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
  10 static int add_submodule_odb(const char *path)
  11 {
  12         struct strbuf objects_directory = STRBUF_INIT;
  13         struct alternate_object_database *alt_odb;
  14         int ret = 0;
  15         const char *git_dir;
  16
  17         strbuf_addf(&objects_directory, "%s/.git", path);
  18         git_dir = read_gitfile_gently(objects_directory.buf);
  19         if (git_dir) {
  20                 strbuf_reset(&objects_directory);
  21                 strbuf_addstr(&objects_directory, git_dir);
  22         }
  23         strbuf_addstr(&objects_directory, "/objects/");
  24         if (!is_directory(objects_directory.buf)) {
  25                 ret = -1;
  26                 goto done;
  27         }
  28         /* avoid adding it twice */
  29         for (alt_odb = alt_odb_list; alt_odb; alt_odb = alt_odb->next)
  30                 if (alt_odb->name - alt_odb->base == objects_directory.len &&
  31                                 !strncmp(alt_odb->base, objects_directory.buf,
  32                                         objects_directory.len))
  33                         goto done;
  34
  35         alt_odb = xmalloc(objects_directory.len + 42 + sizeof(*alt_odb));
  36         alt_odb->next = alt_odb_list;
  37         strcpy(alt_odb->base, objects_directory.buf);
  38         alt_odb->name = alt_odb->base + objects_directory.len;
  39         alt_odb->name[2] = '/';
  40         alt_odb->name[40] = '\0';
  41         alt_odb->name[41] = '\0';
  42         alt_odb_list = alt_odb;
  43         prepare_alt_odb();
  44 done:
  45         strbuf_release(&objects_directory);
  46         return ret;
  47 }
  48
  49 void show_submodule_summary(FILE *f, const char *path,
  50                 unsigned char one[20], unsigned char two[20],
  51                 unsigned dirty_submodule,
  52                 const char *del, const char *add, const char *reset)
  53 {
  54         struct rev_info rev;
  55         struct commit *commit, *left = left, *right = right;
  56         struct commit_list *merge_bases, *list;
  57         const char *message = NULL;
  58         struct strbuf sb = STRBUF_INIT;
  59         static const char *format = "  %m %s";
  60         int fast_forward = 0, fast_backward = 0;
  61
  62         if (is_null_sha1(two))
  63                 message = "(submodule deleted)";
  64         else if (add_submodule_odb(path))
  65                 message = "(not checked out)";
  66         else if (is_null_sha1(one))
  67                 message = "(new submodule)";
  68         else if (!(left = lookup_commit_reference(one)) ||
  69                  !(right = lookup_commit_reference(two)))
  70                 message = "(commits not present)";
  71
  72         if (!message) {
  73                 init_revisions(&rev, NULL);
  74                 setup_revisions(0, NULL, &rev, NULL);
  75                 rev.left_right = 1;
  76                 rev.first_parent_only = 1;
  77                 left->object.flags |= SYMMETRIC_LEFT;
  78                 add_pending_object(&rev, &left->object, path);
  79                 add_pending_object(&rev, &right->object, path);
  80                 merge_bases = get_merge_bases(left, right, 1);
  81                 if (merge_bases) {
  82                         if (merge_bases->item == left)
  83                                 fast_forward = 1;
  84                         else if (merge_bases->item == right)
  85                                 fast_backward = 1;
  86                 }
  87                 for (list = merge_bases; list; list = list->next) {
  88                         list->item->object.flags |= UNINTERESTING;
  89                         add_pending_object(&rev, &list->item->object,
  90                                 sha1_to_hex(list->item->object.sha1));
  91                 }
  92                 if (prepare_revision_walk(&rev))
  93                         message = "(revision walker failed)";
  94         }
  95
  96         if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
  97                 fprintf(f, "Submodule %s contains untracked content\n", path);
  98         if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
  99                 fprintf(f, "Submodule %s contains modified content\n", path);
 100
 101         if (!hashcmp(one, two)) {
 102                 strbuf_release(&sb);
 103                 return;
 104         }
 105
 106         strbuf_addf(&sb, "Submodule %s %s..", path,
 107                         find_unique_abbrev(one, DEFAULT_ABBREV));
 108         if (!fast_backward && !fast_forward)
 109                 strbuf_addch(&sb, '.');
 110         strbuf_addf(&sb, "%s", find_unique_abbrev(two, DEFAULT_ABBREV));
 111         if (message)
 112                 strbuf_addf(&sb, " %s\n", message);
 113         else
 114                 strbuf_addf(&sb, "%s:\n", fast_backward ? " (rewind)" : "");
 115         fwrite(sb.buf, sb.len, 1, f);
 116
 117         if (!message) {
 118                 while ((commit = get_revision(&rev))) {
 119                         struct pretty_print_context ctx = {0};
 120                         ctx.date_mode = rev.date_mode;
 121                         strbuf_setlen(&sb, 0);
 122                         if (commit->object.flags & SYMMETRIC_LEFT) {
 123                                 if (del)
 124                                         strbuf_addstr(&sb, del);
 125                         }
 126                         else if (add)
 127                                 strbuf_addstr(&sb, add);
 128                         format_commit_message(commit, format, &sb, &ctx);
 129                         if (reset)
 130                                 strbuf_addstr(&sb, reset);
 131                         strbuf_addch(&sb, '\n');
 132                         fprintf(f, "%s", sb.buf);
 133                 }
 134                 clear_commit_marks(left, ~0);
 135                 clear_commit_marks(right, ~0);
 136         }
 137         strbuf_release(&sb);
 138 }
 139
 140 unsigned is_submodule_modified(const char *path, int ignore_untracked)
 141 {
 142         ssize_t len;
 143         struct child_process cp;
 144         const char *argv[] = {
 145                 "status",
 146                 "--porcelain",
 147                 NULL,
 148                 NULL,
 149         };
 150         struct strbuf buf = STRBUF_INIT;
 151         unsigned dirty_submodule = 0;
 152         const char *line, *next_line;
 153         const char *git_dir;
 154
 155         strbuf_addf(&buf, "%s/.git", path);
 156         git_dir = read_gitfile_gently(buf.buf);
 157         if (!git_dir)
 158                 git_dir = buf.buf;
 159         if (!is_directory(git_dir)) {
 160                 strbuf_release(&buf);
 161                 /* The submodule is not checked out, so it is not modified */
 162                 return 0;
 163
 164         }
 165         strbuf_reset(&buf);
 166
 167         if (ignore_untracked)
 168                 argv[2] = "-uno";
 169
 170         memset(&cp, 0, sizeof(cp));
 171         cp.argv = argv;
 172         cp.env = local_repo_env;
 173         cp.git_cmd = 1;
 174         cp.no_stdin = 1;
 175         cp.out = -1;
 176         cp.dir = path;
 177         if (start_command(&cp))
 178                 die("Could not run git status --porcelain");
 179
 180         len = strbuf_read(&buf, cp.out, 1024);
 181         line = buf.buf;
 182         while (len > 2) {
 183                 if ((line[0] == '?') && (line[1] == '?')) {
 184                         dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
 185                         if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
 186                                 break;
 187                 } else {
 188                         dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
 189                         if (ignore_untracked ||
 190                             (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))
 191                                 break;
 192                 }
 193                 next_line = strchr(line, '\n');
 194                 if (!next_line)
 195                         break;
 196                 next_line++;
 197                 len -= (next_line - line);
 198                 line = next_line;
 199         }
 200         close(cp.out);
 201
 202         if (finish_command(&cp))
 203                 die("git status --porcelain failed");
 204
 205         strbuf_release(&buf);
 206         return dirty_submodule;
 207 }