--- /dev/null
+GIT v1.6.0.2 Release Notes
+==========================
+
+Fixes since v1.6.0.1
+--------------------
+
+* Installation on platforms that needs .exe suffix to git-* programs were
+ broken in 1.6.0.1.
+
+* Installation on filesystems without symbolic links support did nto
+ work well.
+
+* In-tree documentations and test scripts now use "git foo" form to set a
+ better example, instead of the "git-foo" form (which is an acceptable
+ form if you have "PATH=$(git --exec-path):$PATH" in your script)
+
+* Many commands did not use the correct working tree location when used
+ with GIT_WORK_TREE environment settings.
+
+
+* "git apply --unidiff-zero" incorrectly applied a -U0 patch that inserts
+ a new line before the second line.
+
+* "git blame -c" did not exactly work like "git annotate" when range
+ boundaries are involved.
+
+* "git clone $there $here/" with extra trailing slashes after explicit
+ local directory name $here did not work as expected.
+
+* "git diff --dirstat -M" did not add changes in subdirectories up
+ correctly for renamed paths.
+
+* "git diff --cumulative" did not imply "--dirstat".
+
+* "git for-each-ref refs/heads/" did not work as expected.
+
+* "git gui" allowed users to feed patch without any context to be applied.
+
+* "git gui" botched parsing "diff" output when a line that begins with two
+ dashes and a space gets removed or a line that begins with two pluses
+ and a space gets added.
+
+* "git gui" translation updates and i18n fixes.
+
+* "git log -i --grep=pattern" did not ignore case; neither "git log -E
+ --grep=pattern" triggered extended regexp.
+
+* "git log --pretty="%ad" --date=short" did not use short format when
+ showing the timestamp.
+
+* Build procedure for "git shell" that used stub versions of some
+ functions and globals was not understood by linkers on some platforms.
+
+* "git stash" was fooled by a stat-dirty but otherwise unmodified paths
+ and refused to work until the user refreshed the index.
+
+* "git verify-pack -v" did not work correctly when given more than one
+ packfile.
+
+Also contains many documentation updates.
+
+--
+exec >/var/tmp/1
+O=v1.6.0.1-61-g1eff26c
+echo O=$(git describe maint)
+git shortlog --no-merges $O..maint
+
Path to a log file where the CVS server interface well... logs
various stuff. See linkgit:git-cvsserver[1].
-gitcvs.usecrlfattr
+gitcvs.usecrlfattr::
If true, the server will look up the `crlf` attribute for
files to determine the '-k' modes to use. If `crlf` is set,
the '-k' mode will be left blank, so cvs clients will
lines.
--dirstat[=limit]::
- Output only the sub-directories that are impacted by a diff,
- and to what degree they are impacted. You can override the
- default cut-off in percent (3) by "--dirstat=limit". If you
- want to enable "cumulative" directory statistics, you can use
- the "--cumulative" flag, which adds up percentages recursively
- even when they have been already reported for a sub-directory.
+ Output the distribution of relative amount of changes (number of lines added or
+ removed) for each sub-directory. Directories with changes below
+ a cut-off percent (3% by default) are not shown. The cut-off percent
+ can be set with "--dirstat=limit". Changes in a child directory is not
+ counted for the parent directory, unless "--cumulative" is used.
--summary::
Output a condensed summary of extended header information
Annotates each line in the given file with information from the commit
which introduced the line. Optionally annotate from a given revision.
+The only difference between this command and linkgit:git-blame[1] is that
+they use slightly different output formats, and this command exists only
+for backward compatibility to support existing scripts, and provide more
+familiar command name for people coming from other SCM systems.
+
OPTIONS
-------
include::blame-options.txt[]
You don't exist. Go away!::
The passwd(5) gecos field couldn't be read
Your parents must have hated you!::
- The password(5) gecos field is longer than a giant static buffer.
+ The passwd(5) gecos field is longer than a giant static buffer.
Your sysadmin must hate you!::
- The password(5) name field is longer than a giant static buffer.
+ The passwd(5) name field is longer than a giant static buffer.
Discussion
----------
Iterate over all refs that match `<pattern>` and show them
according to the given `<format>`, after sorting them according
-to the given set of `<key>`. If `<max>` is given, stop after
+to the given set of `<key>`. If `<count>` is given, stop after
showing that many refs. The interpolated values in `<format>`
can optionally be quoted as string literals in the specified
host language allowing their direct evaluation in that language.
------------
% git name-rev 33db5f4d9027a10e477ccf054b2c1ab94f74c85a
-33db5f4d9027a10e477ccf054b2c1ab94f74c85a tags/v0.99^0~940
+33db5f4d9027a10e477ccf054b2c1ab94f74c85a tags/v0.99~940
------------
Now you are wiser, because you know that it happened 940 revisions before v0.99.
This is useful if your default address is not the address that is
subscribed to a list. If you use the sendmail binary, you must have
suitable privileges for the -f parameter.
+ Default is the value of the 'sendemail.envelopesender' configuration
+ variable; if that is unspecified, choosing the envelope sender is left
+ to your MTA.
--to::
Specify the primary recipient of the emails generated.
+
----------------------------------------------------------------
$ git pull
-...
+ ...
file foobar not up to date, cannot merge.
$ git stash
$ git pull
return to your original branch to make the emergency fix, like this:
+
----------------------------------------------------------------
-... hack hack hack ...
+# ... hack hack hack ...
$ git checkout -b my_wip
$ git commit -a -m "WIP"
$ git checkout master
$ git commit -a -m "Fix in a hurry"
$ git checkout my_wip
$ git reset --soft HEAD^
-... continue hacking ...
+# ... continue hacking ...
----------------------------------------------------------------
+
You can use 'git-stash' to simplify the above, like this:
+
----------------------------------------------------------------
-... hack hack hack ...
+# ... hack hack hack ...
$ git stash
$ edit emergency fix
$ git commit -a -m "Fix in a hurry"
$ git stash apply
-... continue hacking ...
+# ... continue hacking ...
----------------------------------------------------------------
Testing partial commits::
each change before committing:
+
----------------------------------------------------------------
-... hack hack hack ...
+# ... hack hack hack ...
$ git add --patch foo # add just first part to the index
$ git stash save --keep-index # save all other changes to the stash
$ edit/build/test first part
-$ git commit foo -m 'First part' # commit fully tested change
+$ git commit -m 'First part' # commit fully tested change
$ git stash pop # prepare to work on all other changes
-... repeat above five steps until one commit remains ...
+# ... repeat above five steps until one commit remains ...
$ edit/build/test remaining parts
$ git commit foo -m 'Remaining parts'
----------------------------------------------------------------
Cause the logical variables to be listed. In addition, all the
variables of the git configuration file .git/config are listed
as well. (However, the configuration variables listing functionality
- is deprecated in favor of 'git-config -l'.)
+ is deprecated in favor of 'git config -l'.)
EXAMPLE
--------
You don't exist. Go away!::
The passwd(5) gecos field couldn't be read
Your parents must have hated you!::
- The password(5) gecos field is longer than a giant static buffer.
+ The passwd(5) gecos field is longer than a giant static buffer.
Your sysadmin must hate you!::
- The password(5) name field is longer than a giant static buffer.
+ The passwd(5) name field is longer than a giant static buffer.
SEE ALSO
--------
SYNOPSIS
--------
-$GIT_DIR/info/attributes, gitattributes
+$GIT_DIR/info/attributes, .gitattributes
DESCRIPTION
Unset::
- Unsetting the `crlf` attribute on a path is meant to
- mark the path as a "binary" file. The path never goes
- through line endings conversion upon checkin/checkout.
+ Unsetting the `crlf` attribute on a path tells git not to
+ attempt any end-of-line conversion upon checkin or checkout.
Unspecified::
commit hash.
+USING ATTRIBUTE MACROS
+----------------------
+
+You do not want any end-of-line conversions applied to, nor textual diffs
+produced for, any binary file you track. You would need to specify e.g.
+
+------------
+*.jpg -crlf -diff
+------------
+
+but that may become cumbersome, when you have many attributes. Using
+attribute macros, you can specify groups of attributes set or unset at
+the same time. The system knows a built-in attribute macro, `binary`:
+
+------------
+*.jpg binary
+------------
+
+which is equivalent to the above. Note that the attribute macros can only
+be "Set" (see the above example that sets "binary" macro as if it were an
+ordinary attribute --- setting it in turn unsets "crlf" and "diff").
+
+
+DEFINING ATTRIBUTE MACROS
+-------------------------
+
+Custom attribute macros can be defined only in the `.gitattributes` file
+at the toplevel (i.e. not in any subdirectory). The built-in attribute
+macro "binary" is equivalent to:
+
+------------
+[attr]binary -diff -crlf
+------------
+
+
EXAMPLE
-------
SYNOPSIS
--------
-gitmodules
+$GIT_WORK_DIR/.gitmodules
DESCRIPTION
does not forbid it. However, there are a few things to keep in
mind.
-. 'git-commit-tree' (hence, 'git-commit' which uses it) issues
+. 'git-commit' and 'git-commit-tree' issues
a warning if the commit log message given to it does not look
like a valid UTF-8 string, unless you explicitly say your
project uses a legacy encoding. The way to say this is to
export PERL_PATH
LIB_FILE=libgit.a
-COMPAT_LIB = compat/lib.a
XDIFF_LIB=xdiff/lib.a
LIB_H += archive.h
LIB_H += ll-merge.h
LIB_H += log-tree.h
LIB_H += mailmap.h
+LIB_H += merge-recursive.h
LIB_H += object.h
LIB_H += pack.h
LIB_H += pack-refs.h
'-DGIT_INFO_PATH="$(infodir_SQ)"' $<
$(BUILT_INS): git$X
- $(QUIET_BUILT_IN)$(RM) $@ && ln git$X $@
+ $(QUIET_BUILT_IN)$(RM) $@ && \
+ ln git$X $@ 2>/dev/null || \
+ ln -s git$X $@ 2>/dev/null || \
+ cp git$X $@
common-cmds.h: ./generate-cmdlist.sh command-list.txt
$(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
$(LIBS) $(CURL_LIBCURL) $(EXPAT_LIBEXPAT)
-$(COMPAT_LIB): $(COMPAT_OBJS)
- $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(COMPAT_OBJS)
-
-git-shell$X: abspath.o ctype.o exec_cmd.o quote.o strbuf.o usage.o wrapper.o shell.o $(COMPAT_LIB)
- $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(COMPAT_LIB)
-
$(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
$(patsubst git-%$X,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
builtin-revert.o wt-status.o: wt-status.h
endif
bindir=$$(cd '$(DESTDIR_SQ)$(bindir_SQ)' && pwd) && \
execdir=$$(cd '$(DESTDIR_SQ)$(gitexec_instdir_SQ)' && pwd) && \
- if test "z$$bindir" != "z$$execdir"; \
- then \
- ln -f "$$bindir/git$X" "$$execdir/git$X" || \
- cp "$$bindir/git$X" "$$execdir/git$X"; \
- fi && \
- { $(foreach p,$(BUILT_INS), $(RM) "$$execdir/$p" && ln "$$execdir/git$X" "$$execdir/$p" ;) } && \
- if test "z$$bindir" != "z$$execdir"; \
- then \
- $(RM) "$$execdir/git$X"; \
- fi && \
+ { $(RM) "$$execdir/git-add$X" && \
+ ln git-add$X "$$execdir/git-add$X" 2>/dev/null || \
+ cp git-add$X "$$execdir/git-add$X"; } && \
+ { $(foreach p,$(filter-out git-add$X,$(BUILT_INS)), $(RM) "$$execdir/$p" && \
+ ln "$$execdir/git-add$X" "$$execdir/$p" 2>/dev/null || \
+ ln -s "git-add$X" "$$execdir/$p" 2>/dev/null || \
+ cp "$$execdir/git-add$X" "$$execdir/$p" || exit;) } && \
./check_bindir "z$$bindir" "z$$execdir" "$$bindir/git-add$X"
install-doc:
clean:
$(RM) *.o mozilla-sha1/*.o arm/*.o ppc/*.o compat/*.o xdiff/*.o \
- $(LIB_FILE) $(XDIFF_LIB) $(COMPAT_LIB)
+ $(LIB_FILE) $(XDIFF_LIB)
$(RM) $(ALL_PROGRAMS) $(BUILT_INS) git$X
$(RM) $(TEST_PROGRAMS)
$(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo common-cmds.h TAGS tags cscope*
-Documentation/RelNotes-1.6.0.1.txt
\ No newline at end of file
+Documentation/RelNotes-1.6.0.2.txt
\ No newline at end of file
static void read_patch_file(struct strbuf *sb, int fd)
{
if (strbuf_read(sb, fd, 0) < 0)
- die("git-apply: read returned %s", strerror(errno));
+ die("git apply: read returned %s", strerror(errno));
/*
* Make sure that we have some slop in the buffer
name = orig_name;
len = strlen(name);
if (isnull)
- die("git-apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);
+ die("git apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);
another = find_name(line, NULL, p_value, TERM_TAB);
if (!another || memcmp(another, name, len))
- die("git-apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);
+ die("git apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);
free(another);
return orig_name;
}
else {
/* expect "/dev/null" */
if (memcmp("/dev/null", line, 9) || line[9] != '\n')
- die("git-apply: bad git-diff - expected /dev/null on line %d", linenr);
+ die("git apply: bad git-diff - expected /dev/null on line %d", linenr);
return NULL;
}
}
/*
* A hunk to change lines at the beginning would begin with
* @@ -1,L +N,M @@
+ * but we need to be careful. -U0 that inserts before the second
+ * line also has this pattern.
*
* And a hunk to add to an empty file would begin with
* @@ -0,0 +N,M @@
* In other words, a hunk that is (frag->oldpos <= 1) with or
* without leading context must match at the beginning.
*/
- match_beginning = frag->oldpos <= 1;
+ match_beginning = (!frag->oldpos ||
+ (frag->oldpos == 1 && !unidiff_zero));
/*
* A hunk without trailing lines must match at the end.
len = packet_read_line(fd[0], buf, sizeof(buf));
if (!len)
- die("git-archive: expected ACK/NAK, got EOF");
+ die("git archive: expected ACK/NAK, got EOF");
if (buf[len-1] == '\n')
buf[--len] = 0;
if (strcmp(buf, "ACK")) {
if (len > 5 && !prefixcmp(buf, "NACK "))
- die("git-archive: NACK %s", buf + 5);
- die("git-archive: protocol error");
+ die("git archive: NACK %s", buf + 5);
+ die("git archive: protocol error");
}
len = packet_read_line(fd[0], buf, sizeof(buf));
if (len)
- die("git-archive: expected a flush");
+ die("git archive: expected a flush");
/* Now, start reading from fd[0] and spit it out to stdout */
rv = recv_sideband("archive", fd[0], 1, 2);
static int reverse;
static int blank_boundary;
static int incremental;
-static int cmd_is_annotate;
static int xdl_opts = XDF_NEED_MINIMAL;
static struct string_list mailmap;
if (suspect->commit->object.flags & UNINTERESTING) {
if (blank_boundary)
memset(hex, ' ', length);
- else if (!cmd_is_annotate) {
+ else if (!(opt & OUTPUT_ANNOTATE_COMPAT)) {
length--;
putchar('^');
}
/*
* Add phony grafts for use with -S; this is primarily to
- * support git-cvsserver that wants to give a linear history
+ * support git's cvsserver that wants to give a linear history
* to its clients.
*/
static int read_ancestry(const char *graft_file)
};
struct parse_opt_ctx_t ctx;
-
- cmd_is_annotate = !strcmp(argv[0], "annotate");
+ int cmd_is_annotate = !strcmp(argv[0], "annotate");
git_config(git_blame_config, NULL);
init_revisions(&revs, NULL);
parse_done:
argc = parse_options_end(&ctx);
+ if (cmd_is_annotate)
+ output_option |= OUTPUT_ANNOTATE_COMPAT;
+
if (DIFF_OPT_TST(&revs.diffopt, FIND_COPIES_HARDER))
opt |= (PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE |
PICKAXE_BLAME_COPY_HARDER);
* Basic handler for bundle files to connect repositories via sneakernet.
* Invocation must include action.
* This function can create a bundle or provide information on an existing
- * bundle supporting git-fetch, git-pull, and git-ls-remote
+ * bundle supporting "fetch", "pull", and "ls-remote".
*/
-static const char *bundle_usage="git-bundle (create <bundle> <git-rev-list args> | verify <bundle> | list-heads <bundle> [refname]... | unbundle <bundle> [refname]... )";
+static const char *bundle_usage="git bundle (create <bundle> <git rev-list args> | verify <bundle> | list-heads <bundle> [refname]... | unbundle <bundle> [refname]... )";
int cmd_bundle(int argc, const char **argv, const char *prefix)
{
break;
default:
- die("git-cat-file: unknown option: %s\n", exp_type);
+ die("git cat-file: unknown option: %s\n", exp_type);
}
if (!buf)
- die("git-cat-file %s: bad file", obj_name);
+ die("git cat-file %s: bad file", obj_name);
write_or_die(1, buf, size);
return 0;
int cmd_check_ref_format(int argc, const char **argv, const char *prefix)
{
if (argc != 2)
- usage("git-check-ref-format refname");
+ usage("git check-ref-format refname");
return !!check_ref_format(argv[1]);
}
const char *p;
if (all)
- die("git-checkout-index: don't mix '--all' and explicit filenames");
+ die("git checkout-index: don't mix '--all' and explicit filenames");
if (read_from_stdin)
- die("git-checkout-index: don't mix '--stdin' and explicit filenames");
+ die("git checkout-index: don't mix '--stdin' and explicit filenames");
p = prefix_path(prefix, prefix_length, arg);
checkout_file(p, prefix_length);
if (p < arg || p > arg + strlen(arg))
struct strbuf buf, nbuf;
if (all)
- die("git-checkout-index: don't mix '--all' and '--stdin'");
+ die("git checkout-index: don't mix '--all' and '--stdin'");
strbuf_init(&buf, 0);
strbuf_init(&nbuf, 0);
}
/*
- * If the new thing isn't a branch and isn't HEAD and we're
- * not starting a new branch, and we want messages, and we
- * weren't on a branch, and we're moving to a new commit,
- * describe the old commit.
+ * If we were on a detached HEAD, but we are now moving to
+ * a new commit, we want to mention the old commit once more
+ * to remind the user that it might be lost.
*/
- if (!new->path && strcmp(new->name, "HEAD") && !opts->new_branch &&
- !opts->quiet && !old.path && new->commit != old.commit)
+ if (!opts->quiet && !old.path && new->commit != old.commit)
describe_detached_head("Previous HEAD position was", old.commit);
if (!old.commit) {
return !stat(path, &buf) && S_ISDIR(buf.st_mode);
}
+static void strip_trailing_slashes(char *dir)
+{
+ char *end = dir + strlen(dir);
+
+ while (dir < end - 1 && is_dir_sep(end[-1]))
+ end--;
+ *end = '\0';
+}
+
static void setup_reference(const char *repo)
{
const char *ref_git;
path = get_repo_path(repo_name, &is_bundle);
if (path)
- repo = path;
+ repo = xstrdup(make_nonrelative_path(repo_name));
else if (!strchr(repo_name, ':'))
repo = xstrdup(make_absolute_path(repo_name));
else
dir = xstrdup(argv[1]);
else
dir = guess_dir_name(repo_name, is_bundle, option_bare);
+ strip_trailing_slashes(dir);
if (!stat(dir, &buf))
die("destination directory '%s' already exists.", dir);
if (!option_bare) {
junk_work_tree = work_tree;
if (safe_create_leading_directories_const(work_tree) < 0)
- die("could not create leading directories of '%s'",
- work_tree);
+ die("could not create leading directories of '%s': %s",
+ work_tree, strerror(errno));
if (mkdir(work_tree, 0755))
- die("could not create work tree dir '%s'.", work_tree);
+ die("could not create work tree dir '%s': %s.",
+ work_tree, strerror(errno));
set_git_work_tree(work_tree);
}
junk_git_dir = git_dir;
}
if (strbuf_read(&buffer, 0, 0) < 0)
- die("git-commit-tree: read returned %s", strerror(errno));
+ die("git commit-tree: read returned %s", strerror(errno));
if (!commit_tree(buffer.buf, tree_sha1, parents, commit_sha1)) {
printf("%s\n", sha1_to_hex(commit_sha1));
if (rev.pending.nr != 1 ||
rev.max_count != -1 || rev.min_age != -1 || rev.max_age != -1)
usage(diff_cache_usage);
+ if (!cached)
+ setup_work_tree();
if (read_cache() < 0) {
perror("read_cache");
return -1;
usage(builtin_diff_usage);
argv++; argc--;
}
+ if (!cached)
+ setup_work_tree();
/*
* Make sure there is one revision (i.e. pending object),
* and there is no revision filtering parameters.
(revs->diffopt.output_format & DIFF_FORMAT_PATCH))
revs->combine_merges = revs->dense_combined_merges = 1;
+ setup_work_tree();
if (read_cache() < 0) {
perror("read_cache");
return -1;
fprintf(stderr, "warning: no common commits\n");
if (get_pack(fd, pack_lockfile))
- die("git-fetch-pack: fetch failed.");
+ die("git fetch-pack: fetch failed.");
all_done:
return ref;
/* Make sure we do not get outside of paths */
for (i = 0; paths[i]; i++)
if (strncmp(prefix, paths[i], opt.prefix_length))
- die("git-grep: cannot generate relative filenames containing '..'");
+ die("git grep: cannot generate relative filenames containing '..'");
}
}
else if (prefix) {
paths[1] = NULL;
}
- if (!list.nr)
+ if (!list.nr) {
+ if (!cached)
+ setup_work_tree();
return !grep_cache(&opt, paths, cached);
+ }
if (cached)
die("both --cached and trees are given.");
int offset = prefix_offset;
if (len >= ent->len)
- die("git-ls-files: internal error - directory entry not superset of prefix");
+ die("git ls-files: internal error - directory entry not superset of prefix");
if (pathspec && !pathspec_match(pathspec, ps_matched, ent->name, len))
return;
int offset = prefix_offset;
if (len >= ce_namelen(ce))
- die("git-ls-files: internal error - cache entry not superset of prefix");
+ die("git ls-files: internal error - cache entry not superset of prefix");
if (pathspec && !pathspec_match(pathspec, ps_matched, ce->name, len))
return;
}
if (prefix_offset > max || memcmp(prev, prefix, prefix_offset))
- die("git-ls-files: cannot generate relative filenames containing '..'");
+ die("git ls-files: cannot generate relative filenames containing '..'");
prefix_len = max;
return max ? xmemdupz(prev, max) : NULL;
}
entry->type = sha1_object_info(entry->idx.sha1, &entry->size);
- if (entry->type < 0)
- die("unable to get type of object %s",
- sha1_to_hex(entry->idx.sha1));
+ /*
+ * The error condition is checked in prepare_pack(). This is
+ * to permit a missing preferred base object to be ignored
+ * as a preferred base. Doing so can result in a larger
+ * pack file, but the transfer will still take place.
+ */
}
static int pack_offset_sort(const void *_a, const void *_b)
if (entry->no_try_delta)
continue;
- if (!entry->preferred_base)
+ if (!entry->preferred_base) {
nr_deltas++;
+ if (entry->type < 0)
+ die("unable to get type of object %s",
+ sha1_to_hex(entry->idx.sha1));
+ }
delta_list[n++] = entry;
}
usage(read_tree_usage);
if ((opts.dir && !opts.update))
die("--exclude-per-directory is meaningless unless -u");
+ if (opts.merge && !opts.index_only)
+ setup_work_tree();
if (opts.merge) {
if (stage < 2)
printf("rm '%s'\n", path);
if (remove_file_from_cache(path))
- die("git-rm: unable to remove %s", path);
+ die("git rm: unable to remove %s", path);
}
if (show_only)
continue;
}
if (!removed)
- die("git-rm: %s: %s", path, strerror(errno));
+ die("git rm: %s: %s", path, strerror(errno));
}
}
* ref points at a nonexistent object.
*/
if (!has_sha1_file(sha1))
- die("git-show-ref: bad ref %s (%s)", refname,
+ die("git show-ref: bad ref %s (%s)", refname,
sha1_to_hex(sha1));
if (quiet)
else {
obj = parse_object(sha1);
if (!obj)
- die("git-show-ref: bad ref %s (%s)", refname,
+ die("git show-ref: bad ref %s (%s)", refname,
sha1_to_hex(sha1));
if (obj->type == OBJ_TAG) {
obj = deref_tag(obj, refname, 0);
if (!obj)
- die("git-show-ref: bad tag at ref %s (%s)", refname,
+ die("git show-ref: bad tag at ref %s (%s)", refname,
sha1_to_hex(sha1));
hex = find_unique_abbrev(obj->sha1, abbrev);
printf("%s %s^{}\n", hex, refname);
n = read_in_full(0, buffer, HEADERSIZE);
if (n < HEADERSIZE)
- die("git-get-tar-commit-id: read error");
+ die("git get-tar-commit-id: read error");
if (header->typeflag[0] != 'g')
return 1;
if (memcmp(content, "52 comment=", 11))
n = write_in_full(1, content + 11, 41);
if (n < 41)
- die("git-get-tar-commit-id: write error");
+ die("git get-tar-commit-id: write error");
return 0;
}
report("chmod %cx '%s'", flip, path);
return;
fail:
- die("git-update-index: cannot chmod %cx '%s'", flip, path);
+ die("git update-index: cannot chmod %cx '%s'", flip, path);
}
static void update_one(const char *path, const char *prefix, int prefix_length)
if (force_remove) {
if (remove_file_from_cache(p))
- die("git-update-index: unable to remove %s", path);
+ die("git update-index: unable to remove %s", path);
report("remove '%s'", path);
goto free_return;
}
if (line_termination && path_name[0] == '"') {
strbuf_reset(&uq);
if (unquote_c_style(&uq, path_name, NULL)) {
- die("git-update-index: bad quoting of path name");
+ die("git update-index: bad quoting of path name");
}
path_name = uq.buf;
}
if (!mode) {
/* mode == 0 means there is no such path -- remove */
if (remove_file_from_cache(path_name))
- die("git-update-index: unable to remove %s",
+ die("git update-index: unable to remove %s",
ptr);
}
else {
*/
ptr[-42] = ptr[-1] = 0;
if (add_cacheinfo(mode, sha1, path_name, stage))
- die("git-update-index: unable to update %s",
+ die("git update-index: unable to update %s",
path_name);
}
continue;
continue;
}
if (!strcmp(path, "--refresh")) {
+ setup_work_tree();
has_errors |= refresh_cache(refresh_flags);
continue;
}
if (!strcmp(path, "--really-refresh")) {
+ setup_work_tree();
has_errors |= refresh_cache(REFRESH_REALLY | refresh_flags);
continue;
}
unsigned int mode;
if (i+3 >= argc)
- die("git
-update-index: --cacheinfo <mode> <sha1> <path>");
+ die("git
update-index: --cacheinfo <mode> <sha1> <path>");
if (strtoul_ui(argv[i+1], 8, &mode) ||
get_sha1_hex(argv[i+2], sha1) ||
add_cacheinfo(mode, sha1, argv[i+3], 0))
- die("git-update-index: --cacheinfo"
+ die("git update-index: --cacheinfo"
" cannot add %s", argv[i+3]);
i += 3;
continue;
if (!strcmp(path, "--chmod=-x") ||
!strcmp(path, "--chmod=+x")) {
if (argc <= i+1)
- die("git
-update-index: %s <path>", path);
+ die("git
update-index: %s <path>", path);
set_executable_bit = path[8];
continue;
}
goto finish;
}
if (!strcmp(path, "--again") || !strcmp(path, "-g")) {
+ setup_work_tree();
has_errors = do_reupdate(argc - i, argv + i,
prefix, prefix_length);
if (has_errors)
usage(update_index_usage);
die("unknown option %s", path);
}
+ setup_work_tree();
p = prefix_path(prefix, prefix_length, path);
update_one(p, NULL, 0);
if (set_executable_bit)
strbuf_init(&buf, 0);
strbuf_init(&nbuf, 0);
+ setup_work_tree();
while (strbuf_getline(&buf, stdin, line_termination) != EOF) {
const char *p;
if (line_termination && buf.buf[0] == '"') {
#include "builtin.h"
#include "cache.h"
#include "pack.h"
-
+#include "pack-revindex.h"
#define MAX_CHAIN 50
else {
if (verify_one_pack(argv[1], verbose))
err = 1;
+ discard_revindex();
nothing_done = 0;
}
argc--; argv++;
int len = packet_read_line(fd, line, sizeof(line));
if (!len)
- die("git-fetch-pack: expected ACK/NAK, got EOF");
+ die("git fetch-pack: expected ACK/NAK, got EOF");
if (line[len-1] == '\n')
line[--len] = 0;
if (!strcmp(line, "NAK"))
return 1;
}
}
- die("git-fetch_pack: expected ACK/NAK, got '%s'", line);
+ die("git fetch_pack: expected ACK/NAK, got '%s'", line);
}
int path_match(const char *path, int nr, char **match)
cat-file) : plumbing;;
check-attr) : plumbing;;
check-ref-format) : plumbing;;
+ checkout-index) : plumbing;;
commit-tree) : plumbing;;
+ count-objects) : infrequent;;
cvsexportcommit) : export;;
cvsimport) : import;;
cvsserver) : daemon;;
diff-index) : plumbing;;
diff-tree) : plumbing;;
fast-import) : import;;
+ fast-export) : export;;
fsck-objects) : plumbing;;
fetch-pack) : plumbing;;
fmt-merge-msg) : plumbing;;
index-pack) : plumbing;;
init-db) : deprecated;;
local-fetch) : plumbing;;
+ lost-found) : infrequent;;
+ ls-files) : plumbing;;
+ ls-remote) : plumbing;;
+ ls-tree) : plumbing;;
mailinfo) : plumbing;;
mailsplit) : plumbing;;
merge-*) : plumbing;;
runstatus) : plumbing;;
sh-setup) : internal;;
shell) : daemon;;
+ show-ref) : plumbing;;
send-pack) : plumbing;;
show-index) : plumbing;;
ssh-*) : transport;;
upload-archive) : plumbing;;
upload-pack) : plumbing;;
write-tree) : plumbing;;
+ var) : infrequent;;
+ verify-pack) : infrequent;;
verify-tag) : plumbing;;
*) echo $i;;
esac
dir.alloc = 0;
dir.nr = 0;
dir.percent = options->dirstat_percent;
- dir.cumulative = options->output_format & DIFF_FORMAT_CUMULATIVE;
+ dir.cumulative = DIFF_OPT_TST(options, DIRSTAT_CUMULATIVE);
changed = 0;
for (i = 0; i < q->nr; i++) {
options->break_opt = -1;
options->rename_limit = -1;
options->dirstat_percent = 3;
+ DIFF_OPT_CLR(options, DIRSTAT_CUMULATIVE);
options->context = 3;
options->change = diff_change;
options->output_format |= DIFF_FORMAT_SHORTSTAT;
else if (opt_arg(arg, 'X', "dirstat", &options->dirstat_percent))
options->output_format |= DIFF_FORMAT_DIRSTAT;
- else if (!strcmp(arg, "--cumulative"))
- options->output_format |= DIFF_FORMAT_CUMULATIVE;
+ else if (!strcmp(arg, "--cumulative")) {
+ options->output_format |= DIFF_FORMAT_DIRSTAT;
+ DIFF_OPT_SET(options, DIRSTAT_CUMULATIVE);
+ }
else if (!strcmp(arg, "--check"))
options->output_format |= DIFF_FORMAT_CHECKDIFF;
else if (!strcmp(arg, "--summary"))
#define DIFF_FORMAT_PATCH 0x0010
#define DIFF_FORMAT_SHORTSTAT 0x0020
#define DIFF_FORMAT_DIRSTAT 0x0040
-#define DIFF_FORMAT_CUMULATIVE 0x0080
/* These override all above */
#define DIFF_FORMAT_NAME 0x0100
#define DIFF_OPT_CHECK_FAILED (1 << 16)
#define DIFF_OPT_RELATIVE_NAME (1 << 17)
#define DIFF_OPT_IGNORE_SUBMODULES (1 << 18)
+#define DIFF_OPT_DIRSTAT_CUMULATIVE (1 << 19)
#define DIFF_OPT_TST(opts, flag) ((opts)->flags & DIFF_OPT_##flag)
#define DIFF_OPT_SET(opts, flag) ((opts)->flags |= DIFF_OPT_##flag)
#define DIFF_OPT_CLR(opts, flag) ((opts)->flags &= ~DIFF_OPT_##flag)
case S_IFREG:
new = read_blob_entry(ce, path, &size);
if (!new)
- return error("git-checkout-index: unable to read sha1 file of %s (%s)",
+ return error("git checkout-index: unable to read sha1 file of %s (%s)",
path, sha1_to_hex(ce->sha1));
/*
fd = create_file(path, ce->ce_mode);
if (fd < 0) {
free(new);
- return error("git-checkout-index: unable to create file %s (%s)",
+ return error("git checkout-index: unable to create file %s (%s)",
path, strerror(errno));
}
close(fd);
free(new);
if (wrote != size)
- return error("git-checkout-index: unable to write file %s", path);
+ return error("git checkout-index: unable to write file %s", path);
break;
case S_IFLNK:
new = read_blob_entry(ce, path, &size);
if (!new)
- return error("git-checkout-index: unable to read sha1 file of %s (%s)",
+ return error("git checkout-index: unable to read sha1 file of %s (%s)",
path, sha1_to_hex(ce->sha1));
if (to_tempfile || !has_symlinks) {
if (to_tempfile) {
fd = create_file(path, 0666);
if (fd < 0) {
free(new);
- return error("git-checkout-index: unable to create "
+ return error("git checkout-index: unable to create "
"file %s (%s)", path, strerror(errno));
}
wrote = write_in_full(fd, new, size);
close(fd);
free(new);
if (wrote != size)
- return error("git-checkout-index: unable to write file %s",
+ return error("git checkout-index: unable to write file %s",
path);
} else {
wrote = symlink(new, path);
free(new);
if (wrote)
- return error("git-checkout-index: unable to create "
+ return error("git checkout-index: unable to create "
"symlink %s (%s)", path, strerror(errno));
}
break;
case S_IFGITLINK:
if (to_tempfile)
- return error("git-checkout-index: cannot create temporary subproject %s", path);
+ return error("git checkout-index: cannot create temporary subproject %s", path);
if (mkdir(path, 0777) < 0)
- return error("git-checkout-index: cannot create subproject directory %s", path);
+ return error("git checkout-index: cannot create subproject directory %s", path);
break;
default:
- return error("git-checkout-index: unknown file mode for %s", path);
+ return error("git checkout-index: unknown file mode for %s", path);
}
if (state->refresh_cache) {
proc show_less_context {} {
global repo_config
- if {$repo_config(gui.diffcontext) >= 1} {
+ if {$repo_config(gui.diffcontext) > 1} {
incr repo_config(gui.diffcontext) -1
reshow_diff
}
lappend cmd -p
lappend cmd --no-color
- if {$repo_config(gui.diffcontext) >= 0} {
+ if {$repo_config(gui.diffcontext) >= 1} {
lappend cmd "-U$repo_config(gui.diffcontext)"
}
if {$w eq $ui_index} {
return
}
+ set ::current_diff_inheader 1
fconfigure $fd \
-blocking 0 \
-encoding binary \
while {[gets $fd line] >= 0} {
# -- Cleanup uninteresting diff header lines.
#
- if { [string match {diff --git *} $line]
- || [string match {diff --cc *} $line]
- || [string match {diff --combined *} $line]
- || [string match {--- *} $line]
- || [string match {+++ *} $line]} {
- append current_diff_header $line "\n"
- continue
+ if {$::current_diff_inheader} {
+ if { [string match {diff --git *} $line]
+ || [string match {diff --cc *} $line]
+ || [string match {diff --combined *} $line]
+ || [string match {--- *} $line]
+ || [string match {+++ *} $line]} {
+ append current_diff_header $line "\n"
+ continue
+ }
}
if {[string match {index *} $line]} continue
if {$line eq {deleted file mode 120000}} {
set line "deleted symlink"
}
+ set ::current_diff_inheader 0
# -- Automatically detect if this is a 3 way diff.
#
{b gui.matchtrackingbranch {mc "Match Tracking Branches"}}
{b gui.fastcopyblame {mc "Blame Copy Only On Changed Files"}}
{i-20..200 gui.copyblamethreshold {mc "Minimum Letters To Blame Copy On"}}
- {i-0..99 gui.diffcontext {mc "Number of Diff Context Lines"}}
+ {i-1..99 gui.diffcontext {mc "Number of Diff Context Lines"}}
{i-0..99 gui.commitmsgwidth {mc "Commit Message Text Width"}}
{t gui.newbranchtemplate {mc "New Branch Name Template"}}
} {
-# translation of fr.po to French
+# translation of fr.po to Français
# Translation of git-gui to French.
# Copyright (C) 2008 Shawn Pearce, et al.
# This file is distributed under the same license as the git package.
#
# Christian Couder <chriscool@tuxfamily.org>, 2008.
+# Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>, 2008.
msgid ""
msgstr ""
"Project-Id-Version: fr\n"
"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2008-03-14 07:18+0100\n"
-"PO-Revision-Date: 2008-04-04 22:05+0200\n"
-"Last-Translator: Christian Couder <chriscool@tuxfamily.org>\n"
-"Language-Team: French\n"
+"POT-Creation-Date: 2008-08-02 14:45-0700\n"
+"PO-Revision-Date: 2008-08-11 17:12-0400\n"
+"Last-Translator: Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>\n"
+"Language-Team: Français <fr@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
-#: git-gui.sh:41 git-gui.sh:634 git-gui.sh:648 git-gui.sh:661 git-gui.sh:744
-#: git-gui.sh:763
+#: git-gui.sh:41 git-gui.sh:688 git-gui.sh:702 git-gui.sh:715 git-gui.sh:798
+#: git-gui.sh:817
msgid "git-gui: fatal error"
msgstr "git-gui: erreur fatale"
-#: git-gui.sh:593
+#: git-gui.sh:644
#, tcl-format
msgid "Invalid font specified in %s:"
-msgstr "Invalide fonte spécifiée dans %s :"
+msgstr "Police invalide spécifiée dans %s :"
-#: git-gui.sh:620
+#: git-gui.sh:674
msgid "Main Font"
-msgstr "Fonte principale"
+msgstr "Police principale"
-#: git-gui.sh:621
+#: git-gui.sh:675
msgid "Diff/Console Font"
-msgstr "Fonte diff/console"
+msgstr "Police diff/console"
-#: git-gui.sh:635
+#: git-gui.sh:689
msgid "Cannot find git in PATH."
msgstr "Impossible de trouver git dans PATH."
-#: git-gui.sh:662
+#: git-gui.sh:716
msgid "Cannot parse Git version string:"
msgstr "Impossible de parser la version de Git :"
-#: git-gui.sh:680
+#: git-gui.sh:734
#, tcl-format
msgid ""
"Git version cannot be determined.\n"
"\n"
"Peut'on considérer que '%s' est en version 1.5.0 ?\n"
-#: git-gui.sh:918
+#: git-gui.sh:972
msgid "Git directory not found:"
-msgstr "Impossible de trouver le répertoire de Git :"
+msgstr "Impossible de trouver le répertoire git :"
-#: git-gui.sh:925
+#: git-gui.sh:979
msgid "Cannot move to top of working directory:"
msgstr "Impossible d'aller à la racine du répertoire de travail :"
-#: git-gui.sh:932
+#: git-gui.sh:986
msgid "Cannot use funny .git directory:"
-msgstr "Impossible d'utiliser un drôle de répertoire git :"
+msgstr "Impossible d'utiliser le répertoire .git:"
-#: git-gui.sh:937
+#: git-gui.sh:991
msgid "No working directory"
-msgstr "Pas de répertoire de travail"
+msgstr "Aucun répertoire de travail"
-#: git-gui.sh:1084 lib/checkout_op.tcl:283
+#: git-gui.sh:1138 lib/checkout_op.tcl:305
msgid "Refreshing file status..."
msgstr "Rafraichissement du status des fichiers..."
-#: git-gui.sh:1149
+#: git-gui.sh:1194
msgid "Scanning for modified files ..."
msgstr "Recherche de fichiers modifiés..."
-#: git-gui.sh:1324 lib/browser.tcl:246
+#: git-gui.sh:1369 lib/browser.tcl:246
msgid "Ready."
msgstr "Prêt."
-#: git-gui.sh:1590
+#: git-gui.sh:1635
msgid "Unmodified"
msgstr "Non modifié"
-#: git-gui.sh:1592
+#: git-gui.sh:1637
msgid "Modified, not staged"
-msgstr "Modifié, non pré-commité"
+msgstr "Modifié, pas indexé"
-#: git-gui.sh:1593 git-gui.sh:1598
+#: git-gui.sh:1638 git-gui.sh:1643
msgid "Staged for commit"
-msgstr "Pré-commité"
+msgstr "Indexé"
-#: git-gui.sh:1594 git-gui.sh:1599
+#: git-gui.sh:1639 git-gui.sh:1644
msgid "Portions staged for commit"
-msgstr "En partie pré-commité"
+msgstr "Portions indexées"
-#: git-gui.sh:1595 git-gui.sh:1600
+#: git-gui.sh:1640 git-gui.sh:1645
msgid "Staged for commit, missing"
-msgstr "Pré-commité, manquant"
+msgstr "Indexés, manquant"
-#: git-gui.sh:1597
+#: git-gui.sh:1642
msgid "Untracked, not staged"
-msgstr "Non suivi, non pré-commité"
+msgstr "Non versionné, non indexé"
-#: git-gui.sh:1602
+#: git-gui.sh:1647
msgid "Missing"
msgstr "Manquant"
-#: git-gui.sh:1603
+#: git-gui.sh:1648
msgid "Staged for removal"
-msgstr "Pré-commité pour suppression"
+msgstr "Indexé pour suppression"
-#: git-gui.sh:1604
+#: git-gui.sh:1649
msgid "Staged for removal, still present"
-msgstr "Pré-commité pour suppression, toujours présent"
+msgstr "Indexé pour suppression, toujours présent"
-#: git-gui.sh:1606 git-gui.sh:1607 git-gui.sh:1608 git-gui.sh:1609
+#: git-gui.sh:1651 git-gui.sh:1652 git-gui.sh:1653 git-gui.sh:1654
msgid "Requires merge resolution"
msgstr "Nécessite la résolution d'une fusion"
-#: git-gui.sh:1644
+#: git-gui.sh:1689
msgid "Starting gitk... please wait..."
-msgstr "Lancement de gitk... merci de patienter..."
+msgstr "Lancement de gitk... un instant..."
-#: git-gui.sh:1653
-#, tcl-format
-msgid ""
-"Unable to start gitk:\n"
-"\n"
-"%s does not exist"
-msgstr ""
-"Impossible de lancer gitk :\n"
-"\n"
-"%s inexistant"
+#: git-gui.sh:1698
+msgid "Couldn't find gitk in PATH"
+msgstr "Impossible de trouver gitk dans PATH."
-#: git-gui.sh:1860 lib/choose_repository.tcl:36
+#: git-gui.sh:1948 lib/choose_repository.tcl:36
msgid "Repository"
-msgstr "Référentiel"
+msgstr "Dépôt"
-#: git-gui.sh:1861
+#: git-gui.sh:1949
msgid "Edit"
-msgstr "Editer"
+msgstr "Edition"
-#: git-gui.sh:1863 lib/choose_rev.tcl:561
+#: git-gui.sh:1951 lib/choose_rev.tcl:561
msgid "Branch"
msgstr "Branche"
-#: git-gui.sh:1866 lib/choose_rev.tcl:548
+#: git-gui.sh:1954 lib/choose_rev.tcl:548
msgid "Commit@@noun"
msgstr "Commit"
-#: git-gui.sh:1869 lib/merge.tcl:120 lib/merge.tcl:149 lib/merge.tcl:167
+#: git-gui.sh:1957 lib/merge.tcl:120 lib/merge.tcl:149 lib/merge.tcl:167
msgid "Merge"
msgstr "Fusionner"
-#: git-gui.sh:1870 lib/choose_rev.tcl:557
+#: git-gui.sh:1958 lib/choose_rev.tcl:557
msgid "Remote"
-msgstr "Référentiel distant"
+msgstr "Dépôt distant"
-#: git-gui.sh:1879
+#: git-gui.sh:1967
msgid "Browse Current Branch's Files"
-msgstr "Visionner fichiers dans branche courante"
+msgstr "Naviguer dans la branche courante"
-#: git-gui.sh:1883
+#: git-gui.sh:1971
msgid "Browse Branch Files..."
-msgstr "Visionner fichiers de branche"
+msgstr "Naviguer dans la branche..."
-#: git-gui.sh:1888
+#: git-gui.sh:1976
msgid "Visualize Current Branch's History"
msgstr "Visualiser historique branche courante"
-#: git-gui.sh:1892
+#: git-gui.sh:1980
msgid "Visualize All Branch History"
-msgstr "Visualiser historique toutes branches"
+msgstr "Voir l'historique de toutes les branches"
-#: git-gui.sh:1899
+#: git-gui.sh:1987
#, tcl-format
msgid "Browse %s's Files"
-msgstr "Visionner fichiers de %s"
+msgstr "Naviguer l'arborescence de %s"
-#: git-gui.sh:1901
+#: git-gui.sh:1989
#, tcl-format
msgid "Visualize %s's History"
-msgstr "Visualiser historique de %s"
+msgstr "Voir l'historique de la branche: %s"
-#: git-gui.sh:1906 lib/database.tcl:27 lib/database.tcl:67
+#: git-gui.sh:1994 lib/database.tcl:27 lib/database.tcl:67
msgid "Database Statistics"
-msgstr "Statistiques base de donnée"
+msgstr "Statistiques du dépôt"
-#: git-gui.sh:1909 lib/database.tcl:34
+#: git-gui.sh:1997 lib/database.tcl:34
msgid "Compress Database"
-msgstr "Comprimer base de donnée"
+msgstr "Comprimer le dépôt"
-#: git-gui.sh:1912
+#: git-gui.sh:2000
msgid "Verify Database"
-msgstr "Vérifier base de donnée"
+msgstr "Vérifier le dépôt"
-#: git-gui.sh:1919 git-gui.sh:1923 git-gui.sh:1927 lib/shortcut.tcl:7
+#: git-gui.sh:2007 git-gui.sh:2011 git-gui.sh:2015 lib/shortcut.tcl:7
#: lib/shortcut.tcl:39 lib/shortcut.tcl:71
msgid "Create Desktop Icon"
msgstr "Créer icône sur bureau"
-#: git-gui.sh:1932 lib/choose_repository.tcl:177 lib/choose_repository.tcl:185
+#: git-gui.sh:2023 lib/choose_repository.tcl:177 lib/choose_repository.tcl:185
msgid "Quit"
msgstr "Quitter"
-#: git-gui.sh:1939
+#: git-gui.sh:2031
msgid "Undo"
msgstr "Défaire"
-#: git-gui.sh:1942
+#: git-gui.sh:2034
msgid "Redo"
msgstr "Refaire"
-#: git-gui.sh:1946 git-gui.sh:2443
+#: git-gui.sh:2038 git-gui.sh:2545
msgid "Cut"
msgstr "Couper"
-#: git-gui.sh:1949 git-gui.sh:2446 git-gui.sh:2520 git-gui.sh:2614
+#: git-gui.sh:2041 git-gui.sh:2548 git-gui.sh:2622 git-gui.sh:2715
#: lib/console.tcl:69
msgid "Copy"
msgstr "Copier"
-#: git-gui.sh:1952 git-gui.sh:2449
+#: git-gui.sh:2044 git-gui.sh:2551
msgid "Paste"
msgstr "Coller"
-#: git-gui.sh:1955 git-gui.sh:2452 lib/branch_delete.tcl:26
+#: git-gui.sh:2047 git-gui.sh:2554 lib/branch_delete.tcl:26
#: lib/remote_branch_delete.tcl:38
msgid "Delete"
msgstr "Supprimer"
-#: git-gui.sh:1959 git-gui.sh:2456 git-gui.sh:2618 lib/console.tcl:71
+#: git-gui.sh:2051 git-gui.sh:2558 git-gui.sh:2719 lib/console.tcl:71
msgid "Select All"
msgstr "Tout sélectionner"
-#: git-gui.sh:1968
+#: git-gui.sh:2060
msgid "Create..."
msgstr "Créer..."
-#: git-gui.sh:1974
+#: git-gui.sh:2066
msgid "Checkout..."
-msgstr "Emprunter... "
+msgstr "Charger (checkout)..."
-#: git-gui.sh:1980
+#: git-gui.sh:2072
msgid "Rename..."
msgstr "Renommer..."
-#: git-gui.sh:1985 git-gui.sh:2085
+#: git-gui.sh:2077 git-gui.sh:2187
msgid "Delete..."
msgstr "Supprimer..."
-#: git-gui.sh:1990
+#: git-gui.sh:2082
msgid "Reset..."
msgstr "Réinitialiser..."
-#: git-gui.sh:2002 git-gui.sh:2389
+#: git-gui.sh:2094 git-gui.sh:2491
msgid "New Commit"
msgstr "Nouveau commit"
-#: git-gui.sh:2010 git-gui.sh:2396
+#: git-gui.sh:2102 git-gui.sh:2498
msgid "Amend Last Commit"
msgstr "Corriger dernier commit"
-#: git-gui.sh:2019 git-gui.sh:2356 lib/remote_branch_delete.tcl:99
+#: git-gui.sh:2111 git-gui.sh:2458 lib/remote_branch_delete.tcl:99
msgid "Rescan"
-msgstr "Resynchroniser"
+msgstr "Recharger modifs."
-#: git-gui.sh:2025
+#: git-gui.sh:2117
msgid "Stage To Commit"
-msgstr "Commiter un pré-commit"
+msgstr "Indexer"
-#: git-gui.sh:2031
+#: git-gui.sh:2123
msgid "Stage Changed Files To Commit"
-msgstr "Commiter fichiers modifiés dans pré-commit"
+msgstr "Indexer toutes modifications"
-#: git-gui.sh:2037
+#: git-gui.sh:2129
msgid "Unstage From Commit"
-msgstr "Commit vers pré-commit"
+msgstr "Désindexer"
-#: git-gui.sh:2042 lib/index.tcl:395
+#: git-gui.sh:2134 lib/index.tcl:395
msgid "Revert Changes"
-msgstr "Inverser modification"
+msgstr "Annuler les modifications (revert)"
-#: git-gui.sh:2049 git-gui.sh:2368 git-gui.sh:2467
+#: git-gui.sh:2141 git-gui.sh:2702
+msgid "Show Less Context"
+msgstr "Montrer moins de contexte"
+
+#: git-gui.sh:2145 git-gui.sh:2706
+msgid "Show More Context"
+msgstr "Montrer plus de contexte"
+
+#: git-gui.sh:2151 git-gui.sh:2470 git-gui.sh:2569
msgid "Sign Off"
-msgstr "Se désinscrire"
+msgstr "Signer"
-#: git-gui.sh:2053 git-gui.sh:2372
+#: git-gui.sh:2155 git-gui.sh:2474
msgid "Commit@@verb"
msgstr "Commiter"
-#: git-gui.sh:2064
+#: git-gui.sh:2166
msgid "Local Merge..."
msgstr "Fusion locale..."
-#: git-gui.sh:2069
+#: git-gui.sh:2171
msgid "Abort Merge..."
msgstr "Abandonner fusion..."
-#: git-gui.sh:2081
+#: git-gui.sh:2183
msgid "Push..."
msgstr "Pousser..."
-#: git-gui.sh:2092 lib/choose_repository.tcl:41
-msgid "Apple"
-msgstr "Pomme"
-
-#: git-gui.sh:2095 git-gui.sh:2117 lib/about.tcl:14
+#: git-gui.sh:2197 git-gui.sh:2219 lib/about.tcl:14
#: lib/choose_repository.tcl:44 lib/choose_repository.tcl:50
#, tcl-format
msgid "About %s"
-msgstr "A propos de %s"
+msgstr "À propos de %s"
-#: git-gui.sh:2099
+#: git-gui.sh:2201
msgid "Preferences..."
msgstr "Préférences..."
-#: git-gui.sh:2107 git-gui.sh:2639
+#: git-gui.sh:2209 git-gui.sh:2740
msgid "Options..."
msgstr "Options..."
-#: git-gui.sh:2113 lib/choose_repository.tcl:47
+#: git-gui.sh:2215 lib/choose_repository.tcl:47
msgid "Help"
msgstr "Aide"
-#: git-gui.sh:2154
+#: git-gui.sh:2256
msgid "Online Documentation"
msgstr "Documentation en ligne"
-#: git-gui.sh:2238
+#: git-gui.sh:2340
#, tcl-format
msgid "fatal: cannot stat path %s: No such file or directory"
-msgstr "erreur fatale : pas d'infos sur le chemin %s : Fichier ou répertoire inexistant"
+msgstr ""
+"erreur fatale : pas d'infos sur le chemin %s : Fichier ou répertoire "
+"inexistant"
-#: git-gui.sh:2271
+#: git-gui.sh:2373
msgid "Current Branch:"
msgstr "Branche courante :"
-#: git-gui.sh:2292
+#: git-gui.sh:2394
msgid "Staged Changes (Will Commit)"
-msgstr "Modifications pré-commitées"
+msgstr "Modifs. indexées (pour commit)"
-#: git-gui.sh:2312
+#: git-gui.sh:2414
msgid "Unstaged Changes"
-msgstr "Modifications non pré-commitées"
+msgstr "Modifs. non indexées"
-#: git-gui.sh:2362
+#: git-gui.sh:2464
msgid "Stage Changed"
-msgstr "Pré-commit modifié"
+msgstr "Indexer modifs."
-#: git-gui.sh:2378 lib/transport.tcl:93 lib/transport.tcl:182
+#: git-gui.sh:2480 lib/transport.tcl:93 lib/transport.tcl:182
msgid "Push"
msgstr "Pousser"
-#: git-gui.sh:2408
+#: git-gui.sh:2510
msgid "Initial Commit Message:"
msgstr "Message de commit initial :"
-#: git-gui.sh:2409
+#: git-gui.sh:2511
msgid "Amended Commit Message:"
msgstr "Message de commit corrigé :"
-#: git-gui.sh:2410
+#: git-gui.sh:2512
msgid "Amended Initial Commit Message:"
msgstr "Message de commit initial corrigé :"
-#: git-gui.sh:2411
+#: git-gui.sh:2513
msgid "Amended Merge Commit Message:"
msgstr "Message de commit de fusion corrigé :"
-#: git-gui.sh:2412
+#: git-gui.sh:2514
msgid "Merge Commit Message:"
msgstr "Message de commit de fusion :"
-#: git-gui.sh:2413
+#: git-gui.sh:2515
msgid "Commit Message:"
msgstr "Message de commit :"
-#: git-gui.sh:2459 git-gui.sh:2622 lib/console.tcl:73
+#: git-gui.sh:2561 git-gui.sh:2723 lib/console.tcl:73
msgid "Copy All"
msgstr "Copier tout"
-#: git-gui.sh:2483 lib/blame.tcl:107
+#: git-gui.sh:2585 lib/blame.tcl:100
msgid "File:"
msgstr "Fichier :"
-#: git-gui.sh:2589
+#: git-gui.sh:2691
msgid "Apply/Reverse Hunk"
msgstr "Appliquer/Inverser section"
-#: git-gui.sh:2595
-msgid "Show Less Context"
-msgstr "Montrer moins de contexte"
-
-#: git-gui.sh:2602
-msgid "Show More Context"
-msgstr "Montrer plus de contexte"
+#: git-gui.sh:2696
+msgid "Apply/Reverse Line"
+msgstr "Appliquer/Inverser la ligne"
-#: git-gui.sh:2610
+#: git-gui.sh:2711
msgid "Refresh"
msgstr "Rafraichir"
-#: git-gui.sh:2631
+#: git-gui.sh:2732
msgid "Decrease Font Size"
-msgstr "Réduire fonte"
+msgstr "Diminuer la police"
-#: git-gui.sh:2635
+#: git-gui.sh:2736
msgid "Increase Font Size"
-msgstr "Agrandir fonte"
+msgstr "Agrandir la police"
-#: git-gui.sh:2646
+#: git-gui.sh:2747
msgid "Unstage Hunk From Commit"
-msgstr "Enlever section pré-commitée"
+msgstr "Désindexer la section"
+
+#: git-gui.sh:2748
+msgid "Unstage Line From Commit"
+msgstr "Désindexer la ligne"
-#: git-gui.sh:2648
+#: git-gui.sh:2750
msgid "Stage Hunk For Commit"
-msgstr "Pré-commiter section"
+msgstr "Indexer la section"
-#: git-gui.sh:2667
+#: git-gui.sh:2751
+msgid "Stage Line For Commit"
+msgstr "Indexer la ligne"
+
+#: git-gui.sh:2771
msgid "Initializing..."
msgstr "Initialisation..."
-#: git-gui.sh:2762
+#: git-gui.sh:2876
#, tcl-format
msgid ""
"Possible environment issues exist.\n"
"sous-processus de Git lancés par %s\n"
"\n"
-#: git-gui.sh:2792
+#: git-gui.sh:2906
msgid ""
"\n"
"This is due to a known issue with the\n"
"Ceci est du à un problème connu avec\n"
"le binaire Tcl distribué par Cygwin."
-#: git-gui.sh:2797
+#: git-gui.sh:2911
#, tcl-format
msgid ""
"\n"
msgid "git-gui - a graphical user interface for Git."
msgstr "git-gui - une interface graphique utilisateur pour Git"
-#: lib/blame.tcl:77
+#: lib/blame.tcl:70
msgid "File Viewer"
msgstr "Visionneur de fichier"
-#: lib/blame.tcl:81
+#: lib/blame.tcl:74
msgid "Commit:"
msgstr "Commit :"
-#: lib/blame.tcl:264
+#: lib/blame.tcl:257
msgid "Copy Commit"
msgstr "Copier commit"
-#: lib/blame.tcl:384
+#: lib/blame.tcl:260
+msgid "Do Full Copy Detection"
+msgstr "Lancer la détection approfondie des copies"
+
+#: lib/blame.tcl:388
#, tcl-format
msgid "Reading %s..."
msgstr "Lecture de %s..."
-#: lib/blame.tcl:488
+#: lib/blame.tcl:492
msgid "Loading copy/move tracking annotations..."
msgstr "Chargement des annotations de suivi des copies/déplacements..."
-#: lib/blame.tcl:508
+#: lib/blame.tcl:512
msgid "lines annotated"
msgstr "lignes annotées"
-#: lib/blame.tcl:689
+#: lib/blame.tcl:704
msgid "Loading original location annotations..."
msgstr "Chargement des annotations d'emplacement original"
-#: lib/blame.tcl:692
+#: lib/blame.tcl:707
msgid "Annotation complete."
msgstr "Annotation terminée."
-#: lib/blame.tcl:746
+#: lib/blame.tcl:737
+msgid "Busy"
+msgstr "Occupé"
+
+#: lib/blame.tcl:738
+msgid "Annotation process is already running."
+msgstr "Annotation en cours d'exécution."
+
+#: lib/blame.tcl:777
+msgid "Running thorough copy detection..."
+msgstr "Recherche de copie approfondie en cours..."
+
+#: lib/blame.tcl:827
msgid "Loading annotation..."
msgstr "Chargement des annotations..."
-#: lib/blame.tcl:802
+#: lib/blame.tcl:883
msgid "Author:"
msgstr "Auteur :"
-#: lib/blame.tcl:806
+#: lib/blame.tcl:887
msgid "Committer:"
msgstr "Commiteur :"
-#: lib/blame.tcl:811
+#: lib/blame.tcl:892
msgid "Original File:"
msgstr "Fichier original :"
-#: lib/blame.tcl:925
+#: lib/blame.tcl:1006
msgid "Originally By:"
msgstr "A l'origine par :"
-#: lib/blame.tcl:931
+#: lib/blame.tcl:1012
msgid "In File:"
msgstr "Dans le fichier :"
-#: lib/blame.tcl:936
+#: lib/blame.tcl:1017
msgid "Copied Or Moved Here By:"
msgstr "Copié ou déplacé ici par :"
#: lib/branch_checkout.tcl:14 lib/branch_checkout.tcl:19
msgid "Checkout Branch"
-msgstr "Emprunter branche"
+msgstr "Charger la branche (checkout)"
#: lib/branch_checkout.tcl:23
msgid "Checkout"
-msgstr "Emprunter"
+msgstr "Charger (checkout)"
#: lib/branch_checkout.tcl:27 lib/branch_create.tcl:35
#: lib/branch_delete.tcl:32 lib/branch_rename.tcl:30 lib/browser.tcl:282
-#: lib/checkout_op.tcl:522 lib/choose_font.tcl:43 lib/merge.tcl:171
+#: lib/checkout_op.tcl:544 lib/choose_font.tcl:43 lib/merge.tcl:171
#: lib/option.tcl:103 lib/remote_branch_delete.tcl:42 lib/transport.tcl:97
msgid "Cancel"
msgstr "Annuler"
msgid "Revision"
msgstr "Révision"
-#: lib/branch_checkout.tcl:36 lib/branch_create.tcl:69 lib/option.tcl:242
+#: lib/branch_checkout.tcl:36 lib/branch_create.tcl:69 lib/option.tcl:244
msgid "Options"
msgstr "Options"
#: lib/branch_checkout.tcl:39 lib/branch_create.tcl:92
msgid "Fetch Tracking Branch"
-msgstr "Branche suivant récupération"
+msgstr "Récupérer la branche de suivi"
#: lib/branch_checkout.tcl:44
msgid "Detach From Local Branch"
-msgstr "Détacher de branche locale"
+msgstr "Détacher de la branche locale"
#: lib/branch_create.tcl:22
msgid "Create Branch"
#: lib/branch_create.tcl:66
msgid "Starting Revision"
-msgstr "Début de révision"
+msgstr "Révision initiale"
#: lib/branch_create.tcl:72
msgid "Update Existing Branch:"
#: lib/branch_create.tcl:80
msgid "Fast Forward Only"
-msgstr "Avance rapide seulement"
+msgstr "Mise-à-jour rectiligne seulement (fast-forward)"
-#: lib/branch_create.tcl:85 lib/checkout_op.tcl:514
+#: lib/branch_create.tcl:85 lib/checkout_op.tcl:536
msgid "Reset"
msgstr "Réinitialiser"
#: lib/branch_create.tcl:97
msgid "Checkout After Creation"
-msgstr "Emprunt après création"
+msgstr "Charger (checkout) après création"
#: lib/branch_create.tcl:131
msgid "Please select a tracking branch."
-msgstr "Merci de choisir une branche de suivi"
+msgstr "Choisissez une branche de suivi"
#: lib/branch_create.tcl:140
#, tcl-format
msgid "Tracking branch %s is not a branch in the remote repository."
-msgstr "La branche de suivi %s n'est pas une branche dans le référentiel distant."
+msgstr "La branche de suivi %s n'est pas une branche dans le dépôt distant."
#: lib/branch_create.tcl:153 lib/branch_rename.tcl:86
msgid "Please supply a branch name."
-msgstr "Merci de fournir un nom de branche."
+msgstr "Fournissez un nom de branche."
#: lib/branch_create.tcl:164 lib/branch_rename.tcl:106
#, tcl-format
#: lib/branch_delete.tcl:52
msgid "Delete Only If Merged Into"
-msgstr "Supprimer ssi fusion dedans"
+msgstr "Supprimer seulement si fusionnée dans:"
#: lib/branch_delete.tcl:54
msgid "Always (Do not perform merge test.)"
msgid "Please select a branch to rename."
msgstr "Merci de sélectionner une branche à renommer."
-#: lib/branch_rename.tcl:96 lib/checkout_op.tcl:179
+#: lib/branch_rename.tcl:96 lib/checkout_op.tcl:201
#, tcl-format
msgid "Branch '%s' already exists."
msgstr "La branche '%s' existe déjà."
#: lib/branch_rename.tcl:117
#, tcl-format
msgid "Failed to rename '%s'."
-msgstr "Le renommage de '%s' a échoué."
+msgstr "Échec pour renommer '%s'."
#: lib/browser.tcl:17
msgid "Starting..."
#: lib/browser.tcl:267 lib/browser.tcl:273
msgid "Browse Branch Files"
-msgstr "Visionner fichiers de branches"
+msgstr "Naviguer dans les fichiers de le branche"
#: lib/browser.tcl:278 lib/choose_repository.tcl:387
-#: lib/choose_repository.tcl:474 lib/choose_repository.tcl:484
-#: lib/choose_repository.tcl:987
+#: lib/choose_repository.tcl:472 lib/choose_repository.tcl:482
+#: lib/choose_repository.tcl:985
msgid "Browse"
-msgstr "Visionner"
+msgstr "Naviguer"
-#: lib/checkout_op.tcl:79
+#: lib/checkout_op.tcl:84
#, tcl-format
msgid "Fetching %s from %s"
msgstr "Récupération de %s à partir de %s"
-#: lib/checkout_op.tcl:127
+#: lib/checkout_op.tcl:132
#, tcl-format
msgid "fatal: Cannot resolve %s"
msgstr "erreur fatale : Impossible de résoudre %s"
-#: lib/checkout_op.tcl:140 lib/console.tcl:81 lib/database.tcl:31
+#: lib/checkout_op.tcl:145 lib/console.tcl:81 lib/database.tcl:31
msgid "Close"
msgstr "Fermer"
-#: lib/checkout_op.tcl:169
+#: lib/checkout_op.tcl:174
#, tcl-format
msgid "Branch '%s' does not exist."
msgstr "La branche '%s' n'existe pas."
-#: lib/checkout_op.tcl:206
+#: lib/checkout_op.tcl:193
+#, tcl-format
+msgid "Failed to configure simplified git-pull for '%s'."
+msgstr "Échec de la configuration simplifiée de git-pull pour '%s'."
+
+#: lib/checkout_op.tcl:228
#, tcl-format
msgid ""
"Branch '%s' already exists.\n"
msgstr ""
"La branche '%s' existe déjà.\n"
"\n"
-"Impossible d'avancer rapidement à %s.\n"
+"Impossible de faire une avance rapide (fast forward) vers %s.\n"
"Une fusion est nécessaire."
-#: lib/checkout_op.tcl:220
+#: lib/checkout_op.tcl:242
#, tcl-format
msgid "Merge strategy '%s' not supported."
msgstr "La stratégie de fusion '%s' n'est pas supportée."
-#: lib/checkout_op.tcl:239
+#: lib/checkout_op.tcl:261
#, tcl-format
msgid "Failed to update '%s'."
msgstr "La mise à jour de '%s' a échouée."
-#: lib/checkout_op.tcl:251
+#: lib/checkout_op.tcl:273
msgid "Staging area (index) is already locked."
-msgstr "L'espace de pré-commit ('index' ou 'staging') est déjà vérouillé."
+msgstr "L'index (staging area) est déjà vérouillé"
-#: lib/checkout_op.tcl:266
+#: lib/checkout_op.tcl:288
msgid ""
"Last scanned state does not match repository state.\n"
"\n"
"\n"
"The rescan will be automatically started now.\n"
msgstr ""
-"L'état lors de la dernière synchronisation ne correspond plus à l'état du référentiel.\n"
+"L'état lors de la dernière synchronisation ne correspond plus à l'état du "
+"dépôt\n"
"\n"
-"Un autre programme Git a modifié ce référentiel depuis la dernière synchronisation. Une resynchronisation doit être effectuée avant de pouvoir modifier la branche courante.\n"
+"Un autre programme Git a modifié ce dépôt depuis la dernière "
+"synchronisation. Une resynchronisation doit être effectuée avant de pouvoir "
+"modifier la branche courante.\n"
"\n"
"Cela va être fait tout de suite automatiquement.\n"
-#: lib/checkout_op.tcl:322
+#: lib/checkout_op.tcl:344
#, tcl-format
msgid "Updating working directory to '%s'..."
msgstr "Mise à jour du répertoire courant avec '%s'..."
-#: lib/checkout_op.tcl:323
+#: lib/checkout_op.tcl:345
msgid "files checked out"
-msgstr "fichiers empruntés"
+msgstr "fichiers chargés"
-#: lib/checkout_op.tcl:353
+#: lib/checkout_op.tcl:375
#, tcl-format
msgid "Aborted checkout of '%s' (file level merging is required)."
-msgstr "Emprunt de '%s' abandonné. (Il est nécessaire de fusionner des fichiers.)"
+msgstr "Chargement de '%s' abandonné (il est nécessaire de fusionner des fichiers)."
-#: lib/checkout_op.tcl:354
+#: lib/checkout_op.tcl:376
msgid "File level merge required."
msgstr "Il est nécessaire de fusionner des fichiers."
-#: lib/checkout_op.tcl:358
+#: lib/checkout_op.tcl:380
#, tcl-format
msgid "Staying on branch '%s'."
msgstr "Le répertoire de travail reste sur la branche '%s'."
-#: lib/checkout_op.tcl:429
+#: lib/checkout_op.tcl:451
msgid ""
"You are no longer on a local branch.\n"
"\n"
"Si vous vouliez être sur une branche, créez en une maintenant en partant de "
"'Cet emprunt détaché'."
-#: lib/checkout_op.tcl:446 lib/checkout_op.tcl:450
+#: lib/checkout_op.tcl:468 lib/checkout_op.tcl:472
#, tcl-format
msgid "Checked out '%s'."
-msgstr "'%s' emprunté."
+msgstr "'%s' chargé."
-#: lib/checkout_op.tcl:478
+#: lib/checkout_op.tcl:500
#, tcl-format
msgid "Resetting '%s' to '%s' will lose the following commits:"
msgstr "Réinitialiser '%s' à '%s' va faire perdre les commits suivants :"
-#: lib/checkout_op.tcl:500
+#: lib/checkout_op.tcl:522
msgid "Recovering lost commits may not be easy."
msgstr "Récupérer les commits perdus ne sera peut être pas facile."
-#: lib/checkout_op.tcl:505
+#: lib/checkout_op.tcl:527
#, tcl-format
msgid "Reset '%s'?"
msgstr "Réinitialiser '%s' ?"
-#: lib/checkout_op.tcl:510 lib/merge.tcl:163
+#: lib/checkout_op.tcl:532 lib/merge.tcl:163
msgid "Visualize"
msgstr "Visualiser"
-#: lib/checkout_op.tcl:578
+#: lib/checkout_op.tcl:600
#, tcl-format
msgid ""
"Failed to set current branch.\n"
#: lib/choose_font.tcl:53
msgid "Font Family"
-msgstr "Famille de fonte"
+msgstr "Familles de polices"
#: lib/choose_font.tcl:74
msgid "Font Size"
-msgstr "Taille de fonte"
+msgstr "Taille de police"
#: lib/choose_font.tcl:91
msgid "Font Example"
-msgstr "Exemple de fonte"
+msgstr "Exemple de police"
#: lib/choose_font.tcl:103
msgid ""
"If you like this text, it can be your font."
msgstr ""
"C'est un texte d'exemple.\n"
-"Si vous aimez ce texte, vous pouvez choisir cette fonte."
+"Si vous aimez ce texte, vous pouvez choisir cette police"
#: lib/choose_repository.tcl:28
msgid "Git Gui"
#: lib/choose_repository.tcl:81 lib/choose_repository.tcl:376
msgid "Create New Repository"
-msgstr "Créer nouveau référentiel"
+msgstr "Créer nouveau dépôt"
#: lib/choose_repository.tcl:87
msgid "New..."
msgstr "Nouveau..."
-#: lib/choose_repository.tcl:94 lib/choose_repository.tcl:460
+#: lib/choose_repository.tcl:94 lib/choose_repository.tcl:458
msgid "Clone Existing Repository"
-msgstr "Cloner référentiel existant"
+msgstr "Cloner dépôt existant"
#: lib/choose_repository.tcl:100
msgid "Clone..."
msgstr "Cloner..."
-#: lib/choose_repository.tcl:107 lib/choose_repository.tcl:976
+#: lib/choose_repository.tcl:107 lib/choose_repository.tcl:974
msgid "Open Existing Repository"
-msgstr "Ouvrir référentiel existant"
+msgstr "Ouvrir dépôt existant"
#: lib/choose_repository.tcl:113
msgid "Open..."
#: lib/choose_repository.tcl:126
msgid "Recent Repositories"
-msgstr "Référentiels récents"
+msgstr "Dépôt récemment utilisés"
#: lib/choose_repository.tcl:132
msgid "Open Recent Repository:"
-msgstr "Ouvrir référentiel récent :"
+msgstr "Ouvrir dépôt récent :"
#: lib/choose_repository.tcl:296 lib/choose_repository.tcl:303
#: lib/choose_repository.tcl:310
#, tcl-format
msgid "Failed to create repository %s:"
-msgstr "La création du référentiel %s a échouée :"
+msgstr "La création du dépôt %s a échouée :"
-#: lib/choose_repository.tcl:381 lib/choose_repository.tcl:478
+#: lib/choose_repository.tcl:381 lib/choose_repository.tcl:476
msgid "Directory:"
msgstr "Répertoire :"
-#: lib/choose_repository.tcl:412 lib/choose_repository.tcl:537
-#: lib/choose_repository.tcl:1011
+#: lib/choose_repository.tcl:410 lib/choose_repository.tcl:535
+#: lib/choose_repository.tcl:1007
msgid "Git Repository"
-msgstr "Référentiel Git"
+msgstr "Dépôt Git"
-#: lib/choose_repository.tcl:437
+#: lib/choose_repository.tcl:435
#, tcl-format
msgid "Directory %s already exists."
msgstr "Le répertoire %s existe déjà."
-#: lib/choose_repository.tcl:441
+#: lib/choose_repository.tcl:439
#, tcl-format
msgid "File %s already exists."
msgstr "Le fichier %s existe déjà."
-#: lib/choose_repository.tcl:455
+#: lib/choose_repository.tcl:453
msgid "Clone"
msgstr "Cloner"
-#: lib/choose_repository.tcl:468
+#: lib/choose_repository.tcl:466
msgid "URL:"
msgstr "URL :"
-#: lib/choose_repository.tcl:489
+#: lib/choose_repository.tcl:487
msgid "Clone Type:"
msgstr "Type de clonage :"
-#: lib/choose_repository.tcl:495
+#: lib/choose_repository.tcl:493
msgid "Standard (Fast, Semi-Redundant, Hardlinks)"
msgstr "Standard (rapide, semi-redondant, liens durs)"
-#: lib/choose_repository.tcl:501
+#: lib/choose_repository.tcl:499
msgid "Full Copy (Slower, Redundant Backup)"
msgstr "Copy complète (plus lent, sauvegarde redondante)"
-#: lib/choose_repository.tcl:507
+#: lib/choose_repository.tcl:505
msgid "Shared (Fastest, Not Recommended, No Backup)"
msgstr "Partagé (le plus rapide, non recommandé, pas de sauvegarde)"
-#: lib/choose_repository.tcl:543 lib/choose_repository.tcl:590
-#: lib/choose_repository.tcl:736 lib/choose_repository.tcl:806
-#: lib/choose_repository.tcl:1017 lib/choose_repository.tcl:1025
+#: lib/choose_repository.tcl:541 lib/choose_repository.tcl:588
+#: lib/choose_repository.tcl:734 lib/choose_repository.tcl:804
+#: lib/choose_repository.tcl:1013 lib/choose_repository.tcl:1021
#, tcl-format
msgid "Not a Git repository: %s"
-msgstr "'%s' n'est pas un référentiel Git."
+msgstr "'%s' n'est pas un dépôt Git."
-#: lib/choose_repository.tcl:579
+#: lib/choose_repository.tcl:577
msgid "Standard only available for local repository."
-msgstr "Standard n'est disponible que pour un référentiel local."
+msgstr "Standard n'est disponible que pour un dépôt local."
-#: lib/choose_repository.tcl:583
+#: lib/choose_repository.tcl:581
msgid "Shared only available for local repository."
-msgstr "Partagé n'est disponible que pour un référentiel local."
+msgstr "Partagé n'est disponible que pour un dépôt local."
-#: lib/choose_repository.tcl:604
+#: lib/choose_repository.tcl:602
#, tcl-format
msgid "Location %s already exists."
msgstr "L'emplacement %s existe déjà."
-#: lib/choose_repository.tcl:615
+#: lib/choose_repository.tcl:613
msgid "Failed to configure origin"
msgstr "La configuration de l'origine a échouée."
-#: lib/choose_repository.tcl:627
+#: lib/choose_repository.tcl:625
msgid "Counting objects"
-msgstr "Comptage des objets"
+msgstr "Décompte des objets"
-#: lib/choose_repository.tcl:628
+#: lib/choose_repository.tcl:626
msgid "buckets"
msgstr "paniers"
-#: lib/choose_repository.tcl:652
+#: lib/choose_repository.tcl:650
#, tcl-format
msgid "Unable to copy objects/info/alternates: %s"
msgstr "Impossible de copier 'objects/info/alternates' : %s"
-#: lib/choose_repository.tcl:688
+#: lib/choose_repository.tcl:686
#, tcl-format
msgid "Nothing to clone from %s."
msgstr "Il n'y a rien à cloner depuis %s."
-#: lib/choose_repository.tcl:690 lib/choose_repository.tcl:904
-#: lib/choose_repository.tcl:916
+#: lib/choose_repository.tcl:688 lib/choose_repository.tcl:902
+#: lib/choose_repository.tcl:914
msgid "The 'master' branch has not been initialized."
-msgstr "Cette branche 'master' n'a pas été initialisée."
+msgstr "La branche 'master' n'a pas été initialisée."
-#: lib/choose_repository.tcl:703
+#: lib/choose_repository.tcl:701
msgid "Hardlinks are unavailable. Falling back to copying."
-msgstr "Les liens durs ne sont pas disponibles. On se résoud à copier."
+msgstr "Les liens durs ne sont pas supportés. Une copie sera effectuée à la place."
-#: lib/choose_repository.tcl:715
+#: lib/choose_repository.tcl:713
#, tcl-format
msgid "Cloning from %s"
msgstr "Clonage depuis %s"
-#: lib/choose_repository.tcl:746
+#: lib/choose_repository.tcl:744
msgid "Copying objects"
msgstr "Copie des objets"
-#: lib/choose_repository.tcl:747
+#: lib/choose_repository.tcl:745
msgid "KiB"
msgstr "KiB"
-#: lib/choose_repository.tcl:771
+#: lib/choose_repository.tcl:769
#, tcl-format
msgid "Unable to copy object: %s"
msgstr "Impossible de copier l'objet : %s"
-#: lib/choose_repository.tcl:781
+#: lib/choose_repository.tcl:779
msgid "Linking objects"
msgstr "Liaison des objets"
-#: lib/choose_repository.tcl:782
+#: lib/choose_repository.tcl:780
msgid "objects"
msgstr "objets"
-#: lib/choose_repository.tcl:790
+#: lib/choose_repository.tcl:788
#, tcl-format
msgid "Unable to hardlink object: %s"
msgstr "Impossible créer un lien dur pour l'objet : %s"
-#: lib/choose_repository.tcl:845
+#: lib/choose_repository.tcl:843
msgid "Cannot fetch branches and objects. See console output for details."
msgstr ""
"Impossible de récupérer les branches et objets. Voir la sortie console pour "
"plus de détails."
-#: lib/choose_repository.tcl:856
+#: lib/choose_repository.tcl:854
msgid "Cannot fetch tags. See console output for details."
msgstr ""
-"Impossible de récupérer les marques. Voir la sortie console pour plus de "
-"détails."
+"Impossible de récupérer les marques (tags). Voir la sortie console pour plus "
+"de détails."
-#: lib/choose_repository.tcl:880
+#: lib/choose_repository.tcl:878
msgid "Cannot determine HEAD. See console output for details."
msgstr "Impossible de déterminer HEAD. Voir la sortie console pour plus de détails."
-#: lib/choose_repository.tcl:889
+#: lib/choose_repository.tcl:887
#, tcl-format
msgid "Unable to cleanup %s"
msgstr "Impossible de nettoyer %s"
-#: lib/choose_repository.tcl:895
+#: lib/choose_repository.tcl:893
msgid "Clone failed."
msgstr "Le clonage a échoué."
-#: lib/choose_repository.tcl:902
+#: lib/choose_repository.tcl:900
msgid "No default branch obtained."
msgstr "Aucune branche par défaut n'a été obtenue."
-#: lib/choose_repository.tcl:913
+#: lib/choose_repository.tcl:911
#, tcl-format
msgid "Cannot resolve %s as a commit."
msgstr "Impossible de résoudre %s comme commit."
-#: lib/choose_repository.tcl:925
+#: lib/choose_repository.tcl:923
msgid "Creating working directory"
msgstr "Création du répertoire de travail"
-#: lib/choose_repository.tcl:926 lib/index.tcl:65 lib/index.tcl:127
+#: lib/choose_repository.tcl:924 lib/index.tcl:65 lib/index.tcl:127
#: lib/index.tcl:193
msgid "files"
msgstr "fichiers"
-#: lib/choose_repository.tcl:955
+#: lib/choose_repository.tcl:953
msgid "Initial file checkout failed."
-msgstr "L'emprunt initial de fichier a échoué."
+msgstr "Chargement initial du fichier échoué."
-#: lib/choose_repository.tcl:971
+#: lib/choose_repository.tcl:969
msgid "Open"
msgstr "Ouvrir"
-#: lib/choose_repository.tcl:981
+#: lib/choose_repository.tcl:979
msgid "Repository:"
-msgstr "Référentiel :"
+msgstr "Dépôt :"
-#: lib/choose_repository.tcl:1031
+#: lib/choose_repository.tcl:1027
#, tcl-format
msgid "Failed to open repository %s:"
-msgstr "Impossible d'ouvrir le référentiel %s :"
+msgstr "Impossible d'ouvrir le dépôt %s :"
#: lib/choose_rev.tcl:53
msgid "This Detached Checkout"
#: lib/choose_rev.tcl:79
msgid "Tracking Branch"
-msgstr "Suivi de branche"
+msgstr "Branche de suivi"
#: lib/choose_rev.tcl:84 lib/choose_rev.tcl:538
msgid "Tag"
-msgstr "Marque"
+msgstr "Marque (tag)"
#: lib/choose_rev.tcl:317
#, tcl-format
#: lib/choose_rev.tcl:531
msgid "Updated"
-msgstr "Misa à jour"
+msgstr "Mise-à-jour:"
#: lib/choose_rev.tcl:559
msgid "URL"
"The rescan will be automatically started now.\n"
msgstr ""
"L'état lors de la dernière synchronisation ne correspond plus à l'état du "
-"référentiel.\n"
+"dépôt.\n"
"\n"
-"Un autre programme Git a modifié ce référentiel depuis la dernière "
+"Un autre programme Git a modifié ce dépôt depuis la dernière "
"synchronisation. Une resynshronisation doit être effectuée avant de pouvoir "
"créer un nouveau commit.\n"
"\n"
msgstr ""
"Pas de modification à commiter.\n"
"\n"
-"Vous devez pré-commiter au moins 1 fichier avant de pouvoir commiter.\n"
+"Vous devez indexer au moins 1 fichier avant de pouvoir commiter.\n"
#: lib/commit.tcl:183
msgid ""
#: lib/commit.tcl:221
msgid "Calling pre-commit hook..."
-msgstr "Appel du programme externe d'avant commit..."
+msgstr "Lancement de l'action d'avant-commit..."
#: lib/commit.tcl:236
msgid "Commit declined by pre-commit hook."
-msgstr "Commit refusé par le programme externe d'avant commit."
+msgstr "Commit refusé par l'action d'avant-commit."
#: lib/commit.tcl:259
msgid "Calling commit-msg hook..."
-msgstr "Appel du programme externe de message de commit..."
+msgstr "Lancement de l'action \"message de commit\"..."
#: lib/commit.tcl:274
msgid "Commit declined by commit-msg hook."
-msgstr "Commit refusé par le programme externe de message de commit."
+msgstr "Commit refusé par l'action \"message de commit\"."
#: lib/commit.tcl:287
msgid "Committing changes..."
"\n"
"Compress the database now?"
msgstr ""
-"Ce référentiel comprend actuellement environ %i objets ayant leur fichier "
+"Ce dépôt comprend actuellement environ %i objets ayant leur fichier "
"particulier.\n"
"\n"
"Pour conserver une performance optimale, il est fortement recommandé de "
msgid "Invalid date from Git: %s"
msgstr "Date invalide de Git : %s"
-#: lib/diff.tcl:42
+#: lib/diff.tcl:44
#, tcl-format
msgid ""
"No differences detected.\n"
"Une resynchronisation va être lancée automatiquement pour trouver d'autres "
"fichiers qui pourraient se trouver dans le même état."
-#: lib/diff.tcl:81
+#: lib/diff.tcl:83
#, tcl-format
msgid "Loading diff of %s..."
msgstr "Chargement des différences de %s..."
-#: lib/diff.tcl:114 lib/diff.tcl:184
+#: lib/diff.tcl:116 lib/diff.tcl:190
#, tcl-format
msgid "Unable to display %s"
msgstr "Impossible d'afficher %s"
-#: lib/diff.tcl:115
+#: lib/diff.tcl:117
msgid "Error loading file:"
msgstr "Erreur lors du chargement du fichier :"
-#: lib/diff.tcl:122
+#: lib/diff.tcl:124
msgid "Git Repository (subproject)"
-msgstr "Référentiel Git (sous projet)"
+msgstr "Dépôt Git (sous projet)"
-#: lib/diff.tcl:134
+#: lib/diff.tcl:136
msgid "* Binary file (not showing content)."
msgstr "* Fichier binaire (pas d'apperçu du contenu)."
-#: lib/diff.tcl:185
+#: lib/diff.tcl:191
msgid "Error loading diff:"
msgstr "Erreur lors du chargement des différences :"
-#: lib/diff.tcl:303
+#: lib/diff.tcl:313
msgid "Failed to unstage selected hunk."
-msgstr "La suppression dans le pré-commit de la section sélectionnée a échouée."
+msgstr "Échec lors de la désindexation de la section sélectionnée."
-#: lib/diff.tcl:310
+#: lib/diff.tcl:320
msgid "Failed to stage selected hunk."
-msgstr "Le pré-commit de la section sélectionnée a échoué."
+msgstr "Échec lors de l'indexation de la section."
+
+#: lib/diff.tcl:386
+msgid "Failed to unstage selected line."
+msgstr "Échec lors de la désindexation de la ligne sélectionnée."
+
+#: lib/diff.tcl:394
+msgid "Failed to stage selected line."
+msgstr "Échec lors de l'indexation de la ligne."
#: lib/error.tcl:20 lib/error.tcl:114
msgid "error"
#: lib/index.tcl:6
msgid "Unable to unlock the index."
-msgstr "Impossible de dévérouiller le pré-commit."
+msgstr "Impossible de dévérouiller l'index."
#: lib/index.tcl:15
msgid "Index Error"
-msgstr "Erreur de pré-commit"
+msgstr "Erreur de l'index"
#: lib/index.tcl:21
msgid ""
"Updating the Git index failed. A rescan will be automatically started to "
"resynchronize git-gui."
-msgstr "Le pré-commit a échoué. Une resynchronisation va être lancée automatiquement."
+msgstr ""
+"Échec de la mise à jour de l'index. Une resynchronisation va être lancée "
+"automatiquement."
#: lib/index.tcl:27
msgid "Continue"
#: lib/index.tcl:31
msgid "Unlock Index"
-msgstr "Dévérouiller le pré-commit"
+msgstr "Déverouiller l'index"
#: lib/index.tcl:282
#, tcl-format
msgid "Unstaging %s from commit"
-msgstr "Supprimer %s du commit"
+msgstr "Désindexation de: %s"
#: lib/index.tcl:313
msgid "Ready to commit."
#: lib/index.tcl:326
#, tcl-format
msgid "Adding %s"
-msgstr "Ajouter %s"
+msgstr "Ajout de %s"
#: lib/index.tcl:381
#, tcl-format
msgid "Revert changes in file %s?"
-msgstr "Inverser les modifications dans le fichier %s ? "
+msgstr "Annuler les modifications dans le fichier %s ? "
#: lib/index.tcl:383
#, tcl-format
msgid "Revert changes in these %i files?"
-msgstr "Inverser les modifications dans ces %i fichiers ?"
+msgstr "Annuler les modifications dans ces %i fichiers ?"
#: lib/index.tcl:391
msgid "Any unstaged changes will be permanently lost by the revert."
msgstr ""
-"Toutes les modifications non pré-commitées seront définitivement perdues "
-"lors de l'inversion."
+"Toutes les modifications non-indexées seront définitivement perdues par "
+"l'annulation."
#: lib/index.tcl:394
msgid "Do Nothing"
"\n"
"You must finish amending this commit before starting any type of merge.\n"
msgstr ""
-"Impossible de fucionner pendant une correction.\n"
+"Impossible de fusionner pendant une correction.\n"
"\n"
"Vous devez finir de corriger ce commit avant de lancer une quelconque "
"fusion.\n"
"The rescan will be automatically started now.\n"
msgstr ""
"L'état lors de la dernière synchronisation ne correspond plus à l'état du "
-"référentiel.\n"
+"dépôt.\n"
"\n"
-"Un autre programme Git a modifié ce référentiel depuis la dernière "
+"Un autre programme Git a modifié ce dépôt depuis la dernière "
"synchronisation. Une resynchronisation doit être effectuée avant de pouvoir "
"fusionner de nouveau.\n"
"\n"
"\n"
"Le fichier %s a des conflicts de fusion.\n"
"\n"
-"Vous devez les résoudre, puis pré-commiter le fichier, et enfin commiter "
-"pour terminer la fusion courante. Seulementà ce moment là, il sera possible "
+"Vous devez les résoudre, puis indexer le fichier, et enfin commiter pour "
+"terminer la fusion courante. Seulement à ce moment là sera-t-il possible "
"d'effectuer une nouvelle fusion.\n"
#: lib/merge.tcl:54
msgid "files reset"
msgstr "fichiers réinitialisés"
-#: lib/merge.tcl:265
+#: lib/merge.tcl:266
msgid "Abort failed."
msgstr "L'abandon a échoué."
-#: lib/merge.tcl:267
+#: lib/merge.tcl:268
msgid "Abort completed. Ready."
msgstr "Abandon teminé. Prêt."
#: lib/option.tcl:109
#, tcl-format
msgid "%s Repository"
-msgstr "Référentiel de %s"
+msgstr "Dépôt: %s"
#: lib/option.tcl:110
msgid "Global (All Repositories)"
-msgstr "Globales (tous les référentiels)"
+msgstr "Globales (tous les dépôts)"
#: lib/option.tcl:116
msgid "User Name"
#: lib/option.tcl:124
msgid "Prune Tracking Branches During Fetch"
-msgstr "Nettoyer les branches de suivi pendant la récupération"
+msgstr "Purger les branches de suivi pendant la récupération"
#: lib/option.tcl:125
msgid "Match Tracking Branches"
msgstr "Faire correspondre les branches de suivi"
#: lib/option.tcl:126
+msgid "Blame Copy Only On Changed Files"
+msgstr "Annoter les copies seulement sur fichiers modifiés"
+
+#: lib/option.tcl:127
+msgid "Minimum Letters To Blame Copy On"
+msgstr "Minimum de caratères pour annoter une copie"
+
+#: lib/option.tcl:128
msgid "Number of Diff Context Lines"
msgstr "Nombre de lignes de contexte dans les diffs"
-#: lib/option.tcl:127
+#: lib/option.tcl:129
msgid "Commit Message Text Width"
msgstr "Largeur du texte de message de commit"
-#: lib/option.tcl:128
+#: lib/option.tcl:130
msgid "New Branch Name Template"
msgstr "Nouveau modèle de nom de branche"
-#: lib/option.tcl:192
+#: lib/option.tcl:194
msgid "Spelling Dictionary:"
msgstr "Dictionnaire d'orthographe :"
-#: lib/option.tcl:216
+#: lib/option.tcl:218
msgid "Change Font"
-msgstr "Modifier les fontes"
+msgstr "Modifier les polices"
-#: lib/option.tcl:220
+#: lib/option.tcl:222
#, tcl-format
msgid "Choose %s"
msgstr "Choisir %s"
-#: lib/option.tcl:226
+#: lib/option.tcl:228
msgid "pt."
msgstr "pt."
-#: lib/option.tcl:240
+#: lib/option.tcl:242
msgid "Preferences"
msgstr "Préférences"
-#: lib/option.tcl:275
+#: lib/option.tcl:277
msgid "Failed to completely save options:"
msgstr "La sauvegarde complète des options a échouée :"
+#: lib/remote.tcl:165
+msgid "Prune from"
+msgstr "Purger de"
+
+#: lib/remote.tcl:170
+msgid "Fetch from"
+msgstr "Récupérer de"
+
+#: lib/remote.tcl:213
+msgid "Push to"
+msgstr "Pousser vers"
+
#: lib/remote_branch_delete.tcl:29 lib/remote_branch_delete.tcl:34
msgid "Delete Remote Branch"
msgstr "Supprimer branche distante"
#: lib/remote_branch_delete.tcl:47
msgid "From Repository"
-msgstr "Référentiel"
+msgstr "Dépôt source"
#: lib/remote_branch_delete.tcl:50 lib/transport.tcl:123
msgid "Remote:"
#: lib/remote_branch_delete.tcl:286
msgid "No repository selected."
-msgstr "Aucun référentiel n'est sélectionné."
+msgstr "Aucun dépôt n'est sélectionné."
#: lib/remote_branch_delete.tcl:291
#, tcl-format
msgid "Scanning %s..."
msgstr "Synchronisation de %s..."
-#: lib/remote.tcl:165
-msgid "Prune from"
-msgstr "Nettoyer de"
-
-#: lib/remote.tcl:170
-msgid "Fetch from"
-msgstr "Récupérer de"
-
-#: lib/remote.tcl:213
-msgid "Push to"
-msgstr "Pousser vers"
-
#: lib/shortcut.tcl:20 lib/shortcut.tcl:61
msgid "Cannot write shortcut:"
msgstr "Impossible d'écrire le raccourcis :"
msgid "Unrecognized spell checker"
msgstr "Vérificateur d'orthographe non reconnu"
-#: lib/spellcheck.tcl:180
+#: lib/spellcheck.tcl:186
msgid "No Suggestions"
msgstr "Aucune suggestion"
-#: lib/spellcheck.tcl:381
+#: lib/spellcheck.tcl:387
msgid "Unexpected EOF from spell checker"
-msgstr "Fin de fichier innatendue envoyée par le vérificateur d'orthographe"
+msgstr "EOF inattendue envoyée par le vérificateur d'orthographe"
-#: lib/spellcheck.tcl:385
+#: lib/spellcheck.tcl:391
msgid "Spell Checker Failed"
msgstr "Le vérificateur d'orthographe a échoué"
#: lib/transport.tcl:18
#, tcl-format
msgid "remote prune %s"
-msgstr "nettoyer à distance %s"
+msgstr "purger à distance %s"
#: lib/transport.tcl:19
#, tcl-format
#: lib/transport.tcl:120
msgid "Destination Repository"
-msgstr "Référentiel de destination"
+msgstr "Dépôt de destination"
#: lib/transport.tcl:158
msgid "Transfer Options"
-msgstr "Transférer options"
+msgstr "Options de transfert"
#: lib/transport.tcl:160
msgid "Force overwrite existing branch (may discard changes)"
#: lib/transport.tcl:168
msgid "Include tags"
-msgstr "Inclure les marques"
+msgstr "Inclure les marques (tags)"
foreach i [split $s ""] {
scan $i %c c
if {$c<128} {
- # escape '[', '\' and ']'
- if {$c == 0x5b || $c == 0x5d} {
+ # escape '[', '\', '$' and ']'
+ if {$c == 0x5b || $c == 0x5d || $c == 0x24} {
append res "\\"
}
append res $i
create_stash () {
stash_msg="$1"
+ git update-index -q --refresh
if no_changes
then
exit 0
stash_msg="$*"
+ git update-index -q --refresh
if no_changes
then
echo 'No local changes to save'
}
apply_stash () {
+ git update-index -q --refresh &&
git diff-files --quiet --ignore-submodules ||
die 'Cannot restore on top of a dirty state'
{ "count-objects", cmd_count_objects, RUN_SETUP },
{ "describe", cmd_describe, RUN_SETUP },
{ "diff", cmd_diff },
- { "diff-files", cmd_diff_files, RUN_SETUP },
+ { "diff-files", cmd_diff_files, RUN_SETUP | NEED_WORK_TREE },
{ "diff-index", cmd_diff_index, RUN_SETUP },
{ "diff-tree", cmd_diff_tree, RUN_SETUP },
{ "fast-export", cmd_fast_export, RUN_SETUP },
int found;
if (pos >= active_nr)
- die("git-merge-index: %s not in the cache", path);
+ die("git merge-index: %s not in the cache", path);
arguments[0] = pgm;
arguments[1] = "";
arguments[2] = "";
arguments[stage + 4] = ownbuf[stage];
} while (++pos < active_nr);
if (!found)
- die("git-merge-index: %s not in the cache", path);
+ die("git merge-index: %s not in the cache", path);
run_program();
return found;
}
merge_all();
continue;
}
- die("git-merge-index: unknown option %s", arg);
+ die("git merge-index: unknown option %s", arg);
}
merge_file(arg);
}
} while (lo < hi);
die("internal error: pack revindex corrupt");
}
+
+void discard_revindex(void)
+{
+ if (pack_revindex_hashsz) {
+ int i;
+ for (i = 0; i < pack_revindex_hashsz; i++)
+ if (pack_revindex[i].revindex)
+ free(pack_revindex[i].revindex);
+ free(pack_revindex);
+ pack_revindex_hashsz = 0;
+ }
+}
};
struct revindex_entry *find_pack_revindex(struct packed_git *p, off_t ofs);
+void discard_revindex(void);
#endif
if (retval && chdir(retval))
die ("Could not jump back into original cwd");
rel = get_relative_cwd(buffer, PATH_MAX, get_git_work_tree());
+ if (rel && *rel && chdir(get_git_work_tree()))
+ die ("Could not jump to working directory");
return rel && *rel ? strcat(rel, "/") : NULL;
}
void reprepare_packed_git(void)
{
+ discard_revindex();
prepare_packed_git_run_once = 0;
prepare_packed_git();
}
#include "exec_cmd.h"
#include "strbuf.h"
-/* Stubs for functions that make no sense for git-shell. These stubs
- * are provided here to avoid linking in external redundant modules.
- */
-void release_pack_memory(size_t need, int fd){}
-void trace_argv_printf(const char **argv, const char *fmt, ...){}
-void trace_printf(const char *fmt, ...){}
-
-
static int do_generic_cmd(const char *me, char *arg)
{
const char *my_argv[4];
unsigned sf;
char buf[LARGE_PACKET_MAX + 2*FIX_SIZE];
char *suffix, *term;
+ int skip_pf = 0;
memcpy(buf, PREFIX, pf);
term = getenv("TERM");
return SIDEBAND_REMOTE_ERROR;
case 2:
buf[pf] = ' ';
- len += pf+1;
- while (1) {
- int brk = pf+1;
+ do {
+ char *b = buf;
+ int brk = 0;
- /* Break the buffer into separate lines. */
- while (brk < len) {
+ /*
+ * If the last buffer didn't end with a line
+ * break then we should not print a prefix
+ * this time around.
+ */
+ if (skip_pf) {
+ b += pf+1;
+ } else {
+ len += pf+1;
+ brk += pf+1;
+ }
+
+ /* Look for a line break. */
+ for (;;) {
brk++;
- if (buf[brk-1] == '\n' ||
- buf[brk-1] == '\r')
+ if (brk > len) {
+ brk = 0;
+ break;
+ }
+ if (b[brk-1] == '\n' ||
+ b[brk-1] == '\r')
break;
}
/*
* Let's insert a suffix to clear the end
- * of the screen line, but only if current
- * line data actually contains something.
+ * of the screen line if a line break was
+ * found. Also, if we don't skip the
+ * prefix, then a non-empty string must be
+ * present too.
*/
- if (brk > pf+1 + 1) {
+ if (brk > (skip_pf ? 0 : (pf+1 + 1))) {
char save[FIX_SIZE];
- memcpy(save, buf + brk, sf);
- buf[brk + sf - 1] = buf[brk - 1];
- memcpy(buf + brk - 1, suffix, sf);
- safe_write(err, buf, brk + sf);
- memcpy(buf + brk, save, sf);
- } else
- safe_write(err, buf, brk);
+ memcpy(save, b + brk, sf);
+ b[brk + sf - 1] = b[brk - 1];
+ memcpy(b + brk - 1, suffix, sf);
+ safe_write(err, b, brk + sf);
+ memcpy(b + brk, save, sf);
+ len -= brk;
+ } else {
+ int l = brk ? brk : len;
+ safe_write(err, b, l);
+ len -= l;
+ }
- if (brk < len) {
- memmove(buf + pf+1, buf + brk, len - brk);
- len = len - brk + pf+1;
- } else
- break;
- }
+ skip_pf = !brk;
+ memmove(buf + pf+1, b + brk, len);
+ } while (len);
continue;
case 1:
safe_write(out, buf + pf+1, len);
rm camelcase &&
echo 1 >CamelCase &&
git add CamelCase &&
- test $(git-ls-files | grep -i camelcase | wc -l) = 1
+ test $(git ls-files | grep -i camelcase | wc -l) = 1
'
#!/bin/sh
-test_description="git-hash-object"
+test_description="git hash-object"
. ./test-lib.sh
git tag my-first-tag
test_expect_success 'git tag my-first-tag' 'cmp .git/refs/heads/master .git/refs/tags/my-first-tag'
-# TODO: test git-clone
+# TODO: test git clone
git checkout -b mybranch
test_expect_success 'git checkout -b mybranch' 'cmp .git/refs/heads/master .git/refs/heads/mybranch'
'
SECTION="test.q\"s\\sq'sp e.key"
-test_expect_success 'make sure git-config escapes section names properly' '
+test_expect_success 'make sure git config escapes section names properly' '
git config "$SECTION" bar &&
check "$SECTION" bar
'
'echo TEST >F &&
git add F &&
GIT_AUTHOR_DATE="2005-05-26 23:30" \
- GIT_COMMITTER_DATE="2005-05-26 23:30" git-commit -m add -a &&
+ GIT_COMMITTER_DATE="2005-05-26 23:30" git commit -m add -a &&
h_TEST=$(git rev-parse --verify HEAD)
echo The other day this did not work. >M &&
echo And then Bob told me how to fix it. >>M &&
echo OTHER >F &&
GIT_AUTHOR_DATE="2005-05-26 23:41" \
- GIT_COMMITTER_DATE="2005-05-26 23:41" git-commit -F M -a &&
+ GIT_COMMITTER_DATE="2005-05-26 23:41" git commit -F M -a &&
h_OTHER=$(git rev-parse --verify HEAD) &&
GIT_AUTHOR_DATE="2005-05-26 23:44" \
- GIT_COMMITTER_DATE="2005-05-26 23:44" git-commit --amend &&
+ GIT_COMMITTER_DATE="2005-05-26 23:44" git commit --amend &&
h_FIXED=$(git rev-parse --verify HEAD) &&
echo Merged initial commit and a later commit. >M &&
echo $h_TEST >.git/MERGE_HEAD &&
GIT_AUTHOR_DATE="2005-05-26 23:45" \
- GIT_COMMITTER_DATE="2005-05-26 23:45" git-commit -F M &&
+ GIT_COMMITTER_DATE="2005-05-26 23:45" git commit -F M &&
h_MERGED=$(git rev-parse --verify HEAD) &&
rm -f M'
$h_FIXED $h_MERGED $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117151100 +0000 commit (merge): Merged initial commit and a later commit.
EOF
test_expect_success \
- 'git-commit logged updates' \
+ 'git commit logged updates' \
"diff expect .git/logs/$m"
unset h_TEST h_OTHER h_FIXED h_MERGED
[ $# -eq 0 ] && return
}
+EMPTY_TREE=$(git write-tree)
mkdir -p work/sub/dir || exit 1
mv .git repo.git || exit 1
'
test_expect_success '_gently() groks relative GIT_DIR & GIT_WORK_TREE' '
- cd repo.git/work/sub/dir &&
+ (cd repo.git/work/sub/dir &&
GIT_DIR=../../.. GIT_WORK_TREE=../.. GIT_PAGER= \
git diff --exit-code tracked &&
echo changed > tracked &&
! GIT_DIR=../../.. GIT_WORK_TREE=../.. GIT_PAGER= \
- git diff --exit-code tracked
+ git diff --exit-code tracked)
+'
+cat > diff-index-cached.expected <<\EOF
+:000000 100644 0000000000000000000000000000000000000000 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 A sub/dir/tracked
+EOF
+cat > diff-index.expected <<\EOF
+:000000 100644 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 A sub/dir/tracked
+EOF
+
+
+test_expect_success 'git diff-index' '
+ GIT_DIR=repo.git GIT_WORK_TREE=repo.git/work git diff-index $EMPTY_TREE > result &&
+ test_cmp diff-index.expected result &&
+ GIT_DIR=repo.git git diff-index --cached $EMPTY_TREE > result &&
+ test_cmp diff-index-cached.expected result
+'
+cat >diff-files.expected <<\EOF
+:100644 100644 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 0000000000000000000000000000000000000000 M sub/dir/tracked
+EOF
+
+test_expect_success 'git diff-files' '
+ GIT_DIR=repo.git GIT_WORK_TREE=repo.git/work git diff-files > result &&
+ test_cmp diff-files.expected result
+'
+
+cat >diff-TREE.expected <<\EOF
+diff --git a/sub/dir/tracked b/sub/dir/tracked
+new file mode 100644
+index 0000000..5ea2ed4
+--- /dev/null
++++ b/sub/dir/tracked
+@@ -0,0 +1 @@
++changed
+EOF
+cat >diff-TREE-cached.expected <<\EOF
+diff --git a/sub/dir/tracked b/sub/dir/tracked
+new file mode 100644
+index 0000000..e69de29
+EOF
+cat >diff-FILES.expected <<\EOF
+diff --git a/sub/dir/tracked b/sub/dir/tracked
+index e69de29..5ea2ed4 100644
+--- a/sub/dir/tracked
++++ b/sub/dir/tracked
+@@ -0,0 +1 @@
++changed
+EOF
+
+test_expect_success 'git diff' '
+ GIT_DIR=repo.git GIT_WORK_TREE=repo.git/work git diff $EMPTY_TREE > result &&
+ test_cmp diff-TREE.expected result &&
+ GIT_DIR=repo.git git diff --cached $EMPTY_TREE > result &&
+ test_cmp diff-TREE-cached.expected result &&
+ GIT_DIR=repo.git GIT_WORK_TREE=repo.git/work git diff > result &&
+ test_cmp diff-FILES.expected result
+'
+
+test_expect_success 'git grep' '
+ (cd repo.git/work/sub &&
+ GIT_DIR=../.. GIT_WORK_TREE=.. git grep -l changed | grep -q dir/tracked)
'
test_done
fi
test_tick
- git-commit --quiet -m "$MSG" $_file
+ git commit --quiet -m "$MSG" $_file
}
HASH1=
test_expect_success \
'preparation' '
git config core.symlinks false &&
-l=$(echo -n file | git-hash-object -t blob -w --stdin) &&
+l=$(echo -n file | git hash-object -t blob -w --stdin) &&
echo "120000 $l symlink" | git update-index --index-info'
test_expect_success \
test_expect_success \
'the file must be the blob we added during the setup' '
-test "$(git-hash-object -t blob symlink)" = $l'
+test "$(git hash-object -t blob symlink)" = $l'
test_done
test_expect_success 'post-commit hook used ordinarily' '
echo initial >top &&
-git-add top
-git-commit -m initial &&
+git add top
+git commit -m initial &&
test -r "${COMMIT_FILE}"
'
git ls-files -s >current &&
cmp current expected'
-test_expect_success 'first commit' 'git-commit -m initial'
+test_expect_success 'first commit' 'git commit -m initial'
cat > expected <<\EOF
100644 53ab446c3f4e42ce9bb728a0ccb283a101be4979 0 dir1/file3
test_expect_success \
'preparation' '
git config core.symlinks false &&
-l=$(echo -n file | git-hash-object -t blob -w --stdin) &&
+l=$(echo -n file | git hash-object -t blob -w --stdin) &&
echo "120000 $l symlink" | git update-index --index-info'
test_expect_success \
echo initial >dir2/sub3 &&
git add check dir1 dir2 top foo &&
test_tick
- git-commit -m initial &&
+ git commit -m initial &&
echo changed >check &&
echo changed >top &&
'
test_expect_success 'update noticed a removal' '
- test "$(git-ls-files dir1/sub1)" = ""
+ test "$(git ls-files dir1/sub1)" = ""
'
test_expect_success 'update touched correct path' '
- test "$(git-diff-files --name-status dir2/sub3)" = ""
+ test "$(git diff-files --name-status dir2/sub3)" = ""
'
test_expect_success 'update did not touch other tracked files' '
- test "$(git-diff-files --name-status check)" = "M check" &&
- test "$(git-diff-files --name-status top)" = "M top"
+ test "$(git diff-files --name-status check)" = "M check" &&
+ test "$(git diff-files --name-status top)" = "M top"
'
test_expect_success 'update did not touch untracked files' '
- test "$(git-ls-files dir2/other)" = ""
+ test "$(git ls-files dir2/other)" = ""
'
test_expect_success 'cache tree has not been corrupted' '
# three/
EOF
-test_expect_success 'git-status honours core.excludesfile' \
+test_expect_success 'git status honors core.excludesfile' \
'test_cmp expect output'
test_expect_success 'trailing slash in exclude allows directory match(1)' '
touch foo bar
git update-index --add foo bar
-git-commit -m "add foo bar"
+git commit -m "add foo bar"
test_expect_success \
'git ls-files --error-unmatch should fail with unmatched path.' \
rm -fr [abcd] &&
git checkout -f "$c2" &&
- git-merge-recursive "$c0" -- "$c2" "$c1"
+ git merge-recursive "$c0" -- "$c2" "$c1"
status=$?
case "$status" in
1)
rm -fr [abcd] &&
git checkout -f "$c1" &&
- git-merge-recursive "$c0" -- "$c1" "$c5"
+ git merge-recursive "$c0" -- "$c1" "$c5"
status=$?
case "$status" in
1)
git reset --hard &&
git checkout -f "$c1" &&
- git-merge-recursive "$c0" -- "$c1" "$c3"
+ git merge-recursive "$c0" -- "$c1" "$c3"
'
test_expect_success 'merge-recursive result' '
git reset --hard &&
git checkout -f "$c1" &&
- git-merge-recursive "$c0" -- "$c1" "$c4"
+ git merge-recursive "$c0" -- "$c1" "$c4"
status=$?
case "$status" in
1)
git reset --hard &&
git checkout -f "$c4" &&
- git-merge-recursive "$c0" -- "$c4" "$c1"
+ git merge-recursive "$c0" -- "$c4" "$c1"
status=$?
case "$status" in
1)
git reset --hard &&
git checkout -f "$c1" &&
- git-merge-recursive "$c0" -- "$c1" "$c6"
+ git merge-recursive "$c0" -- "$c1" "$c6"
status=$?
case "$status" in
1)
git reset --hard &&
git checkout -f "$c6" &&
- git-merge-recursive "$c0" -- "$c6" "$c1"
+ git merge-recursive "$c0" -- "$c6" "$c1"
status=$?
case "$status" in
1)
'prepare a trivial repository' \
'echo Hello > A &&
git update-index --add A &&
- git-commit -m "Initial commit." &&
+ git commit -m "Initial commit." &&
echo World >> A &&
git update-index --add A &&
- git-commit -m "Second commit." &&
+ git commit -m "Second commit." &&
HEAD=$(git rev-parse --verify HEAD)'
test_expect_success \
test_expect_success 'test tracking setup via --track' \
'git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --track my1 local/master &&
test $(git config branch.my1.remote) = local &&
test $(git config branch.my1.merge) = refs/heads/master'
test_expect_success 'test tracking setup (non-wildcard, matching)' \
'git config remote.local.url . &&
git config remote.local.fetch refs/heads/master:refs/remotes/local/master &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --track my4 local/master &&
test $(git config branch.my4.remote) = local &&
test $(git config branch.my4.merge) = refs/heads/master'
test_expect_success 'test tracking setup (non-wildcard, not matching)' \
'git config remote.local.url . &&
git config remote.local.fetch refs/heads/s:refs/remotes/local/s &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --track my5 local/master &&
! test "$(git config branch.my5.remote)" = local &&
! test "$(git config branch.my5.merge)" = refs/heads/master'
'git config branch.autosetupmerge true &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch my3 local/master &&
test $(git config branch.my3.remote) = local &&
test $(git config branch.my3.merge) = refs/heads/master'
'git config branch.autosetupmerge true &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track my2 local/master &&
git config branch.autosetupmerge false &&
! test "$(git config branch.my2.remote)" = local &&
test_expect_success 'test tracking setup via --track but deeper' \
'git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/o/o || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/o/o || git fetch local) &&
git branch --track my7 local/o/o &&
test "$(git config branch.my7.remote)" = local &&
test "$(git config branch.my7.merge)" = refs/heads/o/o'
test_expect_success \
'git checkout -b g/h/i -l should create a branch and a log' \
'GIT_COMMITTER_DATE="2005-05-26 23:30" \
- git-checkout -b g/h/i -l master &&
+ git checkout -b g/h/i -l master &&
test -f .git/refs/heads/g/h/i &&
test -f .git/logs/refs/heads/g/h/i &&
diff expect .git/logs/refs/heads/g/h/i'
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
git config branch.autosetuprebase local &&
- (git show-ref -q refs/remotes/local/o || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/o || git fetch local) &&
git branch mybase &&
git branch --track myr1 mybase &&
test "$(git config branch.myr1.remote)" = . &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
git config branch.autosetuprebase always &&
- (git show-ref -q refs/remotes/local/o || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/o || git fetch local) &&
git branch mybase2 &&
git branch --track myr2 mybase &&
test "$(git config branch.myr2.remote)" = . &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
git config branch.autosetuprebase remote &&
- (git show-ref -q refs/remotes/local/o || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/o || git fetch local) &&
git branch mybase3 &&
git branch --track myr3 mybase2 &&
test "$(git config branch.myr3.remote)" = . &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
git config branch.autosetuprebase never &&
- (git show-ref -q refs/remotes/local/o || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/o || git fetch local) &&
git branch mybase4 &&
git branch --track myr4 mybase2 &&
test "$(git config branch.myr4.remote)" = . &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
git config branch.autosetuprebase local &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --track myr5 local/master &&
test "$(git config branch.myr5.remote)" = local &&
test "$(git config branch.myr5.merge)" = refs/heads/master &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
git config branch.autosetuprebase never &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --track myr6 local/master &&
test "$(git config branch.myr6.remote)" = local &&
test "$(git config branch.myr6.merge)" = refs/heads/master &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
git config branch.autosetuprebase remote &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --track myr7 local/master &&
test "$(git config branch.myr7.remote)" = local &&
test "$(git config branch.myr7.merge)" = refs/heads/master &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
git config branch.autosetuprebase remote &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --track myr8 local/master &&
test "$(git config branch.myr8.remote)" = local &&
test "$(git config branch.myr8.merge)" = refs/heads/master &&
git config --unset branch.autosetuprebase &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --track myr9 local/master &&
test "$(git config branch.myr9.remote)" = local &&
test "$(git config branch.myr9.merge)" = refs/heads/master &&
test_expect_success 'autosetuprebase unconfigured on a tracked local branch' '
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/o || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/o || git fetch local) &&
git branch mybase10 &&
git branch --track myr10 mybase2 &&
test "$(git config branch.myr10.remote)" = . &&
test_expect_success 'autosetuprebase unconfigured on untracked local branch' '
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr11 mybase2 &&
test "z$(git config branch.myr11.remote)" = z &&
test "z$(git config branch.myr11.merge)" = z &&
test_expect_success 'autosetuprebase unconfigured on untracked remote branch' '
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr12 local/master &&
test "z$(git config branch.myr12.remote)" = z &&
test "z$(git config branch.myr12.merge)" = z &&
git config branch.autosetuprebase never &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr13 mybase2 &&
test "z$(git config branch.myr13.remote)" = z &&
test "z$(git config branch.myr13.merge)" = z &&
git config branch.autosetuprebase local &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr14 mybase2 &&
test "z$(git config branch.myr14.remote)" = z &&
test "z$(git config branch.myr14.merge)" = z &&
git config branch.autosetuprebase remote &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr15 mybase2 &&
test "z$(git config branch.myr15.remote)" = z &&
test "z$(git config branch.myr15.merge)" = z &&
git config branch.autosetuprebase always &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr16 mybase2 &&
test "z$(git config branch.myr16.remote)" = z &&
test "z$(git config branch.myr16.merge)" = z &&
git config branch.autosetuprebase never &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr17 local/master &&
test "z$(git config branch.myr17.remote)" = z &&
test "z$(git config branch.myr17.merge)" = z &&
git config branch.autosetuprebase local &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr18 local/master &&
test "z$(git config branch.myr18.remote)" = z &&
test "z$(git config branch.myr18.merge)" = z &&
git config branch.autosetuprebase remote &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr19 local/master &&
test "z$(git config branch.myr19.remote)" = z &&
test "z$(git config branch.myr19.merge)" = z &&
git config branch.autosetuprebase always &&
git config remote.local.url . &&
git config remote.local.fetch refs/heads/*:refs/remotes/local/* &&
- (git show-ref -q refs/remotes/local/master || git-fetch local) &&
+ (git show-ref -q refs/remotes/local/master || git fetch local) &&
git branch --no-track myr20 local/master &&
test "z$(git config branch.myr20.remote)" = z &&
test "z$(git config branch.myr20.merge)" = z &&
'prepare a trivial repository' \
'echo Hello > A &&
git update-index --add A &&
- git-commit -m "Initial commit." &&
+ git commit -m "Initial commit." &&
HEAD=$(git rev-parse --verify HEAD)'
SHA1=
git branch n'
test_expect_success 'pack, prune and repack' '
- git-tag foo &&
+ git tag foo &&
git pack-refs --all --prune &&
git show-ref >all-of-them &&
git pack-refs &&
'prepare repository with topic branches' \
'echo First > A &&
git update-index --add A &&
- git-commit -m "Add A." &&
+ git commit -m "Add A." &&
git checkout -b my-topic-branch &&
echo Second > B &&
git update-index --add B &&
- git-commit -m "Add B." &&
+ git commit -m "Add B." &&
git checkout -f master &&
echo Third >> A &&
git update-index A &&
- git-commit -m "Modify A." &&
+ git commit -m "Modify A." &&
git checkout -b side my-topic-branch &&
echo Side >> C &&
git add C &&
'prepare repository with topic branch' \
'echo First > A &&
git update-index --add A &&
- git-commit -m "Add A." &&
+ git commit -m "Add A." &&
- git-checkout -b my-topic-branch &&
+ git checkout -b my-topic-branch &&
echo Second > B &&
git update-index --add B &&
- git-commit -m "Add B." &&
+ git commit -m "Add B." &&
echo AnotherSecond > C &&
git update-index --add C &&
- git-commit -m "Add C." &&
+ git commit -m "Add C." &&
- git-checkout -f master &&
+ git checkout -f master &&
echo Third >> A &&
git update-index A &&
- git-commit -m "Modify A."
+ git commit -m "Modify A."
'
test_expect_success \
'pick top patch from topic branch into master' \
'git cherry-pick my-topic-branch^0 &&
- git-checkout -f my-topic-branch &&
+ git checkout -f my-topic-branch &&
git branch master-merge master &&
git branch my-topic-branch-merge my-topic-branch
'
'
test_expect_success \
- 'rebase topic branch against new master and check git-am did not get halted' \
- 'git-rebase master && test ! -d .git/rebase-apply'
+ 'rebase topic branch against new master and check git am did not get halted' \
+ 'git rebase master && test ! -d .git/rebase-apply'
test_expect_success \
'rebase --merge topic branch that was partially merged upstream' \
- 'git-checkout -f my-topic-branch-merge &&
- git-rebase --merge master-merge &&
+ 'git checkout -f my-topic-branch-merge &&
+ git rebase --merge master-merge &&
test ! -d .git/rebase-merge'
test_done
. ./test-lib.sh
-# we assume the default git-am -3 --skip strategy is tested independently
+# we assume the default git am -3 --skip strategy is tested independently
# and always works :)
test_expect_success setup '
test "$(git rev-parse HEAD~3)" = "$(git rev-parse master)" &&
test_cmp expect .git/rebase-merge/patch &&
test_cmp expect2 file1 &&
- test "$(git-diff --name-status |
+ test "$(git diff --name-status |
sed -n -e "/^U/s/^U[^a-z]*//p")" = file1 &&
test 4 = $(grep -v "^#" < .git/rebase-merge/done | wc -l) &&
test 0 = $(grep -c "^[^#]" < .git/rebase-merge/git-rebase-todo)
test -d "$dotest" &&
test_must_fail git rebase --skip &&
test $(git rev-parse HEAD) = $(git rev-parse master) &&
- git-rebase --abort &&
+ git rebase --abort &&
test $(git rev-parse to-rebase) = $(git rev-parse pre-rebase) &&
test ! -d "$dotest"
'
'prepare repository with topic branch, and check cherry finds the 2 patches from there' \
'echo First > A &&
git update-index --add A &&
- git-commit -m "Add A." &&
+ git commit -m "Add A." &&
- git-checkout -b my-topic-branch &&
+ git checkout -b my-topic-branch &&
echo Second > B &&
git update-index --add B &&
- git-commit -m "Add B." &&
+ git commit -m "Add B." &&
sleep 2 &&
echo AnotherSecond > C &&
git update-index --add C &&
- git-commit -m "Add C." &&
+ git commit -m "Add C." &&
- git-checkout -f master &&
+ git checkout -f master &&
rm -f B C &&
echo Third >> A &&
git update-index A &&
- git-commit -m "Modify A." &&
+ git commit -m "Modify A." &&
expr "$(echo $(git cherry master my-topic-branch) )" : "+ [^ ]* + .*"
'
'Initialize test directory' \
"touch -- foo bar baz 'space embedded' -q &&
git add -- foo bar baz 'space embedded' -q &&
- git-commit -m 'add normal files' &&
+ git commit -m 'add normal files' &&
test_tabs=y &&
if touch -- 'tab embedded' 'newline
embedded'
then
git add -- 'tab embedded' 'newline
embedded' &&
- git-commit -m 'add files with tabs and newlines'
+ git commit -m 'add files with tabs and newlines'
else
say 'Your filesystem does not allow tabs in filenames.'
test_tabs=n
#
#
-test_description='git-mktag: tag object verify test'
+test_description='git mktag: tag object verify test'
. ./test-lib.sh
check_verify_failure () {
expect="$2"
test_expect_success "$1" '
- ( test_must_fail git-mktag <tag.sig 2>message ) &&
+ ( test_must_fail git mktag <tag.sig 2>message ) &&
grep "$expect" message
'
}
# for the tag.
echo Hello >A
git update-index --add A
-git-commit -m "Initial commit"
+git commit -m "Initial commit"
head=$(git rev-parse --verify HEAD)
############################################################
test_expect_success \
'allow empty tag email' \
- 'git-mktag <tag.sig >.git/refs/tags/mytag 2>message'
+ 'git mktag <tag.sig >.git/refs/tags/mytag 2>message'
############################################################
# 16. disallow spaces in tag email
test_expect_success \
'create valid tag' \
- 'git-mktag <tag.sig >.git/refs/tags/mytag 2>message'
+ 'git mktag <tag.sig >.git/refs/tags/mytag 2>message'
############################################################
# 25. check mytag
test_expect_success \
'check mytag' \
- 'git-tag -l | grep mytag'
+ 'git tag -l | grep mytag'
test_done
T=$(git write-tree) &&
C=$(git commit-tree $T <../t3900/1-UTF-8.txt) &&
git update-ref HEAD $C &&
- git-tag C0
+ git tag C0
'
test_expect_success 'no encoding header for base case' '
do
test_expect_success "$H setup" '
git config i18n.commitencoding $H &&
- git-checkout -b $H C0 &&
+ git checkout -b $H C0 &&
echo $H >F &&
- git-commit -a -F ../t3900/$H.txt
+ git commit -a -F ../t3900/$H.txt
'
done
# we want UTF-8 encoded name.
. ../t3901-utf8.txt &&
git checkout -b test &&
- git-rebase master &&
+ git rebase master &&
check_encoding 2
'
. ../t3901-utf8.txt &&
git reset --hard side &&
- git-rebase master &&
+ git rebase master &&
check_encoding 2
'
. ../t3901-8859-1.txt &&
git reset --hard side &&
- git-rebase master &&
+ git rebase master &&
check_encoding 2 8859
'
. ../t3901-8859-1.txt &&
git reset --hard side &&
- git-rebase master &&
+ git rebase master &&
check_encoding 2 8859
'
. ../t3901-utf8.txt &&
git reset --hard side &&
- git-rebase --merge master &&
+ git rebase --merge master &&
check_encoding 2
'
. ../t3901-utf8.txt &&
git reset --hard side &&
- git-rebase --merge master &&
+ git rebase --merge master &&
check_encoding 2
'
. ../t3901-8859-1.txt &&
git reset --hard side &&
- git-rebase --merge master &&
+ git rebase --merge master &&
check_encoding 2 8859
'
. ../t3901-8859-1.txt &&
git reset --hard side &&
- git-rebase --merge master &&
+ git rebase --merge master &&
check_encoding 2 8859
'
# Copyright (c) 2007 Johannes E Schindelin
#
-test_description='Test git-stash'
+test_description='Test git stash'
. ./test-lib.sh
detected=`sed -ne "${detected}p" broken` &&
test "$detected" = xCIT'
-test_expect_success 'initial commit' 'git-commit -a -m initial'
+test_expect_success 'initial commit' 'git commit -a -m initial'
# Try removal (b), modification (d), and creation (e).
test_expect_success 'diff-index with --binary' \
git apply --stat --summary current'
test_expect_success 'apply binary patch' \
- 'git-reset --hard &&
+ 'git reset --hard &&
git apply --binary --index <current &&
tree1=`git write-tree` &&
test "$tree1" = "$tree0"'
cat file1 >file4
git update-index --add --remove file1 file2 file4
-git-commit -m 'Initial Version' 2>/dev/null
+git commit -m 'Initial Version' 2>/dev/null
-git-checkout -b binary
+git checkout -b binary
perl -pe 'y/x/\000/' <file1 >file3
cat file3 >file4
git add file2
perl -pe 'y/\000/v/' <file3 >file1
rm -f file2
git update-index --add --remove file1 file2 file3 file4
-git-commit -m 'Second Version'
+git commit -m 'Second Version'
git diff-tree -p master binary >B.diff
git diff-tree -p -C master binary >C.diff
git diff-tree -p --binary -C master binary >CF.diff
test_expect_success 'stat binary diff -- should not fail.' \
- 'git-checkout master
+ 'git checkout master
git apply --stat --summary B.diff'
test_expect_success 'stat binary diff (copy) -- should not fail.' \
- 'git-checkout master
+ 'git checkout master
git apply --stat --summary C.diff'
test_expect_success 'check binary diff -- should fail.' \
- 'git-checkout master &&
+ 'git checkout master &&
test_must_fail git apply --check B.diff'
test_expect_success 'check binary diff (copy) -- should fail.' \
- 'git-checkout master &&
+ 'git checkout master &&
test_must_fail git apply --check C.diff'
test_expect_success \
'check incomplete binary diff with replacement -- should fail.' '
- git-checkout master &&
+ git checkout master &&
test_must_fail git apply --check --allow-binary-replacement B.diff
'
test_expect_success \
'check incomplete binary diff with replacement (copy) -- should fail.' '
- git-checkout master &&
+ git checkout master &&
test_must_fail git apply --check --allow-binary-replacement C.diff
'
test_expect_success 'check binary diff with replacement.' \
- 'git-checkout master
+ 'git checkout master
git apply --check --allow-binary-replacement BF.diff'
test_expect_success 'check binary diff with replacement (copy).' \
- 'git-checkout master
+ 'git checkout master
git apply --check --allow-binary-replacement CF.diff'
# Now we start applying them.
do_reset () {
rm -f file? &&
- git-reset --hard &&
- git-checkout -f master
+ git reset --hard &&
+ git checkout -f master
}
test_expect_success 'apply binary diff -- should fail.' \
git diff victim >add-a-patch.with &&
git diff --unified=0 >add-a-patch.without &&
+ : insert at line two
+ for i in b a '"$L"' y
+ do
+ echo $i
+ done >victim &&
+ cat victim >insert-a-expect &&
+ git diff victim >insert-a-patch.with &&
+ git diff --unified=0 >insert-a-patch.without &&
+
: modify at the head
for i in a '"$L"' y
do
git diff --unified=0 >add-z-patch.without &&
: modify at the tail
- for i in a '"$L"' y
+ for i in b '"$L"' z
do
echo $i
done >victim &&
with) u= ;;
without) u='--unidiff-zero ' ;;
esac
- for kind in add-a add-z mod-a mod-z del-a del-z
+ for kind in add-a add-z insert-a mod-a mod-z del-a del-z
do
test_expect_success "apply $kind-patch $with context" '
cat original >victim &&
done
done
-for kind in add-a add-z mod-a mod-z del-a del-z
+for kind in add-a add-z insert-a mod-a mod-z del-a del-z
do
rm -f $kind-ng.without
sed -e "s/^diff --git /diff /" \
#!/bin/sh
-test_description='core.whitespace rules and git-apply'
+test_description='core.whitespace rules and git apply'
. ./test-lib.sh
git diff >> patch0 &&
cp same_fn same_fn2 &&
git reset --hard &&
- git-apply patch0 &&
+ git apply patch0 &&
diff same_fn same_fn2
'
git diff >> patch0 &&
cp same_fn same_fn2 &&
git reset --hard &&
- git-apply patch0 &&
+ git apply patch0 &&
diff same_fn same_fn2
'
git checkout HEAD^ &&
git am --keep patch4 &&
! test -d .git/rebase-apply &&
- git-cat-file commit HEAD |
+ git cat-file commit HEAD |
grep -q -F "Re: Re: Re: [PATCH 1/5 v2] third"
'
'
test_expect_success "am$with3 --skip continue after failed am$with3" '
- test_must_fail git-am$with3 --skip >output &&
+ test_must_fail git am$with3 --skip >output &&
test "$(grep "^Applying" output)" = "Applying: 6" &&
test_cmp file-2-expect file-2 &&
test ! -f .git/rr-cache/MERGE_RR
'
test_expect_success "am --abort goes back after failed am$with3" '
- git-am --abort &&
+ git am --abort &&
git rev-parse HEAD >actual &&
git rev-parse initial >expect &&
test_cmp expect actual &&
# Copyright (c) 2005 Junio C Hamano
#
-test_description='git-pack-object
+test_description='git pack-object
'
. ./test-lib.sh
test-2-${packname_2}.idx \
test-3-${packname_3}.idx'
+test_expect_success \
+ 'verify pack -v' \
+ 'git verify-pack -v test-1-${packname_1}.idx \
+ test-2-${packname_2}.idx \
+ test-3-${packname_3}.idx'
+
test_expect_success \
'verify-pack catches mismatched .idx and .pack files' \
'cat test-1-${packname_1}.idx >test-3.idx &&
test_expect_success \
'build pack index for an existing pack' \
'cat test-1-${packname_1}.pack >test-3.pack &&
- git-index-pack -o tmp.idx test-3.pack &&
+ git index-pack -o tmp.idx test-3.pack &&
cmp tmp.idx test-1-${packname_1}.idx &&
- git-index-pack test-3.pack &&
+ git index-pack test-3.pack &&
cmp test-3.idx test-1-${packname_1}.idx &&
cat test-2-${packname_2}.pack >test-3.pack &&
- git-index-pack -o tmp.idx test-2-${packname_2}.pack &&
+ git index-pack -o tmp.idx test-2-${packname_2}.pack &&
cmp tmp.idx test-2-${packname_2}.idx &&
- git-index-pack test-3.pack &&
+ git index-pack test-3.pack &&
cmp test-3.idx test-2-${packname_2}.idx &&
cat test-3-${packname_3}.pack >test-3.pack &&
- git-index-pack -o tmp.idx test-3-${packname_3}.pack &&
+ git index-pack -o tmp.idx test-3-${packname_3}.pack &&
cmp tmp.idx test-3-${packname_3}.idx &&
- git-index-pack test-3.pack &&
+ git index-pack test-3.pack &&
cmp test-3.idx test-3-${packname_3}.idx &&
:'
test_expect_success \
'make sure index-pack detects the SHA1 collision' \
- 'test_must_fail git-index-pack -o bad.idx test-3.pack'
+ 'test_must_fail git index-pack -o bad.idx test-3.pack'
test_expect_success \
'honor pack.packSizeLimit' \
tree=`git write-tree` &&
commit1=`git commit-tree $tree </dev/null` &&
git update-ref HEAD $commit1 &&
- git-repack -a -d &&
+ git repack -a -d &&
test "`git count-objects`" = "0 objects, 0 kilobytes" &&
pack1=`ls .git/objects/pack/*.pack` &&
test -f "$pack1"'
git config core.packedGitLimit 512 &&
commit2=`git commit-tree $tree -p $commit1 </dev/null` &&
git update-ref HEAD $commit2 &&
- git-repack -a -d &&
+ git repack -a -d &&
test "`git count-objects`" = "0 objects, 0 kilobytes" &&
pack2=`ls .git/objects/pack/*.pack` &&
test -f "$pack2"
test_expect_success \
'index-pack with index version 1' \
- 'git-index-pack --index-version=1 -o 1.idx "test-1-${pack1}.pack"'
+ 'git index-pack --index-version=1 -o 1.idx "test-1-${pack1}.pack"'
test_expect_success \
'index-pack with index version 2' \
- 'git-index-pack --index-version=2 -o 2.idx "test-1-${pack1}.pack"'
+ 'git index-pack --index-version=2 -o 2.idx "test-1-${pack1}.pack"'
test_expect_success \
'index-pack results should match pack-objects ones' \
test "$have_64bits" &&
test_expect_success \
'index v2: force some 64-bit offsets with index-pack' \
- 'git-index-pack --index-version=2,0x40000 -o 3.idx "test-1-${pack1}.pack"'
+ 'git index-pack --index-version=2,0x40000 -o 3.idx "test-1-${pack1}.pack"'
test "$have_64bits" &&
test_expect_success \
test_expect_success \
'[index v1] 1) stream pack to repository' \
- 'git-index-pack --index-version=1 --stdin < "test-1-${pack1}.pack" &&
+ 'git index-pack --index-version=1 --stdin < "test-1-${pack1}.pack" &&
git prune-packed &&
git count-objects | ( read nr rest && test "$nr" -eq 1 ) &&
cmp "test-1-${pack1}.pack" ".git/objects/pack/pack-${pack1}.pack" &&
test_expect_success \
'[index v2] 1) stream pack to repository' \
'rm -f .git/objects/pack/* &&
- git-index-pack --index-version=2 --stdin < "test-1-${pack1}.pack" &&
+ git index-pack --index-version=2 --stdin < "test-1-${pack1}.pack" &&
git prune-packed &&
git count-objects | ( read nr rest && test "$nr" -eq 1 ) &&
cmp "test-1-${pack1}.pack" ".git/objects/pack/pack-${pack1}.pack" &&
test_expect_success \
'[index v2] 6) verify-pack detects CRC mismatch' \
'rm -f .git/objects/pack/* &&
- git-index-pack --index-version=2 --stdin < "test-1-${pack1}.pack" &&
+ git index-pack --index-version=2 --stdin < "test-1-${pack1}.pack" &&
git verify-pack ".git/objects/pack/pack-${pack1}.pack" &&
chmod +w ".git/objects/pack/pack-${pack1}.idx" &&
dd if=/dev/zero of=".git/objects/pack/pack-${pack1}.idx" conv=notrunc \
#!/bin/sh
-test_description='git-pack-object --include-tag'
+test_description='git pack-object --include-tag'
. ./test-lib.sh
TRASH=`pwd`
--- /dev/null
+#!/bin/sh
+#
+# Copyright (c) 2008 Google Inc.
+#
+
+test_description='git-pack-object with missing base
+
+'
+. ./test-lib.sh
+
+# Create A-B chain
+#
+test_expect_success \
+ 'setup base' \
+ 'for a in a b c d e f g h i; do echo $a >>text; done &&
+ echo side >side &&
+ git update-index --add text side &&
+ A=$(echo A | git commit-tree $(git write-tree)) &&
+
+ echo m >>text &&
+ git update-index text &&
+ B=$(echo B | git commit-tree $(git write-tree) -p $A) &&
+ git update-ref HEAD $B
+ '
+
+# Create repository with C whose parent is B.
+# Repository contains C, C^{tree}, C:text, B, B^{tree}.
+# Repository is missing B:text (best delta base for C:text).
+# Repository is missing A (parent of B).
+# Repository is missing A:side.
+#
+test_expect_success \
+ 'setup patch_clone' \
+ 'base_objects=$(pwd)/.git/objects &&
+ (mkdir patch_clone &&
+ cd patch_clone &&
+ git init &&
+ echo "$base_objects" >.git/objects/info/alternates &&
+ echo q >>text &&
+ git read-tree $B &&
+ git update-index text &&
+ git update-ref HEAD $(echo C | git commit-tree $(git write-tree) -p $B) &&
+ rm .git/objects/info/alternates &&
+
+ git --git-dir=../.git cat-file commit $B |
+ git hash-object -t commit -w --stdin &&
+
+ git --git-dir=../.git cat-file tree "$B^{tree}" |
+ git hash-object -t tree -w --stdin
+ ) &&
+ C=$(git --git-dir=patch_clone/.git rev-parse HEAD)
+ '
+
+# Clone patch_clone indirectly by cloning base and fetching.
+#
+test_expect_success \
+ 'indirectly clone patch_clone' \
+ '(mkdir user_clone &&
+ cd user_clone &&
+ git init &&
+ git pull ../.git &&
+ test $(git rev-parse HEAD) = $B &&
+
+ git pull ../patch_clone/.git &&
+ test $(git rev-parse HEAD) = $C
+ )
+ '
+
+# Cloning the patch_clone directly should fail.
+#
+test_expect_success \
+ 'clone of patch_clone is incomplete' \
+ '(mkdir user_direct &&
+ cd user_direct &&
+ git init &&
+ test_must_fail git fetch ../patch_clone/.git
+ )
+ '
+
+test_done
parent=$commit || return 1
done &&
git update-ref HEAD "$commit" &&
- git-clone ./. victim &&
+ git clone ./. victim &&
cd victim &&
git log &&
cd .. &&
test_expect_success \
'pushing rewound head should not barf but require --force' '
# should not fail but refuse to update.
- if git-send-pack ./victim/.git/ master
+ if git send-pack ./victim/.git/ master
then
# now it should fail with Pasky patch
echo >&2 Gaah, it should have failed.
true
fi &&
# this should update
- git-send-pack --force ./victim/.git/ master &&
+ git send-pack --force ./victim/.git/ master &&
cmp victim/.git/refs/heads/master .git/refs/heads/master
'
git branch extra master &&
cd .. &&
test -f victim/.git/refs/heads/extra &&
- git-send-pack ./victim/.git/ :extra master &&
+ git send-pack ./victim/.git/ :extra master &&
! test -f victim/.git/refs/heads/extra
'
git config receive.denyNonFastforwards true &&
cd .. &&
git update-ref refs/heads/master master^ || return 1
- git-send-pack --force ./victim/.git/ master && return 1
+ git send-pack --force ./victim/.git/ master && return 1
! test_cmp .git/refs/heads/master victim/.git/refs/heads/master
'
test_expect_success \
'pushing does not include non-head refs' '
mkdir parent && cd parent &&
- git-init && touch file && git-add file && git-commit -m add &&
+ git init && touch file && git add file && git commit -m add &&
cd .. &&
- git-clone parent child && cd child && git-push --all &&
+ git clone parent child && cd child && git push --all &&
cd ../parent &&
- git-branch -a >branches && ! grep origin/master branches
+ git branch -a >branches && ! grep origin/master branches
'
rewound_push_setup() {
rm -rf parent child &&
mkdir parent && cd parent &&
- git-init && echo one >file && git-add file && git-commit -m one &&
- echo two >file && git-commit -a -m two &&
+ git init && echo one >file && git add file && git commit -m one &&
+ echo two >file && git commit -a -m two &&
cd .. &&
- git-clone parent child && cd child && git-reset --hard HEAD^
+ git clone parent child && cd child && git reset --hard HEAD^
}
rewound_push_succeeded() {
test_expect_success \
'pushing explicit refspecs respects forcing' '
rewound_push_setup &&
- if git-send-pack ../parent/.git refs/heads/master:refs/heads/master
+ if git send-pack ../parent/.git refs/heads/master:refs/heads/master
then
false
else
true
fi && rewound_push_failed &&
- git-send-pack ../parent/.git +refs/heads/master:refs/heads/master &&
+ git send-pack ../parent/.git +refs/heads/master:refs/heads/master &&
rewound_push_succeeded
'
test_expect_success \
'pushing wildcard refspecs respects forcing' '
rewound_push_setup &&
- if git-send-pack ../parent/.git refs/heads/*:refs/heads/*
+ if git send-pack ../parent/.git refs/heads/*:refs/heads/*
then
false
else
true
fi && rewound_push_failed &&
- git-send-pack ../parent/.git +refs/heads/*:refs/heads/* &&
+ git send-pack ../parent/.git +refs/heads/*:refs/heads/* &&
rewound_push_succeeded
'
commit1=$(echo modify | git commit-tree $tree1 -p $commit0) &&
git update-ref refs/heads/master $commit0 &&
git update-ref refs/heads/tofail $commit1 &&
- git-clone ./. victim &&
+ git clone ./. victim &&
GIT_DIR=victim/.git git update-ref refs/heads/tofail $commit1 &&
git update-ref refs/heads/master $commit1 &&
git update-ref refs/heads/tofail $commit0
chmod u+x victim/.git/hooks/post-update
test_expect_success push '
- test_must_fail git-send-pack --force ./victim/.git \
+ test_must_fail git send-pack --force ./victim/.git \
master tofail >send.out 2>send.err
'
tree1=$(git write-tree) &&
commit1=$(echo modify | git commit-tree $tree1 -p $commit0) &&
git update-ref refs/heads/master $commit0 &&
- git-clone ./. clone1 &&
+ git clone ./. clone1 &&
GIT_DIR=clone1/.git git update-index --add a &&
- git-clone ./. clone2 &&
+ git clone ./. clone2 &&
GIT_DIR=clone2/.git git update-index --add a
'
tree0=$(git write-tree) &&
commit0=$(echo setup | git commit-tree $tree0) &&
git update-ref refs/heads/master $commit0 &&
- git-clone ./. clone1 &&
- git-clone ./. clone2 &&
+ git clone ./. clone1 &&
+ git clone ./. clone2 &&
GIT_DIR=clone2/.git git branch -a new2 &&
echo Data for commit1. >clone2/b &&
GIT_DIR=clone2/.git git add clone2/b &&
cd client
test_expect_success "$number pull" \
- "git-fetch-pack -k -v .. $heads"
+ "git fetch-pack -k -v .. $heads"
case "$heads" in *A*) echo $ATIP > .git/refs/heads/A;; esac
case "$heads" in *B*) echo $BTIP > .git/refs/heads/B;; esac
git symbolic-ref HEAD refs/heads/`echo $heads | sed -e 's/^\(.\).*$/\1/'`
pull_to_client 3rd "A" $((1*3)) # old fails
-test_expect_success "clone shallow" 'git-clone --depth 2 "file://$(pwd)/." shallow'
+test_expect_success "clone shallow" 'git clone --depth 2 "file://$(pwd)/." shallow'
(cd shallow; git count-objects -v) > count.shallow
cat > test/expect << EOF
* remote origin
- URL: $(pwd)/one/.git
+ URL: $(pwd)/one
Remote branch merged with 'git pull' while on branch master
master
New remote branch (next fetch will store in remotes/origin)
cat > test/expect << EOF
* remote origin
- URL: $(pwd)/one/.git
+ URL: $(pwd)/one
Remote branch merged with 'git pull' while on branch master
master
Tracked remote branches
cat > test/expect << EOF
Pruning origin
-URL: $(pwd)/one/.git
+URL: $(pwd)/one
* [would prune] origin/side2
EOF
test_expect_success 'fetch must not resolve short remote name' '
cd "$D" &&
- git-update-ref refs/remotes/six/HEAD HEAD
+ git update-ref refs/remotes/six/HEAD HEAD
mkdir six &&
cd six &&
! echo "0032want $(git rev-parse HEAD)
00000009done
-0000" | git-upload-pack . > /dev/null 2> output.err &&
+0000" | git upload-pack . > /dev/null 2> output.err &&
grep "pack-objects died" output.err
'
! echo "0032want $(git rev-parse HEAD)
00000009done
-0000" | git-upload-pack . > /dev/null 2> output.err &&
+0000" | git upload-pack . > /dev/null 2> output.err &&
grep "waitpid (async) failed" output.err
'
# Copyright (C) 2006 Carl D. Worth <cworth@cworth.org>
#
-test_description='test git-clone to cleanup after failure
+test_description='test git clone to cleanup after failure
-This test covers the fact that if git-clone fails, it should remove
+This test covers the fact that if git clone fails, it should remove
the directory it created, to avoid the user having to manually
remove the directory before attempting a clone again.'
test_expect_success \
'clone of non-existent source should fail' \
- 'test_must_fail git-clone foo bar'
+ 'test_must_fail git clone foo bar'
test_expect_success \
'failed clone should not leave a directory' \
# clone doesn't like it if there is no HEAD. Is that a bug?
(cd foo && touch file && git add file && git commit -m 'add file' >/dev/null 2>&1)
-# source repository given to git-clone should be relative to the
+# source repository given to git clone should be relative to the
# current path not to the target dir
test_expect_success \
'clone of non-existent (relative to $PWD) source should fail' \
- 'test_must_fail git-clone ../foo baz'
+ 'test_must_fail git clone ../foo baz'
test_expect_success \
'clone should work now that source exists' \
- 'git-clone foo bar'
+ 'git clone foo bar'
test_expect_success \
'successful clone must leave the directory' \
'
+test_expect_success 'clone to destination with trailing /' '
+
+ git clone src target-1/ &&
+ T=$( cd target-1 && git rev-parse HEAD ) &&
+ S=$( cd src && git rev-parse HEAD ) &&
+ test "$T" = "$S"
+
+'
+
+test_expect_success 'clone to destination with extra trailing /' '
+
+ git clone src target-2/// &&
+ T=$( cd target-2 && git rev-parse HEAD ) &&
+ S=$( cd src && git rev-parse HEAD ) &&
+ test "$T" = "$S"
+
+'
+
test_done
chmod +x not_ssh
'
-test_expect_success 'clone calls git-upload-pack unqualified with no -u option' '
+test_expect_success 'clone calls git upload-pack unqualified with no -u option' '
GIT_SSH=./not_ssh git clone localhost:/path/to/repo junk
echo "localhost git-upload-pack '\''/path/to/repo'\''" >expected
test_cmp expected not_ssh_output
'
-test_expect_success 'clone calls specified git-upload-pack with -u option' '
+test_expect_success 'clone calls specified git upload-pack with -u option' '
GIT_SSH=./not_ssh git clone -u /something/bin/git-upload-pack localhost:/path/to/repo junk
echo "localhost /something/bin/git-upload-pack '\''/path/to/repo'\''" >expected
test_cmp expected not_ssh_output
test_tick
test_expect_success 'setup' '
-touch foo && git add foo && git-commit -m "added foo" &&
- echo changed >foo && git-commit -a -m "changed foo"
+touch foo && git add foo && git commit -m "added foo" &&
+ echo changed >foo && git commit -a -m "changed foo"
'
# usage: test_format name format_string <expected_output
EOF
test_expect_success 'setup complex body' '
git config i18n.commitencoding iso8859-1 &&
- echo change2 >foo && git-commit -a -F commit-msg
+ echo change2 >foo && git commit -a -F commit-msg
'
test_format complex-encoding %e <<'EOF'
test_description='merging symlinks on filesystem w/o symlink support.
-This tests that git-merge-recursive writes merge results as plain files
+This tests that git merge-recursive writes merge results as plain files
if core.symlinks is false.'
. ./test-lib.sh
git config core.symlinks false &&
> file &&
git add file &&
-git-commit -m initial &&
+git commit -m initial &&
git branch b-symlink &&
git branch b-file &&
-l=$(echo -n file | git-hash-object -t blob -w --stdin) &&
+l=$(echo -n file | git hash-object -t blob -w --stdin) &&
echo "120000 $l symlink" | git update-index --index-info &&
-git-commit -m master &&
-git-checkout b-symlink &&
-l=$(echo -n file-different | git-hash-object -t blob -w --stdin) &&
+git commit -m master &&
+git checkout b-symlink &&
+l=$(echo -n file-different | git hash-object -t blob -w --stdin) &&
echo "120000 $l symlink" | git update-index --index-info &&
-git-commit -m b-symlink &&
-git-checkout b-file &&
+git commit -m b-symlink &&
+git checkout b-file &&
echo plain-file > symlink &&
git add symlink &&
-git-commit -m b-file'
+git commit -m b-file'
test_expect_success \
'merge master into b-symlink, which has a different symbolic link' '
-git-checkout b-symlink &&
-test_must_fail git-merge master'
+git checkout b-symlink &&
+test_must_fail git merge master'
test_expect_success \
'the merge result must be a file' '
test_expect_success \
'merge master into b-file, which has a file instead of a symbolic link' '
-git-reset --hard && git-checkout b-file &&
-test_must_fail git-merge master'
+git reset --hard && git checkout b-file &&
+test_must_fail git merge master'
test_expect_success \
'the merge result must be a file' '
test_expect_success \
'merge b-file, which has a file instead of a symbolic link, into master' '
-git-reset --hard &&
-git-checkout master &&
-test_must_fail git-merge b-file'
+git reset --hard &&
+git checkout master &&
+test_must_fail git merge b-file'
test_expect_success \
'the merge result must be a file' '
cmp binary union &&
sed -e 1,3d text >check-1 &&
- o=$(git-unpack-file master^:text) &&
- a=$(git-unpack-file side^:text) &&
- b=$(git-unpack-file master:text) &&
+ o=$(git unpack-file master^:text) &&
+ a=$(git unpack-file side^:text) &&
+ b=$(git unpack-file master:text) &&
sh -c "./custom-merge $o $a $b 0" &&
sed -e 1,3d $a >check-2 &&
cmp check-1 check-2 &&
cmp binary union &&
sed -e 1,3d text >check-1 &&
- o=$(git-unpack-file master^:text) &&
- a=$(git-unpack-file anchor:text) &&
- b=$(git-unpack-file master:text) &&
+ o=$(git unpack-file master^:text) &&
+ a=$(git unpack-file anchor:text) &&
+ b=$(git unpack-file master:text) &&
sh -c "./custom-merge $o $a $b 0" &&
sed -e 1,3d $a >check-2 &&
cmp check-1 check-2 &&
#
# Copyright (c) 2007 Christian Couder
#
-test_description='Tests git-bisect functionality'
+test_description='Tests git bisect functionality'
exec </dev/null
fi
test_tick
- git-commit --quiet -m "$MSG" $_file
+ git commit --quiet -m "$MSG" $_file
}
HASH1=
test_expect_success setup '
test_tick &&
- echo one >file && git add file && git-commit -m initial &&
+ echo one >file && git add file && git commit -m initial &&
one=$(git rev-parse HEAD) &&
test_tick &&
- echo two >file && git add file && git-commit -m second &&
+ echo two >file && git add file && git commit -m second &&
two=$(git rev-parse HEAD) &&
test_tick &&
- echo three >file && git add file && git-commit -m third &&
+ echo three >file && git add file && git commit -m third &&
test_tick &&
- echo A >file && git add file && git-commit -m A &&
+ echo A >file && git add file && git commit -m A &&
test_tick &&
- git-tag -a -m A A &&
+ git tag -a -m A A &&
test_tick &&
- echo c >file && git add file && git-commit -m c &&
+ echo c >file && git add file && git commit -m c &&
test_tick &&
- git-tag c &&
+ git tag c &&
git reset --hard $two &&
test_tick &&
- echo B >side && git add side && git-commit -m B &&
+ echo B >side && git add side && git commit -m B &&
test_tick &&
- git-tag -a -m B B &&
+ git tag -a -m B B &&
test_tick &&
- git-merge -m Merged c &&
+ git merge -m Merged c &&
merged=$(git rev-parse HEAD) &&
git reset --hard $two &&
test_tick &&
- echo D >another && git add another && git-commit -m D &&
+ echo D >another && git add another && git commit -m D &&
test_tick &&
- git-tag -a -m D D &&
+ git tag -a -m D D &&
test_tick &&
echo DD >another && git commit -a -m another &&
test_tick &&
- git-tag e &&
+ git tag e &&
test_tick &&
echo DDD >another && git commit -a -m "yet another" &&
test_tick &&
- git-merge -m Merged $merged &&
+ git merge -m Merged $merged &&
test_tick &&
echo X >file && echo X >side && git add file side &&
- git-commit -m x
+ git commit -m x
'
'
test_expect_success 'Check invalid atoms names are errors' '
- test_must_fail git-for-each-ref --format="%(INVALID)" refs/heads
+ test_must_fail git for-each-ref --format="%(INVALID)" refs/heads
'
test_expect_success 'Check format specifiers are ignored in naming date atoms' '
- git-for-each-ref --format="%(authordate)" refs/heads &&
- git-for-each-ref --format="%(authordate:default) %(authordate)" refs/heads &&
- git-for-each-ref --format="%(authordate) %(authordate:default)" refs/heads &&
- git-for-each-ref --format="%(authordate:default) %(authordate:default)" refs/heads
+ git for-each-ref --format="%(authordate)" refs/heads &&
+ git for-each-ref --format="%(authordate:default) %(authordate)" refs/heads &&
+ git for-each-ref --format="%(authordate) %(authordate:default)" refs/heads &&
+ git for-each-ref --format="%(authordate:default) %(authordate:default)" refs/heads
'
test_expect_success 'Check valid format specifiers for date fields' '
- git-for-each-ref --format="%(authordate:default)" refs/heads &&
- git-for-each-ref --format="%(authordate:relative)" refs/heads &&
- git-for-each-ref --format="%(authordate:short)" refs/heads &&
- git-for-each-ref --format="%(authordate:local)" refs/heads &&
- git-for-each-ref --format="%(authordate:iso8601)" refs/heads &&
- git-for-each-ref --format="%(authordate:rfc2822)" refs/heads
+ git for-each-ref --format="%(authordate:default)" refs/heads &&
+ git for-each-ref --format="%(authordate:relative)" refs/heads &&
+ git for-each-ref --format="%(authordate:short)" refs/heads &&
+ git for-each-ref --format="%(authordate:local)" refs/heads &&
+ git for-each-ref --format="%(authordate:iso8601)" refs/heads &&
+ git for-each-ref --format="%(authordate:rfc2822)" refs/heads
'
test_expect_success 'Check invalid format specifiers are errors' '
- test_must_fail git-for-each-ref --format="%(authordate:INVALID)" refs/heads
+ test_must_fail git for-each-ref --format="%(authordate:INVALID)" refs/heads
'
cat >expected <<\EOF
EOF
test_expect_success 'Verify ascending sort' '
- git-for-each-ref --format="%(refname)" --sort=refname >actual &&
+ git for-each-ref --format="%(refname)" --sort=refname >actual &&
test_cmp expected actual
'
EOF
test_expect_success 'Verify descending sort' '
- git-for-each-ref --format="%(refname)" --sort=-refname >actual &&
+ git for-each-ref --format="%(refname)" --sort=-refname >actual &&
test_cmp expected actual
'
'mkdir path0 path1 &&
cp ../../COPYING path0/COPYING &&
git add path0/COPYING &&
- git-commit -m add -a'
+ git commit -m add -a'
test_expect_success \
'moving the file out of subdirectory' \
# in path0 currently
test_expect_success \
'commiting the change' \
- 'cd .. && git-commit -m move-out -a'
+ 'cd .. && git commit -m move-out -a'
test_expect_success \
'checking the commit' \
# in path0 currently
test_expect_success \
'commiting the change' \
- 'cd .. && git-commit -m move-in -a'
+ 'cd .. && git commit -m move-in -a'
test_expect_success \
'checking the commit' \
'adding another file' \
'cp ../../README path0/README &&
git add path0/README &&
- git-commit -m add2 -a'
+ git commit -m add2 -a'
test_expect_success \
'moving whole subdirectory' \
test_expect_success \
'commiting the change' \
- 'git-commit -m dir-move -a'
+ 'git commit -m dir-move -a'
test_expect_success \
'checking the commit' \
test_expect_success \
'commiting the change' \
- 'git-commit -m dir-move -a'
+ 'git commit -m dir-move -a'
test_expect_success \
'checking the commit' \
#!/bin/sh
-test_description='git-filter-branch'
+test_description='git filter-branch'
. ./test-lib.sh
make_commit () {
H=$(git rev-parse H)
test_expect_success 'rewrite identically' '
- git-filter-branch branch
+ git filter-branch branch
'
test_expect_success 'result is really identical' '
test $H = $(git rev-parse HEAD)
'
test_expect_success 'rewrite bare repository identically' '
- (git config core.bare true && cd .git && git-filter-branch branch)
+ (git config core.bare true && cd .git && git filter-branch branch)
'
git config core.bare false
test_expect_success 'result is really identical' '
'
test_expect_success 'rewrite, renaming a specific file' '
- git-filter-branch -f --tree-filter "mv d doh || :" HEAD
+ git filter-branch -f --tree-filter "mv d doh || :" HEAD
'
test_expect_success 'test that the file was renamed' '
'
test_expect_success 'rewrite, renaming a specific directory' '
- git-filter-branch -f --tree-filter "mv dir diroh || :" HEAD
+ git filter-branch -f --tree-filter "mv dir diroh || :" HEAD
'
test_expect_success 'test that the directory was renamed' '
git tag oldD HEAD~4
test_expect_success 'rewrite one branch, keeping a side branch' '
git branch modD oldD &&
- git-filter-branch -f --tree-filter "mv b boh || :" D..modD
+ git filter-branch -f --tree-filter "mv b boh || :" D..modD
'
test_expect_success 'common ancestor is still common (unchanged)' '
test_tick &&
git commit -m "again not subdir" &&
git branch sub &&
- git-filter-branch -f --subdirectory-filter subdir refs/heads/sub
+ git filter-branch -f --subdirectory-filter subdir refs/heads/sub
'
test_expect_success 'subdirectory filter result looks okay' '
test_expect_success 'use index-filter to move into a subdirectory' '
git branch directorymoved &&
- git-filter-branch -f --index-filter \
+ git filter-branch -f --index-filter \
"git ls-files -s | sed \"s-\\t-&newsubdir/-\" |
GIT_INDEX_FILE=\$GIT_INDEX_FILE.new \
git update-index --index-info &&
test_expect_success 'stops when msg filter fails' '
old=$(git rev-parse HEAD) &&
- test_must_fail git-filter-branch -f --msg-filter false HEAD &&
+ test_must_fail git filter-branch -f --msg-filter false HEAD &&
test $old = $(git rev-parse HEAD) &&
rm -rf .git-rewrite
'
test_tick &&
GIT_AUTHOR_NAME="B V Uips" git commit -m bvuips &&
git branch preserved-author &&
- git-filter-branch -f --msg-filter "cat; \
+ git filter-branch -f --msg-filter "cat; \
test \$GIT_COMMIT != $(git rev-parse master) || \
echo Hallo" \
preserved-author &&
test_tick &&
git commit -m i i &&
git branch removed-author &&
- git-filter-branch -f --commit-filter "\
+ git filter-branch -f --commit-filter "\
if [ \"\$GIT_AUTHOR_NAME\" = \"B V Uips\" ];\
then\
skip_commit \"\$@\";
# Copyright (c) 2007 Carlos Rica
#
-test_description='git-tag
+test_description='git tag
Tests for operations with tags.'
'
test_expect_success 'listing all tags in an empty tree should output nothing' '
- test `git-tag -l | wc -l` -eq 0 &&
- test `git-tag | wc -l` -eq 0
+ test `git tag -l | wc -l` -eq 0 &&
+ test `git tag | wc -l` -eq 0
'
test_expect_success 'looking for a tag in an empty tree should fail' \
'! (tag_exists mytag)'
test_expect_success 'creating a tag in an empty tree should fail' '
- test_must_fail git-tag mynotag &&
+ test_must_fail git tag mynotag &&
! tag_exists mynotag
'
test_expect_success 'creating a tag for HEAD in an empty tree should fail' '
- test_must_fail git-tag mytaghead HEAD &&
+ test_must_fail git tag mytaghead HEAD &&
! tag_exists mytaghead
'
test_expect_success 'creating a tag for an unknown revision should fail' '
- test_must_fail git-tag mytagnorev aaaaaaaaaaa &&
+ test_must_fail git tag mytagnorev aaaaaaaaaaa &&
! tag_exists mytagnorev
'
'
test_expect_success 'listing all tags if one exists should succeed' '
- git-tag -l &&
- git-tag
+ git tag -l &&
+ git tag
'
test_expect_success 'listing all tags if one exists should output that tag' '
- test `git-tag -l` = mytag &&
- test `git-tag` = mytag
+ test `git tag -l` = mytag &&
+ test `git tag` = mytag
'
# pattern matching:
test_expect_success 'listing a tag using a matching pattern should succeed' \
- 'git-tag -l mytag'
+ 'git tag -l mytag'
test_expect_success \
'listing a tag using a matching pattern should output that tag' \
- 'test `git-tag -l mytag` = mytag'
+ 'test `git tag -l mytag` = mytag'
# todo: git tag -l now returns always zero, when fixed, change this test
test_expect_success \
'listing tags using a non-matching pattern should suceed' \
- 'git-tag -l xxx'
+ 'git tag -l xxx'
test_expect_success \
'listing tags using a non-matching pattern should output nothing' \
- 'test `git-tag -l xxx | wc -l` -eq 0'
+ 'test `git tag -l xxx | wc -l` -eq 0'
# special cases for creating tags:
test_expect_success \
'trying to create a tag with a non-valid name should fail' '
- test `git-tag -l | wc -l` -eq 1 &&
+ test `git tag -l | wc -l` -eq 1 &&
test_must_fail git tag "" &&
test_must_fail git tag .othertag &&
test_must_fail git tag "other tag" &&
test_must_fail git tag "othertag^" &&
test_must_fail git tag "other~tag" &&
- test `git-tag -l | wc -l` -eq 1
+ test `git tag -l | wc -l` -eq 1
'
test_expect_success 'creating a tag using HEAD directly should succeed' '
test_expect_success 'trying to delete an unknown tag should fail' '
! tag_exists unknown-tag &&
- test_must_fail git-tag -d unknown-tag
+ test_must_fail git tag -d unknown-tag
'
cat >expect <<EOF
test_expect_success \
'trying to delete tags without params should succeed and do nothing' '
git tag -l > actual && test_cmp expect actual &&
- git-tag -d &&
+ git tag -d &&
git tag -l > actual && test_cmp expect actual
'
'deleting two existing tags in one command should succeed' '
tag_exists mytag &&
tag_exists myhead &&
- git-tag -d mytag myhead &&
+ git tag -d mytag myhead &&
! tag_exists mytag &&
! tag_exists myhead
'
test_expect_success \
'creating a tag with the name of another deleted one should succeed' '
! tag_exists mytag &&
- git-tag mytag &&
+ git tag mytag &&
tag_exists mytag
'
'trying to delete two tags, existing and not, should fail in the 2nd' '
tag_exists mytag &&
! tag_exists myhead &&
- test_must_fail git-tag -d mytag anothertag &&
+ test_must_fail git tag -d mytag anothertag &&
! tag_exists mytag &&
! tag_exists myhead
'
test_expect_success 'trying to delete an already deleted tag should fail' \
- 'test_must_fail git-tag -d mytag'
+ 'test_must_fail git tag -d mytag'
# listing various tags with pattern matching:
EOF
test_expect_success \
'listing tags with substring as pattern must print those matching' '
- git-tag -l "*a*" > actual &&
+ git tag -l "*a*" > actual &&
test_cmp expect actual
'
EOF
test_expect_success \
'listing tags with a suffix as pattern must print those matching' '
- git-tag -l "*.1" > actual &&
+ git tag -l "*.1" > actual &&
test_cmp expect actual
'
EOF
test_expect_success \
'listing tags with a prefix as pattern must print those matching' '
- git-tag -l "t21*" > actual &&
+ git tag -l "t21*" > actual &&
test_cmp expect actual
'
EOF
test_expect_success \
'listing tags using a name as pattern must print that one matching' '
- git-tag -l a1 > actual &&
+ git tag -l a1 > actual &&
test_cmp expect actual
'
EOF
test_expect_success \
'listing tags using a name as pattern must print that one matching' '
- git-tag -l v1.0 > actual &&
+ git tag -l v1.0 > actual &&
test_cmp expect actual
'
EOF
test_expect_success \
'listing tags with ? in the pattern should print those matching' '
- git-tag -l "v1.?.?" > actual &&
+ git tag -l "v1.?.?" > actual &&
test_cmp expect actual
'
>expect
test_expect_success \
'listing tags using v.* should print nothing because none have v.' '
- git-tag -l "v.*" > actual &&
+ git tag -l "v.*" > actual &&
test_cmp expect actual
'
EOF
test_expect_success \
'listing tags using v* should print only those having v' '
- git-tag -l "v*" > actual &&
+ git tag -l "v*" > actual &&
test_cmp expect actual
'
test_expect_success \
'a non-annotated tag created without parameters should point to HEAD' '
- git-tag non-annotated-tag &&
+ git tag non-annotated-tag &&
test $(git cat-file -t non-annotated-tag) = commit &&
test $(git rev-parse non-annotated-tag) = $(git rev-parse HEAD)
'
test_expect_success 'trying to verify an unknown tag should fail' \
- 'test_must_fail git-tag -v unknown-tag'
+ 'test_must_fail git tag -v unknown-tag'
test_expect_success \
'trying to verify a non-annotated and non-signed tag should fail' \
- 'test_must_fail git-tag -v non-annotated-tag'
+ 'test_must_fail git tag -v non-annotated-tag'
test_expect_success \
'trying to verify many non-annotated or unknown tags, should fail' \
- 'test_must_fail git-tag -v unknown-tag1 non-annotated-tag unknown-tag2'
+ 'test_must_fail git tag -v unknown-tag1 non-annotated-tag unknown-tag2'
# creating annotated tags:
echo "A message" >>expect
test_expect_success \
'creating an annotated tag with -m message should succeed' '
- git-tag -m "A message" annotated-tag &&
+ git tag -m "A message" annotated-tag &&
get_tag_msg annotated-tag >actual &&
test_cmp expect actual
'
cat msgfile >>expect
test_expect_success \
'creating an annotated tag with -F messagefile should succeed' '
- git-tag -F msgfile file-annotated-tag &&
+ git tag -F msgfile file-annotated-tag &&
get_tag_msg file-annotated-tag >actual &&
test_cmp expect actual
'
get_tag_header stdin-annotated-tag $commit commit $time >expect
cat inputmsg >>expect
test_expect_success 'creating an annotated tag with -F - should succeed' '
- git-tag -F - stdin-annotated-tag <inputmsg &&
+ git tag -F - stdin-annotated-tag <inputmsg &&
get_tag_msg stdin-annotated-tag >actual &&
test_cmp expect actual
'
'trying to create a tag with a non-existing -F file should fail' '
! test -f nonexistingfile &&
! tag_exists notag &&
- test_must_fail git-tag -F nonexistingfile notag &&
+ test_must_fail git tag -F nonexistingfile notag &&
! tag_exists notag
'
echo "message file 1" >msgfile1 &&
echo "message file 2" >msgfile2 &&
! tag_exists msgtag &&
- test_must_fail git-tag -m "message 1" -F msgfile1 msgtag &&
+ test_must_fail git tag -m "message 1" -F msgfile1 msgtag &&
! tag_exists msgtag &&
- test_must_fail git-tag -F msgfile1 -m "message 1" msgtag &&
+ test_must_fail git tag -F msgfile1 -m "message 1" msgtag &&
! tag_exists msgtag &&
- test_must_fail git-tag -m "message 1" -F msgfile1 \
+ test_must_fail git tag -m "message 1" -F msgfile1 \
-m "message 2" msgtag &&
! tag_exists msgtag
'
get_tag_header empty-annotated-tag $commit commit $time >expect
test_expect_success \
'creating a tag with an empty -m message should succeed' '
- git-tag -m "" empty-annotated-tag &&
+ git tag -m "" empty-annotated-tag &&
get_tag_msg empty-annotated-tag >actual &&
test_cmp expect actual
'
get_tag_header emptyfile-annotated-tag $commit commit $time >expect
test_expect_success \
'creating a tag with an empty -F messagefile should succeed' '
- git-tag -F emptyfile emptyfile-annotated-tag &&
+ git tag -F emptyfile emptyfile-annotated-tag &&
get_tag_msg emptyfile-annotated-tag >actual &&
test_cmp expect actual
'
EOF
test_expect_success \
'extra blanks in the message for an annotated tag should be removed' '
- git-tag -F blanksfile blanks-annotated-tag &&
+ git tag -F blanksfile blanks-annotated-tag &&
get_tag_msg blanks-annotated-tag >actual &&
test_cmp expect actual
'
get_tag_header blank-annotated-tag $commit commit $time >expect
test_expect_success \
'creating a tag with blank -m message with spaces should succeed' '
- git-tag -m " " blank-annotated-tag &&
+ git tag -m " " blank-annotated-tag &&
get_tag_msg blank-annotated-tag >actual &&
test_cmp expect actual
'
get_tag_header blankfile-annotated-tag $commit commit $time >expect
test_expect_success \
'creating a tag with blank -F messagefile with spaces should succeed' '
- git-tag -F blankfile blankfile-annotated-tag &&
+ git tag -F blankfile blankfile-annotated-tag &&
get_tag_msg blankfile-annotated-tag >actual &&
test_cmp expect actual
'
get_tag_header blanknonlfile-annotated-tag $commit commit $time >expect
test_expect_success \
'creating a tag with -F file of spaces and no newline should succeed' '
- git-tag -F blanknonlfile blanknonlfile-annotated-tag &&
+ git tag -F blanknonlfile blanknonlfile-annotated-tag &&
get_tag_msg blanknonlfile-annotated-tag >actual &&
test_cmp expect actual
'
EOF
test_expect_success \
'creating a tag using a -F messagefile with #comments should succeed' '
- git-tag -F commentsfile comments-annotated-tag &&
+ git tag -F commentsfile comments-annotated-tag &&
get_tag_msg comments-annotated-tag >actual &&
test_cmp expect actual
'
get_tag_header comment-annotated-tag $commit commit $time >expect
test_expect_success \
'creating a tag with a #comment in the -m message should succeed' '
- git-tag -m "#comment" comment-annotated-tag &&
+ git tag -m "#comment" comment-annotated-tag &&
get_tag_msg comment-annotated-tag >actual &&
test_cmp expect actual
'
get_tag_header commentfile-annotated-tag $commit commit $time >expect
test_expect_success \
'creating a tag with #comments in the -F messagefile should succeed' '
- git-tag -F commentfile commentfile-annotated-tag &&
+ git tag -F commentfile commentfile-annotated-tag &&
get_tag_msg commentfile-annotated-tag >actual &&
test_cmp expect actual
'
get_tag_header commentnonlfile-annotated-tag $commit commit $time >expect
test_expect_success \
'creating a tag with a file of #comment and no newline should succeed' '
- git-tag -F commentnonlfile commentnonlfile-annotated-tag &&
+ git tag -F commentnonlfile commentnonlfile-annotated-tag &&
get_tag_msg commentnonlfile-annotated-tag >actual &&
test_cmp expect actual
'
test_expect_success \
'listing the one-line message of a non-signed tag should succeed' '
- git-tag -m "A msg" tag-one-line &&
+ git tag -m "A msg" tag-one-line &&
echo "tag-one-line" >expect &&
- git-tag -l | grep "^tag-one-line" >actual &&
+ git tag -l | grep "^tag-one-line" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l | grep "^tag-one-line" >actual &&
+ git tag -n0 -l | grep "^tag-one-line" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l tag-one-line >actual &&
+ git tag -n0 -l tag-one-line >actual &&
test_cmp expect actual &&
echo "tag-one-line A msg" >expect &&
- git-tag -n1 -l | grep "^tag-one-line" >actual &&
+ git tag -n1 -l | grep "^tag-one-line" >actual &&
test_cmp expect actual &&
- git-tag -n -l | grep "^tag-one-line" >actual &&
+ git tag -n -l | grep "^tag-one-line" >actual &&
test_cmp expect actual &&
- git-tag -n1 -l tag-one-line >actual &&
+ git tag -n1 -l tag-one-line >actual &&
test_cmp expect actual &&
- git-tag -n2 -l tag-one-line >actual &&
+ git tag -n2 -l tag-one-line >actual &&
test_cmp expect actual &&
- git-tag -n999 -l tag-one-line >actual &&
+ git tag -n999 -l tag-one-line >actual &&
test_cmp expect actual
'
test_expect_success \
'listing the zero-lines message of a non-signed tag should succeed' '
- git-tag -m "" tag-zero-lines &&
+ git tag -m "" tag-zero-lines &&
echo "tag-zero-lines" >expect &&
- git-tag -l | grep "^tag-zero-lines" >actual &&
+ git tag -l | grep "^tag-zero-lines" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l | grep "^tag-zero-lines" >actual &&
+ git tag -n0 -l | grep "^tag-zero-lines" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l tag-zero-lines >actual &&
+ git tag -n0 -l tag-zero-lines >actual &&
test_cmp expect actual &&
echo "tag-zero-lines " >expect &&
- git-tag -n1 -l | grep "^tag-zero-lines" >actual &&
+ git tag -n1 -l | grep "^tag-zero-lines" >actual &&
test_cmp expect actual &&
- git-tag -n -l | grep "^tag-zero-lines" >actual &&
+ git tag -n -l | grep "^tag-zero-lines" >actual &&
test_cmp expect actual &&
- git-tag -n1 -l tag-zero-lines >actual &&
+ git tag -n1 -l tag-zero-lines >actual &&
test_cmp expect actual &&
- git-tag -n2 -l tag-zero-lines >actual &&
+ git tag -n2 -l tag-zero-lines >actual &&
test_cmp expect actual &&
- git-tag -n999 -l tag-zero-lines >actual &&
+ git tag -n999 -l tag-zero-lines >actual &&
test_cmp expect actual
'
echo 'tag line three' >>annotagmsg
test_expect_success \
'listing many message lines of a non-signed tag should succeed' '
- git-tag -F annotagmsg tag-lines &&
+ git tag -F annotagmsg tag-lines &&
echo "tag-lines" >expect &&
- git-tag -l | grep "^tag-lines" >actual &&
+ git tag -l | grep "^tag-lines" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l | grep "^tag-lines" >actual &&
+ git tag -n0 -l | grep "^tag-lines" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l tag-lines >actual &&
+ git tag -n0 -l tag-lines >actual &&
test_cmp expect actual &&
echo "tag-lines tag line one" >expect &&
- git-tag -n1 -l | grep "^tag-lines" >actual &&
+ git tag -n1 -l | grep "^tag-lines" >actual &&
test_cmp expect actual &&
- git-tag -n -l | grep "^tag-lines" >actual &&
+ git tag -n -l | grep "^tag-lines" >actual &&
test_cmp expect actual &&
- git-tag -n1 -l tag-lines >actual &&
+ git tag -n1 -l tag-lines >actual &&
test_cmp expect actual &&
echo " tag line two" >>expect &&
- git-tag -n2 -l | grep "^ *tag.line" >actual &&
+ git tag -n2 -l | grep "^ *tag.line" >actual &&
test_cmp expect actual &&
- git-tag -n2 -l tag-lines >actual &&
+ git tag -n2 -l tag-lines >actual &&
test_cmp expect actual &&
echo " tag line three" >>expect &&
- git-tag -n3 -l | grep "^ *tag.line" >actual &&
+ git tag -n3 -l | grep "^ *tag.line" >actual &&
test_cmp expect actual &&
- git-tag -n3 -l tag-lines >actual &&
+ git tag -n3 -l tag-lines >actual &&
test_cmp expect actual &&
- git-tag -n4 -l | grep "^ *tag.line" >actual &&
+ git tag -n4 -l | grep "^ *tag.line" >actual &&
test_cmp expect actual &&
- git-tag -n4 -l tag-lines >actual &&
+ git tag -n4 -l tag-lines >actual &&
test_cmp expect actual &&
- git-tag -n99 -l | grep "^ *tag.line" >actual &&
+ git tag -n99 -l | grep "^ *tag.line" >actual &&
test_cmp expect actual &&
- git-tag -n99 -l tag-lines >actual &&
+ git tag -n99 -l tag-lines >actual &&
test_cmp expect actual
'
test_expect_success \
'trying to verify an annotated non-signed tag should fail' '
tag_exists annotated-tag &&
- test_must_fail git-tag -v annotated-tag
+ test_must_fail git tag -v annotated-tag
'
test_expect_success \
'trying to verify a file-annotated non-signed tag should fail' '
tag_exists file-annotated-tag &&
- test_must_fail git-tag -v file-annotated-tag
+ test_must_fail git tag -v file-annotated-tag
'
test_expect_success \
'trying to verify two annotated non-signed tags should fail' '
tag_exists annotated-tag file-annotated-tag &&
- test_must_fail git-tag -v annotated-tag file-annotated-tag
+ test_must_fail git tag -v annotated-tag file-annotated-tag
'
# creating and verifying signed tags:
echo 'A signed tag message' >>expect
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success 'creating a signed tag with -m message should succeed' '
- git-tag -s -m "A signed tag message" signed-tag &&
+ git tag -s -m "A signed tag message" signed-tag &&
get_tag_msg signed-tag >actual &&
test_cmp expect actual
'
./fakeeditor >>expect
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success '-u implies signed tag' '
- GIT_EDITOR=./fakeeditor git-tag -u CDDE430D implied-sign &&
+ GIT_EDITOR=./fakeeditor git tag -u CDDE430D implied-sign &&
get_tag_msg implied-sign >actual &&
test_cmp expect actual
'
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with -F messagefile should succeed' '
- git-tag -s -F sigmsgfile file-signed-tag &&
+ git tag -s -F sigmsgfile file-signed-tag &&
get_tag_msg file-signed-tag >actual &&
test_cmp expect actual
'
cat siginputmsg >>expect
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success 'creating a signed tag with -F - should succeed' '
- git-tag -s -F - stdin-signed-tag <siginputmsg &&
+ git tag -s -F - stdin-signed-tag <siginputmsg &&
get_tag_msg stdin-signed-tag >actual &&
test_cmp expect actual
'
./fakeeditor >>expect
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success '-s implies annotated tag' '
- GIT_EDITOR=./fakeeditor git-tag -s implied-annotate &&
+ GIT_EDITOR=./fakeeditor git tag -s implied-annotate &&
get_tag_msg implied-annotate >actual &&
test_cmp expect actual
'
'trying to create a signed tag with non-existing -F file should fail' '
! test -f nonexistingfile &&
! tag_exists nosigtag &&
- test_must_fail git-tag -s -F nonexistingfile nosigtag &&
+ test_must_fail git tag -s -F nonexistingfile nosigtag &&
! tag_exists nosigtag
'
test_expect_success 'verifying a signed tag should succeed' \
- 'git-tag -v signed-tag'
+ 'git tag -v signed-tag'
test_expect_success 'verifying two signed tags in one command should succeed' \
- 'git-tag -v signed-tag file-signed-tag'
+ 'git tag -v signed-tag file-signed-tag'
test_expect_success \
'verifying many signed and non-signed tags should fail' '
- test_must_fail git-tag -v signed-tag annotated-tag &&
- test_must_fail git-tag -v file-annotated-tag file-signed-tag &&
- test_must_fail git-tag -v annotated-tag \
+ test_must_fail git tag -v signed-tag annotated-tag &&
+ test_must_fail git tag -v file-annotated-tag file-signed-tag &&
+ test_must_fail git tag -v annotated-tag \
file-signed-tag file-annotated-tag &&
- test_must_fail git-tag -v signed-tag annotated-tag file-signed-tag
+ test_must_fail git tag -v signed-tag annotated-tag file-signed-tag
'
test_expect_success 'verifying a forged tag should fail' '
sed -e "s/signed-tag/forged-tag/" |
git mktag) &&
git tag forged-tag $forged &&
- test_must_fail git-tag -v forged-tag
+ test_must_fail git tag -v forged-tag
'
# blank and empty messages for signed tags:
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with an empty -m message should succeed' '
- git-tag -s -m "" empty-signed-tag &&
+ git tag -s -m "" empty-signed-tag &&
get_tag_msg empty-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v empty-signed-tag
+ git tag -v empty-signed-tag
'
>sigemptyfile
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with an empty -F messagefile should succeed' '
- git-tag -s -F sigemptyfile emptyfile-signed-tag &&
+ git tag -s -F sigemptyfile emptyfile-signed-tag &&
get_tag_msg emptyfile-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v emptyfile-signed-tag
+ git tag -v emptyfile-signed-tag
'
printf '\n\n \n\t\nLeading blank lines\n' > sigblanksfile
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'extra blanks in the message for a signed tag should be removed' '
- git-tag -s -F sigblanksfile blanks-signed-tag &&
+ git tag -s -F sigblanksfile blanks-signed-tag &&
get_tag_msg blanks-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v blanks-signed-tag
+ git tag -v blanks-signed-tag
'
get_tag_header blank-signed-tag $commit commit $time >expect
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with a blank -m message should succeed' '
- git-tag -s -m " " blank-signed-tag &&
+ git tag -s -m " " blank-signed-tag &&
get_tag_msg blank-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v blank-signed-tag
+ git tag -v blank-signed-tag
'
echo ' ' >sigblankfile
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with blank -F file with spaces should succeed' '
- git-tag -s -F sigblankfile blankfile-signed-tag &&
+ git tag -s -F sigblankfile blankfile-signed-tag &&
get_tag_msg blankfile-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v blankfile-signed-tag
+ git tag -v blankfile-signed-tag
'
printf ' ' >sigblanknonlfile
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with spaces and no newline should succeed' '
- git-tag -s -F sigblanknonlfile blanknonlfile-signed-tag &&
+ git tag -s -F sigblanknonlfile blanknonlfile-signed-tag &&
get_tag_msg blanknonlfile-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v signed-tag
+ git tag -v signed-tag
'
# messages with commented lines for signed tags:
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with a -F file with #comments should succeed' '
- git-tag -s -F sigcommentsfile comments-signed-tag &&
+ git tag -s -F sigcommentsfile comments-signed-tag &&
get_tag_msg comments-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v comments-signed-tag
+ git tag -v comments-signed-tag
'
get_tag_header comment-signed-tag $commit commit $time >expect
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with #commented -m message should succeed' '
- git-tag -s -m "#comment" comment-signed-tag &&
+ git tag -s -m "#comment" comment-signed-tag &&
get_tag_msg comment-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v comment-signed-tag
+ git tag -v comment-signed-tag
'
echo '#comment' >sigcommentfile
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with #commented -F messagefile should succeed' '
- git-tag -s -F sigcommentfile commentfile-signed-tag &&
+ git tag -s -F sigcommentfile commentfile-signed-tag &&
get_tag_msg commentfile-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v commentfile-signed-tag
+ git tag -v commentfile-signed-tag
'
printf '#comment' >sigcommentnonlfile
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag with a #comment and no newline should succeed' '
- git-tag -s -F sigcommentnonlfile commentnonlfile-signed-tag &&
+ git tag -s -F sigcommentnonlfile commentnonlfile-signed-tag &&
get_tag_msg commentnonlfile-signed-tag >actual &&
test_cmp expect actual &&
- git-tag -v commentnonlfile-signed-tag
+ git tag -v commentnonlfile-signed-tag
'
# listing messages for signed tags:
test_expect_success \
'listing the one-line message of a signed tag should succeed' '
- git-tag -s -m "A message line signed" stag-one-line &&
+ git tag -s -m "A message line signed" stag-one-line &&
echo "stag-one-line" >expect &&
- git-tag -l | grep "^stag-one-line" >actual &&
+ git tag -l | grep "^stag-one-line" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l | grep "^stag-one-line" >actual &&
+ git tag -n0 -l | grep "^stag-one-line" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l stag-one-line >actual &&
+ git tag -n0 -l stag-one-line >actual &&
test_cmp expect actual &&
echo "stag-one-line A message line signed" >expect &&
- git-tag -n1 -l | grep "^stag-one-line" >actual &&
+ git tag -n1 -l | grep "^stag-one-line" >actual &&
test_cmp expect actual &&
- git-tag -n -l | grep "^stag-one-line" >actual &&
+ git tag -n -l | grep "^stag-one-line" >actual &&
test_cmp expect actual &&
- git-tag -n1 -l stag-one-line >actual &&
+ git tag -n1 -l stag-one-line >actual &&
test_cmp expect actual &&
- git-tag -n2 -l stag-one-line >actual &&
+ git tag -n2 -l stag-one-line >actual &&
test_cmp expect actual &&
- git-tag -n999 -l stag-one-line >actual &&
+ git tag -n999 -l stag-one-line >actual &&
test_cmp expect actual
'
test_expect_success \
'listing the zero-lines message of a signed tag should succeed' '
- git-tag -s -m "" stag-zero-lines &&
+ git tag -s -m "" stag-zero-lines &&
echo "stag-zero-lines" >expect &&
- git-tag -l | grep "^stag-zero-lines" >actual &&
+ git tag -l | grep "^stag-zero-lines" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l | grep "^stag-zero-lines" >actual &&
+ git tag -n0 -l | grep "^stag-zero-lines" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l stag-zero-lines >actual &&
+ git tag -n0 -l stag-zero-lines >actual &&
test_cmp expect actual &&
echo "stag-zero-lines " >expect &&
- git-tag -n1 -l | grep "^stag-zero-lines" >actual &&
+ git tag -n1 -l | grep "^stag-zero-lines" >actual &&
test_cmp expect actual &&
- git-tag -n -l | grep "^stag-zero-lines" >actual &&
+ git tag -n -l | grep "^stag-zero-lines" >actual &&
test_cmp expect actual &&
- git-tag -n1 -l stag-zero-lines >actual &&
+ git tag -n1 -l stag-zero-lines >actual &&
test_cmp expect actual &&
- git-tag -n2 -l stag-zero-lines >actual &&
+ git tag -n2 -l stag-zero-lines >actual &&
test_cmp expect actual &&
- git-tag -n999 -l stag-zero-lines >actual &&
+ git tag -n999 -l stag-zero-lines >actual &&
test_cmp expect actual
'
echo 'stag line three' >>sigtagmsg
test_expect_success \
'listing many message lines of a signed tag should succeed' '
- git-tag -s -F sigtagmsg stag-lines &&
+ git tag -s -F sigtagmsg stag-lines &&
echo "stag-lines" >expect &&
- git-tag -l | grep "^stag-lines" >actual &&
+ git tag -l | grep "^stag-lines" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l | grep "^stag-lines" >actual &&
+ git tag -n0 -l | grep "^stag-lines" >actual &&
test_cmp expect actual &&
- git-tag -n0 -l stag-lines >actual &&
+ git tag -n0 -l stag-lines >actual &&
test_cmp expect actual &&
echo "stag-lines stag line one" >expect &&
- git-tag -n1 -l | grep "^stag-lines" >actual &&
+ git tag -n1 -l | grep "^stag-lines" >actual &&
test_cmp expect actual &&
- git-tag -n -l | grep "^stag-lines" >actual &&
+ git tag -n -l | grep "^stag-lines" >actual &&
test_cmp expect actual &&
- git-tag -n1 -l stag-lines >actual &&
+ git tag -n1 -l stag-lines >actual &&
test_cmp expect actual &&
echo " stag line two" >>expect &&
- git-tag -n2 -l | grep "^ *stag.line" >actual &&
+ git tag -n2 -l | grep "^ *stag.line" >actual &&
test_cmp expect actual &&
- git-tag -n2 -l stag-lines >actual &&
+ git tag -n2 -l stag-lines >actual &&
test_cmp expect actual &&
echo " stag line three" >>expect &&
- git-tag -n3 -l | grep "^ *stag.line" >actual &&
+ git tag -n3 -l | grep "^ *stag.line" >actual &&
test_cmp expect actual &&
- git-tag -n3 -l stag-lines >actual &&
+ git tag -n3 -l stag-lines >actual &&
test_cmp expect actual &&
- git-tag -n4 -l | grep "^ *stag.line" >actual &&
+ git tag -n4 -l | grep "^ *stag.line" >actual &&
test_cmp expect actual &&
- git-tag -n4 -l stag-lines >actual &&
+ git tag -n4 -l stag-lines >actual &&
test_cmp expect actual &&
- git-tag -n99 -l | grep "^ *stag.line" >actual &&
+ git tag -n99 -l | grep "^ *stag.line" >actual &&
test_cmp expect actual &&
- git-tag -n99 -l stag-lines >actual &&
+ git tag -n99 -l stag-lines >actual &&
test_cmp expect actual
'
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag pointing to a tree should succeed' '
- git-tag -s -m "A message for a tree" tree-signed-tag HEAD^{tree} &&
+ git tag -s -m "A message for a tree" tree-signed-tag HEAD^{tree} &&
get_tag_msg tree-signed-tag >actual &&
test_cmp expect actual
'
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag pointing to a blob should succeed' '
- git-tag -s -m "A message for a blob" blob-signed-tag HEAD:foo &&
+ git tag -s -m "A message for a blob" blob-signed-tag HEAD:foo &&
get_tag_msg blob-signed-tag >actual &&
test_cmp expect actual
'
echo '-----BEGIN PGP SIGNATURE-----' >>expect
test_expect_success \
'creating a signed tag pointing to another tag should succeed' '
- git-tag -s -m "A message for another tag" tag-signed-tag signed-tag &&
+ git tag -s -m "A message for another tag" tag-signed-tag signed-tag &&
get_tag_msg tag-signed-tag >actual &&
test_cmp expect actual
'
# try to sign with bad user.signingkey
git config user.signingkey BobTheMouse
test_expect_success \
- 'git-tag -s fails if gpg is misconfigured' \
+ 'git tag -s fails if gpg is misconfigured' \
'test_must_fail git tag -s -m tail tag-gpg-failure'
git config --unset user.signingkey
rm -rf gpghome
test_expect_success \
'verify signed tag fails when public key is not present' \
- 'test_must_fail git-tag -v signed-tag'
+ 'test_must_fail git tag -v signed-tag'
test_expect_success \
- 'git-tag -a fails if tag annotation is empty' '
+ 'git tag -a fails if tag annotation is empty' '
! (GIT_EDITOR=cat git tag -a initial-comment)
'
# Copyright (c) 2006 Shawn Pearce
#
-test_description='git-reset should cull empty subdirs'
+test_description='git reset should cull empty subdirs'
. ./test-lib.sh
test_expect_success \
'mkdir path0 &&
cp ../../COPYING path0/COPYING &&
git add path0/COPYING &&
- git-commit -m add -a'
+ git commit -m add -a'
test_expect_success \
'creating second files' \
git add path1/COPYING &&
git add COPYING &&
git add path0/COPYING-TOO &&
- git-commit -m change -a'
+ git commit -m change -a'
test_expect_success \
'resetting tree HEAD^' \
- 'git-reset --hard HEAD^'
+ 'git reset --hard HEAD^'
test_expect_success \
'checking initial files exist after rewind' \
# Copyright (c) 2007 Carlos Rica
#
-test_description='git-reset
+test_description='git reset
-Documented tests for git-reset'
+Documented tests for git reset'
. ./test-lib.sh
#!/bin/sh
-test_description='git-reset in a bare repository'
+test_description='git reset in a bare repository'
. ./test-lib.sh
test_expect_success 'setup non-bare' '
# Copyright (c) 2006 Junio C Hamano
#
-test_description='git-checkout tests.
+test_description='git checkout tests.
Creates master, forks renamer and side branches from it.
Test switching across them.
# Copyright (c) 2007 Michael Spang
#
-test_description='git-clean basic tests'
+test_description='git clean basic tests'
. ./test-lib.sh
echo build >.gitignore &&
echo \*.o >>.gitignore &&
git add . &&
- git-commit -m setup &&
+ git commit -m setup &&
touch src/part2.c README &&
git add .
'
-test_expect_success 'git-clean' '
+test_expect_success 'git clean' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean &&
+ git clean &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean src/' '
+test_expect_success 'git clean src/' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean src/ &&
+ git clean src/ &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean src/ src/' '
+test_expect_success 'git clean src/ src/' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean src/ src/ &&
+ git clean src/ src/ &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean with prefix' '
+test_expect_success 'git clean with prefix' '
mkdir -p build docs src/test &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so src/test/1.c &&
- (cd src/ && git-clean) &&
+ (cd src/ && git clean) &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean with relative prefix' '
+test_expect_success 'git clean with relative prefix' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
}
'
-test_expect_success 'git-clean with absolute path' '
+test_expect_success 'git clean with absolute path' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
}
'
-test_expect_success 'git-clean with out of work tree relative path' '
+test_expect_success 'git clean with out of work tree relative path' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
)
'
-test_expect_success 'git-clean with out of work tree absolute path' '
+test_expect_success 'git clean with out of work tree absolute path' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
)
'
-test_expect_success 'git-clean -d with prefix and path' '
+test_expect_success 'git clean -d with prefix and path' '
mkdir -p build docs src/feature &&
touch a.out src/part3.c src/feature/file.c docs/manual.txt obj.o build/lib.so &&
- (cd src/ && git-clean -d feature/) &&
+ (cd src/ && git clean -d feature/) &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean symbolic link' '
+test_expect_success 'git clean symbolic link' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
ln -s docs/manual.txt src/part4.c
- git-clean &&
+ git clean &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean with wildcard' '
+test_expect_success 'git clean with wildcard' '
touch a.clean b.clean other.c &&
- git-clean "*.clean" &&
+ git clean "*.clean" &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean -n' '
+test_expect_success 'git clean -n' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean -n &&
+ git clean -n &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean -d' '
+test_expect_success 'git clean -d' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean -d &&
+ git clean -d &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean -d src/ examples/' '
+test_expect_success 'git clean -d src/ examples/' '
mkdir -p build docs examples &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so examples/1.c &&
- git-clean -d src/ examples/ &&
+ git clean -d src/ examples/ &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean -x' '
+test_expect_success 'git clean -x' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean -x &&
+ git clean -x &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean -d -x' '
+test_expect_success 'git clean -d -x' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean -d -x &&
+ git clean -d -x &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean -X' '
+test_expect_success 'git clean -X' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean -X &&
+ git clean -X &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
'
-test_expect_success 'git-clean -d -X' '
+test_expect_success 'git clean -d -X' '
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean -d -X &&
+ git clean -d -X &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
mkdir -p build docs &&
touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&
- git-clean -n &&
+ git clean -n &&
test -f Makefile &&
test -f README &&
test -f src/part1.c &&
test_expect_success 'clean.requireForce and -f' '
- git-clean -f &&
+ git clean -f &&
test -f README &&
test -f src/part1.c &&
test -f src/part2.c &&
test_description='Basic porcelain support for submodules
This test tries to verify basic sanity of the init, update and status
-subcommands of git-submodule.
+subcommands of git submodule.
'
. ./test-lib.sh
#
test_expect_success 'Prepare submodule testing' '
: > t &&
- git-add t &&
- git-commit -m "initial commit" &&
+ git add t &&
+ git commit -m "initial commit" &&
git branch initial HEAD &&
mkdir init &&
cd init &&
git init &&
echo a >a &&
git add a &&
- git-commit -m "submodule commit 1" &&
- git-tag -a -m "rev-1" rev-1 &&
+ git commit -m "submodule commit 1" &&
+ git tag -a -m "rev-1" rev-1 &&
rev1=$(git rev-parse HEAD) &&
if test -z "$rev1"
then
echo a >a &&
echo z >z &&
git add a init z &&
- git-commit -m "super commit 1" &&
+ git commit -m "super commit 1" &&
mv init .subrepo &&
GIT_CONFIG=.gitmodules git config submodule.example.url git://example.com/init.git
'
test_expect_success 'status should fail for unmapped paths' '
- if git-submodule status
+ if git submodule status
then
echo "[OOPS] submodule status succeeded"
false
'
test_expect_success 'status should only print one line' '
- lines=$(git-submodule status | wc -l) &&
+ lines=$(git submodule status | wc -l) &&
test $lines = 1
'
test_expect_success 'status should initially be "missing"' '
- git-submodule status | grep "^-$rev1"
+ git submodule status | grep "^-$rev1"
'
test_expect_success 'init should register submodule url in .git/config' '
- git-submodule init &&
+ git submodule init &&
url=$(git config submodule.example.url) &&
if test "$url" != "git://example.com/init.git"
then
test_expect_success 'update should fail when path is used by a file' '
echo "hello" >init &&
- if git-submodule update
+ if git submodule update
then
echo "[OOPS] update should have failed"
false
test_expect_success 'update should fail when path is used by a nonempty directory' '
mkdir init &&
echo "hello" >init/a &&
- if git-submodule update
+ if git submodule update
then
echo "[OOPS] update should have failed"
false
test_expect_success 'update should work when path is an empty dir' '
rm -rf init &&
mkdir init &&
- git-submodule update &&
+ git submodule update &&
head=$(cd init && git rev-parse HEAD) &&
if test -z "$head"
then
'
test_expect_success 'status should be "up-to-date" after update' '
- git-submodule status | grep "^ $rev1"
+ git submodule status | grep "^ $rev1"
'
test_expect_success 'status should be "modified" after submodule commit' '
cd init &&
echo b >b &&
git add b &&
- git-commit -m "submodule commit 2" &&
+ git commit -m "submodule commit 2" &&
rev2=$(git rev-parse HEAD) &&
cd .. &&
if test -z "$rev2"
echo "[OOPS] submodule git rev-parse returned nothing"
false
fi &&
- git-submodule status | grep "^+$rev2"
+ git submodule status | grep "^+$rev2"
'
test_expect_success 'the --cached sha1 should be rev1' '
- git-submodule --cached status | grep "^+$rev1"
+ git submodule --cached status | grep "^+$rev1"
'
test_expect_success 'git diff should report the SHA1 of the new submodule commit' '
- git-diff | grep "^+Subproject commit $rev2"
+ git diff | grep "^+Subproject commit $rev2"
'
test_expect_success 'update should checkout rev1' '
- git-submodule update init &&
+ git submodule update init &&
head=$(cd init && git rev-parse HEAD) &&
if test -z "$head"
then
'
test_expect_success 'status should be "up-to-date" after update' '
- git-submodule status | grep "^ $rev1"
+ git submodule status | grep "^ $rev1"
'
test_expect_success 'checkout superproject with subproject already present' '
- git-checkout initial &&
- git-checkout master
+ git checkout initial &&
+ git checkout master
'
test_expect_success 'apply submodule diff' '
git commit -m "change subproject"
) &&
git update-index --add init &&
- git-commit -m "change init" &&
- git-format-patch -1 --stdout >P.diff &&
+ git commit -m "change init" &&
+ git format-patch -1 --stdout >P.diff &&
git checkout second &&
git apply --index P.diff &&
D=$(git diff --cached master) &&
test_description='Summary support for submodules
-This test tries to verify the sanity of summary subcommand of git-submodule.
+This test tries to verify the sanity of summary subcommand of git submodule.
'
. ./test-lib.sh
# Copyright (c) 2007 Steven Grimm
#
-test_description='git-commit
+test_description='git commit
Tests for selected commit options.'
# FIXME: Test the various index usages, -i and -o, test reflog,
# signoff
-test_description='git-commit'
+test_description='git commit'
. ./test-lib.sh
test_tick
test_expect_success \
"initial status" \
"echo 'bongo bongo' >file &&
- git-add file && \
- git-status | grep 'Initial commit'"
+ git add file && \
+ git status | grep 'Initial commit'"
test_expect_success \
"fail initial amend" \
- "test_must_fail git-commit --amend"
+ "test_must_fail git commit --amend"
test_expect_success \
"initial commit" \
- "git-commit -m initial"
+ "git commit -m initial"
test_expect_success \
"invalid options 1" \
- "test_must_fail git-commit -m foo -m bar -F file"
+ "test_must_fail git commit -m foo -m bar -F file"
test_expect_success \
"invalid options 2" \
- "test_must_fail git-commit -C HEAD -m illegal"
+ "test_must_fail git commit -C HEAD -m illegal"
test_expect_success \
"using paths with -a" \
"echo King of the bongo >file &&
- test_must_fail git-commit -m foo -a file"
+ test_must_fail git commit -m foo -a file"
test_expect_success \
"using paths with --interactive" \
"echo bong-o-bong >file &&
- ! (echo 7 | git-commit -m foo --interactive file)"
+ ! (echo 7 | git commit -m foo --interactive file)"
test_expect_success \
"using invalid commit with -C" \
- "test_must_fail git-commit -C bogus"
+ "test_must_fail git commit -C bogus"
test_expect_success \
"testing nothing to commit" \
- "test_must_fail git-commit -m initial"
+ "test_must_fail git commit -m initial"
test_expect_success \
"next commit" \
"echo 'bongo bongo bongo' >file \
- git-commit -m next -a"
+ git commit -m next -a"
test_expect_success \
"commit message from non-existing file" \
"echo 'more bongo: bongo bongo bongo bongo' >file && \
- test_must_fail git-commit -F gah -a"
+ test_must_fail git commit -F gah -a"
# Empty except stray tabs and spaces on a few lines.
sed -e 's/@$//' >msg <<EOF
EOF
test_expect_success \
"empty commit message" \
- "test_must_fail git-commit -F msg -a"
+ "test_must_fail git commit -F msg -a"
test_expect_success \
"commit message from file" \
"echo 'this is the commit message, coming from a file' >msg && \
- git-commit -F msg -a"
+ git commit -F msg -a"
cat >editor <<\EOF
#!/bin/sh
test_expect_success \
"amend commit" \
- "VISUAL=./editor git-commit --amend"
+ "VISUAL=./editor git commit --amend"
test_expect_success \
"passing -m and -F" \
"echo 'enough with the bongos' >file && \
- test_must_fail git-commit -F msg -m amending ."
+ test_must_fail git commit -F msg -m amending ."
test_expect_success \
"using message from other commit" \
- "git-commit -C HEAD^ ."
+ "git commit -C HEAD^ ."
cat >editor <<\EOF
#!/bin/sh
test_expect_success \
"editing message from other commit" \
"echo 'hula hula' >file && \
- VISUAL=./editor git-commit -c HEAD^ -a"
+ VISUAL=./editor git commit -c HEAD^ -a"
test_expect_success \
"message from stdin" \
"echo 'silly new contents' >file && \
- echo commit message from stdin | git-commit -F - -a"
+ echo commit message from stdin | git commit -F - -a"
test_expect_success \
"overriding author from command line" \
"echo 'gak' >file && \
- git-commit -m 'author' --author 'Rubber Duck <rduck@convoy.org>' -a"
+ git commit -m 'author' --author 'Rubber Duck <rduck@convoy.org>' -a"
test_expect_success \
"interactive add" \
- "echo 7 | git-commit --interactive | grep 'What now'"
+ "echo 7 | git commit --interactive | grep 'What now'"
test_expect_success \
"showing committed revisions" \
- "git-rev-list HEAD >current"
+ "git rev-list HEAD >current"
# We could just check the head sha1, but checking each commit makes it
# easier to isolate bugs.
EOF
test_expect_success \
- 'validate git-rev-list output.' \
+ 'validate git rev-list output.' \
'diff current expected'
test_expect_success 'partial commit that involves removal (1)' '
# Copyright (c) 2007 Johannes E. Schindelin
#
-test_description='git-status'
+test_description='git status'
. ./test-lib.sh
cat >> "$HOOK" <<'EOF'
if test "$2" = commit; then
- source=$(git-rev-parse "$3")
+ source=$(git rev-parse "$3")
else
source=${2-default}
fi
#!/bin/sh
-test_description='git-status for submodule'
+test_description='git status for submodule'
. ./test-lib.sh
# Copyright (c) 2007 Lars Hjemli
#
-test_description='git-merge
+test_description='git merge
Testing basic merge operations/option parsing.'
#!/bin/sh
-test_description='git-merge
+test_description='git merge
Testing pull.* configuration parsing.'
#!/bin/sh
-test_description='git-merge
+test_description='git merge
Testing octopus merge with more than 25 refs.'
#!/bin/sh
-test_description='git-merge
+test_description='git merge
Testing octopus merge when reducing parents to independent branches.'
#!/bin/sh
-test_description='git-merge
+test_description='git merge
Testing merge when using a custom message for the merge commit.'
#!/bin/sh
-test_description='git-merge
+test_description='git merge
Testing the resolve strategy.'
# Copyright (c) 2008 Charles Bailey
#
-test_description='git-mergetool
+test_description='git mergetool
Testing basic merge tool invocation'
#!/bin/sh
-test_description='git-repack works correctly'
+test_description='git repack works correctly'
. ./test-lib.sh
#!/bin/sh
-test_description='git-send-email'
+test_description='git send-email'
. ./test-lib.sh
PROG='git send-email'
! grep -v "^master[ ]\+master$" < out
'
+#------------
+# CVS ANNOTATE
+#------------
+
+cd "$WORKDIR"
+test_expect_success 'cvs annotate' '
+ cd cvswork &&
+ GIT_CONFIG="$git_config" cvs annotate merge >../out &&
+ sed -e "s/ .*//" ../out >../actual &&
+ for i in 3 1 1 1 1 1 1 1 2 4; do echo 1.$i; done >../expect &&
+ test_cmp ../expect ../actual
+'
+
test_done
update_tree_entry(t2);
continue;
}
- die("git-diff-tree: internal error");
+ die("git diff-tree: internal error");
}
return 0;
}
/* .data is just a boolean: any non-NULL value will do */
rev_list.data = create_full_pack ? &rev_list : NULL;
if (start_async(&rev_list))
- die("git-upload-pack: unable to fork git-rev-list");
+ die("git upload-pack: unable to fork git-rev-list");
argv[arg++] = "pack-objects";
argv[arg++] = "--stdout";
pack_objects.argv = argv;
if (start_command(&pack_objects))
- die("git-upload-pack: unable to fork git-pack-objects");
+ die("git upload-pack: unable to fork git-pack-objects");
/* We read from pack_objects.err to capture stderr output for
* progress bar, and pack_objects.out to capture the pack data.
}
if (finish_command(&pack_objects)) {
- error("git-upload-pack: git-pack-objects died with error.");
+ error("git upload-pack: git-pack-objects died with error.");
goto fail;
}
if (finish_async(&rev_list))
fail:
send_client_data(3, abort_msg, sizeof(abort_msg));
- die("git-upload-pack: %s", abort_msg);
+ die("git upload-pack: %s", abort_msg);
}
static int got_sha1(char *hex, unsigned char *sha1)
int we_knew_they_have = 0;
if (get_sha1_hex(hex, sha1))
- die("git-upload-pack: expected SHA1 object, got '%s'", hex);
+ die("git upload-pack: expected SHA1 object, got '%s'", hex);
if (!has_sha1_file(sha1))
return -1;
packet_write(1, "NAK\n");
return -1;
}
- die("git-upload-pack: expected SHA1 list, got '%s'", line);
+ die("git upload-pack: expected SHA1 list, got '%s'", line);
}
}
}
if (prefixcmp(line, "want ") ||
get_sha1_hex(line+5, sha1_buf))
- die("git-upload-pack: protocol error, "
+ die("git upload-pack: protocol error, "
"expected to get sha, not '%s'", line);
if (strstr(line+45, "multi_ack"))
multi_ack = 1;
*/
o = lookup_object(sha1_buf);
if (!o || !(o->flags & OUR_REF))
- die("git-upload-pack: not our ref %s", line+5);
+ die("git upload-pack: not our ref %s", line+5);
if (!(o->flags & WANTED)) {
o->flags |= WANTED;
add_object_array(o, NULL, &want_obj);
struct object *o = parse_object(sha1);
if (!o)
- die("git-upload-pack: cannot find object %s:", sha1_to_hex(sha1));
+ die("git upload-pack: cannot find object %s:", sha1_to_hex(sha1));
if (capabilities)
packet_write(1, "%s %s%c%s\n", sha1_to_hex(sha1), refname,