Merge branch 'ds/commit-graph-merging-fix'
[git] / builtin / diff-tree.c
1 #define USE_THE_INDEX_COMPATIBILITY_MACROS
2 #include "cache.h"
3 #include "config.h"
4 #include "diff.h"
5 #include "commit.h"
6 #include "log-tree.h"
7 #include "builtin.h"
8 #include "submodule.h"
9 #include "repository.h"
10
11 static struct rev_info log_tree_opt;
12
13 static int diff_tree_commit_oid(const struct object_id *oid)
14 {
15         struct commit *commit = lookup_commit_reference(the_repository, oid);
16         if (!commit)
17                 return -1;
18         return log_tree_commit(&log_tree_opt, commit);
19 }
20
21 /* Diff one or more commits. */
22 static int stdin_diff_commit(struct commit *commit, const char *p)
23 {
24         struct object_id oid;
25         struct commit_list **pptr = NULL;
26
27         /* Graft the fake parents locally to the commit */
28         while (isspace(*p++) && !parse_oid_hex(p, &oid, &p)) {
29                 struct commit *parent = lookup_commit(the_repository, &oid);
30                 if (!pptr) {
31                         /* Free the real parent list */
32                         free_commit_list(commit->parents);
33                         commit->parents = NULL;
34                         pptr = &(commit->parents);
35                 }
36                 if (parent) {
37                         pptr = &commit_list_insert(parent, pptr)->next;
38                 }
39         }
40         return log_tree_commit(&log_tree_opt, commit);
41 }
42
43 /* Diff two trees. */
44 static int stdin_diff_trees(struct tree *tree1, const char *p)
45 {
46         struct object_id oid;
47         struct tree *tree2;
48         if (!isspace(*p++) || parse_oid_hex(p, &oid, &p) || *p)
49                 return error("Need exactly two trees, separated by a space");
50         tree2 = lookup_tree(the_repository, &oid);
51         if (!tree2 || parse_tree(tree2))
52                 return -1;
53         printf("%s %s\n", oid_to_hex(&tree1->object.oid),
54                           oid_to_hex(&tree2->object.oid));
55         diff_tree_oid(&tree1->object.oid, &tree2->object.oid,
56                       "", &log_tree_opt.diffopt);
57         log_tree_diff_flush(&log_tree_opt);
58         return 0;
59 }
60
61 static int diff_tree_stdin(char *line)
62 {
63         int len = strlen(line);
64         struct object_id oid;
65         struct object *obj;
66         const char *p;
67
68         if (!len || line[len-1] != '\n')
69                 return -1;
70         line[len-1] = 0;
71         if (parse_oid_hex(line, &oid, &p))
72                 return -1;
73         obj = parse_object(the_repository, &oid);
74         if (!obj)
75                 return -1;
76         if (obj->type == OBJ_COMMIT)
77                 return stdin_diff_commit((struct commit *)obj, p);
78         if (obj->type == OBJ_TREE)
79                 return stdin_diff_trees((struct tree *)obj, p);
80         error("Object %s is a %s, not a commit or tree",
81               oid_to_hex(&oid), type_name(obj->type));
82         return -1;
83 }
84
85 static const char diff_tree_usage[] =
86 "git diff-tree [--stdin] [-m] [-c | --cc] [-s] [-v] [--pretty] [-t] [-r] [--root] "
87 "[<common-diff-options>] <tree-ish> [<tree-ish>] [<path>...]\n"
88 "  -r            diff recursively\n"
89 "  -c            show combined diff for merge commits\n"
90 "  --cc          show combined diff for merge commits removing uninteresting hunks\n"
91 "  --combined-all-paths\n"
92 "                show name of file in all parents for combined diffs\n"
93 "  --root        include the initial commit as diff against /dev/null\n"
94 COMMON_DIFF_OPTIONS_HELP;
95
96 static void diff_tree_tweak_rev(struct rev_info *rev, struct setup_revision_opt *opt)
97 {
98         if (!rev->diffopt.output_format) {
99                 if (rev->dense_combined_merges)
100                         rev->diffopt.output_format = DIFF_FORMAT_PATCH;
101                 else
102                         rev->diffopt.output_format = DIFF_FORMAT_RAW;
103         }
104 }
105
106 int cmd_diff_tree(int argc, const char **argv, const char *prefix)
107 {
108         char line[1000];
109         struct object *tree1, *tree2;
110         static struct rev_info *opt = &log_tree_opt;
111         struct setup_revision_opt s_r_opt;
112         struct userformat_want w;
113         int read_stdin = 0;
114
115         if (argc == 2 && !strcmp(argv[1], "-h"))
116                 usage(diff_tree_usage);
117
118         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
119         repo_init_revisions(the_repository, opt, prefix);
120         if (read_cache() < 0)
121                 die(_("index file corrupt"));
122         opt->abbrev = 0;
123         opt->diff = 1;
124         opt->disable_stdin = 1;
125         memset(&s_r_opt, 0, sizeof(s_r_opt));
126         s_r_opt.tweak = diff_tree_tweak_rev;
127
128         precompose_argv(argc, argv);
129         argc = setup_revisions(argc, argv, opt, &s_r_opt);
130
131         memset(&w, 0, sizeof(w));
132         userformat_find_requirements(NULL, &w);
133
134         if (!opt->show_notes_given && w.notes)
135                 opt->show_notes = 1;
136         if (opt->show_notes)
137                 load_display_notes(&opt->notes_opt);
138
139         while (--argc > 0) {
140                 const char *arg = *++argv;
141
142                 if (!strcmp(arg, "--stdin")) {
143                         read_stdin = 1;
144                         continue;
145                 }
146                 usage(diff_tree_usage);
147         }
148
149         /*
150          * NOTE!  We expect "a..b" to expand to "^a b" but it is
151          * perfectly valid for revision range parser to yield "b ^a",
152          * which means the same thing. If we get the latter, i.e. the
153          * second one is marked UNINTERESTING, we recover the original
154          * order the user gave, i.e. "a..b", by swapping the trees.
155          */
156         switch (opt->pending.nr) {
157         case 0:
158                 if (!read_stdin)
159                         usage(diff_tree_usage);
160                 break;
161         case 1:
162                 tree1 = opt->pending.objects[0].item;
163                 diff_tree_commit_oid(&tree1->oid);
164                 break;
165         case 2:
166                 tree1 = opt->pending.objects[0].item;
167                 tree2 = opt->pending.objects[1].item;
168                 if (tree2->flags & UNINTERESTING) {
169                         SWAP(tree2, tree1);
170                 }
171                 diff_tree_oid(&tree1->oid, &tree2->oid, "", &opt->diffopt);
172                 log_tree_diff_flush(opt);
173                 break;
174         }
175
176         if (read_stdin) {
177                 int saved_nrl = 0;
178                 int saved_dcctc = 0;
179
180                 if (opt->diffopt.detect_rename) {
181                         if (!the_index.cache)
182                                 repo_read_index(the_repository);
183                         opt->diffopt.setup |= DIFF_SETUP_USE_SIZE_CACHE;
184                 }
185                 while (fgets(line, sizeof(line), stdin)) {
186                         struct object_id oid;
187
188                         if (get_oid_hex(line, &oid)) {
189                                 fputs(line, stdout);
190                                 fflush(stdout);
191                         }
192                         else {
193                                 diff_tree_stdin(line);
194                                 if (saved_nrl < opt->diffopt.needed_rename_limit)
195                                         saved_nrl = opt->diffopt.needed_rename_limit;
196                                 if (opt->diffopt.degraded_cc_to_c)
197                                         saved_dcctc = 1;
198                         }
199                 }
200                 opt->diffopt.degraded_cc_to_c = saved_dcctc;
201                 opt->diffopt.needed_rename_limit = saved_nrl;
202         }
203
204         return diff_result_code(&opt->diffopt, 0);
205 }