diff backend when it exits with a non-zero status.
* "git grep" allows to paint (or not paint) partial matches on
- context lines whenshowing "grep -C<num>" output in color.
+ context lines when showing "grep -C<num>" output in color.
* "log --date=iso" uses a slight variant of ISO 8601 format that is
made more human readable. A new "--date=iso-strict" option gives
e.g. "hello_BASE_4321.c").
* The temporary files "git mergetools" uses can be placed in a newly
- creted temporary directory, instead of the current directory, by
+ created temporary directory, instead of the current directory, by
setting the mergetool.writeToTemp configuration variable.
* "git mergetool" understands "--tool bc" now, as version 4 of
public repository really point the commits the pusher wanted to,
without having to "trust" the server.
- * "git interpret-trailers" is a new filter to programatically edit
+ * "git interpret-trailers" is a new filter to programmatically edit
the tail end of the commit log messages.
* "git help everyday" shows the "Everyday Git in 20 commands or so"
(merge b12d045 da/mergetool-meld later to maint).
* "git pack-objects" forgot to disable the codepath to generate
- object recheability bitmap when it needs to split the resulting
+ object reachability bitmap when it needs to split the resulting
pack.
(merge 2113471 jk/pack-objects-no-bitmap-when-splitting later to maint).
confusion and troubles with script usage, aliases that
hide existing Git commands are ignored. Arguments are split by
spaces, the usual shell quoting and escaping is supported.
- quote pair and a backslash can be used to quote them.
+ A quote pair or a backslash can be used to quote them.
+
If the alias expansion is prefixed with an exclamation point,
it will be treated as a shell command. For example, defining
default value is 50. Setting this to 0 disables it.
gc.autodetach::
- Make `git gc --auto` return immediately andrun in background
+ Make `git gc --auto` return immediately and run in background
if the system supports it. Default is true.
gc.packrefs::
same command-line interface as GPG, namely, to verify a detached
signature, "gpg --verify $file - <$signature" is run, and the
program is expected to signal a good signature by exiting with
- code 0, and to generate an ascii-armored detached signature, the
+ code 0, and to generate an ASCII-armored detached signature, the
standard input of "gpg -bsau $key" is fed with the contents to be
signed, and the program is expected to send the result to its
standard output.
Can be overridden by the 'GIT_HTTP_USER_AGENT' environment variable.
http.<url>.*::
- Any of the http.* options above can be applied selectively to some urls.
+ Any of the http.* options above can be applied selectively to some URLs.
For a config key to match a URL, each element of the config key is
compared to that of the URL, in the following order:
+
+
All URLs are normalized before attempting any matching (the password part,
if embedded in the URL, is always ignored for matching purposes) so that
-equivalent urls that are simply spelled differently will match properly.
-Environment variable settings always override any matches. The urls that are
+equivalent URLs that are simply spelled differently will match properly.
+Environment variable settings always override any matches. The URLs that are
matched against are those given directly to Git commands. This means any URLs
visited as a result of a redirection do not participate in matching.
files which are not currently tracked by Git. Directories which
contain only untracked files, are shown with the directory name
only. Showing untracked files means that Git needs to lstat() all
- all the files in the whole repository, which might be slow on some
+ the files in the whole repository, which might be slow on some
systems. So, this variable controls how the commands displays
the untracked files. Possible values are:
+
of people. And as there are often many people who depend (sometimes
critically) on such software, regressions are a really big problem.
-One such software is the linux kernel. And if we look at the linux
+One such software is the Linux kernel. And if we look at the Linux
kernel, we can see that a lot of time and effort is spent to fight
regressions. The release cycle start with a 2 weeks long merge
window. Then the first release candidate (rc) version is tagged. And
time. But this is not the end of the fight yet, as of course it
continues after the release.
-And then this is what Ingo Molnar (a well known linux kernel
+And then this is what Ingo Molnar (a well known Linux kernel
developer) says about his use of git bisect:
_____________
filter by pattern::
This shows the files and directories to be deleted and issues an
- "Input ignore patterns>>" prompt. You can input space-seperated
+ "Input ignore patterns>>" prompt. You can input space-separated
patterns to exclude files and directories from deletion.
E.g. "*.c *.h" will excludes files end with ".c" and ".h" from
deletion. When you are satisfied with the filtered result, press
OPTIONS
-------
Use `<path>` to store credentials. The file will have its
filesystem permissions set to prevent other users on the system
* Multiple tags on the same revision are not imported.
If you suspect that any of these issues may apply to the repository you
-want to imort, consider using cvs2git:
+want to import, consider using cvs2git:
* cvs2git (part of cvs2svn), `http://subversion.apache.org/`
authdb = /etc/cvsserver/passwd
------
-The format of these files is username followed by the crypted password,
+The format of these files is username followed by the encrypted password,
for example:
------
* By default The BFG takes full advantage of multi-core machines,
cleansing commit file-trees in parallel. git-filter-branch cleans
- commits sequentially (ie in a single-threaded manner), though it
- _is_ possible to write filters that include their own parallellism,
+ commits sequentially (i.e. in a single-threaded manner), though it
+ _is_ possible to write filters that include their own parallelism,
in the scripts executed against each commit.
* The http://rtyley.github.io/bfg-repo-cleaner/#examples[command options]
NAME
----
-git-interpret-trailers - help add stuctured information into commit messages
+git-interpret-trailers - help add structured information into commit messages
SYNOPSIS
--------
By default the new trailer will appear at the end of all the existing
trailers. If there is no existing trailer, the new trailer will appear
-after the commit message part of the ouput, and, if there is no line
+after the commit message part of the output, and, if there is no line
with only spaces at the end of the commit message part, one blank line
will be added before the new trailer.
When reading trailers, there can be whitespaces before and after the
token, the separator and the value. There can also be whitespaces
-indide the token and the value.
+inside the token and the value.
Note that 'trailers' do not follow and are not intended to follow many
rules for RFC 822 headers. For example they do not follow the line
consider. Repetitions of this option accumulate exclusion patterns
up to the next `--all`, `--branches`, `--tags`, `--remotes`, or
`--glob` option (other options or arguments do not clear
- accumlated patterns).
+ accumulated patterns).
+
The patterns given should not begin with `refs/heads`, `refs/tags`, or
`refs/remotes` when applied to `--branches`, `--tags`, or `--remotes`,
--username=<user>;;
For transports that SVN handles authentication for (http,
https, and plain svn), specify the username. For other
- transports (eg svn+ssh://), you must include the username in
- the URL, eg svn+ssh://foo@svn.bar.com/project
+ transports (e.g. svn+ssh://), you must include the username in
+ the URL, e.g. svn+ssh://foo@svn.bar.com/project
--prefix=<prefix>;;
This allows one to specify a prefix which is prepended
to the names of remotes if trunk/branches/tags are
split-index mode is already enabled and `--split-index` is
given again, all changes in $GIT_DIR/index are pushed back to
the shared index file. This mode is designed for very large
- indexes that take a signficant amount of time to read or write.
+ indexes that take a significant amount of time to read or write.
\--::
Do not interpret any more arguments as options.
may want to override its decision, either because a blob contains binary
data later in the file, or because the content, while technically
composed of text characters, is opaque to a human reader. For example,
-many postscript files contain only ascii characters, but produce noisy
+many postscript files contain only ASCII characters, but produce noisy
and meaningless diffs.
The simplest way to mark a file as binary is to unset the diff
However, one may also want to specify other diff driver attributes. For
example, you might want to use `textconv` to convert postscript files to
-an ascii representation for human viewing, but otherwise treat them as
+an ASCII representation for human viewing, but otherwise treat them as
binary files. You cannot specify both `-diff` and `diff=ps` attributes.
The solution is to use the `diff.*.binary` config option:
This hook can be used in conjunction with a corresponding pre-commit hook to
save and restore any form of metadata associated with the working tree
-(eg: permissions/ownership, ACLS, etc). See contrib/hooks/setgitperms.perl
+(e.g.: permissions/ownership, ACLS, etc). See contrib/hooks/setgitperms.perl
for an example of how to do this.
pre-push
Put a backslash ("`\`") in front of the first hash for patterns
that begin with a hash.
- - Trailing spaces are ignored unless they are quoted with backlash
+ - Trailing spaces are ignored unless they are quoted with backslash
("`\`").
- An optional prefix "`!`" which negates the pattern; any
signature" letters (which optionally is terminated by another colon `:`),
and the remainder is the pattern to match against the path.
The "magic signature" consists of ASCII symbols that are neither
-alphanumeric, glob, regex special charaters nor colon.
+alphanumeric, glob, regex special characters nor colon.
The optional colon that terminates the "magic signature" can be
omitted if the pattern begins with a character that does not belong to
"magic signature" symbol set and is not a colon.
Reading the zlib source code, I found that "incorrect data check" means
that the adler-32 checksum at the end of the zlib data did not match the
inflated data. So stepping the data through zlib would not help, as it
-did not fail until the very end, when we realize the crc does not match.
+did not fail until the very end, when we realize the CRC does not match.
The problematic bytes could be anywhere in the object data.
The first thing I did was pull the broken data out of the packfile. I
-------
I let it run to completion, and got a few more hits at the end (where it
-was munging the crc to match our broken data). So there was a good
+was munging the CRC to match our broken data). So there was a good
chance this middle hit was the source of the problem.
I confirmed by tweaking the byte in a hex editor, zlib inflating the
consider. Repetitions of this option accumulate exclusion patterns
up to the next `--all`, `--branches`, `--tags`, `--remotes`, or
`--glob` option (other options or arguments do not clear
- accumlated patterns).
+ accumulated patterns).
+
The patterns given should not begin with `refs/heads`, `refs/tags`, or
`refs/remotes` when applied to `--branches`, `--tags`, or `--remotes`,
on. Replaced entries may have empty path names to save space.
The remaining index entries after replaced ones will be added to the
- final index. These added entries are also sorted by entry namme then
+ final index. These added entries are also sorted by entry name then
stage.
ASCII characters except space (i.e., the byte range 32 < x < 127), and
are typically of the form "package/version" (e.g., "git/1.8.3.1"). The
agent strings are purely informative for statistics and debugging
-purposes, and MUST NOT be used to programatically assume the presence
+purposes, and MUST NOT be used to programmatically assume the presence
or absence of particular features.
shallow
#!/bin/sh
GVF=GIT-VERSION-FILE
-DEF_VER=v2.2.0-rc0
+DEF_VER=v2.2.0-rc1
LF='
'
fetch_prune_config = git_config_bool(k, v);
return 0;
}
- return 0;
+ return git_default_config(k, v, cb);
}
static int parse_refmap_arg(const struct option *opt, const char *arg, int unset)
return result;
}
-int create_bundle(struct bundle_header *header, const char *path,
- int argc, const char **argv)
+static int write_pack_data(int bundle_fd, struct lock_file *lock, struct rev_info *revs)
{
- static struct lock_file lock;
- int bundle_fd = -1;
- int bundle_to_stdout;
- int i, ref_count = 0;
- struct strbuf buf = STRBUF_INIT;
- struct rev_info revs;
- struct child_process rls = CHILD_PROCESS_INIT;
- FILE *rls_fout;
+ struct child_process pack_objects = CHILD_PROCESS_INIT;
+ int i;
- bundle_to_stdout = !strcmp(path, "-");
- if (bundle_to_stdout)
- bundle_fd = 1;
- else
- bundle_fd = hold_lock_file_for_update(&lock, path,
- LOCK_DIE_ON_ERROR);
+ argv_array_pushl(&pack_objects.args,
+ "pack-objects", "--all-progress-implied",
+ "--stdout", "--thin", "--delta-base-offset",
+ NULL);
+ pack_objects.in = -1;
+ pack_objects.out = bundle_fd;
+ pack_objects.git_cmd = 1;
+ if (start_command(&pack_objects))
+ return error(_("Could not spawn pack-objects"));
- /* write signature */
- write_or_die(bundle_fd, bundle_signature, strlen(bundle_signature));
+ /*
+ * start_command closed bundle_fd if it was > 1
+ * so set the lock fd to -1 so commit_lock_file()
+ * won't fail trying to close it.
+ */
+ lock->fd = -1;
- /* init revs to list objects for pack-objects later */
- save_commit_buffer = 0;
- init_revisions(&revs, NULL);
+ for (i = 0; i < revs->pending.nr; i++) {
+ struct object *object = revs->pending.objects[i].item;
+ if (object->flags & UNINTERESTING)
+ write_or_die(pack_objects.in, "^", 1);
+ write_or_die(pack_objects.in, sha1_to_hex(object->sha1), 40);
+ write_or_die(pack_objects.in, "\n", 1);
+ }
+ close(pack_objects.in);
+ if (finish_command(&pack_objects))
+ return error(_("pack-objects died"));
+ return 0;
+}
+
+static int compute_and_write_prerequisites(int bundle_fd,
+ struct rev_info *revs,
+ int argc, const char **argv)
+{
+ struct child_process rls = CHILD_PROCESS_INIT;
+ struct strbuf buf = STRBUF_INIT;
+ FILE *rls_fout;
+ int i;
- /* write prerequisites */
argv_array_pushl(&rls.args,
"rev-list", "--boundary", "--pretty=oneline",
NULL);
if (!get_sha1_hex(buf.buf + 1, sha1)) {
struct object *object = parse_object_or_die(sha1, buf.buf);
object->flags |= UNINTERESTING;
- add_pending_object(&revs, object, buf.buf);
+ add_pending_object(revs, object, buf.buf);
}
} else if (!get_sha1_hex(buf.buf, sha1)) {
struct object *object = parse_object_or_die(sha1, buf.buf);
fclose(rls_fout);
if (finish_command(&rls))
return error(_("rev-list died"));
+ return 0;
+}
- /* write references */
- argc = setup_revisions(argc, argv, &revs, NULL);
-
- if (argc > 1)
- return error(_("unrecognized argument: %s"), argv[1]);
-
- object_array_remove_duplicates(&revs.pending);
+/*
+ * Write out bundle refs based on the tips already
+ * parsed into revs.pending. As a side effect, may
+ * manipulate revs.pending to include additional
+ * necessary objects (like tags).
+ *
+ * Returns the number of refs written, or negative
+ * on error.
+ */
+static int write_bundle_refs(int bundle_fd, struct rev_info *revs)
+{
+ int i;
+ int ref_count = 0;
- for (i = 0; i < revs.pending.nr; i++) {
- struct object_array_entry *e = revs.pending.objects + i;
+ for (i = 0; i < revs->pending.nr; i++) {
+ struct object_array_entry *e = revs->pending.objects + i;
unsigned char sha1[20];
char *ref;
const char *display_ref;
display_ref = (flag & REF_ISSYMREF) ? e->name : ref;
if (e->item->type == OBJ_TAG &&
- !is_tag_in_date_range(e->item, &revs)) {
+ !is_tag_in_date_range(e->item, revs)) {
e->item->flags |= UNINTERESTING;
continue;
}
*/
obj = parse_object_or_die(sha1, e->name);
obj->flags |= SHOWN;
- add_pending_object(&revs, obj, e->name);
+ add_pending_object(revs, obj, e->name);
}
free(ref);
continue;
write_or_die(bundle_fd, "\n", 1);
free(ref);
}
- if (!ref_count)
- die(_("Refusing to create empty bundle."));
/* end header */
write_or_die(bundle_fd, "\n", 1);
+ return ref_count;
+}
- /* write pack */
- memset(&rls, 0, sizeof(rls));
- argv_array_pushl(&rls.args,
- "pack-objects", "--all-progress-implied",
- "--stdout", "--thin", "--delta-base-offset",
- NULL);
- rls.in = -1;
- rls.out = bundle_fd;
- rls.git_cmd = 1;
- if (start_command(&rls))
- return error(_("Could not spawn pack-objects"));
+int create_bundle(struct bundle_header *header, const char *path,
+ int argc, const char **argv)
+{
+ static struct lock_file lock;
+ int bundle_fd = -1;
+ int bundle_to_stdout;
+ int ref_count = 0;
+ struct rev_info revs;
- /*
- * start_command closed bundle_fd if it was > 1
- * so set the lock fd to -1 so commit_lock_file()
- * won't fail trying to close it.
- */
- lock.fd = -1;
+ bundle_to_stdout = !strcmp(path, "-");
+ if (bundle_to_stdout)
+ bundle_fd = 1;
+ else
+ bundle_fd = hold_lock_file_for_update(&lock, path,
+ LOCK_DIE_ON_ERROR);
+
+ /* write signature */
+ write_or_die(bundle_fd, bundle_signature, strlen(bundle_signature));
+
+ /* init revs to list objects for pack-objects later */
+ save_commit_buffer = 0;
+ init_revisions(&revs, NULL);
+
+ /* write prerequisites */
+ if (compute_and_write_prerequisites(bundle_fd, &revs, argc, argv))
+ return -1;
+
+ argc = setup_revisions(argc, argv, &revs, NULL);
+
+ if (argc > 1)
+ return error(_("unrecognized argument: %s"), argv[1]);
+
+ object_array_remove_duplicates(&revs.pending);
+
+ ref_count = write_bundle_refs(bundle_fd, &revs);
+ if (!ref_count)
+ die(_("Refusing to create empty bundle."));
+ else if (ref_count < 0)
+ return -1;
+
+ /* write pack */
+ if (write_pack_data(bundle_fd, &lock, &revs))
+ return -1;
- for (i = 0; i < revs.pending.nr; i++) {
- struct object *object = revs.pending.objects[i].item;
- if (object->flags & UNINTERESTING)
- write_or_die(rls.in, "^", 1);
- write_or_die(rls.in, sha1_to_hex(object->sha1), 40);
- write_or_die(rls.in, "\n", 1);
- }
- close(rls.in);
- if (finish_command(&rls))
- return error(_("pack-objects died"));
if (!bundle_to_stdout) {
if (commit_lock_file(&lock))
die_errno(_("cannot create '%s'"), path);
flags);
if (subcnt < 0)
return subcnt;
+ if (!subcnt)
+ die("index cache-tree records empty sub-tree");
i += subcnt;
sub->count = subcnt; /* to be used in the next loop */
*skip_count += subskip;
if (fd_out != -1)
return -1;
- memset(&column_process, 0, sizeof(column_process));
+ child_process_init(&column_process);
argv = &column_process.args;
argv_array_push(argv, "column");
my @added;
my $in_hunk;
+# Some scripts may not realize that SIGPIPE is being ignored when launching the
+# pager--for instance scripts written in Python.
+$SIG{PIPE} = 'DEFAULT';
+
while (<>) {
if (!$in_hunk) {
print;
want.
Repeated splits of exactly the same history are
- guaranteed to be identical (ie. to produce the same
+ guaranteed to be identical (i.e. to produce the same
commit ids). Because of this, if you add new commits
and then re-split, the new commits will be attached as
commits on top of the history you generated last time,
int i;
int nparents = commit_list_count(commit->parents);
+ if (nparents > 1 && rev->first_parent_only)
+ nparents = 1;
+
diffqueues = xmalloc(nparents * sizeof(*diffqueues));
cand = xmalloc(nparents * sizeof(*cand));
parents = xmalloc(nparents * sizeof(*parents));
logfd = open(logfile, oflags, 0666);
if (logfd < 0) {
- if (!(oflags & O_CREAT) && errno == ENOENT)
+ if (!(oflags & O_CREAT) && (errno == ENOENT || errno == EISDIR))
return 0;
- if ((oflags & O_CREAT) && errno == EISDIR) {
+ if (errno == EISDIR) {
if (remove_empty_directories(logfile)) {
int save_errno = errno;
error("There are still logs under '%s'",
test $(git reflog master | wc -l) = 4
'
+test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '
+ test_when_finished "git branch -d a || git branch -d a/b" &&
+
+ git branch a/b master &&
+ echo "a/b@{0} branch: Created from master" >expect &&
+ git log -g --format="%gd %gs" a/b >actual &&
+ test_cmp expect actual &&
+ git branch -d a/b &&
+
+ # now logs/refs/heads/a is a stale directory, but
+ # we should move it out of the way to create "a" reflog
+ git branch a master &&
+ echo "a@{0} branch: Created from master" >expect &&
+ git log -g --format="%gd %gs" a >actual &&
+ test_cmp expect actual
+'
+
+test_expect_success 'stale dirs do not cause d/f conflicts (reflogs off)' '
+ test_when_finished "git branch -d a || git branch -d a/b" &&
+
+ git branch a/b master &&
+ echo "a/b@{0} branch: Created from master" >expect &&
+ git log -g --format="%gd %gs" a/b >actual &&
+ test_cmp expect actual &&
+ git branch -d a/b &&
+
+ # same as before, but we only create a reflog for "a" if
+ # it already exists, which it does not
+ git -c core.logallrefupdates=false branch a master &&
+ : >expect &&
+ git log -g --format="%gd %gs" a >actual &&
+ test_cmp expect actual
+'
+
test_done
test_must_fail git log -L ,$n:b.c
'
+test_expect_success '-L with --first-parent and a merge' '
+ git checkout parallel-change &&
+ git log --first-parent -L 1,1:b.c
+'
+
test_done
* hooks
* --porcelain output format
* hiderefs
+* reflogs
'
. ./test-lib.sh
test_cmp expect actual
'
+test_expect_success 'push into bare respects core.logallrefupdates' '
+ rm -rf dst.git &&
+ git init --bare dst.git &&
+ git -C dst.git config core.logallrefupdates true &&
+
+ # double push to test both with and without
+ # the actual pack transfer
+ git push dst.git master:one &&
+ echo "one@{0} push" >expect &&
+ git -C dst.git log -g --format="%gd %gs" one >actual &&
+ test_cmp expect actual &&
+
+ git push dst.git master:two &&
+ echo "two@{0} push" >expect &&
+ git -C dst.git log -g --format="%gd %gs" two >actual &&
+ test_cmp expect actual
+'
+
+test_expect_success 'fetch into bare respects core.logallrefupdates' '
+ rm -rf dst.git &&
+ git init --bare dst.git &&
+ (
+ cd dst.git &&
+ git config core.logallrefupdates true &&
+
+ # as above, we double-fetch to test both
+ # with and without pack transfer
+ git fetch .. master:one &&
+ echo "one@{0} fetch .. master:one: storing head" >expect &&
+ git log -g --format="%gd %gs" one >actual &&
+ test_cmp expect actual &&
+
+ git fetch .. master:two &&
+ echo "two@{0} fetch .. master:two: storing head" >expect &&
+ git log -g --format="%gd %gs" two >actual &&
+ test_cmp expect actual
+ )
+'
+
test_done
{
struct strbuf cmd = STRBUF_INIT;
struct strbuf buf = STRBUF_INIT;
- struct child_process cp;
+ struct child_process cp = CHILD_PROCESS_INIT;
const char *argv[] = {NULL, NULL};
const char *result;
strbuf_replace(&cmd, TRAILER_ARG_STRING, arg);
argv[0] = cmd.buf;
- memset(&cp, 0, sizeof(cp));
cp.argv = argv;
cp.env = local_repo_env;
cp.no_stdin = 1;
struct child_process *helper = get_helper(transport);
int i;
- memset(fastexport, 0, sizeof(*fastexport));
+ child_process_init(fastexport);
/* we need to duplicate helper->in because we want to use it after
* fastexport is done with it. */