1. 19 Sep, 2013 1 commit
  2. 17 Sep, 2013 2 commits
    • Add ident filter · 4b11f25a
      This adds the ident filter (that knows how to replace $Id$) and
      tweaks the filter APIs and code so that git_filter_source objects
      actually have the updated OID of the object being filtered when
      it is a known value.
      Russell Belfer committed
    • Create public filter object and use it · 85d54812
      This creates include/sys/filter.h with a basic definition of a
      git_filter and then converts the internal code to use it.  There
      are related internal objects (git_filter_list) that we will want
      to publish at some point, but this is a first step.
      Russell Belfer committed
  3. 05 Aug, 2013 1 commit
  4. 10 Jul, 2013 5 commits
    • Untracked directories with .git should be ignored · 125655fe
      This restores a behavior that was accidentally lost during some
      diff refactoring where an untracked directory that contains a .git
      item should be treated as IGNORED, not as UNTRACKED.  The submodule
      code already detects this, but the diff code was not handling the
      scenario right.
      
      This also updates a number of existing tests that were actually
      exercising the behavior but did not have the right expectations in
      place.  It actually makes the new
      `test_diff_submodules__diff_ignore_options` test feel much better
      because the "not-a-submodule" entries are now ignored instead of
      showing up as untracked items.
      
      Fixes #1697
      Russell Belfer committed
    • Add ignore_submodules to diff options · f9775a37
      This adds correct support for an equivalent to --ignore-submodules
      in diff, where an actual ignore value can be passed to diff to
      override the per submodule settings in the configuration.
      
      This required tweaking the constants for ignore values so that
      zero would not be used and could represent an unset option to the
      diff.  This was an opportunity to move the submodule values into
      include/git2/types.h and to rename the poorly named DEFAULT values
      for ignore and update constants to RESET instead.
      
      Now the GIT_DIFF_IGNORE_SUBMODULES flag is exactly the same as
      setting the ignore_submodules option to GIT_SUBMODULE_IGNORE_ALL
      (which is actually a minor change from the old behavior in that
      submodules will now be treated as UNMODIFIED deltas instead of
      being left out totally - if you set GIT_DIFF_INCLUDE_UNMODIFIED).
      
      This includes tests for the various new settings.
      Russell Belfer committed
    • Update diff to new internal submodule status API · 2e3e273e
      Submodules now expose an internal status API that allows diff to
      get back the OID values from the submodule very easily and also
      to avoiding caching issues and to override the ignore setting for
      the submodule.
      Russell Belfer committed
    • Add git_pathspec_match_diff API · 2b672d5b
      This adds an additional pathspec API that will match a pathspec
      against a diff object.  This is convenient if you want to handle
      renames (so you need the whole diff and can't use the pathspec
      constraint built into the diff API) but still want to tell if the
      diff had any files that matched the pathspec.
      
      When the pathspec is matched against a diff, instead of keeping
      a list of filenames that matched, instead the API keeps the list
      of git_diff_deltas that matched and they can be retrieved via a
      new API git_pathspec_match_list_diff_entry.
      
      There are a couple of other minor API extensions here that were
      mostly for the sake of convenience and to reduce dependencies
      on knowing the internal data structure between files inside the
      library.
      Russell Belfer committed
    • Add public API for pathspec matching · d2ce27dd
      This adds a new public API for compiling pathspecs and matching
      them against the working directory, the index, or a tree from the
      repository.  This also reworks the pathspec internals to allow the
      sharing of code between the existing internal usage of pathspec
      matching and the new external API.
      
      While this is working and the new API is ready for discussion, I
      think there is still an incorrect behavior in which patterns are
      always matched against the full path of an entry without taking
      the subdirectories into account (so "s*" will match "subdir/file"
      even though it wouldn't with core Git).  Further enhancements are
      coming, but this was a good place to take a functional snapshot.
      Russell Belfer committed
  5. 03 Jul, 2013 2 commits
  6. 20 Jun, 2013 2 commits
    • Add status flags to force output sort order · 22b6b82f
      Files in status will, be default, be sorted according to the case
      insensitivity of the filesystem that we're running on.  However,
      in some cases, this is not desirable.  Even on case insensitive
      file systems, 'git status' at the command line will generally use
      a case sensitive sort (like 'ls').  Some GUIs prefer to display a
      list of file case insensitively even on case-sensitive platforms.
      
      This adds two new flags: GIT_STATUS_OPT_SORT_CASE_SENSITIVELY
      and GIT_STATUS_OPT_SORT_CASE_INSENSITIVELY that will override the
      default sort order of the status output and give the user control.
      This includes tests for exercising these new options and makes
      the examples/status.c program emulate core Git and always use a
      case sensitive sort.
      Russell Belfer committed
    • Fix bug in diff untracked dir scan · 852ded96
      When scanning untracked directories looking for non-ignored files
      there was a bug where an empty directory would generate a false
      error.
      Russell Belfer committed
  7. 19 Jun, 2013 1 commit
    • Add index pathspec-based operations · f30fff45
      This adds three new public APIs for manipulating the index:
      
      1. `git_index_add_all` is similar to `git add -A` and will add
         files in the working directory that match a pathspec to the
         index while honoring ignores, etc.
      2. `git_index_remove_all` removes files from the index that match
         a pathspec.
      3. `git_index_update_all` updates entries in the index based on
         the current contents of the working directory, either added
         the new information or removing the entry from the index.
      Russell Belfer committed
  8. 17 Jun, 2013 3 commits
    • Always do tree to index diffs case sensitively · eefef642
      Trees are always case sensitive.  The index is always case
      preserving and will be case sensitive when it is turned into a
      tree.  Therefore the tree and the index can and should always
      be compared to one another case sensitively.
      
      This will restore the index to case insensitive order after the
      diff has been generated.
      
      Consider this a short-term fix.  The long term fix is to have the
      index always stored both case sensitively and case insensitively
      (at least on platforms that sometimes require case insensitivity).
      Russell Belfer committed
    • Improve case handling in git_diff__paired_foreach · 351888cf
      This commit reinstates some changes to git_diff__paired_foreach
      that were discarded during the rebase (because the diff_output.c
      file had gone away), and also adjusts the case insensitively
      logic slightly to hopefully deal with either mismatched icase
      diffs and other case insensitivity scenarios.
      Russell Belfer committed
    • Be more careful about the path with diffs · a3e8dbb4
      This makes diff more careful about picking the canonical path
      when generating a delta so that it won't accidentally pick up a
      case-mismatched path on a case-insensitive file system.  This
      should make sure we use the "most accurate" case correct version
      of the path (i.e. from the tree if possible, or the index if
      need be).
      Russell Belfer committed
  9. 12 Jun, 2013 1 commit
  10. 10 Jun, 2013 1 commit
    • Reorganize diff and add basic diff driver · 114f5a6c
      This is a significant reorganization of the diff code to break it
      into a set of more clearly distinct files and to document the new
      organization.  Hopefully this will make the diff code easier to
      understand and to extend.
      
      This adds a new `git_diff_driver` object that looks of diff driver
      information from the attributes and the config so that things like
      function content in diff headers can be provided.  The full driver
      spec is not implemented in the commit - this is focused on the
      reorganization of the code and putting the driver hooks in place.
      
      This also removes a few #includes from src/repository.h that were
      overbroad, but as a result required extra #includes in a variety
      of places since including src/repository.h no longer results in
      pulling in the whole world.
      Russell Belfer committed
  11. 07 Jun, 2013 1 commit
  12. 31 May, 2013 2 commits
    • Zero memory for major objects before freeing · f658dc43
      By zeroing out the memory when we free larger objects (i.e. those
      that serve as collections of other data, such as repos, odb, refdb),
      I'm hoping that it will be easier for libgit2 bindings to find
      errors in their object management code.
      Russell Belfer committed
    • Make iterators use GIT_ITEROVER & smart advance · cee695ae
      1. internal iterators now return GIT_ITEROVER when you go past the
         last item in the iteration.
      2. git_iterator_advance will "advance" to the first item in the
         iteration if it is called immediately after creating the
         iterator, which allows a simpler idiom for basic iteration.
      3. if git_iterator_advance encounters an error reading data (e.g.
         a missing tree or an unreadable file), it returns the error
         but also attempts to advance past the invalid data to prevent
         an infinite loop.
      
      Updated all tests and internal usage of iterators to account for
      these new behaviors.
      Russell Belfer committed
  13. 24 May, 2013 1 commit
  14. 17 May, 2013 1 commit
  15. 15 May, 2013 1 commit
  16. 08 May, 2013 1 commit
  17. 07 May, 2013 1 commit
    • Add GIT_DIFF_LINE_CONTEXT_EOFNL · e35e2684
      This adds a new line origin constant for the special line that
      is used when both files end without a newline.
      
      In the course of writing the tests for this, I was having problems
      with modifying a file but not having diff notice because it was
      the same size and modified less than one second from the start of
      the test, so I decided to start working on nanosecond timestamp
      support.  This commit doesn't contain the nanosecond support, but
      it contains the reorganization of maybe_modified and the hooks so
      that if the nanosecond data were being read by stat() (or rather
      being copied by git_index_entry__init_from_stat), then the nsec
      would be taken into account.
      
      This new stuff could probably use some more tests, although there
      is some amount of it here.
      Russell Belfer committed
  18. 03 May, 2013 1 commit
  19. 30 Apr, 2013 3 commits
    • Update diff handling of untracked directories · e26b14c0
      When diff encounters an untracked directory, there was a shortcut
      that it took which is not compatible with core git.  This makes
      the default behavior no longer take that shortcut and instead look
      inside the untracked directory to see if there are any untracked
      files within it.  If there are not, then the directory is treated
      as an ignore directory instead of an untracked directory.  This
      has implications for the git_status APIs.
      Russell Belfer committed
    • Reorganize diff code into functions · fdb3034e
      In preparation for more changes to the internal diff logic, it
      seemed wise to split the very large git_diff__from_iterators into
      separate functions that handle the four main cases (unmatched old
      item, unmatched new item, unmatched new directory, and matched
      old and new items).  Hopefully this will keep the logic easier to
      follow even as more cases have to be added to this code.
      Russell Belfer committed
  20. 29 Apr, 2013 1 commit
  21. 23 Apr, 2013 4 commits
  22. 09 Apr, 2013 1 commit
    • Tests and more fixes for submodule diffs · ad26434b
      This adds tests for diffs with submodules in them and (perhaps
      unsurprisingly) requires further fixes to be made.  Specifically,
      this fixes:
      
      - when considering if a submodule is dirty in the workdir, it was
        being treated as dirty even if only the index was dirty.
      - git_diff_patch_to_str (and git_diff_patch_print) were "printing"
        the headers for files (and submodules) that were unmodified or
        had no meaningful content.
      - added comment to previous fix and removed unneeded parens.
      Russell Belfer committed
  23. 26 Mar, 2013 2 commits
    • Fix some diff ignores and submodule dirty workdir · ccfa6805
      This started out trying to look at the problems from issue #1425
      and gradually grew to a broader set of fixes.  There are two core
      things fixed here:
      
      1. When you had an ignore like "/bin" which is rooted at the top
         of your tree, instead of immediately adding the "bin/" entry
         as an ignored item in the diff, we were returning all of the
         direct descendants of the directory as ignored items.  This
         changes things to immediately ignore the directory.  Note that
         this effects the behavior in test_status_ignore__subdirectories
         so that we no longer exactly match core gits ignore behavior,
         but the new behavior probably makes more sense (i.e. we now
         will include an ignored directory inside an untracked directory
         that we previously would have left off).
      2. When a submodule only contained working directory changes, the
         diff code was always considering it unmodified which was just
         an outright bug. The HEAD SHA of the submodule matches the SHA
         in the parent repo index, and since the SHAs matches, the diff
         code was overwriting the actual status with UNMODIFIED.
      
      These fixes broke existing tests test_diff_workdir__submodules and
      test_status_ignore__subdirectories but looking it over, I actually
      think the new results are correct and the old results were wrong.
      @nulltoken had actually commented on the subdirectory ignore issue
      previously.
      
      I also included in the tests some debugging versions of the
      shared iteration callback routines that print status or diff
      information.  These aren't used actively in the tests, but can be
      quickly swapped in to test code to give a better picture of what
      is being scanned in some of the complex test scenarios.
      Russell Belfer committed
    • Implement GIT_STATUS_OPT_EXCLUDE_SUBMODULES · 37ee70fa
      This option has been sitting unimplemented for a while, so I
      finally went through and implemented it along with some tests.
      
      As part of this, I improved the implementation of
      GIT_DIFF_IGNORE_SUBMODULES so it be more diligent about avoiding
      extra work and about leaving off delta records for submodules to
      the greatest extent possible (though it may include them still
      if you are request TYPECHANGE records).
      Russell Belfer committed
  24. 25 Mar, 2013 1 commit
    • Recursing into ignored dirs for diff and status · 0c289dd7
      This implements working versions of GIT_DIFF_RECURSE_IGNORED_DIRS
      and GIT_STATUS_OPT_RECURSE_IGNORED_DIRS along with some tests for
      the newly available behaviors.  This is not turned on by default
      for status, but can be accessed via the options to the extended
      version of the command.
      Russell Belfer committed