mirrors/git
0
0
Fork 0
mirror of https://github.com/git/git.git synced 2024-11-27 12:03:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'ab/read-tree'

Browse Source 
Code simplification by removing support for a caller that is long gone.

* ab/read-tree:
  tree.h API: simplify read_tree_recursive() signature
  tree.h API: expose read_tree_1() as read_tree_at()
  archive: stop passing "stage" through read_tree_recursive()
  ls-files: refactor away read_tree()
  ls-files: don't needlessly pass around stage variable
  tree.c API: move read_tree() into builtin/ls-files.c
  ls-files tests: add meaningful --with-tree tests
  show tests: add test for "git show <tree>"
This commit is contained in:
Junio C Hamano 2021-03-30 14:35:37 -07:00
commit ad16f748f2
11 changed files with 205 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
archive.c
View File

@ -104,7 +104,6 @@ struct directory {
struct object_id oid;
int baselen, len;
unsigned mode;
int stage;
char path[FLEX_ARRAY];
};
@ -135,7 +134,7 @@ static int check_attr_export_subst(const struct attr_check *check)
}
static int write_archive_entry(const struct object_id *oid, const char *base,
int baselen, const char *filename, unsigned mode, int stage,
int baselen, const char *filename, unsigned mode,
void *context)
{
static struct strbuf path = STRBUF_INIT;
@ -194,7 +193,7 @@ static int write_archive_entry(const struct object_id *oid, const char *base,
static void queue_directory(const unsigned char *sha1,
struct strbuf *base, const char *filename,
unsigned mode, int stage, struct archiver_context *c)
unsigned mode, struct archiver_context *c)
{
struct directory *d;
size_t len = st_add4(base->len, 1, strlen(filename), 1);
@ -202,7 +201,6 @@ static void queue_directory(const unsigned char *sha1,
d->up = c->bottom;
d->baselen = base->len;
d->mode = mode;
d->stage = stage;
c->bottom = d;
d->len = xsnprintf(d->path, len, "%.*s%s/", (int)base->len, base->buf, filename);
hashcpy(d->oid.hash, sha1);
@ -221,14 +219,14 @@ static int write_directory(struct archiver_context *c)
write_directory(c) ||
write_archive_entry(&d->oid, d->path, d->baselen,
d->path + d->baselen, d->mode,
d->stage, c) != READ_TREE_RECURSIVE;
c) != READ_TREE_RECURSIVE;
free(d);
return ret ? -1 : 0;
}
static int queue_or_write_archive_entry(const struct object_id *oid,
struct strbuf *base, const char *filename,
unsigned mode, int stage, void *context)
unsigned mode, void *context)
{
struct archiver_context *c = context;
@ -253,14 +251,14 @@ static int queue_or_write_archive_entry(const struct object_id *oid,
if (check_attr_export_ignore(check))
return 0;
queue_directory(oid->hash, base, filename,
mode, stage, c);
mode, c);
return READ_TREE_RECURSIVE;
}
if (write_directory(c))
return -1;
return write_archive_entry(oid, base->buf, base->len, filename, mode,
stage, context);
context);
}
struct extra_file_info {
@ -313,10 +311,10 @@ int write_archive_entries(struct archiver_args *args,
git_attr_set_direction(GIT_ATTR_INDEX);
}
err = read_tree_recursive(args->repo, args->tree, "",
0, 0, &args->pathspec,
queue_or_write_archive_entry,
&context);
err = read_tree(args->repo, args->tree,
&args->pathspec,
queue_or_write_archive_entry,
&context);
if (err == READ_TREE_RECURSIVE)
err = 0;
while (context.bottom) {
@ -375,7 +373,7 @@ struct path_exists_context {
static int reject_entry(const struct object_id *oid, struct strbuf *base,
const char *filename, unsigned mode,
int stage, void *context)
void *context)
{
int ret = -1;
struct path_exists_context *ctx = context;
@ -402,9 +400,9 @@ static int path_exists(struct archiver_args *args, const char *path)
ctx.args = args;
parse_pathspec(&ctx.pathspec, 0, 0, "", paths);
ctx.pathspec.recursive = 1;
ret = read_tree_recursive(args->repo, args->tree, "",
0, 0, &ctx.pathspec,
reject_entry, &ctx);
ret = read_tree(args->repo, args->tree,
&ctx.pathspec,
reject_entry, &ctx);
clear_pathspec(&ctx.pathspec);
return ret != 0;
}

8
builtin/checkout.c
View File

@ -114,7 +114,7 @@ static int post_checkout_hook(struct commit *old_commit, struct commit *new_comm
}
static int update_some(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *context)
const char *pathname, unsigned mode, void *context)
{
int len;
struct cache_entry *ce;
@ -155,8 +155,8 @@ static int update_some(const struct object_id *oid, struct strbuf *base,
static int read_tree_some(struct tree *tree, const struct pathspec *pathspec)
{
read_tree_recursive(the_repository, tree, "", 0, 0,
pathspec, update_some, NULL);
read_tree(the_repository, tree,
pathspec, update_some, NULL);
/* update the index with the given tree's info
* for all args, expanding wildcards, and exit
@ -322,7 +322,7 @@ static void mark_ce_for_checkout_overlay(struct cache_entry *ce,
* If it comes from the tree-ish, we already know it
* matches the pathspec and could just stamp
* CE_MATCHED to it from update_some(). But we still
* need ps_matched and read_tree_recursive (and
* need ps_matched and read_tree (and
* eventually tree_entry_interesting) cannot fill
* ps_matched yet. Once it can, we can avoid calling
* match_pathspec() for _all_ entries when

8
builtin/log.c
View File

@ -599,7 +599,7 @@ static int show_tag_object(const struct object_id *oid, struct rev_info *rev)
static int show_tree_object(const struct object_id *oid,
struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *context)
const char *pathname, unsigned mode, void *context)
{
FILE *file = context;
fprintf(file, "%s%s\n", pathname, S_ISDIR(mode) ? "/" : "");
@ -681,9 +681,9 @@ int cmd_show(int argc, const char **argv, const char *prefix)
diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
name,
diff_get_color_opt(&rev.diffopt, DIFF_RESET));
read_tree_recursive(the_repository, (struct tree *)o, "",
0, 0, &match_all, show_tree_object,
rev.diffopt.file);
read_tree(the_repository, (struct tree *)o,
&match_all, show_tree_object,
rev.diffopt.file);
rev.shown_one = 1;
break;
case OBJ_COMMIT:

75
builtin/ls-files.c
View File

@ -12,6 +12,7 @@
#include "dir.h"
#include "builtin.h"
#include "tree.h"
#include "cache-tree.h"
#include "parse-options.h"
#include "resolve-undo.h"
#include "string-list.h"
@ -420,6 +421,53 @@ static int get_common_prefix_len(const char *common_prefix)
return common_prefix_len;
}
static int read_one_entry_opt(struct index_state *istate,
const struct object_id *oid,
struct strbuf *base,
const char *pathname,
unsigned mode, int opt)
{
int len;
struct cache_entry *ce;
if (S_ISDIR(mode))
return READ_TREE_RECURSIVE;
len = strlen(pathname);
ce = make_empty_cache_entry(istate, base->len + len);
ce->ce_mode = create_ce_mode(mode);
ce->ce_flags = create_ce_flags(1);
ce->ce_namelen = base->len + len;
memcpy(ce->name, base->buf, base->len);
memcpy(ce->name + base->len, pathname, len+1);
oidcpy(&ce->oid, oid);
return add_index_entry(istate, ce, opt);
}
static int read_one_entry(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode,
void *context)
{
struct index_state *istate = context;
return read_one_entry_opt(istate, oid, base, pathname,
mode,
ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
}
/*
* This is used when the caller knows there is no existing entries at
* the stage that will conflict with the entry being added.
*/
static int read_one_entry_quick(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode,
void *context)
{
struct index_state *istate = context;
return read_one_entry_opt(istate, oid, base, pathname,
mode, ADD_CACHE_JUST_APPEND);
}
/*
* Read the tree specified with --with-tree option
* (typically, HEAD) into stage #1 and then
@ -436,6 +484,8 @@ void overlay_tree_on_index(struct index_state *istate,
struct pathspec pathspec;
struct cache_entry *last_stage0 = NULL;
int i;
read_tree_fn_t fn = NULL;
int err;
if (get_oid(tree_name, &oid))
die("tree-ish %s not found.", tree_name);
@ -458,9 +508,32 @@ void overlay_tree_on_index(struct index_state *istate,
PATHSPEC_PREFER_CWD, prefix, matchbuf);
} else
memset(&pathspec, 0, sizeof(pathspec));
if (read_tree(the_repository, tree, 1, &pathspec, istate))
/*
* See if we have cache entry at the stage. If so,
* do it the original slow way, otherwise, append and then
* sort at the end.
*/
for (i = 0; !fn && i < istate->cache_nr; i++) {
const struct cache_entry *ce = istate->cache[i];
if (ce_stage(ce) == 1)
fn = read_one_entry;
}
if (!fn)
fn = read_one_entry_quick;
err = read_tree(the_repository, tree, &pathspec, fn, istate);
if (err)
die("unable to read tree entries %s", tree_name);
/*
* Sort the cache entry -- we need to nuke the cache tree, though.
*/
if (fn == read_one_entry_quick) {
cache_tree_free(&istate->cache_tree);
QSORT(istate->cache, istate->cache_nr, cmp_cache_name_compare);
}
for (i = 0; i < istate->cache_nr; i++) {
struct cache_entry *ce = istate->cache[i];
switch (ce_stage(ce)) {

6
builtin/ls-tree.c
View File

@ -62,7 +62,7 @@ static int show_recursive(const char *base, int baselen, const char *pathname)
}
static int show_tree(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *context)
const char *pathname, unsigned mode, void *context)
{
int retval = 0;
int baselen;
@ -185,6 +185,6 @@ int cmd_ls_tree(int argc, const char **argv, const char *prefix)
tree = parse_tree_indirect(&oid);
if (!tree)
die("not a tree object");
return !!read_tree_recursive(the_repository, tree, "", 0, 0,
&pathspec, show_tree, NULL);
return !!read_tree(the_repository, tree,
&pathspec, show_tree, NULL);
}

2
cache.h
View File

@ -803,7 +803,7 @@ static inline int index_pos_to_insert_pos(uintmax_t pos)
#define ADD_CACHE_OK_TO_ADD 1 /* Ok to add */
#define ADD_CACHE_OK_TO_REPLACE 2 /* Ok to replace file/directory */
#define ADD_CACHE_SKIP_DFCHECK 4 /* Ok to skip DF conflict checks */
#define ADD_CACHE_JUST_APPEND 8 /* Append only; tree.c::read_tree() */
#define ADD_CACHE_JUST_APPEND 8 /* Append only */
#define ADD_CACHE_NEW_ONLY 16 /* Do not replace existing ones */
#define ADD_CACHE_KEEP_CACHE_TREE 32 /* Do not invalidate cache-tree */
#define ADD_CACHE_RENORMALIZE 64 /* Pass along HASH_RENORMALIZE */

6
merge-recursive.c
View File

@ -453,7 +453,7 @@ static void unpack_trees_finish(struct merge_options *opt)
static int save_files_dirs(const struct object_id *oid,
struct strbuf *base, const char *path,
unsigned int mode, int stage, void *context)
unsigned int mode, void *context)
{
struct path_hashmap_entry *entry;
int baselen = base->len;
@ -473,8 +473,8 @@ static void get_files_dirs(struct merge_options *opt, struct tree *tree)
{
struct pathspec match_all;
memset(&match_all, 0, sizeof(match_all));
read_tree_recursive(opt->repo, tree, "", 0, 0,
&match_all, save_files_dirs, opt);
read_tree(opt->repo, tree,
&match_all, save_files_dirs, opt);
}
static int get_tree_entry_if_blob(struct repository *r,

41
t/t3060-ls-files-with-tree.sh
View File

@ -47,6 +47,12 @@ test_expect_success setup '
git add .
'
test_expect_success 'usage' '
test_expect_code 128 git ls-files --with-tree=HEAD -u &&
test_expect_code 128 git ls-files --with-tree=HEAD -s &&
test_expect_code 128 git ls-files --recurse-submodules --with-tree=HEAD
'
test_expect_success 'git ls-files --with-tree should succeed from subdir' '
# We have to run from a sub-directory to trigger prune_path
# Then we finally get to run our --with-tree test
@ -60,4 +66,39 @@ test_expect_success \
'git ls-files --with-tree should add entries from named tree.' \
'test_cmp expected output'
test_expect_success 'no duplicates in --with-tree output' '
git ls-files --with-tree=HEAD >actual &&
sort -u actual >expected &&
test_cmp expected actual
'
test_expect_success 'setup: output in a conflict' '
test_create_repo conflict &&
test_commit -C conflict BASE file &&
test_commit -C conflict A file foo &&
git -C conflict reset --hard BASE &&
test_commit -C conflict B file bar
'
test_expect_success 'output in a conflict' '
test_must_fail git -C conflict merge A B &&
cat >expected <<-\EOF &&
file
file
file
file
EOF
git -C conflict ls-files --with-tree=HEAD >actual &&
test_cmp expected actual
'
test_expect_success 'output with removed .git/index' '
cat >expected <<-\EOF &&
file
EOF
rm conflict/.git/index &&
git -C conflict ls-files --with-tree=HEAD >actual &&
test_cmp expected actual
'
test_done

39
t/t7007-show.sh
View File

@ -38,6 +38,45 @@ test_expect_success 'showing two commits' '
test_cmp expect actual.filtered
'
test_expect_success 'showing a tree' '
cat >expected <<-EOF &&
tree main1:
main1.t
EOF
git show main1: >actual &&
test_cmp expected actual
'
test_expect_success 'showing two trees' '
cat >expected <<-EOF &&
tree main1^{tree}
main1.t
tree main2^{tree}
main1.t
main2.t
EOF
git show main1^{tree} main2^{tree} >actual &&
test_cmp expected actual
'
test_expect_success 'showing a trees is not recursive' '
git worktree add not-recursive main1 &&
mkdir not-recursive/a &&
test_commit -C not-recursive a/file &&
cat >expected <<-EOF &&
tree HEAD^{tree}
a/
main1.t
EOF
git -C not-recursive show HEAD^{tree} >actual &&
test_cmp expected actual
'
test_expect_success 'showing a range walks (linear)' '
cat >expect <<-EOF &&
commit $(git rev-parse main3)

119
tree.c
View File

@ -11,58 +11,10 @@
const char *tree_type = "tree";
static int read_one_entry_opt(struct index_state *istate,
const struct object_id *oid,
const char *base, int baselen,
const char *pathname,
unsigned mode, int stage, int opt)
{
int len;
struct cache_entry *ce;
if (S_ISDIR(mode))
return READ_TREE_RECURSIVE;
len = strlen(pathname);
ce = make_empty_cache_entry(istate, baselen + len);
ce->ce_mode = create_ce_mode(mode);
ce->ce_flags = create_ce_flags(stage);
ce->ce_namelen = baselen + len;
memcpy(ce->name, base, baselen);
memcpy(ce->name + baselen, pathname, len+1);
oidcpy(&ce->oid, oid);
return add_index_entry(istate, ce, opt);
}
static int read_one_entry(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, int stage,
void *context)
{
struct index_state *istate = context;
return read_one_entry_opt(istate, oid, base->buf, base->len, pathname,
mode, stage,
ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
}
/*
* This is used when the caller knows there is no existing entries at
* the stage that will conflict with the entry being added.
*/
static int read_one_entry_quick(const struct object_id *oid, struct strbuf *base,
const char *pathname, unsigned mode, int stage,
void *context)
{
struct index_state *istate = context;
return read_one_entry_opt(istate, oid, base->buf, base->len, pathname,
mode, stage,
ADD_CACHE_JUST_APPEND);
}
static int read_tree_1(struct repository *r,
struct tree *tree, struct strbuf *base,
int stage, const struct pathspec *pathspec,
read_tree_fn_t fn, void *context)
int read_tree_at(struct repository *r,
struct tree *tree, struct strbuf *base,
const struct pathspec *pathspec,
read_tree_fn_t fn, void *context)
{
struct tree_desc desc;
struct name_entry entry;
@ -86,7 +38,7 @@ static int read_tree_1(struct repository *r,
}
switch (fn(&entry.oid, base,
entry.path, entry.mode, stage, context)) {
entry.path, entry.mode, context)) {
case 0:
continue;
case READ_TREE_RECURSIVE:
@ -119,9 +71,9 @@ static int read_tree_1(struct repository *r,
len = tree_entry_len(&entry);
strbuf_add(base, entry.path, len);
strbuf_addch(base, '/');
retval = read_tree_1(r, lookup_tree(r, &oid),
base, stage, pathspec,
fn, context);
retval = read_tree_at(r, lookup_tree(r, &oid),
base, pathspec,
fn, context);
strbuf_setlen(base, oldlen);
if (retval)
return -1;
@ -129,17 +81,13 @@ static int read_tree_1(struct repository *r,
return 0;
}
int read_tree_recursive(struct repository *r,
struct tree *tree,
const char *base, int baselen,
int stage, const struct pathspec *pathspec,
read_tree_fn_t fn, void *context)
int read_tree(struct repository *r,
struct tree *tree,
const struct pathspec *pathspec,
read_tree_fn_t fn, void *context)
{
struct strbuf sb = STRBUF_INIT;
int ret;
strbuf_add(&sb, base, baselen);
ret = read_tree_1(r, tree, &sb, stage, pathspec, fn, context);
int ret = read_tree_at(r, tree, &sb, pathspec, fn, context);
strbuf_release(&sb);
return ret;
}
@ -154,47 +102,6 @@ int cmp_cache_name_compare(const void *a_, const void *b_)
ce2->name, ce2->ce_namelen, ce_stage(ce2));
}
int read_tree(struct repository *r, struct tree *tree, int stage,
struct pathspec *match, struct index_state *istate)
{
read_tree_fn_t fn = NULL;
int i, err;
/*
* Currently the only existing callers of this function all
* call it with stage=1 and after making sure there is nothing
* at that stage; we could always use read_one_entry_quick().
*
* But when we decide to straighten out git-read-tree not to
* use unpack_trees() in some cases, this will probably start
* to matter.
*/
/*
* See if we have cache entry at the stage. If so,
* do it the original slow way, otherwise, append and then
* sort at the end.
*/
for (i = 0; !fn && i < istate->cache_nr; i++) {
const struct cache_entry *ce = istate->cache[i];
if (ce_stage(ce) == stage)
fn = read_one_entry;
}
if (!fn)
fn = read_one_entry_quick;
err = read_tree_recursive(r, tree, "", 0, stage, match, fn, istate);
if (fn == read_one_entry || err)
return err;
/*
* Sort the cache entry -- we need to nuke the cache tree, though.
*/
cache_tree_free(&istate->cache_tree);
QSORT(istate->cache, istate->cache_nr, cmp_cache_name_compare);
return 0;
}
struct tree *lookup_tree(struct repository *r, const struct object_id *oid)
{
struct object *obj = lookup_object(r, oid);

18
tree.h
View File

@ -31,16 +31,16 @@ struct tree *parse_tree_indirect(const struct object_id *oid);
int cmp_cache_name_compare(const void *a_, const void *b_);
#define READ_TREE_RECURSIVE 1
typedef int (*read_tree_fn_t)(const struct object_id *, struct strbuf *, const char *, unsigned int, int, void *);
typedef int (*read_tree_fn_t)(const struct object_id *, struct strbuf *, const char *, unsigned int, void *);
int read_tree_recursive(struct repository *r,
struct tree *tree,
const char *base, int baselen,
int stage, const struct pathspec *pathspec,
read_tree_fn_t fn, void *context);
int read_tree_at(struct repository *r,
struct tree *tree, struct strbuf *base,
const struct pathspec *pathspec,
read_tree_fn_t fn, void *context);
int read_tree(struct repository *r, struct tree *tree,
int stage, struct pathspec *pathspec,
struct index_state *istate);
int read_tree(struct repository *r,
struct tree *tree,
const struct pathspec *pathspec,
read_tree_fn_t fn, void *context);
#endif /* TREE_H */