submodule.c

   1 #include "cache.h"
   2 #include "submodule.h"
   3 #include "dir.h"
   4 #include "diff.h"
   5 #include "commit.h"
   6 #include "revision.h"
   7 #include "run-command.h"
   8 #include "diffcore.h"
   9 #include "string-list.h"
  10
  11 struct string_list config_ignore;
  12
  13 static int add_submodule_odb(const char *path)
  14 {
  15         struct strbuf objects_directory = STRBUF_INIT;
  16         struct alternate_object_database *alt_odb;
  17         int ret = 0;
  18         const char *git_dir;
  19
  20         strbuf_addf(&objects_directory, "%s/.git", path);
  21         git_dir = read_gitfile_gently(objects_directory.buf);
  22         if (git_dir) {
  23                 strbuf_reset(&objects_directory);
  24                 strbuf_addstr(&objects_directory, git_dir);
  25         }
  26         strbuf_addstr(&objects_directory, "/objects/");
  27         if (!is_directory(objects_directory.buf)) {
  28                 ret = -1;
  29                 goto done;
  30         }
  31         /* avoid adding it twice */
  32         for (alt_odb = alt_odb_list; alt_odb; alt_odb = alt_odb->next)
  33                 if (alt_odb->name - alt_odb->base == objects_directory.len &&
  34                                 !strncmp(alt_odb->base, objects_directory.buf,
  35                                         objects_directory.len))
  36                         goto done;
  37
  38         alt_odb = xmalloc(objects_directory.len + 42 + sizeof(*alt_odb));
  39         alt_odb->next = alt_odb_list;
  40         strcpy(alt_odb->base, objects_directory.buf);
  41         alt_odb->name = alt_odb->base + objects_directory.len;
  42         alt_odb->name[2] = '/';
  43         alt_odb->name[40] = '\0';
  44         alt_odb->name[41] = '\0';
  45         alt_odb_list = alt_odb;
  46         prepare_alt_odb();
  47 done:
  48         strbuf_release(&objects_directory);
  49         return ret;
  50 }
  51
  52 void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
  53                                              const char *path)
  54 {
  55         struct string_list_item *ignore_option;
  56         ignore_option = unsorted_string_list_lookup(&config_ignore, path);
  57         if (ignore_option)
  58                 handle_ignore_submodules_arg(diffopt, ignore_option->util);
  59 }
  60
  61 static int submodule_config(const char *var, const char *value, void *cb)
  62 {
  63         if (!prefixcmp(var, "submodule."))
  64                 return parse_submodule_config_option(var, value);
  65         return 0;
  66 }
  67
  68 void gitmodules_config()
  69 {
  70         const char *work_tree = get_git_work_tree();
  71         if (work_tree) {
  72                 struct strbuf gitmodules_path = STRBUF_INIT;
  73                 strbuf_addstr(&gitmodules_path, work_tree);
  74                 strbuf_addstr(&gitmodules_path, "/.gitmodules");
  75                 git_config_from_file(submodule_config, gitmodules_path.buf, NULL);
  76                 strbuf_release(&gitmodules_path);
  77         }
  78 }
  79
  80 int parse_submodule_config_option(const char *var, const char *value)
  81 {
  82         int len;
  83         struct string_list_item *ignore_option;
  84         struct strbuf path = STRBUF_INIT;
  85
  86         var += 10;              /* Skip "submodule." */
  87
  88         len = strlen(var);
  89         if ((len > 7) && !strcmp(var + len - 7, ".ignore")) {
  90                 if (strcmp(value, "untracked") && strcmp(value, "dirty") &&
  91                     strcmp(value, "all") && strcmp(value, "none")) {
  92                         warning("Invalid parameter \"%s\" for config option \"submodule.%s.ignore\"", value, var);
  93                         return 0;
  94                 }
  95
  96                 strbuf_add(&path, var, len - 7);
  97                 ignore_option = unsorted_string_list_lookup(&config_ignore, path.buf);
  98                 if (ignore_option)
  99                         free(ignore_option->util);
 100                 else
 101                         ignore_option = string_list_append(&config_ignore,
 102                                          strbuf_detach(&path, NULL));
 103                 strbuf_release(&path);
 104                 ignore_option->util = xstrdup(value);
 105                 return 0;
 106         }
 107         return 0;
 108 }
 109
 110 void handle_ignore_submodules_arg(struct diff_options *diffopt,
 111                                   const char *arg)
 112 {
 113         if (!strcmp(arg, "all"))
 114                 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
 115         else if (!strcmp(arg, "untracked"))
 116                 DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
 117         else if (!strcmp(arg, "dirty"))
 118                 DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
 119         else if (strcmp(arg, "none"))
 120                 die("bad --ignore-submodules argument: %s", arg);
 121 }
 122
 123 void show_submodule_summary(FILE *f, const char *path,
 124                 unsigned char one[20], unsigned char two[20],
 125                 unsigned dirty_submodule,
 126                 const char *del, const char *add, const char *reset)
 127 {
 128         struct rev_info rev;
 129         struct commit *commit, *left = left, *right = right;
 130         struct commit_list *merge_bases, *list;
 131         const char *message = NULL;
 132         struct strbuf sb = STRBUF_INIT;
 133         static const char *format = "  %m %s";
 134         int fast_forward = 0, fast_backward = 0;
 135
 136         if (is_null_sha1(two))
 137                 message = "(submodule deleted)";
 138         else if (add_submodule_odb(path))
 139                 message = "(not checked out)";
 140         else if (is_null_sha1(one))
 141                 message = "(new submodule)";
 142         else if (!(left = lookup_commit_reference(one)) ||
 143                  !(right = lookup_commit_reference(two)))
 144                 message = "(commits not present)";
 145
 146         if (!message) {
 147                 init_revisions(&rev, NULL);
 148                 setup_revisions(0, NULL, &rev, NULL);
 149                 rev.left_right = 1;
 150                 rev.first_parent_only = 1;
 151                 left->object.flags |= SYMMETRIC_LEFT;
 152                 add_pending_object(&rev, &left->object, path);
 153                 add_pending_object(&rev, &right->object, path);
 154                 merge_bases = get_merge_bases(left, right, 1);
 155                 if (merge_bases) {
 156                         if (merge_bases->item == left)
 157                                 fast_forward = 1;
 158                         else if (merge_bases->item == right)
 159                                 fast_backward = 1;
 160                 }
 161                 for (list = merge_bases; list; list = list->next) {
 162                         list->item->object.flags |= UNINTERESTING;
 163                         add_pending_object(&rev, &list->item->object,
 164                                 sha1_to_hex(list->item->object.sha1));
 165                 }
 166                 if (prepare_revision_walk(&rev))
 167                         message = "(revision walker failed)";
 168         }
 169
 170         if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
 171                 fprintf(f, "Submodule %s contains untracked content\n", path);
 172         if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
 173                 fprintf(f, "Submodule %s contains modified content\n", path);
 174
 175         if (!hashcmp(one, two)) {
 176                 strbuf_release(&sb);
 177                 return;
 178         }
 179
 180         strbuf_addf(&sb, "Submodule %s %s..", path,
 181                         find_unique_abbrev(one, DEFAULT_ABBREV));
 182         if (!fast_backward && !fast_forward)
 183                 strbuf_addch(&sb, '.');
 184         strbuf_addf(&sb, "%s", find_unique_abbrev(two, DEFAULT_ABBREV));
 185         if (message)
 186                 strbuf_addf(&sb, " %s\n", message);
 187         else
 188                 strbuf_addf(&sb, "%s:\n", fast_backward ? " (rewind)" : "");
 189         fwrite(sb.buf, sb.len, 1, f);
 190
 191         if (!message) {
 192                 while ((commit = get_revision(&rev))) {
 193                         struct pretty_print_context ctx = {0};
 194                         ctx.date_mode = rev.date_mode;
 195                         strbuf_setlen(&sb, 0);
 196                         if (commit->object.flags & SYMMETRIC_LEFT) {
 197                                 if (del)
 198                                         strbuf_addstr(&sb, del);
 199                         }
 200                         else if (add)
 201                                 strbuf_addstr(&sb, add);
 202                         format_commit_message(commit, format, &sb, &ctx);
 203                         if (reset)
 204                                 strbuf_addstr(&sb, reset);
 205                         strbuf_addch(&sb, '\n');
 206                         fprintf(f, "%s", sb.buf);
 207                 }
 208                 clear_commit_marks(left, ~0);
 209                 clear_commit_marks(right, ~0);
 210         }
 211         strbuf_release(&sb);
 212 }
 213
 214 unsigned is_submodule_modified(const char *path, int ignore_untracked)
 215 {
 216         ssize_t len;
 217         struct child_process cp;
 218         const char *argv[] = {
 219                 "status",
 220                 "--porcelain",
 221                 NULL,
 222                 NULL,
 223         };
 224         struct strbuf buf = STRBUF_INIT;
 225         unsigned dirty_submodule = 0;
 226         const char *line, *next_line;
 227         const char *git_dir;
 228
 229         strbuf_addf(&buf, "%s/.git", path);
 230         git_dir = read_gitfile_gently(buf.buf);
 231         if (!git_dir)
 232                 git_dir = buf.buf;
 233         if (!is_directory(git_dir)) {
 234                 strbuf_release(&buf);
 235                 /* The submodule is not checked out, so it is not modified */
 236                 return 0;
 237
 238         }
 239         strbuf_reset(&buf);
 240
 241         if (ignore_untracked)
 242                 argv[2] = "-uno";
 243
 244         memset(&cp, 0, sizeof(cp));
 245         cp.argv = argv;
 246         cp.env = local_repo_env;
 247         cp.git_cmd = 1;
 248         cp.no_stdin = 1;
 249         cp.out = -1;
 250         cp.dir = path;
 251         if (start_command(&cp))
 252                 die("Could not run git status --porcelain");
 253
 254         len = strbuf_read(&buf, cp.out, 1024);
 255         line = buf.buf;
 256         while (len > 2) {
 257                 if ((line[0] == '?') && (line[1] == '?')) {
 258                         dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
 259                         if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
 260                                 break;
 261                 } else {
 262                         dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
 263                         if (ignore_untracked ||
 264                             (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))
 265                                 break;
 266                 }
 267                 next_line = strchr(line, '\n');
 268                 if (!next_line)
 269                         break;
 270                 next_line++;
 271                 len -= (next_line - line);
 272                 line = next_line;
 273         }
 274         close(cp.out);
 275
 276         if (finish_command(&cp))
 277                 die("git status --porcelain failed");
 278
 279         strbuf_release(&buf);
 280         return dirty_submodule;
 281 }