freshlybakedca.ke
Git fork
1#include "git-compat-util.h"
2#include "bloom.h"
3#include "builtin.h"
4#include "commit-graph.h"
5#include "commit.h"
6#include "config.h"
7#include "environment.h"
8#include "diff.h"
9#include "diffcore.h"
10#include "environment.h"
11#include "hashmap.h"
12#include "hex.h"
13#include "log-tree.h"
14#include "object-name.h"
15#include "object.h"
16#include "parse-options.h"
17#include "quote.h"
18#include "repository.h"
19#include "revision.h"
20
21struct last_modified_entry {
22 struct hashmap_entry hashent;
23 struct object_id oid;
24 struct bloom_key key;
25 const char path[FLEX_ARRAY];
26};
27
28static int last_modified_entry_hashcmp(const void *unused UNUSED,
29 const struct hashmap_entry *hent1,
30 const struct hashmap_entry *hent2,
31 const void *path)
32{
33 const struct last_modified_entry *ent1 =
34 container_of(hent1, const struct last_modified_entry, hashent);
35 const struct last_modified_entry *ent2 =
36 container_of(hent2, const struct last_modified_entry, hashent);
37 return strcmp(ent1->path, path ? path : ent2->path);
38}
39
40struct last_modified {
41 struct hashmap paths;
42 struct rev_info rev;
43 bool recursive;
44 bool show_trees;
45};
46
47static void last_modified_release(struct last_modified *lm)
48{
49 struct hashmap_iter iter;
50 struct last_modified_entry *ent;
51
52 hashmap_for_each_entry(&lm->paths, &iter, ent, hashent)
53 bloom_key_clear(&ent->key);
54
55 hashmap_clear_and_free(&lm->paths, struct last_modified_entry, hashent);
56 release_revisions(&lm->rev);
57}
58
59struct last_modified_callback_data {
60 struct last_modified *lm;
61 struct commit *commit;
62};
63
64static void add_path_from_diff(struct diff_queue_struct *q,
65 struct diff_options *opt UNUSED, void *data)
66{
67 struct last_modified *lm = data;
68
69 for (int i = 0; i < q->nr; i++) {
70 struct diff_filepair *p = q->queue[i];
71 struct last_modified_entry *ent;
72 const char *path = p->two->path;
73
74 FLEX_ALLOC_STR(ent, path, path);
75 oidcpy(&ent->oid, &p->two->oid);
76 if (lm->rev.bloom_filter_settings)
77 bloom_key_fill(&ent->key, path, strlen(path),
78 lm->rev.bloom_filter_settings);
79 hashmap_entry_init(&ent->hashent, strhash(ent->path));
80 hashmap_add(&lm->paths, &ent->hashent);
81 }
82}
83
84static int populate_paths_from_revs(struct last_modified *lm)
85{
86 int num_interesting = 0;
87 struct diff_options diffopt;
88
89 /*
90 * Create a copy of `struct diff_options`. In this copy a callback is
91 * set that when called adds entries to `paths` in `struct last_modified`.
92 * This copy is used to diff the tree of the target revision against an
93 * empty tree. This results in all paths in the target revision being
94 * listed. After `paths` is populated, we don't need this copy no more.
95 */
96 memcpy(&diffopt, &lm->rev.diffopt, sizeof(diffopt));
97 copy_pathspec(&diffopt.pathspec, &lm->rev.diffopt.pathspec);
98 diffopt.output_format = DIFF_FORMAT_CALLBACK;
99 diffopt.format_callback = add_path_from_diff;
100 diffopt.format_callback_data = lm;
101
102 for (size_t i = 0; i < lm->rev.pending.nr; i++) {
103 struct object_array_entry *obj = lm->rev.pending.objects + i;
104
105 if (obj->item->flags & UNINTERESTING)
106 continue;
107
108 if (num_interesting++)
109 return error(_("last-modified can only operate on one tree at a time"));
110
111 diff_tree_oid(lm->rev.repo->hash_algo->empty_tree,
112 &obj->item->oid, "", &diffopt);
113 diff_flush(&diffopt);
114 }
115 clear_pathspec(&diffopt.pathspec);
116
117 return 0;
118}
119
120static void last_modified_emit(struct last_modified *lm,
121 const char *path, const struct commit *commit)
122
123{
124 if (commit->object.flags & BOUNDARY)
125 putchar('^');
126 printf("%s\t", oid_to_hex(&commit->object.oid));
127
128 if (lm->rev.diffopt.line_termination)
129 write_name_quoted(path, stdout, '\n');
130 else
131 printf("%s%c", path, '\0');
132}
133
134static void mark_path(const char *path, const struct object_id *oid,
135 struct last_modified_callback_data *data)
136{
137 struct last_modified_entry *ent;
138
139 /* Is it even a path that we are interested in? */
140 ent = hashmap_get_entry_from_hash(&data->lm->paths, strhash(path), path,
141 struct last_modified_entry, hashent);
142 if (!ent)
143 return;
144
145 /*
146 * Is it arriving at a version of interest, or is it from a side branch
147 * which did not contribute to the final state?
148 */
149 if (!oideq(oid, &ent->oid))
150 return;
151
152 last_modified_emit(data->lm, path, data->commit);
153
154 hashmap_remove(&data->lm->paths, &ent->hashent, path);
155 bloom_key_clear(&ent->key);
156 free(ent);
157}
158
159static void last_modified_diff(struct diff_queue_struct *q,
160 struct diff_options *opt UNUSED, void *cbdata)
161{
162 struct last_modified_callback_data *data = cbdata;
163
164 for (int i = 0; i < q->nr; i++) {
165 struct diff_filepair *p = q->queue[i];
166 switch (p->status) {
167 case DIFF_STATUS_DELETED:
168 /*
169 * There's no point in feeding a deletion, as it could
170 * not have resulted in our current state, which
171 * actually has the file.
172 */
173 break;
174
175 default:
176 /*
177 * Otherwise, we care only that we somehow arrived at
178 * a final oid state. Note that this covers some
179 * potentially controversial areas, including:
180 *
181 * 1. A rename or copy will be found, as it is the
182 * first time the content has arrived at the given
183 * path.
184 *
185 * 2. Even a non-content modification like a mode or
186 * type change will trigger it.
187 *
188 * We take the inclusive approach for now, and find
189 * anything which impacts the path. Options to tweak
190 * the behavior (e.g., to "--follow" the content across
191 * renames) can come later.
192 */
193 mark_path(p->two->path, &p->two->oid, data);
194 break;
195 }
196 }
197}
198
199static bool maybe_changed_path(struct last_modified *lm, struct commit *origin)
200{
201 struct bloom_filter *filter;
202 struct last_modified_entry *ent;
203 struct hashmap_iter iter;
204
205 if (!lm->rev.bloom_filter_settings)
206 return true;
207
208 if (commit_graph_generation(origin) == GENERATION_NUMBER_INFINITY)
209 return true;
210
211 filter = get_bloom_filter(lm->rev.repo, origin);
212 if (!filter)
213 return true;
214
215 hashmap_for_each_entry(&lm->paths, &iter, ent, hashent) {
216 if (bloom_filter_contains(filter, &ent->key,
217 lm->rev.bloom_filter_settings))
218 return true;
219 }
220 return false;
221}
222
223static int last_modified_run(struct last_modified *lm)
224{
225 struct last_modified_callback_data data = { .lm = lm };
226
227 lm->rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
228 lm->rev.diffopt.format_callback = last_modified_diff;
229 lm->rev.diffopt.format_callback_data = &data;
230
231 prepare_revision_walk(&lm->rev);
232
233 while (hashmap_get_size(&lm->paths)) {
234 data.commit = get_revision(&lm->rev);
235 if (!data.commit)
236 BUG("paths remaining beyond boundary in last-modified");
237
238 if (data.commit->object.flags & BOUNDARY) {
239 diff_tree_oid(lm->rev.repo->hash_algo->empty_tree,
240 &data.commit->object.oid, "",
241 &lm->rev.diffopt);
242 diff_flush(&lm->rev.diffopt);
243
244 break;
245 }
246
247 if (!maybe_changed_path(lm, data.commit))
248 continue;
249
250 log_tree_commit(&lm->rev, data.commit);
251 }
252
253 return 0;
254}
255
256static int last_modified_init(struct last_modified *lm, struct repository *r,
257 const char *prefix, int argc, const char **argv)
258{
259 hashmap_init(&lm->paths, last_modified_entry_hashcmp, NULL, 0);
260
261 repo_init_revisions(r, &lm->rev, prefix);
262 lm->rev.def = "HEAD";
263 lm->rev.combine_merges = 1;
264 lm->rev.show_root_diff = 1;
265 lm->rev.boundary = 1;
266 lm->rev.no_commit_id = 1;
267 lm->rev.diff = 1;
268 lm->rev.diffopt.flags.no_recursive_diff_tree_combined = 1;
269 lm->rev.diffopt.flags.recursive = lm->recursive;
270 lm->rev.diffopt.flags.tree_in_recursive = lm->show_trees;
271
272 argc = setup_revisions(argc, argv, &lm->rev, NULL);
273 if (argc > 1) {
274 error(_("unknown last-modified argument: %s"), argv[1]);
275 return argc;
276 }
277
278 lm->rev.bloom_filter_settings = get_bloom_filter_settings(lm->rev.repo);
279
280 if (populate_paths_from_revs(lm) < 0)
281 return error(_("unable to setup last-modified"));
282
283 return 0;
284}
285
286int cmd_last_modified(int argc, const char **argv, const char *prefix,
287 struct repository *repo)
288{
289 int ret;
290 struct last_modified lm = { 0 };
291
292 const char * const last_modified_usage[] = {
293 N_("git last-modified [--recursive] [--show-trees] "
294 "[<revision-range>] [[--] <path>...]"),
295 NULL
296 };
297
298 struct option last_modified_options[] = {
299 OPT_BOOL('r', "recursive", &lm.recursive,
300 N_("recurse into subtrees")),
301 OPT_BOOL('t', "show-trees", &lm.show_trees,
302 N_("show tree entries when recursing into subtrees")),
303 OPT_END()
304 };
305
306 argc = parse_options(argc, argv, prefix, last_modified_options,
307 last_modified_usage,
308 PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN_OPT);
309
310 repo_config(repo, git_default_config, NULL);
311
312 ret = last_modified_init(&lm, repo, prefix, argc, argv);
313 if (ret > 0)
314 usage_with_options(last_modified_usage,
315 last_modified_options);
316 if (ret)
317 goto out;
318
319 ret = last_modified_run(&lm);
320 if (ret)
321 goto out;
322
323out:
324 last_modified_release(&lm);
325
326 return ret;
327}