Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Commits on Mar 26, 2015
  1. @gitster

    diff-no-index: align D/F handling with that of normal Git

    gitster authored
    When a commit changes a path P that used to be a file to a directory
    and creates a new path P/X in it, "git show" would say that file P
    was removed and file P/X was created for such a commit.
    
    However, if we compare two directories, D1 and D2, where D1 has a
    file D1/P in it and D2 has a directory D2/P under which there is a
    file D2/P/X, and ask "git diff --no-index D1 D2" to show their
    differences, we simply get a refusal "file/directory conflict".
    
    Surely, that may be what GNU diff does, but we can do better and it
    is easy to do so.
    
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. @gitster

    diff-no-index: DWIM "diff D F" into "diff D/F F"

    gitster authored
    "git diff --no-index" was supposed to be a poor-man's approach to
    allow using Git diff goodies outside of a Git repository, without
    having to patch mainstream diff implementations.
    
    Unlike a POSIX diff that treats "diff D F" (or "diff F D") as a
    request to compare D/F and F (or F and D/F) when D is a directory
    and F is a file, however, we did not accept such a command line and
    instead barfed with "file/directory conflict".
    
    Imitate what POSIX diff does and append the basename of the file
    after the name of the directory before comparing.
    
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Apr 3, 2014
  1. @gitster

    Merge branch 'jc/fix-diff-no-index-diff-opt-parse'

    gitster authored
    "diff --no-index -Mq a b" fell into an infinite loop.
    
    * jc/fix-diff-no-index-diff-opt-parse:
      diff-no-index: correctly diagnose error return from diff_opt_parse()
Commits on Mar 31, 2014
  1. @gitster

    diff-no-index: correctly diagnose error return from diff_opt_parse()

    gitster authored
    diff_opt_parse() returns the number of options parsed, or often
    returns error() which is defined to return -1.  Yes, return value of
    0 is "I did not process that option at all", which should cause the
    caller to say that, but negative return should not be forgotten.
    
    This bug caused "diff --no-index" to infinitely show the same error
    message because the returned value was used to decrement the loop
    control variable, e.g.
    
            $ git diff --no-index --color=words a b
            error: option `color' expects "always", "auto", or "never"
            error: option `color' expects "always", "auto", or "never"
            ...
    
    Instead, make it act like so:
    
            $ git diff --no-index --color=words a b
            error: option `color' expects "always", "auto", or "never"
            fatal: invalid diff option/value: --color=words
    
    Reported-by: Linus Torvalds <torvalds@linux-foundation.org>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Mar 25, 2014
  1. @gitster

    Merge branch 'bb/diff-no-index-dotdot'

    gitster authored
    * bb/diff-no-index-dotdot:
      diff-no-index: replace manual "."/".." check with is_dot_or_dotdot()
      diff-no-index: rename read_directory()
Commits on Mar 19, 2014
  1. @babourn @gitster

    diff-no-index: replace manual "."/".." check with is_dot_or_dotdot()

    babourn authored gitster committed
    Helped-by: Eric Sunshine <sunshine@sunshineco.com>
    Signed-off-by: Brian Bourn <ba.bourn@gmail.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. @babourn @gitster

    diff-no-index: rename read_directory()

    babourn authored gitster committed
    In the next patch, we will replace a manual checking of "." or ".."
    with a call to is_dot_or_dotdot() defined in dir.h.  The private
    function read_directory() defined in this file will conflict with
    the global function declared there when we do so.
    
    As a preparatory step, rename the private read_directory() to avoid
    the name collision.
    
    Helped-by: Eric Sunshine <sunshine@sunshineco.com>
    Signed-off-by: Brian Bourn <ba.bourn@gmail.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Mar 7, 2014
  1. @gitster

    Merge branch 'jc/hold-diff-remove-q-synonym-for-no-deletion'

    gitster authored
    Remove a confusing and deprecated "-q" option from "git diff-files";
    "git diff-files --diff-filter=d" can be used instead.
Commits on Dec 12, 2013
  1. @tgummerer @gitster

    diff: move no-index detection to builtin/diff.c

    tgummerer authored gitster committed
    Currently the --no-index option is parsed in diff_no_index().  Move the
    detection if a no-index diff should be executed to builtin/diff.c, where
    we can use it for executing diff_no_index() conditionally.  This will
    also allow us to execute other operations conditionally, which will be
    done in the next patch.
    
    There are no functional changes.
    
    Helped-by: Jonathan Nieder <jrnieder@gmail.com>
    Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Sep 17, 2013
  1. @gitster

    Merge branch 'dw/diff-no-index-doc'

    gitster authored
    When the user types "git diff" outside a working tree, thinking he
    is inside one, the current error message that is a single-liner
    "usage: git diff --no-index <path> <path>" may not be sufficient to
    make him realize the mistake. Add "Not a git repository" to the
    error message when we fell into the "--no-index" mode without an
    explicit command line option to instruct us to do so.
    
    * dw/diff-no-index-doc:
      diff --no-index: describe in a separate paragraph
      diff --no-index: clarify operation when not inside a repository
Commits on Sep 9, 2013
  1. @gitster

    Merge branch 'jc/diff-filter-negation'

    gitster authored
    Teach "git diff --diff-filter" to express "I do not want to see
    these classes of changes" more directly by listing only the
    unwanted ones in lowercase (e.g. "--diff-filter=d" will show
    everything but deletion) and deprecate "diff-files -q" which did
    the same thing as "--diff-filter=d".
    
    * jc/diff-filter-negation:
      diff: deprecate -q option to diff-files
      diff: allow lowercase letter to specify what change class to exclude
      diff: reject unknown change class given to --diff-filter
      diff: preparse --diff-filter string argument
      diff: factor out match_filter()
      diff: pass the whole diff_options to diffcore_apply_filter()
Commits on Aug 22, 2013
  1. @gitster

    diff --no-index: clarify operation when not inside a repository

    Dale R. Worley authored gitster committed
    Clarify documentation for "diff --no-index".  State that when not
    inside a repository, --no-index is implied and two arguments are
    mandatory.
    
    Clarify error message from diff-no-index to inform user that CWD is
    not inside a repository and thus two arguments are mandatory.
    
    Signed-off-by: Dale Worley <worley@ariadne.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Jul 19, 2013
  1. @gitster

    diff: remove "diff-files -q" in a version of Git in a distant future

    gitster authored
    This was inherited from "show-diff -q" that was invented to tell
    comparison between the index and the working tree to ignore only
    removals in 2005.
    
    These days, it is spelled as "--diff-filter=d".
    
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. @gitster

    diff: deprecate -q option to diff-files

    gitster authored
    This reimplements the ancient "-q" option to "git diff-files" that
    was inherited from "show-diff -q" in terms of "--diff-filter=d".  We
    will be deprecating the "-q" option, so let's issue a warning when
    we do so.
    
    Incidentally this also tentatively fixes "git diff --no-index" to
    honor "-q" and hide deletions; the use will get the same warning.
    
    We should remove the support for "-q" in a future version but it is
    not that urgent.
    
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on May 8, 2013
  1. @jrn @gitster

    mingw: rename WIN32 cpp macro to GIT_WINDOWS_NATIVE

    jrn authored gitster committed
    Throughout git, it is assumed that the WIN32 preprocessor symbol is
    defined on native Windows setups (mingw and msvc) and not on Cygwin.
    On Cygwin, most of the time git can pretend this is just another Unix
    machine, and Windows-specific magic is generally counterproductive.
    
    Unfortunately Cygwin *does* define the WIN32 symbol in some headers.
    Best to rely on a new git-specific symbol GIT_WINDOWS_NATIVE instead,
    defined as follows:
    
    	#if defined(WIN32) && !defined(__CYGWIN__)
    	# define GIT_WINDOWS_NATIVE
    	#endif
    
    After this change, it should be possible to drop the
    CYGWIN_V15_WIN32API setting without any negative effect.
    
    [rj: %s/WINDOWS_NATIVE/GIT_WINDOWS_NATIVE/g ]
    
    Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
    Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Aug 27, 2012
  1. @gitster

    Merge branch 'jk/maint-null-in-trees'

    gitster authored
    We do not want a link to 0{40} object stored anywhere in our objects.
    
    * jk/maint-null-in-trees:
      fsck: detect null sha1 in tree entries
      do not write null sha1s to on-disk index
      diff: do not use null sha1 as a sentinel value
Commits on Aug 22, 2012
  1. @gitster

    Merge branch 'tr/void-diff-setup-done'

    gitster authored
    Remove unnecessary code.
    
    * tr/void-diff-setup-done:
      diff_setup_done(): return void
Commits on Aug 3, 2012
  1. @trast @gitster

    diff_setup_done(): return void

    trast authored gitster committed
    diff_setup_done() has historically returned an error code, but lost
    the last nonzero return in 943d5b7 (allow diff.renamelimit to be set
    regardless of -M/-C, 2006-08-09).  The callers were in a pretty
    confused state: some actually checked for the return code, and some
    did not.
    
    Let it return void, and patch all callers to take this into account.
    This conveniently also gets rid of a handful of different(!) error
    messages that could never be triggered anyway.
    
    Note that the function can still die().
    
    Signed-off-by: Thomas Rast <trast@student.ethz.ch>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Jul 29, 2012
  1. @peff @gitster

    diff: do not use null sha1 as a sentinel value

    peff authored gitster committed
    The diff code represents paths using the diff_filespec
    struct. This struct has a sha1 to represent the sha1 of the
    content at that path, as well as a sha1_valid member which
    indicates whether its sha1 field is actually useful. If
    sha1_valid is not true, then the filespec represents a
    working tree file (e.g., for the no-index case, or for when
    the index is not up-to-date).
    
    The diff_filespec is only used internally, though. At the
    interfaces to the diff subsystem, callers feed the sha1
    directly, and we create a diff_filespec from it. It's at
    that point that we look at the sha1 and decide whether it is
    valid or not; callers may pass the null sha1 as a sentinel
    value to indicate that it is not.
    
    We should not typically see the null sha1 coming from any
    other source (e.g., in the index itself, or from a tree).
    However, a corrupt tree might have a null sha1, which would
    cause "diff --patch" to accidentally diff the working tree
    version of a file instead of treating it as a blob.
    
    This patch extends the edges of the diff interface to accept
    a "sha1_valid" flag whenever we accept a sha1, and to use
    that flag when creating a filespec. In some cases, this
    means passing the flag through several layers, making the
    code change larger than would be desirable.
    
    One alternative would be to simply die() upon seeing
    corrupted trees with null sha1s. However, this fix more
    directly addresses the problem (while bogus sha1s in a tree
    are probably a bad thing, it is really the sentinel
    confusion sending us down the wrong code path that is what
    makes it devastating). And it means that git is more capable
    of examining and debugging these corrupted trees. For
    example, you can still "diff --raw" such a tree to find out
    when the bogus entry was introduced; you just cannot do a
    "--patch" diff (just as you could not with any other
    corrupted tree, as we do not have any content to diff).
    
    Signed-off-by: Jeff King <peff@peff.net>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Jul 13, 2012
  1. @gitster

    Merge branch 'jc/refactor-diff-stdin'

    gitster authored
    Due to the way "git diff --no-index" is bolted onto by touching the
    low level code that is shared with the rest of the "git diff" code,
    even though it has to work in a very different way, any comparison
    that involves a file "-" at the root level incorrectly tried to read
    from the standard input.  This cleans up the no-index codepath
    further to remove code that reads from the standard input from the
    core side, which is never necessary when git is running its usual
    diff operation.
    
    * jc/refactor-diff-stdin:
      diff-index.c: "git diff" has no need to read blob from the standard input
      diff-index.c: unify handling of command line paths
      diff-index.c: do not pretend paths are pathspecs
Commits on Jul 5, 2012
  1. @gitster

    Merge branch 'th/diff-no-index-fixes'

    gitster authored
    "git diff --no-index" did not correctly handle relative paths and
    did not give correct exit codes when run under "--quiet" option.
    
    * th/diff-no-index-fixes:
      diff-no-index: exit(1) if 'diff --quiet <repo file> <external file>' finds changes
      diff: handle relative paths in no-index
Commits on Jun 28, 2012
  1. @gitster

    diff-index.c: "git diff" has no need to read blob from the standard i…

    gitster authored
    …nput
    
    Only "diff --no-index -" does.  Bolting the logic into the low-level
    function diff_populate_filespec() was a layering violation from day
    one.  Move populate_from_stdin() function out of the generic diff.c
    to its only user, diff-index.c.
    
    Also make sure "-" from the command line stays a special token "read
    from the standard input", even if we later decide to sanitize the
    result from prefix_filename() function in a few obvious ways,
    e.g. removing unnecessary "./" prefix, duplicated slashes "//" in
    the middle, etc.
    
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. @gitster

    diff-index.c: unify handling of command line paths

    gitster authored
    Regardless of where in the directory hierarchy you are, "-" on the
    command line means the standard input.  The old code knew too much
    about how the low level machinery uses paths to read from the
    working tree and did not bother to have the same check for "-" when
    the command is run from the top-level.
    
    Unify the codepaths for subdirectory case and toplevel case into one
    and make it clearer.
    
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  3. @gitster

    diff-index.c: do not pretend paths are pathspecs

    gitster authored
    "git diff --no-index" takes exactly two paths, not pathspecs, and
    has its own way queue_diff() to populate the diff_queue.  Do not
    call diff_tree_setup_paths(), pretending as it takes pathspecs.
    
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Jun 22, 2012
  1. @thenigan @gitster

    diff-no-index: exit(1) if 'diff --quiet <repo file> <external file>' …

    thenigan authored gitster committed
    …finds changes
    
    When running 'git diff --quiet <file1> <file2>', if file1 or file2
    is outside the repository, it will exit(0) even if the files differ.
    It should exit(1) when they differ.
    
    This happens because 'diff_no_index' looks at the 'found_changes'
    member from 'diff_options' to determine if changes were made.  This
    is the wrong thing to do, since it is only set if xdiff is actually
    run and it finds a change (the diff machinery will optimize out the
    xdiff call when it is not necessary) and in that case HAS_CHANGED
    flag needs to be taken into account.
    
    Use diff_result_code() that knows all these details for the correct
    exit value instead.
    
    Signed-off-by: Tim Henigan <tim.henigan@gmail.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. @peff @gitster

    diff: handle relative paths in no-index

    peff authored gitster committed
    When diff-no-index is given a relative path to a file outside the
    repository, it aborts with error. However, if the file is given
    using an absolute path, the diff runs as expected. The two cases
    should be treated the same.
    
    Tests and commit message by Tim Henigan.
    
    Signed-off-by: Jeff King <peff@peff.net>
    Signed-off-by: Tim Henigan <tim.henigan@gmail.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Jun 15, 2012
  1. @peff @gitster

    do not run pager with diff --no-index --quiet

    peff authored gitster committed
    There is no point in running a pager when --quiet is given,
    since we are producing no output. The regular diff code path
    handles this already, because --quiet implies --exit-code,
    and we check for --exit-code when deciding not to run the
    pager.
    
    However, the "quiet implies exit-code" logic is done in
    diff_setup_done, and the no-index code path sets up its
    pager before running diff_setup_done, and misses this case.
    
    We can fix this by reordering our initialization.
    Currently we do:
    
      1. read command line arguments into diff_options
    
      2. Set pager if EXIT_CODE not requested
    
      3. always set EXIT_CODE, since we are emulating
         traditional diff
    
      4. call diff_setup_done
    
    We can fix the problem by moving pager initialization (step
    2) after step 4. But step 3 must come after step 2 (since we
    want to know whether the _user_ requested --exit-code, not
    whether we turned it on unconditionally). So we must move
    both.
    
    Signed-off-by: Jeff King <peff@peff.net>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. @peff @gitster

    fix pager.diff with diff --no-index

    peff authored gitster committed
    git-diff does not rely on the git wrapper to setup its
    pager; instead, it sets it up on its own after seeing
    whether --quiet or --exit-code has been specified.  After
    diff_no_index was split off from cmd_diff, commit b3fde6c
    (git diff --no-index: default to page like other diff
    frontends, 2008-05-26) duplicated the one-liner from
    cmd_diff to turn on the pager.
    
    Later, commit 8f0359f (Allow pager of diff command be
    enabled/disabled, 2008-07-21) taught the the version in
    cmd_diff to respect the pager.diff config, but the version
    in diff_no_index was left behind. This meant that
    
      git -c pager.diff=0 diff a b
    
    would not use a pager, but
    
      git -c pager.diff=0 diff --no-index a b
    
    would.  Let's fix it by factoring out a common function.
    
    While we're there, let's update the antiquated comment,
    which claims that the pager interferes with propagating the
    exit code; this has not been the case since ea27a18 (spawn
    pager via run_command interface, 2008-07-22).
    
    Signed-off-by: Jeff King <peff@peff.net>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on May 16, 2012
  1. @bpowers @gitster

    diff --no-index: don't leak buffers in queue_diff

    bpowers authored gitster committed
    queue_diff uses two strbufs, and at the end of the function
    strbuf_reset was called.  This only reset the length of the buffer -
    any allocated memory was leaked.  Using strbuf_release fixes this.
    
    Signed-off-by: Bobby Powers <bobbypowers@gmail.com>
    Reviewed-by: René Scharfe <rene.scharfe@lsrfire.ath.cx>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. @bpowers @gitster

    diff --no-index: reset temporary buffer lengths on directory iteration

    bpowers authored gitster committed
    Commit 875b91b (diff --no-index: use strbuf for temporary pathnames,
    2012-04-25) introduced a regression when using diff --no-index with
    directories.  When iterating through a directory, the switch to strbuf
    from heap-allocated char arrays caused paths to form like 'dir/file1',
    'dir/file1file2', rather than 'dir/file1', 'dir/file2' as expected.
    
    Avoid this by resetting the paths variables to their original length
    before each iteration.
    
    Signed-off-by: Bobby Powers <bobbypowers@gmail.com>
    Reviewed-by: René Scharfe <rene.scharfe@lsrfire.ath.cx>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Apr 26, 2012
  1. @gitster

    diff --no-index: use strbuf for temporary pathnames

    gitster authored
    Instead of using limited-length buffers and risking of pathname
    truncation, we should be taking advantage of strbuf API nowadays.
    
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Apr 16, 2012
  1. @meyering @gitster

    diff: avoid stack-buffer-read-overrun for very long name

    meyering authored gitster committed
    Due to the use of strncpy without explicit NUL termination,
    we could end up passing names n1 or n2 that are not NUL-terminated
    to queue_diff, which requires NUL-terminated strings.
    Ensure that each is NUL terminated.
    
    Signed-off-by: Jim Meyering <meyering@redhat.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Feb 3, 2011
  1. @pclouds @gitster

    Convert struct diff_options to use struct pathspec

    pclouds authored gitster committed
    Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. @pclouds @gitster

    diff-no-index: use diff_tree_setup_paths()

    pclouds authored gitster committed
    diff_options.{paths,nr_paths} will be removed later. Do not
    modify them directly.
    
    Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Commits on Jul 5, 2010
  1. @gitster

    string_list: Add STRING_LIST_INIT macro and make use of it.

    Thiago Farina authored gitster committed
    Acked-by: Jonathan Nieder <jrnieder@gmail.com>
    Signed-off-by: Thiago Farina <tfransosi@gmail.com>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
Something went wrong with that request. Please try again.