libgiggle/giggle-git-ignore.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007 Imendio AB
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22 #include <string.h>
  23 #include <glib.h>
  24 #include <fnmatch.h>
  25
  26 #include "giggle-git-ignore.h"
  27 #include "giggle-git.h"
  28
  29 typedef struct GiggleGitIgnorePriv GiggleGitIgnorePriv;
  30
  31 struct GiggleGitIgnorePriv {
  32         GiggleGit *git;
  33         gchar     *directory_path;
  34         gchar     *relative_path;
  35
  36         GPtrArray *globs;
  37         GPtrArray *global_globs; /* .git/info/exclude */
  38 };
  39
  40 static void       git_ignore_finalize           (GObject               *object);
  41 static void       git_ignore_get_property       (GObject               *object,
  42                                                  guint                  param_id,
  43                                                  GValue                *value,
  44                                                  GParamSpec            *pspec);
  45 static void       git_ignore_set_property       (GObject               *object,
  46                                                  guint                  param_id,
  47                                                  const GValue          *value,
  48                                                  GParamSpec            *pspec);
  49 static GObject*   git_ignore_constructor        (GType                  type,
  50                                                  guint                  n_construct_properties,
  51                                                  GObjectConstructParam *construct_params);
  52
  53
  54 G_DEFINE_TYPE (GiggleGitIgnore, giggle_git_ignore, G_TYPE_OBJECT);
  55
  56 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIGGLE_TYPE_GIT_IGNORE, GiggleGitIgnorePriv))
  57
  58 enum {
  59         PROP_0,
  60         PROP_DIRECTORY,
  61 };
  62
  63 static void
  64 giggle_git_ignore_class_init (GiggleGitIgnoreClass *class)
  65 {
  66         GObjectClass *object_class = G_OBJECT_CLASS (class);
  67
  68         object_class->finalize = git_ignore_finalize;
  69         object_class->get_property = git_ignore_get_property;
  70         object_class->set_property = git_ignore_set_property;
  71         object_class->constructor = git_ignore_constructor;
  72
  73         g_object_class_install_property (object_class,
  74                                          PROP_DIRECTORY,
  75                                          g_param_spec_string ("directory",
  76                                                               "Directory",
  77                                                               "Path to the Directory containing the .gitignore file",
  78                                                               NULL,
  79                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
  80
  81         g_type_class_add_private (object_class, sizeof (GiggleGitIgnorePriv));
  82 }
  83
  84 static void
  85 giggle_git_ignore_init (GiggleGitIgnore *git_ignore)
  86 {
  87         GiggleGitIgnorePriv *priv;
  88
  89         priv = GET_PRIV (git_ignore);
  90
  91         priv->git = giggle_git_get ();
  92 }
  93
  94 static void
  95 git_ignore_finalize (GObject *object)
  96 {
  97         GiggleGitIgnorePriv *priv;
  98
  99         priv = GET_PRIV (object);
 100
 101         g_object_unref (priv->git);
 102         g_free (priv->directory_path);
 103         g_free (priv->relative_path);
 104
 105         if (priv->globs) {
 106                 g_ptr_array_foreach (priv->globs, (GFunc) g_free, NULL);
 107                 g_ptr_array_free (priv->globs, TRUE);
 108         }
 109
 110         if (priv->global_globs) {
 111                 g_ptr_array_foreach (priv->global_globs, (GFunc) g_free, NULL);
 112                 g_ptr_array_free (priv->global_globs, TRUE);
 113         }
 114
 115         G_OBJECT_CLASS (giggle_git_ignore_parent_class)->finalize (object);
 116 }
 117
 118 static void
 119 git_ignore_get_property (GObject    *object,
 120                          guint       param_id,
 121                          GValue     *value,
 122                          GParamSpec *pspec)
 123 {
 124         GiggleGitIgnorePriv *priv;
 125
 126         priv = GET_PRIV (object);
 127
 128         switch (param_id) {
 129         case PROP_DIRECTORY:
 130                 g_value_set_string (value, priv->directory_path);
 131                 break;
 132         default:
 133                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 134                 break;
 135         }
 136 }
 137
 138 static void
 139 git_ignore_set_property (GObject      *object,
 140                          guint         param_id,
 141                          const GValue *value,
 142                          GParamSpec   *pspec)
 143 {
 144         GiggleGitIgnorePriv *priv;
 145
 146         priv = GET_PRIV (object);
 147
 148         switch (param_id) {
 149         case PROP_DIRECTORY:
 150                 priv->directory_path = g_value_dup_string (value);
 151                 break;
 152         default:
 153                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 154                 break;
 155         }
 156 }
 157
 158 static GPtrArray *
 159 git_ignore_read_file (const gchar *path)
 160 {
 161         GPtrArray  *array;
 162         gchar     **strarr;
 163         gchar      *contents;
 164         gint        i;
 165
 166         if (!g_file_get_contents (path, &contents, NULL, NULL)) {
 167                 return g_ptr_array_new ();
 168         }
 169
 170         array = g_ptr_array_sized_new (10);
 171         strarr = g_strsplit (contents, "\n", -1);
 172
 173         for (i = 0; strarr[i]; i++) {
 174                 if (*strarr[i] && !g_str_has_prefix (strarr[i], "#")) {
 175                         g_ptr_array_add (array, g_strdup (strarr[i]));
 176                 }
 177         }
 178
 179         g_free (contents);
 180         g_strfreev (strarr);
 181
 182         return array;
 183 }
 184
 185 static GObject*
 186 git_ignore_constructor (GType                  type,
 187                         guint                  n_construct_properties,
 188                         GObjectConstructParam *construct_params)
 189 {
 190         GObject             *object;
 191         GiggleGitIgnorePriv *priv;
 192         gchar               *path;
 193         const gchar         *project_path;
 194
 195         object = (* G_OBJECT_CLASS (giggle_git_ignore_parent_class)->constructor) (type,
 196                                                                                    n_construct_properties,
 197                                                                                    construct_params);
 198         priv = GET_PRIV (object);
 199
 200         path = g_build_filename (priv->directory_path, ".gitignore", NULL);
 201         priv->globs = git_ignore_read_file (path);
 202         g_free (path);
 203
 204         path = g_build_filename (giggle_git_get_git_dir (priv->git),
 205                                  "info", "exclude", NULL);
 206         priv->global_globs = git_ignore_read_file (path);
 207         g_free (path);
 208
 209         project_path = giggle_git_get_directory (priv->git);
 210
 211         if (strcmp (priv->directory_path, project_path) != 0) {
 212                 priv->relative_path = g_strdup (priv->directory_path
 213                                                 + strlen (giggle_git_get_directory (priv->git))
 214                                                 + 1 /* dir separator */);
 215         }
 216
 217         return object;
 218 }
 219
 220 static void
 221 git_ignore_save_file (GiggleGitIgnore *git_ignore)
 222 {
 223         GiggleGitIgnorePriv *priv;
 224         gchar               *path;
 225         GString             *content;
 226         gint                 i;
 227
 228         priv = GET_PRIV (git_ignore);
 229         path = g_build_filename (priv->directory_path, ".gitignore", NULL);
 230         content = g_string_new ("");
 231
 232         for (i = 0; i < priv->globs->len; i++) {
 233                 g_string_append_printf (content, "%s\n", (gchar *) g_ptr_array_index (priv->globs, i));
 234         }
 235
 236         g_file_set_contents (path, content->str, -1, NULL);
 237         g_string_free (content, TRUE);
 238 }
 239
 240 GiggleGitIgnore *
 241 giggle_git_ignore_new (const gchar *directory_path)
 242 {
 243         g_return_val_if_fail (directory_path != NULL, NULL);
 244
 245         return g_object_new (GIGGLE_TYPE_GIT_IGNORE,
 246                              "directory", directory_path,
 247                              NULL);
 248 }
 249
 250 static const gchar *
 251 git_ignore_get_basename (const gchar *path)
 252 {
 253         const gchar *basename;
 254
 255         basename = strrchr (path, G_DIR_SEPARATOR);
 256
 257         if (!basename) {
 258                 basename = path;
 259         } else {
 260                 /* avoid dir separator */
 261                 basename++;
 262         }
 263
 264         return basename;
 265 }
 266
 267 static gboolean
 268 git_ignore_path_matches_glob (const gchar *path,
 269                               const gchar *glob,
 270                               const gchar *relative_path)
 271 {
 272         const gchar *filename;
 273         gchar       *str = NULL;
 274         gboolean     match;
 275
 276         /* Match examples:
 277          *      Glob    String
 278          *      ====    ======
 279          *      aaa     aaa     = match
 280          *      /aaa    aaa     = match
 281          *      aaa     b/aaa   = match
 282          *      b/aaa   b/aaa   = match
 283          *      /b/aaa  b/aaa   = match
 284          *
 285          *      aaa     b/aaa/c = NO match
 286          *      /aaa    b/aaa   = NO match
 287          *      b/aaa   aaa     = NO match
 288          *      b/aaa   c/b/aaa = NO match
 289          *      /b/aaa  c/b/aaa = NO match
 290          */
 291
 292         if (strchr (glob, G_DIR_SEPARATOR)) {
 293                 /* contains a dir separator, git wants these
 294                  * entries to match completely occurrences
 295                  * from the current dir.
 296                  */
 297
 298                 if (relative_path) {
 299                         str = g_build_filename (relative_path, glob, NULL);
 300                         glob = str;
 301                 }
 302
 303                 if (glob[0] == G_DIR_SEPARATOR) {
 304                         glob++;
 305                 }
 306
 307                 match = (fnmatch (glob, path, FNM_PATHNAME) == 0);
 308                 g_free (str);
 309         } else {
 310                 /* doesn't contain any dir separator, git will
 311                  * match these entries with any filename in any
 312                  * subdir
 313                  */
 314                 filename = git_ignore_get_basename (path);
 315                 match = (fnmatch (glob, filename, FNM_PATHNAME) == 0);
 316         }
 317
 318         return match;
 319 }
 320
 321 static gboolean
 322 git_ignore_path_matches (const gchar *path,
 323                          GPtrArray   *array,
 324                          const gchar *relative_path)
 325 {
 326         gboolean     match = FALSE;
 327         gint         n_glob = 0;
 328         const gchar *glob;
 329
 330         if (!array) {
 331                 return FALSE;
 332         }
 333
 334         while (!match && n_glob < array->len) {
 335                 glob = g_ptr_array_index (array, n_glob);
 336                 n_glob++;
 337
 338                 match = git_ignore_path_matches_glob (path, glob, relative_path);
 339         }
 340
 341         return match;
 342 }
 343
 344 gboolean
 345 giggle_git_ignore_path_matches (GiggleGitIgnore *git_ignore,
 346                                 const gchar     *path)
 347 {
 348         GiggleGitIgnorePriv *priv;
 349
 350         g_return_val_if_fail (GIGGLE_IS_GIT_IGNORE (git_ignore), FALSE);
 351
 352         priv = GET_PRIV (git_ignore);
 353
 354         if (git_ignore_path_matches (path, priv->globs, priv->relative_path)) {
 355                 return TRUE;
 356         }
 357
 358         if (git_ignore_path_matches (path, priv->global_globs, NULL)) {
 359                 return TRUE;
 360         }
 361
 362         return FALSE;
 363 }
 364
 365 void
 366 giggle_git_ignore_add_glob (GiggleGitIgnore *git_ignore,
 367                             const gchar     *glob)
 368 {
 369         GiggleGitIgnorePriv *priv;
 370
 371         g_return_if_fail (GIGGLE_IS_GIT_IGNORE (git_ignore));
 372         g_return_if_fail (glob != NULL);
 373
 374         priv = GET_PRIV (git_ignore);
 375         g_ptr_array_add (priv->globs, g_strdup (glob));
 376
 377         git_ignore_save_file (git_ignore);
 378 }
 379
 380 void
 381 giggle_git_ignore_add_glob_for_path (GiggleGitIgnore *git_ignore,
 382                                      const gchar     *path)
 383 {
 384         GiggleGitIgnorePriv *priv;
 385         const gchar         *glob;
 386
 387         g_return_if_fail (GIGGLE_IS_GIT_IGNORE (git_ignore));
 388         g_return_if_fail (path != NULL);
 389
 390         priv = GET_PRIV (git_ignore);
 391
 392         /* FIXME: we add here just the filename, which will
 393          * also ignore matching filenames for subdirectories,
 394          * do we want it more fine grained?
 395          */
 396         glob = git_ignore_get_basename (path);
 397         giggle_git_ignore_add_glob (git_ignore, glob);
 398 }
 399
 400 gboolean
 401 giggle_git_ignore_remove_glob_for_path (GiggleGitIgnore *git_ignore,
 402                                         const gchar     *path,
 403                                         gboolean         perfect_match)
 404 {
 405         GiggleGitIgnorePriv *priv;
 406         const gchar         *glob;
 407         gint                 i = 0;
 408         gboolean             removed = FALSE;
 409         const gchar         *filename;
 410
 411         g_return_val_if_fail (GIGGLE_IS_GIT_IGNORE (git_ignore), FALSE);
 412         g_return_val_if_fail (path != NULL, FALSE);
 413
 414         priv = GET_PRIV (git_ignore);
 415
 416         while (i < priv->globs->len) {
 417                 glob = g_ptr_array_index (priv->globs, i);
 418                 filename = git_ignore_get_basename (path);
 419
 420                 if ((perfect_match && strcmp (glob, filename) == 0) ||
 421                     (!perfect_match &&
 422                      git_ignore_path_matches_glob (path, glob, priv->relative_path))) {
 423                         g_ptr_array_remove_index (priv->globs, i);
 424                         removed = TRUE;
 425                 } else {
 426                         /* no match, increment index */
 427                         i++;
 428                 }
 429         }
 430
 431         if (removed) {
 432                 git_ignore_save_file (git_ignore);
 433         }
 434
 435         return removed;
 436 }