Merge branch 'nd/status-auto-comment-char'
authorJunio C Hamano <gitster@pobox.com>
Fri, 6 Jun 2014 18:36:10 +0000 (11:36 -0700)
committerJunio C Hamano <gitster@pobox.com>
Fri, 6 Jun 2014 18:36:10 +0000 (11:36 -0700)
* nd/status-auto-comment-char:
commit: allow core.commentChar=auto for character auto selection
config: be strict on core.commentChar

156 files changed:
.gitignore
Documentation/RelNotes/1.9.4.txt [new file with mode: 0644]
Documentation/RelNotes/2.0.0.txt
Documentation/RelNotes/2.1.0.txt [new file with mode: 0644]
Documentation/config.txt
Documentation/git-grep.txt
Documentation/git-merge.txt
Documentation/git-mergetool.txt
Documentation/git-update-ref.txt
Documentation/git.txt
Documentation/revisions.txt
Documentation/technical/api-builtin.txt
Documentation/technical/api-hashmap.txt
Documentation/technical/api-strbuf.txt
GIT-VERSION-GEN
Makefile
RelNotes
builtin/apply.c
builtin/blame.c
builtin/checkout.c
builtin/clone.c
builtin/commit.c
builtin/grep.c
builtin/index-pack.c
builtin/merge.c
builtin/mv.c
builtin/notes.c
builtin/reflog.c
builtin/rerere.c
builtin/reset.c
builtin/tag.c
builtin/update-ref.c
cache.h
combine-diff.c
compat/mmap.c
compat/poll/poll.c
compat/vcbuild/include/alloca.h [deleted file]
compat/win32/alloca.h [new file with mode: 0644]
config.c
config.mak.uname
configure.ac
contrib/completion/git-prompt.sh
contrib/diffall/README [deleted file]
contrib/diffall/git-diffall [deleted file]
contrib/examples/builtin-fetch--tool.c
contrib/mw-to-git/git-remote-mediawiki.perl
contrib/mw-to-git/t/install-wiki.sh
contrib/mw-to-git/t/t9363-mw-to-git-export-import.sh
contrib/mw-to-git/t/t9365-continuing-queries.sh
contrib/mw-to-git/t/test-gitmw-lib.sh
contrib/remote-helpers/Makefile [deleted file]
contrib/remote-helpers/README [new file with mode: 0644]
contrib/remote-helpers/git-remote-bzr
contrib/remote-helpers/git-remote-hg
contrib/remote-helpers/test-bzr.sh [deleted file]
contrib/remote-helpers/test-hg-bidi.sh [deleted file]
contrib/remote-helpers/test-hg-hg-git.sh [deleted file]
contrib/remote-helpers/test-hg.sh [deleted file]
contrib/subtree/Makefile
contrib/subtree/git-subtree.sh
contrib/subtree/t/t7900-subtree.sh
contrib/svn-fe/svnrdump_sim.py
contrib/thunderbird-patch-inline/appp.sh
contrib/vim/README [deleted file]
diff.c
diff.h
environment.c
git-compat-util.h
git-gui/git-gui.sh
git-mergetool.sh
git-pull.sh
git-rebase--merge.sh
git-rebase.sh
git-request-pull.sh
git-send-email.perl
git-sh-setup.sh
git-stash.sh
git-submodule.sh
git-web--browse.sh
git.c
grep.c
imap-send.c
merge-recursive.c
mergetools/gvimdiff3 [new file with mode: 0644]
mergetools/vimdiff
mergetools/vimdiff3 [new file with mode: 0644]
notes-cache.c
notes-utils.c
pager.c
parse-options.h
perl/Git/SVN.pm
perl/Git/SVN/Log.pm
po/fr.po
pretty.c
read-cache.c
refs.c
refs.h
sequencer.c
strbuf.c
t/lib-credential.sh
t/lib-cvs.sh
t/lib-gpg.sh
t/perf/p5302-pack-index.sh
t/t0001-init.sh
t/t0010-racy-git.sh
t/t0020-crlf.sh
t/t0025-crlf-auto.sh
t/t0026-eol-config.sh
t/t0030-stripspace.sh
t/t0300-credentials.sh
t/t1000-read-tree-m-3way.sh
t/t1001-read-tree-m-2way.sh
t/t1002-read-tree-m-u-2way.sh
t/t1003-read-tree-prefix.sh
t/t1004-read-tree-m-u-wf.sh
t/t1020-subdirectory.sh
t/t1050-large.sh
t/t1300-repo-config.sh
t/t1400-update-ref.sh
t/t1410-reflog.sh
t/t1507-rev-parse-upstream.sh
t/t3404-rebase-interactive.sh
t/t3508-cherry-pick-many-commits.sh
t/t3905-stash-include-untracked.sh
t/t3910-mac-os-precompose.sh
t/t4006-diff-mode.sh
t/t4010-diff-pathspec.sh
t/t4012-diff-binary.sh
t/t4013-diff-various.sh
t/t4014-format-patch.sh
t/t4036-format-patch-signer-mime.sh
t/t4038-diff-combined.sh
t/t4057-diff-combined-paths.sh
t/t4107-apply-ignore-whitespace.sh
t/t4116-apply-reverse.sh
t/t4119-apply-config.sh
t/t4204-patch-id.sh
t/t5000-tar-tree.sh
t/t5150-request-pull.sh
t/t5537-fetch-shallow.sh
t/t6039-merge-ignorecase.sh [new file with mode: 0755]
t/t7004-tag.sh
t/t7007-show.sh
t/t7500-commit.sh
t/t7501-commit.sh
t/t7502-commit.sh
t/t7600-merge.sh
t/t7800-difftool.sh
t/t8003-blame-corner-cases.sh
t/t9903-bash-prompt.sh
tree-diff.c
unicode_width.h [new file with mode: 0644]
update_unicode.sh [new file with mode: 0755]
utf8.c
wrapper.c
wt-status.c
index dc600f9b36d09f0668064e044520c7ce633f09d8..42294e59a1fcf5d744199b6a0feafd4ca6e3eda1 100644 (file)
 /config.mak.autogen
 /config.mak.append
 /configure
+/unicode
 /tags
 /TAGS
 /cscope*
diff --git a/Documentation/RelNotes/1.9.4.txt b/Documentation/RelNotes/1.9.4.txt
new file mode 100644 (file)
index 0000000..e1d1835
--- /dev/null
@@ -0,0 +1,16 @@
+Git v1.9.4 Release Notes
+========================
+
+Fixes since v1.9.3
+------------------
+
+ * Commands that take pathspecs on the command line misbehaved when
+   the pathspec is given as an absolute pathname (which is a
+   practice not particularly encouraged) that points at a symbolic
+   link in the working tree.
+
+ * An earlier fix to the shell prompt script (in contrib/) for using
+   the PROMPT_COMMAND interface did not correctly check if the extra
+   code path needs to trigger, causing the branch name not to appear
+   when 'promptvars' option is disabled in bash or PROMPT_SUBST is
+   unset in zsh.
index 6e628d47995c58c5d46cb3a737bb7f5a983e8ac6..2617372a0c50391985b02595f43e148ff46df73f 100644 (file)
@@ -44,7 +44,7 @@ with "git diff-files --diff-filter=d").
 The default prefix for "git svn" has changed in Git 2.0.  For a long
 time, "git svn" created its remote-tracking branches directly under
 refs/remotes, but it now places them under refs/remotes/origin/ unless
-it is told otherwise with its --prefix option.
+it is told otherwise with its "--prefix" option.
 
 
 Updates since v1.9 series
@@ -53,7 +53,11 @@ Updates since v1.9 series
 UI, Workflows & Features
 
  * The "multi-mail" post-receive hook (in contrib/) has been updated
-   to a more recent version from the upstream.
+   to a more recent version from upstream.
+
+ * The "remote-hg/bzr" remote-helper interfaces (used to be in
+   contrib/) are no more.  They are now maintained separately as
+   third-party plug-ins in their own repositories.
 
  * "git gc --aggressive" learned "--depth" option and
    "gc.aggressiveDepth" configuration variable to allow use of a less
@@ -63,12 +67,13 @@ UI, Workflows & Features
    single strand-of-pearls is broken in its output.
 
  * The "rev-parse --parseopt" mechanism used by scripted Porcelains to
-   parse command line options and to give help text learned to take
+   parse command-line options and to give help text learned to take
    the argv-help (the placeholder string for an option parameter,
    e.g. "key-id" in "--gpg-sign=<key-id>").
 
  * The pattern to find where the function begins in C/C++ used in
-   "diff" and "grep -p" has been updated to help C++ source better.
+   "diff" and "grep -p" has been updated to improve viewing C++
+   sources.
 
  * "git rebase" learned to interpret a lone "-" as "@{-1}", the
    branch that we were previously on.
@@ -79,7 +84,7 @@ UI, Workflows & Features
    "--sort=version:refname".
 
  * Discard the accumulated "heuristics" to guess from which branch the
-   result wants to be pulled from and make sure what the end user
+   result wants to be pulled from and make sure that what the end user
    specified is not second-guessed by "git request-pull", to avoid
    mistakes.  When you pushed out your 'master' branch to your public
    repository as 'for-linus', use the new "master:for-linus" syntax to
@@ -88,9 +93,9 @@ UI, Workflows & Features
  * "git grep" learned to behave in a way similar to native grep when
    "-h" (no header) and "-c" (count) options are given.
 
- * "git push" via transport-helper interface (e.g. remote-hg) has
-   been updated to allow forced ref updates in a way similar to the
-   natively supported transports.
+ * "git push" via transport-helper interface has been updated to
+   allow forced ref updates in a way similar to the natively
+   supported transports.
 
  * The "simple" mode is the default for "git push".
 
@@ -114,28 +119,28 @@ UI, Workflows & Features
  * The progress indicators from various time-consuming commands have
    been marked for i18n/l10n.
 
- * "git notes -C <blob>" diagnoses an attempt to use an object that
-   is not a blob as an error.
+ * "git notes -C <blob>" diagnoses as an error an attempt to use an
+   object that is not a blob.
 
  * "git config" learned to read from the standard input when "-" is
    given as the value to its "--file" parameter (attempting an
-   operation to update the configuration in the standard input of
-   course is rejected).
+   operation to update the configuration in the standard input is
+   rejected, of course).
 
  * Trailing whitespaces in .gitignore files, unless they are quoted
    for fnmatch(3), e.g. "path\ ", are warned and ignored.  Strictly
-   speaking, this is a backward incompatible change, but very unlikely
+   speaking, this is a backward-incompatible change, but very unlikely
    to bite any sane user and adjusting should be obvious and easy.
 
- * Many commands that create commits, e.g. "pull", "rebase",
-   learned to take the --gpg-sign option on the command line.
+ * Many commands that create commits, e.g. "pull" and "rebase",
+   learned to take the "--gpg-sign" option on the command line.
 
  * "git commit" can be told to always GPG sign the resulting commit
-   by setting "commit.gpgsign" configuration variable to true (the
-   command line option --no-gpg-sign should override it).
+   by setting the "commit.gpgsign" configuration variable to "true"
+   (the command-line option "--no-gpg-sign" should override it).
 
  * "git pull" can be told to only accept fast-forward by setting the
-   new "pull.ff" configuration.
+   new "pull.ff" configuration variable.
 
  * "git reset" learned the "-N" option, which does not reset the index
    fully for paths the index knows about but the tree-ish the command
@@ -152,7 +157,7 @@ Performance, Internal Implementation, etc.
 
  * Uses of curl's "multi" interface and "easy" interface do not mix
    well when we attempt to reuse outgoing connections.  Teach the RPC
-   over http code, used in the smart HTTP transport, not to use the
+   over HTTP code, used in the smart HTTP transport, not to use the
    "easy" interface.
 
  * The bitmap-index feature from JGit has been ported, which should
@@ -186,24 +191,19 @@ notes for details).
  * The shell prompt script (in contrib/), when using the PROMPT_COMMAND
    interface, used an unsafe construct when showing the branch name in
    $PS1.
-   (merge 8976500 rh/prompt-pcmode-avoid-eval-on-refname later to maint).
-
- * The remote-helper interface to fast-import/fast-export via the
-   transport-helper has been tightened to avoid leaving the import
-   marks file from a failed/crashed run, as such a file that is out of
-   sync with the reality confuses a later invocation of itself.
+   (merge 1e4119c8 rh/prompt-pcmode-avoid-eval-on-refname later to maint).
 
- * "git rebase" used a POSIX shell construct FreeBSD /bin/sh does not
+ * "git rebase" used a POSIX shell construct FreeBSD's /bin/sh does not
    work well with.
    (merge 8cd6596 km/avoid-non-function-return-in-rebase later to maint).
 
  * zsh prompt (in contrib/) leaked unnecessary error messages.
 
- * bash completion (in contrib/) did not complete the refs and remotes
+ * Bash completion (in contrib/) did not complete the refs and remotes
    correctly given "git pu<TAB>" when "pu" is aliased to "push".
 
- * Some more Unicode codepoints defined in Unicode 6.3 as having zero
-   width have been taught to our display column counting logic.
+ * Some more Unicode code points, defined in Unicode 6.3 as having zero
+   width, have been taught to our display column counting logic.
    (merge d813ab9 tb/unicode-6.3-zero-width later to maint).
 
  * Some tests used shell constructs that did not work well on FreeBSD
@@ -217,7 +217,7 @@ notes for details).
  * "git diff --no-index -Mq a b" fell into an infinite loop.
    (merge ad1c3fb jc/fix-diff-no-index-diff-opt-parse later to maint).
 
- * "git fetch --prune", when the right-hand-side of multiple fetch
+ * "git fetch --prune", when the right-hand side of multiple fetch
    refspecs overlap (e.g. storing "refs/heads/*" to
    "refs/remotes/origin/*", while storing "refs/frotz/*" to
    "refs/remotes/origin/fr/*"), aggressively thought that lack of
@@ -272,7 +272,7 @@ notes for details).
    (merge 3c3e6f5 rr/doc-merge-strategies later to maint).
 
  * Serving objects from a shallow repository needs to write a
-   new file to hold the temporary shallow boundaries but it was not
+   new file to hold the temporary shallow boundaries, but it was not
    cleaned when we exit due to die() or a signal.
    (merge 7839632 jk/shallow-update-fix later to maint).
 
@@ -295,19 +295,19 @@ notes for details).
    ".git" tells us where it is.
    (merge fcfec8b da/difftool-git-files later to maint).
 
- * "git push" did not pay attention to branch.*.pushremote if it is
-   defined earlier than remote.pushdefault; the order of these two
+ * "git push" did not pay attention to "branch.*.pushremote" if it is
+   defined earlier than "remote.pushdefault"; the order of these two
    variables in the configuration file should not matter, but it did
    by mistake.
    (merge 98b406f jk/remote-pushremote-config-reading later to maint).
 
- * Codepaths that parse timestamps in commit objects have been
+ * Code paths that parse timestamps in commit objects have been
    tightened.
    (merge f80d1f9 jk/commit-dates-parsing-fix later to maint).
 
  * "git diff --external-diff" incorrectly fed the submodule directory
-   in the working tree to the external diff driver when it knew it is
-   the same as one of the versions being compared.
+   in the working tree to the external diff driver when it knew that it
+   is the same as one of the versions being compared.
    (merge aba4727 tr/diff-submodule-no-reuse-worktree later to maint).
 
  * "git reset" needs to refresh the index when working in a working
@@ -318,7 +318,7 @@ notes for details).
 
  * "git check-attr" when working on a repository with a working tree
    did not work well when the working tree was specified via the
-   --work-tree (and obviously with --git-dir) option.
+   "--work-tree" (and obviously with "--git-dir") option.
    (merge cdbf623 jc/check-attr-honor-working-tree later to maint).
 
  * "merge-recursive" was broken in 1.7.7 era and stopped working in
@@ -326,12 +326,12 @@ notes for details).
    involved.  This has been corrected.
    (merge 6e2068a bk/refresh-missing-ok-in-merge-recursive later to maint.)
 
- * "git rev-parse" was loose in rejecting command line arguments
+ * "git rev-parse" was loose in rejecting command-line arguments
    that do not make sense, e.g. "--default" without the required
    value for that option.
    (merge a43219f ds/rev-parse-required-args later to maint.)
 
- * include.path variable (or any variable that expects a path that
+ * "include.path" variable (or any variable that expects a path that
    can use ~username expansion) in the configuration file is not a
    boolean, but the code failed to check it.
    (merge 67beb60 jk/config-path-include-fix later to maint.)
@@ -340,23 +340,23 @@ notes for details).
    the pathspec is given as an absolute pathname (which is a
    practice not particularly encouraged) that points at a symbolic
    link in the working tree.
-   (merge later 655ee9e mw/symlinks to maint.)
+   (merge 6127ff6 mw/symlinks later to maint.)
 
  * "git diff --quiet -- pathspec1 pathspec2" sometimes did not return
-   correct status value.
+   the correct status value.
    (merge f34b205 nd/diff-quiet-stat-dirty later to maint.)
 
  * Attempting to deepen a shallow repository by fetching over smart
-   HTTP transport failed in the protocol exchange, when no-done
+   HTTP transport failed in the protocol exchange, when the no-done
    extension was used.  The fetching side waited for the list of
-   shallow boundary commits after the sending end stopped talking to
+   shallow boundary commits after the sending side stopped talking to
    it.
    (merge 0232852 nd/http-fetch-shallow-fix later to maint.)
 
  * Allow "git cmd path/", when the 'path' is where a submodule is
    bound to the top-level working tree, to match 'path', despite the
    extra and unnecessary trailing slash (such a slash is often
-   given by command line completion).
+   given by command-line completion).
    (merge 2e70c01 nd/submodule-pathspec-ending-with-slash later to maint.)
 
  * Documentation and in-code comments had many instances of mistaken
diff --git a/Documentation/RelNotes/2.1.0.txt b/Documentation/RelNotes/2.1.0.txt
new file mode 100644 (file)
index 0000000..ad53d0d
--- /dev/null
@@ -0,0 +1,86 @@
+Git v2.1 Release Notes
+======================
+
+Updates since v2.0
+------------------
+
+UI, Workflows & Features
+
+ * "git commit --date=<date>" option learned to read from more
+   timestamp formats, including "--date=now".
+
+ * "git grep" learned grep.fullname configuration variable to force
+   "--full-name" to be default.  This may cause regressions on
+   scripted users that do not expect this new behaviour.
+
+ * "git merge" without argument, even when there is an upstream
+   defined for the current branch, refused to run until
+   merge.defaultToUpstream is set to true.  Flip the default of that
+   configuration variable to true.
+
+ * "git mergetool" learned to drive the vimdiff3 backend.
+
+ * mergetool.prompt used to default to 'true', always asking "do you
+   really want to run the tool on this path?".  Among the two
+   purposes this prompt serves, ignore the use case to confirm that
+   the user wants to view particular path with the named tool, and
+   redefine the meaning of the prompt only to confirm the choice of
+   the tool made by the autodetection (for those who configured the
+   tool explicitly, the prompt shown for the latter purpose is
+   simply annoying).
+
+   Strictly speaking, this is a backward incompatible change and the
+   users need to explicitly set the variable to 'true' if they want
+   to resurrect the now-ignored use case.
+
+ * "git svn" learned to cope with malformed timestamps with only one
+   digit in the hour part, e.g. 2014-01-07T5:01:02.048176Z, emitted
+   by some broken subversion server implementations.
+
+
+Performance, Internal Implementation, etc.
+
+ * "git diff" that compares 3-or-more trees (e.g. parents and the
+   result of a merge) have been optimized.
+
+ * The API to update/delete references are being converted to handle
+   updates to multiple references in a transactional way.  As an
+   example, "update-ref --stdin [-z]" has been updated to use this
+   API.
+
+
+Also contains various documentation updates and code clean-ups.
+
+
+Fixes since v2.0
+----------------
+
+Unless otherwise noted, all the fixes since v2.0 in the maintenance
+track are contained in this release (see the maintenance releases'
+notes for details).
+
+ * "--ignore-space-change" option of "git apply" ignored the spaces
+   at the beginning of line too aggressively, which is inconsistent
+   with the option of the same name "diff" and "git diff" have.
+   (merge 14d3bb4 jc/apply-ignore-whitespace later to maint).
+
+ * "git blame" miscounted number of columns needed to show localized
+   timestamps, resulting in jaggy left-side-edge of the source code
+   lines in its output.
+   (merge dd75553 jx/blame-align-relative-time later to maint).
+
+ * We used to disable threaded "git index-pack" on platforms without
+   thread-safe pread(); use a different workaround for such
+   platforms to allow threaded "git index-pack".
+   (merge 3953949 nd/index-pack-one-fd-per-thread later to maint).
+
+ * "git rerere forget" did not work well when merge.conflictstyle
+   was set to a non-default value.
+   (merge de3d8bb fc/rerere-conflict-style later to maint).
+
+ * "git status", even though it is a read-only operation, tries to
+   update the index with refreshed lstat(2) info to optimize future
+   accesses to the working tree opportunistically, but this could
+   race with a "read-write" operation that modify the index while it
+   is running.  Detect such a race and avoid overwriting the index.
+   (merge 426ddee ym/fix-opportunistic-index-update-race later to maint).
index 9f3ce06c8734d2fca2752b28192aea9f8a19cf58..2e3c6655f0ab45dbab82e9440179b5a52bd73117 100644 (file)
@@ -489,7 +489,7 @@ core.deltaBaseCacheLimit::
        to avoid unpacking and decompressing frequently used base
        objects multiple times.
 +
-Default is 16 MiB on all platforms.  This should be reasonable
+Default is 96 MiB on all platforms.  This should be reasonable
 for all users/operating systems, except on the largest projects.
 You probably do not need to adjust this value.
 +
@@ -561,14 +561,19 @@ core.pager::
        configuration, then `$PAGER`, and then the default chosen at
        compile time (usually 'less').
 +
-When the `LESS` environment variable is unset, Git sets it to `FRSX`
+When the `LESS` environment variable is unset, Git sets it to `FRX`
 (if `LESS` environment variable is set, Git does not change it at
 all).  If you want to selectively override Git's default setting
-for `LESS`, you can set `core.pager` to e.g. `less -+S`.  This will
+for `LESS`, you can set `core.pager` to e.g. `less -S`.  This will
 be passed to the shell by Git, which will translate the final
-command to `LESS=FRSX less -+S`. The environment tells the command
-to set the `S` option to chop long lines but the command line
-resets it to the default to fold long lines.
+command to `LESS=FRX less -S`. The environment does not set the
+`S` option but the command line does, instructing less to truncate
+long lines. Similarly, setting `core.pager` to `less -+F` will
+deactivate the `F` option specified by the environment from the
+command-line, deactivating the "quit if one screen" behavior of
+`less`.  One can specifically activate some flags for particular
+commands: for example, setting `pager.blame` to `less -S` enables
+line truncation only for `git blame`.
 +
 Likewise, when the `LV` environment variable is unset, Git sets it
 to `-c`.  You can override this setting by exporting `LV` with
index f83733490f5a881f6f197b3b62000337c500ef9d..31811f16bdaac49d01d38dcdea82bb191942b1cf 100644 (file)
@@ -53,6 +53,9 @@ grep.extendedRegexp::
        option is ignored when the 'grep.patternType' option is set to a value
        other than 'default'.
 
+grep.fullName::
+       If set to true, enable '--full-name' option by default.
+
 
 OPTIONS
 -------
index a3c1fa332abb8d65051f6f6d5df6a14708fba980..cf2c374b710673e891f8337cb9bcc90d72be460a 100644 (file)
@@ -101,9 +101,8 @@ commit or stash your changes before running 'git merge'.
        Specifying more than one commit will create a merge with
        more than two parents (affectionately called an Octopus merge).
 +
-If no commit is given from the command line, and if `merge.defaultToUpstream`
-configuration variable is set, merge the remote-tracking branches
-that the current branch is configured to use as its upstream.
+If no commit is given from the command line, merge the remote-tracking
+branches that the current branch is configured to use as its upstream.
 See also the configuration section of this manual page.
 
 
index 07137f252b0fd57a671ef69884bea893cdd7767c..e846c2ed7f7f862f5324c0e95a2b17dabcaac58d 100644 (file)
@@ -71,11 +71,13 @@ success of the resolution after the custom tool has exited.
 --no-prompt::
        Don't prompt before each invocation of the merge resolution
        program.
+       This is the default if the merge resolution program is
+       explicitly specified with the `--tool` option or with the
+       `merge.tool` configuration variable.
 
 --prompt::
-       Prompt before each invocation of the merge resolution program.
-       This is the default behaviour; the option is provided to
-       override any configuration settings.
+       Prompt before each invocation of the merge resolution program
+       to give the user a chance to skip the path.
 
 TEMPORARY FILES
 ---------------
index 0a0a5512b3c62eb1179a3d5a9687949c39b2a9ef..c8f5ae5cb362276de94aa867af59818a75b04595 100644 (file)
@@ -68,7 +68,12 @@ performs all modifications together.  Specify commands of the form:
        option SP <opt> LF
 
 Quote fields containing whitespace as if they were strings in C source
-code.  Alternatively, use `-z` to specify commands without quoting:
+code; i.e., surrounded by double-quotes and with backslash escapes.
+Use 40 "0" characters or the empty string to specify a zero value.  To
+specify a missing value, omit the value and its preceding SP entirely.
+
+Alternatively, use `-z` to specify in NUL-terminated format, without
+quoting:
 
        update SP <ref> NUL <newvalue> NUL [<oldvalue>] NUL
        create SP <ref> NUL <newvalue> NUL
@@ -76,8 +81,12 @@ code.  Alternatively, use `-z` to specify commands without quoting:
        verify SP <ref> NUL [<oldvalue>] NUL
        option SP <opt> NUL
 
-Lines of any other format or a repeated <ref> produce an error.
-Command meanings are:
+In this format, use 40 "0" to specify a zero value, and use the empty
+string to specify a missing value.
+
+In either format, values can be specified in any form that Git
+recognizes as an object name.  Commands in any other format or a
+repeated <ref> produce an error.  Command meanings are:
 
 update::
        Set <ref> to <newvalue> after verifying <oldvalue>, if given.
@@ -102,9 +111,6 @@ option::
        The only valid option is `no-deref` to avoid dereferencing
        a symbolic ref.
 
-Use 40 "0" or the empty string to specify a zero value, except that
-with `-z` an empty <oldvalue> is considered missing.
-
 If all <ref>s can be locked with matching <oldvalue>s
 simultaneously, all modifications are performed.  Otherwise, no
 modifications are performed.  Note that while each individual
index a041cd006a5a32937fff7938d6396fc563b145c2..b075e0bed55c9cfd84b130ef6e93080ef3207517 100644 (file)
@@ -43,9 +43,15 @@ unreleased) version of Git, that is available from 'master'
 branch of the `git.git` repository.
 Documentation for older releases are available here:
 
-* link:v1.9.3/git.html[documentation for release 1.9.3]
+* link:v2.0.0/git.html[documentation for release 2.0]
 
 * release notes for
+  link:RelNotes/2.0.0.txt[2.0.0].
+
+* link:v1.9.4/git.html[documentation for release 1.9.4]
+
+* release notes for
+  link:RelNotes/1.9.4.txt[1.9.4],
   link:RelNotes/1.9.3.txt[1.9.3],
   link:RelNotes/1.9.2.txt[1.9.2],
   link:RelNotes/1.9.1.txt[1.9.1],
index 5a286d0d61ffc5b3daa00d7d550d5931a91b35ec..07961185fe0cddf78822aee75b43f206cbcd4579 100644 (file)
@@ -94,7 +94,9 @@ some output processing may assume ref names in UTF-8.
 '<branchname>@\{upstream\}', e.g. 'master@\{upstream\}', '@\{u\}'::
   The suffix '@\{upstream\}' to a branchname (short form '<branchname>@\{u\}')
   refers to the branch that the branch specified by branchname is set to build on
-  top of.  A missing branchname defaults to the current one.
+  top of (configured with `branch.<name>.remote` and
+  `branch.<name>.merge`).  A missing branchname defaults to the
+  current one.
 
 '<rev>{caret}', e.g. 'HEAD{caret}, v1.5.1{caret}0'::
   A suffix '{caret}' to a revision parameter means the first parent of
index e3d6e7a79a6c2136a796c5409d16feb8058e96d2..22a39b929932b78653d1d0b1a59fe35e5d5e75f5 100644 (file)
@@ -22,11 +22,14 @@ Git:
 where options is the bitwise-or of:
 
 `RUN_SETUP`::
-
-       Make sure there is a Git directory to work on, and if there is a
-       work tree, chdir to the top of it if the command was invoked
-       in a subdirectory.  If there is no work tree, no chdir() is
-       done.
+       If there is not a Git directory to work on, abort.  If there
+       is a work tree, chdir to the top of it if the command was
+       invoked in a subdirectory.  If there is no work tree, no
+       chdir() is done.
+
+`RUN_SETUP_GENTLY`::
+       If there is a Git directory, chdir as per RUN_SETUP, otherwise,
+       don't chdir anywhere.
 
 `USE_PAGER`::
 
index 42ca2347edd2e13c5e3132a077ac96777bbefa11..b977ae8bbb1f46ebb40d1d315e79262fe344f1c2 100644 (file)
@@ -166,7 +166,6 @@ Usage example
 -------------
 
 Here's a simple usage example that maps long keys to double values.
-[source,c]
 ------------
 struct hashmap map;
 
index 3350d97dda2408f92dc44c1e3216facc50257a50..4396be9dda07dfad679f834120b7f1aa2adb16c5 100644 (file)
@@ -121,10 +121,19 @@ Functions
 
 * Related to the contents of the buffer
 
+`strbuf_trim`::
+
+       Strip whitespace from the beginning and end of a string.
+       Equivalent to performing `strbuf_rtrim()` followed by `strbuf_ltrim()`.
+
 `strbuf_rtrim`::
 
        Strip whitespace from the end of a string.
 
+`strbuf_ltrim`::
+
+       Strip whitespace from the beginning of a string.
+
 `strbuf_cmp`::
 
        Compare two buffers. Returns an integer less than, equal to, or greater
index faecf33417b354e3e5ae51369f9a7724869df9cc..40adbf7bf79ad7d7800b71d2ca79418cdbddd3ed 100755 (executable)
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v2.0.0-rc3
+DEF_VER=v2.0.0.GIT
 
 LF='
 '
index a53f3a8326c2e62dc79bae7169d64137ac3dab20..07ea1058379ab963648d0df7fd2917e0d2efa8a7 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -30,6 +30,8 @@ all::
 # Define LIBPCREDIR=/foo/bar if your libpcre header and library files are in
 # /foo/bar/include and /foo/bar/lib directories.
 #
+# Define HAVE_ALLOCA_H if you have working alloca(3) defined in that header.
+#
 # Define NO_CURL if you do not have libcurl installed.  git-http-fetch and
 # git-http-push are not built, and you cannot use http:// and https://
 # transports (neither smart nor dumb).
@@ -183,9 +185,6 @@ all::
 # Define NO_STRUCT_ITIMERVAL if you don't have struct itimerval
 # This also implies NO_SETITIMER
 #
-# Define NO_THREAD_SAFE_PREAD if your pread() implementation is not
-# thread-safe. (e.g. compat/pread.c or cygwin)
-#
 # Define NO_FAST_WORKING_DIRECTORY if accessing objects in pack files is
 # generally faster on your platform than accessing the working directory.
 #
@@ -730,6 +729,7 @@ LIB_H += transport.h
 LIB_H += tree-walk.h
 LIB_H += tree.h
 LIB_H += unpack-trees.h
+LIB_H += unicode_width.h
 LIB_H += url.h
 LIB_H += urlmatch.h
 LIB_H += userdiff.h
@@ -1111,6 +1111,10 @@ ifdef USE_LIBPCRE
        EXTLIBS += -lpcre
 endif
 
+ifdef HAVE_ALLOCA_H
+       BASIC_CFLAGS += -DHAVE_ALLOCA_H
+endif
+
 ifdef NO_CURL
        BASIC_CFLAGS += -DNO_CURL
        REMOTE_CURL_PRIMARY =
@@ -1339,10 +1343,6 @@ endif
 ifdef NO_PREAD
        COMPAT_CFLAGS += -DNO_PREAD
        COMPAT_OBJS += compat/pread.o
-       NO_THREAD_SAFE_PREAD = YesPlease
-endif
-ifdef NO_THREAD_SAFE_PREAD
-       BASIC_CFLAGS += -DNO_THREAD_SAFE_PREAD
 endif
 ifdef NO_FAST_WORKING_DIRECTORY
        BASIC_CFLAGS += -DNO_FAST_WORKING_DIRECTORY
index e50885caa1043665dfe2d995e0a2f7a7a7bb51ca..bf760914010786c830233effc8b96ddacfb114fd 120000 (symlink)
--- a/RelNotes
+++ b/RelNotes
@@ -1 +1 @@
-Documentation/RelNotes/2.0.0.txt
\ No newline at end of file
+Documentation/RelNotes/2.1.0.txt
\ No newline at end of file
index 87439fad118a2671989120dd5993a17b4541e2db..9c5724eaccfaee62ff10eb097adc39ace351cade 100644 (file)
@@ -300,11 +300,13 @@ static int fuzzy_matchlines(const char *s1, size_t n1,
        while ((*last2 == '\r') || (*last2 == '\n'))
                last2--;
 
-       /* skip leading whitespace */
-       while (isspace(*s1) && (s1 <= last1))
-               s1++;
-       while (isspace(*s2) && (s2 <= last2))
-               s2++;
+       /* skip leading whitespaces, if both begin with whitespace */
+       if (s1 <= last1 && s2 <= last2 && isspace(*s1) && isspace(*s2)) {
+               while (isspace(*s1) && (s1 <= last1))
+                       s1++;
+               while (isspace(*s2) && (s2 <= last2))
+                       s2++;
+       }
        /* early return if both lines are empty */
        if ((s1 > last1) && (s2 > last2))
                return 1;
index 88cb7997274de6f9ab6f8a5944748334ce605f60..a52a279144bec14f2b2a0795f30e0c5871f60c1b 100644 (file)
@@ -1,7 +1,8 @@
 /*
  * Blame
  *
- * Copyright (c) 2006, Junio C Hamano
+ * Copyright (c) 2006, 2014 by its authors
+ * See COPYING for licensing conditions
  */
 
 #include "cache.h"
@@ -18,7 +19,9 @@
 #include "cache-tree.h"
 #include "string-list.h"
 #include "mailmap.h"
+#include "mergesort.h"
 #include "parse-options.h"
+#include "prio-queue.h"
 #include "utf8.h"
 #include "userdiff.h"
 #include "line-range.h"
@@ -83,11 +86,42 @@ static unsigned blame_copy_score;
  */
 struct origin {
        int refcnt;
+       /* Record preceding blame record for this blob */
        struct origin *previous;
+       /* origins are put in a list linked via `next' hanging off the
+        * corresponding commit's util field in order to make finding
+        * them fast.  The presence in this chain does not count
+        * towards the origin's reference count.  It is tempting to
+        * let it count as long as the commit is pending examination,
+        * but even under circumstances where the commit will be
+        * present multiple times in the priority queue of unexamined
+        * commits, processing the first instance will not leave any
+        * work requiring the origin data for the second instance.  An
+        * interspersed commit changing that would have to be
+        * preexisting with a different ancestry and with the same
+        * commit date in order to wedge itself between two instances
+        * of the same commit in the priority queue _and_ produce
+        * blame entries relevant for it.  While we don't want to let
+        * us get tripped up by this case, it certainly does not seem
+        * worth optimizing for.
+        */
+       struct origin *next;
        struct commit *commit;
+       /* `suspects' contains blame entries that may be attributed to
+        * this origin's commit or to parent commits.  When a commit
+        * is being processed, all suspects will be moved, either by
+        * assigning them to an origin in a different commit, or by
+        * shipping them to the scoreboard's ent list because they
+        * cannot be attributed to a different commit.
+        */
+       struct blame_entry *suspects;
        mmfile_t file;
        unsigned char blob_sha1[20];
        unsigned mode;
+       /* guilty gets set when shipping any suspects to the final
+        * blame list instead of other commits
+        */
+       char guilty;
        char path[FLEX_ARRAY];
 };
 
@@ -176,10 +210,22 @@ static inline struct origin *origin_incref(struct origin *o)
 static void origin_decref(struct origin *o)
 {
        if (o && --o->refcnt <= 0) {
+               struct origin *p, *l = NULL;
                if (o->previous)
                        origin_decref(o->previous);
                free(o->file.ptr);
-               free(o);
+               /* Should be present exactly once in commit chain */
+               for (p = o->commit->util; p; l = p, p = p->next) {
+                       if (p == o) {
+                               if (l)
+                                       l->next = p->next;
+                               else
+                                       o->commit->util = p->next;
+                               free(o);
+                               return;
+                       }
+               }
+               die("internal error in blame::origin_decref");
        }
 }
 
@@ -193,8 +239,12 @@ static void drop_origin_blob(struct origin *o)
 
 /*
  * Each group of lines is described by a blame_entry; it can be split
- * as we pass blame to the parents.  They form a linked list in the
- * scoreboard structure, sorted by the target line number.
+ * as we pass blame to the parents.  They are arranged in linked lists
+ * kept as `suspects' of some unprocessed origin, or entered (when the
+ * blame origin has been finalized) into the scoreboard structure.
+ * While the scoreboard structure is only sorted at the end of
+ * processing (according to final image line number), the lists
+ * attached to an origin are sorted by the target line number.
  */
 struct blame_entry {
        struct blame_entry *next;
@@ -210,15 +260,6 @@ struct blame_entry {
        /* the commit that introduced this group into the final image */
        struct origin *suspect;
 
-       /* true if the suspect is truly guilty; false while we have not
-        * checked if the group came from one of its parents.
-        */
-       char guilty;
-
-       /* true if the entry has been scanned for copies in the current parent
-        */
-       char scanned;
-
        /* the line number of the first line of this group in the
         * suspect's file; internally all line numbers are 0 based.
         */
@@ -230,12 +271,113 @@ struct blame_entry {
        unsigned score;
 };
 
+/*
+ * Any merge of blames happens on lists of blames that arrived via
+ * different parents in a single suspect.  In this case, we want to
+ * sort according to the suspect line numbers as opposed to the final
+ * image line numbers.  The function body is somewhat longish because
+ * it avoids unnecessary writes.
+ */
+
+static struct blame_entry *blame_merge(struct blame_entry *list1,
+                                      struct blame_entry *list2)
+{
+       struct blame_entry *p1 = list1, *p2 = list2,
+               **tail = &list1;
+
+       if (!p1)
+               return p2;
+       if (!p2)
+               return p1;
+
+       if (p1->s_lno <= p2->s_lno) {
+               do {
+                       tail = &p1->next;
+                       if ((p1 = *tail) == NULL) {
+                               *tail = p2;
+                               return list1;
+                       }
+               } while (p1->s_lno <= p2->s_lno);
+       }
+       for (;;) {
+               *tail = p2;
+               do {
+                       tail = &p2->next;
+                       if ((p2 = *tail) == NULL)  {
+                               *tail = p1;
+                               return list1;
+                       }
+               } while (p1->s_lno > p2->s_lno);
+               *tail = p1;
+               do {
+                       tail = &p1->next;
+                       if ((p1 = *tail) == NULL) {
+                               *tail = p2;
+                               return list1;
+                       }
+               } while (p1->s_lno <= p2->s_lno);
+       }
+}
+
+static void *get_next_blame(const void *p)
+{
+       return ((struct blame_entry *)p)->next;
+}
+
+static void set_next_blame(void *p1, void *p2)
+{
+       ((struct blame_entry *)p1)->next = p2;
+}
+
+/*
+ * Final image line numbers are all different, so we don't need a
+ * three-way comparison here.
+ */
+
+static int compare_blame_final(const void *p1, const void *p2)
+{
+       return ((struct blame_entry *)p1)->lno > ((struct blame_entry *)p2)->lno
+               ? 1 : -1;
+}
+
+static int compare_blame_suspect(const void *p1, const void *p2)
+{
+       const struct blame_entry *s1 = p1, *s2 = p2;
+       /*
+        * to allow for collating suspects, we sort according to the
+        * respective pointer value as the primary sorting criterion.
+        * The actual relation is pretty unimportant as long as it
+        * establishes a total order.  Comparing as integers gives us
+        * that.
+        */
+       if (s1->suspect != s2->suspect)
+               return (intptr_t)s1->suspect > (intptr_t)s2->suspect ? 1 : -1;
+       if (s1->s_lno == s2->s_lno)
+               return 0;
+       return s1->s_lno > s2->s_lno ? 1 : -1;
+}
+
+static struct blame_entry *blame_sort(struct blame_entry *head,
+                                     int (*compare_fn)(const void *, const void *))
+{
+       return llist_mergesort (head, get_next_blame, set_next_blame, compare_fn);
+}
+
+static int compare_commits_by_reverse_commit_date(const void *a,
+                                                 const void *b,
+                                                 void *c)
+{
+       return -compare_commits_by_commit_date(a, b, c);
+}
+
 /*
  * The current state of the blame assignment.
  */
 struct scoreboard {
        /* the final commit (i.e. where we started digging from) */
        struct commit *final;
+       /* Priority queue for commits with unassigned blame records */
+       struct prio_queue commits;
        struct rev_info *revs;
        const char *path;
 
@@ -268,7 +410,6 @@ static void coalesce(struct scoreboard *sb)
 
        for (ent = sb->ent; ent && (next = ent->next); ent = next) {
                if (ent->suspect == next->suspect &&
-                   ent->guilty == next->guilty &&
                    ent->s_lno + ent->num_lines == next->s_lno) {
                        ent->num_lines += next->num_lines;
                        ent->next = next->next;
@@ -283,6 +424,30 @@ static void coalesce(struct scoreboard *sb)
                sanity_check_refcnt(sb);
 }
 
+/*
+ * Merge the given sorted list of blames into a preexisting origin.
+ * If there were no previous blames to that commit, it is entered into
+ * the commit priority queue of the score board.
+ */
+
+static void queue_blames(struct scoreboard *sb, struct origin *porigin,
+                        struct blame_entry *sorted)
+{
+       if (porigin->suspects)
+               porigin->suspects = blame_merge(porigin->suspects, sorted);
+       else {
+               struct origin *o;
+               for (o = porigin->commit->util; o; o = o->next) {
+                       if (o->suspects) {
+                               porigin->suspects = sorted;
+                               return;
+                       }
+               }
+               porigin->suspects = sorted;
+               prio_queue_put(&sb->commits, porigin->commit);
+       }
+}
+
 /*
  * Given a commit and a path in it, create a new origin structure.
  * The callers that add blame to the scoreboard should use
@@ -295,23 +460,32 @@ static struct origin *make_origin(struct commit *commit, const char *path)
        o = xcalloc(1, sizeof(*o) + strlen(path) + 1);
        o->commit = commit;
        o->refcnt = 1;
+       o->next = commit->util;
+       commit->util = o;
        strcpy(o->path, path);
        return o;
 }
 
 /*
  * Locate an existing origin or create a new one.
+ * This moves the origin to front position in the commit util list.
  */
 static struct origin *get_origin(struct scoreboard *sb,
                                 struct commit *commit,
                                 const char *path)
 {
-       struct blame_entry *e;
+       struct origin *o, *l;
 
-       for (e = sb->ent; e; e = e->next) {
-               if (e->suspect->commit == commit &&
-                   !strcmp(e->suspect->path, path))
-                       return origin_incref(e->suspect);
+       for (o = commit->util, l = NULL; o; l = o, o = o->next) {
+               if (!strcmp(o->path, path)) {
+                       /* bump to front */
+                       if (l) {
+                               l->next = o->next;
+                               o->next = commit->util;
+                               commit->util = o;
+                       }
+                       return origin_incref(o);
+               }
        }
        return make_origin(commit, path);
 }
@@ -350,41 +524,19 @@ static struct origin *find_origin(struct scoreboard *sb,
                                  struct commit *parent,
                                  struct origin *origin)
 {
-       struct origin *porigin = NULL;
+       struct origin *porigin;
        struct diff_options diff_opts;
        const char *paths[2];
 
-       if (parent->util) {
-               /*
-                * Each commit object can cache one origin in that
-                * commit.  This is a freestanding copy of origin and
-                * not refcounted.
-                */
-               struct origin *cached = parent->util;
-               if (!strcmp(cached->path, origin->path)) {
+       /* First check any existing origins */
+       for (porigin = parent->util; porigin; porigin = porigin->next)
+               if (!strcmp(porigin->path, origin->path)) {
                        /*
                         * The same path between origin and its parent
                         * without renaming -- the most common case.
                         */
-                       porigin = get_origin(sb, parent, cached->path);
-
-                       /*
-                        * If the origin was newly created (i.e. get_origin
-                        * would call make_origin if none is found in the
-                        * scoreboard), it does not know the blob_sha1/mode,
-                        * so copy it.  Otherwise porigin was in the
-                        * scoreboard and already knows blob_sha1/mode.
-                        */
-                       if (porigin->refcnt == 1) {
-                               hashcpy(porigin->blob_sha1, cached->blob_sha1);
-                               porigin->mode = cached->mode;
-                       }
-                       return porigin;
+                       return origin_incref (porigin);
                }
-               /* otherwise it was not very useful; free it */
-               free(parent->util);
-               parent->util = NULL;
-       }
 
        /* See if the origin->path is different between parent
         * and origin first.  Most of the time they are the
@@ -450,19 +602,6 @@ static struct origin *find_origin(struct scoreboard *sb,
        }
        diff_flush(&diff_opts);
        free_pathspec(&diff_opts.pathspec);
-       if (porigin) {
-               /*
-                * Create a freestanding copy that is not part of
-                * the refcounted origin found in the scoreboard, and
-                * cache it in the commit.
-                */
-               struct origin *cached;
-
-               cached = make_origin(porigin->commit, porigin->path);
-               hashcpy(cached->blob_sha1, porigin->blob_sha1);
-               cached->mode = porigin->mode;
-               parent->util = cached;
-       }
        return porigin;
 }
 
@@ -509,46 +648,31 @@ static struct origin *find_rename(struct scoreboard *sb,
 }
 
 /*
- * Link in a new blame entry to the scoreboard.  Entries that cover the
- * same line range have been removed from the scoreboard previously.
+ * Append a new blame entry to a given output queue.
  */
-static void add_blame_entry(struct scoreboard *sb, struct blame_entry *e)
+static void add_blame_entry(struct blame_entry ***queue, struct blame_entry *e)
 {
-       struct blame_entry *ent, *prev = NULL;
-
        origin_incref(e->suspect);
 
-       for (ent = sb->ent; ent && ent->lno < e->lno; ent = ent->next)
-               prev = ent;
-
-       /* prev, if not NULL, is the last one that is below e */
-
-       if (prev) {
-               e->next = prev->next;
-               prev->next = e;
-       }
-       else {
-               e->next = sb->ent;
-               sb->ent = e;
-       }
+       e->next = **queue;
+       **queue = e;
+       *queue = &e->next;
 }
 
 /*
  * src typically is on-stack; we want to copy the information in it to
- * a malloced blame_entry that is already on the linked list of the
- * scoreboard.  The origin of dst loses a refcnt while the origin of src
- * gains one.
+ * a malloced blame_entry that gets added to the given queue.  The
+ * origin of dst loses a refcnt.
  */
-static void dup_entry(struct blame_entry *dst, struct blame_entry *src)
+static void dup_entry(struct blame_entry ***queue,
+                     struct blame_entry *dst, struct blame_entry *src)
 {
-       struct blame_entry *n;
-
-       n = dst->next;
        origin_incref(src->suspect);
        origin_decref(dst->suspect);
        memcpy(dst, src, sizeof(*src));
-       dst->next = n;
-       dst->score = 0;
+       dst->next = **queue;
+       **queue = dst;
+       *queue = &dst->next;
 }
 
 static const char *nth_line(struct scoreboard *sb, long lno)
@@ -620,10 +744,11 @@ static void split_overlap(struct blame_entry *split,
 
 /*
  * split_overlap() divided an existing blame e into up to three parts
- * in split.  Adjust the linked list of blames in the scoreboard to
+ * in split.  Any assigned blame is moved to queue to
  * reflect the split.
  */
-static void split_blame(struct scoreboard *sb,
+static void split_blame(struct blame_entry ***blamed,
+                       struct blame_entry ***unblamed,
                        struct blame_entry *split,
                        struct blame_entry *e)
 {
@@ -631,61 +756,39 @@ static void split_blame(struct scoreboard *sb,
 
        if (split[0].suspect && split[2].suspect) {
                /* The first part (reuse storage for the existing entry e) */
-               dup_entry(e, &split[0]);
+               dup_entry(unblamed, e, &split[0]);
 
                /* The last part -- me */
                new_entry = xmalloc(sizeof(*new_entry));
                memcpy(new_entry, &(split[2]), sizeof(struct blame_entry));
-               add_blame_entry(sb, new_entry);
+               add_blame_entry(unblamed, new_entry);
 
                /* ... and the middle part -- parent */
                new_entry = xmalloc(sizeof(*new_entry));
                memcpy(new_entry, &(split[1]), sizeof(struct blame_entry));
-               add_blame_entry(sb, new_entry);
+               add_blame_entry(blamed, new_entry);
        }
        else if (!split[0].suspect && !split[2].suspect)
                /*
                 * The parent covers the entire area; reuse storage for
                 * e and replace it with the parent.
                 */
-               dup_entry(e, &split[1]);
+               dup_entry(blamed, e, &split[1]);
        else if (split[0].suspect) {
                /* me and then parent */
-               dup_entry(e, &split[0]);
+               dup_entry(unblamed, e, &split[0]);
 
                new_entry = xmalloc(sizeof(*new_entry));
                memcpy(new_entry, &(split[1]), sizeof(struct blame_entry));
-               add_blame_entry(sb, new_entry);
+               add_blame_entry(blamed, new_entry);
        }
        else {
                /* parent and then me */
-               dup_entry(e, &split[1]);
+               dup_entry(blamed, e, &split[1]);
 
                new_entry = xmalloc(sizeof(*new_entry));
                memcpy(new_entry, &(split[2]), sizeof(struct blame_entry));
-               add_blame_entry(sb, new_entry);
-       }
-
-       if (DEBUG) { /* sanity */
-               struct blame_entry *ent;
-               int lno = sb->ent->lno, corrupt = 0;
-
-               for (ent = sb->ent; ent; ent = ent->next) {
-                       if (lno != ent->lno)
-                               corrupt = 1;
-                       if (ent->s_lno < 0)
-                               corrupt = 1;
-                       lno += ent->num_lines;
-               }
-               if (corrupt) {
-                       lno = sb->ent->lno;
-                       for (ent = sb->ent; ent; ent = ent->next) {
-                               printf("L %8d l %8d n %8d\n",
-                                      lno, ent->lno, ent->num_lines);
-                               lno = ent->lno + ent->num_lines;
-                       }
-                       die("oops");
-               }
+               add_blame_entry(unblamed, new_entry);
        }
 }
 
@@ -702,74 +805,146 @@ static void decref_split(struct blame_entry *split)
 }
 
 /*
- * Helper for blame_chunk().  blame_entry e is known to overlap with
- * the patch hunk; split it and pass blame to the parent.
+ * reverse_blame reverses the list given in head, appending tail.
+ * That allows us to build lists in reverse order, then reverse them
+ * afterwards.  This can be faster than building the list in proper
+ * order right away.  The reason is that building in proper order
+ * requires writing a link in the _previous_ element, while building
+ * in reverse order just requires placing the list head into the
+ * _current_ element.
  */
-static void blame_overlap(struct scoreboard *sb, struct blame_entry *e,
-                         int tlno, int plno, int same,
-                         struct origin *parent)
-{
-       struct blame_entry split[3];
-
-       split_overlap(split, e, tlno, plno, same, parent);
-       if (split[1].suspect)
-               split_blame(sb, split, e);
-       decref_split(split);
-}
 
-/*
- * Find the line number of the last line the target is suspected for.
- */
-static int find_last_in_target(struct scoreboard *sb, struct origin *target)
+static struct blame_entry *reverse_blame(struct blame_entry *head,
+                                        struct blame_entry *tail)
 {
-       struct blame_entry *e;
-       int last_in_target = -1;
-
-       for (e = sb->ent; e; e = e->next) {
-               if (e->guilty || e->suspect != target)
-                       continue;
-               if (last_in_target < e->s_lno + e->num_lines)
-                       last_in_target = e->s_lno + e->num_lines;
+       while (head) {
+               struct blame_entry *next = head->next;
+               head->next = tail;
+               tail = head;
+               head = next;
        }
-       return last_in_target;
+       return tail;
 }
 
 /*
  * Process one hunk from the patch between the current suspect for
- * blame_entry e and its parent.  Find and split the overlap, and
- * pass blame to the overlapping part to the parent.
+ * blame_entry e and its parent.  This first blames any unfinished
+ * entries before the chunk (which is where target and parent start
+ * differing) on the parent, and then splits blame entries at the
+ * start and at the end of the difference region.  Since use of -M and
+ * -C options may lead to overlapping/duplicate source line number
+ * ranges, all we can rely on from sorting/merging is the order of the
+ * first suspect line number.
  */
-static void blame_chunk(struct scoreboard *sb,
-                       int tlno, int plno, int same,
-                       struct origin *target, struct origin *parent)
+static void blame_chunk(struct blame_entry ***dstq, struct blame_entry ***srcq,
+                       int tlno, int offset, int same,
+                       struct origin *parent)
 {
-       struct blame_entry *e;
+       struct blame_entry *e = **srcq;
+       struct blame_entry *samep = NULL, *diffp = NULL;
 
-       for (e = sb->ent; e; e = e->next) {
-               if (e->guilty || e->suspect != target)
-                       continue;
-               if (same <= e->s_lno)
-                       continue;
-               if (tlno < e->s_lno + e->num_lines)
-                       blame_overlap(sb, e, tlno, plno, same, parent);
+       while (e && e->s_lno < tlno) {
+               struct blame_entry *next = e->next;
+               /*
+                * current record starts before differing portion.  If
+                * it reaches into it, we need to split it up and
+                * examine the second part separately.
+                */
+               if (e->s_lno + e->num_lines > tlno) {
+                       /* Move second half to a new record */
+                       int len = tlno - e->s_lno;
+                       struct blame_entry *n = xcalloc(1, sizeof (struct blame_entry));
+                       n->suspect = e->suspect;
+                       n->lno = e->lno + len;
+                       n->s_lno = e->s_lno + len;
+                       n->num_lines = e->num_lines - len;
+                       e->num_lines = len;
+                       e->score = 0;
+                       /* Push new record to diffp */
+                       n->next = diffp;
+                       diffp = n;
+               } else
+                       origin_decref(e->suspect);
+               /* Pass blame for everything before the differing
+                * chunk to the parent */
+               e->suspect = origin_incref(parent);
+               e->s_lno += offset;
+               e->next = samep;
+               samep = e;
+               e = next;
+       }
+       /*
+        * As we don't know how much of a common stretch after this
+        * diff will occur, the currently blamed parts are all that we
+        * can assign to the parent for now.
+        */
+
+       if (samep) {
+               **dstq = reverse_blame(samep, **dstq);
+               *dstq = &samep->next;
+       }
+       /*
+        * Prepend the split off portions: everything after e starts
+        * after the blameable portion.
+        */
+       e = reverse_blame(diffp, e);
+
+       /*
+        * Now retain records on the target while parts are different
+        * from the parent.
+        */
+       samep = NULL;
+       diffp = NULL;
+       while (e && e->s_lno < same) {
+               struct blame_entry *next = e->next;
+
+               /*
+                * If current record extends into sameness, need to split.
+                */
+               if (e->s_lno + e->num_lines > same) {
+                       /*
+                        * Move second half to a new record to be
+                        * processed by later chunks
+                        */
+                       int len = same - e->s_lno;
+                       struct blame_entry *n = xcalloc(1, sizeof (struct blame_entry));
+                       n->suspect = origin_incref(e->suspect);
+                       n->lno = e->lno + len;
+                       n->s_lno = e->s_lno + len;
+                       n->num_lines = e->num_lines - len;
+                       e->num_lines = len;
+                       e->score = 0;
+                       /* Push new record to samep */
+                       n->next = samep;
+                       samep = n;
+               }
+               e->next = diffp;
+               diffp = e;
+               e = next;
        }
+       **srcq = reverse_blame(diffp, reverse_blame(samep, e));
+       /* Move across elements that are in the unblamable portion */
+       if (diffp)
+               *srcq = &diffp->next;
 }
 
 struct blame_chunk_cb_data {
-       struct scoreboard *sb;
-       struct origin *target;
        struct origin *parent;
-       long plno;
-       long tlno;
+       long offset;
+       struct blame_entry **dstq;
+       struct blame_entry **srcq;
 };
 
+/* diff chunks are from parent to target */
 static int blame_chunk_cb(long start_a, long count_a,
                          long start_b, long count_b, void *data)
 {
        struct blame_chunk_cb_data *d = data;
-       blame_chunk(d->sb, d->tlno, d->plno, start_b, d->target, d->parent);
-       d->plno = start_a + count_a;
-       d->tlno = start_b + count_b;
+       if (start_a - start_b != d->offset)
+               die("internal error in blame::blame_chunk_cb");
+       blame_chunk(&d->dstq, &d->srcq, start_b, start_a - start_b,
+                   start_b + count_b, d->parent);
+       d->offset = start_a + count_a - (start_b + count_b);
        return 0;
 }
 
@@ -778,29 +953,32 @@ static int blame_chunk_cb(long start_a, long count_a,
  * for the lines it is suspected to its parent.  Run diff to find
  * which lines came from parent and pass blame for them.
  */
-static int pass_blame_to_parent(struct scoreboard *sb,
-                               struct origin *target,
-                               struct origin *parent)
+static void pass_blame_to_parent(struct scoreboard *sb,
+                                struct origin *target,
+                                struct origin *parent)
 {
-       int last_in_target;
        mmfile_t file_p, file_o;
        struct blame_chunk_cb_data d;
+       struct blame_entry *newdest = NULL;
 
-       memset(&d, 0, sizeof(d));
-       d.sb = sb; d.target = target; d.parent = parent;
-       last_in_target = find_last_in_target(sb, target);
-       if (last_in_target < 0)
-               return 1; /* nothing remains for this target */
+       if (!target->suspects)
+               return; /* nothing remains for this target */
+
+       d.parent = parent;
+       d.offset = 0;
+       d.dstq = &newdest; d.srcq = &target->suspects;
 
        fill_origin_blob(&sb->revs->diffopt, parent, &file_p);
        fill_origin_blob(&sb->revs->diffopt, target, &file_o);
        num_get_patch++;
 
        diff_hunks(&file_p, &file_o, 0, blame_chunk_cb, &d);
-       /* The rest (i.e. anything after tlno) are the same as the parent */
-       blame_chunk(sb, d.tlno, d.plno, last_in_target, target, parent);
+       /* The rest are the same as the parent */
+       blame_chunk(&d.dstq, &d.srcq, INT_MAX, d.offset, INT_MAX, parent);
+       *d.dstq = NULL;
+       queue_blames(sb, parent, newdest);
 
-       return 0;
+       return;
 }
 
 /*
@@ -945,43 +1123,80 @@ static void find_copy_in_blob(struct scoreboard *sb,
        handle_split(sb, ent, d.tlno, d.plno, ent->num_lines, parent, split);
 }
 
+/* Move all blame entries from list *source that have a score smaller
+ * than score_min to the front of list *small.
+ * Returns a pointer to the link pointing to the old head of the small list.
+ */
+
+static struct blame_entry **filter_small(struct scoreboard *sb,
+                                        struct blame_entry **small,
+                                        struct blame_entry **source,
+                                        unsigned score_min)
+{
+       struct blame_entry *p = *source;
+       struct blame_entry *oldsmall = *small;
+       while (p) {
+               if (ent_score(sb, p) <= score_min) {
+                       *small = p;
+                       small = &p->next;
+                       p = *small;
+               } else {
+                       *source = p;
+                       source = &p->next;
+                       p = *source;
+               }
+       }
+       *small = oldsmall;
+       *source = NULL;
+       return small;
+}
+
 /*
  * See if lines currently target is suspected for can be attributed to
  * parent.
  */
-static int find_move_in_parent(struct scoreboard *sb,
-                              struct origin *target,
-                              struct origin *parent)
+static void find_move_in_parent(struct scoreboard *sb,
+                               struct blame_entry ***blamed,
+                               struct blame_entry **toosmall,
+                               struct origin *target,
+                               struct origin *parent)
 {
-       int last_in_target, made_progress;
        struct blame_entry *e, split[3];
+       struct blame_entry *unblamed = target->suspects;
+       struct blame_entry *leftover = NULL;
        mmfile_t file_p;
 
-       last_in_target = find_last_in_target(sb, target);
-       if (last_in_target < 0)
-               return 1; /* nothing remains for this target */
+       if (!unblamed)
+               return; /* nothing remains for this target */
 
        fill_origin_blob(&sb->revs->diffopt, parent, &file_p);
        if (!file_p.ptr)
-               return 0;
+               return;
 
-       made_progress = 1;
-       while (made_progress) {
-               made_progress = 0;
-               for (e = sb->ent; e; e = e->next) {
-                       if (e->guilty || e->suspect != target ||
-                           ent_score(sb, e) < blame_move_score)
-                               continue;
+       /* At each iteration, unblamed has a NULL-terminated list of
+        * entries that have not yet been tested for blame.  leftover
+        * contains the reversed list of entries that have been tested
+        * without being assignable to the parent.
+        */
+       do {
+               struct blame_entry **unblamedtail = &unblamed;
+               struct blame_entry *next;
+               for (e = unblamed; e; e = next) {
+                       next = e->next;
                        find_copy_in_blob(sb, e, parent, split, &file_p);
                        if (split[1].suspect &&
                            blame_move_score < ent_score(sb, &split[1])) {
-                               split_blame(sb, split, e);
-                               made_progress = 1;
+                               split_blame(blamed, &unblamedtail, split, e);
+                       } else {
+                               e->next = leftover;
+                               leftover = e;
                        }
                        decref_split(split);
                }
-       }
-       return 0;
+               *unblamedtail = NULL;
+               toosmall = filter_small(sb, toosmall, &unblamed, blame_move_score);
+       } while (unblamed);
+       target->suspects = reverse_blame(leftover, NULL);
 }
 
 struct blame_list {
@@ -993,62 +1208,46 @@ struct blame_list {
  * Count the number of entries the target is suspected for,
  * and prepare a list of entry and the best split.
  */
-static struct blame_list *setup_blame_list(struct scoreboard *sb,
-                                          struct origin *target,
-                                          int min_score,
+static struct blame_list *setup_blame_list(struct blame_entry *unblamed,
                                           int *num_ents_p)
 {
        struct blame_entry *e;
        int num_ents, i;
        struct blame_list *blame_list = NULL;
 
-       for (e = sb->ent, num_ents = 0; e; e = e->next)
-               if (!e->scanned && !e->guilty &&
-                   e->suspect == target &&
-                   min_score < ent_score(sb, e))
-                       num_ents++;
+       for (e = unblamed, num_ents = 0; e; e = e->next)
+               num_ents++;
        if (num_ents) {
                blame_list = xcalloc(num_ents, sizeof(struct blame_list));
-               for (e = sb->ent, i = 0; e; e = e->next)
-                       if (!e->scanned && !e->guilty &&
-                           e->suspect == target &&
-                           min_score < ent_score(sb, e))
-                               blame_list[i++].ent = e;
+               for (e = unblamed, i = 0; e; e = e->next)
+                       blame_list[i++].ent = e;
        }
        *num_ents_p = num_ents;
        return blame_list;
 }
 
-/*
- * Reset the scanned status on all entries.
- */
-static void reset_scanned_flag(struct scoreboard *sb)
-{
-       struct blame_entry *e;
-       for (e = sb->ent; e; e = e->next)
-               e->scanned = 0;
-}
-
 /*
  * For lines target is suspected for, see if we can find code movement
  * across file boundary from the parent commit.  porigin is the path
  * in the parent we already tried.
  */
-static int find_copy_in_parent(struct scoreboard *sb,
-                              struct origin *target,
-                              struct commit *parent,
-                              struct origin *porigin,
-                              int opt)
+static void find_copy_in_parent(struct scoreboard *sb,
+                               struct blame_entry ***blamed,
+                               struct blame_entry **toosmall,
+                               struct origin *target,
+                               struct commit *parent,
+                               struct origin *porigin,
+                               int opt)
 {
        struct diff_options diff_opts;
        int i, j;
-       int retval;
        struct blame_list *blame_list;
        int num_ents;
+       struct blame_entry *unblamed = target->suspects;
+       struct blame_entry *leftover = NULL;
 
-       blame_list = setup_blame_list(sb, target, blame_copy_score, &num_ents);
-       if (!blame_list)
-               return 1; /* nothing remains for this target */
+       if (!unblamed)
+               return; /* nothing remains for this target */
 
        diff_setup(&diff_opts);
        DIFF_OPT_SET(&diff_opts, RECURSIVE);
@@ -1078,9 +1277,9 @@ static int find_copy_in_parent(struct scoreboard *sb,
        if (!DIFF_OPT_TST(&diff_opts, FIND_COPIES_HARDER))
                diffcore_std(&diff_opts);
 
-       retval = 0;
-       while (1) {
-               int made_progress = 0;
+       do {
+               struct blame_entry **unblamedtail = &unblamed;
+               blame_list = setup_blame_list(unblamed, &num_ents);
 
                for (i = 0; i < diff_queued_diff.nr; i++) {
                        struct diff_filepair *p = diff_queued_diff.queue[i];
@@ -1117,27 +1316,21 @@ static int find_copy_in_parent(struct scoreboard *sb,
                        struct blame_entry *split = blame_list[j].split;
                        if (split[1].suspect &&
                            blame_copy_score < ent_score(sb, &split[1])) {
-                               split_blame(sb, split, blame_list[j].ent);
-                               made_progress = 1;
+                               split_blame(blamed, &unblamedtail, split,
+                                           blame_list[j].ent);
+                       } else {
+                               blame_list[j].ent->next = leftover;
+                               leftover = blame_list[j].ent;
                        }
-                       else
-                               blame_list[j].ent->scanned = 1;
                        decref_split(split);
                }
                free(blame_list);
-
-               if (!made_progress)
-                       break;
-               blame_list = setup_blame_list(sb, target, blame_copy_score, &num_ents);
-               if (!blame_list) {
-                       retval = 1;
-                       break;
-               }
-       }
-       reset_scanned_flag(sb);
+               *unblamedtail = NULL;
+               toosmall = filter_small(sb, toosmall, &unblamed, blame_copy_score);
+       } while (unblamed);
+       target->suspects = reverse_blame(leftover, NULL);
        diff_flush(&diff_opts);
        free_pathspec(&diff_opts.pathspec);
-       return retval;
 }
 
 /*
@@ -1147,20 +1340,21 @@ static int find_copy_in_parent(struct scoreboard *sb,
 static void pass_whole_blame(struct scoreboard *sb,
                             struct origin *origin, struct origin *porigin)
 {
-       struct blame_entry *e;
+       struct blame_entry *e, *suspects;
 
        if (!porigin->file.ptr && origin->file.ptr) {
                /* Steal its file */
                porigin->file = origin->file;
                origin->file.ptr = NULL;
        }
-       for (e = sb->ent; e; e = e->next) {
-               if (e->suspect != origin)
-                       continue;
+       suspects = origin->suspects;
+       origin->suspects = NULL;
+       for (e = suspects; e; e = e->next) {
                origin_incref(porigin);
                origin_decref(e->suspect);
                e->suspect = porigin;
        }
+       queue_blames(sb, porigin, suspects);
 }
 
 /*
@@ -1184,6 +1378,27 @@ static int num_scapegoats(struct rev_info *revs, struct commit *commit)
        return cnt;
 }
 
+/* Distribute collected unsorted blames to the respected sorted lists
+ * in the various origins.
+ */
+static void distribute_blame(struct scoreboard *sb, struct blame_entry *blamed)
+{
+       blamed = blame_sort(blamed, compare_blame_suspect);
+       while (blamed)
+       {
+               struct origin *porigin = blamed->suspect;
+               struct blame_entry *suspects = NULL;
+               do {
+                       struct blame_entry *next = blamed->next;
+                       blamed->next = suspects;
+                       suspects = blamed;
+                       blamed = next;
+               } while (blamed && blamed->suspect == porigin);
+               suspects = reverse_blame(suspects, NULL);
+               queue_blames(sb, porigin, suspects);
+       }
+}
+
 #define MAXSG 16
 
 static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
@@ -1194,6 +1409,8 @@ static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
        struct commit_list *sg;
        struct origin *sg_buf[MAXSG];
        struct origin *porigin, **sg_origin = sg_buf;
+       struct blame_entry *toosmall = NULL;
+       struct blame_entry *blames, **blametail = &blames;
 
        num_sg = num_scapegoats(revs, commit);
        if (!num_sg)
@@ -1255,38 +1472,71 @@ static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
                        origin_incref(porigin);
                        origin->previous = porigin;
                }
-               if (pass_blame_to_parent(sb, origin, porigin))
+               pass_blame_to_parent(sb, origin, porigin);
+               if (!origin->suspects)
                        goto finish;
        }
 
        /*
         * Optionally find moves in parents' files.
         */
-       if (opt & PICKAXE_BLAME_MOVE)
-               for (i = 0, sg = first_scapegoat(revs, commit);
-                    i < num_sg && sg;
-                    sg = sg->next, i++) {
-                       struct origin *porigin = sg_origin[i];
-                       if (!porigin)
-                               continue;
-                       if (find_move_in_parent(sb, origin, porigin))
-                               goto finish;
+       if (opt & PICKAXE_BLAME_MOVE) {
+               filter_small(sb, &toosmall, &origin->suspects, blame_move_score);
+               if (origin->suspects) {
+                       for (i = 0, sg = first_scapegoat(revs, commit);
+                            i < num_sg && sg;
+                            sg = sg->next, i++) {
+                               struct origin *porigin = sg_origin[i];
+                               if (!porigin)
+                                       continue;
+                               find_move_in_parent(sb, &blametail, &toosmall, origin, porigin);
+                               if (!origin->suspects)
+                                       break;
+                       }
                }
+       }
 
        /*
         * Optionally find copies from parents' files.
         */
-       if (opt & PICKAXE_BLAME_COPY)
+       if (opt & PICKAXE_BLAME_COPY) {
+               if (blame_copy_score > blame_move_score)
+                       filter_small(sb, &toosmall, &origin->suspects, blame_copy_score);
+               else if (blame_copy_score < blame_move_score) {
+                       origin->suspects = blame_merge(origin->suspects, toosmall);
+                       toosmall = NULL;
+                       filter_small(sb, &toosmall, &origin->suspects, blame_copy_score);
+               }
+               if (!origin->suspects)
+                       goto finish;
+
                for (i = 0, sg = first_scapegoat(revs, commit);
                     i < num_sg && sg;
                     sg = sg->next, i++) {
                        struct origin *porigin = sg_origin[i];
-                       if (find_copy_in_parent(sb, origin, sg->item,
-                                               porigin, opt))
+                       find_copy_in_parent(sb, &blametail, &toosmall,
+                                           origin, sg->item, porigin, opt);
+                       if (!origin->suspects)
                                goto finish;
                }
+       }
 
- finish:
+finish:
+       *blametail = NULL;
+       distribute_blame(sb, blames);
+       /*
+        * prepend toosmall to origin->suspects
+        *
+        * There is no point in sorting: this ends up on a big
+        * unsorted list in the caller anyway.
+        */
+       if (toosmall) {
+               struct blame_entry **tail = &toosmall;
+               while (*tail)
+                       tail = &(*tail)->next;
+               *tail = origin->suspects;
+               origin->suspects = toosmall;
+       }
        for (i = 0; i < num_sg; i++) {
                if (sg_origin[i]) {
                        drop_origin_blob(sg_origin[i]);
@@ -1481,14 +1731,11 @@ static int emit_one_suspect_detail(struct origin *suspect, int repeat)
 }
 
 /*
- * The blame_entry is found to be guilty for the range.  Mark it
- * as such, and show it in incremental output.
+ * The blame_entry is found to be guilty for the range.
+ * Show it in incremental output.
  */
 static void found_guilty_entry(struct blame_entry *ent)
 {
-       if (ent->guilty)
-               return;
-       ent->guilty = 1;
        if (incremental) {
                struct origin *suspect = ent->suspect;
 
@@ -1502,32 +1749,34 @@ static void found_guilty_entry(struct blame_entry *ent)
 }
 
 /*
- * The main loop -- while the scoreboard has lines whose true origin
- * is still unknown, pick one blame_entry, and allow its current
- * suspect to pass blames to its parents.
- */
+ * The main loop -- while we have blobs with lines whose true origin
+ * is still unknown, pick one blob, and allow its lines to pass blames
+ * to its parents. */
 static void assign_blame(struct scoreboard *sb, int opt)
 {
        struct rev_info *revs = sb->revs;
+       struct commit *commit = prio_queue_get(&sb->commits);
 
-       while (1) {
+       while (commit) {
                struct blame_entry *ent;
-               struct commit *commit;
-               struct origin *suspect = NULL;
+               struct origin *suspect = commit->util;
 
                /* find one suspect to break down */
-               for (ent = sb->ent; !suspect && ent; ent = ent->next)
-                       if (!ent->guilty)
-                               suspect = ent->suspect;
-               if (!suspect)
-                       return; /* all done */
+               while (suspect && !suspect->suspects)
+                       suspect = suspect->next;
+
+               if (!suspect) {
+                       commit = prio_queue_get(&sb->commits);
+                       continue;
+               }
+
+               assert(commit == suspect->commit);
 
                /*
                 * We will use this suspect later in the loop,
                 * so hold onto it in the meantime.
                 */
                origin_incref(suspect);
-               commit = suspect->commit;
                parse_commit(commit);
                if (reverse ||
                    (!(commit->object.flags & UNINTERESTING) &&
@@ -1543,9 +1792,22 @@ static void assign_blame(struct scoreboard *sb, int opt)
                        commit->object.flags |= UNINTERESTING;
 
                /* Take responsibility for the remaining entries */
-               for (ent = sb->ent; ent; ent = ent->next)
-                       if (ent->suspect == suspect)
+               ent = suspect->suspects;
+               if (ent) {
+                       suspect->guilty = 1;
+                       for (;;) {
+                               struct blame_entry *next = ent->next;
                                found_guilty_entry(ent);
+                               if (next) {
+                                       ent = next;
+                                       continue;
+                               }
+                               ent->next = sb->ent;
+                               sb->ent = suspect->suspects;
+                               suspect->suspects = NULL;
+                               break;
+                       }
+               }
                origin_decref(suspect);
 
                if (DEBUG) /* sanity */
@@ -1556,22 +1818,29 @@ static void assign_blame(struct scoreboard *sb, int opt)
 static const char *format_time(unsigned long time, const char *tz_str,
                               int show_raw_time)
 {
-       static char time_buf[128];
+       static struct strbuf time_buf = STRBUF_INIT;
 
+       strbuf_reset(&time_buf);
        if (show_raw_time) {
-               snprintf(time_buf, sizeof(time_buf), "%lu %s", time, tz_str);
+               strbuf_addf(&time_buf, "%lu %s", time, tz_str);
        }
        else {
                const char *time_str;
-               int time_len;
+               size_t time_width;
                int tz;
                tz = atoi(tz_str);
                time_str = show_date(time, tz, blame_date_mode);
-               time_len = strlen(time_str);
-               memcpy(time_buf, time_str, time_len);
-               memset(time_buf + time_len, ' ', blame_date_width - time_len);
+               strbuf_addstr(&time_buf, time_str);
+               /*
+                * Add space paddings to time_buf to display a fixed width
+                * string, and use time_width for display width calibration.
+                */
+               for (time_width = utf8_strwidth(time_str);
+                    time_width < blame_date_width;
+                    time_width++)
+                       strbuf_addch(&time_buf, ' ');
        }
-       return time_buf;
+       return time_buf.buf;
 }
 
 #define OUTPUT_ANNOTATE_COMPAT 001
@@ -1602,9 +1871,8 @@ static void emit_porcelain(struct scoreboard *sb, struct blame_entry *ent,
        char hex[41];
 
        strcpy(hex, sha1_to_hex(suspect->commit->object.sha1));
-       printf("%s%c%d %d %d\n",
+       printf("%s %d %d %d\n",
               hex,
-              ent->guilty ? ' ' : '*', /* purely for debugging */
               ent->s_lno + 1,
               ent->lno + 1,
               ent->num_lines);
@@ -1717,17 +1985,16 @@ static void output(struct scoreboard *sb, int option)
 
        if (option & OUTPUT_PORCELAIN) {
                for (ent = sb->ent; ent; ent = ent->next) {
-                       struct blame_entry *oth;
-                       struct origin *suspect = ent->suspect;
-                       struct commit *commit = suspect->commit;
+                       int count = 0;
+                       struct origin *suspect;
+                       struct commit *commit = ent->suspect->commit;
                        if (commit->object.flags & MORE_THAN_ONE_PATH)
                                continue;
-                       for (oth = ent->next; oth; oth = oth->next) {
-                               if ((oth->suspect->commit != commit) ||
-                                   !strcmp(oth->suspect->path, suspect->path))
-                                       continue;
-                               commit->object.flags |= MORE_THAN_ONE_PATH;
-                               break;
+                       for (suspect = commit->util; suspect; suspect = suspect->next) {
+                               if (suspect->guilty && count++) {
+                                       commit->object.flags |= MORE_THAN_ONE_PATH;
+                                       break;
+                               }
                        }
                }
        }
@@ -2088,11 +2355,9 @@ static struct commit *fake_working_tree_commit(struct diff_options *opt,
                if (strbuf_read(&buf, 0, 0) < 0)
                        die_errno("failed to read from stdin");
        }
-       convert_to_git(path, buf.buf, buf.len, &buf, 0);
        origin->file.ptr = buf.buf;
        origin->file.size = buf.len;
        pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_sha1);
-       commit->util = origin;
 
        /*
         * Read the current index, replace the path entry with
@@ -2331,7 +2596,14 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
                blame_date_width = sizeof("2006-10-19");
                break;
        case DATE_RELATIVE:
-               /* "normal" is used as the fallback for "relative" */
+               /* TRANSLATORS: This string is used to tell us the maximum
+                  display width for a relative timestamp in "git blame"
+                  output.  For C locale, "4 years, 11 months ago", which
+                  takes 22 places, is the longest among various forms of
+                  relative timestamps, but your language may need more or
+                  fewer display columns. */
+               blame_date_width = utf8_strwidth(_("4 years, 11 months ago")) + 1; /* add the null */
+               break;
        case DATE_LOCAL:
        case DATE_NORMAL:
                blame_date_width = sizeof("Thu Oct 19 16:00:04 2006 -0700");
@@ -2403,12 +2675,16 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
        memset(&sb, 0, sizeof(sb));
 
        sb.revs = &revs;
-       if (!reverse)
+       if (!reverse) {
                final_commit_name = prepare_final(&sb);
+               sb.commits.compare = compare_commits_by_commit_date;
+       }
        else if (contents_from)
                die("--contents and --children do not blend well.");
-       else
+       else {
                final_commit_name = prepare_initial(&sb);
+               sb.commits.compare = compare_commits_by_reverse_commit_date;
+       }
 
        if (!sb.final) {
                /*
@@ -2497,12 +2773,16 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
                ent->next = next;
                origin_incref(o);
        }
+
+       o->suspects = ent;
+       prio_queue_put(&sb.commits, o->commit);
+
        origin_decref(o);
 
        range_set_release(&ranges);
        string_list_clear(&range_list, 0);
 
-       sb.ent = ent;
+       sb.ent = NULL;
        sb.path = path;
 
        read_mailmap(&mailmap, NULL);
@@ -2515,6 +2795,8 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
        if (incremental)
                return 0;
 
+       sb.ent = blame_sort(sb.ent, compare_blame_final);
+
        coalesce(&sb);
 
        if (!(output_option & OUTPUT_PORCELAIN))
index 07cf55530918e8de6ae45e1c9b7e16707c32f844..f1dc56e55f7b2200412142b10517458ccfda2952 100644 (file)
@@ -624,7 +624,7 @@ static void update_refs_for_switch(const struct checkout_opts *opts,
                /* Nothing to do. */
        } else if (opts->force_detach || !new->path) {  /* No longer on any branch. */
                update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
-                          REF_NODEREF, DIE_ON_ERR);
+                          REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
                if (!opts->quiet) {
                        if (old->path && advice_detached_head)
                                detach_advice(new->name);
@@ -651,12 +651,8 @@ static void update_refs_for_switch(const struct checkout_opts *opts,
                        }
                }
                if (old->path && old->name) {
-                       char log_file[PATH_MAX], ref_file[PATH_MAX];
-
-                       git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
-                       git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
-                       if (!file_exists(ref_file) && file_exists(log_file))
-                               remove_path(log_file);
+                       if (!ref_exists(old->path) && reflog_exists(old->path))
+                               delete_reflog(old->path);
                }
        }
        remove_branch_state();
index 9b3c04d914b3d318f723c2d3ded403fca9503c07..b12989d1caecb48128e8a468014f07b237b1a4cc 100644 (file)
@@ -521,7 +521,7 @@ static void write_followtags(const struct ref *refs, const char *msg)
                if (!has_sha1_file(ref->old_sha1))
                        continue;
                update_ref(msg, ref->name, ref->old_sha1,
-                          NULL, 0, DIE_ON_ERR);
+                          NULL, 0, UPDATE_REFS_DIE_ON_ERR);
        }
 }
 
@@ -589,14 +589,15 @@ static void update_head(const struct ref *our, const struct ref *remote,
                create_symref("HEAD", our->name, NULL);
                if (!option_bare) {
                        const char *head = skip_prefix(our->name, "refs/heads/");
-                       update_ref(msg, "HEAD", our->old_sha1, NULL, 0, DIE_ON_ERR);
+                       update_ref(msg, "HEAD", our->old_sha1, NULL, 0,
+                                  UPDATE_REFS_DIE_ON_ERR);
                        install_branch_config(0, head, option_origin, our->name);
                }
        } else if (our) {
                struct commit *c = lookup_commit_reference(our->old_sha1);
                /* --branch specifies a non-branch (i.e. tags), detach HEAD */
                update_ref(msg, "HEAD", c->object.sha1,
-                          NULL, REF_NODEREF, DIE_ON_ERR);
+                          NULL, REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
        } else if (remote) {
                /*
                 * We know remote HEAD points to a non-branch, or
@@ -604,7 +605,7 @@ static void update_head(const struct ref *our, const struct ref *remote,
                 * Detach HEAD in all these cases.
                 */
                update_ref(msg, "HEAD", remote->old_sha1,
-                          NULL, REF_NODEREF, DIE_ON_ERR);
+                          NULL, REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
        }
 }
 
index 515c4c4c0553c00c0ad6d577af192a96cf1bc60a..99c20446352edb477d19122fae2b2821e10d689f 100644 (file)
@@ -526,10 +526,29 @@ static int sane_ident_split(struct ident_split *person)
        return 1;
 }
 
+static int parse_force_date(const char *in, char *out, int len)
+{
+       if (len < 1)
+               return -1;
+       *out++ = '@';
+       len--;
+
+       if (parse_date(in, out, len) < 0) {
+               int errors = 0;
+               unsigned long t = approxidate_careful(in, &errors);
+               if (errors)
+                       return -1;
+               snprintf(out, len, "%lu", t);
+       }
+
+       return 0;
+}
+
 static void determine_author_info(struct strbuf *author_ident)
 {
        char *name, *email, *date;
        struct ident_split author;
+       char date_buf[64];
 
        name = getenv("GIT_AUTHOR_NAME");
        email = getenv("GIT_AUTHOR_EMAIL");
@@ -574,8 +593,12 @@ static void determine_author_info(struct strbuf *author_ident)
                email = xstrndup(lb + 2, rb - (lb + 2));
        }
 
-       if (force_date)
-               date = force_date;
+       if (force_date) {
+               if (parse_force_date(force_date, date_buf, sizeof(date_buf)))
+                       die(_("invalid date format: %s"), force_date);
+               date = date_buf;
+       }
+
        strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
        if (!split_ident_line(&author, author_ident->buf, author_ident->len) &&
            sane_ident_split(&author)) {
@@ -585,13 +608,16 @@ static void determine_author_info(struct strbuf *author_ident)
        }
 }
 
-static char *cut_ident_timestamp_part(char *string)
+static void split_ident_or_die(struct ident_split *id, const struct strbuf *buf)
+{
+       if (split_ident_line(id, buf->buf, buf->len) ||
+           !sane_ident_split(id))
+               die(_("Malformed ident string: '%s'"), buf->buf);
+}
+
+static int author_date_is_interesting(void)
 {
-       char *ket = strrchr(string, '>');
-       if (!ket || ket[1] != ' ')
-               die(_("Malformed ident string: '%s'"), string);
-       *++ket = '\0';
-       return ket;
+       return author_message || force_date;
 }
 
 static void adjust_comment_line_char(const struct strbuf *sb)
@@ -680,9 +706,8 @@ static int prepare_to_commit(const char *index_file, const char *prefix,
        } else if (use_message) {
                char *buffer;
                buffer = strstr(use_message_buffer, "\n\n");
-               if (!use_editor && (!buffer || buffer[2] == '\0'))
-                       die(_("commit has empty message"));
-               strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
+               if (buffer)
+                       strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
                hook_arg1 = "commit";
                hook_arg2 = use_message;
        } else if (fixup_message) {
@@ -787,7 +812,8 @@ static int prepare_to_commit(const char *index_file, const char *prefix,
        if (use_editor && include_status) {
                int ident_shown = 0;
                int saved_color_setting;
-               char *ai_tmp, *ci_tmp;
+               struct ident_split ci, ai;
+
                if (whence != FROM_COMMIT) {
                        if (cleanup_mode == CLEANUP_SCISSORS)
                                wt_status_add_cut_line(s->fp);
@@ -827,32 +853,39 @@ static int prepare_to_commit(const char *index_file, const char *prefix,
                        status_printf_ln(s, GIT_COLOR_NORMAL,
                                        "%s", only_include_assumed);
 
-               ai_tmp = cut_ident_timestamp_part(author_ident->buf);
-               ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
-               if (strcmp(author_ident->buf, committer_ident.buf))
+               split_ident_or_die(&ai, author_ident);
+               split_ident_or_die(&ci, &committer_ident);
+
+               if (ident_cmp(&ai, &ci))
                        status_printf_ln(s, GIT_COLOR_NORMAL,
                                _("%s"
-                               "Author:    %s"),
+                               "Author:    %.*s <%.*s>"),
                                ident_shown++ ? "" : "\n",
-                               author_ident->buf);
+                               (int)(ai.name_end - ai.name_begin), ai.name_begin,
+                               (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
+
+               if (author_date_is_interesting())
+                       status_printf_ln(s, GIT_COLOR_NORMAL,
+                               _("%s"
+                               "Date:      %s"),
+                               ident_shown++ ? "" : "\n",
+                               show_ident_date(&ai, DATE_NORMAL));
 
                if (!committer_ident_sufficiently_given())
                        status_printf_ln(s, GIT_COLOR_NORMAL,
                                _("%s"
-                               "Committer: %s"),
+                               "Committer: %.*s <%.*s>"),
                                ident_shown++ ? "" : "\n",
-                               committer_ident.buf);
+                               (int)(ci.name_end - ci.name_begin), ci.name_begin,
+                               (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
 
                if (ident_shown)
-                       status_printf_ln(s, GIT_COLOR_NORMAL, "");
+                       status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");
 
                saved_color_setting = s->use_color;
                s->use_color = 0;
                commitable = run_status(s->fp, index_file, prefix, 1, s);
                s->use_color = saved_color_setting;
-
-               *ai_tmp = ' ';
-               *ci_tmp = ' ';
        } else {
                unsigned char sha1[20];
                const char *parent = "HEAD";
@@ -1388,6 +1421,13 @@ static void print_summary(const char *prefix, const unsigned char *sha1,
                strbuf_addstr(&format, "\n Author: ");
                strbuf_addbuf_percentquote(&format, &author_ident);
        }
+       if (author_date_is_interesting()) {
+               struct strbuf date = STRBUF_INIT;
+               format_commit_message(commit, "%ad", &date, &pctx);
+               strbuf_addstr(&format, "\n Date: ");
+               strbuf_addbuf_percentquote(&format, &date);
+               strbuf_release(&date);
+       }
        if (!committer_ident_sufficiently_given()) {
                strbuf_addstr(&format, "\n Committer: ");
                strbuf_addbuf_percentquote(&format, &committer_ident);
@@ -1704,6 +1744,10 @@ int cmd_commit(int argc, const char **argv, const char *prefix)
                                           ? NULL
                                           : current_head->object.sha1,
                                           0, NULL);
+       if (!ref_lock) {
+               rollback_index_files();
+               die(_("cannot lock HEAD ref"));
+       }
 
        nl = strchr(sb.buf, '\n');
        if (nl)
@@ -1713,10 +1757,6 @@ int cmd_commit(int argc, const char **argv, const char *prefix)
        strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
        strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
 
-       if (!ref_lock) {
-               rollback_index_files();
-               die(_("cannot lock HEAD ref"));
-       }
        if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
                rollback_index_files();
                die(_("cannot update HEAD ref"));
index 69ac2d8797ec32dc206425db0a2f3d7356810cfe..c86a142f308d614daefd459fd9f9ddebe03f4cb8 100644 (file)
@@ -361,9 +361,7 @@ static void run_pager(struct grep_opt *opt, const char *prefix)
                argv[i] = path_list->items[i].string;
        argv[path_list->nr] = NULL;
 
-       if (prefix && chdir(prefix))
-               die(_("Failed to chdir: %s"), prefix);
-       status = run_command_v_opt(argv, RUN_USING_SHELL);
+       status = run_command_v_opt_cd_env(argv, RUN_USING_SHELL, prefix, NULL);
        if (status)
                exit(status);
        free(argv);
@@ -874,6 +872,9 @@ int cmd_grep(int argc, const char **argv, const char *prefix)
                if (len > 4 && is_dir_sep(pager[len - 5]))
                        pager += len - 4;
 
+               if (opt.ignore_case && !strcmp("less", pager))
+                       string_list_append(&path_list, "-I");
+
                if (!strcmp("less", pager) || !strcmp("vi", pager)) {
                        struct strbuf buf = STRBUF_INIT;
                        strbuf_addf(&buf, "+/%s%s",
index b9f6e12c0e91635eafd8510dc7cf20d6c3e58433..18f57de58b02de33909a40ea9720e6602cc9dcb5 100644 (file)
@@ -40,17 +40,13 @@ struct base_data {
        int ofs_first, ofs_last;
 };
 
-#if !defined(NO_PTHREADS) && defined(NO_THREAD_SAFE_PREAD)
-/* pread() emulation is not thread-safe. Disable threading. */
-#define NO_PTHREADS
-#endif
-
 struct thread_local {
 #ifndef NO_PTHREADS
        pthread_t thread;
 #endif
        struct base_data *base_cache;
        size_t base_cache_used;
+       int pack_fd;
 };
 
 /*
@@ -91,7 +87,8 @@ static off_t consumed_bytes;
 static unsigned deepest_delta;
 static git_SHA_CTX input_ctx;
 static uint32_t input_crc32;
-static int input_fd, output_fd, pack_fd;
+static int input_fd, output_fd;
+static const char *curr_pack;
 
 #ifndef NO_PTHREADS
 
@@ -134,6 +131,7 @@ static inline void unlock_mutex(pthread_mutex_t *mutex)
  */
 static void init_thread(void)
 {
+       int i;
        init_recursive_mutex(&read_mutex);
        pthread_mutex_init(&counter_mutex, NULL);
        pthread_mutex_init(&work_mutex, NULL);
@@ -141,11 +139,18 @@ static void init_thread(void)
                pthread_mutex_init(&deepest_delta_mutex, NULL);
        pthread_key_create(&key, NULL);
        thread_data = xcalloc(nr_threads, sizeof(*thread_data));
+       for (i = 0; i < nr_threads; i++) {
+               thread_data[i].pack_fd = open(curr_pack, O_RDONLY);
+               if (thread_data[i].pack_fd == -1)
+                       die_errno(_("unable to open %s"), curr_pack);
+       }
+
        threads_active = 1;
 }
 
 static void cleanup_thread(void)
 {
+       int i;
        if (!threads_active)
                return;
        threads_active = 0;
@@ -154,6 +159,8 @@ static void cleanup_thread(void)
        pthread_mutex_destroy(&work_mutex);
        if (show_stat)
                pthread_mutex_destroy(&deepest_delta_mutex);
+       for (i = 0; i < nr_threads; i++)
+               close(thread_data[i].pack_fd);
        pthread_key_delete(key);
        free(thread_data);
 }
@@ -200,8 +207,13 @@ static unsigned check_object(struct object *obj)
        if (!(obj->flags & FLAG_CHECKED)) {
                unsigned long size;
                int type = sha1_object_info(obj->sha1, &size);
-               if (type != obj->type || type <= 0)
-                       die(_("object of unexpected type"));
+               if (type <= 0)
+                       die(_("did not receive expected object %s"),
+                             sha1_to_hex(obj->sha1));
+               if (type != obj->type)
+                       die(_("object %s: expected type %s, found %s"),
+                           sha1_to_hex(obj->sha1),
+                           typename(obj->type), typename(type));
                obj->flags |= FLAG_CHECKED;
                return 1;
        }
@@ -288,13 +300,13 @@ static const char *open_pack_file(const char *pack_name)
                        output_fd = open(pack_name, O_CREAT|O_EXCL|O_RDWR, 0600);
                if (output_fd < 0)
                        die_errno(_("unable to create '%s'"), pack_name);
-               pack_fd = output_fd;
+               nothread_data.pack_fd = output_fd;
        } else {
                input_fd = open(pack_name, O_RDONLY);
                if (input_fd < 0)
                        die_errno(_("cannot open packfile '%s'"), pack_name);
                output_fd = -1;
-               pack_fd = input_fd;
+               nothread_data.pack_fd = input_fd;
        }
        git_SHA1_Init(&input_ctx);
        return pack_name;
@@ -542,7 +554,7 @@ static void *unpack_data(struct object_entry *obj,
 
        do {
                ssize_t n = (len < 64*1024) ? len : 64*1024;
-               n = pread(pack_fd, inbuf, n, from);
+               n = xpread(get_thread_data()->pack_fd, inbuf, n, from);
                if (n < 0)
                        die_errno(_("cannot pread pack file"));
                if (!n)
@@ -1490,7 +1502,7 @@ static void show_pack_info(int stat_only)
 int cmd_index_pack(int argc, const char **argv, const char *prefix)
 {
        int i, fix_thin_pack = 0, verify = 0, stat_only = 0;
-       const char *curr_pack, *curr_index;
+       const char *curr_index;
        const char *index_name = NULL, *pack_name = NULL;
        const char *keep_name = NULL, *keep_msg = NULL;
        char *index_name_buf = NULL, *keep_name_buf = NULL;
index 66d8843301b22a6a89d9d765e9d3020942e6f672..428ca247bd17e0f18776b46d40a09282b0b955de 100644 (file)
@@ -63,7 +63,7 @@ static int verbosity;
 static int allow_rerere_auto;
 static int abort_current_merge;
 static int show_progress = -1;
-static int default_to_upstream;
+static int default_to_upstream = 1;
 static const char *sign_commit;
 
 static struct strategy all_strategy[] = {
@@ -398,7 +398,7 @@ static void finish(struct commit *head_commit,
                        const char *argv_gc_auto[] = { "gc", "--auto", NULL };
                        update_ref(reflog_message.buf, "HEAD",
                                new_head, head, 0,
-                               DIE_ON_ERR);
+                               UPDATE_REFS_DIE_ON_ERR);
                        /*
                         * We ignore errors in 'gc --auto', since the
                         * user should see them.
@@ -1222,7 +1222,7 @@ int cmd_merge(int argc, const char **argv, const char *prefix)
                        die(_("%s - not something we can merge"), argv[0]);
                read_empty(remote_head->object.sha1, 0);
                update_ref("initial pull", "HEAD", remote_head->object.sha1,
-                          NULL, 0, DIE_ON_ERR);
+                          NULL, 0, UPDATE_REFS_DIE_ON_ERR);
                goto done;
        } else {
                struct strbuf merge_names = STRBUF_INIT;
@@ -1339,7 +1339,7 @@ int cmd_merge(int argc, const char **argv, const char *prefix)
        }
 
        update_ref("updating ORIG_HEAD", "ORIG_HEAD", head_commit->object.sha1,
-                  NULL, 0, DIE_ON_ERR);
+                  NULL, 0, UPDATE_REFS_DIE_ON_ERR);
 
        if (remoteheads && !common)
                ; /* No common ancestors found. We need a real merge. */
index 2a7243f52e413c821f9f75969edcc0a9822c8e21..180ef99127d47d0e8fe9f12a590fd9ba9e524f08 100644 (file)
@@ -203,7 +203,8 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
                        }
                } else if (cache_name_pos(src, length) < 0)
                        bad = _("not under version control");
-               else if (lstat(dst, &st) == 0) {
+               else if (lstat(dst, &st) == 0 &&
+                        (!ignore_case || strcasecmp(src, dst))) {
                        bad = _("destination exists");
                        if (force) {
                                /*
index 39c8573cde00bc15e673ae549fcd0f22ea67d29f..820c34135cab439e2168dd08947bd79d7ed7ae71 100644 (file)
@@ -717,7 +717,7 @@ static int merge_commit(struct notes_merge_options *o)
        strbuf_insert(&msg, 0, "notes: ", 7);
        update_ref(msg.buf, o->local_ref, sha1,
                   is_null_sha1(parent_sha1) ? NULL : parent_sha1,
-                  0, DIE_ON_ERR);
+                  0, UPDATE_REFS_DIE_ON_ERR);
 
        free_notes(t);
        strbuf_release(&msg);
@@ -812,11 +812,11 @@ static int merge(int argc, const char **argv, const char *prefix)
        if (result >= 0) /* Merge resulted (trivially) in result_sha1 */
                /* Update default notes ref with new commit */
                update_ref(msg.buf, default_notes_ref(), result_sha1, NULL,
-                          0, DIE_ON_ERR);
+                          0, UPDATE_REFS_DIE_ON_ERR);
        else { /* Merge has unresolved conflicts */
                /* Update .git/NOTES_MERGE_PARTIAL with partial merge result */
                update_ref(msg.buf, "NOTES_MERGE_PARTIAL", result_sha1, NULL,
-                          0, DIE_ON_ERR);
+                          0, UPDATE_REFS_DIE_ON_ERR);
                /* Store ref-to-be-updated into .git/NOTES_MERGE_REF */
                if (create_symref("NOTES_MERGE_REF", default_notes_ref(), NULL))
                        die("Failed to store link to current notes ref (%s)",
index c12a9784e6b45d50129b786a45bb5f4e4dd0801a..e8a8fb13b9ffc8d3276048131e33e9874bc3bdea 100644 (file)
@@ -369,7 +369,7 @@ static int expire_reflog(const char *ref, const unsigned char *sha1, int unused,
        if (!lock)
                return error("cannot lock ref '%s'", ref);
        log_file = git_pathdup("logs/%s", ref);
-       if (!file_exists(log_file))
+       if (!reflog_exists(ref))
                goto finish;
        if (!cmd->dry_run) {
                newlog_path = git_pathdup("logs/%s.lock", ref);
index 4e51addb3e135465bdb728bb00c5dc3dd53b7c51..98eb8c5404914e4046fdb886866b611351deeacf 100644 (file)
@@ -60,6 +60,8 @@ int cmd_rerere(int argc, const char **argv, const char *prefix)
 
        argc = parse_options(argc, argv, prefix, options, rerere_usage, 0);
 
+       git_config(git_xmerge_config, NULL);
+
        if (autoupdate == 1)
                flags = RERERE_AUTOUPDATE;
        if (autoupdate == 0)
index f4e087596b6337d2306af4cf45119752b4a049ea..f368266762fae1e6c783d7351e289e423e408b3c 100644 (file)
@@ -252,11 +252,13 @@ static int reset_refs(const char *rev, const unsigned char *sha1)
        if (!get_sha1("HEAD", sha1_orig)) {
                orig = sha1_orig;
                set_reflog_message(&msg, "updating ORIG_HEAD", NULL);
-               update_ref(msg.buf, "ORIG_HEAD", orig, old_orig, 0, MSG_ON_ERR);
+               update_ref(msg.buf, "ORIG_HEAD", orig, old_orig, 0,
+                          UPDATE_REFS_MSG_ON_ERR);
        } else if (old_orig)
                delete_ref("ORIG_HEAD", old_orig, 0);
        set_reflog_message(&msg, "updating HEAD", rev);
-       update_ref_status = update_ref(msg.buf, "HEAD", sha1, orig, 0, MSG_ON_ERR);
+       update_ref_status = update_ref(msg.buf, "HEAD", sha1, orig, 0,
+                                      UPDATE_REFS_MSG_ON_ERR);
        strbuf_release(&msg);
        return update_ref_status;
 }
index 6c7c6bde9de9cbc0ace94aa75df30b7b88b43aca..c6e8a7112700c03b2615f9c99c9858884128ab25 100644 (file)
@@ -80,11 +80,19 @@ static int in_commit_list(const struct commit_list *want, struct commit *c)
        return 0;
 }
 
-static int contains_recurse(struct commit *candidate,
+enum contains_result {
+       CONTAINS_UNKNOWN = -1,
+       CONTAINS_NO = 0,
+       CONTAINS_YES = 1,
+};
+
+/*
+ * Test whether the candidate or one of its parents is contained in the list.
+ * Do not recurse to find out, though, but return -1 if inconclusive.
+ */
+static enum contains_result contains_test(struct commit *candidate,
                            const struct commit_list *want)
 {
-       struct commit_list *p;
-
        /* was it previously marked as containing a want commit? */
        if (candidate->object.flags & TMP_MARK)
                return 1;
@@ -92,26 +100,78 @@ static int contains_recurse(struct commit *candidate,
        if (candidate->object.flags & UNINTERESTING)
                return 0;
        /* or are we it? */
-       if (in_commit_list(want, candidate))
+       if (in_commit_list(want, candidate)) {
+               candidate->object.flags |= TMP_MARK;
                return 1;
+       }
 
        if (parse_commit(candidate) < 0)
                return 0;
 
-       /* Otherwise recurse and mark ourselves for future traversals. */
-       for (p = candidate->parents; p; p = p->next) {
-               if (contains_recurse(p->item, want)) {
-                       candidate->object.flags |= TMP_MARK;
-                       return 1;
-               }
-       }
-       candidate->object.flags |= UNINTERESTING;
-       return 0;
+       return -1;
 }
 
-static int contains(struct commit *candidate, const struct commit_list *want)
+/*
+ * Mimicking the real stack, this stack lives on the heap, avoiding stack
+ * overflows.
+ *
+ * At each recursion step, the stack items points to the commits whose
+ * ancestors are to be inspected.
+ */
+struct stack {
+       int nr, alloc;
+       struct stack_entry {
+               struct commit *commit;
+               struct commit_list *parents;
+       } *stack;
+};
+
+static void push_to_stack(struct commit *candidate, struct stack *stack)
+{
+       int index = stack->nr++;
+       ALLOC_GROW(stack->stack, stack->nr, stack->alloc);
+       stack->stack[index].commit = candidate;
+       stack->stack[index].parents = candidate->parents;
+}
+
+static enum contains_result contains(struct commit *candidate,
+               const struct commit_list *want)
 {
-       return contains_recurse(candidate, want);
+       struct stack stack = { 0, 0, NULL };
+       int result = contains_test(candidate, want);
+
+       if (result != CONTAINS_UNKNOWN)
+               return result;
+
+       push_to_stack(candidate, &stack);
+       while (stack.nr) {
+               struct stack_entry *entry = &stack.stack[stack.nr - 1];
+               struct commit *commit = entry->commit;
+               struct commit_list *parents = entry->parents;
+
+               if (!parents) {
+                       commit->object.flags |= UNINTERESTING;
+                       stack.nr--;
+               }
+               /*
+                * If we just popped the stack, parents->item has been marked,
+                * therefore contains_test will return a meaningful 0 or 1.
+                */
+               else switch (contains_test(parents->item, want)) {
+               case CONTAINS_YES:
+                       commit->object.flags |= TMP_MARK;
+                       stack.nr--;
+                       break;
+               case CONTAINS_NO:
+                       entry->parents = parents->next;
+                       break;
+               case CONTAINS_UNKNOWN:
+                       push_to_stack(parents->item, &stack);
+                       break;
+               }
+       }
+       free(stack.stack);
+       return contains_test(candidate, want);
 }
 
 static void show_tag_lines(const unsigned char *sha1, int lines)
@@ -278,11 +338,11 @@ static int do_sign(struct strbuf *buffer)
 }
 
 static const char tag_template[] =
-       N_("\nWrite a tag message\n"
+       N_("\nWrite a message for tag:\n  %s\n"
        "Lines starting with '%c' will be ignored.\n");
 
 static const char tag_template_nocleanup[] =
-       N_("\nWrite a tag message\n"
+       N_("\nWrite a message for tag:\n  %s\n"
        "Lines starting with '%c' will be kept; you may remove them"
        " yourself if you want to.\n");
 
@@ -378,9 +438,9 @@ static void create_tag(const unsigned char *object, const char *tag,
                        struct strbuf buf = STRBUF_INIT;
                        strbuf_addch(&buf, '\n');
                        if (opt->cleanup_mode == CLEANUP_ALL)
-                               strbuf_commented_addf(&buf, _(tag_template), comment_line_char);
+                               strbuf_commented_addf(&buf, _(tag_template), tag, comment_line_char);
                        else
-                               strbuf_commented_addf(&buf, _(tag_template_nocleanup), comment_line_char);
+                               strbuf_commented_addf(&buf, _(tag_template_nocleanup), tag, comment_line_char);
                        write_or_die(fd, buf.buf, buf.len);
                        strbuf_release(&buf);
                }
index 5c208bb1fc4f6c467842b37157435e87fe1415cd..405267f6e2776b3b2bf5c91c1102e090f5ac68f0 100644 (file)
@@ -12,238 +12,329 @@ static const char * const git_update_ref_usage[] = {
        NULL
 };
 
-static int updates_alloc;
-static int updates_count;
-static const struct ref_update **updates;
+static struct ref_transaction *transaction;
 
 static char line_termination = '\n';
 static int update_flags;
 
-static struct ref_update *update_alloc(void)
-{
-       struct ref_update *update;
-
-       /* Allocate and zero-init a struct ref_update */
-       update = xcalloc(1, sizeof(*update));
-       ALLOC_GROW(updates, updates_count + 1, updates_alloc);
-       updates[updates_count++] = update;
-
-       /* Store and reset accumulated options */
-       update->flags = update_flags;
-       update_flags = 0;
-
-       return update;
-}
-
-static void update_store_ref_name(struct ref_update *update,
-                                 const char *ref_name)
-{
-       if (check_refname_format(ref_name, REFNAME_ALLOW_ONELEVEL))
-               die("invalid ref format: %s", ref_name);
-       update->ref_name = xstrdup(ref_name);
-}
-
-static void update_store_new_sha1(struct ref_update *update,
-                                 const char *newvalue)
-{
-       if (*newvalue && get_sha1(newvalue, update->new_sha1))
-               die("invalid new value for ref %s: %s",
-                   update->ref_name, newvalue);
-}
-
-static void update_store_old_sha1(struct ref_update *update,
-                                 const char *oldvalue)
-{
-       if (*oldvalue && get_sha1(oldvalue, update->old_sha1))
-               die("invalid old value for ref %s: %s",
-                   update->ref_name, oldvalue);
-
-       /* We have an old value if non-empty, or if empty without -z */
-       update->have_old = *oldvalue || line_termination;
-}
-
+/*
+ * Parse one whitespace- or NUL-terminated, possibly C-quoted argument
+ * and append the result to arg.  Return a pointer to the terminator.
+ * Die if there is an error in how the argument is C-quoted.  This
+ * function is only used if not -z.
+ */
 static const char *parse_arg(const char *next, struct strbuf *arg)
 {
-       /* Parse SP-terminated, possibly C-quoted argument */
-       if (*next != '"')
+       if (*next == '"') {
+               const char *orig = next;
+
+               if (unquote_c_style(arg, next, &next))
+                       die("badly quoted argument: %s", orig);
+               if (*next && !isspace(*next))
+                       die("unexpected character after quoted argument: %s", orig);
+       } else {
                while (*next && !isspace(*next))
                        strbuf_addch(arg, *next++);
-       else if (unquote_c_style(arg, next, &next))
-               die("badly quoted argument: %s", next);
+       }
 
-       /* Return position after the argument */
        return next;
 }
 
-static const char *parse_first_arg(const char *next, struct strbuf *arg)
+/*
+ * Parse the reference name immediately after "command SP".  If not
+ * -z, then handle C-quoting.  Return a pointer to a newly allocated
+ * string containing the name of the reference, or NULL if there was
+ * an error.  Update *next to point at the character that terminates
+ * the argument.  Die if C-quoting is malformed or the reference name
+ * is invalid.
+ */
+static char *parse_refname(struct strbuf *input, const char **next)
 {
-       /* Parse argument immediately after "command SP" */
-       strbuf_reset(arg);
+       struct strbuf ref = STRBUF_INIT;
+
        if (line_termination) {
                /* Without -z, use the next argument */
-               next = parse_arg(next, arg);
+               *next = parse_arg(*next, &ref);
        } else {
-               /* With -z, use rest of first NUL-terminated line */
-               strbuf_addstr(arg, next);
-               next = next + arg->len;
+               /* With -z, use everything up to the next NUL */
+               strbuf_addstr(&ref, *next);
+               *next += ref.len;
        }
-       return next;
+
+       if (!ref.len) {
+               strbuf_release(&ref);
+               return NULL;
+       }
+
+       if (check_refname_format(ref.buf, REFNAME_ALLOW_ONELEVEL))
+               die("invalid ref format: %s", ref.buf);
+
+       return strbuf_detach(&ref, NULL);
 }
 
-static const char *parse_next_arg(const char *next, struct strbuf *arg)
+/*
+ * The value being parsed is <oldvalue> (as opposed to <newvalue>; the
+ * difference affects which error messages are generated):
+ */
+#define PARSE_SHA1_OLD 0x01
+
+/*
+ * For backwards compatibility, accept an empty string for update's
+ * <newvalue> in binary mode to be equivalent to specifying zeros.
+ */
+#define PARSE_SHA1_ALLOW_EMPTY 0x02
+
+/*
+ * Parse an argument separator followed by the next argument, if any.
+ * If there is an argument, convert it to a SHA-1, write it to sha1,
+ * set *next to point at the character terminating the argument, and
+ * return 0.  If there is no argument at all (not even the empty
+ * string), return 1 and leave *next unchanged.  If the value is
+ * provided but cannot be converted to a SHA-1, die.  flags can
+ * include PARSE_SHA1_OLD and/or PARSE_SHA1_ALLOW_EMPTY.
+ */
+static int parse_next_sha1(struct strbuf *input, const char **next,
+                          unsigned char *sha1,
+                          const char *command, const char *refname,
+                          int flags)
 {
-       /* Parse next SP-terminated or NUL-terminated argument, if any */
-       strbuf_reset(arg);
+       struct strbuf arg = STRBUF_INIT;
+       int ret = 0;
+
+       if (*next == input->buf + input->len)
+               goto eof;
+
        if (line_termination) {
                /* Without -z, consume SP and use next argument */
-               if (!*next)
-                       return NULL;
-               if (*next != ' ')
-                       die("expected SP but got: %s", next);
-               next = parse_arg(next + 1, arg);
+               if (!**next || **next == line_termination)
+                       return 1;
+               if (**next != ' ')
+                       die("%s %s: expected SP but got: %s",
+                           command, refname, *next);
+               (*next)++;
+               *next = parse_arg(*next, &arg);
+               if (arg.len) {
+                       if (get_sha1(arg.buf, sha1))
+                               goto invalid;
+               } else {
+                       /* Without -z, an empty value means all zeros: */
+                       hashclr(sha1);
+               }
        } else {
                /* With -z, read the next NUL-terminated line */
-               if (*next)
-                       die("expected NUL but got: %s", next);
-               if (strbuf_getline(arg, stdin, '\0') == EOF)
-                       return NULL;
-               next = arg->buf + arg->len;
+               if (**next)
+                       die("%s %s: expected NUL but got: %s",
+                           command, refname, *next);
+               (*next)++;
+               if (*next == input->buf + input->len)
+                       goto eof;
+               strbuf_addstr(&arg, *next);
+               *next += arg.len;
+
+               if (arg.len) {
+                       if (get_sha1(arg.buf, sha1))
+                               goto invalid;
+               } else if (flags & PARSE_SHA1_ALLOW_EMPTY) {
+                       /* With -z, treat an empty value as all zeros: */
+                       warning("%s %s: missing <newvalue>, treating as zero",
+                               command, refname);
+                       hashclr(sha1);
+               } else {
+                       /*
+                        * With -z, an empty non-required value means
+                        * unspecified:
+                        */
+                       ret = 1;
+               }
        }
-       return next;
+
+       strbuf_release(&arg);
+
+       return ret;
+
+ invalid:
+       die(flags & PARSE_SHA1_OLD ?
+           "%s %s: invalid <oldvalue>: %s" :
+           "%s %s: invalid <newvalue>: %s",
+           command, refname, arg.buf);
+
+ eof:
+       die(flags & PARSE_SHA1_OLD ?
+           "%s %s: unexpected end of input when reading <oldvalue>" :
+           "%s %s: unexpected end of input when reading <newvalue>",
+           command, refname);
 }
 
-static void parse_cmd_update(const char *next)
+
+/*
+ * The following five parse_cmd_*() functions parse the corresponding
+ * command.  In each case, next points at the character following the
+ * command name and the following space.  They each return a pointer
+ * to the character terminating the command, and die with an
+ * explanatory message if there are any parsing problems.  All of
+ * these functions handle either text or binary format input,
+ * depending on how line_termination is set.
+ */
+
+static const char *parse_cmd_update(struct strbuf *input, const char *next)
 {
-       struct strbuf ref = STRBUF_INIT;
-       struct strbuf newvalue = STRBUF_INIT;
-       struct strbuf oldvalue = STRBUF_INIT;
-       struct ref_update *update;
+       char *refname;
+       unsigned char new_sha1[20];
+       unsigned char old_sha1[20];
+       int have_old;
 
-       update = update_alloc();
+       refname = parse_refname(input, &next);
+       if (!refname)
+               die("update: missing <ref>");
 
-       if ((next = parse_first_arg(next, &ref)) != NULL && ref.buf[0])
-               update_store_ref_name(update, ref.buf);
-       else
-               die("update line missing <ref>");
+       if (parse_next_sha1(input, &next, new_sha1, "update", refname,
+                           PARSE_SHA1_ALLOW_EMPTY))
+               die("update %s: missing <newvalue>", refname);
 
-       if ((next = parse_next_arg(next, &newvalue)) != NULL)
-               update_store_new_sha1(update, newvalue.buf);
-       else
-               die("update %s missing <newvalue>", ref.buf);
+       have_old = !parse_next_sha1(input, &next, old_sha1, "update", refname,
+                                   PARSE_SHA1_OLD);
 
-       if ((next = parse_next_arg(next, &oldvalue)) != NULL)
-               update_store_old_sha1(update, oldvalue.buf);
-       else if(!line_termination)
-               die("update %s missing [<oldvalue>] NUL", ref.buf);
+       if (*next != line_termination)
+               die("update %s: extra input: %s", refname, next);
 
-       if (next && *next)
-               die("update %s has extra input: %s", ref.buf, next);
+       ref_transaction_update(transaction, refname, new_sha1, old_sha1,
+                              update_flags, have_old);
+
+       update_flags = 0;
+       free(refname);
+
+       return next;
 }
 
-static void parse_cmd_create(const char *next)
+static const char *parse_cmd_create(struct strbuf *input, const char *next)
 {
-       struct strbuf ref = STRBUF_INIT;
-       struct strbuf newvalue = STRBUF_INIT;
-       struct ref_update *update;
+       char *refname;
+       unsigned char new_sha1[20];
 
-       update = update_alloc();
-       update->have_old = 1;
+       refname = parse_refname(input, &next);
+       if (!refname)
+               die("create: missing <ref>");
 
-       if ((next = parse_first_arg(next, &ref)) != NULL && ref.buf[0])
-               update_store_ref_name(update, ref.buf);
-       else
-               die("create line missing <ref>");
+       if (parse_next_sha1(input, &next, new_sha1, "create", refname, 0))
+               die("create %s: missing <newvalue>", refname);
 
-       if ((next = parse_next_arg(next, &newvalue)) != NULL)
-               update_store_new_sha1(update, newvalue.buf);
-       else
-               die("create %s missing <newvalue>", ref.buf);
-       if (is_null_sha1(update->new_sha1))
-               die("create %s given zero new value", ref.buf);
+       if (is_null_sha1(new_sha1))
+               die("create %s: zero <newvalue>", refname);
+
+       if (*next != line_termination)
+               die("create %s: extra input: %s", refname, next);
 
-       if (next && *next)
-               die("create %s has extra input: %s", ref.buf, next);
+       ref_transaction_create(transaction, refname, new_sha1, update_flags);
+
+       update_flags = 0;
+       free(refname);
+
+       return next;
 }
 
-static void parse_cmd_delete(const char *next)
+static const char *parse_cmd_delete(struct strbuf *input, const char *next)
 {
-       struct strbuf ref = STRBUF_INIT;
-       struct strbuf oldvalue = STRBUF_INIT;
-       struct ref_update *update;
+       char *refname;
+       unsigned char old_sha1[20];
+       int have_old;
 
-       update = update_alloc();
+       refname = parse_refname(input, &next);
+       if (!refname)
+               die("delete: missing <ref>");
 
-       if ((next = parse_first_arg(next, &ref)) != NULL && ref.buf[0])
-               update_store_ref_name(update, ref.buf);
-       else
-               die("delete line missing <ref>");
+       if (parse_next_sha1(input, &next, old_sha1, "delete", refname,
+                           PARSE_SHA1_OLD)) {
+               have_old = 0;
+       } else {
+               if (is_null_sha1(old_sha1))
+                       die("delete %s: zero <oldvalue>", refname);
+               have_old = 1;
+       }
+
+       if (*next != line_termination)
+               die("delete %s: extra input: %s", refname, next);
 
-       if ((next = parse_next_arg(next, &oldvalue)) != NULL)
-               update_store_old_sha1(update, oldvalue.buf);
-       else if(!line_termination)
-               die("delete %s missing [<oldvalue>] NUL", ref.buf);
-       if (update->have_old && is_null_sha1(update->old_sha1))
-               die("delete %s given zero old value", ref.buf);
+       ref_transaction_delete(transaction, refname, old_sha1,
+                              update_flags, have_old);
 
-       if (next && *next)
-               die("delete %s has extra input: %s", ref.buf, next);
+       update_flags = 0;
+       free(refname);
+
+       return next;
 }
 
-static void parse_cmd_verify(const char *next)
+static const char *parse_cmd_verify(struct strbuf *input, const char *next)
 {
-       struct strbuf ref = STRBUF_INIT;
-       struct strbuf value = STRBUF_INIT;
-       struct ref_update *update;
+       char *refname;
+       unsigned char new_sha1[20];
+       unsigned char old_sha1[20];
+       int have_old;
+
+       refname = parse_refname(input, &next);
+       if (!refname)
+               die("verify: missing <ref>");
+
+       if (parse_next_sha1(input, &next, old_sha1, "verify", refname,
+                           PARSE_SHA1_OLD)) {
+               hashclr(new_sha1);
+               have_old = 0;
+       } else {
+               hashcpy(new_sha1, old_sha1);
+               have_old = 1;
+       }
 
-       update = update_alloc();
+       if (*next != line_termination)
+               die("verify %s: extra input: %s", refname, next);
 
-       if ((next = parse_first_arg(next, &ref)) != NULL && ref.buf[0])
-               update_store_ref_name(update, ref.buf);
-       else
-               die("verify line missing <ref>");
+       ref_transaction_update(transaction, refname, new_sha1, old_sha1,
+                              update_flags, have_old);
 
-       if ((next = parse_next_arg(next, &value)) != NULL) {
-               update_store_old_sha1(update, value.buf);
-               update_store_new_sha1(update, value.buf);
-       } else if(!line_termination)
-               die("verify %s missing [<oldvalue>] NUL", ref.buf);
+       update_flags = 0;
+       free(refname);
 
-       if (next && *next)
-               die("verify %s has extra input: %s", ref.buf, next);
+       return next;
 }
 
-static void parse_cmd_option(const char *next)
+static const char *parse_cmd_option(struct strbuf *input, const char *next)
 {
-       if (!strcmp(next, "no-deref"))
+       if (!strncmp(next, "no-deref", 8) && next[8] == line_termination)
                update_flags |= REF_NODEREF;
        else
                die("option unknown: %s", next);
+       return next + 8;
 }
 
 static void update_refs_stdin(void)
 {
-       struct strbuf cmd = STRBUF_INIT;
+       struct strbuf input = STRBUF_INIT;
+       const char *next;
 
+       if (strbuf_read(&input, 0, 1000) < 0)
+               die_errno("could not read from stdin");
+       next = input.buf;
        /* Read each line dispatch its command */
-       while (strbuf_getline(&cmd, stdin, line_termination) != EOF)
-               if (!cmd.buf[0])
+       while (next < input.buf + input.len) {
+               if (*next == line_termination)
                        die("empty command in input");
-               else if (isspace(*cmd.buf))
-                       die("whitespace before command: %s", cmd.buf);
-               else if (starts_with(cmd.buf, "update "))
-                       parse_cmd_update(cmd.buf + 7);
-               else if (starts_with(cmd.buf, "create "))
-                       parse_cmd_create(cmd.buf + 7);
-               else if (starts_with(cmd.buf, "delete "))
-                       parse_cmd_delete(cmd.buf + 7);
-               else if (starts_with(cmd.buf, "verify "))
-                       parse_cmd_verify(cmd.buf + 7);
-               else if (starts_with(cmd.buf, "option "))
-                       parse_cmd_option(cmd.buf + 7);
+               else if (isspace(*next))
+                       die("whitespace before command: %s", next);
+               else if (starts_with(next, "update "))
+                       next = parse_cmd_update(&input, next + 7);
+               else if (starts_with(next, "create "))
+                       next = parse_cmd_create(&input, next + 7);
+               else if (starts_with(next, "delete "))
+                       next = parse_cmd_delete(&input, next + 7);
+               else if (starts_with(next, "verify "))
+                       next = parse_cmd_verify(&input, next + 7);
+               else if (starts_with(next, "option "))
+                       next = parse_cmd_option(&input, next + 7);
                else
-                       die("unknown command: %s", cmd.buf);
+                       die("unknown command: %s", next);
+
+               next++;
+       }
 
-       strbuf_release(&cmd);
+       strbuf_release(&input);
 }
 
 int cmd_update_ref(int argc, const char **argv, const char *prefix)
@@ -268,12 +359,17 @@ int cmd_update_ref(int argc, const char **argv, const char *prefix)
                die("Refusing to perform update with empty message.");
 
        if (read_stdin) {
+               int ret;
+               transaction = ref_transaction_begin();
+
                if (delete || no_deref || argc > 0)
                        usage_with_options(git_update_ref_usage, options);
                if (end_null)
                        line_termination = '\0';
                update_refs_stdin();
-               return update_refs(msg, updates, updates_count, DIE_ON_ERR);
+               ret = ref_transaction_commit(transaction, msg,
+                                            UPDATE_REFS_DIE_ON_ERR);
+               return ret;
        }
 
        if (end_null)
@@ -305,5 +401,5 @@ int cmd_update_ref(int argc, const char **argv, const char *prefix)
                return delete_ref(refname, oldval ? oldsha1 : NULL, flags);
        else
                return update_ref(msg, refname, sha1, oldval ? oldsha1 : NULL,
-                                 flags, DIE_ON_ERR);
+                                 flags, UPDATE_REFS_DIE_ON_ERR);
 }
diff --git a/cache.h b/cache.h
index 646fb810bb38f5a942fab7bb091e1d965443d1b8..1e4b4f06e1ee013db0cb696115ead61a76087f4e 100644 (file)
--- a/cache.h
+++ b/cache.h
@@ -74,6 +74,21 @@ unsigned long git_deflate_bound(git_zstream *, unsigned long);
 #define S_IFGITLINK    0160000
 #define S_ISGITLINK(m) (((m) & S_IFMT) == S_IFGITLINK)
 
+/*
+ * Some mode bits are also used internally for computations.
+ *
+ * They *must* not overlap with any valid modes, and they *must* not be emitted
+ * to outside world - i.e. appear on disk or network. In other words, it's just
+ * temporary fields, which we internally use, but they have to stay in-house.
+ *
+ * ( such approach is valid, as standard S_IF* fits into 16 bits, and in Git
+ *   codebase mode is `unsigned int` which is assumed to be at least 32 bits )
+ */
+
+/* used internally in tree-diff */
+#define S_DIFFTREE_IFXMIN_NEQ  0x80000000
+
+
 /*
  * Intensive research over the course of many years has shown that
  * port 9418 is totally unused by anything else. Or
@@ -279,6 +294,7 @@ struct index_state {
                 initialized : 1;
        struct hashmap name_hash;
        struct hashmap dir_hash;
+       unsigned char sha1[20];
 };
 
 extern struct index_state the_index;
@@ -1046,6 +1062,13 @@ struct ident_split {
  */
 extern int split_ident_line(struct ident_split *, const char *, int);
 
+/*
+ * Like show_date, but pull the timestamp and tz parameters from
+ * the ident_split. It will also sanity-check the values and produce
+ * a well-known sentinel date if they appear bogus.
+ */
+const char *show_ident_date(const struct ident_split *id, enum date_mode mode);
+
 /*
  * Compare split idents for equality or strict ordering. Note that we
  * compare only the ident part of the line, ignoring any timestamp.
@@ -1272,8 +1295,8 @@ extern int check_repository_format_version(const char *var, const char *value, v
 extern int git_env_bool(const char *, int);
 extern int git_config_system(void);
 extern int config_error_nonbool(const char *);
-#if defined(__GNUC__) && ! defined(__clang__)
-#define config_error_nonbool(s) (config_error_nonbool(s), -1)
+#if defined(__GNUC__)
+#define config_error_nonbool(s) (config_error_nonbool(s), const_error())
 #endif
 extern const char *get_log_output_encoding(void);
 extern const char *get_commit_output_encoding(void);
@@ -1323,6 +1346,8 @@ extern void fsync_or_die(int fd, const char *);
 
 extern ssize_t read_in_full(int fd, void *buf, size_t count);
 extern ssize_t write_in_full(int fd, const void *buf, size_t count);
+extern ssize_t pread_in_full(int fd, void *buf, size_t count, off_t offset);
+
 static inline ssize_t write_str_in_full(int fd, const char *str)
 {
        return write_in_full(fd, str, strlen(str));
index 24ca7e2334b68e06afd24051ad1aafcc129bcba4..f9975d2c2ebc83e8ecfc953c8df907fbff7858f5 100644 (file)
@@ -1301,6 +1301,81 @@ static const char *path_path(void *obj)
        return path->path;
 }
 
+
+/* find set of paths that every parent touches */
+static struct combine_diff_path *find_paths_generic(const unsigned char *sha1,
+       const struct sha1_array *parents, struct diff_options *opt)
+{
+       struct combine_diff_path *paths = NULL;
+       int i, num_parent = parents->nr;
+
+       int output_format = opt->output_format;
+       const char *orderfile = opt->orderfile;
+
+       opt->output_format = DIFF_FORMAT_NO_OUTPUT;
+       /* tell diff_tree to emit paths in sorted (=tree) order */
+       opt->orderfile = NULL;
+
+       /* D(A,P1...Pn) = D(A,P1) ^ ... ^ D(A,Pn)  (wrt paths) */
+       for (i = 0; i < num_parent; i++) {
+               /*
+                * show stat against the first parent even when doing
+                * combined diff.
+                */
+               int stat_opt = (output_format &
+                               (DIFF_FORMAT_NUMSTAT|DIFF_FORMAT_DIFFSTAT));
+               if (i == 0 && stat_opt)
+                       opt->output_format = stat_opt;
+               else
+                       opt->output_format = DIFF_FORMAT_NO_OUTPUT;
+               diff_tree_sha1(parents->sha1[i], sha1, "", opt);
+               diffcore_std(opt);
+               paths = intersect_paths(paths, i, num_parent);
+
+               /* if showing diff, show it in requested order */
+               if (opt->output_format != DIFF_FORMAT_NO_OUTPUT &&
+                   orderfile) {
+                       diffcore_order(orderfile);
+               }
+
+               diff_flush(opt);
+       }
+
+       opt->output_format = output_format;
+       opt->orderfile = orderfile;
+       return paths;
+}
+
+
+/*
+ * find set of paths that everybody touches, assuming diff is run without
+ * rename/copy detection, etc, comparing all trees simultaneously (= faster).
+ */
+static struct combine_diff_path *find_paths_multitree(
+       const unsigned char *sha1, const struct sha1_array *parents,
+       struct diff_options *opt)
+{
+       int i, nparent = parents->nr;
+       const unsigned char **parents_sha1;
+       struct combine_diff_path paths_head;
+       struct strbuf base;
+
+       parents_sha1 = xmalloc(nparent * sizeof(parents_sha1[0]));
+       for (i = 0; i < nparent; i++)
+               parents_sha1[i] = parents->sha1[i];
+
+       /* fake list head, so worker can assume it is non-NULL */
+       paths_head.next = NULL;
+
+       strbuf_init(&base, PATH_MAX);
+       diff_tree_paths(&paths_head, sha1, parents_sha1, nparent, &base, opt);
+
+       strbuf_release(&base);
+       free(parents_sha1);
+       return paths_head.next;
+}
+
+
 void diff_tree_combined(const unsigned char *sha1,
                        const struct sha1_array *parents,
                        int dense,
@@ -1308,49 +1383,83 @@ void diff_tree_combined(const unsigned char *sha1,
 {
        struct diff_options *opt = &rev->diffopt;
        struct diff_options diffopts;
-       struct combine_diff_path *p, *paths = NULL;
+       struct combine_diff_path *p, *paths;
        int i, num_paths, needsep, show_log_first, num_parent = parents->nr;
+       int need_generic_pathscan;
+
+       /* nothing to do, if no parents */
+       if (!num_parent)
+               return;
+
+       show_log_first = !!rev->loginfo && !rev->no_commit_id;
+       needsep = 0;
+       if (show_log_first) {
+               show_log(rev);
+
+               if (rev->verbose_header && opt->output_format &&
+                   opt->output_format != DIFF_FORMAT_NO_OUTPUT)
+                       printf("%s%c", diff_line_prefix(opt),
+                              opt->line_termination);
+       }
 
        diffopts = *opt;
        copy_pathspec(&diffopts.pathspec, &opt->pathspec);
-       diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
        DIFF_OPT_SET(&diffopts, RECURSIVE);
        DIFF_OPT_CLR(&diffopts, ALLOW_EXTERNAL);
-       /* tell diff_tree to emit paths in sorted (=tree) order */
-       diffopts.orderfile = NULL;
 
-       show_log_first = !!rev->loginfo && !rev->no_commit_id;
-       needsep = 0;
-       /* find set of paths that everybody touches */
-       for (i = 0; i < num_parent; i++) {
-               /* show stat against the first parent even
+       /* find set of paths that everybody touches
+        *
+        * NOTE
+        *
+        * Diffcore transformations are bound to diff_filespec and logic
+        * comparing two entries - i.e. they do not apply directly to combine
+        * diff.
+        *
+        * If some of such transformations is requested - we launch generic
+        * path scanning, which works significantly slower compared to
+        * simultaneous all-trees-in-one-go scan in find_paths_multitree().
+        *
+        * TODO some of the filters could be ported to work on
+        * combine_diff_paths - i.e. all functionality that skips paths, so in
+        * theory, we could end up having only multitree path scanning.
+        *
+        * NOTE please keep this semantically in sync with diffcore_std()
+        */
+       need_generic_pathscan = opt->skip_stat_unmatch  ||
+                       DIFF_OPT_TST(opt, FOLLOW_RENAMES)       ||
+                       opt->break_opt != -1    ||
+                       opt->detect_rename      ||
+                       opt->pickaxe            ||
+                       opt->filter;
+
+
+       if (need_generic_pathscan) {
+               /*
+                * NOTE generic case also handles --stat, as it computes
+                * diff(sha1,parent_i) for all i to do the job, specifically
+                * for parent0.
+                */
+               paths = find_paths_generic(sha1, parents, &diffopts);
+       }
+       else {
+               int stat_opt;
+               paths = find_paths_multitree(sha1, parents, &diffopts);
+
+               /*
+                * show stat against the first parent even
                 * when doing combined diff.
                 */
-               int stat_opt = (opt->output_format &
+               stat_opt = (opt->output_format &
                                (DIFF_FORMAT_NUMSTAT|DIFF_FORMAT_DIFFSTAT));
-               if (i == 0 && stat_opt)
+               if (stat_opt) {
                        diffopts.output_format = stat_opt;
-               else
-                       diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
-               diff_tree_sha1(parents->sha1[i], sha1, "", &diffopts);
-               diffcore_std(&diffopts);
-               paths = intersect_paths(paths, i, num_parent);
 
-               if (show_log_first && i == 0) {
-                       show_log(rev);
-
-                       if (rev->verbose_header && opt->output_format)
-                               printf("%s%c", diff_line_prefix(opt),
-                                      opt->line_termination);
+                       diff_tree_sha1(parents->sha1[0], sha1, "", &diffopts);
+                       diffcore_std(&diffopts);
+                       if (opt->orderfile)
+                               diffcore_order(opt->orderfile);
+                       diff_flush(&diffopts);
                }
-
-               /* if showing diff, show it in requested order */
-               if (diffopts.output_format != DIFF_FORMAT_NO_OUTPUT &&
-                   opt->orderfile) {
-                       diffcore_order(opt->orderfile);
-               }
-
-               diff_flush(&diffopts);
        }
 
        /* find out number of surviving paths */
index c9d46d174259f42a3e2a2eb073475aba517044be..7f662fef7bcb408045eb1536afed058a607ae97b 100644 (file)
@@ -14,7 +14,7 @@ void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t of
        }
 
        while (n < length) {
-               ssize_t count = pread(fd, (char *)start + n, length - n, offset + n);
+               ssize_t count = xpread(fd, (char *)start + n, length - n, offset + n);
 
                if (count == 0) {
                        memset((char *)start+n, 0, length-n);
@@ -22,8 +22,6 @@ void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t of
                }
 
                if (count < 0) {
-                       if (errno == EAGAIN || errno == EINTR)
-                               continue;
                        free(start);
                        errno = EACCES;
                        return MAP_FAILED;
index 31163f2ae7b71857889f561dea0b3ffecff61989..a9b41d89f465208b6f0e417672077403bf30898f 100644 (file)
@@ -605,7 +605,7 @@ poll (struct pollfd *pfd, nfds_t nfd, int timeout)
 
   if (!rc && timeout == INFTIM)
     {
-      SwitchToThread();
+      SleepEx (1, TRUE);
       goto restart;
     }
 
diff --git a/compat/vcbuild/include/alloca.h b/compat/vcbuild/include/alloca.h
deleted file mode 100644 (file)
index c0d7985..0000000
+++ /dev/null
@@ -1 +0,0 @@
-#include <malloc.h>
diff --git a/compat/win32/alloca.h b/compat/win32/alloca.h
new file mode 100644 (file)
index 0000000..c0d7985
--- /dev/null
@@ -0,0 +1 @@
+#include <malloc.h>
index d29c733419829295961898f754271871f807a505..3c3e31448e5be385f9302ccce9c6993667014e5b 100644 (file)
--- a/config.c
+++ b/config.c
@@ -1643,6 +1643,13 @@ int git_config_set_multivar_in_file(const char *config_filename,
                        MAP_PRIVATE, in_fd, 0);
                close(in_fd);
 
+               if (fchmod(fd, st.st_mode & 07777) < 0) {
+                       error("fchmod on %s failed: %s",
+                               lock->filename, strerror(errno));
+                       ret = CONFIG_NO_WRITE;
+                       goto out_free;
+               }
+
                if (store.seen == 0)
                        store.seen = 1;
 
@@ -1791,6 +1798,7 @@ int git_config_rename_section_in_file(const char *config_filename,
        int out_fd;
        char buf[1024];
        FILE *config_file;
+       struct stat st;
 
        if (new_name && !section_name_is_ok(new_name)) {
                ret = error("invalid section name: %s", new_name);
@@ -1812,6 +1820,14 @@ int git_config_rename_section_in_file(const char *config_filename,
                goto unlock_and_out;
        }
 
+       fstat(fileno(config_file), &st);
+
+       if (fchmod(out_fd, st.st_mode & 07777) < 0) {
+               ret = error("fchmod on %s failed: %s",
+                               lock->filename, strerror(errno));
+               goto out;
+       }
+
        while (fgets(buf, sizeof(buf), config_file)) {
                int i;
                int length;
index 23a880365616c34ea84d8a3194b98163864a2cd1..1ae675b05344912d8798b9856b60b03c282cf908 100644 (file)
@@ -28,6 +28,7 @@ ifeq ($(uname_S),OSF1)
        NO_NSEC = YesPlease
 endif
 ifeq ($(uname_S),Linux)
+       HAVE_ALLOCA_H = YesPlease
        NO_STRLCPY = YesPlease
        NO_MKSTEMPS = YesPlease
        HAVE_PATHS_H = YesPlease
@@ -35,6 +36,7 @@ ifeq ($(uname_S),Linux)
        HAVE_DEV_TTY = YesPlease
 endif
 ifeq ($(uname_S),GNU/kFreeBSD)
+       HAVE_ALLOCA_H = YesPlease
        NO_STRLCPY = YesPlease
        NO_MKSTEMPS = YesPlease
        HAVE_PATHS_H = YesPlease
@@ -103,6 +105,7 @@ ifeq ($(uname_S),SunOS)
        NEEDS_NSL = YesPlease
        SHELL_PATH = /bin/bash
        SANE_TOOL_PATH = /usr/xpg6/bin:/usr/xpg4/bin
+       HAVE_ALLOCA_H = YesPlease
        NO_STRCASESTR = YesPlease
        NO_MEMMEM = YesPlease
        NO_MKDTEMP = YesPlease
@@ -145,7 +148,7 @@ ifeq ($(uname_S),SunOS)
        endif
        INSTALL = /usr/ucb/install
        TAR = gtar
-       BASIC_CFLAGS += -D__EXTENSIONS__ -D__sun__ -DHAVE_ALLOCA_H
+       BASIC_CFLAGS += -D__EXTENSIONS__ -D__sun__
 endif
 ifeq ($(uname_O),Cygwin)
        ifeq ($(shell expr "$(uname_R)" : '1\.[1-6]\.'),4)
@@ -157,7 +160,6 @@ ifeq ($(uname_O),Cygwin)
                NO_SYMLINK_HEAD = YesPlease
                NO_IPV6 = YesPlease
                OLD_ICONV = UnfortunatelyYes
-               NO_THREAD_SAFE_PREAD = YesPlease
                # There are conflicting reports about this.
                # On some boxes NO_MMAP is needed, and not so elsewhere.
                # Try commenting this out if you suspect MMAP is more efficient
@@ -165,6 +167,7 @@ ifeq ($(uname_O),Cygwin)
        else
                NO_REGEX = UnfortunatelyYes
        endif
+       HAVE_ALLOCA_H = YesPlease
        NEEDS_LIBICONV = YesPlease
        NO_FAST_WORKING_DIRECTORY = UnfortunatelyYes
        NO_ST_BLOCKS_IN_STRUCT_STAT = YesPlease
@@ -239,6 +242,7 @@ ifeq ($(uname_S),AIX)
 endif
 ifeq ($(uname_S),GNU)
        # GNU/Hurd
+       HAVE_ALLOCA_H = YesPlease
        NO_STRLCPY = YesPlease
        NO_MKSTEMPS = YesPlease
        HAVE_PATHS_H = YesPlease
@@ -313,6 +317,7 @@ endif
 ifeq ($(uname_S),Windows)
        GIT_VERSION := $(GIT_VERSION).MSVC
        pathsep = ;
+       HAVE_ALLOCA_H = YesPlease
        NO_PREAD = YesPlease
        NEEDS_CRYPTO_WITH_SSL = YesPlease
        NO_LIBGEN_H = YesPlease
@@ -357,17 +362,17 @@ ifeq ($(uname_S),Windows)
        COMPAT_OBJS = compat/msvc.o compat/winansi.o \
                compat/win32/pthread.o compat/win32/syslog.o \
                compat/win32/dirent.o
-       COMPAT_CFLAGS = -D__USE_MINGW_ACCESS -DNOGDI -DHAVE_STRING_H -DHAVE_ALLOCA_H -Icompat -Icompat/regex -Icompat/win32 -DSTRIP_EXTENSION=\".exe\"
-       BASIC_LDFLAGS = -IGNORE:4217 -IGNORE:4049 -NOLOGO -SUBSYSTEM:CONSOLE -NODEFAULTLIB:MSVCRT.lib
+       COMPAT_CFLAGS = -D__USE_MINGW_ACCESS -DNOGDI -DHAVE_STRING_H -Icompat -Icompat/regex -Icompat/win32 -DSTRIP_EXTENSION=\".exe\"
+       BASIC_LDFLAGS = -IGNORE:4217 -IGNORE:4049 -NOLOGO -SUBSYSTEM:CONSOLE
        EXTLIBS = user32.lib advapi32.lib shell32.lib wininet.lib ws2_32.lib invalidcontinue.obj
        PTHREAD_LIBS =
        lib =
 ifndef DEBUG
-       BASIC_CFLAGS += -GL -Os -MT
+       BASIC_CFLAGS += -GL -Os -MD
        BASIC_LDFLAGS += -LTCG
        AR += -LTCG
 else
-       BASIC_CFLAGS += -Zi -MTd
+       BASIC_CFLAGS += -Zi -MDd
 endif
        X = .exe
 endif
@@ -465,6 +470,7 @@ ifeq ($(uname_S),NONSTOP_KERNEL)
 endif
 ifneq (,$(findstring MINGW,$(uname_S)))
        pathsep = ;
+       HAVE_ALLOCA_H = YesPlease
        NO_PREAD = YesPlease
        NEEDS_CRYPTO_WITH_SSL = YesPlease
        NO_LIBGEN_H = YesPlease
index b7112542b4b62fbbf0235c923f75803edc149e5c..4b1ae7c3c9f5ff5080dc026a6eb835d579d29949 100644 (file)
@@ -272,6 +272,14 @@ AS_HELP_STRING([],           [ARG can be also prefix for libpcre library and hea
        GIT_CONF_SUBST([LIBPCREDIR])
     fi)
 #
+# Define HAVE_ALLOCA_H if you have working alloca(3) defined in that header.
+AC_FUNC_ALLOCA
+case $ac_cv_working_alloca_h in
+    yes)    HAVE_ALLOCA_H=YesPlease;;
+    *)      HAVE_ALLOCA_H='';;
+esac
+GIT_CONF_SUBST([HAVE_ALLOCA_H])
+#
 # Define NO_CURL if you do not have curl installed.  git-http-pull and
 # git-http-push are not built, and you cannot use http:// and https://
 # transports.
index 853425d005cc7eec5e931b9d1db4a738ba772c74..9d684b10a67ea663410db3ba68482c1a52bbc367 100644 (file)
@@ -209,9 +209,7 @@ __git_ps1_show_upstream ()
                if [[ -n "$count" && -n "$name" ]]; then
                        __git_ps1_upstream_name=$(git rev-parse \
                                --abbrev-ref "$upstream" 2>/dev/null)
-                       if [ $pcmode = yes ]; then
-                               # see the comments around the
-                               # __git_ps1_branch_name variable below
+                       if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then
                                p="$p \${__git_ps1_upstream_name}"
                        else
                                p="$p ${__git_ps1_upstream_name}"
@@ -308,6 +306,43 @@ __git_ps1 ()
                ;;
        esac
 
+       # ps1_expanded:  This variable is set to 'yes' if the shell
+       # subjects the value of PS1 to parameter expansion:
+       #
+       #   * bash does unless the promptvars option is disabled
+       #   * zsh does not unless the PROMPT_SUBST option is set
+       #   * POSIX shells always do
+       #
+       # If the shell would expand the contents of PS1 when drawing
+       # the prompt, a raw ref name must not be included in PS1.
+       # This protects the user from arbitrary code execution via
+       # specially crafted ref names.  For example, a ref named
+       # 'refs/heads/$(IFS=_;cmd=sudo_rm_-rf_/;$cmd)' might cause the
+       # shell to execute 'sudo rm -rf /' when the prompt is drawn.
+       #
+       # Instead, the ref name should be placed in a separate global
+       # variable (in the __git_ps1_* namespace to avoid colliding
+       # with the user's environment) and that variable should be
+       # referenced from PS1.  For example:
+       #
+       #     __git_ps1_foo=$(do_something_to_get_ref_name)
+       #     PS1="...stuff...\${__git_ps1_foo}...stuff..."
+       #
+       # If the shell does not expand the contents of PS1, the raw
+       # ref name must be included in PS1.
+       #
+       # The value of this variable is only relevant when in pcmode.
+       #
+       # Assume that the shell follows the POSIX specification and
+       # expands PS1 unless determined otherwise.  (This is more
+       # likely to be correct if the user has a non-bash, non-zsh
+       # shell and safer than the alternative if the assumption is
+       # incorrect.)
+       #
+       local ps1_expanded=yes
+       [ -z "$ZSH_VERSION" ] || [[ -o PROMPT_SUBST ]] || ps1_expanded=no
+       [ -z "$BASH_VERSION" ] || shopt -q promptvars || ps1_expanded=no
+
        local repo_info rev_parse_exit_code
        repo_info="$(git rev-parse --git-dir --is-inside-git-dir \
                --is-bare-repository --is-inside-work-tree \
@@ -457,21 +492,8 @@ __git_ps1 ()
        fi
 
        b=${b##refs/heads/}
-       if [ $pcmode = yes ]; then
-               # In pcmode (and only pcmode) the contents of
-               # $gitstring are subject to expansion by the shell.
-               # Avoid putting the raw ref name in the prompt to
-               # protect the user from arbitrary code execution via
-               # specially crafted ref names (e.g., a ref named
-               # '$(IFS=_;cmd=sudo_rm_-rf_/;$cmd)' would execute
-               # 'sudo rm -rf /' when the prompt is drawn).  Instead,
-               # put the ref name in a new global variable (in the
-               # __git_ps1_* namespace to avoid colliding with the
-               # user's environment) and reference that variable from
-               # PS1.
+       if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then
                __git_ps1_branch_name=$b
-               # note that the $ is escaped -- the variable will be
-               # expanded later (when it's time to draw the prompt)
                b="\${__git_ps1_branch_name}"
        fi
 
diff --git a/contrib/diffall/README b/contrib/diffall/README
deleted file mode 100644 (file)
index 507f17d..0000000
+++ /dev/null
@@ -1,31 +0,0 @@
-The git-diffall script provides a directory based diff mechanism
-for git.
-
-To determine what diff viewer is used, the script requires either
-the 'diff.tool' or 'merge.tool' configuration option to be set.
-
-This script is compatible with most common forms used to specify a
-range of revisions to diff:
-
-  1. git diffall: shows diff between working tree and staged changes
-  2. git diffall --cached [<commit>]: shows diff between staged
-     changes and HEAD (or other named commit)
-  3. git diffall <commit>: shows diff between working tree and named
-     commit
-  4. git diffall <commit> <commit>: show diff between two named commits
-  5. git diffall <commit>..<commit>: same as above
-  6. git diffall <commit>...<commit>: show the changes on the branch
-     containing and up to the second, starting at a common ancestor
-     of both <commit>
-
-Note: all forms take an optional path limiter [-- <path>*]
-
-The '--extcmd=<command>' option allows the user to specify a custom
-command for viewing diffs.  When given, configured defaults are
-ignored and the script runs $command $LOCAL $REMOTE.  Additionally,
-$BASE is set in the environment.
-
-This script is based on an example provided by Thomas Rast on the
-Git list [1]:
-
-[1] http://thread.gmane.org/gmane.comp.version-control.git/124807
diff --git a/contrib/diffall/git-diffall b/contrib/diffall/git-diffall
deleted file mode 100755 (executable)
index 84f2b65..0000000
+++ /dev/null
@@ -1,257 +0,0 @@
-#!/bin/sh
-# Copyright 2010 - 2012, Tim Henigan <tim.henigan@gmail.com>
-#
-# Perform a directory diff between commits in the repository using
-# the external diff or merge tool specified in the user's config.
-
-USAGE='[--cached] [--copy-back] [-x|--extcmd=<command>] <commit>{0,2} [-- <path>*]
-
-    --cached     Compare to the index rather than the working tree.
-
-    --copy-back  Copy files back to the working tree when the diff
-                 tool exits (in case they were modified by the
-                 user).  This option is only valid if the diff
-                 compared with the working tree.
-
-    -x=<command>
-    --extcmd=<command>  Specify a custom command for viewing diffs.
-                 git-diffall ignores the configured defaults and
-                 runs $command $LOCAL $REMOTE when this option is
-                 specified. Additionally, $BASE is set in the
-                 environment.
-'
-
-SUBDIRECTORY_OK=1
-. "$(git --exec-path)/git-sh-setup"
-
-TOOL_MODE=diff
-. "$(git --exec-path)/git-mergetool--lib"
-
-merge_tool="$(get_merge_tool)"
-if test -z "$merge_tool"
-then
-       echo "Error: Either the 'diff.tool' or 'merge.tool' option must be set."
-       usage
-fi
-
-start_dir=$(pwd)
-
-# All the file paths returned by the diff command are relative to the root
-# of the working copy. So if the script is called from a subdirectory, it
-# must switch to the root of working copy before trying to use those paths.
-cdup=$(git rev-parse --show-cdup) &&
-cd "$cdup" || {
-       echo >&2 "Cannot chdir to $cdup, the toplevel of the working tree"
-       exit 1
-}
-
-# set up temp dir
-tmp=$(perl -e 'use File::Temp qw(tempdir);
-       $t=tempdir("/tmp/git-diffall.XXXXX") or exit(1);
-       print $t') || exit 1
-trap 'rm -rf "$tmp"' EXIT
-
-left=
-right=
-paths=
-dashdash_seen=
-compare_staged=
-merge_base=
-left_dir=
-right_dir=
-diff_tool=
-copy_back=
-
-while test $# != 0
-do
-       case "$1" in
-       -h|--h|--he|--hel|--help)
-               usage
-               ;;
-       --cached)
-               compare_staged=1
-               ;;
-       --copy-back)
-               copy_back=1
-               ;;
-       -x|--e|--ex|--ext|--extc|--extcm|--extcmd)
-               if test $# = 1
-               then
-                       echo You must specify the tool for use with --extcmd
-                       usage
-               else
-                       diff_tool=$2
-                       shift
-               fi
-               ;;
-       --)
-               dashdash_seen=1
-               ;;
-       -*)
-               echo Invalid option: "$1"
-               usage
-               ;;
-       *)
-               # could be commit, commit range or path limiter
-               case "$1" in
-               *...*)
-                       left=${1%...*}
-                       right=${1#*...}
-                       merge_base=1
-                       ;;
-               *..*)
-                       left=${1%..*}
-                       right=${1#*..}
-                       ;;
-               *)
-                       if test -n "$dashdash_seen"
-                       then
-                               paths="$paths$1 "
-                       elif test -z "$left"
-                       then
-                               left=$1
-                       elif test -z "$right"
-                       then
-                               right=$1
-                       else
-                               paths="$paths$1 "
-                       fi
-                       ;;
-               esac
-               ;;
-       esac
-       shift
-done
-
-# Determine the set of files which changed
-if test -n "$left" && test -n "$right"
-then
-       left_dir="cmt-$(git rev-parse --short $left)"
-       right_dir="cmt-$(git rev-parse --short $right)"
-
-       if test -n "$compare_staged"
-       then
-               usage
-       elif test -n "$merge_base"
-       then
-               git diff --name-only "$left"..."$right" -- $paths >"$tmp/filelist"
-       else
-               git diff --name-only "$left" "$right" -- $paths >"$tmp/filelist"
-       fi
-elif test -n "$left"
-then
-       left_dir="cmt-$(git rev-parse --short $left)"
-
-       if test -n "$compare_staged"
-       then
-               right_dir="staged"
-               git diff --name-only --cached "$left" -- $paths >"$tmp/filelist"
-       else
-               right_dir="working_tree"
-               git diff --name-only "$left" -- $paths >"$tmp/filelist"
-       fi
-else
-       left_dir="HEAD"
-
-       if test -n "$compare_staged"
-       then
-               right_dir="staged"
-               git diff --name-only --cached -- $paths >"$tmp/filelist"
-       else
-               right_dir="working_tree"
-               git diff --name-only -- $paths >"$tmp/filelist"
-       fi
-fi
-
-# Exit immediately if there are no diffs
-if test ! -s "$tmp/filelist"
-then
-       exit 0
-fi
-
-if test -n "$copy_back" && test "$right_dir" != "working_tree"
-then
-       echo "--copy-back is only valid when diff includes the working tree."
-       exit 1
-fi
-
-# Create the named tmp directories that will hold the files to be compared
-mkdir -p "$tmp/$left_dir" "$tmp/$right_dir"
-
-# Populate the tmp/right_dir directory with the files to be compared
-while read name
-do
-       if test -n "$right"
-       then
-               ls_list=$(git ls-tree $right "$name")
-               if test -n "$ls_list"
-               then
-                       mkdir -p "$tmp/$right_dir/$(dirname "$name")"
-                       git show "$right":"$name" >"$tmp/$right_dir/$name" || true
-               fi
-       elif test -n "$compare_staged"
-       then
-               ls_list=$(git ls-files -- "$name")
-               if test -n "$ls_list"
-               then
-                       mkdir -p "$tmp/$right_dir/$(dirname "$name")"
-                       git show :"$name" >"$tmp/$right_dir/$name"
-               fi
-       else
-               if test -e "$name"
-               then
-                       mkdir -p "$tmp/$right_dir/$(dirname "$name")"
-                       cp "$name" "$tmp/$right_dir/$name"
-               fi
-       fi
-done < "$tmp/filelist"
-
-# Populate the tmp/left_dir directory with the files to be compared
-while read name
-do
-       if test -n "$left"
-       then
-               ls_list=$(git ls-tree $left "$name")
-               if test -n "$ls_list"
-               then
-                       mkdir -p "$tmp/$left_dir/$(dirname "$name")"
-                       git show "$left":"$name" >"$tmp/$left_dir/$name" || true
-               fi
-       else
-               if test -n "$compare_staged"
-               then
-                       ls_list=$(git ls-tree HEAD "$name")
-                       if test -n "$ls_list"
-                       then
-                               mkdir -p "$tmp/$left_dir/$(dirname "$name")"
-                               git show HEAD:"$name" >"$tmp/$left_dir/$name"
-                       fi
-               else
-                       mkdir -p "$tmp/$left_dir/$(dirname "$name")"
-                       git show :"$name" >"$tmp/$left_dir/$name"
-               fi
-       fi
-done < "$tmp/filelist"
-
-LOCAL="$tmp/$left_dir"
-REMOTE="$tmp/$right_dir"
-
-if test -n "$diff_tool"
-then
-       export BASE
-       eval $diff_tool '"$LOCAL"' '"$REMOTE"'
-else
-       run_merge_tool "$merge_tool" false
-fi
-
-# Copy files back to the working dir, if requested
-if test -n "$copy_back" && test "$right_dir" = "working_tree"
-then
-       cd "$start_dir"
-       git_top_dir=$(git rev-parse --show-toplevel)
-       find "$tmp/$right_dir" -type f |
-       while read file
-       do
-               cp "$file" "$git_top_dir/${file#$tmp/$right_dir/}"
-       done
-fi
index 8bc8c7533a8678e2a43d3ddd49bc9aa8d670897d..ee1916641e46c1adfaac31e27c78c11b023d6ffa 100644 (file)
@@ -31,7 +31,8 @@ static int update_ref_env(const char *action,
                rla = "(reflog update)";
        if (snprintf(msg, sizeof(msg), "%s: %s", rla, action) >= sizeof(msg))
                warning("reflog message too long: %.*s...", 50, msg);
-       return update_ref(msg, refname, sha1, oldval, 0, QUIET_ON_ERR);
+       return update_ref(msg, refname, sha1, oldval, 0,
+                         UPDATE_REFS_QUIET_ON_ERR);
 }
 
 static int update_local_ref(const char *name,
index 3f8d993afaca53024aa75b4118da9ee80e6a6313..8dd74a9a406e9cfd685ea1af3947e4bea4c82f90 100755 (executable)
@@ -461,7 +461,12 @@ sub download_mw_mediafile {
 
        my $response = $mediawiki->{ua}->get($download_url);
        if ($response->code == HTTP_CODE_OK) {
-               return $response->decoded_content;
+               # It is tempting to return
+               # $response->decoded_content({charset => "none"}), but
+               # when doing so, utf8::downgrade($content) fails with
+               # "Wide character in subroutine entry".
+               $response->decode();
+               return $response->content();
        } else {
                print {*STDERR} "Error downloading mediafile from :\n";
                print {*STDERR} "URL: ${download_url}\n";
index 70a53f67fd06bd2ce6f2f544655b03b99c6b2ee9..c215213c4bfddb583fb3de0eb624e0cffdb8cc7c 100755 (executable)
@@ -20,6 +20,8 @@ usage () {
        echo "          install | -i :  Install a wiki on your computer."
        echo "          delete | -d : Delete the wiki and all its pages and "
        echo "                  content."
+       echo "          start  | -s : Start the previously configured lighttpd daemon"
+       echo "          stop        : Stop lighttpd daemon."
 }
 
 
@@ -33,6 +35,14 @@ case "$1" in
                wiki_delete
                exit 0
                ;;
+       "start" | "-s")
+               start_lighttpd
+               exit
+               ;;
+       "stop")
+               stop_lighttpd
+               exit
+               ;;
        "--help" | "-h")
                usage
                exit 0
index 5a0373935f1f4b66c4521158e4b3c41508c908ea..3ff3a095670ecdf578dc9f4d51841c102c5a10fd 100755 (executable)
@@ -58,6 +58,25 @@ test_expect_success 'git clone works on previously created wiki with media files
        test_cmp mw_dir_clone/Foo.txt mw_dir/Foo.txt
 '
 
+test_expect_success 'git push can upload media (File:) files containing valid UTF-8' '
+       wiki_reset &&
+       git clone mediawiki::'"$WIKI_URL"' mw_dir &&
+       (
+               cd mw_dir &&
+               "$PERL_PATH" -e "print STDOUT \"UTF-8 content: éèàéê€.\";" >Bar.txt &&
+               git add Bar.txt &&
+               git commit -m "add a text file with UTF-8 content" &&
+               git push
+       )
+'
+
+test_expect_success 'git clone works on previously created wiki with media files containing valid UTF-8' '
+       test_when_finished "rm -rf mw_dir mw_dir_clone" &&
+       git clone -c remote.origin.mediaimport=true \
+               mediawiki::'"$WIKI_URL"' mw_dir_clone &&
+       test_cmp mw_dir_clone/Bar.txt mw_dir/Bar.txt
+'
+
 test_expect_success 'git push & pull work with locally renamed media files' '
        wiki_reset &&
        git clone mediawiki::'"$WIKI_URL"' mw_dir &&
index 27e267f532974914d1b214920bcfb8e2d4e3de6c..016454749f8dfa8539c7af1ca7fe4338414ab661 100755 (executable)
@@ -9,7 +9,7 @@ test_check_precond
 
 test_expect_success 'creating page w/ >500 revisions' '
        wiki_reset &&
-       for i in `test_seq 501`
+       for i in $(test_seq 501)
        do
                echo "creating revision $i" &&
                wiki_editpage foo "revision $i<br/>" true
index 3372b2af346ac23a73a7723ac6d0c81fb8c5e705..6546294f159e940eb8f7adc3e695f16d9395eebc 100755 (executable)
@@ -90,7 +90,7 @@ test_diff_directories () {
 #
 # Check that <dir> contains exactly <N> files
 test_contains_N_files () {
-       if test `ls -- "$1" | wc -l` -ne "$2"; then
+       if test $(ls -- "$1" | wc -l) -ne "$2"; then
                echo "directory $1 should contain $2 files"
                echo "it contains these files:"
                ls "$1"
@@ -289,7 +289,6 @@ start_lighttpd () {
 # Kill daemon lighttpd and removes files and folders associated.
 stop_lighttpd () {
        test -f "$WEB_TMP/pid" && kill $(cat "$WEB_TMP/pid")
-       rm -rf "$WEB"
 }
 
 # Create the SQLite database of the MediaWiki. If the database file already
@@ -341,10 +340,10 @@ wiki_install () {
                        "http://download.wikimedia.org/mediawiki/$MW_VERSION_MAJOR/"\
                        "$MW_FILENAME. "\
                        "Please fix your connection and launch the script again."
-               echo "$MW_FILENAME downloaded in `pwd`. "\
+               echo "$MW_FILENAME downloaded in $(pwd). "\
                        "You can delete it later if you want."
        else
-               echo "Reusing existing $MW_FILENAME downloaded in `pwd`."
+               echo "Reusing existing $MW_FILENAME downloaded in $(pwd)."
        fi
        archive_abs_path=$(pwd)/$MW_FILENAME
        cd "$WIKI_DIR_INST/$WIKI_DIR_NAME/" ||
@@ -415,6 +414,7 @@ wiki_reset () {
 wiki_delete () {
        if test $LIGHTTPD = "true"; then
                stop_lighttpd
+               rm -fr "$WEB"
        else
                # Delete the wiki's directory.
                rm -rf "$WIKI_DIR_INST/$WIKI_DIR_NAME" ||
diff --git a/contrib/remote-helpers/Makefile b/contrib/remote-helpers/Makefile
deleted file mode 100644 (file)
index 239161d..0000000
+++ /dev/null
@@ -1,14 +0,0 @@
-TESTS := $(wildcard test*.sh)
-
-export T := $(addprefix $(CURDIR)/,$(TESTS))
-export MAKE := $(MAKE) -e
-export PATH := $(CURDIR):$(PATH)
-export TEST_LINT := test-lint-executable test-lint-shell-syntax
-
-test:
-       $(MAKE) -C ../../t $@
-
-$(TESTS):
-       $(MAKE) -C ../../t $(CURDIR)/$@
-
-.PHONY: $(TESTS)
diff --git a/contrib/remote-helpers/README b/contrib/remote-helpers/README
new file mode 100644 (file)
index 0000000..ac72332
--- /dev/null
@@ -0,0 +1,15 @@
+The remote-helper bridges to access data stored in Mercurial and
+Bazaar are maintained outside the git.git tree in the repositories
+of their primary author:
+
+    https://github.com/felipec/git-remote-hg (for Mercurial)
+    https://github.com/felipec/git-remote-bzr (for Bazaar)
+
+You can pick a directory on your $PATH and download them from these
+repositories, e.g.:
+
+  $ wget -O $HOME/bin/git-remote-hg \
+    https://raw.github.com/felipec/git-remote-hg/master/git-remote-hg
+  $ wget -O $HOME/bin/git-remote-bzr \
+    https://raw.github.com/felipec/git-remote-bzr/master/git-remote-bzr
+  $ chmod +x $HOME/bin/git-remote-hg $HOME/bin/git-remote-bzr
index 9abb58e6ab45077bf9b5e01658438817ea9b7126..712a1377e208f717b61df44f0b5ea0ba99dc72d1 100755 (executable)
 #!/usr/bin/env python
-#
-# Copyright (c) 2012 Felipe Contreras
-#
-
-#
-# Just copy to your ~/bin, or anywhere in your $PATH.
-# Then you can clone with:
-# % git clone bzr::/path/to/bzr/repo/or/url
-#
-# For example:
-# % git clone bzr::$HOME/myrepo
-# or
-# % git clone bzr::lp:myrepo
-#
-# If you want to specify which branches you want to track (per repo):
-# % git config remote.origin.bzr-branches 'trunk, devel, test'
-#
-# Where 'origin' is the name of the repository you want to specify the
-# branches.
-#
-
-import sys
-
-import bzrlib
-if hasattr(bzrlib, "initialize"):
-    bzrlib.initialize()
-
-import bzrlib.plugin
-bzrlib.plugin.load_plugins()
-
-import bzrlib.generate_ids
-import bzrlib.transport
-import bzrlib.errors
-import bzrlib.ui
-import bzrlib.urlutils
-import bzrlib.branch
 
 import sys
-import os
-import json
-import re
-import StringIO
-import atexit, shutil, hashlib, urlparse, subprocess
-
-NAME_RE = re.compile('^([^<>]+)')
-AUTHOR_RE = re.compile('^([^<>]+?)? ?[<>]([^<>]*)(?:$|>)')
-EMAIL_RE = re.compile(r'([^ \t<>]+@[^ \t<>]+)')
-RAW_AUTHOR_RE = re.compile('^(\w+) (.+)? <(.*)> (\d+) ([+-]\d+)')
-
-def die(msg, *args):
-    sys.stderr.write('ERROR: %s\n' % (msg % args))
-    sys.exit(1)
-
-def warn(msg, *args):
-    sys.stderr.write('WARNING: %s\n' % (msg % args))
-
-def gittz(tz):
-    return '%+03d%02d' % (tz / 3600, tz % 3600 / 60)
-
-def get_config(config):
-    cmd = ['git', 'config', '--get', config]
-    process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
-    output, _ = process.communicate()
-    return output
-
-class Marks:
-
-    def __init__(self, path):
-        self.path = path
-        self.tips = {}
-        self.marks = {}
-        self.rev_marks = {}
-        self.last_mark = 0
-        self.load()
-
-    def load(self):
-        if not os.path.exists(self.path):
-            return
-
-        tmp = json.load(open(self.path))
-        self.tips = tmp['tips']
-        self.marks = tmp['marks']
-        self.last_mark = tmp['last-mark']
-
-        for rev, mark in self.marks.iteritems():
-            self.rev_marks[mark] = rev
-
-    def dict(self):
-        return { 'tips': self.tips, 'marks': self.marks, 'last-mark' : self.last_mark }
-
-    def store(self):
-        json.dump(self.dict(), open(self.path, 'w'))
-
-    def __str__(self):
-        return str(self.dict())
-
-    def from_rev(self, rev):
-        return self.marks[rev]
-
-    def to_rev(self, mark):
-        return str(self.rev_marks[mark])
-
-    def next_mark(self):
-        self.last_mark += 1
-        return self.last_mark
-
-    def get_mark(self, rev):
-        self.last_mark += 1
-        self.marks[rev] = self.last_mark
-        return self.last_mark
-
-    def is_marked(self, rev):
-        return rev in self.marks
-
-    def new_mark(self, rev, mark):
-        self.marks[rev] = mark
-        self.rev_marks[mark] = rev
-        self.last_mark = mark
-
-    def get_tip(self, branch):
-        try:
-            return str(self.tips[branch])
-        except KeyError:
-            return None
-
-    def set_tip(self, branch, tip):
-        self.tips[branch] = tip
-
-class Parser:
-
-    def __init__(self, repo):
-        self.repo = repo
-        self.line = self.get_line()
-
-    def get_line(self):
-        return sys.stdin.readline().strip()
-
-    def __getitem__(self, i):
-        return self.line.split()[i]
-
-    def check(self, word):
-        return self.line.startswith(word)
-
-    def each_block(self, separator):
-        while self.line != separator:
-            yield self.line
-            self.line = self.get_line()
-
-    def __iter__(self):
-        return self.each_block('')
-
-    def next(self):
-        self.line = self.get_line()
-        if self.line == 'done':
-            self.line = None
-
-    def get_mark(self):
-        i = self.line.index(':') + 1
-        return int(self.line[i:])
-
-    def get_data(self):
-        if not self.check('data'):
-            return None
-        i = self.line.index(' ') + 1
-        size = int(self.line[i:])
-        return sys.stdin.read(size)
-
-    def get_author(self):
-        m = RAW_AUTHOR_RE.match(self.line)
-        if not m:
-            return None
-        _, name, email, date, tz = m.groups()
-        name = name.decode('utf-8')
-        committer = '%s <%s>' % (name, email)
-        tz = int(tz)
-        tz = ((tz / 100) * 3600) + ((tz % 100) * 60)
-        return (committer, int(date), tz)
-
-def rev_to_mark(rev):
-    return marks.from_rev(rev)
-
-def mark_to_rev(mark):
-    return marks.to_rev(mark)
-
-def fixup_user(user):
-    name = mail = None
-    user = user.replace('"', '')
-    m = AUTHOR_RE.match(user)
-    if m:
-        name = m.group(1)
-        mail = m.group(2).strip()
-    else:
-        m = EMAIL_RE.match(user)
-        if m:
-            mail = m.group(1)
-        else:
-            m = NAME_RE.match(user)
-            if m:
-                name = m.group(1).strip()
-
-    if not name:
-        name = 'unknown'
-    if not mail:
-        mail = 'Unknown'
-
-    return '%s <%s>' % (name, mail)
-
-def get_filechanges(cur, prev):
-    modified = {}
-    removed = {}
-
-    changes = cur.changes_from(prev)
-
-    def u(s):
-        return s.encode('utf-8')
-
-    for path, fid, kind in changes.added:
-        modified[u(path)] = fid
-    for path, fid, kind in changes.removed:
-        removed[u(path)] = None
-    for path, fid, kind, mod, _ in changes.modified:
-        modified[u(path)] = fid
-    for oldpath, newpath, fid, kind, mod, _ in changes.renamed:
-        removed[u(oldpath)] = None
-        if kind == 'directory':
-            lst = cur.list_files(from_dir=newpath, recursive=True)
-            for path, file_class, kind, fid, entry in lst:
-                if kind != 'directory':
-                    modified[u(newpath + '/' + path)] = fid
-        else:
-            modified[u(newpath)] = fid
-
-    return modified, removed
-
-def export_files(tree, files):
-    final = []
-    for path, fid in files.iteritems():
-        kind = tree.kind(fid)
-
-        h = tree.get_file_sha1(fid)
-
-        if kind == 'symlink':
-            d = tree.get_symlink_target(fid)
-            mode = '120000'
-        elif kind == 'file':
-
-            if tree.is_executable(fid):
-                mode = '100755'
-            else:
-                mode = '100644'
-
-            # is the blob already exported?
-            if h in filenodes:
-                mark = filenodes[h]
-                final.append((mode, mark, path))
-                continue
-
-            d = tree.get_file_text(fid)
-        elif kind == 'directory':
-            continue
-        else:
-            die("Unhandled kind '%s' for path '%s'" % (kind, path))
-
-        mark = marks.next_mark()
-        filenodes[h] = mark
-
-        print "blob"
-        print "mark :%u" % mark
-        print "data %d" % len(d)
-        print d
-
-        final.append((mode, mark, path))
-
-    return final
-
-def export_branch(repo, name):
-    ref = '%s/heads/%s' % (prefix, name)
-    tip = marks.get_tip(name)
-
-    branch = get_remote_branch(name)
-    repo = branch.repository
-
-    branch.lock_read()
-    revs = branch.iter_merge_sorted_revisions(None, tip, 'exclude', 'forward')
-    try:
-        tip_revno = branch.revision_id_to_revno(tip)
-        last_revno, _ = branch.last_revision_info()
-        total = last_revno - tip_revno
-    except bzrlib.errors.NoSuchRevision:
-        tip_revno = 0
-        total = 0
-
-    for revid, _, seq, _ in revs:
-
-        if marks.is_marked(revid):
-            continue
-
-        rev = repo.get_revision(revid)
-        revno = seq[0]
-
-        parents = rev.parent_ids
-        time = rev.timestamp
-        tz = rev.timezone
-        committer = rev.committer.encode('utf-8')
-        committer = "%s %u %s" % (fixup_user(committer), time, gittz(tz))
-        authors = rev.get_apparent_authors()
-        if authors:
-            author = authors[0].encode('utf-8')
-            author = "%s %u %s" % (fixup_user(author), time, gittz(tz))
-        else:
-            author = committer
-        msg = rev.message.encode('utf-8')
-
-        msg += '\n'
-
-        if len(parents) == 0:
-            parent = bzrlib.revision.NULL_REVISION
-        else:
-            parent = parents[0]
-
-        cur_tree = repo.revision_tree(revid)
-        prev = repo.revision_tree(parent)
-        modified, removed = get_filechanges(cur_tree, prev)
-
-        modified_final = export_files(cur_tree, modified)
-
-        if len(parents) == 0:
-            print 'reset %s' % ref
-
-        print "commit %s" % ref
-        print "mark :%d" % (marks.get_mark(revid))
-        print "author %s" % (author)
-        print "committer %s" % (committer)
-        print "data %d" % (len(msg))
-        print msg
-
-        for i, p in enumerate(parents):
-            try:
-                m = rev_to_mark(p)
-            except KeyError:
-                # ghost?
-                continue
-            if i == 0:
-                print "from :%s" % m
-            else:
-                print "merge :%s" % m
-
-        for f in removed:
-            print "D %s" % (f,)
-        for f in modified_final:
-            print "M %s :%u %s" % f
-        print
-
-        if len(seq) > 1:
-            # let's skip branch revisions from the progress report
-            continue
-
-        progress = (revno - tip_revno)
-        if (progress % 100 == 0):
-            if total:
-                print "progress revision %d '%s' (%d/%d)" % (revno, name, progress, total)
-            else:
-                print "progress revision %d '%s' (%d)" % (revno, name, progress)
-
-    branch.unlock()
-
-    revid = branch.last_revision()
-
-    # make sure the ref is updated
-    print "reset %s" % ref
-    print "from :%u" % rev_to_mark(revid)
-    print
-
-    marks.set_tip(name, revid)
-
-def export_tag(repo, name):
-    ref = '%s/tags/%s' % (prefix, name)
-    print "reset %s" % ref
-    print "from :%u" % rev_to_mark(tags[name])
-    print
-
-def do_import(parser):
-    repo = parser.repo
-    path = os.path.join(dirname, 'marks-git')
-
-    print "feature done"
-    if os.path.exists(path):
-        print "feature import-marks=%s" % path
-    print "feature export-marks=%s" % path
-    print "feature force"
-    sys.stdout.flush()
-
-    while parser.check('import'):
-        ref = parser[1]
-        if ref.startswith('refs/heads/'):
-            name = ref[len('refs/heads/'):]
-            export_branch(repo, name)
-        if ref.startswith('refs/tags/'):
-            name = ref[len('refs/tags/'):]
-            export_tag(repo, name)
-        parser.next()
-
-    print 'done'
-
-    sys.stdout.flush()
-
-def parse_blob(parser):
-    parser.next()
-    mark = parser.get_mark()
-    parser.next()
-    data = parser.get_data()
-    blob_marks[mark] = data
-    parser.next()
-
-class CustomTree():
-
-    def __init__(self, branch, revid, parents, files):
-        self.updates = {}
-        self.branch = branch
-
-        def copy_tree(revid):
-            files = files_cache[revid] = {}
-            branch.lock_read()
-            tree = branch.repository.revision_tree(revid)
-            try:
-                for path, entry in tree.iter_entries_by_dir():
-                    files[path] = [entry.file_id, None]
-            finally:
-                branch.unlock()
-            return files
-
-        if len(parents) == 0:
-            self.base_id = bzrlib.revision.NULL_REVISION
-            self.base_files = {}
-        else:
-            self.base_id = parents[0]
-            self.base_files = files_cache.get(self.base_id, None)
-            if not self.base_files:
-                self.base_files = copy_tree(self.base_id)
-
-        self.files = files_cache[revid] = self.base_files.copy()
-        self.rev_files = {}
-
-        for path, data in self.files.iteritems():
-            fid, mark = data
-            self.rev_files[fid] = [path, mark]
-
-        for path, f in files.iteritems():
-            fid, mark = self.files.get(path, [None, None])
-            if not fid:
-                fid = bzrlib.generate_ids.gen_file_id(path)
-            f['path'] = path
-            self.rev_files[fid] = [path, mark]
-            self.updates[fid] = f
-
-    def last_revision(self):
-        return self.base_id
-
-    def iter_changes(self):
-        changes = []
-
-        def get_parent(dirname, basename):
-            parent_fid, mark = self.base_files.get(dirname, [None, None])
-            if parent_fid:
-                return parent_fid
-            parent_fid, mark = self.files.get(dirname, [None, None])
-            if parent_fid:
-                return parent_fid
-            if basename == '':
-                return None
-            fid = bzrlib.generate_ids.gen_file_id(path)
-            add_entry(fid, dirname, 'directory')
-            return fid
-
-        def add_entry(fid, path, kind, mode=None):
-            dirname, basename = os.path.split(path)
-            parent_fid = get_parent(dirname, basename)
-
-            executable = False
-            if mode == '100755':
-                executable = True
-            elif mode == '120000':
-                kind = 'symlink'
-
-            change = (fid,
-                    (None, path),
-                    True,
-                    (False, True),
-                    (None, parent_fid),
-                    (None, basename),
-                    (None, kind),
-                    (None, executable))
-            self.files[path] = [change[0], None]
-            changes.append(change)
-
-        def update_entry(fid, path, kind, mode=None):
-            dirname, basename = os.path.split(path)
-            parent_fid = get_parent(dirname, basename)
-
-            executable = False
-            if mode == '100755':
-                executable = True
-            elif mode == '120000':
-                kind = 'symlink'
-
-            change = (fid,
-                    (path, path),
-                    True,
-                    (True, True),
-                    (None, parent_fid),
-                    (None, basename),
-                    (None, kind),
-                    (None, executable))
-            self.files[path] = [change[0], None]
-            changes.append(change)
-
-        def remove_entry(fid, path, kind):
-            dirname, basename = os.path.split(path)
-            parent_fid = get_parent(dirname, basename)
-            change = (fid,
-                    (path, None),
-                    True,
-                    (True, False),
-                    (parent_fid, None),
-                    (None, None),
-                    (None, None),
-                    (None, None))
-            del self.files[path]
-            changes.append(change)
-
-        for fid, f in self.updates.iteritems():
-            path = f['path']
-
-            if 'deleted' in f:
-                remove_entry(fid, path, 'file')
-                continue
-
-            if path in self.base_files:
-                update_entry(fid, path, 'file', f['mode'])
-            else:
-                add_entry(fid, path, 'file', f['mode'])
-
-            self.files[path][1] = f['mark']
-            self.rev_files[fid][1] = f['mark']
-
-        return changes
-
-    def get_content(self, file_id):
-        path, mark = self.rev_files[file_id]
-        if mark:
-            return blob_marks[mark]
-
-        # last resort
-        tree = self.branch.repository.revision_tree(self.base_id)
-        return tree.get_file_text(file_id)
-
-    def get_file_with_stat(self, file_id, path=None):
-        content = self.get_content(file_id)
-        return (StringIO.StringIO(content), None)
-
-    def get_symlink_target(self, file_id):
-        return self.get_content(file_id)
-
-    def id2path(self, file_id):
-        path, mark = self.rev_files[file_id]
-        return path
-
-def c_style_unescape(string):
-    if string[0] == string[-1] == '"':
-        return string.decode('string-escape')[1:-1]
-    return string
-
-def parse_commit(parser):
-    parents = []
-
-    ref = parser[1]
-    parser.next()
-
-    if ref.startswith('refs/heads/'):
-        name = ref[len('refs/heads/'):]
-        branch = get_remote_branch(name)
-    else:
-        die('unknown ref')
-
-    commit_mark = parser.get_mark()
-    parser.next()
-    author = parser.get_author()
-    parser.next()
-    committer = parser.get_author()
-    parser.next()
-    data = parser.get_data()
-    parser.next()
-    if parser.check('from'):
-        parents.append(parser.get_mark())
-        parser.next()
-    while parser.check('merge'):
-        parents.append(parser.get_mark())
-        parser.next()
-
-    # fast-export adds an extra newline
-    if data[-1] == '\n':
-        data = data[:-1]
-
-    files = {}
-
-    for line in parser:
-        if parser.check('M'):
-            t, m, mark_ref, path = line.split(' ', 3)
-            mark = int(mark_ref[1:])
-            f = { 'mode' : m, 'mark' : mark }
-        elif parser.check('D'):
-            t, path = line.split(' ', 1)
-            f = { 'deleted' : True }
-        else:
-            die('Unknown file command: %s' % line)
-        path = c_style_unescape(path).decode('utf-8')
-        files[path] = f
-
-    committer, date, tz = committer
-    author, _, _ = author
-    parents = [mark_to_rev(p) for p in parents]
-    revid = bzrlib.generate_ids.gen_revision_id(committer, date)
-    props = {}
-    props['branch-nick'] = branch.nick
-    props['authors'] = author
-
-    mtree = CustomTree(branch, revid, parents, files)
-    changes = mtree.iter_changes()
-
-    branch.lock_write()
-    try:
-        builder = branch.get_commit_builder(parents, None, date, tz, committer, props, revid)
-        try:
-            list(builder.record_iter_changes(mtree, mtree.last_revision(), changes))
-            builder.finish_inventory()
-            builder.commit(data.decode('utf-8', 'replace'))
-        except Exception, e:
-            builder.abort()
-            raise
-    finally:
-        branch.unlock()
-
-    parsed_refs[ref] = revid
-    marks.new_mark(revid, commit_mark)
-
-def parse_reset(parser):
-    ref = parser[1]
-    parser.next()
-
-    # ugh
-    if parser.check('commit'):
-        parse_commit(parser)
-        return
-    if not parser.check('from'):
-        return
-    from_mark = parser.get_mark()
-    parser.next()
-
-    parsed_refs[ref] = mark_to_rev(from_mark)
-
-def do_export(parser):
-    parser.next()
-
-    for line in parser.each_block('done'):
-        if parser.check('blob'):
-            parse_blob(parser)
-        elif parser.check('commit'):
-            parse_commit(parser)
-        elif parser.check('reset'):
-            parse_reset(parser)
-        elif parser.check('tag'):
-            pass
-        elif parser.check('feature'):
-            pass
-        else:
-            die('unhandled export command: %s' % line)
-
-    for ref, revid in parsed_refs.iteritems():
-        if ref.startswith('refs/heads/'):
-            name = ref[len('refs/heads/'):]
-            branch = get_remote_branch(name)
-            branch.generate_revision_history(revid, marks.get_tip(name))
-
-            if name in peers:
-                peer = bzrlib.branch.Branch.open(peers[name],
-                                                 possible_transports=transports)
-                try:
-                    peer.bzrdir.push_branch(branch, revision_id=revid,
-                                            overwrite=force)
-                except bzrlib.errors.DivergedBranches:
-                    print "error %s non-fast forward" % ref
-                    continue
-
-            try:
-                wt = branch.bzrdir.open_workingtree()
-                wt.update()
-            except bzrlib.errors.NoWorkingTree:
-                pass
-        elif ref.startswith('refs/tags/'):
-            # TODO: implement tag push
-            print "error %s pushing tags not supported" % ref
-            continue
-        else:
-            # transport-helper/fast-export bugs
-            continue
-
-        print "ok %s" % ref
-
-    print
-
-def do_capabilities(parser):
-    print "import"
-    print "export"
-    print "refspec refs/heads/*:%s/heads/*" % prefix
-    print "refspec refs/tags/*:%s/tags/*" % prefix
-
-    path = os.path.join(dirname, 'marks-git')
-
-    if os.path.exists(path):
-        print "*import-marks %s" % path
-    print "*export-marks %s" % path
-
-    print "option"
-    print
-
-class InvalidOptionValue(Exception):
-    pass
-
-def get_bool_option(val):
-    if val == 'true':
-        return True
-    elif val == 'false':
-        return False
-    else:
-        raise InvalidOptionValue()
-
-def do_option(parser):
-    global force
-    opt, val = parser[1:3]
-    try:
-        if opt == 'force':
-            force = get_bool_option(val)
-            print 'ok'
-        else:
-            print 'unsupported'
-    except InvalidOptionValue:
-        print "error '%s' is not a valid value for option '%s'" % (val, opt)
-
-def ref_is_valid(name):
-    return not True in [c in name for c in '~^: \\']
-
-def do_list(parser):
-    master_branch = None
-
-    for name in branches:
-        if not master_branch:
-            master_branch = name
-        print "? refs/heads/%s" % name
-
-    branch = get_remote_branch(master_branch)
-    branch.lock_read()
-    for tag, revid in branch.tags.get_tag_dict().items():
-        try:
-            branch.revision_id_to_dotted_revno(revid)
-        except bzrlib.errors.NoSuchRevision:
-            continue
-        if not ref_is_valid(tag):
-            continue
-        print "? refs/tags/%s" % tag
-        tags[tag] = revid
-    branch.unlock()
-
-    print "@refs/heads/%s HEAD" % master_branch
-    print
-
-def clone(path, remote_branch):
-    try:
-        bdir = bzrlib.bzrdir.BzrDir.create(path, possible_transports=transports)
-    except bzrlib.errors.AlreadyControlDirError:
-        bdir = bzrlib.bzrdir.BzrDir.open(path, possible_transports=transports)
-    repo = bdir.find_repository()
-    repo.fetch(remote_branch.repository)
-    return remote_branch.sprout(bdir, repository=repo)
-
-def get_remote_branch(name):
-    remote_branch = bzrlib.branch.Branch.open(branches[name],
-                                              possible_transports=transports)
-    if isinstance(remote_branch.bzrdir.root_transport, bzrlib.transport.local.LocalTransport):
-        return remote_branch
-
-    branch_path = os.path.join(dirname, 'clone', name)
-
-    try:
-        branch = bzrlib.branch.Branch.open(branch_path,
-                                           possible_transports=transports)
-    except bzrlib.errors.NotBranchError:
-        # clone
-        branch = clone(branch_path, remote_branch)
-    else:
-        # pull
-        try:
-            branch.pull(remote_branch, overwrite=True)
-        except bzrlib.errors.DivergedBranches:
-            # use remote branch for now
-            return remote_branch
-
-    return branch
-
-def find_branches(repo):
-    transport = repo.bzrdir.root_transport
-
-    for fn in transport.iter_files_recursive():
-        if not fn.endswith('.bzr/branch-format'):
-            continue
-
-        name = subdir = fn[:-len('/.bzr/branch-format')]
-        name = name if name != '' else 'master'
-        name = name.replace('/', '+')
-
-        try:
-            cur = transport.clone(subdir)
-            branch = bzrlib.branch.Branch.open_from_transport(cur)
-        except bzrlib.errors.NotBranchError:
-            continue
-        else:
-            yield name, branch.base
-
-def get_repo(url, alias):
-    normal_url = bzrlib.urlutils.normalize_url(url)
-    origin = bzrlib.bzrdir.BzrDir.open(url, possible_transports=transports)
-    is_local = isinstance(origin.transport, bzrlib.transport.local.LocalTransport)
-
-    shared_path = os.path.join(gitdir, 'bzr')
-    try:
-        shared_dir = bzrlib.bzrdir.BzrDir.open(shared_path,
-                                               possible_transports=transports)
-    except bzrlib.errors.NotBranchError:
-        shared_dir = bzrlib.bzrdir.BzrDir.create(shared_path,
-                                                 possible_transports=transports)
-    try:
-        shared_repo = shared_dir.open_repository()
-    except bzrlib.errors.NoRepositoryPresent:
-        shared_repo = shared_dir.create_repository(shared=True)
-
-    if not is_local:
-        clone_path = os.path.join(dirname, 'clone')
-        if not os.path.exists(clone_path):
-            os.mkdir(clone_path)
-        else:
-            # check and remove old organization
-            try:
-                bdir = bzrlib.bzrdir.BzrDir.open(clone_path,
-                                                 possible_transports=transports)
-                bdir.destroy_repository()
-            except bzrlib.errors.NotBranchError:
-                pass
-            except bzrlib.errors.NoRepositoryPresent:
-                pass
-
-    wanted = get_config('remote.%s.bzr-branches' % alias).rstrip().split(', ')
-    # stupid python
-    wanted = [e for e in wanted if e]
-    if not wanted:
-        wanted = get_config('remote-bzr.branches').rstrip().split(', ')
-        # stupid python
-        wanted = [e for e in wanted if e]
-
-    if not wanted:
-        try:
-            repo = origin.open_repository()
-            if not repo.bzrdir.root_transport.listable():
-                # this repository is not usable for us
-                raise bzrlib.errors.NoRepositoryPresent(repo.bzrdir)
-        except bzrlib.errors.NoRepositoryPresent:
-            wanted = ['master']
-
-    if wanted:
-        def list_wanted(url, wanted):
-            for name in wanted:
-                subdir = name if name != 'master' else ''
-                yield name, bzrlib.urlutils.join(url, subdir)
-
-        branch_list = list_wanted(url, wanted)
-    else:
-        branch_list = find_branches(repo)
-
-    for name, url in branch_list:
-        if not is_local:
-            peers[name] = url
-        branches[name] = url
-
-    return origin
-
-def fix_path(alias, orig_url):
-    url = urlparse.urlparse(orig_url, 'file')
-    if url.scheme != 'file' or os.path.isabs(url.path):
-        return
-    abs_url = urlparse.urljoin("%s/" % os.getcwd(), orig_url)
-    cmd = ['git', 'config', 'remote.%s.url' % alias, "bzr::%s" % abs_url]
-    subprocess.call(cmd)
-
-def main(args):
-    global marks, prefix, gitdir, dirname
-    global tags, filenodes
-    global blob_marks
-    global parsed_refs
-    global files_cache
-    global is_tmp
-    global branches, peers
-    global transports
-    global force
-
-    marks = None
-    is_tmp = False
-    gitdir = os.environ.get('GIT_DIR', None)
-
-    if len(args) < 3:
-        die('Not enough arguments.')
-
-    if not gitdir:
-        die('GIT_DIR not set')
-
-    alias = args[1]
-    url = args[2]
-
-    tags = {}
-    filenodes = {}
-    blob_marks = {}
-    parsed_refs = {}
-    files_cache = {}
-    branches = {}
-    peers = {}
-    transports = []
-    force = False
-
-    if alias[5:] == url:
-        is_tmp = True
-        alias = hashlib.sha1(alias).hexdigest()
-
-    prefix = 'refs/bzr/%s' % alias
-    dirname = os.path.join(gitdir, 'bzr', alias)
-
-    if not is_tmp:
-        fix_path(alias, url)
-
-    if not os.path.exists(dirname):
-        os.makedirs(dirname)
-
-    if hasattr(bzrlib.ui.ui_factory, 'be_quiet'):
-        bzrlib.ui.ui_factory.be_quiet(True)
-
-    repo = get_repo(url, alias)
-
-    marks_path = os.path.join(dirname, 'marks-int')
-    marks = Marks(marks_path)
-
-    parser = Parser(repo)
-    for line in parser:
-        if parser.check('capabilities'):
-            do_capabilities(parser)
-        elif parser.check('list'):
-            do_list(parser)
-        elif parser.check('import'):
-            do_import(parser)
-        elif parser.check('export'):
-            do_export(parser)
-        elif parser.check('option'):
-            do_option(parser)
-        else:
-            die('unhandled command: %s' % line)
-        sys.stdout.flush()
 
-def bye():
-    if not marks:
-        return
-    if not is_tmp:
-        marks.store()
-    else:
-        shutil.rmtree(dirname)
+sys.stderr.write('WARNING: git-remote-bzr is now maintained independently.\n')
+sys.stderr.write('WARNING: For more information visit https://github.com/felipec/git-remote-bzr\n')
 
-atexit.register(bye)
-sys.exit(main(sys.argv))
+sys.stderr.write('''WARNING:
+WARNING: You can pick a directory on your $PATH and download it, e.g.:
+WARNING:   $ wget -O $HOME/bin/git-remote-bzr \\
+WARNING:     https://raw.github.com/felipec/git-remote-bzr/master/git-remote-bzr
+WARNING:   $ chmod +x $HOME/bin/git-remote-bzr
+''')
index 34cda027597f30ddacf340466778404f3705361d..4255ad6312ec027b65ffd4dfc456bc0ed5dd533f 100755 (executable)
 #!/usr/bin/env python
-#
-# Copyright (c) 2012 Felipe Contreras
-#
 
-# Inspired by Rocco Rutte's hg-fast-export
-
-# Just copy to your ~/bin, or anywhere in your $PATH.
-# Then you can clone with:
-# git clone hg::/path/to/mercurial/repo/
-#
-# For remote repositories a local clone is stored in
-# "$GIT_DIR/hg/origin/clone/.hg/".
-
-from mercurial import hg, ui, bookmarks, context, encoding, node, error, extensions, discovery, util
-
-import re
 import sys
-import os
-import json
-import shutil
-import subprocess
-import urllib
-import atexit
-import urlparse, hashlib
-import time as ptime
-
-#
-# If you want to see Mercurial revisions as Git commit notes:
-# git config core.notesRef refs/notes/hg
-#
-# If you are not in hg-git-compat mode and want to disable the tracking of
-# named branches:
-# git config --global remote-hg.track-branches false
-#
-# If you want the equivalent of hg's clone/pull--insecure option:
-# git config --global remote-hg.insecure true
-#
-# If you want to switch to hg-git compatibility mode:
-# git config --global remote-hg.hg-git-compat true
-#
-# git:
-# Sensible defaults for git.
-# hg bookmarks are exported as git branches, hg branches are prefixed
-# with 'branches/', HEAD is a special case.
-#
-# hg:
-# Emulate hg-git.
-# Only hg bookmarks are exported as git branches.
-# Commits are modified to preserve hg information and allow bidirectionality.
-#
-
-NAME_RE = re.compile('^([^<>]+)')
-AUTHOR_RE = re.compile('^([^<>]+?)? ?[<>]([^<>]*)(?:$|>)')
-EMAIL_RE = re.compile(r'([^ \t<>]+@[^ \t<>]+)')
-AUTHOR_HG_RE = re.compile('^(.*?) ?<(.*?)(?:>(.+)?)?$')
-RAW_AUTHOR_RE = re.compile('^(\w+) (?:(.+)? )?<(.*)> (\d+) ([+-]\d+)')
-
-VERSION = 2
-
-def die(msg, *args):
-    sys.stderr.write('ERROR: %s\n' % (msg % args))
-    sys.exit(1)
-
-def warn(msg, *args):
-    sys.stderr.write('WARNING: %s\n' % (msg % args))
-
-def gitmode(flags):
-    return 'l' in flags and '120000' or 'x' in flags and '100755' or '100644'
-
-def gittz(tz):
-    return '%+03d%02d' % (-tz / 3600, -tz % 3600 / 60)
-
-def hgmode(mode):
-    m = { '100755': 'x', '120000': 'l' }
-    return m.get(mode, '')
-
-def hghex(n):
-    return node.hex(n)
-
-def hgbin(n):
-    return node.bin(n)
-
-def hgref(ref):
-    return ref.replace('___', ' ')
-
-def gitref(ref):
-    return ref.replace(' ', '___')
-
-def check_version(*check):
-    if not hg_version:
-        return True
-    return hg_version >= check
-
-def get_config(config):
-    cmd = ['git', 'config', '--get', config]
-    process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
-    output, _ = process.communicate()
-    return output
-
-def get_config_bool(config, default=False):
-    value = get_config(config).rstrip('\n')
-    if value == "true":
-        return True
-    elif value == "false":
-        return False
-    else:
-        return default
-
-class Marks:
-
-    def __init__(self, path, repo):
-        self.path = path
-        self.repo = repo
-        self.clear()
-        self.load()
-
-        if self.version < VERSION:
-            if self.version == 1:
-                self.upgrade_one()
-
-            # upgraded?
-            if self.version < VERSION:
-                self.clear()
-                self.version = VERSION
-
-    def clear(self):
-        self.tips = {}
-        self.marks = {}
-        self.rev_marks = {}
-        self.last_mark = 0
-        self.version = 0
-        self.last_note = 0
-
-    def load(self):
-        if not os.path.exists(self.path):
-            return
-
-        tmp = json.load(open(self.path))
-
-        self.tips = tmp['tips']
-        self.marks = tmp['marks']
-        self.last_mark = tmp['last-mark']
-        self.version = tmp.get('version', 1)
-        self.last_note = tmp.get('last-note', 0)
-
-        for rev, mark in self.marks.iteritems():
-            self.rev_marks[mark] = rev
-
-    def upgrade_one(self):
-        def get_id(rev):
-            return hghex(self.repo.changelog.node(int(rev)))
-        self.tips = dict((name, get_id(rev)) for name, rev in self.tips.iteritems())
-        self.marks = dict((get_id(rev), mark) for rev, mark in self.marks.iteritems())
-        self.rev_marks = dict((mark, get_id(rev)) for mark, rev in self.rev_marks.iteritems())
-        self.version = 2
-
-    def dict(self):
-        return { 'tips': self.tips, 'marks': self.marks, 'last-mark' : self.last_mark, 'version' : self.version, 'last-note' : self.last_note }
-
-    def store(self):
-        json.dump(self.dict(), open(self.path, 'w'))
-
-    def __str__(self):
-        return str(self.dict())
-
-    def from_rev(self, rev):
-        return self.marks[rev]
-
-    def to_rev(self, mark):
-        return str(self.rev_marks[mark])
-
-    def next_mark(self):
-        self.last_mark += 1
-        return self.last_mark
-
-    def get_mark(self, rev):
-        self.last_mark += 1
-        self.marks[rev] = self.last_mark
-        return self.last_mark
-
-    def new_mark(self, rev, mark):
-        self.marks[rev] = mark
-        self.rev_marks[mark] = rev
-        self.last_mark = mark
-
-    def is_marked(self, rev):
-        return rev in self.marks
-
-    def get_tip(self, branch):
-        return str(self.tips[branch])
-
-    def set_tip(self, branch, tip):
-        self.tips[branch] = tip
-
-class Parser:
-
-    def __init__(self, repo):
-        self.repo = repo
-        self.line = self.get_line()
-
-    def get_line(self):
-        return sys.stdin.readline().strip()
-
-    def __getitem__(self, i):
-        return self.line.split()[i]
-
-    def check(self, word):
-        return self.line.startswith(word)
-
-    def each_block(self, separator):
-        while self.line != separator:
-            yield self.line
-            self.line = self.get_line()
-
-    def __iter__(self):
-        return self.each_block('')
-
-    def next(self):
-        self.line = self.get_line()
-        if self.line == 'done':
-            self.line = None
-
-    def get_mark(self):
-        i = self.line.index(':') + 1
-        return int(self.line[i:])
-
-    def get_data(self):
-        if not self.check('data'):
-            return None
-        i = self.line.index(' ') + 1
-        size = int(self.line[i:])
-        return sys.stdin.read(size)
-
-    def get_author(self):
-        ex = None
-        m = RAW_AUTHOR_RE.match(self.line)
-        if not m:
-            return None
-        _, name, email, date, tz = m.groups()
-        if name and 'ext:' in name:
-            m = re.match('^(.+?) ext:\((.+)\)$', name)
-            if m:
-                name = m.group(1)
-                ex = urllib.unquote(m.group(2))
-
-        if email != bad_mail:
-            if name:
-                user = '%s <%s>' % (name, email)
-            else:
-                user = '<%s>' % (email)
-        else:
-            user = name
-
-        if ex:
-            user += ex
-
-        tz = int(tz)
-        tz = ((tz / 100) * 3600) + ((tz % 100) * 60)
-        return (user, int(date), -tz)
-
-def fix_file_path(path):
-    path = os.path.normpath(path)
-    if not os.path.isabs(path):
-        return path
-    return os.path.relpath(path, '/')
-
-def export_files(files):
-    final = []
-    for f in files:
-        fid = node.hex(f.filenode())
-
-        if fid in filenodes:
-            mark = filenodes[fid]
-        else:
-            mark = marks.next_mark()
-            filenodes[fid] = mark
-            d = f.data()
-
-            print "blob"
-            print "mark :%u" % mark
-            print "data %d" % len(d)
-            print d
-
-        path = fix_file_path(f.path())
-        final.append((gitmode(f.flags()), mark, path))
-
-    return final
-
-def get_filechanges(repo, ctx, parent):
-    modified = set()
-    added = set()
-    removed = set()
-
-    # load earliest manifest first for caching reasons
-    prev = parent.manifest().copy()
-    cur = ctx.manifest()
-
-    for fn in cur:
-        if fn in prev:
-            if (cur.flags(fn) != prev.flags(fn) or cur[fn] != prev[fn]):
-                modified.add(fn)
-            del prev[fn]
-        else:
-            added.add(fn)
-    removed |= set(prev.keys())
-
-    return added | modified, removed
-
-def fixup_user_git(user):
-    name = mail = None
-    user = user.replace('"', '')
-    m = AUTHOR_RE.match(user)
-    if m:
-        name = m.group(1)
-        mail = m.group(2).strip()
-    else:
-        m = EMAIL_RE.match(user)
-        if m:
-            mail = m.group(1)
-        else:
-            m = NAME_RE.match(user)
-            if m:
-                name = m.group(1).strip()
-    return (name, mail)
-
-def fixup_user_hg(user):
-    def sanitize(name):
-        # stole this from hg-git
-        return re.sub('[<>\n]', '?', name.lstrip('< ').rstrip('> '))
-
-    m = AUTHOR_HG_RE.match(user)
-    if m:
-        name = sanitize(m.group(1))
-        mail = sanitize(m.group(2))
-        ex = m.group(3)
-        if ex:
-            name += ' ext:(' + urllib.quote(ex) + ')'
-    else:
-        name = sanitize(user)
-        if '@' in user:
-            mail = name
-        else:
-            mail = None
-
-    return (name, mail)
-
-def fixup_user(user):
-    if mode == 'git':
-        name, mail = fixup_user_git(user)
-    else:
-        name, mail = fixup_user_hg(user)
-
-    if not name:
-        name = bad_name
-    if not mail:
-        mail = bad_mail
-
-    return '%s <%s>' % (name, mail)
-
-def updatebookmarks(repo, peer):
-    remotemarks = peer.listkeys('bookmarks')
-    localmarks = repo._bookmarks
-
-    if not remotemarks:
-        return
-
-    for k, v in remotemarks.iteritems():
-        localmarks[k] = hgbin(v)
-
-    if hasattr(localmarks, 'write'):
-        localmarks.write()
-    else:
-        bookmarks.write(repo)
-
-def get_repo(url, alias):
-    global peer
-
-    myui = ui.ui()
-    myui.setconfig('ui', 'interactive', 'off')
-    myui.fout = sys.stderr
-
-    if get_config_bool('remote-hg.insecure'):
-        myui.setconfig('web', 'cacerts', '')
-
-    extensions.loadall(myui)
-
-    if hg.islocal(url) and not os.environ.get('GIT_REMOTE_HG_TEST_REMOTE'):
-        repo = hg.repository(myui, url)
-        if not os.path.exists(dirname):
-            os.makedirs(dirname)
-    else:
-        shared_path = os.path.join(gitdir, 'hg')
-
-        # check and upgrade old organization
-        hg_path = os.path.join(shared_path, '.hg')
-        if os.path.exists(shared_path) and not os.path.exists(hg_path):
-            repos = os.listdir(shared_path)
-            for x in repos:
-                local_hg = os.path.join(shared_path, x, 'clone', '.hg')
-                if not os.path.exists(local_hg):
-                    continue
-                if not os.path.exists(hg_path):
-                    shutil.move(local_hg, hg_path)
-                shutil.rmtree(os.path.join(shared_path, x, 'clone'))
-
-        # setup shared repo (if not there)
-        try:
-            hg.peer(myui, {}, shared_path, create=True)
-        except error.RepoError:
-            pass
-
-        if not os.path.exists(dirname):
-            os.makedirs(dirname)
-
-        local_path = os.path.join(dirname, 'clone')
-        if not os.path.exists(local_path):
-            hg.share(myui, shared_path, local_path, update=False)
-        else:
-            # make sure the shared path is always up-to-date
-            util.writefile(os.path.join(local_path, '.hg', 'sharedpath'), hg_path)
-
-        repo = hg.repository(myui, local_path)
-        try:
-            peer = hg.peer(myui, {}, url)
-        except:
-            die('Repository error')
-        repo.pull(peer, heads=None, force=True)
-
-        updatebookmarks(repo, peer)
-
-    return repo
-
-def rev_to_mark(rev):
-    return marks.from_rev(rev.hex())
-
-def mark_to_rev(mark):
-    return marks.to_rev(mark)
-
-def export_ref(repo, name, kind, head):
-    ename = '%s/%s' % (kind, name)
-    try:
-        tip = marks.get_tip(ename)
-        tip = repo[tip].rev()
-    except:
-        tip = 0
-
-    revs = xrange(tip, head.rev() + 1)
-    total = len(revs)
-
-    for rev in revs:
-
-        c = repo[rev]
-        node = c.node()
-
-        if marks.is_marked(c.hex()):
-            continue
-
-        (manifest, user, (time, tz), files, desc, extra) = repo.changelog.read(node)
-        rev_branch = extra['branch']
-
-        author = "%s %d %s" % (fixup_user(user), time, gittz(tz))
-        if 'committer' in extra:
-            user, time, tz = extra['committer'].rsplit(' ', 2)
-            committer = "%s %s %s" % (user, time, gittz(int(tz)))
-        else:
-            committer = author
-
-        parents = [repo[p] for p in repo.changelog.parentrevs(rev) if p >= 0]
-
-        if len(parents) == 0:
-            modified = c.manifest().keys()
-            removed = []
-        else:
-            modified, removed = get_filechanges(repo, c, parents[0])
-
-        desc += '\n'
-
-        if mode == 'hg':
-            extra_msg = ''
-
-            if rev_branch != 'default':
-                extra_msg += 'branch : %s\n' % rev_branch
-
-            renames = []
-            for f in c.files():
-                if f not in c.manifest():
-                    continue
-                rename = c.filectx(f).renamed()
-                if rename:
-                    renames.append((rename[0], f))
-
-            for e in renames:
-                extra_msg += "rename : %s => %s\n" % e
-
-            for key, value in extra.iteritems():
-                if key in ('author', 'committer', 'encoding', 'message', 'branch', 'hg-git'):
-                    continue
-                else:
-                    extra_msg += "extra : %s : %s\n" % (key, urllib.quote(value))
-
-            if extra_msg:
-                desc += '\n--HG--\n' + extra_msg
-
-        if len(parents) == 0 and rev:
-            print 'reset %s/%s' % (prefix, ename)
-
-        modified_final = export_files(c.filectx(f) for f in modified)
-
-        print "commit %s/%s" % (prefix, ename)
-        print "mark :%d" % (marks.get_mark(c.hex()))
-        print "author %s" % (author)
-        print "committer %s" % (committer)
-        print "data %d" % (len(desc))
-        print desc
-
-        if len(parents) > 0:
-            print "from :%s" % (rev_to_mark(parents[0]))
-            if len(parents) > 1:
-                print "merge :%s" % (rev_to_mark(parents[1]))
-
-        for f in removed:
-            print "D %s" % (fix_file_path(f))
-        for f in modified_final:
-            print "M %s :%u %s" % f
-        print
-
-        progress = (rev - tip)
-        if (progress % 100 == 0):
-            print "progress revision %d '%s' (%d/%d)" % (rev, name, progress, total)
-
-    # make sure the ref is updated
-    print "reset %s/%s" % (prefix, ename)
-    print "from :%u" % rev_to_mark(head)
-    print
-
-    pending_revs = set(revs) - notes
-    if pending_revs:
-        note_mark = marks.next_mark()
-        ref = "refs/notes/hg"
-
-        print "commit %s" % ref
-        print "mark :%d" % (note_mark)
-        print "committer remote-hg <> %d %s" % (ptime.time(), gittz(ptime.timezone))
-        desc = "Notes for %s\n" % (name)
-        print "data %d" % (len(desc))
-        print desc
-        if marks.last_note:
-            print "from :%u" % marks.last_note
-
-        for rev in pending_revs:
-            notes.add(rev)
-            c = repo[rev]
-            print "N inline :%u" % rev_to_mark(c)
-            msg = c.hex()
-            print "data %d" % (len(msg))
-            print msg
-        print
-
-        marks.last_note = note_mark
-
-    marks.set_tip(ename, head.hex())
-
-def export_tag(repo, tag):
-    export_ref(repo, tag, 'tags', repo[hgref(tag)])
-
-def export_bookmark(repo, bmark):
-    head = bmarks[hgref(bmark)]
-    export_ref(repo, bmark, 'bookmarks', head)
-
-def export_branch(repo, branch):
-    tip = get_branch_tip(repo, branch)
-    head = repo[tip]
-    export_ref(repo, branch, 'branches', head)
-
-def export_head(repo):
-    export_ref(repo, g_head[0], 'bookmarks', g_head[1])
-
-def do_capabilities(parser):
-    print "import"
-    print "export"
-    print "refspec refs/heads/branches/*:%s/branches/*" % prefix
-    print "refspec refs/heads/*:%s/bookmarks/*" % prefix
-    print "refspec refs/tags/*:%s/tags/*" % prefix
-
-    path = os.path.join(dirname, 'marks-git')
-
-    if os.path.exists(path):
-        print "*import-marks %s" % path
-    print "*export-marks %s" % path
-    print "option"
-
-    print
-
-def branch_tip(branch):
-    return branches[branch][-1]
-
-def get_branch_tip(repo, branch):
-    heads = branches.get(hgref(branch), None)
-    if not heads:
-        return None
-
-    # verify there's only one head
-    if (len(heads) > 1):
-        warn("Branch '%s' has more than one head, consider merging" % branch)
-        return branch_tip(hgref(branch))
-
-    return heads[0]
-
-def list_head(repo, cur):
-    global g_head, fake_bmark
-
-    if 'default' not in branches:
-        # empty repo
-        return
-
-    node = repo[branch_tip('default')]
-    head = 'master' if not 'master' in bmarks else 'default'
-    fake_bmark = head
-    bmarks[head] = node
-
-    head = gitref(head)
-    print "@refs/heads/%s HEAD" % head
-    g_head = (head, node)
-
-def do_list(parser):
-    repo = parser.repo
-    for bmark, node in bookmarks.listbookmarks(repo).iteritems():
-        bmarks[bmark] = repo[node]
-
-    cur = repo.dirstate.branch()
-    orig = peer if peer else repo
-
-    for branch, heads in orig.branchmap().iteritems():
-        # only open heads
-        heads = [h for h in heads if 'close' not in repo.changelog.read(h)[5]]
-        if heads:
-            branches[branch] = heads
-
-    list_head(repo, cur)
-
-    if track_branches:
-        for branch in branches:
-            print "? refs/heads/branches/%s" % gitref(branch)
-
-    for bmark in bmarks:
-        if  bmarks[bmark].hex() == '0000000000000000000000000000000000000000':
-            warn("Ignoring invalid bookmark '%s'", bmark)
-        else:
-            print "? refs/heads/%s" % gitref(bmark)
-
-    for tag, node in repo.tagslist():
-        if tag == 'tip':
-            continue
-        print "? refs/tags/%s" % gitref(tag)
-
-    print
-
-def do_import(parser):
-    repo = parser.repo
-
-    path = os.path.join(dirname, 'marks-git')
-
-    print "feature done"
-    if os.path.exists(path):
-        print "feature import-marks=%s" % path
-    print "feature export-marks=%s" % path
-    print "feature force"
-    sys.stdout.flush()
-
-    tmp = encoding.encoding
-    encoding.encoding = 'utf-8'
-
-    # lets get all the import lines
-    while parser.check('import'):
-        ref = parser[1]
-
-        if (ref == 'HEAD'):
-            export_head(repo)
-        elif ref.startswith('refs/heads/branches/'):
-            branch = ref[len('refs/heads/branches/'):]
-            export_branch(repo, branch)
-        elif ref.startswith('refs/heads/'):
-            bmark = ref[len('refs/heads/'):]
-            export_bookmark(repo, bmark)
-        elif ref.startswith('refs/tags/'):
-            tag = ref[len('refs/tags/'):]
-            export_tag(repo, tag)
-
-        parser.next()
-
-    encoding.encoding = tmp
-
-    print 'done'
-
-def parse_blob(parser):
-    parser.next()
-    mark = parser.get_mark()
-    parser.next()
-    data = parser.get_data()
-    blob_marks[mark] = data
-    parser.next()
-
-def get_merge_files(repo, p1, p2, files):
-    for e in repo[p1].files():
-        if e not in files:
-            if e not in repo[p1].manifest():
-                continue
-            f = { 'ctx' : repo[p1][e] }
-            files[e] = f
-
-def c_style_unescape(string):
-    if string[0] == string[-1] == '"':
-        return string.decode('string-escape')[1:-1]
-    return string
-
-def parse_commit(parser):
-    from_mark = merge_mark = None
-
-    ref = parser[1]
-    parser.next()
-
-    commit_mark = parser.get_mark()
-    parser.next()
-    author = parser.get_author()
-    parser.next()
-    committer = parser.get_author()
-    parser.next()
-    data = parser.get_data()
-    parser.next()
-    if parser.check('from'):
-        from_mark = parser.get_mark()
-        parser.next()
-    if parser.check('merge'):
-        merge_mark = parser.get_mark()
-        parser.next()
-        if parser.check('merge'):
-            die('octopus merges are not supported yet')
-
-    # fast-export adds an extra newline
-    if data[-1] == '\n':
-        data = data[:-1]
-
-    files = {}
-
-    for line in parser:
-        if parser.check('M'):
-            t, m, mark_ref, path = line.split(' ', 3)
-            mark = int(mark_ref[1:])
-            f = { 'mode' : hgmode(m), 'data' : blob_marks[mark] }
-        elif parser.check('D'):
-            t, path = line.split(' ', 1)
-            f = { 'deleted' : True }
-        else:
-            die('Unknown file command: %s' % line)
-        path = c_style_unescape(path)
-        files[path] = f
-
-    # only export the commits if we are on an internal proxy repo
-    if dry_run and not peer:
-        parsed_refs[ref] = None
-        return
-
-    def getfilectx(repo, memctx, f):
-        of = files[f]
-        if 'deleted' in of:
-            raise IOError
-        if 'ctx' in of:
-            return of['ctx']
-        is_exec = of['mode'] == 'x'
-        is_link = of['mode'] == 'l'
-        rename = of.get('rename', None)
-        return context.memfilectx(f, of['data'],
-                is_link, is_exec, rename)
-
-    repo = parser.repo
-
-    user, date, tz = author
-    extra = {}
-
-    if committer != author:
-        extra['committer'] = "%s %u %u" % committer
-
-    if from_mark:
-        p1 = mark_to_rev(from_mark)
-    else:
-        p1 = '0' * 40
-
-    if merge_mark:
-        p2 = mark_to_rev(merge_mark)
-    else:
-        p2 = '0' * 40
-
-    #
-    # If files changed from any of the parents, hg wants to know, but in git if
-    # nothing changed from the first parent, nothing changed.
-    #
-    if merge_mark:
-        get_merge_files(repo, p1, p2, files)
-
-    # Check if the ref is supposed to be a named branch
-    if ref.startswith('refs/heads/branches/'):
-        branch = ref[len('refs/heads/branches/'):]
-        extra['branch'] = hgref(branch)
-
-    if mode == 'hg':
-        i = data.find('\n--HG--\n')
-        if i >= 0:
-            tmp = data[i + len('\n--HG--\n'):].strip()
-            for k, v in [e.split(' : ', 1) for e in tmp.split('\n')]:
-                if k == 'rename':
-                    old, new = v.split(' => ', 1)
-                    files[new]['rename'] = old
-                elif k == 'branch':
-                    extra[k] = v
-                elif k == 'extra':
-                    ek, ev = v.split(' : ', 1)
-                    extra[ek] = urllib.unquote(ev)
-            data = data[:i]
-
-    ctx = context.memctx(repo, (p1, p2), data,
-            files.keys(), getfilectx,
-            user, (date, tz), extra)
-
-    tmp = encoding.encoding
-    encoding.encoding = 'utf-8'
-
-    node = hghex(repo.commitctx(ctx))
-
-    encoding.encoding = tmp
-
-    parsed_refs[ref] = node
-    marks.new_mark(node, commit_mark)
-
-def parse_reset(parser):
-    ref = parser[1]
-    parser.next()
-    # ugh
-    if parser.check('commit'):
-        parse_commit(parser)
-        return
-    if not parser.check('from'):
-        return
-    from_mark = parser.get_mark()
-    parser.next()
-
-    try:
-        rev = mark_to_rev(from_mark)
-    except KeyError:
-        rev = None
-    parsed_refs[ref] = rev
-
-def parse_tag(parser):
-    name = parser[1]
-    parser.next()
-    from_mark = parser.get_mark()
-    parser.next()
-    tagger = parser.get_author()
-    parser.next()
-    data = parser.get_data()
-    parser.next()
-
-    parsed_tags[name] = (tagger, data)
-
-def write_tag(repo, tag, node, msg, author):
-    branch = repo[node].branch()
-    tip = branch_tip(branch)
-    tip = repo[tip]
-
-    def getfilectx(repo, memctx, f):
-        try:
-            fctx = tip.filectx(f)
-            data = fctx.data()
-        except error.ManifestLookupError:
-            data = ""
-        content = data + "%s %s\n" % (node, tag)
-        return context.memfilectx(f, content, False, False, None)
-
-    p1 = tip.hex()
-    p2 = '0' * 40
-    if author:
-        user, date, tz = author
-        date_tz = (date, tz)
-    else:
-        cmd = ['git', 'var', 'GIT_COMMITTER_IDENT']
-        process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
-        output, _ = process.communicate()
-        m = re.match('^.* <.*>', output)
-        if m:
-            user = m.group(0)
-        else:
-            user = repo.ui.username()
-        date_tz = None
-
-    ctx = context.memctx(repo, (p1, p2), msg,
-            ['.hgtags'], getfilectx,
-            user, date_tz, {'branch' : branch})
-
-    tmp = encoding.encoding
-    encoding.encoding = 'utf-8'
-
-    tagnode = repo.commitctx(ctx)
-
-    encoding.encoding = tmp
-
-    return (tagnode, branch)
-
-def checkheads_bmark(repo, ref, ctx):
-    bmark = ref[len('refs/heads/'):]
-    if not bmark in bmarks:
-        # new bmark
-        return True
-
-    ctx_old = bmarks[bmark]
-    ctx_new = ctx
-    if not repo.changelog.descendant(ctx_old.rev(), ctx_new.rev()):
-        if force_push:
-            print "ok %s forced update" % ref
-        else:
-            print "error %s non-fast forward" % ref
-            return False
-
-    return True
-
-def checkheads(repo, remote, p_revs):
-
-    remotemap = remote.branchmap()
-    if not remotemap:
-        # empty repo
-        return True
-
-    new = {}
-    ret = True
-
-    for node, ref in p_revs.iteritems():
-        ctx = repo[node]
-        branch = ctx.branch()
-        if not branch in remotemap:
-            # new branch
-            continue
-        if not ref.startswith('refs/heads/branches'):
-            if ref.startswith('refs/heads/'):
-                if not checkheads_bmark(repo, ref, ctx):
-                    ret = False
-
-            # only check branches
-            continue
-        new.setdefault(branch, []).append(ctx.rev())
-
-    for branch, heads in new.iteritems():
-        old = [repo.changelog.rev(x) for x in remotemap[branch]]
-        for rev in heads:
-            if check_version(2, 3):
-                ancestors = repo.changelog.ancestors([rev], stoprev=min(old))
-            else:
-                ancestors = repo.changelog.ancestors(rev)
-            found = False
-
-            for x in old:
-                if x in ancestors:
-                    found = True
-                    break
-
-            if found:
-                continue
-
-            node = repo.changelog.node(rev)
-            ref = p_revs[node]
-            if force_push:
-                print "ok %s forced update" % ref
-            else:
-                print "error %s non-fast forward" % ref
-                ret = False
-
-    return ret
-
-def push_unsafe(repo, remote, parsed_refs, p_revs):
-
-    force = force_push
-
-    fci = discovery.findcommonincoming
-    commoninc = fci(repo, remote, force=force)
-    common, _, remoteheads = commoninc
-
-    if not checkheads(repo, remote, p_revs):
-        return None
-
-    cg = repo.getbundle('push', heads=list(p_revs), common=common)
-
-    unbundle = remote.capable('unbundle')
-    if unbundle:
-        if force:
-            remoteheads = ['force']
-        return remote.unbundle(cg, remoteheads, 'push')
-    else:
-        return remote.addchangegroup(cg, 'push', repo.url())
-
-def push(repo, remote, parsed_refs, p_revs):
-    if hasattr(remote, 'canpush') and not remote.canpush():
-        print "error cannot push"
-
-    if not p_revs:
-        # nothing to push
-        return
-
-    lock = None
-    unbundle = remote.capable('unbundle')
-    if not unbundle:
-        lock = remote.lock()
-    try:
-        ret = push_unsafe(repo, remote, parsed_refs, p_revs)
-    finally:
-        if lock is not None:
-            lock.release()
-
-    return ret
-
-def check_tip(ref, kind, name, heads):
-    try:
-        ename = '%s/%s' % (kind, name)
-        tip = marks.get_tip(ename)
-    except KeyError:
-        return True
-    else:
-        return tip in heads
-
-def do_export(parser):
-    p_bmarks = []
-    p_revs = {}
-
-    parser.next()
-
-    for line in parser.each_block('done'):
-        if parser.check('blob'):
-            parse_blob(parser)
-        elif parser.check('commit'):
-            parse_commit(parser)
-        elif parser.check('reset'):
-            parse_reset(parser)
-        elif parser.check('tag'):
-            parse_tag(parser)
-        elif parser.check('feature'):
-            pass
-        else:
-            die('unhandled export command: %s' % line)
-
-    need_fetch = False
-
-    for ref, node in parsed_refs.iteritems():
-        bnode = hgbin(node) if node else None
-        if ref.startswith('refs/heads/branches'):
-            branch = ref[len('refs/heads/branches/'):]
-            if branch in branches and bnode in branches[branch]:
-                # up to date
-                continue
-
-            if peer:
-                remotemap = peer.branchmap()
-                if remotemap and branch in remotemap:
-                    heads = [hghex(e) for e in remotemap[branch]]
-                    if not check_tip(ref, 'branches', branch, heads):
-                        print "error %s fetch first" % ref
-                        need_fetch = True
-                        continue
-
-            p_revs[bnode] = ref
-            print "ok %s" % ref
-        elif ref.startswith('refs/heads/'):
-            bmark = ref[len('refs/heads/'):]
-            new = node
-            old = bmarks[bmark].hex() if bmark in bmarks else ''
-
-            if old == new:
-                continue
-
-            print "ok %s" % ref
-            if bmark != fake_bmark and \
-                    not (bmark == 'master' and bmark not in parser.repo._bookmarks):
-                p_bmarks.append((ref, bmark, old, new))
-
-            if peer:
-                remote_old = peer.listkeys('bookmarks').get(bmark)
-                if remote_old:
-                    if not check_tip(ref, 'bookmarks', bmark, remote_old):
-                        print "error %s fetch first" % ref
-                        need_fetch = True
-                        continue
-
-            p_revs[bnode] = ref
-        elif ref.startswith('refs/tags/'):
-            if dry_run:
-                print "ok %s" % ref
-                continue
-            tag = ref[len('refs/tags/'):]
-            tag = hgref(tag)
-            author, msg = parsed_tags.get(tag, (None, None))
-            if mode == 'git':
-                if not msg:
-                    msg = 'Added tag %s for changeset %s' % (tag, node[:12])
-                tagnode, branch = write_tag(parser.repo, tag, node, msg, author)
-                p_revs[tagnode] = 'refs/heads/branches/' + gitref(branch)
-            else:
-                fp = parser.repo.opener('localtags', 'a')
-                fp.write('%s %s\n' % (node, tag))
-                fp.close()
-            p_revs[bnode] = ref
-            print "ok %s" % ref
-        else:
-            # transport-helper/fast-export bugs
-            continue
-
-    if need_fetch:
-        print
-        return
-
-    if dry_run:
-        if peer and not force_push:
-            checkheads(parser.repo, peer, p_revs)
-        print
-        return
-
-    if peer:
-        if not push(parser.repo, peer, parsed_refs, p_revs):
-            # do not update bookmarks
-            print
-            return
-
-        # update remote bookmarks
-        remote_bmarks = peer.listkeys('bookmarks')
-        for ref, bmark, old, new in p_bmarks:
-            if force_push:
-                old = remote_bmarks.get(bmark, '')
-            if not peer.pushkey('bookmarks', bmark, old, new):
-                print "error %s" % ref
-    else:
-        # update local bookmarks
-        for ref, bmark, old, new in p_bmarks:
-            if not bookmarks.pushbookmark(parser.repo, bmark, old, new):
-                print "error %s" % ref
-
-    print
-
-def do_option(parser):
-    global dry_run, force_push
-    _, key, value = parser.line.split(' ')
-    if key == 'dry-run':
-        dry_run = (value == 'true')
-        print 'ok'
-    elif key == 'force':
-        force_push = (value == 'true')
-        print 'ok'
-    else:
-        print 'unsupported'
-
-def fix_path(alias, repo, orig_url):
-    url = urlparse.urlparse(orig_url, 'file')
-    if url.scheme != 'file' or os.path.isabs(os.path.expanduser(url.path)):
-        return
-    abs_url = urlparse.urljoin("%s/" % os.getcwd(), orig_url)
-    cmd = ['git', 'config', 'remote.%s.url' % alias, "hg::%s" % abs_url]
-    subprocess.call(cmd)
-
-def main(args):
-    global prefix, gitdir, dirname, branches, bmarks
-    global marks, blob_marks, parsed_refs
-    global peer, mode, bad_mail, bad_name
-    global track_branches, force_push, is_tmp
-    global parsed_tags
-    global filenodes
-    global fake_bmark, hg_version
-    global dry_run
-    global notes, alias
-
-    marks = None
-    is_tmp = False
-    gitdir = os.environ.get('GIT_DIR', None)
-
-    if len(args) < 3:
-        die('Not enough arguments.')
-
-    if not gitdir:
-        die('GIT_DIR not set')
-
-    alias = args[1]
-    url = args[2]
-    peer = None
-
-    hg_git_compat = get_config_bool('remote-hg.hg-git-compat')
-    track_branches = get_config_bool('remote-hg.track-branches', True)
-    force_push = False
-
-    if hg_git_compat:
-        mode = 'hg'
-        bad_mail = 'none@none'
-        bad_name = ''
-    else:
-        mode = 'git'
-        bad_mail = 'unknown'
-        bad_name = 'Unknown'
-
-    if alias[4:] == url:
-        is_tmp = True
-        alias = hashlib.sha1(alias).hexdigest()
-
-    dirname = os.path.join(gitdir, 'hg', alias)
-    branches = {}
-    bmarks = {}
-    blob_marks = {}
-    parsed_refs = {}
-    parsed_tags = {}
-    filenodes = {}
-    fake_bmark = None
-    try:
-        hg_version = tuple(int(e) for e in util.version().split('.'))
-    except:
-        hg_version = None
-    dry_run = False
-    notes = set()
-
-    repo = get_repo(url, alias)
-    prefix = 'refs/hg/%s' % alias
-
-    if not is_tmp:
-        fix_path(alias, peer or repo, url)
-
-    marks_path = os.path.join(dirname, 'marks-hg')
-    marks = Marks(marks_path, repo)
-
-    if sys.platform == 'win32':
-        import msvcrt
-        msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
-
-    parser = Parser(repo)
-    for line in parser:
-        if parser.check('capabilities'):
-            do_capabilities(parser)
-        elif parser.check('list'):
-            do_list(parser)
-        elif parser.check('import'):
-            do_import(parser)
-        elif parser.check('export'):
-            do_export(parser)
-        elif parser.check('option'):
-            do_option(parser)
-        else:
-            die('unhandled command: %s' % line)
-        sys.stdout.flush()
 
-def bye():
-    if not marks:
-        return
-    if not is_tmp:
-        marks.store()
-    else:
-        shutil.rmtree(dirname)
+sys.stderr.write('WARNING: git-remote-hg is now maintained independently.\n')
+sys.stderr.write('WARNING: For more information visit https://github.com/felipec/git-remote-hg\n')
 
-atexit.register(bye)
-sys.exit(main(sys.argv))
+sys.stderr.write('''WARNING:
+WARNING: You can pick a directory on your $PATH and download it, e.g.:
+WARNING:   $ wget -O $HOME/bin/git-remote-hg \\
+WARNING:     https://raw.github.com/felipec/git-remote-hg/master/git-remote-hg
+WARNING:   $ chmod +x $HOME/bin/git-remote-hg
+''')
diff --git a/contrib/remote-helpers/test-bzr.sh b/contrib/remote-helpers/test-bzr.sh
deleted file mode 100755 (executable)
index a4656ce..0000000
+++ /dev/null
@@ -1,438 +0,0 @@
-#!/bin/sh
-#
-# Copyright (c) 2012 Felipe Contreras
-#
-
-test_description='Test remote-bzr'
-
-test -n "$TEST_DIRECTORY" || TEST_DIRECTORY=${0%/*}/../../t
-. "$TEST_DIRECTORY"/test-lib.sh
-
-if ! test_have_prereq PYTHON
-then
-       skip_all='skipping remote-bzr tests; python not available'
-       test_done
-fi
-
-if ! python -c 'import bzrlib'
-then
-       skip_all='skipping remote-bzr tests; bzr not available'
-       test_done
-fi
-
-check () {
-       echo $3 >expected &&
-       git --git-dir=$1/.git log --format='%s' -1 $2 >actual
-       test_cmp expected actual
-}
-
-bzr whoami "A U Thor <author@example.com>"
-
-test_expect_success 'cloning' '
-       (
-       bzr init bzrrepo &&
-       cd bzrrepo &&
-       echo one >content &&
-       bzr add content &&
-       bzr commit -m one
-       ) &&
-
-       git clone "bzr::bzrrepo" gitrepo &&
-       check gitrepo HEAD one
-'
-
-test_expect_success 'pulling' '
-       (
-       cd bzrrepo &&
-       echo two >content &&
-       bzr commit -m two
-       ) &&
-
-       (cd gitrepo && git pull) &&
-
-       check gitrepo HEAD two
-'
-
-test_expect_success 'pushing' '
-       (
-       cd gitrepo &&
-       echo three >content &&
-       git commit -a -m three &&
-       git push
-       ) &&
-
-       echo three >expected &&
-       cat bzrrepo/content >actual &&
-       test_cmp expected actual
-'
-
-test_expect_success 'forced pushing' '
-       (
-       cd gitrepo &&
-       echo three-new >content &&
-       git commit -a --amend -m three-new &&
-       git push -f
-       ) &&
-
-       (
-       cd bzrrepo &&
-       # the forced update overwrites the bzr branch but not the bzr
-       # working directory (it tries to merge instead)
-       bzr revert
-       ) &&
-
-       echo three-new >expected &&
-       cat bzrrepo/content >actual &&
-       test_cmp expected actual
-'
-
-test_expect_success 'roundtrip' '
-       (
-       cd gitrepo &&
-       git pull &&
-       git log --format="%s" -1 origin/master >actual
-       ) &&
-       echo three-new >expected &&
-       test_cmp expected actual &&
-
-       (cd gitrepo && git push && git pull) &&
-
-       (
-       cd bzrrepo &&
-       echo four >content &&
-       bzr commit -m four
-       ) &&
-
-       (cd gitrepo && git pull && git push) &&
-
-       check gitrepo HEAD four &&
-
-       (
-       cd gitrepo &&
-       echo five >content &&
-       git commit -a -m five &&
-       git push && git pull
-       ) &&
-
-       (cd bzrrepo && bzr revert) &&
-
-       echo five >expected &&
-       cat bzrrepo/content >actual &&
-       test_cmp expected actual
-'
-
-cat >expected <<\EOF
-100644 blob 54f9d6da5c91d556e6b54340b1327573073030af   content
-100755 blob 68769579c3eaadbe555379b9c3538e6628bae1eb   executable
-120000 blob 6b584e8ece562ebffc15d38808cd6b98fc3d97ea   link
-EOF
-
-test_expect_success 'special modes' '
-       (
-       cd bzrrepo &&
-       echo exec >executable
-       chmod +x executable &&
-       bzr add executable
-       bzr commit -m exec &&
-       ln -s content link
-       bzr add link
-       bzr commit -m link &&
-       mkdir dir &&
-       bzr add dir &&
-       bzr commit -m dir
-       ) &&
-
-       (
-       cd gitrepo &&
-       git pull
-       git ls-tree HEAD >../actual
-       ) &&
-
-       test_cmp expected actual &&
-
-       (
-       cd gitrepo &&
-       git cat-file -p HEAD:link >../actual
-       ) &&
-
-       printf content >expected &&
-       test_cmp expected actual
-'
-
-cat >expected <<\EOF
-100644 blob 54f9d6da5c91d556e6b54340b1327573073030af   content
-100755 blob 68769579c3eaadbe555379b9c3538e6628bae1eb   executable
-120000 blob 6b584e8ece562ebffc15d38808cd6b98fc3d97ea   link
-040000 tree 35c0caa46693cef62247ac89a680f0c5ce32b37b   movedir-new
-EOF
-
-test_expect_success 'moving directory' '
-       (
-       cd bzrrepo &&
-       mkdir movedir &&
-       echo one >movedir/one &&
-       echo two >movedir/two &&
-       bzr add movedir &&
-       bzr commit -m movedir &&
-       bzr mv movedir movedir-new &&
-       bzr commit -m movedir-new
-       ) &&
-
-       (
-       cd gitrepo &&
-       git pull &&
-       git ls-tree HEAD >../actual
-       ) &&
-
-       test_cmp expected actual
-'
-
-test_expect_success 'different authors' '
-       (
-       cd bzrrepo &&
-       echo john >>content &&
-       bzr commit -m john \
-         --author "Jane Rey <jrey@example.com>" \
-         --author "John Doe <jdoe@example.com>"
-       ) &&
-
-       (
-       cd gitrepo &&
-       git pull &&
-       git show --format="%an <%ae>, %cn <%ce>" --quiet >../actual
-       ) &&
-
-       echo "Jane Rey <jrey@example.com>, A U Thor <author@example.com>" >expected &&
-       test_cmp expected actual
-'
-
-# cleanup previous stuff
-rm -rf bzrrepo gitrepo
-
-test_expect_success 'fetch utf-8 filenames' '
-       test_when_finished "rm -rf bzrrepo gitrepo && LC_ALL=C" &&
-
-       LC_ALL=en_US.UTF-8
-       export LC_ALL
-
-       (
-       bzr init bzrrepo &&
-       cd bzrrepo &&
-
-       echo test >>"ærø" &&
-       bzr add "ærø" &&
-       echo test >>"ø~?" &&
-       bzr add "ø~?" &&
-       bzr commit -m add-utf-8 &&
-       echo test >>"ærø" &&
-       bzr commit -m test-utf-8 &&
-       bzr rm "ø~?" &&
-       bzr mv "ærø" "ø~?" &&
-       bzr commit -m bzr-mv-utf-8
-       ) &&
-
-       (
-       git clone "bzr::bzrrepo" gitrepo &&
-       cd gitrepo &&
-       git -c core.quotepath=false ls-files >../actual
-       ) &&
-       echo "ø~?" >expected &&
-       test_cmp expected actual
-'
-
-test_expect_success 'push utf-8 filenames' '
-       test_when_finished "rm -rf bzrrepo gitrepo && LC_ALL=C" &&
-
-       mkdir -p tmp && cd tmp &&
-
-       LC_ALL=en_US.UTF-8
-       export LC_ALL
-
-       (
-       bzr init bzrrepo &&
-       cd bzrrepo &&
-
-       echo one >>content &&
-       bzr add content &&
-       bzr commit -m one
-       ) &&
-
-       (
-       git clone "bzr::bzrrepo" gitrepo &&
-       cd gitrepo &&
-
-       echo test >>"ærø" &&
-       git add "ærø" &&
-       git commit -m utf-8 &&
-
-       git push
-       ) &&
-
-       (cd bzrrepo && bzr ls >../actual) &&
-       printf "content\nærø\n" >expected &&
-       test_cmp expected actual
-'
-
-test_expect_success 'pushing a merge' '
-       test_when_finished "rm -rf bzrrepo gitrepo" &&
-
-       (
-       bzr init bzrrepo &&
-       cd bzrrepo &&
-       echo one >content &&
-       bzr add content &&
-       bzr commit -m one
-       ) &&
-
-       git clone "bzr::bzrrepo" gitrepo &&
-
-       (
-       cd bzrrepo &&
-       echo two >content &&
-       bzr commit -m two
-       ) &&
-
-       (
-       cd gitrepo &&
-       echo three >content &&
-       git commit -a -m three &&
-       git fetch &&
-       git merge origin/master || true &&
-       echo three >content &&
-       git commit -a --no-edit &&
-       git push
-       ) &&
-
-       echo three >expected &&
-       cat bzrrepo/content >actual &&
-       test_cmp expected actual
-'
-
-cat >expected <<\EOF
-origin/HEAD
-origin/branch
-origin/trunk
-EOF
-
-test_expect_success 'proper bzr repo' '
-       test_when_finished "rm -rf bzrrepo gitrepo" &&
-
-       bzr init-repo bzrrepo &&
-
-       (
-       bzr init bzrrepo/trunk &&
-       cd bzrrepo/trunk &&
-       echo one >>content &&
-       bzr add content &&
-       bzr commit -m one
-       ) &&
-
-       (
-       bzr branch bzrrepo/trunk bzrrepo/branch &&
-       cd bzrrepo/branch &&
-       echo two >>content &&
-       bzr commit -m one
-       ) &&
-
-       (
-       git clone "bzr::bzrrepo" gitrepo &&
-       cd gitrepo &&
-       git for-each-ref --format "%(refname:short)" refs/remotes/origin >../actual
-       ) &&
-
-       test_cmp expected actual
-'
-
-test_expect_success 'strip' '
-       test_when_finished "rm -rf bzrrepo gitrepo" &&
-
-       (
-       bzr init bzrrepo &&
-       cd bzrrepo &&
-
-       echo one >>content &&
-       bzr add content &&
-       bzr commit -m one &&
-
-       echo two >>content &&
-       bzr commit -m two
-       ) &&
-
-       git clone "bzr::bzrrepo" gitrepo &&
-
-       (
-       cd bzrrepo &&
-       bzr uncommit --force &&
-
-       echo three >>content &&
-       bzr commit -m three &&
-
-       echo four >>content &&
-       bzr commit -m four &&
-       bzr log --line | sed -e "s/^[0-9][0-9]*: //" >../expected
-       ) &&
-
-       (
-       cd gitrepo &&
-       git fetch &&
-       git log --format="%an %ad %s" --date=short origin/master >../actual
-       ) &&
-
-       test_cmp expected actual
-'
-
-test_expect_success 'export utf-8 authors' '
-       test_when_finished "rm -rf bzrrepo gitrepo && LC_ALL=C && GIT_COMMITTER_NAME=\"C O Mitter\""
-
-       LC_ALL=en_US.UTF-8
-       export LC_ALL
-
-       GIT_COMMITTER_NAME="Grégoire"
-       export GIT_COMMITTER_NAME
-
-       bzr init bzrrepo &&
-
-       (
-       git init gitrepo &&
-       cd gitrepo &&
-       echo greg >>content &&
-       git add content &&
-       git commit -m one &&
-       git remote add bzr "bzr::../bzrrepo" &&
-       git push bzr master
-       ) &&
-
-       (
-       cd bzrrepo &&
-       bzr log | grep "^committer: " >../actual
-       ) &&
-
-       echo "committer: Grégoire <committer@example.com>" >expected &&
-       test_cmp expected actual
-'
-
-test_expect_success 'push different author' '
-       test_when_finished "rm -rf bzrrepo gitrepo" &&
-
-       bzr init bzrrepo &&
-
-       (
-       git init gitrepo &&
-       cd gitrepo &&
-       echo john >> content &&
-       git add content &&
-       git commit -m john --author "John Doe <jdoe@example.com>" &&
-       git remote add bzr "bzr::../bzrrepo" &&
-       git push bzr master
-       ) &&
-
-       (
-       cd bzrrepo &&
-       bzr log | grep "^author: " > ../actual
-       ) &&
-
-       echo "author: John Doe <jdoe@example.com>" > expected &&
-       test_cmp expected actual
-'
-
-test_done
diff --git a/contrib/remote-helpers/test-hg-bidi.sh b/contrib/remote-helpers/test-hg-bidi.sh
deleted file mode 100755 (executable)
index d86e147..0000000
+++ /dev/null
@@ -1,243 +0,0 @@
-#!/bin/sh
-#
-# Copyright (c) 2012 Felipe Contreras
-#
-# Base commands from hg-git tests:
-# https://bitbucket.org/durin42/hg-git/src
-#
-
-test_description='Test bidirectionality of remote-hg'
-
-test -n "$TEST_DIRECTORY" || TEST_DIRECTORY=${0%/*}/../../t
-. "$TEST_DIRECTORY"/test-lib.sh
-
-if ! test_have_prereq PYTHON
-then
-       skip_all='skipping remote-hg tests; python not available'
-       test_done
-fi
-
-if ! python -c 'import mercurial'
-then
-       skip_all='skipping remote-hg tests; mercurial not available'
-       test_done
-fi
-
-# clone to a git repo
-git_clone () {
-       git clone -q "hg::$1" $2
-}
-
-# clone to an hg repo
-hg_clone () {
-       (
-       hg init $2 &&
-       cd $1 &&
-       git push -q "hg::../$2" 'refs/tags/*:refs/tags/*' 'refs/heads/*:refs/heads/*'
-       ) &&
-
-       (cd $2 && hg -q update)
-}
-
-# push an hg repo
-hg_push () {
-       (
-       cd $2
-       git checkout -q -b tmp &&
-       git fetch -q "hg::../$1" 'refs/tags/*:refs/tags/*' 'refs/heads/*:refs/heads/*' &&
-       git checkout -q @{-1} &&
-       git branch -q -D tmp 2>/dev/null || true
-       )
-}
-
-hg_log () {
-       hg -R $1 log --graph --debug
-}
-
-setup () {
-       (
-       echo "[ui]"
-       echo "username = A U Thor <author@example.com>"
-       echo "[defaults]"
-       echo "backout = -d \"0 0\""
-       echo "commit = -d \"0 0\""
-       echo "debugrawcommit = -d \"0 0\""
-       echo "tag = -d \"0 0\""
-       echo "[extensions]"
-       echo "graphlog ="
-       ) >>"$HOME"/.hgrc &&
-       git config --global remote-hg.hg-git-compat true
-       git config --global remote-hg.track-branches true
-
-       HGEDITOR=/usr/bin/true
-       GIT_AUTHOR_DATE="2007-01-01 00:00:00 +0230"
-       GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"
-       export HGEDITOR GIT_AUTHOR_DATE GIT_COMMITTER_DATE
-}
-
-setup
-
-test_expect_success 'encoding' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -m "add älphà" &&
-
-       GIT_AUTHOR_NAME="tést èncödîng" &&
-       export GIT_AUTHOR_NAME &&
-       echo beta >beta &&
-       git add beta &&
-       git commit -m "add beta" &&
-
-       echo gamma >gamma &&
-       git add gamma &&
-       git commit -m "add gämmâ" &&
-
-       : TODO git config i18n.commitencoding latin-1 &&
-       echo delta >delta &&
-       git add delta &&
-       git commit -m "add déltà"
-       ) &&
-
-       hg_clone gitrepo hgrepo &&
-       git_clone hgrepo gitrepo2 &&
-       hg_clone gitrepo2 hgrepo2 &&
-
-       HGENCODING=utf-8 hg_log hgrepo >expected &&
-       HGENCODING=utf-8 hg_log hgrepo2 >actual &&
-
-       test_cmp expected actual
-'
-
-test_expect_success 'file removal' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -m "add alpha" &&
-       echo beta >beta &&
-       git add beta &&
-       git commit -m "add beta"
-       mkdir foo &&
-       echo blah >foo/bar &&
-       git add foo &&
-       git commit -m "add foo" &&
-       git rm alpha &&
-       git commit -m "remove alpha" &&
-       git rm foo/bar &&
-       git commit -m "remove foo/bar"
-       ) &&
-
-       hg_clone gitrepo hgrepo &&
-       git_clone hgrepo gitrepo2 &&
-       hg_clone gitrepo2 hgrepo2 &&
-
-       hg_log hgrepo >expected &&
-       hg_log hgrepo2 >actual &&
-
-       test_cmp expected actual
-'
-
-test_expect_success 'git tags' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-       git config receive.denyCurrentBranch ignore &&
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -m "add alpha" &&
-       git tag alpha &&
-
-       echo beta >beta &&
-       git add beta &&
-       git commit -m "add beta" &&
-       git tag -a -m "added tag beta" beta
-       ) &&
-
-       hg_clone gitrepo hgrepo &&
-       git_clone hgrepo gitrepo2 &&
-       hg_clone gitrepo2 hgrepo2 &&
-
-       hg_log hgrepo >expected &&
-       hg_log hgrepo2 >actual &&
-
-       test_cmp expected actual
-'
-
-test_expect_success 'hg branch' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -q -m "add alpha" &&
-       git checkout -q -b not-master
-       ) &&
-
-       (
-       hg_clone gitrepo hgrepo &&
-
-       cd hgrepo &&
-       hg -q co default &&
-       hg mv alpha beta &&
-       hg -q commit -m "rename alpha to beta" &&
-       hg branch gamma | grep -v "permanent and global" &&
-       hg -q commit -m "started branch gamma"
-       ) &&
-
-       hg_push hgrepo gitrepo &&
-       hg_clone gitrepo hgrepo2 &&
-
-       : Back to the common revision &&
-       (cd hgrepo && hg checkout default) &&
-
-       hg_log hgrepo >expected &&
-       hg_log hgrepo2 >actual &&
-
-       test_cmp expected actual
-'
-
-test_expect_success 'hg tags' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -m "add alpha" &&
-       git checkout -q -b not-master
-       ) &&
-
-       (
-       hg_clone gitrepo hgrepo &&
-
-       cd hgrepo &&
-       hg co default &&
-       hg tag alpha
-       ) &&
-
-       hg_push hgrepo gitrepo &&
-       hg_clone gitrepo hgrepo2 &&
-
-       hg_log hgrepo >expected &&
-       hg_log hgrepo2 >actual &&
-
-       test_cmp expected actual
-'
-
-test_done
diff --git a/contrib/remote-helpers/test-hg-hg-git.sh b/contrib/remote-helpers/test-hg-hg-git.sh
deleted file mode 100755 (executable)
index b23909a..0000000
+++ /dev/null
@@ -1,542 +0,0 @@
-#!/bin/sh
-#
-# Copyright (c) 2012 Felipe Contreras
-#
-# Base commands from hg-git tests:
-# https://bitbucket.org/durin42/hg-git/src
-#
-
-test_description='Test remote-hg output compared to hg-git'
-
-test -n "$TEST_DIRECTORY" || TEST_DIRECTORY=${0%/*}/../../t
-. "$TEST_DIRECTORY"/test-lib.sh
-
-if ! test_have_prereq PYTHON
-then
-       skip_all='skipping remote-hg tests; python not available'
-       test_done
-fi
-
-if ! python -c 'import mercurial'
-then
-       skip_all='skipping remote-hg tests; mercurial not available'
-       test_done
-fi
-
-if ! python -c 'import hggit'
-then
-       skip_all='skipping remote-hg tests; hg-git not available'
-       test_done
-fi
-
-# clone to a git repo with git
-git_clone_git () {
-       git clone -q "hg::$1" $2 &&
-       (cd $2 && git checkout master && git branch -D default)
-}
-
-# clone to an hg repo with git
-hg_clone_git () {
-       (
-       hg init $2 &&
-       hg -R $2 bookmark -i master &&
-       cd $1 &&
-       git push -q "hg::../$2" 'refs/tags/*:refs/tags/*' 'refs/heads/*:refs/heads/*'
-       ) &&
-
-       (cd $2 && hg -q update)
-}
-
-# clone to a git repo with hg
-git_clone_hg () {
-       (
-       git init -q $2 &&
-       cd $1 &&
-       hg bookmark -i -f -r tip master &&
-       hg -q push -r master ../$2 || true
-       )
-}
-
-# clone to an hg repo with hg
-hg_clone_hg () {
-       hg -q clone $1 $2
-}
-
-# push an hg repo with git
-hg_push_git () {
-       (
-       cd $2
-       git checkout -q -b tmp &&
-       git fetch -q "hg::../$1" 'refs/tags/*:refs/tags/*' 'refs/heads/*:refs/heads/*' &&
-       git branch -D default &&
-       git checkout -q @{-1} &&
-       git branch -q -D tmp 2>/dev/null || true
-       )
-}
-
-# push an hg git repo with hg
-hg_push_hg () {
-       (
-       cd $1 &&
-       hg -q push ../$2 || true
-       )
-}
-
-hg_log () {
-       hg -R $1 log --graph --debug >log &&
-       grep -v 'tag: *default/' log
-}
-
-git_log () {
-       git --git-dir=$1/.git fast-export --branches
-}
-
-setup () {
-       (
-       echo "[ui]"
-       echo "username = A U Thor <author@example.com>"
-       echo "[defaults]"
-       echo "backout = -d \"0 0\""
-       echo "commit = -d \"0 0\""
-       echo "debugrawcommit = -d \"0 0\""
-       echo "tag = -d \"0 0\""
-       echo "[extensions]"
-       echo "hgext.bookmarks ="
-       echo "hggit ="
-       echo "graphlog ="
-       ) >>"$HOME"/.hgrc &&
-       git config --global receive.denycurrentbranch warn
-       git config --global remote-hg.hg-git-compat true
-       git config --global remote-hg.track-branches false
-
-       HGEDITOR=true
-       HGMERGE=true
-
-       GIT_AUTHOR_DATE="2007-01-01 00:00:00 +0230"
-       GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"
-       export HGEDITOR HGMERGE GIT_AUTHOR_DATE GIT_COMMITTER_DATE
-}
-
-setup
-
-test_expect_success 'executable bit' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-       echo alpha >alpha &&
-       chmod 0644 alpha &&
-       git add alpha &&
-       git commit -m "add alpha" &&
-       chmod 0755 alpha &&
-       git add alpha &&
-       git commit -m "set executable bit" &&
-       chmod 0644 alpha &&
-       git add alpha &&
-       git commit -m "clear executable bit"
-       ) &&
-
-       for x in hg git
-       do
-               (
-               hg_clone_$x gitrepo hgrepo-$x &&
-               cd hgrepo-$x &&
-               hg_log . &&
-               hg manifest -r 1 -v &&
-               hg manifest -v
-               ) >"output-$x" &&
-
-               git_clone_$x hgrepo-$x gitrepo2-$x &&
-               git_log gitrepo2-$x >"log-$x"
-       done &&
-
-       test_cmp output-hg output-git &&
-       test_cmp log-hg log-git
-'
-
-test_expect_success 'symlink' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -m "add alpha" &&
-       ln -s alpha beta &&
-       git add beta &&
-       git commit -m "add beta"
-       ) &&
-
-       for x in hg git
-       do
-               (
-               hg_clone_$x gitrepo hgrepo-$x &&
-               cd hgrepo-$x &&
-               hg_log . &&
-               hg manifest -v
-               ) >"output-$x" &&
-
-               git_clone_$x hgrepo-$x gitrepo2-$x &&
-               git_log gitrepo2-$x >"log-$x"
-       done &&
-
-       test_cmp output-hg output-git &&
-       test_cmp log-hg log-git
-'
-
-test_expect_success 'merge conflict 1' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       hg init hgrepo1 &&
-       cd hgrepo1 &&
-       echo A >afile &&
-       hg add afile &&
-       hg ci -m "origin" &&
-
-       echo B >afile &&
-       hg ci -m "A->B" &&
-
-       hg up -r0 &&
-       echo C >afile &&
-       hg ci -m "A->C" &&
-
-       hg merge -r1 &&
-       echo C >afile &&
-       hg resolve -m afile &&
-       hg ci -m "merge to C"
-       ) &&
-
-       for x in hg git
-       do
-               git_clone_$x hgrepo1 gitrepo-$x &&
-               hg_clone_$x gitrepo-$x hgrepo2-$x &&
-               hg_log hgrepo2-$x >"hg-log-$x" &&
-               git_log gitrepo-$x >"git-log-$x"
-       done &&
-
-       test_cmp hg-log-hg hg-log-git &&
-       test_cmp git-log-hg git-log-git
-'
-
-test_expect_success 'merge conflict 2' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       hg init hgrepo1 &&
-       cd hgrepo1 &&
-       echo A >afile &&
-       hg add afile &&
-       hg ci -m "origin" &&
-
-       echo B >afile &&
-       hg ci -m "A->B" &&
-
-       hg up -r0 &&
-       echo C >afile &&
-       hg ci -m "A->C" &&
-
-       hg merge -r1 || true &&
-       echo B >afile &&
-       hg resolve -m afile &&
-       hg ci -m "merge to B"
-       ) &&
-
-       for x in hg git
-       do
-               git_clone_$x hgrepo1 gitrepo-$x &&
-               hg_clone_$x gitrepo-$x hgrepo2-$x &&
-               hg_log hgrepo2-$x >"hg-log-$x" &&
-               git_log gitrepo-$x >"git-log-$x"
-       done &&
-
-       test_cmp hg-log-hg hg-log-git &&
-       test_cmp git-log-hg git-log-git
-'
-
-test_expect_success 'converged merge' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       hg init hgrepo1 &&
-       cd hgrepo1 &&
-       echo A >afile &&
-       hg add afile &&
-       hg ci -m "origin" &&
-
-       echo B >afile &&
-       hg ci -m "A->B" &&
-
-       echo C >afile &&
-       hg ci -m "B->C" &&
-
-       hg up -r0 &&
-       echo C >afile &&
-       hg ci -m "A->C" &&
-
-       hg merge -r2 || true &&
-       hg ci -m "merge"
-       ) &&
-
-       for x in hg git
-       do
-               git_clone_$x hgrepo1 gitrepo-$x &&
-               hg_clone_$x gitrepo-$x hgrepo2-$x &&
-               hg_log hgrepo2-$x >"hg-log-$x" &&
-               git_log gitrepo-$x >"git-log-$x"
-       done &&
-
-       test_cmp hg-log-hg hg-log-git &&
-       test_cmp git-log-hg git-log-git
-'
-
-test_expect_success 'encoding' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -m "add älphà" &&
-
-       GIT_AUTHOR_NAME="tést èncödîng" &&
-       export GIT_AUTHOR_NAME &&
-       echo beta >beta &&
-       git add beta &&
-       git commit -m "add beta" &&
-
-       echo gamma >gamma &&
-       git add gamma &&
-       git commit -m "add gämmâ" &&
-
-       : TODO git config i18n.commitencoding latin-1 &&
-       echo delta >delta &&
-       git add delta &&
-       git commit -m "add déltà"
-       ) &&
-
-       for x in hg git
-       do
-               hg_clone_$x gitrepo hgrepo-$x &&
-               git_clone_$x hgrepo-$x gitrepo2-$x &&
-
-               HGENCODING=utf-8 hg_log hgrepo-$x >"hg-log-$x" &&
-               git_log gitrepo2-$x >"git-log-$x"
-       done &&
-
-       test_cmp hg-log-hg hg-log-git &&
-       test_cmp git-log-hg git-log-git
-'
-
-test_expect_success 'file removal' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -m "add alpha" &&
-       echo beta >beta &&
-       git add beta &&
-       git commit -m "add beta"
-       mkdir foo &&
-       echo blah >foo/bar &&
-       git add foo &&
-       git commit -m "add foo" &&
-       git rm alpha &&
-       git commit -m "remove alpha" &&
-       git rm foo/bar &&
-       git commit -m "remove foo/bar"
-       ) &&
-
-       for x in hg git
-       do
-               (
-               hg_clone_$x gitrepo hgrepo-$x &&
-               cd hgrepo-$x &&
-               hg_log . &&
-               hg manifest -r 3 &&
-               hg manifest
-               ) >"output-$x" &&
-
-               git_clone_$x hgrepo-$x gitrepo2-$x &&
-               git_log gitrepo2-$x >"log-$x"
-       done &&
-
-       test_cmp output-hg output-git &&
-       test_cmp log-hg log-git
-'
-
-test_expect_success 'git tags' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       (
-       git init -q gitrepo &&
-       cd gitrepo &&
-       git config receive.denyCurrentBranch ignore &&
-       echo alpha >alpha &&
-       git add alpha &&
-       git commit -m "add alpha" &&
-       git tag alpha &&
-
-       echo beta >beta &&
-       git add beta &&
-       git commit -m "add beta" &&
-       git tag -a -m "added tag beta" beta
-       ) &&
-
-       for x in hg git
-       do
-               hg_clone_$x gitrepo hgrepo-$x &&
-               hg_log hgrepo-$x >"log-$x"
-       done &&
-
-       test_cmp log-hg log-git
-'
-
-test_expect_success 'hg author' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       for x in hg git
-       do
-               (
-               git init -q gitrepo-$x &&
-               cd gitrepo-$x &&
-
-               echo alpha >alpha &&
-               git add alpha &&
-               git commit -m "add alpha" &&
-               git checkout -q -b not-master
-               ) &&
-
-               (
-               hg_clone_$x gitrepo-$x hgrepo-$x &&
-               cd hgrepo-$x &&
-
-               hg co master &&
-               echo beta >beta &&
-               hg add beta &&
-               hg commit -u "test" -m "add beta" &&
-
-               echo gamma >>beta &&
-               hg commit -u "test <test@example.com> (comment)" -m "modify beta" &&
-
-               echo gamma >gamma &&
-               hg add gamma &&
-               hg commit -u "<test@example.com>" -m "add gamma" &&
-
-               echo delta >delta &&
-               hg add delta &&
-               hg commit -u "name<test@example.com>" -m "add delta" &&
-
-               echo epsilon >epsilon &&
-               hg add epsilon &&
-               hg commit -u "name <test@example.com" -m "add epsilon" &&
-
-               echo zeta >zeta &&
-               hg add zeta &&
-               hg commit -u " test " -m "add zeta" &&
-
-               echo eta >eta &&
-               hg add eta &&
-               hg commit -u "test < test@example.com >" -m "add eta" &&
-
-               echo theta >theta &&
-               hg add theta &&
-               hg commit -u "test >test@example.com>" -m "add theta" &&
-
-               echo iota >iota &&
-               hg add iota &&
-               hg commit -u "test <test <at> example <dot> com>" -m "add iota"
-               ) &&
-
-               hg_push_$x hgrepo-$x gitrepo-$x &&
-               hg_clone_$x gitrepo-$x hgrepo2-$x &&
-
-               hg_log hgrepo2-$x >"hg-log-$x" &&
-               git_log gitrepo-$x >"git-log-$x"
-       done &&
-
-       test_cmp hg-log-hg hg-log-git &&
-       test_cmp git-log-hg git-log-git
-'
-
-test_expect_success 'hg branch' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       for x in hg git
-       do
-               (
-               git init -q gitrepo-$x &&
-               cd gitrepo-$x &&
-
-               echo alpha >alpha &&
-               git add alpha &&
-               git commit -q -m "add alpha" &&
-               git checkout -q -b not-master
-               ) &&
-
-               (
-               hg_clone_$x gitrepo-$x hgrepo-$x &&
-
-               cd hgrepo-$x &&
-               hg -q co master &&
-               hg mv alpha beta &&
-               hg -q commit -m "rename alpha to beta" &&
-               hg branch gamma | grep -v "permanent and global" &&
-               hg -q commit -m "started branch gamma"
-               ) &&
-
-               hg_push_$x hgrepo-$x gitrepo-$x &&
-               hg_clone_$x gitrepo-$x hgrepo2-$x &&
-
-               hg_log hgrepo2-$x >"hg-log-$x" &&
-               git_log gitrepo-$x >"git-log-$x"
-       done &&
-
-       test_cmp hg-log-hg hg-log-git &&
-       test_cmp git-log-hg git-log-git
-'
-
-test_expect_success 'hg tags' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       for x in hg git
-       do
-               (
-               git init -q gitrepo-$x &&
-               cd gitrepo-$x &&
-
-               echo alpha >alpha &&
-               git add alpha &&
-               git commit -m "add alpha" &&
-               git checkout -q -b not-master
-               ) &&
-
-               (
-               hg_clone_$x gitrepo-$x hgrepo-$x &&
-
-               cd hgrepo-$x &&
-               hg co master &&
-               hg tag alpha
-               ) &&
-
-               hg_push_$x hgrepo-$x gitrepo-$x &&
-               hg_clone_$x gitrepo-$x hgrepo2-$x &&
-
-               (
-               git --git-dir=gitrepo-$x/.git tag -l &&
-               hg_log hgrepo2-$x &&
-               cat hgrepo2-$x/.hgtags
-               ) >"output-$x"
-       done &&
-
-       test_cmp output-hg output-git
-'
-
-test_done
diff --git a/contrib/remote-helpers/test-hg.sh b/contrib/remote-helpers/test-hg.sh
deleted file mode 100755 (executable)
index 7d90056..0000000
+++ /dev/null
@@ -1,848 +0,0 @@
-#!/bin/sh
-#
-# Copyright (c) 2012 Felipe Contreras
-#
-# Base commands from hg-git tests:
-# https://bitbucket.org/durin42/hg-git/src
-#
-
-test_description='Test remote-hg'
-
-test -n "$TEST_DIRECTORY" || TEST_DIRECTORY=${0%/*}/../../t
-. "$TEST_DIRECTORY"/test-lib.sh
-
-if ! test_have_prereq PYTHON
-then
-       skip_all='skipping remote-hg tests; python not available'
-       test_done
-fi
-
-if ! python -c 'import mercurial'
-then
-       skip_all='skipping remote-hg tests; mercurial not available'
-       test_done
-fi
-
-check () {
-       echo $3 >expected &&
-       git --git-dir=$1/.git log --format='%s' -1 $2 >actual
-       test_cmp expected actual
-}
-
-check_branch () {
-       if test -n "$3"
-       then
-               echo $3 >expected &&
-               hg -R $1 log -r $2 --template '{desc}\n' >actual &&
-               test_cmp expected actual
-       else
-               hg -R $1 branches >out &&
-               ! grep $2 out
-       fi
-}
-
-check_bookmark () {
-       if test -n "$3"
-       then
-               echo $3 >expected &&
-               hg -R $1 log -r "bookmark('$2')" --template '{desc}\n' >actual &&
-               test_cmp expected actual
-       else
-               hg -R $1 bookmarks >out &&
-               ! grep $2 out
-       fi
-}
-
-check_push () {
-       expected_ret=$1 ret=0 ref_ret=0
-
-       shift
-       git push origin "$@" 2>error
-       ret=$?
-       cat error
-
-       while IFS=':' read branch kind
-       do
-               case "$kind" in
-               'new')
-                       grep "^ \* \[new branch\] *${branch} -> ${branch}$" error || ref_ret=1
-                       ;;
-               'non-fast-forward')
-                       grep "^ ! \[rejected\] *${branch} -> ${branch} (non-fast-forward)$" error || ref_ret=1
-                       ;;
-               'fetch-first')
-                       grep "^ ! \[rejected\] *${branch} -> ${branch} (fetch first)$" error || ref_ret=1
-                       ;;
-               'forced-update')
-                       grep "^ + [a-f0-9]*\.\.\.[a-f0-9]* *${branch} -> ${branch} (forced update)$" error || ref_ret=1
-                       ;;
-               '')
-                       grep "^   [a-f0-9]*\.\.[a-f0-9]* *${branch} -> ${branch}$" error || ref_ret=1
-                       ;;
-               esac
-               test $ref_ret -ne 0 && echo "match for '$branch' failed" && break
-       done
-
-       if test $expected_ret -ne $ret || test $ref_ret -ne 0
-       then
-               return 1
-       fi
-
-       return 0
-}
-
-setup () {
-       (
-       echo "[ui]"
-       echo "username = H G Wells <wells@example.com>"
-       echo "[extensions]"
-       echo "mq ="
-       ) >>"$HOME"/.hgrc &&
-
-       GIT_AUTHOR_DATE="2007-01-01 00:00:00 +0230" &&
-       GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE" &&
-       export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
-}
-
-setup
-
-test_expect_success 'cloning' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-       echo zero >content &&
-       hg add content &&
-       hg commit -m zero
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-       check gitrepo HEAD zero
-'
-
-test_expect_success 'cloning with branches' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       cd hgrepo &&
-       hg branch next &&
-       echo next >content &&
-       hg commit -m next
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-       check gitrepo origin/branches/next next
-'
-
-test_expect_success 'cloning with bookmarks' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       cd hgrepo &&
-       hg checkout default &&
-       hg bookmark feature-a &&
-       echo feature-a >content &&
-       hg commit -m feature-a
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-       check gitrepo origin/feature-a feature-a
-'
-
-test_expect_success 'update bookmark' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       cd hgrepo &&
-       hg bookmark devel
-       ) &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-       git checkout --quiet devel &&
-       echo devel >content &&
-       git commit -a -m devel &&
-       git push --quiet
-       ) &&
-
-       check_bookmark hgrepo devel devel
-'
-
-test_expect_success 'new bookmark' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-       git checkout --quiet -b feature-b &&
-       echo feature-b >content &&
-       git commit -a -m feature-b &&
-       git push --quiet origin feature-b
-       ) &&
-
-       check_bookmark hgrepo feature-b feature-b
-'
-
-# cleanup previous stuff
-rm -rf hgrepo
-
-author_test () {
-       echo $1 >>content &&
-       hg commit -u "$2" -m "add $1" &&
-       echo "$3" >>../expected
-}
-
-test_expect_success 'authors' '
-       test_when_finished "rm -rf hgrepo gitrepo" &&
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-
-       touch content &&
-       hg add content &&
-
-       >../expected &&
-       author_test alpha "" "H G Wells <wells@example.com>" &&
-       author_test beta "beta" "beta <unknown>" &&
-       author_test gamma "gamma <test@example.com> (comment)" "gamma <test@example.com>" &&
-       author_test delta "<delta@example.com>" "Unknown <delta@example.com>" &&
-       author_test epsilon "epsilon<test@example.com>" "epsilon <test@example.com>" &&
-       author_test zeta "zeta <test@example.com" "zeta <test@example.com>" &&
-       author_test eta " eta " "eta <unknown>" &&
-       author_test theta "theta < test@example.com >" "theta <test@example.com>" &&
-       author_test iota "iota >test@example.com>" "iota <test@example.com>" &&
-       author_test kappa "kappa < test <at> example <dot> com>" "kappa <unknown>" &&
-       author_test lambda "lambda@example.com" "Unknown <lambda@example.com>" &&
-       author_test mu "mu.mu@example.com" "Unknown <mu.mu@example.com>"
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-       git --git-dir=gitrepo/.git log --reverse --format="%an <%ae>" >actual &&
-
-       test_cmp expected actual
-'
-
-test_expect_success 'strip' '
-       test_when_finished "rm -rf hgrepo gitrepo" &&
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-
-       echo one >>content &&
-       hg add content &&
-       hg commit -m one &&
-
-       echo two >>content &&
-       hg commit -m two
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-
-       (
-       cd hgrepo &&
-       hg strip 1 &&
-
-       echo three >>content &&
-       hg commit -m three &&
-
-       echo four >>content &&
-       hg commit -m four
-       ) &&
-
-       (
-       cd gitrepo &&
-       git fetch &&
-       git log --format="%s" origin/master >../actual
-       ) &&
-
-       hg -R hgrepo log --template "{desc}\n" >expected &&
-       test_cmp actual expected
-'
-
-test_expect_success 'remote push with master bookmark' '
-       test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-       echo zero >content &&
-       hg add content &&
-       hg commit -m zero &&
-       hg bookmark master &&
-       echo one >content &&
-       hg commit -m one
-       ) &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-       echo two >content &&
-       git commit -a -m two &&
-       git push
-       ) &&
-
-       check_branch hgrepo default two
-'
-
-cat >expected <<\EOF
-changeset:   0:6e2126489d3d
-tag:         tip
-user:        A U Thor <author@example.com>
-date:        Mon Jan 01 00:00:00 2007 +0230
-summary:     one
-
-EOF
-
-test_expect_success 'remote push from master branch' '
-       test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-       hg init hgrepo &&
-
-       (
-       git init gitrepo &&
-       cd gitrepo &&
-       git remote add origin "hg::../hgrepo" &&
-       echo one >content &&
-       git add content &&
-       git commit -a -m one &&
-       git push origin master
-       ) &&
-
-       hg -R hgrepo log >actual &&
-       cat actual &&
-       test_cmp expected actual &&
-
-       check_branch hgrepo default one
-'
-
-GIT_REMOTE_HG_TEST_REMOTE=1
-export GIT_REMOTE_HG_TEST_REMOTE
-
-test_expect_success 'remote cloning' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-       echo zero >content &&
-       hg add content &&
-       hg commit -m zero
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-       check gitrepo HEAD zero
-'
-
-test_expect_success 'moving remote clone' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       mv gitrepo gitrepo2 &&
-       cd gitrepo2 &&
-       git fetch
-       )
-'
-
-test_expect_success 'remote update bookmark' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       cd hgrepo &&
-       hg bookmark devel
-       ) &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-       git checkout --quiet devel &&
-       echo devel >content &&
-       git commit -a -m devel &&
-       git push --quiet
-       ) &&
-
-       check_bookmark hgrepo devel devel
-'
-
-test_expect_success 'remote new bookmark' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-       git checkout --quiet -b feature-b &&
-       echo feature-b >content &&
-       git commit -a -m feature-b &&
-       git push --quiet origin feature-b
-       ) &&
-
-       check_bookmark hgrepo feature-b feature-b
-'
-
-test_expect_success 'remote push diverged' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       git clone "hg::hgrepo" gitrepo &&
-
-       (
-       cd hgrepo &&
-       hg checkout default &&
-       echo bump >content &&
-       hg commit -m bump
-       ) &&
-
-       (
-       cd gitrepo &&
-       echo diverge >content &&
-       git commit -a -m diverged &&
-       check_push 1 <<-\EOF
-       master:non-fast-forward
-       EOF
-       ) &&
-
-       check_branch hgrepo default bump
-'
-
-test_expect_success 'remote update bookmark diverge' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       cd hgrepo &&
-       hg checkout tip^ &&
-       hg bookmark diverge
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-
-       (
-       cd hgrepo &&
-       echo "bump bookmark" >content &&
-       hg commit -m "bump bookmark"
-       ) &&
-
-       (
-       cd gitrepo &&
-       git checkout --quiet diverge &&
-       echo diverge >content &&
-       git commit -a -m diverge &&
-       check_push 1 <<-\EOF
-       diverge:fetch-first
-       EOF
-       ) &&
-
-       check_bookmark hgrepo diverge "bump bookmark"
-'
-
-test_expect_success 'remote new bookmark multiple branch head' '
-       test_when_finished "rm -rf gitrepo*" &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-       git checkout --quiet -b feature-c HEAD^ &&
-       echo feature-c >content &&
-       git commit -a -m feature-c &&
-       git push --quiet origin feature-c
-       ) &&
-
-       check_bookmark hgrepo feature-c feature-c
-'
-
-# cleanup previous stuff
-rm -rf hgrepo
-
-test_expect_success 'fetch special filenames' '
-       test_when_finished "rm -rf hgrepo gitrepo && LC_ALL=C" &&
-
-       LC_ALL=en_US.UTF-8
-       export LC_ALL
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-
-       echo test >> "æ rø" &&
-       hg add "æ rø" &&
-       echo test >> "ø~?" &&
-       hg add "ø~?" &&
-       hg commit -m add-utf-8 &&
-       echo test >> "æ rø" &&
-       hg commit -m test-utf-8 &&
-       hg rm "ø~?" &&
-       hg mv "æ rø" "ø~?" &&
-       hg commit -m hg-mv-utf-8
-       ) &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-       git -c core.quotepath=false ls-files > ../actual
-       ) &&
-       echo "ø~?" > expected &&
-       test_cmp expected actual
-'
-
-test_expect_success 'push special filenames' '
-       test_when_finished "rm -rf hgrepo gitrepo && LC_ALL=C" &&
-
-       mkdir -p tmp && cd tmp &&
-
-       LC_ALL=en_US.UTF-8
-       export LC_ALL
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-
-       echo one >> content &&
-       hg add content &&
-       hg commit -m one
-       ) &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-
-       echo test >> "æ rø" &&
-       git add "æ rø" &&
-       git commit -m utf-8 &&
-
-       git push
-       ) &&
-
-       (cd hgrepo &&
-       hg update &&
-       hg manifest > ../actual
-       ) &&
-
-       printf "content\næ rø\n" > expected &&
-       test_cmp expected actual
-'
-
-setup_big_push () {
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-       echo zero >content &&
-       hg add content &&
-       hg commit -m zero &&
-       hg bookmark bad_bmark1 &&
-       echo one >content &&
-       hg commit -m one &&
-       hg bookmark bad_bmark2 &&
-       hg bookmark good_bmark &&
-       hg bookmark -i good_bmark &&
-       hg -q branch good_branch &&
-       echo "good branch" >content &&
-       hg commit -m "good branch" &&
-       hg -q branch bad_branch &&
-       echo "bad branch" >content &&
-       hg commit -m "bad branch"
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-
-       (
-       cd gitrepo &&
-       echo two >content &&
-       git commit -q -a -m two &&
-
-       git checkout -q good_bmark &&
-       echo three >content &&
-       git commit -q -a -m three &&
-
-       git checkout -q bad_bmark1 &&
-       git reset --hard HEAD^ &&
-       echo four >content &&
-       git commit -q -a -m four &&
-
-       git checkout -q bad_bmark2 &&
-       git reset --hard HEAD^ &&
-       echo five >content &&
-       git commit -q -a -m five &&
-
-       git checkout -q -b new_bmark master &&
-       echo six >content &&
-       git commit -q -a -m six &&
-
-       git checkout -q branches/good_branch &&
-       echo seven >content &&
-       git commit -q -a -m seven &&
-       echo eight >content &&
-       git commit -q -a -m eight &&
-
-       git checkout -q branches/bad_branch &&
-       git reset --hard HEAD^ &&
-       echo nine >content &&
-       git commit -q -a -m nine &&
-
-       git checkout -q -b branches/new_branch master &&
-       echo ten >content &&
-       git commit -q -a -m ten
-       )
-}
-
-test_expect_success 'remote big push' '
-       test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-       setup_big_push
-
-       (
-       cd gitrepo &&
-
-       check_push 1 --all <<-\EOF
-       master
-       good_bmark
-       branches/good_branch
-       new_bmark:new
-       branches/new_branch:new
-       bad_bmark1:non-fast-forward
-       bad_bmark2:non-fast-forward
-       branches/bad_branch:non-fast-forward
-       EOF
-       ) &&
-
-       check_branch hgrepo default one &&
-       check_branch hgrepo good_branch "good branch" &&
-       check_branch hgrepo bad_branch "bad branch" &&
-       check_branch hgrepo new_branch '' &&
-       check_bookmark hgrepo good_bmark one &&
-       check_bookmark hgrepo bad_bmark1 one &&
-       check_bookmark hgrepo bad_bmark2 one &&
-       check_bookmark hgrepo new_bmark ''
-'
-
-test_expect_success 'remote big push fetch first' '
-       test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-       echo zero >content &&
-       hg add content &&
-       hg commit -m zero &&
-       hg bookmark bad_bmark &&
-       hg bookmark good_bmark &&
-       hg bookmark -i good_bmark &&
-       hg -q branch good_branch &&
-       echo "good branch" >content &&
-       hg commit -m "good branch" &&
-       hg -q branch bad_branch &&
-       echo "bad branch" >content &&
-       hg commit -m "bad branch"
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-
-       (
-       cd hgrepo &&
-       hg bookmark -f bad_bmark &&
-       echo update_bmark >content &&
-       hg commit -m "update bmark"
-       ) &&
-
-       (
-       cd gitrepo &&
-       echo two >content &&
-       git commit -q -a -m two &&
-
-       git checkout -q good_bmark &&
-       echo three >content &&
-       git commit -q -a -m three &&
-
-       git checkout -q bad_bmark &&
-       echo four >content &&
-       git commit -q -a -m four &&
-
-       git checkout -q branches/bad_branch &&
-       echo five >content &&
-       git commit -q -a -m five &&
-
-       check_push 1 --all <<-\EOF &&
-       master
-       good_bmark
-       bad_bmark:fetch-first
-       branches/bad_branch:festch-first
-       EOF
-
-       git fetch &&
-
-       check_push 1 --all <<-\EOF
-       master
-       good_bmark
-       bad_bmark:non-fast-forward
-       branches/bad_branch:non-fast-forward
-       EOF
-       )
-'
-
-test_expect_success 'remote big push force' '
-       test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-       setup_big_push
-
-       (
-       cd gitrepo &&
-
-       check_push 0 --force --all <<-\EOF
-       master
-       good_bmark
-       branches/good_branch
-       new_bmark:new
-       branches/new_branch:new
-       bad_bmark1:forced-update
-       bad_bmark2:forced-update
-       branches/bad_branch:forced-update
-       EOF
-       ) &&
-
-       check_branch hgrepo default six &&
-       check_branch hgrepo good_branch eight &&
-       check_branch hgrepo bad_branch nine &&
-       check_branch hgrepo new_branch ten &&
-       check_bookmark hgrepo good_bmark three &&
-       check_bookmark hgrepo bad_bmark1 four &&
-       check_bookmark hgrepo bad_bmark2 five &&
-       check_bookmark hgrepo new_bmark six
-'
-
-test_expect_success 'remote big push dry-run' '
-       test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-       setup_big_push
-
-       (
-       cd gitrepo &&
-
-       check_push 1 --dry-run --all <<-\EOF &&
-       master
-       good_bmark
-       branches/good_branch
-       new_bmark:new
-       branches/new_branch:new
-       bad_bmark1:non-fast-forward
-       bad_bmark2:non-fast-forward
-       branches/bad_branch:non-fast-forward
-       EOF
-
-       check_push 0 --dry-run master good_bmark new_bmark branches/good_branch branches/new_branch <<-\EOF
-       master
-       good_bmark
-       branches/good_branch
-       new_bmark:new
-       branches/new_branch:new
-       EOF
-       ) &&
-
-       check_branch hgrepo default one &&
-       check_branch hgrepo good_branch "good branch" &&
-       check_branch hgrepo bad_branch "bad branch" &&
-       check_branch hgrepo new_branch '' &&
-       check_bookmark hgrepo good_bmark one &&
-       check_bookmark hgrepo bad_bmark1 one &&
-       check_bookmark hgrepo bad_bmark2 one &&
-       check_bookmark hgrepo new_bmark ''
-'
-
-test_expect_success 'remote double failed push' '
-       test_when_finished "rm -rf hgrepo gitrepo*" &&
-
-       (
-       hg init hgrepo &&
-       cd hgrepo &&
-       echo zero >content &&
-       hg add content &&
-       hg commit -m zero &&
-       echo one >content &&
-       hg commit -m one
-       ) &&
-
-       (
-       git clone "hg::hgrepo" gitrepo &&
-       cd gitrepo &&
-       git reset --hard HEAD^ &&
-       echo two >content &&
-       git commit -a -m two &&
-       test_expect_code 1 git push &&
-       test_expect_code 1 git push
-       )
-'
-
-test_expect_success 'clone remote with master null bookmark, then push to the bookmark' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       hg init hgrepo &&
-       (
-               cd hgrepo &&
-               echo a >a &&
-               hg add a &&
-               hg commit -m a &&
-               hg bookmark -r null master
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-       check gitrepo HEAD a &&
-       (
-               cd gitrepo &&
-               git checkout --quiet -b master &&
-               echo b >b &&
-               git add b &&
-               git commit -m b &&
-               git push origin master
-       )
-'
-
-test_expect_success 'clone remote with default null bookmark, then push to the bookmark' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       hg init hgrepo &&
-       (
-               cd hgrepo &&
-               echo a >a &&
-               hg add a &&
-               hg commit -m a &&
-               hg bookmark -r null -f default
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-       check gitrepo HEAD a &&
-       (
-               cd gitrepo &&
-               git checkout --quiet -b default &&
-               echo b >b &&
-               git add b &&
-               git commit -m b &&
-               git push origin default
-       )
-'
-
-test_expect_success 'clone remote with generic null bookmark, then push to the bookmark' '
-       test_when_finished "rm -rf gitrepo* hgrepo*" &&
-
-       hg init hgrepo &&
-       (
-               cd hgrepo &&
-               echo a >a &&
-               hg add a &&
-               hg commit -m a &&
-               hg bookmark -r null bmark
-       ) &&
-
-       git clone "hg::hgrepo" gitrepo &&
-       check gitrepo HEAD a &&
-       (
-               cd gitrepo &&
-               git checkout --quiet -b bmark &&
-               git remote -v &&
-               echo b >b &&
-               git add b &&
-               git commit -m b &&
-               git push origin bmark
-       )
-'
-
-test_done
index 4030a168986d29bdbb2cd982a2e819ce009580f6..d888d4516114c719e46ab7f2aeb24e63618b7fac 100644 (file)
@@ -3,17 +3,23 @@
 
 prefix ?= /usr/local
 mandir ?= $(prefix)/share/man
-libexecdir ?= $(prefix)/libexec/git-core
-gitdir ?= $(shell git --exec-path)
+gitexecdir ?= $(prefix)/libexec/git-core
 man1dir ?= $(mandir)/man1
 
-gitver ?= $(word 3,$(shell git --version))
+../../GIT-VERSION-FILE: FORCE
+       $(MAKE) -C ../../ GIT-VERSION-FILE
+
+-include ../../GIT-VERSION-FILE
 
 # this should be set to a 'standard' bsd-type install program
-INSTALL ?= install
+INSTALL  ?= install
+RM       ?= rm -f
+
+ASCIIDOC = asciidoc
+XMLTO    = xmlto
 
-ASCIIDOC_CONF      = ../../Documentation/asciidoc.conf
-MANPAGE_NORMAL_XSL =  ../../Documentation/manpage-normal.xsl
+ASCIIDOC_CONF = ../../Documentation/asciidoc.conf
+MANPAGE_XSL   = ../../Documentation/manpage-normal.xsl
 
 GIT_SUBTREE_SH := git-subtree.sh
 GIT_SUBTREE    := git-subtree
@@ -31,8 +37,8 @@ $(GIT_SUBTREE): $(GIT_SUBTREE_SH)
 doc: $(GIT_SUBTREE_DOC) $(GIT_SUBTREE_HTML)
 
 install: $(GIT_SUBTREE)
-       $(INSTALL) -d -m 755 $(DESTDIR)$(libexecdir)
-       $(INSTALL) -m 755 $(GIT_SUBTREE) $(DESTDIR)$(libexecdir)
+       $(INSTALL) -d -m 755 $(DESTDIR)$(gitexecdir)
+       $(INSTALL) -m 755 $(GIT_SUBTREE) $(DESTDIR)$(gitexecdir)
 
 install-doc: install-man
 
@@ -41,19 +47,21 @@ install-man: $(GIT_SUBTREE_DOC)
        $(INSTALL) -m 644 $^ $(DESTDIR)$(man1dir)
 
 $(GIT_SUBTREE_DOC): $(GIT_SUBTREE_XML)
-       xmlto -m $(MANPAGE_NORMAL_XSL)  man $^
+       $(XMLTO) -m $(MANPAGE_XSL) man $^
 
 $(GIT_SUBTREE_XML): $(GIT_SUBTREE_TXT)
-       asciidoc -b docbook -d manpage -f $(ASCIIDOC_CONF) \
-               -agit_version=$(gitver) $^
+       $(ASCIIDOC) -b docbook -d manpage -f $(ASCIIDOC_CONF) \
+               -agit_version=$(GIT_VERSION) $^
 
 $(GIT_SUBTREE_HTML): $(GIT_SUBTREE_TXT)
-       asciidoc -b xhtml11 -d manpage -f $(ASCIIDOC_CONF) \
-               -agit_version=$(gitver) $^
+       $(ASCIIDOC) -b xhtml11 -d manpage -f $(ASCIIDOC_CONF) \
+               -agit_version=$(GIT_VERSION) $^
 
 test:
        $(MAKE) -C t/ test
 
 clean:
-       rm -f *~ *.xml *.html *.1
-       rm -rf subproj mainline
+       $(RM) $(GIT_SUBTREE)
+       $(RM) *.xml *.html *.1
+
+.PHONY: FORCE
index db925ca76991c635ea53fe7f38d6608d08dfc4d5..fa1a5839af2d0c423adb51238fb330f555dc4dff 100755 (executable)
@@ -558,8 +558,9 @@ cmd_add_commit()
                commit=$(add_squashed_msg "$rev" "$dir" |
                         git commit-tree $tree $headp -p "$rev") || exit $?
        else
+               revp=$(peel_committish "$rev") &&
                commit=$(add_msg "$dir" "$headrev" "$rev" |
-                        git commit-tree $tree $headp -p "$rev") || exit $?
+                        git commit-tree $tree $headp -p "$revp") || exit $?
        fi
        git reset "$commit" || exit $?
        
index 66ce4b07c2dc2d2d56dc260883f86d8672d2ac69..b22b710c262ed6c55e97859aac8a2fd1c5adb219 100755 (executable)
@@ -76,7 +76,7 @@ test_expect_success 'add sub1' '
 
 # Save this hash for testing later.
 
-subdir_hash=`git rev-parse HEAD`
+subdir_hash=$(git rev-parse HEAD)
 
 test_expect_success 'add sub2' '
         create sub2 &&
index 4e78a1c3cda15659256c7aa64eb98cab7737c61f..11ac6f692733fbfde96a44cc553002ad748065db 100755 (executable)
@@ -5,53 +5,64 @@
 To simulate incremental imports the environment variable SVNRMAX can be set
 to the highest revision that should be available.
 """
-import sys, os
+import sys
+import os
 
 if sys.hexversion < 0x02040000:
-        # The limiter is the ValueError() calls. This may be too conservative
-        sys.stderr.write("svnrdump-sim.py: requires Python 2.4 or later.\n")
-        sys.exit(1)
+    # The limiter is the ValueError() calls. This may be too conservative
+    sys.stderr.write("svnrdump-sim.py: requires Python 2.4 or later.\n")
+    sys.exit(1)
+
 
 def getrevlimit():
-        var = 'SVNRMAX'
-        if var in os.environ:
-                return os.environ[var]
-        return None
+    var = 'SVNRMAX'
+    if var in os.environ:
+        return os.environ[var]
+    return None
+
 
 def writedump(url, lower, upper):
-        if url.startswith('sim://'):
-                filename = url[6:]
-                if filename[-1] == '/': filename = filename[:-1] #remove terminating slash
-        else:
-                raise ValueError('sim:// url required')
-        f = open(filename, 'r');
-        state = 'header'
-        wroterev = False
-        while(True):
-                l = f.readline()
-                if l == '': break
-                if state == 'header' and l.startswith('Revision-number: '):
-                        state = 'prefix'
-                if state == 'prefix' and l == 'Revision-number: %s\n' % lower:
-                        state = 'selection'
-                if not upper == 'HEAD' and state == 'selection' and l == 'Revision-number: %s\n' % upper:
-                        break;
+    if url.startswith('sim://'):
+        filename = url[6:]
+        if filename[-1] == '/':
+            filename = filename[:-1]  # remove terminating slash
+    else:
+        raise ValueError('sim:// url required')
+    f = open(filename, 'r')
+    state = 'header'
+    wroterev = False
+    while(True):
+        l = f.readline()
+        if l == '':
+            break
+        if state == 'header' and l.startswith('Revision-number: '):
+            state = 'prefix'
+        if state == 'prefix' and l == 'Revision-number: %s\n' % lower:
+            state = 'selection'
+        if not upper == 'HEAD' and state == 'selection' and \
+                l == 'Revision-number: %s\n' % upper:
+            break
 
-                if state == 'header' or state == 'selection':
-                        if state == 'selection': wroterev = True
-                        sys.stdout.write(l)
-        return wroterev
+        if state == 'header' or state == 'selection':
+            if state == 'selection':
+                wroterev = True
+            sys.stdout.write(l)
+    return wroterev
 
 if __name__ == "__main__":
-        if not (len(sys.argv) in (3, 4, 5)):
-                print("usage: %s dump URL -rLOWER:UPPER")
-                sys.exit(1)
-        if not sys.argv[1] == 'dump': raise NotImplementedError('only "dump" is suppported.')
-        url = sys.argv[2]
-        r = ('0', 'HEAD')
-        if len(sys.argv) == 4 and sys.argv[3][0:2] == '-r':
-                r = sys.argv[3][2:].lstrip().split(':')
-        if not getrevlimit() is None: r[1] = getrevlimit()
-        if writedump(url, r[0], r[1]): ret = 0
-        else: ret = 1
-        sys.exit(ret)
+    if not (len(sys.argv) in (3, 4, 5)):
+        print("usage: %s dump URL -rLOWER:UPPER")
+        sys.exit(1)
+    if not sys.argv[1] == 'dump':
+        raise NotImplementedError('only "dump" is suppported.')
+    url = sys.argv[2]
+    r = ('0', 'HEAD')
+    if len(sys.argv) == 4 and sys.argv[3][0:2] == '-r':
+        r = sys.argv[3][2:].lstrip().split(':')
+    if not getrevlimit() is None:
+        r[1] = getrevlimit()
+    if writedump(url, r[0], r[1]):
+        ret = 0
+    else:
+        ret = 1
+    sys.exit(ret)
index 5eb4a5164397e3a34be10690025a9cd472261db9..8dc73ece15a075bb60971da577d2da272c8f7c14 100755 (executable)
@@ -10,7 +10,7 @@ CONFFILE=~/.appprc
 
 SEP="-=-=-=-=-=-=-=-=-=# Don't remove this line #=-=-=-=-=-=-=-=-=-"
 if [ -e "$CONFFILE" ] ; then
-       LAST_DIR=`grep -m 1 "^LAST_DIR=" "${CONFFILE}"|sed -e 's/^LAST_DIR=//'`
+       LAST_DIR=$(grep -m 1 "^LAST_DIR=" "${CONFFILE}"|sed -e 's/^LAST_DIR=//')
        cd "${LAST_DIR}"
 else
        cd > /dev/null
@@ -25,11 +25,11 @@ fi
 
 cd - > /dev/null
 
-SUBJECT=`sed -n -e '/^Subject: /p' "${PATCH}"`
-HEADERS=`sed -e '/^'"${SEP}"'$/,$d' $1`
-BODY=`sed -e "1,/${SEP}/d" $1`
-CMT_MSG=`sed -e '1,/^$/d' -e '/^---$/,$d' "${PATCH}"`
-DIFF=`sed -e '1,/^---$/d' "${PATCH}"`
+SUBJECT=$(sed -n -e '/^Subject: /p' "${PATCH}")
+HEADERS=$(sed -e '/^'"${SEP}"'$/,$d' $1)
+BODY=$(sed -e "1,/${SEP}/d" $1)
+CMT_MSG=$(sed -e '1,/^$/d' -e '/^---$/,$d' "${PATCH}")
+DIFF=$(sed -e '1,/^---$/d' "${PATCH}")
 
 CCS=`echo -e "$CMT_MSG\n$HEADERS" | sed -n -e 's/^Cc: \(.*\)$/\1,/gp' \
        -e 's/^Signed-off-by: \(.*\)/\1,/gp'`
@@ -48,7 +48,7 @@ if [ "x${BODY}x" != "xx" ] ; then
 fi
 echo "$DIFF" >> $1
 
-LAST_DIR=`dirname "${PATCH}"`
+LAST_DIR=$(dirname "${PATCH}")
 
 grep -v "^LAST_DIR=" "${CONFFILE}" > "${CONFFILE}_"
 echo "LAST_DIR=${LAST_DIR}" >> "${CONFFILE}_"
diff --git a/contrib/vim/README b/contrib/vim/README
deleted file mode 100644 (file)
index 8f16d06..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-Syntax highlighting for git commit messages, config files, etc. is
-included with the vim distribution as of vim 7.2, and should work
-automatically.
-
-If you have an older version of vim, you can get the latest syntax
-files from the vim project:
-
-  http://ftp.vim.org/pub/vim/runtime/syntax/git.vim
-  http://ftp.vim.org/pub/vim/runtime/syntax/gitcommit.vim
-  http://ftp.vim.org/pub/vim/runtime/syntax/gitconfig.vim
-  http://ftp.vim.org/pub/vim/runtime/syntax/gitrebase.vim
-  http://ftp.vim.org/pub/vim/runtime/syntax/gitsendemail.vim
-
-These files are also available via FTP at the same location.
-
-To install:
-
-  1. Copy these files to vim's syntax directory $HOME/.vim/syntax
-  2. To auto-detect the editing of various git-related filetypes:
-
-       $ curl http://ftp.vim.org/pub/vim/runtime/filetype.vim |
-               sed -ne '/^" Git$/, /^$/ p' >>$HOME/.vim/filetype.vim
diff --git a/diff.c b/diff.c
index f72769a1c492dfcac501032c54c3fb2ac0a4343e..f66716fab4b477c58434126b4aaa4b4372ce163a 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -2880,6 +2880,16 @@ static struct diff_tempfile *prepare_temp_file(const char *name,
        return temp;
 }
 
+static void add_external_diff_name(struct argv_array *argv,
+                                  const char *name,
+                                  struct diff_filespec *df)
+{
+       struct diff_tempfile *temp = prepare_temp_file(name, df);
+       argv_array_push(argv, temp->name);
+       argv_array_push(argv, temp->hex);
+       argv_array_push(argv, temp->mode);
+}
+
 /* An external diff command takes:
  *
  * diff-cmd name infile1 infile1-sha1 infile1-mode \
@@ -2896,48 +2906,32 @@ static void run_external_diff(const char *pgm,
                              struct diff_options *o)
 {
        struct argv_array argv = ARGV_ARRAY_INIT;
-       int retval;
+       struct argv_array env = ARGV_ARRAY_INIT;
        struct diff_queue_struct *q = &diff_queued_diff;
-       const char *env[3] = { NULL };
-       char env_counter[50];
-       char env_total[50];
+
+       argv_array_push(&argv, pgm);
+       argv_array_push(&argv, name);
 
        if (one && two) {
-               struct diff_tempfile *temp_one, *temp_two;
-               const char *othername = (other ? other : name);
-               temp_one = prepare_temp_file(name, one);
-               temp_two = prepare_temp_file(othername, two);
-               argv_array_push(&argv, pgm);
-               argv_array_push(&argv, name);
-               argv_array_push(&argv, temp_one->name);
-               argv_array_push(&argv, temp_one->hex);
-               argv_array_push(&argv, temp_one->mode);
-               argv_array_push(&argv, temp_two->name);
-               argv_array_push(&argv, temp_two->hex);
-               argv_array_push(&argv, temp_two->mode);
-               if (other) {
+               add_external_diff_name(&argv, name, one);
+               if (!other)
+                       add_external_diff_name(&argv, name, two);
+               else {
+                       add_external_diff_name(&argv, other, two);
                        argv_array_push(&argv, other);
                        argv_array_push(&argv, xfrm_msg);
                }
-       } else {
-               argv_array_push(&argv, pgm);
-               argv_array_push(&argv, name);
        }
-       fflush(NULL);
 
-       env[0] = env_counter;
-       snprintf(env_counter, sizeof(env_counter), "GIT_DIFF_PATH_COUNTER=%d",
-                ++o->diff_path_counter);
-       env[1] = env_total;
-       snprintf(env_total, sizeof(env_total), "GIT_DIFF_PATH_TOTAL=%d", q->nr);
+       argv_array_pushf(&env, "GIT_DIFF_PATH_COUNTER=%d", ++o->diff_path_counter);
+       argv_array_pushf(&env, "GIT_DIFF_PATH_TOTAL=%d", q->nr);
+
+       if (run_command_v_opt_cd_env(argv.argv, RUN_USING_SHELL, NULL, env.argv))
+               die(_("external diff died, stopping at %s"), name);
 
-       retval = run_command_v_opt_cd_env(argv.argv, RUN_USING_SHELL, NULL, env);
        remove_tempfile();
        argv_array_clear(&argv);
-       if (retval) {
-               fprintf(stderr, "external diff died, stopping at %s.\n", name);
-               exit(1);
-       }
+       argv_array_clear(&env);
 }
 
 static int similarity_index(struct diff_filepair *p)
@@ -3205,6 +3199,7 @@ void diff_setup(struct diff_options *options)
        options->context = diff_context_default;
        DIFF_OPT_SET(options, RENAME_EMPTY);
 
+       /* pathchange left =NULL by default */
        options->change = diff_change;
        options->add_remove = diff_addremove;
        options->use_color = diff_use_color_default;
@@ -4749,6 +4744,7 @@ void diffcore_fix_diff_index(struct diff_options *options)
 
 void diffcore_std(struct diff_options *options)
 {
+       /* NOTE please keep the following in sync with diff_tree_combined() */
        if (options->skip_stat_unmatch)
                diffcore_skip_stat_unmatch(options);
        if (!options->found_follow) {
diff --git a/diff.h b/diff.h
index a24a767db78d8e864175cf342f03fc48e159e06e..b4a624d235748bf13be44e7479f086880dcf574f 100644 (file)
--- a/diff.h
+++ b/diff.h
@@ -15,6 +15,10 @@ struct diff_filespec;
 struct userdiff_driver;
 struct sha1_array;
 struct commit;
+struct combine_diff_path;
+
+typedef int (*pathchange_fn_t)(struct diff_options *options,
+                struct combine_diff_path *path);
 
 typedef void (*change_fn_t)(struct diff_options *options,
                 unsigned old_mode, unsigned new_mode,
@@ -157,6 +161,7 @@ struct diff_options {
        int close_file;
 
        struct pathspec pathspec;
+       pathchange_fn_t pathchange;
        change_fn_t change;
        add_remove_fn_t add_remove;
        diff_format_fn_t format_callback;
@@ -189,8 +194,10 @@ const char *diff_line_prefix(struct diff_options *);
 
 extern const char mime_boundary_leader[];
 
-extern int diff_tree(struct tree_desc *t1, struct tree_desc *t2,
-                    const char *base, struct diff_options *opt);
+extern struct combine_diff_path *diff_tree_paths(
+       struct combine_diff_path *p, const unsigned char *sha1,
+       const unsigned char **parent_sha1, int nparent,
+       struct strbuf *base, struct diff_options *opt);
 extern int diff_tree_sha1(const unsigned char *old, const unsigned char *new,
                          const char *base, struct diff_options *opt);
 extern int diff_root_tree_sha1(const unsigned char *new, const char *base,
index f2de1ee9ada0c1211fe7e31da52011ec0825758d..c648ac3d3af1f86889ccc34e7f794683bd1951ea 100644 (file)
@@ -37,7 +37,7 @@ int core_compression_seen;
 int fsync_object_files;
 size_t packed_git_window_size = DEFAULT_PACKED_GIT_WINDOW_SIZE;
 size_t packed_git_limit = DEFAULT_PACKED_GIT_LIMIT;
-size_t delta_base_cache_limit = 16 * 1024 * 1024;
+size_t delta_base_cache_limit = 96 * 1024 * 1024;
 unsigned long big_file_threshold = 512 * 1024 * 1024;
 const char *pager_program;
 int pager_use_color = 1;
index f6d3a46622d1de2497b56274a255d7bca46117dd..7849d314051a1de351c9c985516135397042a091 100644 (file)
@@ -330,8 +330,12 @@ extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)))
  * trying to help gcc, anyway, it's OK; other compilers will fall back to
  * using the function as usual.
  */
-#if defined(__GNUC__) && ! defined(__clang__)
-#define error(...) (error(__VA_ARGS__), -1)
+#if defined(__GNUC__)
+static inline int const_error(void)
+{
+       return -1;
+}
+#define error(...) (error(__VA_ARGS__), const_error())
 #endif
 
 extern void set_die_routine(NORETURN_PTR void (*routine)(const char *err, va_list params));
@@ -521,6 +525,14 @@ extern void release_pack_memory(size_t);
 typedef void (*try_to_free_t)(size_t);
 extern try_to_free_t set_try_to_free_routine(try_to_free_t);
 
+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+# define xalloca(size)      (alloca(size))
+# define xalloca_free(p)    do {} while (0)
+#else
+# define xalloca(size)      (xmalloc(size))
+# define xalloca_free(p)    (free(p))
+#endif
 extern char *xstrdup(const char *str);
 extern void *xmalloc(size_t size);
 extern void *xmallocz(size_t size);
@@ -531,6 +543,7 @@ extern void *xcalloc(size_t nmemb, size_t size);
 extern void *xmmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
 extern ssize_t xread(int fd, void *buf, size_t len);
 extern ssize_t xwrite(int fd, const void *buf, size_t len);
+extern ssize_t xpread(int fd, void *buf, size_t len, off_t offset);
 extern int xdup(int fd);
 extern FILE *xfdopen(int fd, const char *mode);
 extern int xmkstemp(char *template);
index cf2209b4f201b990cffab6d454599b9fa6932fc0..6a8907e7b327d066c616f8f77c2bc2096d618e06 100755 (executable)
@@ -1283,7 +1283,7 @@ load_config 0
 apply_config
 
 # v1.7.0 introduced --show-toplevel to return the canonical work-tree
-if {[package vsatisfies $_git_version 1.7.0]} {
+if {[package vsatisfies $_git_version 1.7.0-]} {
        if { [is_Cygwin] } {
                catch {set _gitworktree [exec cygpath --windows [git rev-parse --show-toplevel]]}
        } else {
@@ -1539,7 +1539,7 @@ proc rescan_stage2 {fd after} {
                close $fd
        }
 
-       if {[package vsatisfies $::_git_version 1.6.3]} {
+       if {[package vsatisfies $::_git_version 1.6.3-]} {
                set ls_others [list --exclude-standard]
        } else {
                set ls_others [list --exclude-per-directory=.gitignore]
index 332528ff4556116f9ff22c257e49825954a183fb..d08dc92589b366746965a0eab0727ce2befc579d 100755 (executable)
@@ -277,7 +277,7 @@ merge_file () {
        echo "Normal merge conflict for '$MERGED':"
        describe_file "$local_mode" "local" "$LOCAL"
        describe_file "$remote_mode" "remote" "$REMOTE"
-       if "$prompt" = true
+       if test "$guessed_merge_tool" = true || test "$prompt" = true
        then
                printf "Hit return to start merge resolution tool (%s): " "$merge_tool"
                read ans || return 1
@@ -315,7 +315,8 @@ merge_file () {
        return 0
 }
 
-prompt=$(git config --bool mergetool.prompt || echo true)
+prompt=$(git config --bool mergetool.prompt)
+guessed_merge_tool=false
 
 while test $# != 0
 do
@@ -373,7 +374,14 @@ prompt_after_failed_merge () {
 
 if test -z "$merge_tool"
 then
-       merge_tool=$(get_merge_tool "$merge_tool") || exit
+       # Check if a merge tool has been configured
+       merge_tool=$(get_configured_merge_tool)
+       # Try to guess an appropriate merge tool if no tool has been set.
+       if test -z "$merge_tool"
+       then
+               merge_tool=$(guess_merge_tool) || exit
+               guessed_merge_tool=true
+       fi
 fi
 merge_keep_backup="$(git config --bool mergetool.keepBackup || echo true)"
 merge_keep_temporaries="$(git config --bool mergetool.keepTemporaries || echo false)"
index 6cd8ebc534c174dfe613f62047424dc7491d75fa..cfc589dc15061c8ed1797c2d91ec420b1d6f33fe 100755 (executable)
@@ -108,7 +108,7 @@ do
        -s|--s|--st|--str|--stra|--strat|--strate|--strateg|--strategy)
                case "$#,$1" in
                *,*=*)
-                       strategy=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
+                       strategy=$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
                1,*)
                        usage ;;
                *)
index 71429fd74373f3f804fc841b5dd60faca2baaec6..6d77b3ca9118e6fdd36615757a24c109cf0530ee 100644 (file)
@@ -24,7 +24,7 @@ continue_merge () {
                die "$resolvemsg"
        fi
 
-       cmt=`cat "$state_dir/current"`
+       cmt=$(cat "$state_dir/current")
        if ! git diff-index --quiet --ignore-submodules HEAD --
        then
                if ! git commit ${gpg_sign_opt:+"$gpg_sign_opt"} --no-verify -C "$cmt"
@@ -143,7 +143,7 @@ echo "$onto_name" > "$state_dir/onto_name"
 write_basic_state
 
 msgnum=0
-for cmt in `git rev-list --reverse --no-merges "$revisions"`
+for cmt in $(git rev-list --reverse --no-merges "$revisions")
 do
        msgnum=$(($msgnum + 1))
        echo "$cmt" > "$state_dir/cmt.$msgnum"
index 4543815ffd6b0d49466edc3059f6d085b79ebf8a..5c7a0a1a583552de49ee2e094e80f80ee18fd68c 100755 (executable)
@@ -457,8 +457,8 @@ then
 else
        if test -z "$onto"
        then
-               empty_tree=`git hash-object -t tree /dev/null`
-               onto=`git commit-tree $empty_tree </dev/null`
+               empty_tree=$(git hash-object -t tree /dev/null)
+               onto=$(git commit-tree $empty_tree </dev/null)
                squash_onto="$onto"
        fi
        unset upstream_name
@@ -516,10 +516,10 @@ case "$#" in
        ;;
 0)
        # Do not need to switch branches, we are already on it.
-       if branch_name=`git symbolic-ref -q HEAD`
+       if branch_name=$(git symbolic-ref -q HEAD)
        then
                head_name=$branch_name
-               branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
+               branch_name=$(expr "z$branch_name" : 'zrefs/heads/\(.*\)')
        else
                head_name="detached HEAD"
                branch_name=HEAD ;# detached
index 5c1599752314696ef1f317095d1786493fbfc935..d5500fde4658410db477008617730cb5799f310e 100755 (executable)
@@ -119,6 +119,12 @@ then
        status=1
 fi
 
+# Special case: turn "for_linus" to "tags/for_linus" when it is correct
+if test "$ref" = "refs/tags/$pretty_remote"
+then
+       pretty_remote=tags/$pretty_remote
+fi
+
 url=$(git ls-remote --get-url "$url")
 
 git show -s --format='The following changes since commit %H:
index fdb0029b597898559376b1b28d692450794251f3..abd62b484cdaef8e6ab5ba366551c03959c08beb 100755 (executable)
@@ -1113,6 +1113,18 @@ sub ssl_verify_params {
        }
 }
 
+sub file_name_is_absolute {
+       my ($path) = @_;
+
+       # msys does not grok DOS drive-prefixes
+       if ($^O eq 'msys') {
+               return ($path =~ m#^/# || $path =~ m#^[a-zA-Z]\:#)
+       }
+
+       require File::Spec::Functions;
+       return File::Spec::Functions::file_name_is_absolute($path);
+}
+
 # Returns 1 if the message was sent, and 0 otherwise.
 # In actuality, the whole program dies when there
 # is an error sending a message.
@@ -1197,7 +1209,7 @@ sub send_message {
 
        if ($dry_run) {
                # We don't want to send the email.
-       } elsif ($smtp_server =~ m#^/#) {
+       } elsif (file_name_is_absolute($smtp_server)) {
                my $pid = open my $sm, '|-';
                defined $pid or die $!;
                if (!$pid) {
@@ -1271,7 +1283,7 @@ sub send_message {
                printf (($dry_run ? "Dry-" : "")."Sent %s\n", $subject);
        } else {
                print (($dry_run ? "Dry-" : "")."OK. Log says:\n");
-               if ($smtp_server !~ m#^/#) {
+               if (!file_name_is_absolute($smtp_server)) {
                        print "Server: $smtp_server\n";
                        print "MAIL FROM:<$raw_from>\n";
                        foreach my $entry (@recipients) {
index 5f28b32dc7ff75830bde919b2f4776f7a9b017e2..9447980330ce7892757f9b11fa45cfeb3e6fcb34 100644 (file)
@@ -160,7 +160,7 @@ git_pager() {
        else
                GIT_PAGER=cat
        fi
-       : ${LESS=-FRSX}
+       : ${LESS=-FRX}
        : ${LV=-c}
        export LESS LV
 
index 4798bcf0e51b705005215e9a6339310defe16d03..af549c731779db02db29fef446014a58bc9a3996 100755 (executable)
@@ -13,7 +13,7 @@ USAGE="list [<options>]
 
 SUBDIRECTORY_OK=Yes
 OPTIONS_SPEC=
-START_DIR=`pwd`
+START_DIR=$(pwd)
 . git-sh-setup
 . git-sh-i18n
 require_work_tree
index b55d83ac46a96ba15fb7ac8cb43b8c279b40d119..e146b833d163ab58984fec3d6fb9f45b148e0171 100755 (executable)
@@ -291,9 +291,6 @@ module_clone()
        # resolve any symlinks that might be present in $PWD
        a=$(cd_to_toplevel && cd "$gitdir" && pwd)/
        b=$(cd_to_toplevel && cd "$sm_path" && pwd)/
-       # normalize Windows-style absolute paths to POSIX-style absolute paths
-       case $a in [a-zA-Z]:/*) a=/${a%%:*}${a#*:} ;; esac
-       case $b in [a-zA-Z]:/*) b=/${b%%:*}${b#*:} ;; esac
        # Remove all common leading directories after a sanity check
        if test "${a#$b}" != "$a" || test "${b#$a}" != "$b"; then
                die "$(eval_gettext "Gitdir '\$a' is part of the submodule path '\$b' or vice versa")"
index ebdfba6c94db947f66add0c1b4840319c12252ea..ae152534f5026d50fa32b568d1bdd591629bc59d 100755 (executable)
@@ -59,7 +59,7 @@ do
        -b|--browser*|-t|--tool*)
                case "$#,$1" in
                *,*=*)
-                       browser=`expr "z$1" : 'z-[^=]*=\(.*\)'`
+                       browser=$(expr "z$1" : 'z-[^=]*=\(.*\)')
                        ;;
                1,*)
                        usage ;;
@@ -71,7 +71,7 @@ do
        -c|--config*)
                case "$#,$1" in
                *,*=*)
-                       conf=`expr "z$1" : 'z-[^=]*=\(.*\)'`
+                       conf=$(expr "z$1" : 'z-[^=]*=\(.*\)')
                        ;;
                1,*)
                        usage ;;
@@ -100,7 +100,7 @@ then
        for opt in "$conf" "web.browser"
        do
                test -z "$opt" && continue
-               browser="`git config $opt`"
+               browser="$(git config $opt)"
                test -z "$browser" || break
        done
        if test -n "$browser" && ! valid_tool "$browser"; then
diff --git a/git.c b/git.c
index 9efd1a3ec1f2af63fe575f9c755dff685d9b1e51..778057294892d68b3dee58869cf22265223cab83 100644 (file)
--- a/git.c
+++ b/git.c
@@ -290,7 +290,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
        if (!help) {
                if (p->option & RUN_SETUP)
                        prefix = setup_git_directory();
-               if (p->option & RUN_SETUP_GENTLY) {
+               else if (p->option & RUN_SETUP_GENTLY) {
                        int nongit_ok;
                        prefix = setup_git_directory_gently(&nongit_ok);
                }
diff --git a/grep.c b/grep.c
index 4aef0a69d084deee61486e43bc62ae2da6b6b440..99217dc04f5d04c761f094069f1053cb090baaf1 100644 (file)
--- a/grep.c
+++ b/grep.c
@@ -86,6 +86,11 @@ int grep_config(const char *var, const char *value, void *cb)
                return 0;
        }
 
+       if (!strcmp(var, "grep.fullname")) {
+               opt->relative = !git_config_bool(var, value);
+               return 0;
+       }
+
        if (!strcmp(var, "color.grep"))
                opt->color = git_config_colorbool(var, value);
        else if (!strcmp(var, "color.grep.context"))
index 0bc6f7fae151ea364e9d141b30b8e68d544a4448..5c4f336330e416379a15cee75b593f0aea451025 100644 (file)
@@ -23,9 +23,9 @@
  */
 
 #include "cache.h"
+#include "credential.h"
 #include "exec_cmd.h"
 #include "run-command.h"
-#include "prompt.h"
 #ifdef NO_OPENSSL
 typedef void *SSL;
 #endif
@@ -946,6 +946,7 @@ static int auth_cram_md5(struct imap_store *ctx, struct imap_cmd *cmd, const cha
 
 static struct imap_store *imap_open_store(struct imap_server_conf *srvc)
 {
+       struct credential cred = CREDENTIAL_INIT;
        struct imap_store *ctx;
        struct imap *imap;
        char *arg, *rsp;
@@ -1096,25 +1097,23 @@ static struct imap_store *imap_open_store(struct imap_server_conf *srvc)
                }
 #endif
                imap_info("Logging in...\n");
-               if (!srvc->user) {
-                       fprintf(stderr, "Skipping server %s, no user\n", srvc->host);
-                       goto bail;
-               }
-               if (!srvc->pass) {
-                       struct strbuf prompt = STRBUF_INIT;
-                       strbuf_addf(&prompt, "Password (%s@%s): ", srvc->user, srvc->host);
-                       arg = git_getpass(prompt.buf);
-                       strbuf_release(&prompt);
-                       if (!*arg) {
-                               fprintf(stderr, "Skipping account %s@%s, no password\n", srvc->user, srvc->host);
-                               goto bail;
-                       }
-                       /*
-                        * getpass() returns a pointer to a static buffer.  make a copy
-                        * for long term storage.
-                        */
-                       srvc->pass = xstrdup(arg);
+               if (!srvc->user || !srvc->pass) {
+                       cred.protocol = xstrdup(srvc->use_ssl ? "imaps" : "imap");
+                       cred.host = xstrdup(srvc->host);
+
+                       if (srvc->user)
+                               cred.username = xstrdup(srvc->user);
+                       if (srvc->pass)
+                               cred.password = xstrdup(srvc->pass);
+
+                       credential_fill(&cred);
+
+                       if (!srvc->user)
+                               srvc->user = xstrdup(cred.username);
+                       if (!srvc->pass)
+                               srvc->pass = xstrdup(cred.password);
                }
+
                if (CAP(NOLOGIN)) {
                        fprintf(stderr, "Skipping account %s@%s, server forbids LOGIN\n", srvc->user, srvc->host);
                        goto bail;
@@ -1153,10 +1152,18 @@ static struct imap_store *imap_open_store(struct imap_server_conf *srvc)
                }
        } /* !preauth */
 
+       if (cred.username)
+               credential_approve(&cred);
+       credential_clear(&cred);
+
        ctx->prefix = "";
        return ctx;
 
 bail:
+       if (cred.username)
+               credential_reject(&cred);
+       credential_clear(&cred);
+
        imap_close_store(ctx);
        return NULL;
 }
index 41770929420da4cba934b0b86b9cd2f55f9cab31..cab16fafb5c2b7792c78d3a7fbace1f43ab099cc 100644 (file)
@@ -589,6 +589,12 @@ static int remove_file(struct merge_options *o, int clean,
                        return -1;
        }
        if (update_working_directory) {
+               if (ignore_case) {
+                       struct cache_entry *ce;
+                       ce = cache_file_exists(path, strlen(path), ignore_case);
+                       if (ce && ce_stage(ce) == 0)
+                               return 0;
+               }
                if (remove_path(path))
                        return -1;
        }
diff --git a/mergetools/gvimdiff3 b/mergetools/gvimdiff3
new file mode 100644 (file)
index 0000000..04a5bb0
--- /dev/null
@@ -0,0 +1 @@
+. "$MERGE_TOOLS_DIR/vimdiff"
index 39d032771b8525253d3828fd68b2c7f6d6df8478..1ddfbfcd782d3b8d0e479cb0c5e29abce86e63c9 100644 (file)
@@ -20,16 +20,26 @@ merge_cmd () {
                "$merge_tool_path" -f -d -c 'wincmd l' \
                        "$LOCAL" "$MERGED" "$REMOTE"
                ;;
+       gvimdiff3|vimdiff3)
+               if $base_present
+               then
+                       "$merge_tool_path" -f -d -c 'hid | hid | hid' \
+                               "$LOCAL" "$REMOTE" "$BASE" "$MERGED"
+               else
+                       "$merge_tool_path" -f -d -c 'hid | hid' \
+                               "$LOCAL" "$REMOTE" "$MERGED"
+               fi
+               ;;
        esac
        check_unchanged
 }
 
 translate_merge_tool_path() {
        case "$1" in
-       gvimdiff|gvimdiff2)
+       gvimdiff|gvimdiff2|gvimdiff3)
                echo gvim
                ;;
-       vimdiff|vimdiff2)
+       vimdiff|vimdiff2|vimdiff3)
                echo vim
                ;;
        esac
diff --git a/mergetools/vimdiff3 b/mergetools/vimdiff3
new file mode 100644 (file)
index 0000000..04a5bb0
--- /dev/null
@@ -0,0 +1 @@
+. "$MERGE_TOOLS_DIR/vimdiff"
index eabe4a0d9bf44050dba43cbd821642cdfd3fb40b..97dfd63c9bf564ac052addc4a3f62a325bbc1303 100644 (file)
@@ -62,7 +62,7 @@ int notes_cache_write(struct notes_cache *c)
        if (commit_tree(&msg, tree_sha1, NULL, commit_sha1, NULL, NULL) < 0)
                return -1;
        if (update_ref("update notes cache", c->tree.ref, commit_sha1, NULL,
-                      0, QUIET_ON_ERR) < 0)
+                      0, UPDATE_REFS_QUIET_ON_ERR) < 0)
                return -1;
 
        return 0;
index 4aa7023903374aa3ccea23d5fc9ae82c9c67bca7..a0b1d7be98253368921a6e95653ceb36dbda28b2 100644 (file)
@@ -48,7 +48,8 @@ void commit_notes(struct notes_tree *t, const char *msg)
 
        create_notes_commit(t, NULL, &buf, commit_sha1);
        strbuf_insert(&buf, 0, "notes: ", 7); /* commit message starts at index 7 */
-       update_ref(buf.buf, t->ref, commit_sha1, NULL, 0, DIE_ON_ERR);
+       update_ref(buf.buf, t->ref, commit_sha1, NULL, 0,
+                  UPDATE_REFS_DIE_ON_ERR);
 
        strbuf_release(&buf);
 }
diff --git a/pager.c b/pager.c
index 0cc75a8eee32a0195a74c6819a04745f341e45e3..8b5cbc56e4fd57a1b9d2cad3e668df4c508a7b17 100644 (file)
--- a/pager.c
+++ b/pager.c
@@ -64,7 +64,7 @@ void setup_pager(void)
 {
        const char *pager = git_pager(isatty(1));
 
-       if (!pager || pager_in_use())
+       if (!pager)
                return;
 
        /*
@@ -85,7 +85,7 @@ void setup_pager(void)
                int i = 0;
 
                if (!getenv("LESS"))
-                       env[i++] = "LESS=FRSX";
+                       env[i++] = "LESS=FRX";
                if (!getenv("LV"))
                        env[i++] = "LV=-c";
                env[i] = NULL;
index 3189676695bc173cf6475445cfb6365d08a37906..7940bc71af4c6dacd65d042091454c8fa83c53c7 100644 (file)
@@ -176,8 +176,8 @@ extern NORETURN void usage_msg_opt(const char *msg,
 
 extern int optbug(const struct option *opt, const char *reason);
 extern int opterror(const struct option *opt, const char *reason, int flags);
-#if defined(__GNUC__) && ! defined(__clang__)
-#define opterror(o,r,f) (opterror((o),(r),(f)), -1)
+#if defined(__GNUC__)
+#define opterror(o,r,f) (opterror((o),(r),(f)), const_error())
 #endif
 
 /*----- incremental advanced APIs -----*/
index a59564fb34fbedd4915da2afd7d4b8f1fd40bb49..09cff135efd98a486ff767485602d9383e7c3c23 100644 (file)
@@ -1321,7 +1321,7 @@ sub get_untracked {
 sub parse_svn_date {
        my $date = shift || return '+0000 1970-01-01 00:00:00';
        my ($Y,$m,$d,$H,$M,$S) = ($date =~ /^(\d{4})\-(\d\d)\-(\d\d)T
-                                           (\d\d)\:(\d\d)\:(\d\d)\.\d*Z$/x) or
+                                           (\d\d?)\:(\d\d)\:(\d\d)\.\d*Z$/x) or
                                         croak "Unable to parse date: $date\n";
        my $parsed_date;    # Set next.
 
index 34f2869ab5995e3f9143af8cc2c46a4717ae8be8..664105357c0031e869b3348a09d91777a42c1cdf 100644 (file)
@@ -116,7 +116,7 @@ sub run_pager {
                return;
        }
        open STDIN, '<&', $rfd or fatal "Can't redirect stdin: $!";
-       $ENV{LESS} ||= 'FRSX';
+       $ENV{LESS} ||= 'FRX';
        $ENV{LV} ||= '-c';
        exec $pager or fatal "Can't run pager: $! ($pager)";
 }
index ba10b5f616e54078c2d2df3a05e97c28f24d2e27..6b32da05bcf11bf34c8c0202afc3483d76b006f6 100644 (file)
--- a/po/fr.po
+++ b/po/fr.po
@@ -296,11 +296,11 @@ msgid ""
 msgstr ""
 "\n"
 "Si vous comptez baser votre travail sur une branche\n"
-"amont qui existe déjà sur le serveur distant, vous pourriez\n"
-"devoir lancer \"git fetch\" pour la récupérer.\n"
+"amont qui existe déjà sur le serveur distant, vous pouvez\n"
+"lancer \"git fetch\" pour la récupérer.\n"
 "\n"
 "Si vous comptez pousser une nouvelle branche locale qui suivra\n"
-"sa jumelle distante, vous souhaiterez utiliser \"git push -u\"\n"
+"sa jumelle distante, vous pouvez utiliser \"git push -u\"\n"
 "pour paramétrer le suivi distant en même temps que vous poussez."
 
 #: branch.c:260
@@ -343,7 +343,7 @@ msgstr "impossible d'ouvrir '%s'"
 
 #: bundle.c:138
 msgid "Repository lacks these prerequisite commits:"
-msgstr "Le dépôt ne dispose pas des commits prérequis :"
+msgstr "Le dépôt ne dispose pas des commits prérequis suivants :"
 
 #: bundle.c:162 sequencer.c:669 sequencer.c:1123 builtin/log.c:332
 #: builtin/log.c:821 builtin/log.c:1418 builtin/log.c:1644 builtin/merge.c:357
@@ -620,7 +620,7 @@ msgid ""
 msgstr ""
 "ATTENTION : vous avez invoqué une commande Git nommée '%s' qui n'existe "
 "pas.\n"
-"Poursuite en supposant que vous avez voulu dire '%s'"
+"Continuons en supposant que vous avez voulu dire '%s'"
 
 #: help.c:373
 #, c-format
@@ -3480,12 +3480,12 @@ msgid_plural ""
 "\n"
 "%s\n"
 msgstr[0] ""
-"Attention : vous laissez %d commit en retard, non connectés à\n"
+"Attention : vous abandonnez %d commit, non connecté à\n"
 "une branche :\n"
 "\n"
 "%s\n"
 msgstr[1] ""
-"Attention : vous laissez %d commits en retard, non connectés à\n"
+"Attention : vous abandonnez %d commits, non connectés à\n"
 "une branche :\n"
 "\n"
 "%s\n"
@@ -3501,7 +3501,7 @@ msgid ""
 msgstr ""
 "Si vous souhaitez les garder en créant une nouvelle branche, c'est le bon "
 "moment\n"
-"de le faire avec :\n"
+"pour le faire avec :\n"
 "\n"
 "git branch nouvelle_branche %s\n"
 "\n"
@@ -3576,7 +3576,7 @@ msgstr "détacher la HEAD à la validation nommée"
 
 #: builtin/checkout.c:1096
 msgid "set upstream info for new branch"
-msgstr "paramétrer l'information de branche amont pour une nouvelle branche"
+msgstr "paramétrer les coordonnées de branche amont pour une nouvelle branche"
 
 #: builtin/checkout.c:1098
 msgid "new-branch"
@@ -3846,7 +3846,7 @@ msgstr "git clone [options] [--] <dépôt> [<répertoire>]"
 #: builtin/clone.c:64 builtin/fetch.c:97 builtin/merge.c:222
 #: builtin/push.c:504
 msgid "force progress reporting"
-msgstr "forcer l'état d'avancement"
+msgstr "forcer l'affichage de l'état d'avancement"
 
 #: builtin/clone.c:66
 msgid "don't create a checkout"
@@ -4156,7 +4156,7 @@ msgid ""
 msgstr ""
 "Votre nom et votre adresse e-mail ont été configurés automatiquement en se "
 "fondant\n"
-"sur votre nom d'utilisateur et votre nom d'ordinateur. Veuillez vérifier "
+"sur votre nom d'utilisateur et le nom de votre machine. Veuillez vérifier "
 "qu'ils sont corrects.\n"
 "Vous pouvez supprimer ce message en les paramétrant explicitement :\n"
 "\n"
@@ -4565,12 +4565,12 @@ msgstr "réutiliser le message du commit spécifié"
 #: builtin/commit.c:1496
 msgid "use autosquash formatted message to fixup specified commit"
 msgstr ""
-"utiliser un message formaté par autosquash pour corriger le commit spécifié"
+"utiliser un message au format autosquash pour corriger le commit spécifié"
 
 #: builtin/commit.c:1497
 msgid "use autosquash formatted message to squash specified commit"
 msgstr ""
-"utiliser un message formaté par autosquash pour compresser le commit spécifié"
+"utiliser un message au format autosquash pour compresser le commit spécifié"
 
 #: builtin/commit.c:1498
 msgid "the commit is authored by me now (used with -C/-c/--amend)"
@@ -6404,7 +6404,7 @@ msgstr "Exactement une plage nécessaire."
 
 #: builtin/log.c:809
 msgid "Not a range."
-msgstr "Pas une plage."
+msgstr "Ceci n'est pas une plage."
 
 #: builtin/log.c:911
 msgid "Cover letter needs email format"
@@ -6527,7 +6527,7 @@ msgstr "répondre dans le premier message à <id-message>"
 
 #: builtin/log.c:1221 builtin/log.c:1224
 msgid "boundary"
-msgstr "frontière"
+msgstr "limite"
 
 #: builtin/log.c:1222
 msgid "attach the patch"
@@ -8092,7 +8092,7 @@ msgstr ""
 #: builtin/push.c:361
 #, c-format
 msgid "Pushing to %s\n"
-msgstr "Poussage vers %s\n"
+msgstr "Poussée vers %s\n"
 
 #: builtin/push.c:365
 #, c-format
@@ -8185,7 +8185,7 @@ msgstr "check"
 
 #: builtin/push.c:497
 msgid "control recursive pushing of submodules"
-msgstr "contrôler le poussage récursif des sous-modules"
+msgstr "contrôler la poussée récursive des sous-modules"
 
 #: builtin/push.c:499
 msgid "use thin pack"
@@ -8736,12 +8736,12 @@ msgstr "Impossible de paramétrer %s"
 #: builtin/remote.c:1307
 #, c-format
 msgid " %s will become dangling!"
-msgstr " %s deviendra en suspens !"
+msgstr " %s se retrouvera en suspens !"
 
 #: builtin/remote.c:1308
 #, c-format
 msgid " %s has become dangling!"
-msgstr " %s est devenu en suspens !"
+msgstr " %s se retrouve en suspens !"
 
 #: builtin/remote.c:1314
 #, c-format
@@ -10643,7 +10643,7 @@ msgstr "Conflits dans l'index. Essayez sans --index."
 
 #: git-stash.sh:457
 msgid "Could not save index tree"
-msgstr "Impossible de sauver l'arbre d'index"
+msgstr "Impossible de sauvegarder l'arbre d'index"
 
 #: git-stash.sh:491
 msgid "Cannot unstage modified files"
@@ -10799,7 +10799,7 @@ msgstr ""
 #, sh-format
 msgid "No url found for submodule path '$displaypath' in .gitmodules"
 msgstr ""
-"URL non trouvé pour le chemin de sous-module '$displaypath' dans .gitmodules"
+"URL non trouvée pour le chemin de sous-module '$displaypath' dans .gitmodules"
 
 #: git-submodule.sh:620
 #, sh-format
index 3c43db558aee43b0ea69c23c6611dcc9fae0661f..e1e2cad36d6d2d2773f05c6e69b0013ed8d01240 100644 (file)
--- a/pretty.c
+++ b/pretty.c
@@ -393,8 +393,8 @@ static void add_rfc2047(struct strbuf *sb, const char *line, size_t len,
        strbuf_addstr(sb, "?=");
 }
 
-static const char *show_ident_date(const struct ident_split *ident,
-                                  enum date_mode mode)
+const char *show_ident_date(const struct ident_split *ident,
+                           enum date_mode mode)
 {
        unsigned long date = 0;
        long tz = 0;
index ba13353b377d4f27b9ff6cf1b85811fcca61e224..7f5645e74546e459efdb584dbf63e1fd75857317 100644 (file)
@@ -1477,6 +1477,7 @@ int read_index_from(struct index_state *istate, const char *path)
        if (verify_hdr(hdr, mmap_size) < 0)
                goto unmap;
 
+       hashcpy(istate->sha1, (unsigned char *)hdr + mmap_size - 20);
        istate->version = ntohl(hdr->hdr_version);
        istate->cache_nr = ntohl(hdr->hdr_entries);
        istate->cache_alloc = alloc_nr(istate->cache_nr);
@@ -1760,6 +1761,50 @@ static int ce_write_entry(git_SHA_CTX *c, int fd, struct cache_entry *ce,
        return result;
 }
 
+/*
+ * This function verifies if index_state has the correct sha1 of the
+ * index file.  Don't die if we have any other failure, just return 0.
+ */
+static int verify_index_from(const struct index_state *istate, const char *path)
+{
+       int fd;
+       ssize_t n;
+       struct stat st;
+       unsigned char sha1[20];
+
+       if (!istate->initialized)
+               return 0;
+
+       fd = open(path, O_RDONLY);
+       if (fd < 0)
+               return 0;
+
+       if (fstat(fd, &st))
+               goto out;
+
+       if (st.st_size < sizeof(struct cache_header) + 20)
+               goto out;
+
+       n = pread_in_full(fd, sha1, 20, st.st_size - 20);
+       if (n != 20)
+               goto out;
+
+       if (hashcmp(istate->sha1, sha1))
+               goto out;
+
+       close(fd);
+       return 1;
+
+out:
+       close(fd);
+       return 0;
+}
+
+static int verify_index(const struct index_state *istate)
+{
+       return verify_index_from(istate, get_index_file());
+}
+
 static int has_racy_timestamp(struct index_state *istate)
 {
        int entries = istate->cache_nr;
@@ -1779,7 +1824,7 @@ static int has_racy_timestamp(struct index_state *istate)
 void update_index_if_able(struct index_state *istate, struct lock_file *lockfile)
 {
        if ((istate->cache_changed || has_racy_timestamp(istate)) &&
-           !write_index(istate, lockfile->fd))
+           verify_index(istate) && !write_index(istate, lockfile->fd))
                commit_locked_index(lockfile);
        else
                rollback_lock_file(lockfile);
diff --git a/refs.c b/refs.c
index 28d5eca8eaff7be48a4b89e6217886b8c96eb3b2..68982637ed89a2d679d5e2a9a86e76e6fb56a7b4 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -1999,7 +1999,6 @@ int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
 
        *log = NULL;
        for (p = ref_rev_parse_rules; *p; p++) {
-               struct stat st;
                unsigned char hash[20];
                char path[PATH_MAX];
                const char *ref, *it;
@@ -2008,12 +2007,9 @@ int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
                ref = resolve_ref_unsafe(path, hash, 1, NULL);
                if (!ref)
                        continue;
-               if (!stat(git_path("logs/%s", path), &st) &&
-                   S_ISREG(st.st_mode))
+               if (reflog_exists(path))
                        it = path;
-               else if (strcmp(ref, path) &&
-                        !stat(git_path("logs/%s", ref), &st) &&
-                        S_ISREG(st.st_mode))
+               else if (strcmp(ref, path) && reflog_exists(ref))
                        it = ref;
                else
                        continue;
@@ -3046,6 +3042,19 @@ int read_ref_at(const char *refname, unsigned long at_time, int cnt,
        return 1;
 }
 
+int reflog_exists(const char *refname)
+{
+       struct stat st;
+
+       return !lstat(git_path("logs/%s", refname), &st) &&
+               S_ISREG(st.st_mode);
+}
+
+int delete_reflog(const char *refname)
+{
+       return remove_path(git_path("logs/%s", refname));
+}
+
 static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)
 {
        unsigned char osha1[20], nsha1[20];
@@ -3243,9 +3252,9 @@ static struct ref_lock *update_ref_lock(const char *refname,
        if (!lock) {
                const char *str = "Cannot lock the ref '%s'.";
                switch (onerr) {
-               case MSG_ON_ERR: error(str, refname); break;
-               case DIE_ON_ERR: die(str, refname); break;
-               case QUIET_ON_ERR: break;
+               case UPDATE_REFS_MSG_ON_ERR: error(str, refname); break;
+               case UPDATE_REFS_DIE_ON_ERR: die(str, refname); break;
+               case UPDATE_REFS_QUIET_ON_ERR: break;
                }
        }
        return lock;
@@ -3258,15 +3267,118 @@ static int update_ref_write(const char *action, const char *refname,
        if (write_ref_sha1(lock, sha1, action) < 0) {
                const char *str = "Cannot update the ref '%s'.";
                switch (onerr) {
-               case MSG_ON_ERR: error(str, refname); break;
-               case DIE_ON_ERR: die(str, refname); break;
-               case QUIET_ON_ERR: break;
+               case UPDATE_REFS_MSG_ON_ERR: error(str, refname); break;
+               case UPDATE_REFS_DIE_ON_ERR: die(str, refname); break;
+               case UPDATE_REFS_QUIET_ON_ERR: break;
                }
                return 1;
        }
        return 0;
 }
 
+/**
+ * Information needed for a single ref update.  Set new_sha1 to the
+ * new value or to zero to delete the ref.  To check the old value
+ * while locking the ref, set have_old to 1 and set old_sha1 to the
+ * value or to zero to ensure the ref does not exist before update.
+ */
+struct ref_update {
+       unsigned char new_sha1[20];
+       unsigned char old_sha1[20];
+       int flags; /* REF_NODEREF? */
+       int have_old; /* 1 if old_sha1 is valid, 0 otherwise */
+       struct ref_lock *lock;
+       int type;
+       const char refname[FLEX_ARRAY];
+};
+
+/*
+ * Data structure for holding a reference transaction, which can
+ * consist of checks and updates to multiple references, carried out
+ * as atomically as possible.  This structure is opaque to callers.
+ */
+struct ref_transaction {
+       struct ref_update **updates;
+       size_t alloc;
+       size_t nr;
+};
+
+struct ref_transaction *ref_transaction_begin(void)
+{
+       return xcalloc(1, sizeof(struct ref_transaction));
+}
+
+static void ref_transaction_free(struct ref_transaction *transaction)
+{
+       int i;
+
+       for (i = 0; i < transaction->nr; i++)
+               free(transaction->updates[i]);
+
+       free(transaction->updates);
+       free(transaction);
+}
+
+void ref_transaction_rollback(struct ref_transaction *transaction)
+{
+       ref_transaction_free(transaction);
+}
+
+static struct ref_update *add_update(struct ref_transaction *transaction,
+                                    const char *refname)
+{
+       size_t len = strlen(refname);
+       struct ref_update *update = xcalloc(1, sizeof(*update) + len + 1);
+
+       strcpy((char *)update->refname, refname);
+       ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
+       transaction->updates[transaction->nr++] = update;
+       return update;
+}
+
+void ref_transaction_update(struct ref_transaction *transaction,
+                           const char *refname,
+                           unsigned char *new_sha1, unsigned char *old_sha1,
+                           int flags, int have_old)
+{
+       struct ref_update *update = add_update(transaction, refname);
+
+       hashcpy(update->new_sha1, new_sha1);
+       update->flags = flags;
+       update->have_old = have_old;
+       if (have_old)
+               hashcpy(update->old_sha1, old_sha1);
+}
+
+void ref_transaction_create(struct ref_transaction *transaction,
+                           const char *refname,
+                           unsigned char *new_sha1,
+                           int flags)
+{
+       struct ref_update *update = add_update(transaction, refname);
+
+       assert(!is_null_sha1(new_sha1));
+       hashcpy(update->new_sha1, new_sha1);
+       hashclr(update->old_sha1);
+       update->flags = flags;
+       update->have_old = 1;
+}
+
+void ref_transaction_delete(struct ref_transaction *transaction,
+                           const char *refname,
+                           unsigned char *old_sha1,
+                           int flags, int have_old)
+{
+       struct ref_update *update = add_update(transaction, refname);
+
+       update->flags = flags;
+       update->have_old = have_old;
+       if (have_old) {
+               assert(!is_null_sha1(old_sha1));
+               hashcpy(update->old_sha1, old_sha1);
+       }
+}
+
 int update_ref(const char *action, const char *refname,
               const unsigned char *sha1, const unsigned char *oldval,
               int flags, enum action_on_err onerr)
@@ -3282,7 +3394,7 @@ static int ref_update_compare(const void *r1, const void *r2)
 {
        const struct ref_update * const *u1 = r1;
        const struct ref_update * const *u2 = r2;
-       return strcmp((*u1)->ref_name, (*u2)->ref_name);
+       return strcmp((*u1)->refname, (*u2)->refname);
 }
 
 static int ref_update_reject_duplicates(struct ref_update **updates, int n,
@@ -3290,15 +3402,15 @@ static int ref_update_reject_duplicates(struct ref_update **updates, int n,
 {
        int i;
        for (i = 1; i < n; i++)
-               if (!strcmp(updates[i - 1]->ref_name, updates[i]->ref_name)) {
+               if (!strcmp(updates[i - 1]->refname, updates[i]->refname)) {
                        const char *str =
                                "Multiple updates for ref '%s' not allowed.";
                        switch (onerr) {
-                       case MSG_ON_ERR:
-                               error(str, updates[i]->ref_name); break;
-                       case DIE_ON_ERR:
-                               die(str, updates[i]->ref_name); break;
-                       case QUIET_ON_ERR:
+                       case UPDATE_REFS_MSG_ON_ERR:
+                               error(str, updates[i]->refname); break;
+                       case UPDATE_REFS_DIE_ON_ERR:
+                               die(str, updates[i]->refname); break;
+                       case UPDATE_REFS_QUIET_ON_ERR:
                                break;
                        }
                        return 1;
@@ -3306,26 +3418,21 @@ static int ref_update_reject_duplicates(struct ref_update **updates, int n,
        return 0;
 }
 
-int update_refs(const char *action, const struct ref_update **updates_orig,
-               int n, enum action_on_err onerr)
+int ref_transaction_commit(struct ref_transaction *transaction,
+                          const char *msg, enum action_on_err onerr)
 {
        int ret = 0, delnum = 0, i;
-       struct ref_update **updates;
-       int *types;
-       struct ref_lock **locks;
        const char **delnames;
+       int n = transaction->nr;
+       struct ref_update **updates = transaction->updates;
 
-       if (!updates_orig || !n)
+       if (!n)
                return 0;
 
        /* Allocate work space */
-       updates = xmalloc(sizeof(*updates) * n);
-       types = xmalloc(sizeof(*types) * n);
-       locks = xcalloc(n, sizeof(*locks));
        delnames = xmalloc(sizeof(*delnames) * n);
 
        /* Copy, sort, and reject duplicate refs */
-       memcpy(updates, updates_orig, sizeof(*updates) * n);
        qsort(updates, n, sizeof(*updates), ref_update_compare);
        ret = ref_update_reject_duplicates(updates, n, onerr);
        if (ret)
@@ -3333,35 +3440,44 @@ int update_refs(const char *action, const struct ref_update **updates_orig,
 
        /* Acquire all locks while verifying old values */
        for (i = 0; i < n; i++) {
-               locks[i] = update_ref_lock(updates[i]->ref_name,
-                                          (updates[i]->have_old ?
-                                           updates[i]->old_sha1 : NULL),
-                                          updates[i]->flags,
-                                          &types[i], onerr);
-               if (!locks[i]) {
+               struct ref_update *update = updates[i];
+
+               update->lock = update_ref_lock(update->refname,
+                                              (update->have_old ?
+                                               update->old_sha1 : NULL),
+                                              update->flags,
+                                              &update->type, onerr);
+               if (!update->lock) {
                        ret = 1;
                        goto cleanup;
                }
        }
 
        /* Perform updates first so live commits remain referenced */
-       for (i = 0; i < n; i++)
-               if (!is_null_sha1(updates[i]->new_sha1)) {
-                       ret = update_ref_write(action,
-                                              updates[i]->ref_name,
-                                              updates[i]->new_sha1,
-                                              locks[i], onerr);
-                       locks[i] = NULL; /* freed by update_ref_write */
+       for (i = 0; i < n; i++) {
+               struct ref_update *update = updates[i];
+
+               if (!is_null_sha1(update->new_sha1)) {
+                       ret = update_ref_write(msg,
+                                              update->refname,
+                                              update->new_sha1,
+                                              update->lock, onerr);
+                       update->lock = NULL; /* freed by update_ref_write */
                        if (ret)
                                goto cleanup;
                }
+       }
 
        /* Perform deletes now that updates are safely completed */
-       for (i = 0; i < n; i++)
-               if (locks[i]) {
-                       delnames[delnum++] = locks[i]->ref_name;
-                       ret |= delete_ref_loose(locks[i], types[i]);
+       for (i = 0; i < n; i++) {
+               struct ref_update *update = updates[i];
+
+               if (update->lock) {
+                       delnames[delnum++] = update->lock->ref_name;
+                       ret |= delete_ref_loose(update->lock, update->type);
                }
+       }
+
        ret |= repack_without_refs(delnames, delnum);
        for (i = 0; i < delnum; i++)
                unlink_or_warn(git_path("logs/%s", delnames[i]));
@@ -3369,12 +3485,10 @@ int update_refs(const char *action, const struct ref_update **updates_orig,
 
 cleanup:
        for (i = 0; i < n; i++)
-               if (locks[i])
-                       unlock_ref(locks[i]);
-       free(updates);
-       free(types);
-       free(locks);
+               if (updates[i]->lock)
+                       unlock_ref(updates[i]->lock);
        free(delnames);
+       ref_transaction_free(transaction);
        return ret;
 }
 
diff --git a/refs.h b/refs.h
index 87a1a79ad659f3520a22ae14bac1d5082cf2c27b..09ff483c19ec9484359864640da86f9a40418ecc 100644 (file)
--- a/refs.h
+++ b/refs.h
@@ -10,19 +10,7 @@ struct ref_lock {
        int force_write;
 };
 
-/**
- * Information needed for a single ref update.  Set new_sha1 to the
- * new value or to zero to delete the ref.  To check the old value
- * while locking the ref, set have_old to 1 and set old_sha1 to the
- * value or to zero to ensure the ref does not exist before update.
- */
-struct ref_update {
-       const char *ref_name;
-       unsigned char new_sha1[20];
-       unsigned char old_sha1[20];
-       int flags; /* REF_NODEREF? */
-       int have_old; /* 1 if old_sha1 is valid, 0 otherwise */
-};
+struct ref_transaction;
 
 /*
  * Bit values set in the flags argument passed to each_ref_fn():
@@ -166,13 +154,19 @@ extern void unlock_ref(struct ref_lock *lock);
 extern int write_ref_sha1(struct ref_lock *lock, const unsigned char *sha1, const char *msg);
 
 /** Setup reflog before using. **/
-int log_ref_setup(const char *ref_name, char *logfile, int bufsize);
+int log_ref_setup(const char *refname, char *logfile, int bufsize);
 
 /** Reads log for the value of ref during at_time. **/
 extern int read_ref_at(const char *refname, unsigned long at_time, int cnt,
                       unsigned char *sha1, char **msg,
                       unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt);
 
+/** Check if a particular reflog exists */
+extern int reflog_exists(const char *refname);
+
+/** Delete a reflog */
+extern int delete_reflog(const char *refname);
+
 /* iterate over reflog entries */
 typedef int each_reflog_ent_fn(unsigned char *osha1, unsigned char *nsha1, const char *, unsigned long, int, const char *, void *);
 int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data);
@@ -214,18 +208,80 @@ extern int rename_ref(const char *oldref, const char *newref, const char *logmsg
  */
 extern int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1);
 
-/** lock a ref and then write its file */
-enum action_on_err { MSG_ON_ERR, DIE_ON_ERR, QUIET_ON_ERR };
+enum action_on_err {
+       UPDATE_REFS_MSG_ON_ERR,
+       UPDATE_REFS_DIE_ON_ERR,
+       UPDATE_REFS_QUIET_ON_ERR
+};
+
+/*
+ * Begin a reference transaction.  The reference transaction must
+ * eventually be commited using ref_transaction_commit() or rolled
+ * back using ref_transaction_rollback().
+ */
+struct ref_transaction *ref_transaction_begin(void);
+
+/*
+ * Roll back a ref_transaction and free all associated data.
+ */
+void ref_transaction_rollback(struct ref_transaction *transaction);
+
+
+/*
+ * The following functions add a reference check or update to a
+ * ref_transaction.  In all of them, refname is the name of the
+ * reference to be affected.  The functions make internal copies of
+ * refname, so the caller retains ownership of the parameter.  flags
+ * can be REF_NODEREF; it is passed to update_ref_lock().
+ */
+
+
+/*
+ * Add a reference update to transaction.  new_sha1 is the value that
+ * the reference should have after the update, or zeros if it should
+ * be deleted.  If have_old is true, then old_sha1 holds the value
+ * that the reference should have had before the update, or zeros if
+ * it must not have existed beforehand.
+ */
+void ref_transaction_update(struct ref_transaction *transaction,
+                           const char *refname,
+                           unsigned char *new_sha1, unsigned char *old_sha1,
+                           int flags, int have_old);
+
+/*
+ * Add a reference creation to transaction.  new_sha1 is the value
+ * that the reference should have after the update; it must not be the
+ * null SHA-1.  It is verified that the reference does not exist
+ * already.
+ */
+void ref_transaction_create(struct ref_transaction *transaction,
+                           const char *refname,
+                           unsigned char *new_sha1,
+                           int flags);
+
+/*
+ * Add a reference deletion to transaction.  If have_old is true, then
+ * old_sha1 holds the value that the reference should have had before
+ * the update (which must not be the null SHA-1).
+ */
+void ref_transaction_delete(struct ref_transaction *transaction,
+                           const char *refname,
+                           unsigned char *old_sha1,
+                           int flags, int have_old);
+
+/*
+ * Commit all of the changes that have been queued in transaction, as
+ * atomically as possible.  Return a nonzero value if there is a
+ * problem.  The ref_transaction is freed by this function.
+ */
+int ref_transaction_commit(struct ref_transaction *transaction,
+                          const char *msg, enum action_on_err onerr);
+
+/** Lock a ref and then write its file */
 int update_ref(const char *action, const char *refname,
                const unsigned char *sha1, const unsigned char *oldval,
                int flags, enum action_on_err onerr);
 
-/**
- * Lock all refs and then perform all modifications.
- */
-int update_refs(const char *action, const struct ref_update **updates,
-               int n, enum action_on_err onerr);
-
 extern int parse_hide_refs_config(const char *var, const char *value, const char *);
 extern int ref_is_hidden(const char *);
 
index bde5f047b01376e05255a55516d3bdd261f497ea..0a80c58d1194c3476dfd2861a98fbd08610597a3 100644 (file)
@@ -281,8 +281,12 @@ static int fast_forward_to(const unsigned char *to, const unsigned char *from,
                exit(1); /* the callee should have complained already */
        ref_lock = lock_any_ref_for_update("HEAD", unborn ? null_sha1 : from,
                                           0, NULL);
+       if (!ref_lock)
+               return error(_("Failed to lock HEAD during fast_forward_to"));
+
        strbuf_addf(&sb, "%s: fast-forward", action_name(opts));
        ret = write_ref_sha1(ref_lock, to, sb.buf);
+
        strbuf_release(&sb);
        return ret;
 }
index ee96dcfb816625436582833d812a7156513d5d39..4d31567a1a6a67ae9697816d78da442f87ab5803 100644 (file)
--- a/strbuf.c
+++ b/strbuf.c
@@ -78,15 +78,8 @@ void strbuf_grow(struct strbuf *sb, size_t extra)
 
 void strbuf_trim(struct strbuf *sb)
 {
-       char *b = sb->buf;
-       while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
-               sb->len--;
-       while (sb->len > 0 && isspace(*b)) {
-               b++;
-               sb->len--;
-       }
-       memmove(sb->buf, b, sb->len);
-       sb->buf[sb->len] = '\0';
+       strbuf_rtrim(sb);
+       strbuf_ltrim(sb);
 }
 void strbuf_rtrim(struct strbuf *sb)
 {
index 957ae936e8b785f8b1afbffd9a5918a3260d213f..9e7d7962b0678dceefb93e3706b742cbfdc5b45e 100755 (executable)
@@ -281,7 +281,7 @@ helper_test_timeout() {
 cat >askpass <<\EOF
 #!/bin/sh
 echo >&2 askpass: $*
-what=`echo $1 | cut -d" " -f1 | tr A-Z a-z | tr -cd a-z`
+what=$(echo $1 | cut -d" " -f1 | tr A-Z a-z | tr -cd a-z)
 echo "askpass-$what"
 EOF
 chmod +x askpass
index 5076718916388d6abf483220cd35f9f61394abc4..9b2bcfb1b0e38ec75e4d6d772e530a69eaaad874 100644 (file)
@@ -13,7 +13,7 @@ fi
 CVS="cvs -f"
 export CVS
 
-cvsps_version=`cvsps -h 2>&1 | sed -ne 's/cvsps version //p'`
+cvsps_version=$(cvsps -h 2>&1 | sed -ne 's/cvsps version //p')
 case "$cvsps_version" in
 2.1 | 2.2*)
        ;;
index 05824fa8e4d18252f74c51531d6504039986c078..fd499e7c498449834992e67645f098d49c6290b8 100755 (executable)
@@ -1,6 +1,6 @@
 #!/bin/sh
 
-gpg_version=`gpg --version 2>&1`
+gpg_version=$(gpg --version 2>&1)
 if test $? = 127; then
        say "You do not seem to have gpg installed"
 else
index 6cb5b0d55b6d6ed4a91f6d0674c210d98b962b66..5ee9211f988dce1f334d796623feccda85641bbe 100755 (executable)
@@ -8,7 +8,7 @@ test_perf_large_repo
 
 test_expect_success 'repack' '
        git repack -ad &&
-       PACK=`ls .git/objects/pack/*.pack | head -n1` &&
+       PACK=$(ls .git/objects/pack/*.pack | head -n1) &&
        test -f "$PACK" &&
        export PACK
 '
index bbc9cb60ddea49f1ce3f0b0d124f704c30a61346..2f3020342a75f0d382af88e6ad35691ad0f183d5 100755 (executable)
@@ -185,14 +185,14 @@ test_expect_success 'init --bare/--shared overrides system/global config' '
        git init --bare --shared=0666 init-bare-shared-override &&
        check_config init-bare-shared-override true unset &&
        test x0666 = \
-       x`git config -f init-bare-shared-override/config core.sharedRepository`
+       x$(git config -f init-bare-shared-override/config core.sharedRepository)
 '
 
 test_expect_success 'init honors global core.sharedRepository' '
        test_config_global core.sharedRepository 0666 &&
        git init shared-honor-global &&
        test x0666 = \
-       x`git config -f shared-honor-global/.git/config core.sharedRepository`
+       x$(git config -f shared-honor-global/.git/config core.sharedRepository)
 '
 
 test_expect_success 'init rejects insanely long --template' '
@@ -285,7 +285,7 @@ test_expect_success 'init prefers command line to GIT_DIR' '
 test_expect_success 'init with separate gitdir' '
        rm -rf newdir &&
        git init --separate-git-dir realgitdir newdir &&
-       echo "gitdir: `pwd`/realgitdir" >expected &&
+       echo "gitdir: $(pwd)/realgitdir" >expected &&
        test_cmp expected newdir/.git &&
        test_path_is_dir realgitdir/refs
 '
@@ -299,7 +299,7 @@ test_expect_success 're-init to update git link' '
        cd newdir &&
        git init --separate-git-dir ../surrealgitdir
        ) &&
-       echo "gitdir: `pwd`/surrealgitdir" >expected &&
+       echo "gitdir: $(pwd)/surrealgitdir" >expected &&
        test_cmp expected newdir/.git &&
        test_path_is_dir surrealgitdir/refs &&
        test_path_is_missing realgitdir/refs
@@ -312,7 +312,7 @@ test_expect_success 're-init to move gitdir' '
        cd newdir &&
        git init --separate-git-dir ../realgitdir
        ) &&
-       echo "gitdir: `pwd`/realgitdir" >expected &&
+       echo "gitdir: $(pwd)/realgitdir" >expected &&
        test_cmp expected newdir/.git &&
        test_path_is_dir realgitdir/refs
 '
@@ -326,7 +326,7 @@ test_expect_success SYMLINKS 're-init to move gitdir symlink' '
        ln -s here .git &&
        git init --separate-git-dir ../realgitdir
        ) &&
-       echo "gitdir: `pwd`/realgitdir" >expected &&
+       echo "gitdir: $(pwd)/realgitdir" >expected &&
        test_cmp expected newdir/.git &&
        test_cmp expected newdir/here &&
        test_path_is_dir realgitdir/refs
index e45a9e40e432524454e94a041599b201a092879a..5657c5a87b6e253b8c8ca7d18dfa7535c295dc83 100755 (executable)
@@ -14,7 +14,7 @@ do
        git update-index --add infocom
        echo xyzzy >infocom
 
-       files=`git diff-files -p`
+       files=$(git diff-files -p)
        test_expect_success \
        "Racy GIT trial #$trial part A" \
        'test "" != "$files"'
@@ -23,7 +23,7 @@ do
        echo xyzzy >cornerstone
        git update-index --add cornerstone
 
-       files=`git diff-files -p`
+       files=$(git diff-files -p)
        test_expect_success \
        "Racy GIT trial #$trial part B" \
        'test "" != "$files"'
index e526184a0bfa3c8ad2171d0c41a7bee22cf9a04e..d2e51a81bc0897b19f8f087894187ed705ce29e3 100755 (executable)
@@ -20,14 +20,14 @@ test_expect_success setup '
 
        git commit -m initial &&
 
-       one=`git rev-parse HEAD:one` &&
-       dir=`git rev-parse HEAD:dir` &&
-       two=`git rev-parse HEAD:dir/two` &&
-       three=`git rev-parse HEAD:three` &&
+       one=$(git rev-parse HEAD:one) &&
+       dir=$(git rev-parse HEAD:dir) &&
+       two=$(git rev-parse HEAD:dir/two) &&
+       three=$(git rev-parse HEAD:three) &&
 
        for w in Some extra lines here; do echo $w; done >>one &&
        git diff >patch.file &&
-       patched=`git hash-object --stdin <one` &&
+       patched=$(git hash-object --stdin <one) &&
        git read-tree --reset -u HEAD &&
 
        echo happy.
@@ -111,7 +111,7 @@ test_expect_success 'update with autocrlf=input' '
                }
        done &&
 
-       differs=`git diff-index --cached HEAD` &&
+       differs=$(git diff-index --cached HEAD) &&
        test -z "$differs" || {
                echo Oops "$differs"
                false
@@ -135,7 +135,7 @@ test_expect_success 'update with autocrlf=true' '
                }
        done &&
 
-       differs=`git diff-index --cached HEAD` &&
+       differs=$(git diff-index --cached HEAD) &&
        test -z "$differs" || {
                echo Oops "$differs"
                false
@@ -158,9 +158,9 @@ test_expect_success 'checkout with autocrlf=true' '
                        break
                }
        done &&
-       test "$one" = `git hash-object --stdin <one` &&
-       test "$two" = `git hash-object --stdin <dir/two` &&
-       differs=`git diff-index --cached HEAD` &&
+       test "$one" = $(git hash-object --stdin <one) &&
+       test "$two" = $(git hash-object --stdin <dir/two) &&
+       differs=$(git diff-index --cached HEAD) &&
        test -z "$differs" || {
                echo Oops "$differs"
                false
@@ -184,9 +184,9 @@ test_expect_success 'checkout with autocrlf=input' '
                        git update-index -- $f
                fi
        done &&
-       test "$one" = `git hash-object --stdin <one` &&
-       test "$two" = `git hash-object --stdin <dir/two` &&
-       differs=`git diff-index --cached HEAD` &&
+       test "$one" = $(git hash-object --stdin <one) &&
+       test "$two" = $(git hash-object --stdin <dir/two) &&
+       differs=$(git diff-index --cached HEAD) &&
        test -z "$differs" || {
                echo Oops "$differs"
                false
@@ -200,7 +200,7 @@ test_expect_success 'apply patch (autocrlf=input)' '
        git read-tree --reset -u HEAD &&
 
        git apply patch.file &&
-       test "$patched" = "`git hash-object --stdin <one`" || {
+       test "$patched" = "$(git hash-object --stdin <one)" || {
                echo "Eh?  apply without index"
                false
        }
@@ -213,7 +213,7 @@ test_expect_success 'apply patch --cached (autocrlf=input)' '
        git read-tree --reset -u HEAD &&
 
        git apply --cached patch.file &&
-       test "$patched" = `git rev-parse :one` || {
+       test "$patched" = $(git rev-parse :one) || {
                echo "Eh?  apply with --cached"
                false
        }
@@ -226,8 +226,8 @@ test_expect_success 'apply patch --index (autocrlf=input)' '
        git read-tree --reset -u HEAD &&
 
        git apply --index patch.file &&
-       test "$patched" = `git rev-parse :one` &&
-       test "$patched" = `git hash-object --stdin <one` || {
+       test "$patched" = $(git rev-parse :one) &&
+       test "$patched" = $(git hash-object --stdin <one) || {
                echo "Eh?  apply with --index"
                false
        }
@@ -240,7 +240,7 @@ test_expect_success 'apply patch (autocrlf=true)' '
        git read-tree --reset -u HEAD &&
 
        git apply patch.file &&
-       test "$patched" = "`remove_cr <one | git hash-object --stdin`" || {
+       test "$patched" = "$(remove_cr <one | git hash-object --stdin)" || {
                echo "Eh?  apply without index"
                false
        }
@@ -253,7 +253,7 @@ test_expect_success 'apply patch --cached (autocrlf=true)' '
        git read-tree --reset -u HEAD &&
 
        git apply --cached patch.file &&
-       test "$patched" = `git rev-parse :one` || {
+       test "$patched" = $(git rev-parse :one) || {
                echo "Eh?  apply without index"
                false
        }
@@ -266,8 +266,8 @@ test_expect_success 'apply patch --index (autocrlf=true)' '
        git read-tree --reset -u HEAD &&
 
        git apply --index patch.file &&
-       test "$patched" = `git rev-parse :one` &&
-       test "$patched" = "`remove_cr <one | git hash-object --stdin`" || {
+       test "$patched" = $(git rev-parse :one) &&
+       test "$patched" = "$(remove_cr <one | git hash-object --stdin)" || {
                echo "Eh?  apply with --index"
                false
        }
index f5f67a6337320c11a285b78be299fa955663991d..b0e5694ebd07b59e80823cd87825cc9ec8187c21 100755 (executable)
@@ -19,9 +19,9 @@ test_expect_success setup '
 
        git commit -m initial &&
 
-       one=`git rev-parse HEAD:one` &&
-       two=`git rev-parse HEAD:two` &&
-       three=`git rev-parse HEAD:three` &&
+       one=$(git rev-parse HEAD:one) &&
+       two=$(git rev-parse HEAD:two) &&
+       three=$(git rev-parse HEAD:three) &&
 
        echo happy.
 '
@@ -33,9 +33,9 @@ test_expect_success 'default settings cause no changes' '
 
        ! has_cr one &&
        has_cr two &&
-       onediff=`git diff one` &&
-       twodiff=`git diff two` &&
-       threediff=`git diff three` &&
+       onediff=$(git diff one) &&
+       twodiff=$(git diff two) &&
+       threediff=$(git diff three) &&
        test -z "$onediff" -a -z "$twodiff" -a -z "$threediff"
 '
 
@@ -48,7 +48,7 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
 
        # Note, "normalized" means that git will normalize it if added
        has_cr two &&
-       twodiff=`git diff two` &&
+       twodiff=$(git diff two) &&
        test -n "$twodiff"
 '
 
@@ -60,7 +60,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
 
        # Note, "normalized" means that git will normalize it if added
        has_cr two &&
-       twodiff=`git diff two` &&
+       twodiff=$(git diff two) &&
        test -n "$twodiff"
 '
 
@@ -72,7 +72,7 @@ test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false'
        git read-tree --reset -u HEAD &&
 
        has_cr one &&
-       onediff=`git diff one` &&
+       onediff=$(git diff one) &&
        test -z "$onediff"
 '
 
@@ -84,7 +84,7 @@ test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=input'
        git read-tree --reset -u HEAD &&
 
        has_cr one &&
-       onediff=`git diff one` &&
+       onediff=$(git diff one) &&
        test -z "$onediff"
 '
 
@@ -96,7 +96,7 @@ test_expect_success 'eol=lf gives a normalized file LFs with autocrlf=true' '
        git read-tree --reset -u HEAD &&
 
        ! has_cr one &&
-       onediff=`git diff one` &&
+       onediff=$(git diff one) &&
        test -z "$onediff"
 '
 
@@ -108,9 +108,9 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
 
        has_cr one &&
        has_cr two &&
-       onediff=`git diff one` &&
-       twodiff=`git diff two` &&
-       threediff=`git diff three` &&
+       onediff=$(git diff one) &&
+       twodiff=$(git diff two) &&
+       threediff=$(git diff three) &&
        test -z "$onediff" -a -z "$twodiff" -a -z "$threediff"
 '
 
@@ -123,9 +123,9 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
 
        has_cr one &&
        has_cr two &&
-       onediff=`git diff one` &&
-       twodiff=`git diff two` &&
-       threediff=`git diff three` &&
+       onediff=$(git diff one) &&
+       twodiff=$(git diff two) &&
+       threediff=$(git diff three) &&
        test -z "$onediff" -a -n "$twodiff" -a -z "$threediff"
 '
 
@@ -137,7 +137,7 @@ test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
        git read-tree --reset -u HEAD &&
 
        ! has_cr three &&
-       threediff=`git diff three` &&
+       threediff=$(git diff three) &&
        test -z "$threediff"
 '
 
@@ -148,7 +148,7 @@ test_expect_success 'eol=crlf _does_ normalize binary files' '
        git read-tree --reset -u HEAD &&
 
        has_cr three &&
-       threediff=`git diff three` &&
+       threediff=$(git diff three) &&
        test -z "$threediff"
 '
 
index fe0164be62ad9ae7a2ea426c6e576cd1133f3d67..e1126aa7cc05ff61ddf087fe13880da7f48219a6 100755 (executable)
@@ -20,8 +20,8 @@ test_expect_success setup '
 
        git commit -m initial &&
 
-       one=`git rev-parse HEAD:one` &&
-       two=`git rev-parse HEAD:two` &&
+       one=$(git rev-parse HEAD:one) &&
+       two=$(git rev-parse HEAD:two) &&
 
        echo happy.
 '
@@ -34,8 +34,8 @@ test_expect_success 'eol=lf puts LFs in normalized file' '
 
        ! has_cr one &&
        ! has_cr two &&
-       onediff=`git diff one` &&
-       twodiff=`git diff two` &&
+       onediff=$(git diff one) &&
+       twodiff=$(git diff two) &&
        test -z "$onediff" -a -z "$twodiff"
 '
 
@@ -47,8 +47,8 @@ test_expect_success 'eol=crlf puts CRLFs in normalized file' '
 
        has_cr one &&
        ! has_cr two &&
-       onediff=`git diff one` &&
-       twodiff=`git diff two` &&
+       onediff=$(git diff one) &&
+       twodiff=$(git diff two) &&
        test -z "$onediff" -a -z "$twodiff"
 '
 
@@ -61,8 +61,8 @@ test_expect_success 'autocrlf=true overrides eol=lf' '
 
        has_cr one &&
        has_cr two &&
-       onediff=`git diff one` &&
-       twodiff=`git diff two` &&
+       onediff=$(git diff one) &&
+       twodiff=$(git diff two) &&
        test -z "$onediff" -a -z "$twodiff"
 '
 
@@ -75,8 +75,8 @@ test_expect_success 'autocrlf=true overrides unset eol' '
 
        has_cr one &&
        has_cr two &&
-       onediff=`git diff one` &&
-       twodiff=`git diff two` &&
+       onediff=$(git diff one) &&
+       twodiff=$(git diff two) &&
        test -z "$onediff" -a -z "$twodiff"
 '
 
index a8e84d854636178224b1bbd52272d47fc686ece9..0333dd9875af9fbbad04cf05eb9f0e9fe37ae182 100755 (executable)
@@ -225,22 +225,22 @@ test_expect_success \
 
 test_expect_success \
     'text without newline at end should end with newline' '
-    test `printf "$ttt" | git stripspace | wc -l` -gt 0 &&
-    test `printf "$ttt$ttt" | git stripspace | wc -l` -gt 0 &&
-    test `printf "$ttt$ttt$ttt" | git stripspace | wc -l` -gt 0 &&
-    test `printf "$ttt$ttt$ttt$ttt" | git stripspace | wc -l` -gt 0
+    test $(printf "$ttt" | git stripspace | wc -l) -gt 0 &&
+    test $(printf "$ttt$ttt" | git stripspace | wc -l) -gt 0 &&
+    test $(printf "$ttt$ttt$ttt" | git stripspace | wc -l) -gt 0 &&
+    test $(printf "$ttt$ttt$ttt$ttt" | git stripspace | wc -l) -gt 0
 '
 
 # text plus spaces at the end:
 
 test_expect_success \
     'text plus spaces without newline at end should end with newline' '
-    test `printf "$ttt$sss" | git stripspace | wc -l` -gt 0 &&
-    test `printf "$ttt$ttt$sss" | git stripspace | wc -l` -gt 0 &&
-    test `printf "$ttt$ttt$ttt$sss" | git stripspace | wc -l` -gt 0 &&
-    test `printf "$ttt$sss$sss" | git stripspace | wc -l` -gt 0 &&
-    test `printf "$ttt$ttt$sss$sss" | git stripspace | wc -l` -gt 0 &&
-    test `printf "$ttt$sss$sss$sss" | git stripspace | wc -l` -gt 0
+    test $(printf "$ttt$sss" | git stripspace | wc -l) -gt 0 &&
+    test $(printf "$ttt$ttt$sss" | git stripspace | wc -l) -gt 0 &&
+    test $(printf "$ttt$ttt$ttt$sss" | git stripspace | wc -l) -gt 0 &&
+    test $(printf "$ttt$sss$sss" | git stripspace | wc -l) -gt 0 &&
+    test $(printf "$ttt$ttt$sss$sss" | git stripspace | wc -l) -gt 0 &&
+    test $(printf "$ttt$sss$sss$sss" | git stripspace | wc -l) -gt 0
 '
 
 test_expect_success \
index 538ea5fb1c27bf5e4f9c4a0268f219f5d6d6e9c5..57ea5a10c5c716f52a8c8c7335ac7f68fe9dd92d 100755 (executable)
@@ -6,7 +6,7 @@ test_description='basic credential helper tests'
 
 test_expect_success 'setup helper scripts' '
        cat >dump <<-\EOF &&
-       whoami=`echo $0 | sed s/.*git-credential-//`
+       whoami=$(echo $0 | sed s/.*git-credential-//)
        echo >&2 "$whoami: $*"
        OIFS=$IFS
        IFS==
index babcdd23433348cd0e2397b2fb6968f7cfae4b0a..a0b79b4839fb21a96bf8aca769542d93b21bb90f 100755 (executable)
@@ -519,10 +519,10 @@ test_expect_success \
     'rm -f .git/index F16 &&
     echo F16 >F16 &&
     git update-index --add F16 &&
-    tree0=`git write-tree` &&
+    tree0=$(git write-tree) &&
     echo E16 >F16 &&
     git update-index F16 &&
-    tree1=`git write-tree` &&
+    tree1=$(git write-tree) &&
     read_tree_must_succeed -m $tree0 $tree1 $tree1 $tree0 &&
     git ls-files --stage'
 
index 3a24abf5496c76862e772907442dc24bdcb4d78a..db1b6f5cf4dd8c7932946a53bc2e1c30b09b762b 100755 (executable)
@@ -36,7 +36,7 @@ compare_change () {
 }
 
 check_cache_at () {
-       clean_if_empty=`git diff-files -- "$1"`
+       clean_if_empty=$(git diff-files -- "$1")
        case "$clean_if_empty" in
        '')  echo "$1: clean" ;;
        ?*)  echo "$1: dirty" ;;
@@ -68,14 +68,14 @@ test_expect_success \
      echo rezrov >rezrov &&
      echo yomin >yomin &&
      git update-index --add nitfol bozbar rezrov &&
-     treeH=`git write-tree` &&
+     treeH=$(git write-tree) &&
      echo treeH $treeH &&
      git ls-tree $treeH &&
 
      cat bozbar-new >bozbar &&
      git update-index --add frotz bozbar --force-remove rezrov &&
      git ls-files --stage >M.out &&
-     treeM=`git write-tree` &&
+     treeM=$(git write-tree) &&
      echo treeM $treeM &&
      git ls-tree $treeM &&
      git diff-tree $treeH $treeM'
@@ -315,7 +315,7 @@ test_expect_success \
     'rm -f .git/index &&
      echo DF >DF &&
      git update-index --add DF &&
-     treeDF=`git write-tree` &&
+     treeDF=$(git write-tree) &&
      echo treeDF $treeDF &&
      git ls-tree $treeDF &&
 
@@ -323,7 +323,7 @@ test_expect_success \
      mkdir DF &&
      echo DF/DF >DF/DF &&
      git update-index --add --remove DF DF/DF &&
-     treeDFDF=`git write-tree` &&
+     treeDFDF=$(git write-tree) &&
      echo treeDFDF $treeDFDF &&
      git ls-tree $treeDFDF &&
      git ls-files --stage >DFDF.out'
@@ -345,7 +345,7 @@ test_expect_success \
     'rm -f .git/index &&
      : >a &&
      git update-index --add a &&
-     treeM=`git write-tree` &&
+     treeM=$(git write-tree) &&
      echo treeM $treeM &&
      git ls-tree $treeM &&
      git ls-files --stage >treeM.out &&
@@ -354,7 +354,7 @@ test_expect_success \
      git update-index --remove a &&
      mkdir a &&
      : >a/b &&
-     treeH=`git write-tree` &&
+     treeH=$(git write-tree) &&
      echo treeH $treeH &&
      git ls-tree $treeH'
 
@@ -372,7 +372,7 @@ test_expect_success \
      mkdir c &&
      : >c/d &&
      git update-index --add a c/d &&
-     treeM=`git write-tree` &&
+     treeM=$(git write-tree) &&
      echo treeM $treeM &&
      git ls-tree $treeM &&
      git ls-files --stage >treeM.out &&
@@ -381,7 +381,7 @@ test_expect_success \
      mkdir a &&
      : >a/b &&
      git update-index --add --remove a a/b &&
-     treeH=`git write-tree` &&
+     treeH=$(git write-tree) &&
      echo treeH $treeH &&
      git ls-tree $treeH'
 
index a847709a1354a824c90a13d2c9e9ab6d6bc69b6c..fed877b20f428a1987357ad1f66dc678f5c7e2eb 100755 (executable)
@@ -21,7 +21,7 @@ compare_change () {
 }
 
 check_cache_at () {
-       clean_if_empty=`git diff-files -- "$1"`
+       clean_if_empty=$(git diff-files -- "$1")
        case "$clean_if_empty" in
        '')  echo "$1: clean" ;;
        ?*)  echo "$1: dirty" ;;
@@ -41,14 +41,14 @@ test_expect_success \
      echo bozbar >bozbar &&
      echo rezrov >rezrov &&
      git update-index --add nitfol bozbar rezrov &&
-     treeH=`git write-tree` &&
+     treeH=$(git write-tree) &&
      echo treeH $treeH &&
      git ls-tree $treeH &&
 
      echo gnusto >bozbar &&
      git update-index --add frotz bozbar --force-remove rezrov &&
      git ls-files --stage >M.out &&
-     treeM=`git write-tree` &&
+     treeM=$(git write-tree) &&
      echo treeM $treeM &&
      git ls-tree $treeM &&
      sum bozbar frotz nitfol >M.sum &&
@@ -318,7 +318,7 @@ test_expect_success \
     'rm -f .git/index &&
      echo DF >DF &&
      git update-index --add DF &&
-     treeDF=`git write-tree` &&
+     treeDF=$(git write-tree) &&
      echo treeDF $treeDF &&
      git ls-tree $treeDF &&
 
@@ -326,7 +326,7 @@ test_expect_success \
      mkdir DF &&
      echo DF/DF >DF/DF &&
      git update-index --add --remove DF DF/DF &&
-     treeDFDF=`git write-tree` &&
+     treeDFDF=$(git write-tree) &&
      echo treeDFDF $treeDFDF &&
      git ls-tree $treeDFDF &&
      git ls-files --stage >DFDF.out'
index 8c6d67edda1468ba0f1c7afc6d13ea3a7bbe0a90..b6111cd150fdd69973142808cf4a86a4fa6b7e76 100755 (executable)
@@ -11,7 +11,7 @@ test_description='git read-tree --prefix test.
 test_expect_success setup '
        echo hello >one &&
        git update-index --add one &&
-       tree=`git write-tree` &&
+       tree=$(git write-tree) &&
        echo tree is $tree
 '
 
index 3e72aff470f8d9e5e79689de459904d1f3271d0d..c70cf423008cfb6f3f3fd735c1f6ee2d1408de2c 100755 (executable)
@@ -30,7 +30,7 @@ test_expect_success 'two-way not clobbering' '
 
        echo >file2 master creates untracked file2 &&
        echo >subdir/file2 master creates untracked subdir/file2 &&
-       if err=`read_tree_u_must_succeed -m -u master side 2>&1`
+       if err=$(read_tree_u_must_succeed -m -u master side 2>&1)
        then
                echo should have complained
                false
@@ -43,7 +43,7 @@ echo file2 >.gitignore
 
 test_expect_success 'two-way with incorrect --exclude-per-directory (1)' '
 
-       if err=`read_tree_u_must_succeed -m --exclude-per-directory=.gitignore master side 2>&1`
+       if err=$(read_tree_u_must_succeed -m --exclude-per-directory=.gitignore master side 2>&1)
        then
                echo should have complained
                false
@@ -54,7 +54,7 @@ test_expect_success 'two-way with incorrect --exclude-per-directory (1)' '
 
 test_expect_success 'two-way with incorrect --exclude-per-directory (2)' '
 
-       if err=`read_tree_u_must_succeed -m -u --exclude-per-directory=foo --exclude-per-directory=.gitignore master side 2>&1`
+       if err=$(read_tree_u_must_succeed -m -u --exclude-per-directory=foo --exclude-per-directory=.gitignore master side 2>&1)
        then
                echo should have complained
                false
@@ -95,7 +95,7 @@ test_expect_success 'three-way not clobbering a working tree file' '
        git checkout master &&
        echo >file3 file three created in master, untracked &&
        echo >subdir/file3 file three created in master, untracked &&
-       if err=`read_tree_u_must_succeed -m -u branch-point master side 2>&1`
+       if err=$(read_tree_u_must_succeed -m -u branch-point master side 2>&1)
        then
                echo should have complained
                false
index 6902320e819651553beac7d80971b984b9168a8a..62c0d25af4ca1c8ef5d0d63b6e3ea329a6d75205 100755 (executable)
@@ -20,27 +20,27 @@ test_expect_success setup '
 
 test_expect_success 'update-index and ls-files' '
        git update-index --add one &&
-       case "`git ls-files`" in
+       case "$(git ls-files)" in
        one) echo pass one ;;
        *) echo bad one; exit 1 ;;
        esac &&
        (
                cd dir &&
                git update-index --add two &&
-               case "`git ls-files`" in
+               case "$(git ls-files)" in
                two) echo pass two ;;
                *) echo bad two; exit 1 ;;
                esac
        ) &&
-       case "`git ls-files`" in
+       case "$(git ls-files)" in
        dir/two"$LF"one) echo pass both ;;
        *) echo bad; exit 1 ;;
        esac
 '
 
 test_expect_success 'cat-file' '
-       two=`git ls-files -s dir/two` &&
-       two=`expr "$two" : "[0-7]* \\([0-9a-f]*\\)"` &&
+       two=$(git ls-files -s dir/two) &&
+       two=$(expr "$two" : "[0-7]* \\([0-9a-f]*\\)") &&
        echo "$two" &&
        git cat-file -p "$two" >actual &&
        cmp dir/two actual &&
@@ -55,18 +55,18 @@ rm -f actual dir/actual
 test_expect_success 'diff-files' '
        echo a >>one &&
        echo d >>dir/two &&
-       case "`git diff-files --name-only`" in
+       case "$(git diff-files --name-only)" in
        dir/two"$LF"one) echo pass top ;;
        *) echo bad top; exit 1 ;;
        esac &&
        # diff should not omit leading paths
        (
                cd dir &&
-               case "`git diff-files --name-only`" in
+               case "$(git diff-files --name-only)" in
                dir/two"$LF"one) echo pass subdir ;;
                *) echo bad subdir; exit 1 ;;
                esac &&
-               case "`git diff-files --name-only .`" in
+               case "$(git diff-files --name-only .)" in
                dir/two) echo pass subdir limited ;;
                *) echo bad subdir limited; exit 1 ;;
                esac
@@ -74,11 +74,11 @@ test_expect_success 'diff-files' '
 '
 
 test_expect_success 'write-tree' '
-       top=`git write-tree` &&
+       top=$(git write-tree) &&
        echo $top &&
        (
                cd dir &&
-               sub=`git write-tree` &&
+               sub=$(git write-tree) &&
                echo $sub &&
                test "z$top" = "z$sub"
        )
@@ -96,7 +96,7 @@ test_expect_success 'checkout-index' '
 
 test_expect_success 'read-tree' '
        rm -f one dir/two &&
-       tree=`git write-tree` &&
+       tree=$(git write-tree) &&
        read_tree_u_must_succeed --reset -u "$tree" &&
        cmp one original.one &&
        cmp dir/two original.two &&
index fd105280092b7f655f5c48f09b2e8f5e0ee6d351..aea493646e4400e733749768e48f2a3d1a470299 100755 (executable)
@@ -131,7 +131,7 @@ test_expect_success 'git-show a large file' '
 '
 
 test_expect_success 'index-pack' '
-       git clone file://"`pwd`"/.git foo &&
+       git clone file://"$(pwd)"/.git foo &&
        GIT_DIR=non-existent git index-pack --strict --verify foo/.git/objects/pack/*.pack
 '
 
@@ -140,7 +140,7 @@ test_expect_success 'repack' '
 '
 
 test_expect_success 'pack-objects with large loose object' '
-       SHA1=`git hash-object huge` &&
+       SHA1=$(git hash-object huge) &&
        test_create_repo loose &&
        echo $SHA1 | git pack-objects --stdout |
                GIT_ALLOC_LIMIT=0 GIT_DIR=loose/.git git unpack-objects &&
index 58cd5435be59107c3bac323e0d53816ab0f8e4ae..3f80ff0c14c47b87bbbecb74d1951a1abe6bc5ba 100755 (executable)
@@ -1158,4 +1158,14 @@ test_expect_failure 'adding a key into an empty section reuses header' '
        test_cmp expect .git/config
 '
 
+test_expect_success POSIXPERM,PERL 'preserves existing permissions' '
+       chmod 0600 .git/config &&
+       git config imap.pass Hunter2 &&
+       perl -e \
+         "die q(badset) if ((stat(q(.git/config)))[2] & 07777) != 0600" &&
+       git config --rename-section imap pop &&
+       perl -e \
+         "die q(badrename) if ((stat(q(.git/config)))[2] & 07777) != 0600"
+'
+
 test_done
index e130c528fe5a0115c99b1203cfe9dced046cece3..4e2459afc549d5d2985024e8c23bf5fa117d570a 100755 (executable)
@@ -350,22 +350,28 @@ test_expect_success 'stdin fails on unknown command' '
        grep "fatal: unknown command: unknown $a" err
 '
 
-test_expect_success 'stdin fails on badly quoted input' '
+test_expect_success 'stdin fails on unbalanced quotes' '
        echo "create $a \"master" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
        grep "fatal: badly quoted argument: \\\"master" err
 '
 
-test_expect_success 'stdin fails on arguments not separated by space' '
+test_expect_success 'stdin fails on invalid escape' '
+       echo "create $a \"ma\zter\"" >stdin &&
+       test_must_fail git update-ref --stdin <stdin 2>err &&
+       grep "fatal: badly quoted argument: \\\"ma\\\\zter\\\"" err
+'
+
+test_expect_success 'stdin fails on junk after quoted argument' '
        echo "create \"$a\"master" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: expected SP but got: master" err
+       grep "fatal: unexpected character after quoted argument: \\\"$a\\\"master" err
 '
 
 test_expect_success 'stdin fails create with no ref' '
        echo "create " >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: create line missing <ref>" err
+       grep "fatal: create: missing <ref>" err
 '
 
 test_expect_success 'stdin fails create with bad ref name' '
@@ -377,19 +383,19 @@ test_expect_success 'stdin fails create with bad ref name' '
 test_expect_success 'stdin fails create with no new value' '
        echo "create $a" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: create $a missing <newvalue>" err
+       grep "fatal: create $a: missing <newvalue>" err
 '
 
 test_expect_success 'stdin fails create with too many arguments' '
        echo "create $a $m $m" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: create $a has extra input:  $m" err
+       grep "fatal: create $a: extra input:  $m" err
 '
 
 test_expect_success 'stdin fails update with no ref' '
        echo "update " >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: update line missing <ref>" err
+       grep "fatal: update: missing <ref>" err
 '
 
 test_expect_success 'stdin fails update with bad ref name' '
@@ -401,19 +407,19 @@ test_expect_success 'stdin fails update with bad ref name' '
 test_expect_success 'stdin fails update with no new value' '
        echo "update $a" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: update $a missing <newvalue>" err
+       grep "fatal: update $a: missing <newvalue>" err
 '
 
 test_expect_success 'stdin fails update with too many arguments' '
        echo "update $a $m $m $m" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: update $a has extra input:  $m" err
+       grep "fatal: update $a: extra input:  $m" err
 '
 
 test_expect_success 'stdin fails delete with no ref' '
        echo "delete " >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: delete line missing <ref>" err
+       grep "fatal: delete: missing <ref>" err
 '
 
 test_expect_success 'stdin fails delete with bad ref name' '
@@ -425,13 +431,13 @@ test_expect_success 'stdin fails delete with bad ref name' '
 test_expect_success 'stdin fails delete with too many arguments' '
        echo "delete $a $m $m" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: delete $a has extra input:  $m" err
+       grep "fatal: delete $a: extra input:  $m" err
 '
 
 test_expect_success 'stdin fails verify with too many arguments' '
        echo "verify $a $m $m" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: verify $a has extra input:  $m" err
+       grep "fatal: verify $a: extra input:  $m" err
 '
 
 test_expect_success 'stdin fails option with unknown name' '
@@ -458,6 +464,24 @@ test_expect_success 'stdin create ref works' '
        test_cmp expect actual
 '
 
+test_expect_success 'stdin succeeds with quoted argument' '
+       git update-ref -d $a &&
+       echo "create $a \"$m\"" >stdin &&
+       git update-ref --stdin <stdin &&
+       git rev-parse $m >expect &&
+       git rev-parse $a >actual &&
+       test_cmp expect actual
+'
+
+test_expect_success 'stdin succeeds with escaped character' '
+       git update-ref -d $a &&
+       echo "create $a \"ma\\163ter\"" >stdin &&
+       git update-ref --stdin <stdin &&
+       git rev-parse $m >expect &&
+       git rev-parse $a >actual &&
+       test_cmp expect actual
+'
+
 test_expect_success 'stdin update ref creates with zero old value' '
        echo "update $b $m $Z" >stdin &&
        git update-ref --stdin <stdin &&
@@ -494,21 +518,21 @@ test_expect_success 'stdin update ref fails with wrong old value' '
 test_expect_success 'stdin update ref fails with bad old value' '
        echo "update $c $m does-not-exist" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: invalid old value for ref $c: does-not-exist" err &&
+       grep "fatal: update $c: invalid <oldvalue>: does-not-exist" err &&
        test_must_fail git rev-parse --verify -q $c
 '
 
 test_expect_success 'stdin create ref fails with bad new value' '
        echo "create $c does-not-exist" >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: invalid new value for ref $c: does-not-exist" err &&
+       grep "fatal: create $c: invalid <newvalue>: does-not-exist" err &&
        test_must_fail git rev-parse --verify -q $c
 '
 
 test_expect_success 'stdin create ref fails with zero new value' '
        echo "create $c " >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: create $c given zero new value" err &&
+       grep "fatal: create $c: zero <newvalue>" err &&
        test_must_fail git rev-parse --verify -q $c
 '
 
@@ -532,7 +556,7 @@ test_expect_success 'stdin delete ref fails with wrong old value' '
 test_expect_success 'stdin delete ref fails with zero old value' '
        echo "delete $a " >stdin &&
        test_must_fail git update-ref --stdin <stdin 2>err &&
-       grep "fatal: delete $a given zero old value" err &&
+       grep "fatal: delete $a: zero <oldvalue>" err &&
        git rev-parse $m >expect &&
        git rev-parse $a >actual &&
        test_cmp expect actual
@@ -673,7 +697,7 @@ test_expect_success 'stdin -z fails on unknown command' '
 test_expect_success 'stdin -z fails create with no ref' '
        printf $F "create " >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: create line missing <ref>" err
+       grep "fatal: create: missing <ref>" err
 '
 
 test_expect_success 'stdin -z fails create with bad ref name' '
@@ -685,7 +709,7 @@ test_expect_success 'stdin -z fails create with bad ref name' '
 test_expect_success 'stdin -z fails create with no new value' '
        printf $F "create $a" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: create $a missing <newvalue>" err
+       grep "fatal: create $a: unexpected end of input when reading <newvalue>" err
 '
 
 test_expect_success 'stdin -z fails create with too many arguments' '
@@ -697,25 +721,39 @@ test_expect_success 'stdin -z fails create with too many arguments' '
 test_expect_success 'stdin -z fails update with no ref' '
        printf $F "update " >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: update line missing <ref>" err
+       grep "fatal: update: missing <ref>" err
+'
+
+test_expect_success 'stdin -z fails update with too few args' '
+       printf $F "update $a" "$m" >stdin &&
+       test_must_fail git update-ref -z --stdin <stdin 2>err &&
+       grep "fatal: update $a: unexpected end of input when reading <oldvalue>" err
 '
 
 test_expect_success 'stdin -z fails update with bad ref name' '
-       printf $F "update ~a" "$m" >stdin &&
+       printf $F "update ~a" "$m" "" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
        grep "fatal: invalid ref format: ~a" err
 '
 
+test_expect_success 'stdin -z emits warning with empty new value' '
+       git update-ref $a $m &&
+       printf $F "update $a" "" "" >stdin &&
+       git update-ref -z --stdin <stdin 2>err &&
+       grep "warning: update $a: missing <newvalue>, treating as zero" err &&
+       test_must_fail git rev-parse --verify -q $a
+'
+
 test_expect_success 'stdin -z fails update with no new value' '
        printf $F "update $a" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: update $a missing <newvalue>" err
+       grep "fatal: update $a: unexpected end of input when reading <newvalue>" err
 '
 
 test_expect_success 'stdin -z fails update with no old value' '
        printf $F "update $a" "$m" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: update $a missing \\[<oldvalue>\\] NUL" err
+       grep "fatal: update $a: unexpected end of input when reading <oldvalue>" err
 '
 
 test_expect_success 'stdin -z fails update with too many arguments' '
@@ -727,7 +765,7 @@ test_expect_success 'stdin -z fails update with too many arguments' '
 test_expect_success 'stdin -z fails delete with no ref' '
        printf $F "delete " >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: delete line missing <ref>" err
+       grep "fatal: delete: missing <ref>" err
 '
 
 test_expect_success 'stdin -z fails delete with bad ref name' '
@@ -739,7 +777,7 @@ test_expect_success 'stdin -z fails delete with bad ref name' '
 test_expect_success 'stdin -z fails delete with no old value' '
        printf $F "delete $a" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: delete $a missing \\[<oldvalue>\\] NUL" err
+       grep "fatal: delete $a: unexpected end of input when reading <oldvalue>" err
 '
 
 test_expect_success 'stdin -z fails delete with too many arguments' '
@@ -757,7 +795,7 @@ test_expect_success 'stdin -z fails verify with too many arguments' '
 test_expect_success 'stdin -z fails verify with no old value' '
        printf $F "verify $a" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: verify $a missing \\[<oldvalue>\\] NUL" err
+       grep "fatal: verify $a: unexpected end of input when reading <oldvalue>" err
 '
 
 test_expect_success 'stdin -z fails option with unknown name' '
@@ -816,7 +854,7 @@ test_expect_success 'stdin -z update ref fails with wrong old value' '
 test_expect_success 'stdin -z update ref fails with bad old value' '
        printf $F "update $c" "$m" "does-not-exist" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: invalid old value for ref $c: does-not-exist" err &&
+       grep "fatal: update $c: invalid <oldvalue>: does-not-exist" err &&
        test_must_fail git rev-parse --verify -q $c
 '
 
@@ -834,14 +872,14 @@ test_expect_success 'stdin -z create ref fails with bad new value' '
        git update-ref -d "$c" &&
        printf $F "create $c" "does-not-exist" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: invalid new value for ref $c: does-not-exist" err &&
+       grep "fatal: create $c: invalid <newvalue>: does-not-exist" err &&
        test_must_fail git rev-parse --verify -q $c
 '
 
-test_expect_success 'stdin -z create ref fails with zero new value' '
+test_expect_success 'stdin -z create ref fails with empty new value' '
        printf $F "create $c" "" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: create $c given zero new value" err &&
+       grep "fatal: create $c: missing <newvalue>" err &&
        test_must_fail git rev-parse --verify -q $c
 '
 
@@ -865,7 +903,7 @@ test_expect_success 'stdin -z delete ref fails with wrong old value' '
 test_expect_success 'stdin -z delete ref fails with zero old value' '
        printf $F "delete $a" "$Z" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
-       grep "fatal: delete $a given zero old value" err &&
+       grep "fatal: delete $a: zero <oldvalue>" err &&
        git rev-parse $m >expect &&
        git rev-parse $a >actual &&
        test_cmp expect actual
@@ -923,7 +961,7 @@ test_expect_success 'stdin -z update refs works with identity updates' '
 
 test_expect_success 'stdin -z update refs fails with wrong old value' '
        git update-ref $c $m &&
-       printf $F "update $a" "$m" "$m" "update $b" "$m" "$m" "update $c" "" "$Z" >stdin &&
+       printf $F "update $a" "$m" "$m" "update $b" "$m" "$m" "update $c" "$m" "$Z" >stdin &&
        test_must_fail git update-ref -z --stdin <stdin 2>err &&
        grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err &&
        git rev-parse $m >expect &&
index 236b13a3ab27f54808fa88574738747e3c3936b1..8cab06f90a52b82518aca6f7baa0530eb77ab986 100755 (executable)
@@ -245,4 +245,12 @@ test_expect_success 'gc.reflogexpire=false' '
 
 '
 
+test_expect_success 'checkout should not delete log for packed ref' '
+       test $(git reflog master | wc -l) = 4 &&
+       git branch foo &&
+       git pack-refs --all &&
+       git checkout foo &&
+       test $(git reflog master | wc -l) = 4
+'
+
 test_done
index 178694ee63937a9ec1f8d182d54441c2d20bd4a3..1978947c4196fb666d55395bedc53ae149b6d13d 100755 (executable)
@@ -121,7 +121,7 @@ test_expect_success 'merge my-side@{u} records the correct name' '
        git branch -D new ;# can fail but is ok
        git branch -t new my-side@{u} &&
        git merge -s ours new@{u} &&
-       git show -s --pretty=format:%s >actual &&
+       git show -s --pretty=tformat:%s >actual &&
        echo "Merge remote-tracking branch ${sq}origin/side${sq}" >expect &&
        test_cmp expect actual
 )
index c0023a5b4ff6ef60f5d77e9e54a64adf387bce6e..8197ed29a9ecedb43679200f1485a7b50984fdff 100755 (executable)
@@ -67,6 +67,14 @@ test_expect_success 'setup' '
 SHELL=
 export SHELL
 
+test_expect_success 'rebase --keep-empty' '
+       git checkout -b emptybranch master &&
+       git commit --allow-empty -m "empty" &&
+       git rebase --keep-empty -i HEAD~2 &&
+       git log --oneline >actual &&
+       test_line_count = 6 actual
+'
+
 test_expect_success 'rebase -i with the exec command' '
        git checkout master &&
        (
index 19c99d7ef1bc02e67a7b995206b9f66c04c1b31c..b457333e1865de794e47fa6b601648fd67a02a7c 100755 (executable)
@@ -65,12 +65,15 @@ test_expect_success 'output to keep user entertained during multi-pick' '
        cat <<-\EOF >expected &&
        [master OBJID] second
         Author: A U Thor <author@example.com>
+        Date: Thu Apr 7 15:14:13 2005 -0700
         1 file changed, 1 insertion(+)
        [master OBJID] third
         Author: A U Thor <author@example.com>
+        Date: Thu Apr 7 15:15:13 2005 -0700
         1 file changed, 1 insertion(+)
        [master OBJID] fourth
         Author: A U Thor <author@example.com>
+        Date: Thu Apr 7 15:16:13 2005 -0700
         1 file changed, 1 insertion(+)
        EOF
 
@@ -98,14 +101,17 @@ test_expect_success 'output during multi-pick indicates merge strategy' '
        Trying simple merge.
        [master OBJID] second
         Author: A U Thor <author@example.com>
+        Date: Thu Apr 7 15:14:13 2005 -0700
         1 file changed, 1 insertion(+)
        Trying simple merge.
        [master OBJID] third
         Author: A U Thor <author@example.com>
+        Date: Thu Apr 7 15:15:13 2005 -0700
         1 file changed, 1 insertion(+)
        Trying simple merge.
        [master OBJID] fourth
         Author: A U Thor <author@example.com>
+        Date: Thu Apr 7 15:16:13 2005 -0700
         1 file changed, 1 insertion(+)
        EOF
 
index a5e7e6b2ba3138d06c400e965decf1389da3274a..f372fc8ca8e3b311b03313a46db1aa8f35de2ea9 100755 (executable)
@@ -96,8 +96,8 @@ test_expect_success 'stash pop after save --include-untracked leaves files untra
        git stash pop &&
        git status --porcelain >actual &&
        test_cmp expect actual &&
-       test "1" = "`cat file2`" &&
-       test untracked = "`cat untracked/untracked`"
+       test "1" = "$(cat file2)" &&
+       test untracked = "$(cat untracked/untracked)"
 '
 
 git clean --force --quiet -d
index e4ba6013e41927bc0ec3ff3876648a71a71ce6e1..831935665e012c04bbe4c57feee92c0310df5c04 100755 (executable)
@@ -14,13 +14,13 @@ then
 fi
 
 # create utf-8 variables
-Adiarnfc=`printf '\303\204'`
-Adiarnfd=`printf 'A\314\210'`
+Adiarnfc=$(printf '\303\204')
+Adiarnfd=$(printf 'A\314\210')
 
-Odiarnfc=`printf '\303\226'`
-Odiarnfd=`printf 'O\314\210'`
-AEligatu=`printf '\303\206'`
-Invalidu=`printf '\303\377'`
+Odiarnfc=$(printf '\303\226')
+Odiarnfd=$(printf 'O\314\210')
+AEligatu=$(printf '\303\206')
+Invalidu=$(printf '\303\377')
 
 
 #Create a string with 255 bytes (decomposed)
@@ -35,7 +35,7 @@ Alongc=$Alongc$Alongc$Alongc$Alongc$Alongc           #250 Byte
 Alongc=$Alongc$AEligatu$AEligatu                     #254 Byte
 
 test_expect_success "detect if nfd needed" '
-       precomposeunicode=`git config core.precomposeunicode` &&
+       precomposeunicode=$(git config core.precomposeunicode) &&
        test "$precomposeunicode" = true &&
        git config core.precomposeunicode true
 '
@@ -140,13 +140,23 @@ test_expect_success "Add long precomposed filename" '
        git add * &&
        git commit -m "Long filename"
 '
+
+test_expect_failure 'handle existing decomposed filenames' '
+       echo content >"verbatim.$Adiarnfd" &&
+       git -c core.precomposeunicode=false add "verbatim.$Adiarnfd" &&
+       git commit -m "existing decomposed file" &&
+       >expect &&
+       git ls-files --exclude-standard -o "verbatim*" >untracked &&
+       test_cmp expect untracked
+'
+
 # Test if the global core.precomposeunicode stops autosensing
 # Must be the last test case
 test_expect_success "respect git config --global core.precomposeunicode" '
        git config --global core.precomposeunicode true &&
        rm -rf .git &&
        git init &&
-       precomposeunicode=`git config core.precomposeunicode` &&
+       precomposeunicode=$(git config core.precomposeunicode) &&
        test "$precomposeunicode" = "true"
 '
 
index 05911492ca6df386bfe344ffcfb9562beeaceabf..76f643b2c2a2c7e307135de6942cf46743b6cbef 100755 (executable)
@@ -13,7 +13,7 @@ sed_script='s/\(:100644 100755\) \('"$_x40"'\) \2 /\1 X X /'
 test_expect_success 'setup' '
        echo frotz >rezrov &&
        git update-index --add rezrov &&
-       tree=`git write-tree` &&
+       tree=$(git write-tree) &&
        echo $tree
 '
 
index 2bb973655bf043cc43292764ffd68becda25aa2e..bf078418662c4bab4e512be8fc22a5aa76466119 100755 (executable)
@@ -18,7 +18,7 @@ test_expect_success \
      mkdir path1 &&
      echo rezrov >path1/file1 &&
      git update-index --add file0 path1/file1 &&
-     tree=`git write-tree` &&
+     tree=$(git write-tree) &&
      echo "$tree" &&
      echo nitfol >file0 &&
      echo yomin >path1/file1 &&
@@ -131,7 +131,7 @@ test_expect_success 'diff multiple wildcard pathspecs' '
        mkdir path2 &&
        echo rezrov >path2/file1 &&
        git update-index --add path2/file1 &&
-       tree3=`git write-tree` &&
+       tree3=$(git write-tree) &&
        git diff --name-only $tree $tree3 -- "path2*1" "path1*1" >actual &&
        cat <<-\EOF >expect &&
        path1/file1
index 1215ae544b6915fe2cc6df4d193c8f3a805beba1..643d729157d23ce501258710640e4090c34922fc 100755 (executable)
@@ -67,18 +67,18 @@ test_expect_success C_LOCALE_OUTPUT 'apply detecting corrupt patch correctly' '
        git diff >output &&
        sed -e "s/-CIT/xCIT/" <output >broken &&
        test_must_fail git apply --stat --summary broken 2>detected &&
-       detected=`cat detected` &&
-       detected=`expr "$detected" : "fatal.*at line \\([0-9]*\\)\$"` &&
-       detected=`sed -ne "${detected}p" broken` &&
+       detected=$(cat detected) &&
+       detected=$(expr "$detected" : "fatal.*at line \\([0-9]*\\)\$") &&
+       detected=$(sed -ne "${detected}p" broken) &&
        test "$detected" = xCIT
 '
 
 test_expect_success C_LOCALE_OUTPUT 'apply detecting corrupt patch correctly' '
        git diff --binary | sed -e "s/-CIT/xCIT/" >broken &&
        test_must_fail git apply --stat --summary broken 2>detected &&
-       detected=`cat detected` &&
-       detected=`expr "$detected" : "fatal.*at line \\([0-9]*\\)\$"` &&
-       detected=`sed -ne "${detected}p" broken` &&
+       detected=$(cat detected) &&
+       detected=$(expr "$detected" : "fatal.*at line \\([0-9]*\\)\$") &&
+       detected=$(sed -ne "${detected}p" broken) &&
        test "$detected" = xCIT
 '
 
@@ -88,7 +88,7 @@ test_expect_success 'initial commit' 'git commit -a -m initial'
 test_expect_success 'diff-index with --binary' '
        echo AIT >a && mv b e && echo CIT >c && cat e >d &&
        git update-index --add --remove a b c d e &&
-       tree0=`git write-tree` &&
+       tree0=$(git write-tree) &&
        git diff --cached --binary >current &&
        git apply --stat --summary current
 '
@@ -96,7 +96,7 @@ test_expect_success 'diff-index with --binary' '
 test_expect_success 'apply binary patch' '
        git reset --hard &&
        git apply --binary --index <current &&
-       tree1=`git write-tree` &&
+       tree1=$(git write-tree) &&
        test "$tree1" = "$tree0"
 '
 
index e77c09c37eede2f039610199ba8e3c45e94213d4..805b055c899e7c9f5653eb740572f67417c9dcb6 100755 (executable)
@@ -107,14 +107,14 @@ test_expect_success setup '
 +*++ [initial] Initial
 EOF
 
-V=`git version | sed -e 's/^git version //' -e 's/\./\\./g'`
+V=$(git version | sed -e 's/^git version //' -e 's/\./\\./g')
 while read cmd
 do
        case "$cmd" in
        '' | '#'*) continue ;;
        esac
-       test=`echo "$cmd" | sed -e 's|[/ ][/ ]*|_|g'`
-       pfx=`printf "%04d" $test_count`
+       test=$(echo "$cmd" | sed -e 's|[/ ][/ ]*|_|g')
+       pfx=$(printf "%04d" $test_count)
        expect="$TEST_DIRECTORY/t4013/diff.$test"
        actual="$pfx-diff.$test"
 
index 9c8063314688ec0c03d3fb2099379cbbf4ff2e19..282bee4a54c924b8168b6a28dfdbeb7ab300d7b7 100755 (executable)
@@ -43,7 +43,7 @@ test_expect_success setup '
 test_expect_success "format-patch --ignore-if-in-upstream" '
 
        git format-patch --stdout master..side >patch0 &&
-       cnt=`grep "^From " patch0 | wc -l` &&
+       cnt=$(grep "^From " patch0 | wc -l) &&
        test $cnt = 3
 
 '
@@ -52,7 +52,7 @@ test_expect_success "format-patch --ignore-if-in-upstream" '
 
        git format-patch --stdout \
                --ignore-if-in-upstream master..side >patch1 &&
-       cnt=`grep "^From " patch1 | wc -l` &&
+       cnt=$(grep "^From " patch1 | wc -l) &&
        test $cnt = 2
 
 '
@@ -69,7 +69,7 @@ test_expect_success "format-patch doesn't consider merge commits" '
        git checkout -b merger master &&
        test_tick &&
        git merge --no-ff slave &&
-       cnt=`git format-patch -3 --stdout | grep "^From " | wc -l` &&
+       cnt=$(git format-patch -3 --stdout | grep "^From " | wc -l) &&
        test $cnt = 3
 '
 
@@ -77,7 +77,7 @@ test_expect_success "format-patch result applies" '
 
        git checkout -b rebuild-0 master &&
        git am -3 patch0 &&
-       cnt=`git rev-list master.. | wc -l` &&
+       cnt=$(git rev-list master.. | wc -l) &&
        test $cnt = 2
 '
 
@@ -85,7 +85,7 @@ test_expect_success "format-patch --ignore-if-in-upstream result applies" '
 
        git checkout -b rebuild-1 master &&
        git am -3 patch1 &&
-       cnt=`git rev-list master.. | wc -l` &&
+       cnt=$(git rev-list master.. | wc -l) &&
        test $cnt = 2
 '
 
index ba43f185494630c50fc2a168df8dcd45c0b2421b..98d9713d8b2454eb1dfc4f137133a7cb0174bd0d 100755 (executable)
@@ -42,7 +42,7 @@ test_expect_success 'attach and signoff do not duplicate mime headers' '
 
        GIT_COMMITTER_NAME="はまの ふにおう" \
        git format-patch -s --stdout -1 --attach >output &&
-       test `grep -ci ^MIME-Version: output` = 1
+       test $(grep -ci ^MIME-Version: output) = 1
 
 '
 
index 1019d7b35fcb350761a44cf4ccd5ae156ce8d577..41913c3aa30de6d55b016fa9331e0877579b2d6b 100755 (executable)
@@ -94,7 +94,7 @@ test_expect_success 'setup for --cc --raw' '
        blob=$(echo file | git hash-object --stdin -w) &&
        base_tree=$(echo "100644 blob $blob     file" | git mktree) &&
        trees= &&
-       for i in `test_seq 1 40`
+       for i in $(test_seq 1 40)
        do
                blob=$(echo file$i | git hash-object --stdin -w) &&
                trees="$trees$(echo "100644 blob $blob  file" | git mktree)$LF"
index 097e63215e1ffc349ae9e3803f953aa70882b6a4..dff36b77ec8856573da26685376d156d49f8e021 100755 (executable)
@@ -5,7 +5,7 @@ test_description='combined diff show only paths that are different to all parent
 . ./test-lib.sh
 
 # verify that diffc.expect matches output of
-# `git diff -c --name-only HEAD HEAD^ HEAD^2`
+# $(git diff -c --name-only HEAD HEAD^ HEAD^2)
 diffc_verify () {
        git diff -c --name-only HEAD HEAD^ HEAD^2 >diffc.actual &&
        test_cmp diffc.expect diffc.actual
index b04fc8fc12238c3326306ed0e055b7d67bf950b4..9e29b5262d3f2e8514d5742951e28a3a339218dc 100755 (executable)
@@ -111,7 +111,6 @@ sed -e 's/T/        /g' > main.c.final <<\EOF
 #include <stdio.h>
 
 void print_int(int num);
-T/* a comment */
 int func(int num);
 
 int main() {
@@ -154,7 +153,8 @@ test_expect_success 'patch2 reverse applies with --ignore-space-change' '
 git config apply.ignorewhitespace change
 
 test_expect_success 'patch2 applies (apply.ignorewhitespace = change)' '
-       git apply patch2.patch
+       git apply patch2.patch &&
+       test_cmp main.c.final main.c
 '
 
 test_expect_success 'patch3 fails (missing string at EOL)' '
@@ -165,12 +165,8 @@ test_expect_success 'patch4 fails (missing EOL at EOF)' '
        test_must_fail git apply patch4.patch
 '
 
-test_expect_success 'patch5 applies (leading whitespace)' '
-       git apply patch5.patch
-'
-
-test_expect_success 'patches do not mangle whitespace' '
-       test_cmp main.c main.c.final
+test_expect_success 'patch5 fails (leading whitespace differences matter)' '
+       test_must_fail git apply patch5.patch
 '
 
 test_expect_success 're-create file (with --ignore-whitespace)' '
index 1e4d4380bf01c081aeb1df44cef40319063f2faa..ce8567f496438c18501f30632269ecbe7de15fd3 100755 (executable)
@@ -30,10 +30,10 @@ test_expect_success setup '
 
 test_expect_success 'apply in forward' '
 
-       T0=`git rev-parse "second^{tree}"` &&
+       T0=$(git rev-parse "second^{tree}") &&
        git reset --hard initial &&
        git apply --index --binary patch &&
-       T1=`git write-tree` &&
+       T1=$(git write-tree) &&
        test "$T0" = "$T1"
 '
 
@@ -62,22 +62,22 @@ test_expect_success 'setup separate repository lacking postimage' '
 
 test_expect_success 'apply in forward without postimage' '
 
-       T0=`git rev-parse "second^{tree}"` &&
+       T0=$(git rev-parse "second^{tree}") &&
        (
                cd initial &&
                git apply --index --binary ../patch &&
-               T1=`git write-tree` &&
+               T1=$(git write-tree) &&
                test "$T0" = "$T1"
        )
 '
 
 test_expect_success 'apply in reverse without postimage' '
 
-       T0=`git rev-parse "initial^{tree}"` &&
+       T0=$(git rev-parse "initial^{tree}") &&
        (
                cd second &&
                git apply --index --binary --reverse ../patch &&
-               T1=`git write-tree` &&
+               T1=$(git write-tree) &&
                test "$T0" = "$T1"
        )
 '
index 3d0384daa8a7b7369826b05bcb793cb445c3f9ee..c393be691be42a0b0a982c07ffeee489d4075bce 100755 (executable)
@@ -68,7 +68,7 @@ test_expect_success 'apply --whitespace=strip from config' '
        check_result sub/file1
 '
 
-D=`pwd`
+D=$(pwd)
 
 test_expect_success 'apply --whitespace=strip in subdir' '
 
index d2c930de87f721a0e876351e511295ae0b094108..7940f6f0b952b5accd3f1263f08e131a018de140 100755 (executable)
@@ -45,8 +45,8 @@ test_expect_success 'patch-id supports git-format-patch output' '
        git checkout same &&
        git format-patch -1 --stdout | calc_patch_id same &&
        test_cmp patch-id_master patch-id_same &&
-       set `git format-patch -1 --stdout | git patch-id` &&
-       test "$2" = `git rev-parse HEAD`
+       set $(git format-patch -1 --stdout | git patch-id) &&
+       test "$2" = $(git rev-parse HEAD)
 '
 
 test_expect_success 'whitespace is irrelevant in footer' '
index 1cf0a4e10301fe1bbfb3acced0c010da7b8df7f8..74fc5a88ecdaf66e34449df1a3429f8ee22cb1da 100755 (executable)
@@ -123,7 +123,7 @@ test_expect_success \
     'add files to repository' \
     'find a -type f | xargs git update-index --add &&
      find a -type l | xargs git update-index --add &&
-     treeid=`git write-tree` &&
+     treeid=$(git write-tree) &&
      echo $treeid >treeid &&
      git update-ref HEAD $(TZ=GMT GIT_COMMITTER_DATE="2005-05-27 22:00:00" \
      git commit-tree $treeid </dev/null)'
@@ -207,7 +207,7 @@ test_expect_success \
 
 test_expect_success 'clients cannot access unreachable commits' '
        test_commit unreachable &&
-       sha1=`git rev-parse HEAD` &&
+       sha1=$(git rev-parse HEAD) &&
        git reset --hard HEAD^ &&
        git archive $sha1 >remote.tar &&
        test_must_fail git archive --remote=. $sha1 >remote.tar
@@ -215,7 +215,7 @@ test_expect_success 'clients cannot access unreachable commits' '
 
 test_expect_success 'upload-archive can allow unreachable commits' '
        test_commit unreachable1 &&
-       sha1=`git rev-parse HEAD` &&
+       sha1=$(git rev-parse HEAD) &&
        git reset --hard HEAD^ &&
        git archive $sha1 >remote.tar &&
        test_config uploadarchive.allowUnreachable true &&
index 75d6b3843ad4070f225e82aec160eca494ab6238..93e2c65de65f8dd8544332dd512e6d61dad1746c 100755 (executable)
@@ -223,7 +223,13 @@ test_expect_success 'pull request format' '
                git request-pull initial "$downstream_url" tags/full:refs/tags/full
        ) >request &&
        sed -nf fuzz.sed <request >request.fuzzy &&
-       test_i18ncmp expect request.fuzzy
+       test_i18ncmp expect request.fuzzy &&
+
+       (
+               cd local &&
+               git request-pull initial "$downstream_url" full
+       ) >request &&
+       grep ' tags/full$'
 '
 
 test_expect_success 'request-pull ignores OPTIONS_KEEPDASHDASH poison' '
index be951a46797c6b88d2a8d420cf160ea4f3ad71b0..a980574682012fbb3f5f7c28a011df980f45c3de 100755 (executable)
@@ -173,33 +173,6 @@ EOF
        )
 '
 
-if test -n "$NO_CURL" -o -z "$GIT_TEST_HTTPD"; then
-       say 'skipping remaining tests, git built without http support'
-       test_done
-fi
-
-LIB_HTTPD_PORT=${LIB_HTTPD_PORT-'5537'}
-. "$TEST_DIRECTORY"/lib-httpd.sh
-start_httpd
-
-test_expect_success 'clone http repository' '
-       git clone --bare --no-local shallow "$HTTPD_DOCUMENT_ROOT_PATH/repo.git" &&
-       git clone $HTTPD_URL/smart/repo.git clone &&
-       (
-       cd clone &&
-       git fsck &&
-       git log --format=%s origin/master >actual &&
-       cat <<EOF >expect &&
-7
-6
-5
-4
-3
-EOF
-       test_cmp expect actual
-       )
-'
-
 test_expect_success POSIXPERM,SANITY 'shallow fetch from a read-only repo' '
        cp -R .git read-only.git &&
        find read-only.git -print | xargs chmod -w &&
@@ -213,5 +186,4 @@ EOF
        test_cmp expect actual
 '
 
-stop_httpd
 test_done
diff --git a/t/t6039-merge-ignorecase.sh b/t/t6039-merge-ignorecase.sh
new file mode 100755 (executable)
index 0000000..a977653
--- /dev/null
@@ -0,0 +1,53 @@
+#!/bin/sh
+
+test_description='git-merge with case-changing rename on case-insensitive file system'
+
+. ./test-lib.sh
+
+if ! test_have_prereq CASE_INSENSITIVE_FS
+then
+       skip_all='skipping case insensitive tests - case sensitive file system'
+       test_done
+fi
+
+test_expect_success 'merge with case-changing rename' '
+       test $(git config core.ignorecase) = true &&
+       >TestCase &&
+       git add TestCase &&
+       git commit -m "add TestCase" &&
+       git tag baseline
+       git checkout -b with-camel &&
+       >foo &&
+       git add foo &&
+       git commit -m "intervening commit" &&
+       git checkout master &&
+       git rm TestCase &&
+       >testcase &&
+       git add testcase &&
+       git commit -m "rename to testcase" &&
+       git checkout with-camel &&
+       git merge master -m "merge" &&
+       test_path_is_file testcase
+'
+
+test_expect_success 'merge with case-changing rename on both sides' '
+       git checkout master &&
+       git reset --hard baseline &&
+       git branch -D with-camel &&
+       git checkout -b with-camel &&
+       git mv TestCase testcase &&
+       git commit -m "recase on branch" &&
+       >foo &&
+       git add foo &&
+       git commit -m "intervening commit" &&
+       git checkout master &&
+       git rm TestCase &&
+       >testcase &&
+       git add testcase &&
+       git commit -m "rename to testcase" &&
+       git checkout with-camel &&
+       git merge master -m "merge" &&
+       test_path_is_file testcase
+'
+
+test_done
index 143a8ea60507a35bbdfb310eb74a33cf5b88bf1f..e4ab0f5b64194da05b159782a5e41479bf47de20 100755 (executable)
@@ -1423,4 +1423,30 @@ EOF
        test_cmp expect actual
 '
 
+run_with_limited_stack () {
+       (ulimit -s 64 && "$@")
+}
+
+test_lazy_prereq ULIMIT 'run_with_limited_stack true'
+
+# we require ulimit, this excludes Windows
+test_expect_success ULIMIT '--contains works in a deep repo' '
+       >expect &&
+       i=1 &&
+       while test $i -lt 4000
+       do
+               echo "commit refs/heads/master
+committer A U Thor <author@example.com> $((1000000000 + $i * 100)) +0200
+data <<EOF
+commit #$i
+EOF"
+               test $i = 1 && echo "from refs/heads/master^0"
+               i=$(($i + 1))
+       done | git fast-import &&
+       git checkout master &&
+       git tag far-far-away HEAD^ &&
+       run_with_limited_stack git tag --contains HEAD >actual &&
+       test_cmp expect actual
+'
+
 test_done
index e41fa00b80e9b3eb47e45be848397ccda0f47c53..1b824fe5ede3b933350696b78b6f53c1c69d0fff 100755 (executable)
@@ -24,7 +24,8 @@ test_expect_success 'set up a bit of history' '
        git tag -m "annotated tag" annotated &&
        git checkout -b side HEAD^^ &&
        test_commit side2 &&
-       test_commit side3
+       test_commit side3 &&
+       test_merge merge main3
 '
 
 test_expect_success 'showing two commits' '
@@ -109,8 +110,11 @@ test_expect_success 'showing range' '
 '
 
 test_expect_success '-s suppresses diff' '
-       echo main3 >expect &&
-       git show -s --format=%s main3 >actual &&
+       cat >expect <<-\EOF &&
+       merge
+       main3
+       EOF
+       git show -s --format=%s merge main3 >actual &&
        test_cmp expect actual
 '
 
index bdc1f295030b61fd6d4fc0ef672dffa99c027d8b..116885a260a56f94550ace2b541498a5e6f8e877 100755 (executable)
@@ -223,7 +223,8 @@ test_expect_success 'Commit without message is allowed with --allow-empty-messag
        git add foo &&
        >empty &&
        git commit --allow-empty-message <empty &&
-       commit_msg_is ""
+       commit_msg_is "" &&
+       git tag empty-message-commit
 '
 
 test_expect_success 'Commit without message is no-no without --allow-empty-message' '
@@ -240,6 +241,14 @@ test_expect_success 'Commit a message with --allow-empty-message' '
        commit_msg_is "hello there"
 '
 
+test_expect_success 'commit -C empty respects --allow-empty-message' '
+       echo more >>foo &&
+       git add foo &&
+       test_must_fail git commit -C empty-message-commit &&
+       git commit -C empty-message-commit --allow-empty-message &&
+       commit_msg_is ""
+'
+
 commit_for_rebase_autosquash_setup () {
        echo "first content line" >>foo &&
        git add foo &&
index d58b097ff3b3d0e6e68d15491d38f1f32460f6e7..63e04277f99a08b15e12c3392f9e128147180fad 100755 (executable)
@@ -346,8 +346,21 @@ test_expect_success 'amend commit to fix date' '
 
 '
 
-test_expect_success 'commit complains about bogus date' '
-       test_must_fail git commit --amend --date=10.11.2010
+test_expect_success 'commit mentions forced date in output' '
+       git commit --amend --date=2010-01-02T03:04:05 >output &&
+       grep "Date: *Sat Jan 2 03:04:05 2010" output
+'
+
+test_expect_success 'commit complains about completely bogus dates' '
+       test_must_fail git commit --amend --date=seventeen
+'
+
+test_expect_success 'commit --date allows approxidate' '
+       git commit --amend \
+               --date="midnight the 12th of october, anno domini 1979" &&
+       echo "Fri Oct 12 00:00:00 1979 +0000" >expect &&
+       git log -1 --format=%ad >actual &&
+       test_cmp expect actual
 '
 
 test_expect_success 'sign off (1)' '
index 30e46884f29722c38b8fd664339b8440a2b042e4..051489ea334c9693c2d19823ad23947703f66d90 100755 (executable)
@@ -344,6 +344,13 @@ test_expect_success 'message shows author when it is not equal to committer' '
          .git/COMMIT_EDITMSG
 '
 
+test_expect_success 'message shows date when it is explicitly set' '
+       git commit --allow-empty -e -m foo --date="2010-01-02T03:04:05" &&
+       test_i18ngrep \
+         "^# Date: *Sat Jan 2 03:04:05 2010 +0000" \
+         .git/COMMIT_EDITMSG
+'
+
 test_expect_success AUTOIDENT 'message shows committer when it is automatic' '
 
        echo >>negative &&
index 10aa028017833479c43bbb551741dfd36d9741aa..b16462132fd01f21cfd2af40a3c769803b0b7c50 100755 (executable)
@@ -57,11 +57,10 @@ create_merge_msgs () {
                git log --no-merges ^HEAD c2 c3
        } >squash.1-5-9 &&
        : >msg.nologff &&
-       echo >msg.nolognoff &&
+       : >msg.nolognoff &&
        {
                echo "* tag 'c3':" &&
-               echo "  commit 3" &&
-               echo
+               echo "  commit 3"
        } >msg.log
 }
 
@@ -71,7 +70,7 @@ verify_merge () {
        git diff --exit-code &&
        if test -n "$3"
        then
-               git show -s --pretty=format:%s HEAD >msg.act &&
+               git show -s --pretty=tformat:%s HEAD >msg.act &&
                test_cmp "$3" msg.act
        fi
 }
@@ -620,10 +619,10 @@ test_expect_success 'merge early part of c2' '
        git tag c6 &&
        git branch -f c5-branch c5 &&
        git merge c5-branch~1 &&
-       git show -s --pretty=format:%s HEAD >actual.branch &&
+       git show -s --pretty=tformat:%s HEAD >actual.branch &&
        git reset --keep HEAD^ &&
        git merge c5~1 &&
-       git show -s --pretty=format:%s HEAD >actual.tag &&
+       git show -s --pretty=tformat:%s HEAD >actual.tag &&
        test_cmp expected.branch actual.branch &&
        test_cmp expected.tag actual.tag
 '
index 5a193c500d282cc2b13e8de6e128229585897a16..dc30a514bf681dde44dea32e671632ef6f0a47a7 100755 (executable)
@@ -58,7 +58,7 @@ test_expect_success PERL 'custom tool commands override built-ins' '
 
 test_expect_success PERL 'difftool ignores bad --tool values' '
        : >expect &&
-       test_expect_code 1 \
+       test_must_fail \
                git difftool --no-prompt --tool=bad-tool branch >actual &&
        test_cmp expect actual
 '
index e7cac1db55113188c7149686399292bded9c07dd..2a3469bcbea39e832ab44280bb1223fc4ee20b61 100755 (executable)
@@ -191,4 +191,13 @@ test_expect_success 'indent of line numbers, ten lines' '
        test $(grep -c "  " actual) = 9
 '
 
+test_expect_success 'blaming files with CRLF newlines' '
+       git config core.autocrlf false &&
+       printf "testcase\r\n" >crlffile &&
+       git add crlffile &&
+       git commit -m testcase &&
+       git -c core.autocrlf=input blame crlffile >actual &&
+       grep "A U Thor" actual
+'
+
 test_done
index 6efd0d9c78fda8b28e79fad7153b610a0b40173f..915098418495b488b748db9e610c79f81223a960 100755 (executable)
@@ -578,12 +578,12 @@ test_expect_success 'prompt - bash color pc mode - untracked files status indica
 '
 
 test_expect_success 'prompt - zsh color pc mode' '
-       printf "BEFORE: (%%F{green}\${__git_ps1_branch_name}%%f):AFTER\\nmaster" >expected &&
+       printf "BEFORE: (%%F{green}master%%f):AFTER" >expected &&
        (
                ZSH_VERSION=5.0.0 &&
                GIT_PS1_SHOWCOLORHINTS=y &&
-               __git_ps1 "BEFORE:" ":AFTER" >"$actual"
-               printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
+               __git_ps1 "BEFORE:" ":AFTER" &&
+               printf "%s" "$PS1" >"$actual"
        ) &&
        test_cmp expected "$actual"
 '
index 11c3550177dbaab30596be2fc3c1633f2a0485f8..e7b378c8b2c8f145519410bb17811bf60eb29384 100644 (file)
 #include "diffcore.h"
 #include "tree.h"
 
-static void show_entry(struct diff_options *opt, const char *prefix,
-                      struct tree_desc *desc, struct strbuf *base);
+/*
+ * internal mode marker, saying a tree entry != entry of tp[imin]
+ * (see ll_diff_tree_paths for what it means there)
+ *
+ * we will update/use/emit entry for diff only with it unset.
+ */
+#define S_IFXMIN_NEQ   S_DIFFTREE_IFXMIN_NEQ
 
-static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2,
-                             struct strbuf *base, struct diff_options *opt)
-{
-       unsigned mode1, mode2;
-       const char *path1, *path2;
-       const unsigned char *sha1, *sha2;
-       int cmp, pathlen1, pathlen2;
-       int old_baselen = base->len;
 
-       sha1 = tree_entry_extract(t1, &path1, &mode1);
-       sha2 = tree_entry_extract(t2, &path2, &mode2);
+static struct combine_diff_path *ll_diff_tree_paths(
+       struct combine_diff_path *p, const unsigned char *sha1,
+       const unsigned char **parents_sha1, int nparent,
+       struct strbuf *base, struct diff_options *opt);
+static int ll_diff_tree_sha1(const unsigned char *old, const unsigned char *new,
+                            struct strbuf *base, struct diff_options *opt);
+
+/*
+ * Compare two tree entries, taking into account only path/S_ISDIR(mode),
+ * but not their sha1's.
+ *
+ * NOTE files and directories *always* compare differently, even when having
+ *      the same name - thanks to base_name_compare().
+ *
+ * NOTE empty (=invalid) descriptor(s) take part in comparison as +infty,
+ *      so that they sort *after* valid tree entries.
+ *
+ *      Due to this convention, if trees are scanned in sorted order, all
+ *      non-empty descriptors will be processed first.
+ */
+static int tree_entry_pathcmp(struct tree_desc *t1, struct tree_desc *t2)
+{
+       struct name_entry *e1, *e2;
+       int cmp;
 
-       pathlen1 = tree_entry_len(&t1->entry);
-       pathlen2 = tree_entry_len(&t2->entry);
-       cmp = base_name_compare(path1, pathlen1, mode1, path2, pathlen2, mode2);
-       if (cmp < 0) {
-               show_entry(opt, "-", t1, base);
+       /* empty descriptors sort after valid tree entries */
+       if (!t1->size)
+               return t2->size ? 1 : 0;
+       else if (!t2->size)
                return -1;
-       }
-       if (cmp > 0) {
-               show_entry(opt, "+", t2, base);
-               return 1;
-       }
-       if (!DIFF_OPT_TST(opt, FIND_COPIES_HARDER) && !hashcmp(sha1, sha2) && mode1 == mode2)
-               return 0;
 
-       /*
-        * If the filemode has changed to/from a directory from/to a regular
-        * file, we need to consider it a remove and an add.
-        */
-       if (S_ISDIR(mode1) != S_ISDIR(mode2)) {
-               show_entry(opt, "-", t1, base);
-               show_entry(opt, "+", t2, base);
-               return 0;
-       }
+       e1 = &t1->entry;
+       e2 = &t2->entry;
+       cmp = base_name_compare(e1->path, tree_entry_len(e1), e1->mode,
+                               e2->path, tree_entry_len(e2), e2->mode);
+       return cmp;
+}
 
-       strbuf_add(base, path1, pathlen1);
-       if (DIFF_OPT_TST(opt, RECURSIVE) && S_ISDIR(mode1)) {
-               if (DIFF_OPT_TST(opt, TREE_IN_RECURSIVE)) {
-                       opt->change(opt, mode1, mode2,
-                                   sha1, sha2, 1, 1, base->buf, 0, 0);
+
+/*
+ * convert path -> opt->diff_*() callbacks
+ *
+ * emits diff to first parent only, and tells diff tree-walker that we are done
+ * with p and it can be freed.
+ */
+static int emit_diff_first_parent_only(struct diff_options *opt, struct combine_diff_path *p)
+{
+       struct combine_diff_parent *p0 = &p->parent[0];
+       if (p->mode && p0->mode) {
+               opt->change(opt, p0->mode, p->mode, p0->sha1, p->sha1,
+                       1, 1, p->path, 0, 0);
+       }
+       else {
+               const unsigned char *sha1;
+               unsigned int mode;
+               int addremove;
+
+               if (p->mode) {
+                       addremove = '+';
+                       sha1 = p->sha1;
+                       mode = p->mode;
+               } else {
+                       addremove = '-';
+                       sha1 = p0->sha1;
+                       mode = p0->mode;
                }
-               strbuf_addch(base, '/');
-               diff_tree_sha1(sha1, sha2, base->buf, opt);
-       } else {
-               opt->change(opt, mode1, mode2, sha1, sha2, 1, 1, base->buf, 0, 0);
+
+               opt->add_remove(opt, addremove, mode, sha1, 1, p->path, 0);
        }
-       strbuf_setlen(base, old_baselen);
-       return 0;
+
+       return 0;       /* we are done with p */
 }
 
-/* A whole sub-tree went away or appeared */
-static void show_tree(struct diff_options *opt, const char *prefix,
-                     struct tree_desc *desc, struct strbuf *base)
+
+/*
+ * Make a new combine_diff_path from path/mode/sha1
+ * and append it to paths list tail.
+ *
+ * Memory for created elements could be reused:
+ *
+ *     - if last->next == NULL, the memory is allocated;
+ *
+ *     - if last->next != NULL, it is assumed that p=last->next was returned
+ *       earlier by this function, and p->next was *not* modified.
+ *       The memory is then reused from p.
+ *
+ * so for clients,
+ *
+ * - if you do need to keep the element
+ *
+ *     p = path_appendnew(p, ...);
+ *     process(p);
+ *     p->next = NULL;
+ *
+ * - if you don't need to keep the element after processing
+ *
+ *     pprev = p;
+ *     p = path_appendnew(p, ...);
+ *     process(p);
+ *     p = pprev;
+ *     ; don't forget to free tail->next in the end
+ *
+ * p->parent[] remains uninitialized.
+ */
+static struct combine_diff_path *path_appendnew(struct combine_diff_path *last,
+       int nparent, const struct strbuf *base, const char *path, int pathlen,
+       unsigned mode, const unsigned char *sha1)
 {
-       enum interesting match = entry_not_interesting;
-       for (; desc->size; update_tree_entry(desc)) {
-               if (match != all_entries_interesting) {
-                       match = tree_entry_interesting(&desc->entry, base, 0,
-                                                      &opt->pathspec);
-                       if (match == all_entries_not_interesting)
-                               break;
-                       if (match == entry_not_interesting)
-                               continue;
-               }
-               show_entry(opt, prefix, desc, base);
+       struct combine_diff_path *p;
+       int len = base->len + pathlen;
+       int alloclen = combine_diff_path_size(nparent, len);
+
+       /* if last->next is !NULL - it is a pre-allocated memory, we can reuse */
+       p = last->next;
+       if (p && (alloclen > (intptr_t)p->next)) {
+               free(p);
+               p = NULL;
+       }
+
+       if (!p) {
+               p = xmalloc(alloclen);
+
+               /*
+                * until we go to it next round, .next holds how many bytes we
+                * allocated (for faster realloc - we don't need copying old data).
+                */
+               p->next = (struct combine_diff_path *)(intptr_t)alloclen;
        }
+
+       last->next = p;
+
+       p->path = (char *)&(p->parent[nparent]);
+       memcpy(p->path, base->buf, base->len);
+       memcpy(p->path + base->len, path, pathlen);
+       p->path[len] = 0;
+       p->mode = mode;
+       hashcpy(p->sha1, sha1 ? sha1 : null_sha1);
+
+       return p;
 }
 
-/* A file entry went away or appeared */
-static void show_entry(struct diff_options *opt, const char *prefix,
-                      struct tree_desc *desc, struct strbuf *base)
+/*
+ * new path should be added to combine diff
+ *
+ * 3 cases on how/when it should be called and behaves:
+ *
+ *      t, !tp         -> path added, all parents lack it
+ *     !t,  tp         -> path removed from all parents
+ *      t,  tp         -> path modified/added
+ *                        (M for tp[i]=tp[imin], A otherwise)
+ */
+static struct combine_diff_path *emit_path(struct combine_diff_path *p,
+       struct strbuf *base, struct diff_options *opt, int nparent,
+       struct tree_desc *t, struct tree_desc *tp,
+       int imin)
 {
        unsigned mode;
        const char *path;
-       const unsigned char *sha1 = tree_entry_extract(desc, &path, &mode);
-       int pathlen = tree_entry_len(&desc->entry);
+       const unsigned char *sha1;
+       int pathlen;
        int old_baselen = base->len;
+       int i, isdir, recurse = 0, emitthis = 1;
+
+       /* at least something has to be valid */
+       assert(t || tp);
 
-       strbuf_add(base, path, pathlen);
-       if (DIFF_OPT_TST(opt, RECURSIVE) && S_ISDIR(mode)) {
-               enum object_type type;
-               struct tree_desc inner;
-               void *tree;
-               unsigned long size;
+       if (t) {
+               /* path present in resulting tree */
+               sha1 = tree_entry_extract(t, &path, &mode);
+               pathlen = tree_entry_len(&t->entry);
+               isdir = S_ISDIR(mode);
+       } else {
+               /*
+                * a path was removed - take path from imin parent. Also take
+                * mode from that parent, to decide on recursion(1).
+                *
+                * 1) all modes for tp[i]=tp[imin] should be the same wrt
+                *    S_ISDIR, thanks to base_name_compare().
+                */
+               tree_entry_extract(&tp[imin], &path, &mode);
+               pathlen = tree_entry_len(&tp[imin].entry);
 
-               tree = read_sha1_file(sha1, &type, &size);
-               if (!tree || type != OBJ_TREE)
-                       die("corrupt tree sha %s", sha1_to_hex(sha1));
+               isdir = S_ISDIR(mode);
+               sha1 = NULL;
+               mode = 0;
+       }
 
-               if (DIFF_OPT_TST(opt, TREE_IN_RECURSIVE))
-                       opt->add_remove(opt, *prefix, mode, sha1, 1, base->buf, 0);
+       if (DIFF_OPT_TST(opt, RECURSIVE) && isdir) {
+               recurse = 1;
+               emitthis = DIFF_OPT_TST(opt, TREE_IN_RECURSIVE);
+       }
 
-               strbuf_addch(base, '/');
+       if (emitthis) {
+               int keep;
+               struct combine_diff_path *pprev = p;
+               p = path_appendnew(p, nparent, base, path, pathlen, mode, sha1);
 
-               init_tree_desc(&inner, tree, size);
-               show_tree(opt, prefix, &inner, base);
-               free(tree);
-       } else
-               opt->add_remove(opt, prefix[0], mode, sha1, 1, base->buf, 0);
+               for (i = 0; i < nparent; ++i) {
+                       /*
+                        * tp[i] is valid, if present and if tp[i]==tp[imin] -
+                        * otherwise, we should ignore it.
+                        */
+                       int tpi_valid = tp && !(tp[i].entry.mode & S_IFXMIN_NEQ);
+
+                       const unsigned char *sha1_i;
+                       unsigned mode_i;
+
+                       p->parent[i].status =
+                               !t ? DIFF_STATUS_DELETED :
+                                       tpi_valid ?
+                                               DIFF_STATUS_MODIFIED :
+                                               DIFF_STATUS_ADDED;
+
+                       if (tpi_valid) {
+                               sha1_i = tp[i].entry.sha1;
+                               mode_i = tp[i].entry.mode;
+                       }
+                       else {
+                               sha1_i = NULL;
+                               mode_i = 0;
+                       }
+
+                       p->parent[i].mode = mode_i;
+                       hashcpy(p->parent[i].sha1, sha1_i ? sha1_i : null_sha1);
+               }
+
+               keep = 1;
+               if (opt->pathchange)
+                       keep = opt->pathchange(opt, p);
+
+               /*
+                * If a path was filtered or consumed - we don't need to add it
+                * to the list and can reuse its memory, leaving it as
+                * pre-allocated element on the tail.
+                *
+                * On the other hand, if path needs to be kept, we need to
+                * correct its .next to NULL, as it was pre-initialized to how
+                * much memory was allocated.
+                *
+                * see path_appendnew() for details.
+                */
+               if (!keep)
+                       p = pprev;
+               else
+                       p->next = NULL;
+       }
+
+       if (recurse) {
+               const unsigned char **parents_sha1;
+
+               parents_sha1 = xalloca(nparent * sizeof(parents_sha1[0]));
+               for (i = 0; i < nparent; ++i) {
+                       /* same rule as in emitthis */
+                       int tpi_valid = tp && !(tp[i].entry.mode & S_IFXMIN_NEQ);
+
+                       parents_sha1[i] = tpi_valid ? tp[i].entry.sha1
+                                                   : NULL;
+               }
+
+               strbuf_add(base, path, pathlen);
+               strbuf_addch(base, '/');
+               p = ll_diff_tree_paths(p, sha1, parents_sha1, nparent, base, opt);
+               xalloca_free(parents_sha1);
+       }
 
        strbuf_setlen(base, old_baselen);
+       return p;
 }
 
 static void skip_uninteresting(struct tree_desc *t, struct strbuf *base,
-                              struct diff_options *opt,
-                              enum interesting *match)
+                              struct diff_options *opt)
 {
+       enum interesting match;
+
        while (t->size) {
-               *match = tree_entry_interesting(&t->entry, base, 0, &opt->pathspec);
-               if (*match) {
-                       if (*match == all_entries_not_interesting)
+               match = tree_entry_interesting(&t->entry, base, 0, &opt->pathspec);
+               if (match) {
+                       if (match == all_entries_not_interesting)
                                t->size = 0;
                        break;
                }
@@ -128,55 +300,260 @@ static void skip_uninteresting(struct tree_desc *t, struct strbuf *base,
        }
 }
 
-int diff_tree(struct tree_desc *t1, struct tree_desc *t2,
-             const char *base_str, struct diff_options *opt)
+
+/*
+ * generate paths for combined diff D(sha1,parents_sha1[])
+ *
+ * Resulting paths are appended to combine_diff_path linked list, and also, are
+ * emitted on the go via opt->pathchange() callback, so it is possible to
+ * process the result as batch or incrementally.
+ *
+ * The paths are generated scanning new tree and all parents trees
+ * simultaneously, similarly to what diff_tree() was doing for 2 trees.
+ * The theory behind such scan is as follows:
+ *
+ *
+ * D(T,P1...Pn) calculation scheme
+ * -------------------------------
+ *
+ * D(T,P1...Pn) = D(T,P1) ^ ... ^ D(T,Pn)      (regarding resulting paths set)
+ *
+ *     D(T,Pj)         - diff between T..Pj
+ *     D(T,P1...Pn)    - combined diff from T to parents P1,...,Pn
+ *
+ *
+ * We start from all trees, which are sorted, and compare their entries in
+ * lock-step:
+ *
+ *      T     P1       Pn
+ *      -     -        -
+ *     |t|   |p1|     |pn|
+ *     |-|   |--| ... |--|      imin = argmin(p1...pn)
+ *     | |   |  |     |  |
+ *     |-|   |--|     |--|
+ *     |.|   |. |     |. |
+ *      .     .        .
+ *      .     .        .
+ *
+ * at any time there could be 3 cases:
+ *
+ *     1)  t < p[imin];
+ *     2)  t > p[imin];
+ *     3)  t = p[imin].
+ *
+ * Schematic deduction of what every case means, and what to do, follows:
+ *
+ * 1)  t < p[imin]  ->  ∀j t ∉ Pj  ->  "+t" ∈ D(T,Pj)  ->  D += "+t";  t↓
+ *
+ * 2)  t > p[imin]
+ *
+ *     2.1) ∃j: pj > p[imin]  ->  "-p[imin]" ∉ D(T,Pj)  ->  D += ø;  ∀ pi=p[imin]  pi↓
+ *     2.2) ∀i  pi = p[imin]  ->  pi ∉ T  ->  "-pi" ∈ D(T,Pi)  ->  D += "-p[imin]";  ∀i pi↓
+ *
+ * 3)  t = p[imin]
+ *
+ *     3.1) ∃j: pj > p[imin]  ->  "+t" ∈ D(T,Pj)  ->  only pi=p[imin] remains to investigate
+ *     3.2) pi = p[imin]  ->  investigate δ(t,pi)
+ *      |
+ *      |
+ *      v
+ *
+ *     3.1+3.2) looking at δ(t,pi) ∀i: pi=p[imin] - if all != ø  ->
+ *
+ *                       ⎧δ(t,pi)  - if pi=p[imin]
+ *              ->  D += ⎨
+ *                       ⎩"+t"     - if pi>p[imin]
+ *
+ *
+ *     in any case t↓  ∀ pi=p[imin]  pi↓
+ *
+ *
+ * ~~~~~~~~
+ *
+ * NOTE
+ *
+ *     Usual diff D(A,B) is by definition the same as combined diff D(A,[B]),
+ *     so this diff paths generator can, and is used, for plain diffs
+ *     generation too.
+ *
+ *     Please keep attention to the common D(A,[B]) case when working on the
+ *     code, in order not to slow it down.
+ *
+ * NOTE
+ *     nparent must be > 0.
+ */
+
+
+/* ∀ pi=p[imin]  pi↓ */
+static inline void update_tp_entries(struct tree_desc *tp, int nparent)
 {
-       struct strbuf base;
-       int baselen = strlen(base_str);
-       enum interesting t1_match = entry_not_interesting;
-       enum interesting t2_match = entry_not_interesting;
+       int i;
+       for (i = 0; i < nparent; ++i)
+               if (!(tp[i].entry.mode & S_IFXMIN_NEQ))
+                       update_tree_entry(&tp[i]);
+}
+
+static struct combine_diff_path *ll_diff_tree_paths(
+       struct combine_diff_path *p, const unsigned char *sha1,
+       const unsigned char **parents_sha1, int nparent,
+       struct strbuf *base, struct diff_options *opt)
+{
+       struct tree_desc t, *tp;
+       void *ttree, **tptree;
+       int i;
+
+       tp     = xalloca(nparent * sizeof(tp[0]));
+       tptree = xalloca(nparent * sizeof(tptree[0]));
+
+       /*
+        * load parents first, as they are probably already cached.
+        *
+        * ( log_tree_diff() parses commit->parent before calling here via
+        *   diff_tree_sha1(parent, commit) )
+        */
+       for (i = 0; i < nparent; ++i)
+               tptree[i] = fill_tree_descriptor(&tp[i], parents_sha1[i]);
+       ttree = fill_tree_descriptor(&t, sha1);
 
        /* Enable recursion indefinitely */
        opt->pathspec.recursive = DIFF_OPT_TST(opt, RECURSIVE);
 
-       strbuf_init(&base, PATH_MAX);
-       strbuf_add(&base, base_str, baselen);
-
        for (;;) {
+               int imin, cmp;
+
                if (diff_can_quit_early(opt))
                        break;
+
                if (opt->pathspec.nr) {
-                       skip_uninteresting(t1, &base, opt, &t1_match);
-                       skip_uninteresting(t2, &base, opt, &t2_match);
+                       skip_uninteresting(&t, base, opt);
+                       for (i = 0; i < nparent; i++)
+                               skip_uninteresting(&tp[i], base, opt);
                }
-               if (!t1->size) {
-                       if (!t2->size)
+
+               /* comparing is finished when all trees are done */
+               if (!t.size) {
+                       int done = 1;
+                       for (i = 0; i < nparent; ++i)
+                               if (tp[i].size) {
+                                       done = 0;
+                                       break;
+                               }
+                       if (done)
                                break;
-                       show_entry(opt, "+", t2, &base);
-                       update_tree_entry(t2);
-                       continue;
                }
-               if (!t2->size) {
-                       show_entry(opt, "-", t1, &base);
-                       update_tree_entry(t1);
-                       continue;
+
+               /*
+                * lookup imin = argmin(p1...pn),
+                * mark entries whether they =p[imin] along the way
+                */
+               imin = 0;
+               tp[0].entry.mode &= ~S_IFXMIN_NEQ;
+
+               for (i = 1; i < nparent; ++i) {
+                       cmp = tree_entry_pathcmp(&tp[i], &tp[imin]);
+                       if (cmp < 0) {
+                               imin = i;
+                               tp[i].entry.mode &= ~S_IFXMIN_NEQ;
+                       }
+                       else if (cmp == 0) {
+                               tp[i].entry.mode &= ~S_IFXMIN_NEQ;
+                       }
+                       else {
+                               tp[i].entry.mode |= S_IFXMIN_NEQ;
+                       }
+               }
+
+               /* fixup markings for entries before imin */
+               for (i = 0; i < imin; ++i)
+                       tp[i].entry.mode |= S_IFXMIN_NEQ;       /* pi > p[imin] */
+
+
+
+               /* compare t vs p[imin] */
+               cmp = tree_entry_pathcmp(&t, &tp[imin]);
+
+               /* t = p[imin] */
+               if (cmp == 0) {
+                       /* are either pi > p[imin] or diff(t,pi) != ø ? */
+                       if (!DIFF_OPT_TST(opt, FIND_COPIES_HARDER)) {
+                               for (i = 0; i < nparent; ++i) {
+                                       /* p[i] > p[imin] */
+                                       if (tp[i].entry.mode & S_IFXMIN_NEQ)
+                                               continue;
+
+                                       /* diff(t,pi) != ø */
+                                       if (hashcmp(t.entry.sha1, tp[i].entry.sha1) ||
+                                           (t.entry.mode != tp[i].entry.mode))
+                                               continue;
+
+                                       goto skip_emit_t_tp;
+                               }
+                       }
+
+                       /* D += {δ(t,pi) if pi=p[imin];  "+a" if pi > p[imin]} */
+                       p = emit_path(p, base, opt, nparent,
+                                       &t, tp, imin);
+
+               skip_emit_t_tp:
+                       /* t↓,  ∀ pi=p[imin]  pi↓ */
+                       update_tree_entry(&t);
+                       update_tp_entries(tp, nparent);
+               }
+
+               /* t < p[imin] */
+               else if (cmp < 0) {
+                       /* D += "+t" */
+                       p = emit_path(p, base, opt, nparent,
+                                       &t, /*tp=*/NULL, -1);
+
+                       /* t↓ */
+                       update_tree_entry(&t);
                }
-               switch (compare_tree_entry(t1, t2, &base, opt)) {
-               case -1:
-                       update_tree_entry(t1);
-                       continue;
-               case 0:
-                       update_tree_entry(t1);
-                       /* Fallthrough */
-               case 1:
-                       update_tree_entry(t2);
-                       continue;
+
+               /* t > p[imin] */
+               else {
+                       /* ∀i pi=p[imin] -> D += "-p[imin]" */
+                       if (!DIFF_OPT_TST(opt, FIND_COPIES_HARDER)) {
+                               for (i = 0; i < nparent; ++i)
+                                       if (tp[i].entry.mode & S_IFXMIN_NEQ)
+                                               goto skip_emit_tp;
+                       }
+
+                       p = emit_path(p, base, opt, nparent,
+                                       /*t=*/NULL, tp, imin);
+
+               skip_emit_tp:
+                       /* ∀ pi=p[imin]  pi↓ */
+                       update_tp_entries(tp, nparent);
                }
-               die("git diff-tree: internal error");
        }
 
-       strbuf_release(&base);
-       return 0;
+       free(ttree);
+       for (i = nparent-1; i >= 0; i--)
+               free(tptree[i]);
+       xalloca_free(tptree);
+       xalloca_free(tp);
+
+       return p;
+}
+
+struct combine_diff_path *diff_tree_paths(
+       struct combine_diff_path *p, const unsigned char *sha1,
+       const unsigned char **parents_sha1, int nparent,
+       struct strbuf *base, struct diff_options *opt)
+{
+       p = ll_diff_tree_paths(p, sha1, parents_sha1, nparent, base, opt);
+
+       /*
+        * free pre-allocated last element, if any
+        * (see path_appendnew() for details about why)
+        */
+       if (p->next) {
+               free(p->next);
+               p->next = NULL;
+       }
+
+       return p;
 }
 
 /*
@@ -190,7 +567,7 @@ static inline int diff_might_be_rename(void)
                !DIFF_FILE_VALID(diff_queued_diff.queue[0]->one);
 }
 
-static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, const char *base, struct diff_options *opt)
+static void try_to_follow_renames(const unsigned char *old, const unsigned char *new, struct strbuf *base, struct diff_options *opt)
 {
        struct diff_options diff_opts;
        struct diff_queue_struct *q = &diff_queued_diff;
@@ -228,7 +605,7 @@ static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, co
        diff_opts.break_opt = opt->break_opt;
        diff_opts.rename_score = opt->rename_score;
        diff_setup_done(&diff_opts);
-       diff_tree(t1, t2, base, &diff_opts);
+       ll_diff_tree_sha1(old, new, base, &diff_opts);
        diffcore_std(&diff_opts);
        free_pathspec(&diff_opts.pathspec);
 
@@ -287,25 +664,40 @@ static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, co
        q->nr = 1;
 }
 
-int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base, struct diff_options *opt)
+static int ll_diff_tree_sha1(const unsigned char *old, const unsigned char *new,
+                            struct strbuf *base, struct diff_options *opt)
 {
-       void *tree1, *tree2;
-       struct tree_desc t1, t2;
-       unsigned long size1, size2;
-       int retval;
+       struct combine_diff_path phead, *p;
+       pathchange_fn_t pathchange_old = opt->pathchange;
 
-       tree1 = fill_tree_descriptor(&t1, old);
-       tree2 = fill_tree_descriptor(&t2, new);
-       size1 = t1.size;
-       size2 = t2.size;
-       retval = diff_tree(&t1, &t2, base, opt);
-       if (!*base && DIFF_OPT_TST(opt, FOLLOW_RENAMES) && diff_might_be_rename()) {
-               init_tree_desc(&t1, tree1, size1);
-               init_tree_desc(&t2, tree2, size2);
-               try_to_follow_renames(&t1, &t2, base, opt);
+       phead.next = NULL;
+       opt->pathchange = emit_diff_first_parent_only;
+       diff_tree_paths(&phead, new, &old, 1, base, opt);
+
+       for (p = phead.next; p;) {
+               struct combine_diff_path *pprev = p;
+               p = p->next;
+               free(pprev);
        }
-       free(tree1);
-       free(tree2);
+
+       opt->pathchange = pathchange_old;
+       return 0;
+}
+
+int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base_str, struct diff_options *opt)
+{
+       struct strbuf base;
+       int retval;
+
+       strbuf_init(&base, PATH_MAX);
+       strbuf_addstr(&base, base_str);
+
+       retval = ll_diff_tree_sha1(old, new, &base, opt);
+       if (!*base_str && DIFF_OPT_TST(opt, FOLLOW_RENAMES) && diff_might_be_rename())
+               try_to_follow_renames(old, new, &base, opt);
+
+       strbuf_release(&base);
+
        return retval;
 }
 
diff --git a/unicode_width.h b/unicode_width.h
new file mode 100644 (file)
index 0000000..4db7803
--- /dev/null
@@ -0,0 +1,288 @@
+static const struct interval zero_width[] = {
+{ 0x0300, 0x036F },
+{ 0x0483, 0x0489 },
+{ 0x0591, 0x05BD },
+{ 0x05BF, 0x05BF },
+{ 0x05C1, 0x05C2 },
+{ 0x05C4, 0x05C5 },
+{ 0x05C7, 0x05C7 },
+{ 0x0600, 0x0604 },
+{ 0x0610, 0x061A },
+{ 0x061C, 0x061C },
+{ 0x064B, 0x065F },
+{ 0x0670, 0x0670 },
+{ 0x06D6, 0x06DD },
+{ 0x06DF, 0x06E4 },
+{ 0x06E7, 0x06E8 },
+{ 0x06EA, 0x06ED },
+{ 0x070F, 0x070F },
+{ 0x0711, 0x0711 },
+{ 0x0730, 0x074A },
+{ 0x07A6, 0x07B0 },
+{ 0x07EB, 0x07F3 },
+{ 0x0816, 0x0819 },
+{ 0x081B, 0x0823 },
+{ 0x0825, 0x0827 },
+{ 0x0829, 0x082D },
+{ 0x0859, 0x085B },
+{ 0x08E4, 0x08FE },
+{ 0x0900, 0x0902 },
+{ 0x093A, 0x093A },
+{ 0x093C, 0x093C },
+{ 0x0941, 0x0948 },
+{ 0x094D, 0x094D },
+{ 0x0951, 0x0957 },
+{ 0x0962, 0x0963 },
+{ 0x0981, 0x0981 },
+{ 0x09BC, 0x09BC },
+{ 0x09C1, 0x09C4 },
+{ 0x09CD, 0x09CD },
+{ 0x09E2, 0x09E3 },
+{ 0x0A01, 0x0A02 },
+{ 0x0A3C, 0x0A3C },
+{ 0x0A41, 0x0A42 },
+{ 0x0A47, 0x0A48 },
+{ 0x0A4B, 0x0A4D },
+{ 0x0A51, 0x0A51 },
+{ 0x0A70, 0x0A71 },
+{ 0x0A75, 0x0A75 },
+{ 0x0A81, 0x0A82 },
+{ 0x0ABC, 0x0ABC },
+{ 0x0AC1, 0x0AC5 },
+{ 0x0AC7, 0x0AC8 },
+{ 0x0ACD, 0x0ACD },
+{ 0x0AE2, 0x0AE3 },
+{ 0x0B01, 0x0B01 },
+{ 0x0B3C, 0x0B3C },
+{ 0x0B3F, 0x0B3F },
+{ 0x0B41, 0x0B44 },
+{ 0x0B4D, 0x0B4D },
+{ 0x0B56, 0x0B56 },
+{ 0x0B62, 0x0B63 },
+{ 0x0B82, 0x0B82 },
+{ 0x0BC0, 0x0BC0 },
+{ 0x0BCD, 0x0BCD },
+{ 0x0C3E, 0x0C40 },
+{ 0x0C46, 0x0C48 },
+{ 0x0C4A, 0x0C4D },
+{ 0x0C55, 0x0C56 },
+{ 0x0C62, 0x0C63 },
+{ 0x0CBC, 0x0CBC },
+{ 0x0CBF, 0x0CBF },
+{ 0x0CC6, 0x0CC6 },
+{ 0x0CCC, 0x0CCD },
+{ 0x0CE2, 0x0CE3 },
+{ 0x0D41, 0x0D44 },
+{ 0x0D4D, 0x0D4D },
+{ 0x0D62, 0x0D63 },
+{ 0x0DCA, 0x0DCA },
+{ 0x0DD2, 0x0DD4 },
+{ 0x0DD6, 0x0DD6 },
+{ 0x0E31, 0x0E31 },
+{ 0x0E34, 0x0E3A },
+{ 0x0E47, 0x0E4E },
+{ 0x0EB1, 0x0EB1 },
+{ 0x0EB4, 0x0EB9 },
+{ 0x0EBB, 0x0EBC },
+{ 0x0EC8, 0x0ECD },
+{ 0x0F18, 0x0F19 },
+{ 0x0F35, 0x0F35 },
+{ 0x0F37, 0x0F37 },
+{ 0x0F39, 0x0F39 },
+{ 0x0F71, 0x0F7E },
+{ 0x0F80, 0x0F84 },
+{ 0x0F86, 0x0F87 },
+{ 0x0F8D, 0x0F97 },
+{ 0x0F99, 0x0FBC },
+{ 0x0FC6, 0x0FC6 },
+{ 0x102D, 0x1030 },
+{ 0x1032, 0x1037 },
+{ 0x1039, 0x103A },
+{ 0x103D, 0x103E },
+{ 0x1058, 0x1059 },
+{ 0x105E, 0x1060 },
+{ 0x1071, 0x1074 },
+{ 0x1082, 0x1082 },
+{ 0x1085, 0x1086 },
+{ 0x108D, 0x108D },
+{ 0x109D, 0x109D },
+{ 0x1160, 0x11FF },
+{ 0x135D, 0x135F },
+{ 0x1712, 0x1714 },
+{ 0x1732, 0x1734 },
+{ 0x1752, 0x1753 },
+{ 0x1772, 0x1773 },
+{ 0x17B4, 0x17B5 },
+{ 0x17B7, 0x17BD },
+{ 0x17C6, 0x17C6 },
+{ 0x17C9, 0x17D3 },
+{ 0x17DD, 0x17DD },
+{ 0x180B, 0x180E },
+{ 0x18A9, 0x18A9 },
+{ 0x1920, 0x1922 },
+{ 0x1927, 0x1928 },
+{ 0x1932, 0x1932 },
+{ 0x1939, 0x193B },
+{ 0x1A17, 0x1A18 },
+{ 0x1A1B, 0x1A1B },
+{ 0x1A56, 0x1A56 },
+{ 0x1A58, 0x1A5E },
+{ 0x1A60, 0x1A60 },
+{ 0x1A62, 0x1A62 },
+{ 0x1A65, 0x1A6C },
+{ 0x1A73, 0x1A7C },
+{ 0x1A7F, 0x1A7F },
+{ 0x1B00, 0x1B03 },
+{ 0x1B34, 0x1B34 },
+{ 0x1B36, 0x1B3A },
+{ 0x1B3C, 0x1B3C },
+{ 0x1B42, 0x1B42 },
+{ 0x1B6B, 0x1B73 },
+{ 0x1B80, 0x1B81 },
+{ 0x1BA2, 0x1BA5 },
+{ 0x1BA8, 0x1BA9 },
+{ 0x1BAB, 0x1BAB },
+{ 0x1BE6, 0x1BE6 },
+{ 0x1BE8, 0x1BE9 },
+{ 0x1BED, 0x1BED },
+{ 0x1BEF, 0x1BF1 },
+{ 0x1C2C, 0x1C33 },
+{ 0x1C36, 0x1C37 },
+{ 0x1CD0, 0x1CD2 },
+{ 0x1CD4, 0x1CE0 },
+{ 0x1CE2, 0x1CE8 },
+{ 0x1CED, 0x1CED },
+{ 0x1CF4, 0x1CF4 },
+{ 0x1DC0, 0x1DE6 },
+{ 0x1DFC, 0x1DFF },
+{ 0x200B, 0x200F },
+{ 0x202A, 0x202E },
+{ 0x2060, 0x2064 },
+{ 0x2066, 0x206F },
+{ 0x20D0, 0x20F0 },
+{ 0x2CEF, 0x2CF1 },
+{ 0x2D7F, 0x2D7F },
+{ 0x2DE0, 0x2DFF },
+{ 0x302A, 0x302D },
+{ 0x3099, 0x309A },
+{ 0xA66F, 0xA672 },
+{ 0xA674, 0xA67D },
+{ 0xA69F, 0xA69F },
+{ 0xA6F0, 0xA6F1 },
+{ 0xA802, 0xA802 },
+{ 0xA806, 0xA806 },
+{ 0xA80B, 0xA80B },
+{ 0xA825, 0xA826 },
+{ 0xA8C4, 0xA8C4 },
+{ 0xA8E0, 0xA8F1 },
+{ 0xA926, 0xA92D },
+{ 0xA947, 0xA951 },
+{ 0xA980, 0xA982 },
+{ 0xA9B3, 0xA9B3 },
+{ 0xA9B6, 0xA9B9 },
+{ 0xA9BC, 0xA9BC },
+{ 0xAA29, 0xAA2E },
+{ 0xAA31, 0xAA32 },
+{ 0xAA35, 0xAA36 },
+{ 0xAA43, 0xAA43 },
+{ 0xAA4C, 0xAA4C },
+{ 0xAAB0, 0xAAB0 },
+{ 0xAAB2, 0xAAB4 },
+{ 0xAAB7, 0xAAB8 },
+{ 0xAABE, 0xAABF },
+{ 0xAAC1, 0xAAC1 },
+{ 0xAAEC, 0xAAED },
+{ 0xAAF6, 0xAAF6 },
+{ 0xABE5, 0xABE5 },
+{ 0xABE8, 0xABE8 },
+{ 0xABED, 0xABED },
+{ 0xFB1E, 0xFB1E },
+{ 0xFE00, 0xFE0F },
+{ 0xFE20, 0xFE26 },
+{ 0xFEFF, 0xFEFF },
+{ 0xFFF9, 0xFFFB },
+{ 0x101FD, 0x101FD },
+{ 0x10A01, 0x10A03 },
+{ 0x10A05, 0x10A06 },
+{ 0x10A0C, 0x10A0F },
+{ 0x10A38, 0x10A3A },
+{ 0x10A3F, 0x10A3F },
+{ 0x11001, 0x11001 },
+{ 0x11038, 0x11046 },
+{ 0x11080, 0x11081 },
+{ 0x110B3, 0x110B6 },
+{ 0x110B9, 0x110BA },
+{ 0x110BD, 0x110BD },
+{ 0x11100, 0x11102 },
+{ 0x11127, 0x1112B },
+{ 0x1112D, 0x11134 },
+{ 0x11180, 0x11181 },
+{ 0x111B6, 0x111BE },
+{ 0x116AB, 0x116AB },
+{ 0x116AD, 0x116AD },
+{ 0x116B0, 0x116B5 },
+{ 0x116B7, 0x116B7 },
+{ 0x16F8F, 0x16F92 },
+{ 0x1D167, 0x1D169 },
+{ 0x1D173, 0x1D182 },
+{ 0x1D185, 0x1D18B },
+{ 0x1D1AA, 0x1D1AD },
+{ 0x1D242, 0x1D244 },
+{ 0xE0001, 0xE0001 },
+{ 0xE0020, 0xE007F },
+{ 0xE0100, 0xE01EF }
+};
+static const struct interval double_width[] = {
+{ /* plane */ 0x0, 0x1C },
+{ /* plane */ 0x1C, 0x21 },
+{ /* plane */ 0x21, 0x22 },
+{ /* plane */ 0x22, 0x23 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ /* plane */ 0x0, 0x0 },
+{ 0x1100, 0x115F },
+{ 0x2329, 0x232A },
+{ 0x2E80, 0x2E99 },
+{ 0x2E9B, 0x2EF3 },
+{ 0x2F00, 0x2FD5 },
+{ 0x2FF0, 0x2FFB },
+{ 0x3000, 0x303E },
+{ 0x3041, 0x3096 },
+{ 0x3099, 0x30FF },
+{ 0x3105, 0x312D },
+{ 0x3131, 0x318E },
+{ 0x3190, 0x31BA },
+{ 0x31C0, 0x31E3 },
+{ 0x31F0, 0x321E },
+{ 0x3220, 0x3247 },
+{ 0x3250, 0x32FE },
+{ 0x3300, 0x4DBF },
+{ 0x4E00, 0xA48C },
+{ 0xA490, 0xA4C6 },
+{ 0xA960, 0xA97C },
+{ 0xAC00, 0xD7A3 },
+{ 0xF900, 0xFAFF },
+{ 0xFE10, 0xFE19 },
+{ 0xFE30, 0xFE52 },
+{ 0xFE54, 0xFE66 },
+{ 0xFE68, 0xFE6B },
+{ 0xFF01, 0xFF60 },
+{ 0xFFE0, 0xFFE6 },
+{ 0x1B000, 0x1B001 },
+{ 0x1F200, 0x1F202 },
+{ 0x1F210, 0x1F23A },
+{ 0x1F240, 0x1F248 },
+{ 0x1F250, 0x1F251 },
+{ 0x20000, 0x2FFFD },
+{ 0x30000, 0x3FFFD }
+};
diff --git a/update_unicode.sh b/update_unicode.sh
new file mode 100755 (executable)
index 0000000..000b937
--- /dev/null
@@ -0,0 +1,37 @@
+#!/bin/sh
+#See http://www.unicode.org/reports/tr44/
+#
+#Me Enclosing_Mark  an enclosing combining mark
+#Mn Nonspacing_Mark a nonspacing combining mark (zero advance width)
+#Cf Format          a format control character
+#
+UNICODEWIDTH_H=../unicode_width.h
+if ! test -d unicode; then
+       mkdir unicode
+fi &&
+( cd unicode &&
+       if ! test -f UnicodeData.txt; then
+               wget http://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
+       fi &&
+       if ! test -f EastAsianWidth.txt; then
+               wget http://www.unicode.org/Public/UCD/latest/ucd/EastAsianWidth.txt
+       fi &&
+       if ! test -d uniset; then
+               git clone https://github.com/depp/uniset.git
+       fi &&
+       (
+               cd uniset &&
+               if ! test -x uniset; then
+                       autoreconf -i &&
+                       ./configure --enable-warnings=-Werror CFLAGS='-O0 -ggdb'
+               fi &&
+               make
+       ) &&
+       echo "static const struct interval zero_width[] = {" >$UNICODEWIDTH_H &&
+       UNICODE_DIR=. ./uniset/uniset --32 cat:Me,Mn,Cf + U+1160..U+11FF - U+00AD |
+       grep -v plane >>$UNICODEWIDTH_H &&
+       echo "};" >>$UNICODEWIDTH_H &&
+       echo "static const struct interval double_width[] = {" >>$UNICODEWIDTH_H &&
+       UNICODE_DIR=. ./uniset/uniset --32 eaw:F,W >>$UNICODEWIDTH_H &&
+       echo "};" >>$UNICODEWIDTH_H
+)
diff --git a/utf8.c b/utf8.c
index 77c28d492cccfcbcb8a302d168a81b21d909ef12..b30790d043aa4b01da00686654dfb615a92e75b6 100644 (file)
--- a/utf8.c
+++ b/utf8.c
@@ -80,52 +80,8 @@ static int git_wcwidth(ucs_char_t ch)
 {
        /*
         * Sorted list of non-overlapping intervals of non-spacing characters,
-        * generated by
-        *   "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c".
         */
-       static const struct interval combining[] = {
-               { 0x0300, 0x036F }, { 0x0483, 0x0489 }, { 0x0591, 0x05BD },
-               { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 }, { 0x05C4, 0x05C5 },
-               { 0x05C7, 0x05C7 }, { 0x0600, 0x0604 }, { 0x0610, 0x061A },
-               { 0x064B, 0x065F }, { 0x0670, 0x0670 }, { 0x06D6, 0x06E4 },
-               { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, { 0x070F, 0x070F },
-               { 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 },
-               { 0x0901, 0x0902 }, { 0x093C, 0x093C }, { 0x0941, 0x0948 },
-               { 0x094D, 0x094D }, { 0x0951, 0x0954 }, { 0x0962, 0x0963 },
-               { 0x0981, 0x0981 }, { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 },
-               { 0x09CD, 0x09CD }, { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 },
-               { 0x0A3C, 0x0A3C }, { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 },
-               { 0x0A4B, 0x0A4D }, { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 },
-               { 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 },
-               { 0x0ACD, 0x0ACD }, { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 },
-               { 0x0B3C, 0x0B3C }, { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 },
-               { 0x0B4D, 0x0B4D }, { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 },
-               { 0x0BC0, 0x0BC0 }, { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 },
-               { 0x0C46, 0x0C48 }, { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 },
-               { 0x0CBC, 0x0CBC }, { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 },
-               { 0x0CCC, 0x0CCD }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
-               { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
-               { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
-               { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
-               { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
-               { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
-               { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
-               { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
-               { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
-               { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x1712, 0x1714 },
-               { 0x1732, 0x1734 }, { 0x1752, 0x1753 }, { 0x1772, 0x1773 },
-               { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD }, { 0x17C6, 0x17C6 },
-               { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD }, { 0x180B, 0x180D },
-               { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 }, { 0x1927, 0x1928 },
-               { 0x1932, 0x1932 }, { 0x1939, 0x193B }, { 0x200B, 0x200F },
-               { 0x202A, 0x202E }, { 0x2060, 0x2063 }, { 0x206A, 0x206F },
-               { 0x20D0, 0x20EA }, { 0x302A, 0x302F }, { 0x3099, 0x309A },
-               { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE20, 0xFE23 },
-               { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB }, { 0x1D167, 0x1D169 },
-               { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B },
-               { 0x1D1AA, 0x1D1AD }, { 0xE0001, 0xE0001 },
-               { 0xE0020, 0xE007F }, { 0xE0100, 0xE01EF }
-       };
+#include "unicode_width.h"
 
        /* test for 8-bit control characters */
        if (ch == 0)
@@ -134,34 +90,16 @@ static int git_wcwidth(ucs_char_t ch)
                return -1;
 
        /* binary search in table of non-spacing characters */
-       if (bisearch(ch, combining, sizeof(combining)
+       if (bisearch(ch, zero_width, sizeof(zero_width)
                                / sizeof(struct interval) - 1))
                return 0;
 
-       /*
-        * If we arrive here, ch is neither a combining nor a C0/C1
-        * control character.
-        */
+       /* binary search in table of double width characters */
+       if (bisearch(ch, double_width, sizeof(double_width)
+                               / sizeof(struct interval) - 1))
+               return 2;
 
-       return 1 +
-               (ch >= 0x1100 &&
-                    /* Hangul Jamo init. consonants */
-                (ch <= 0x115f ||
-                 ch == 0x2329 || ch == 0x232a ||
-                  /* CJK ... Yi */
-                 (ch >= 0x2e80 && ch <= 0xa4cf &&
-                  ch != 0x303f) ||
-                 /* Hangul Syllables */
-                 (ch >= 0xac00 && ch <= 0xd7a3) ||
-                 /* CJK Compatibility Ideographs */
-                 (ch >= 0xf900 && ch <= 0xfaff) ||
-                 /* CJK Compatibility Forms */
-                 (ch >= 0xfe30 && ch <= 0xfe6f) ||
-                 /* Fullwidth Forms */
-                 (ch >= 0xff00 && ch <= 0xff60) ||
-                 (ch >= 0xffe0 && ch <= 0xffe6) ||
-                 (ch >= 0x20000 && ch <= 0x2fffd) ||
-                 (ch >= 0x30000 && ch <= 0x3fffd)));
+       return 1;
 }
 
 /*
index 0cc56368bd8ccef90ff643ce091cae25007eeee7..bc1bfb86003cb4133cc4ce3ce6423ce780ed7c84 100644 (file)
--- a/wrapper.c
+++ b/wrapper.c
@@ -174,6 +174,24 @@ ssize_t xwrite(int fd, const void *buf, size_t len)
        }
 }
 
+/*
+ * xpread() is the same as pread(), but it automatically restarts pread()
+ * operations with a recoverable error (EAGAIN and EINTR). xpread() DOES
+ * NOT GUARANTEE that "len" bytes is read even if the data is available.
+ */
+ssize_t xpread(int fd, void *buf, size_t len, off_t offset)
+{
+       ssize_t nr;
+       if (len > MAX_IO_SIZE)
+               len = MAX_IO_SIZE;
+       while (1) {
+               nr = pread(fd, buf, len, offset);
+               if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
+                       continue;
+               return nr;
+       }
+}
+
 ssize_t read_in_full(int fd, void *buf, size_t count)
 {
        char *p = buf;
@@ -214,6 +232,26 @@ ssize_t write_in_full(int fd, const void *buf, size_t count)
        return total;
 }
 
+ssize_t pread_in_full(int fd, void *buf, size_t count, off_t offset)
+{
+       char *p = buf;
+       ssize_t total = 0;
+
+       while (count > 0) {
+               ssize_t loaded = xpread(fd, p, count, offset);
+               if (loaded < 0)
+                       return -1;
+               if (loaded == 0)
+                       return total;
+               count -= loaded;
+               p += loaded;
+               total += loaded;
+               offset += loaded;
+       }
+
+       return total;
+}
+
 int xdup(int fd)
 {
        int ret = dup(fd);
index ec7344e50834f18821692d7e38f634778d632080..b8841e1dcaa73223345b6c24eec3a91de74a0222 100644 (file)
@@ -188,7 +188,7 @@ static void wt_status_print_unmerged_header(struct wt_status *s)
        } else {
                status_printf_ln(s, c, _("  (use \"git add/rm <file>...\" as appropriate to mark resolution)"));
        }
-       status_printf_ln(s, c, "");
+       status_printf_ln(s, c, "%s", "");
 }
 
 static void wt_status_print_cached_header(struct wt_status *s)
@@ -204,7 +204,7 @@ static void wt_status_print_cached_header(struct wt_status *s)
                status_printf_ln(s, c, _("  (use \"git reset %s <file>...\" to unstage)"), s->reference);
        else
                status_printf_ln(s, c, _("  (use \"git rm --cached <file>...\" to unstage)"));
-       status_printf_ln(s, c, "");
+       status_printf_ln(s, c, "%s", "");
 }
 
 static void wt_status_print_dirty_header(struct wt_status *s,
@@ -223,7 +223,7 @@ static void wt_status_print_dirty_header(struct wt_status *s,
        status_printf_ln(s, c, _("  (use \"git checkout -- <file>...\" to discard changes in working directory)"));
        if (has_dirty_submodules)
                status_printf_ln(s, c, _("  (commit or discard the untracked or modified content in submodules)"));
-       status_printf_ln(s, c, "");
+       status_printf_ln(s, c, "%s", "");
 }
 
 static void wt_status_print_other_header(struct wt_status *s,
@@ -235,12 +235,12 @@ static void wt_status_print_other_header(struct wt_status *s,
        if (!s->hints)
                return;
        status_printf_ln(s, c, _("  (use \"git %s <file>...\" to include in what will be committed)"), how);
-       status_printf_ln(s, c, "");
+       status_printf_ln(s, c, "%s", "");
 }
 
 static void wt_status_print_trailer(struct wt_status *s)
 {
-       status_printf_ln(s, color(WT_STATUS_HEADER, s), "");
+       status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", "");
 }
 
 #define quote_path quote_path_relative
@@ -826,7 +826,7 @@ static void wt_status_print_other(struct wt_status *s,
        string_list_clear(&output, 0);
        strbuf_release(&buf);
 conclude:
-       status_printf_ln(s, GIT_COLOR_NORMAL, "");
+       status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");
 }
 
 void wt_status_truncate_message_at_cut_line(struct strbuf *buf)
@@ -913,7 +913,7 @@ static void wt_status_print_tracking(struct wt_status *s)
                color_fprintf_ln(s->fp, color(WT_STATUS_HEADER, s), "%c",
                                 comment_line_char);
        else
-               fprintf_ln(s->fp, "");
+               fputs("", s->fp);
 }
 
 static int has_unmerged(struct wt_status *s)
@@ -1329,7 +1329,7 @@ void wt_status_print(struct wt_status *s)
                                on_what = _("Not currently on any branch.");
                        }
                }
-               status_printf(s, color(WT_STATUS_HEADER, s), "");
+               status_printf(s, color(WT_STATUS_HEADER, s), "%s", "");
                status_printf_more(s, branch_status_color, "%s", on_what);
                status_printf_more(s, branch_color, "%s\n", branch_name);
                if (!s->is_initial)
@@ -1342,9 +1342,9 @@ void wt_status_print(struct wt_status *s)
        free(state.detached_from);
 
        if (s->is_initial) {
-               status_printf_ln(s, color(WT_STATUS_HEADER, s), "");
+               status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", "");
                status_printf_ln(s, color(WT_STATUS_HEADER, s), _("Initial commit"));
-               status_printf_ln(s, color(WT_STATUS_HEADER, s), "");
+               status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", "");
        }
 
        wt_status_print_updated(s);
@@ -1361,7 +1361,7 @@ void wt_status_print(struct wt_status *s)
                if (s->show_ignored_files)
                        wt_status_print_other(s, &s->ignored, _("Ignored files"), "add -f");
                if (advice_status_u_option && 2000 < s->untracked_in_ms) {
-                       status_printf_ln(s, GIT_COLOR_NORMAL, "");
+                       status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");
                        status_printf_ln(s, GIT_COLOR_NORMAL,
                                         _("It took %.2f seconds to enumerate untracked files. 'status -uno'\n"
                                           "may speed it up, but you have to be careful not to forget to add\n"