1. 08 Jan, 2013 1 commit
  2. 04 Jan, 2013 2 commits
    • Fix up spoolandsort iterator usage · 546d65a8
      The spoolandsort iterator changes got sort-of cherry picked out of
      this branch and so I dropped the commit when rebasing; however,
      there were a few small changes that got dropped as well (since the
      version merged upstream wasn't quite the same as what I dropped).
      Russell Belfer committed
    • Add index updating to checkout · 5cf9875a
      Make checkout update entries in the index for all files that are
      updated and/or removed, unless flag GIT_CHECKOUT_DONT_UPDATE_INDEX
      is given.  To do this, iterators were extended to allow a little
      more introspection into the index being iterated over, etc.
      Russell Belfer committed
  3. 28 Dec, 2012 1 commit
    • Make spoolandsort a pushable iterator behavior · f616a36b
      An earlier change to `git_diff_from_iterators` introduced a
      memory leak where the allocated spoolandsort iterator was not
      returned to the caller and thus not freed.
      
      One proposal changes all iterator APIs to use git_iterator** so
      we can reallocate the iterator at will, but that seems unexpected.
      This commit makes it so that an iterator can be changed in place.
      The callbacks are isolated in a separate structure and a pointer
      to that structure can be reassigned by the spoolandsort extension.
      
      This means that spoolandsort doesn't create a new iterator; it
      just allocates a new block of callbacks (along with space for its
      own extra data) and swaps that into the iterator.
      
      Additionally, since spoolandsort is only needed to switch the
      case sensitivity of an iterator, this simplifies the API to only
      take the ignore_case boolean and to be a no-op if the iterator
      already matches the requested case sensitivity.
      Russell Belfer committed
  4. 10 Dec, 2012 2 commits
    • Fix iterator reset and add reset ranges · 91e7d263
      The `git_iterator_reset` command has not been working in all cases
      particularly when there is a start and end range.  This fixes it
      and adds tests for it, and also extends it with the ability to
      update the start/end range strings when an iterator is reset.
      Russell Belfer committed
    • Clean up iterator APIs · 9950d27a
      This removes the need to explicitly pass the repo into iterators
      where the repo is implied by the other parameters.  This moves
      the repo to be owned by the parent struct.  Also, this has some
      iterator related updates to the internal diff API to lay the
      groundwork for checkout improvements.
      Russell Belfer committed
  5. 03 Dec, 2012 1 commit
  6. 27 Nov, 2012 4 commits
  7. 20 Nov, 2012 1 commit
    • Improve iterator ignoring .git file · d46b0a04
      The workdir iterator has always tried to ignore .git files, but
      it turns out there were some bugs.  This makes it more robust at
      ignoring .git files.
      
      This also makes iterators always check ".git" case insensitively
      regardless of the properties of the system.  This will make libgit2
      skip ".GIT" and the like.  This is different from core git, but on
      systems with case insensitive but case preserving file systems,
      allowing ".GIT" to be added is problematic.
      Russell Belfer committed
  8. 15 Nov, 2012 1 commit
  9. 09 Nov, 2012 2 commits
    • Some diff refactorings to help code reuse · 55cbd05b
      There are some diff functions that are useful in a rewritten
      checkout and this lays some groundwork for that.  This contains
      three main things:
      
      1. Share the function diff uses to calculate the OID for a file
         in the working directory (now named `git_diff__oid_for_file`
      2. Add a `git_diff__paired_foreach` function to iterator over
         two diff lists concurrently.  Convert status to use it.
      3. Move all the string/prefix/index entry comparisons into
         function pointers inside the `git_diff_list` object so they
         can be switched between case sensitive and insensitive
         versions.  This makes them easier to reuse in various
         functions without replicating logic.  As part of this, move
         a couple of index functions out of diff.c and into index.c.
      Russell Belfer committed
    • Make iterator ignore eval lazy · 220d5a6c
      This makes it so that the check if a file is ignored will be
      deferred until requested on the workdir iterator, instead of
      aggressively evaluating the ignore rules for each entry.  This
      should improve performance because there will be no need to
      check ignore rules for files that are already in the index.
      Russell Belfer committed
  10. 30 Oct, 2012 1 commit
  11. 09 Oct, 2012 1 commit
    • Add complex checkout test and then fix checkout · 0d64bef9
      This started as a complex new test for checkout going through the
      "typechanges" test repository, but that revealed numerous issues
      with checkout, including:
      
      * complete failure with submodules
      * failure to create blobs with exec bits
      * problems when replacing a tree with a blob because the tree
        "example/" sorts after the blob "example" so the delete was
        being processed after the single file blob was created
      
      This fixes most of those problems and includes a number of other
      minor changes that made it easier to do that, including improving
      the TYPECHANGE support in diff/status, etc.
      Russell Belfer committed
  12. 08 Oct, 2012 1 commit
    • Fix a few diff bugs with directory content · dfbff793
      There are a few cases where diff should leave directories in
      the diff list if we want to match core git, such as when the
      directory contains a .git dir.  That feature was lost when I
      introduced some of the new submodule handling.
      
      This restores that and then fixes a couple of related to diff
      output that are triggered by having diffs with directories in
      them.
      
      Also, this adds a new flag that can be passed to diff if you
      want diff output to actually include the file content of any
      untracked files.
      Russell Belfer committed
  13. 17 Sep, 2012 1 commit
  14. 06 Sep, 2012 1 commit
  15. 24 Aug, 2012 1 commit
    • Working implementation of git_submodule_status · 5f4a61ae
      This is a big redesign of the git_submodule_status API and the
      implementation of the redesigned API.  It also fixes a number of
      bugs that I found in other parts of the submodule API while
      writing the tests for the status part.
      
      This also fixes a couple of bugs in the iterators that had not
      been noticed before - one with iterating when there is a gitlink
      (i.e. separate-work-dir) and one where I was treating anything
      even vaguely submodule-like as a submodule, more aggressively
      than core git does.
      Russell Belfer committed
  16. 17 May, 2012 3 commits
  17. 16 May, 2012 1 commit
  18. 15 May, 2012 1 commit
    • Ranged iterators and rewritten git_status_file · 41a82592
      The goal of this work is to rewrite git_status_file to use the
      same underlying code as git_status_foreach.
      
      This is done in 3 phases:
      
      1. Extend iterators to allow ranged iteration with start and
         end prefixes for the range of file names to be covered.
      2. Improve diff so that when there is a pathspec and there is
         a common non-wildcard prefix of the pathspec, it will use
         ranged iterators to minimize excess iteration.
      3. Rewrite git_status_file to call git_status_foreach_ext
         with a pathspec that covers just the one file being checked.
      
      Since ranged iterators underlie the status & diff implementation,
      this is actually fairly efficient.  The workdir iterator does
      end up loading the contents of all the directories down to the
      single file, which should ideally be avoided, but it is pretty
      good.
      Russell Belfer committed
  19. 08 May, 2012 1 commit
  20. 28 Mar, 2012 1 commit
    • Added submodule API and use in status · bfc9ca59
      When processing status for a newly checked out repo, it is
      possible that there will be submodules that have not yet been
      initialized.  The only way to distinguish these from untracked
      directories is to have some knowledge of submodules.  This
      commit adds a new submodule API which, given a name or path,
      can determine if it appears to be a submodule and can give
      information about the submodule.
      Russell Belfer committed
  21. 26 Mar, 2012 1 commit
    • Fix error in tree iterator when popping up trees · 875bfc5f
      There was an error in the tree iterator where it would
      delete two tree levels instead of just one when popping
      up a tree level.  Unfortunately the test data for the
      tree iterator did not have any deep trees with subtrees
      in the middle of the tree items, so this problem went
      unnoticed.  This contains the 1-line fix plus new test
      data and tests that reveal the issue.
      Russell Belfer committed
  22. 22 Mar, 2012 1 commit
    • New status fixes · 66142ae0
      This adds support for roughly-right tracking of submodules
      (although it does not recurse into submodules to detect
      internal modifications a la core git), and it adds support
      for including unmodified files in diff iteration if requested.
      Russell Belfer committed
  23. 19 Mar, 2012 1 commit
    • Migrate index, oid, and utils to new errors · 7c7ff7d1
      This includes a few cleanups that came up while converting
      these files.
      
      This commit introduces a could new git error classes, including
      the catchall class: GITERR_INVALID which I'm using as the class
      for invalid and out of range values which are detected at too low
      a level of library to use a higher level classification.  For
      example, an overflow error in parsing an integer or a bad letter
      in parsing an OID string would generate an error in this class.
      Russell Belfer committed
  24. 16 Mar, 2012 1 commit
  25. 15 Mar, 2012 1 commit
    • Continue error conversion · deafee7b
      This converts blob.c, fileops.c, and all of the win32 files.
      Also, various minor cleanups throughout the code.  Plus, in
      testing the win32 build, I cleaned up a bunch (although not
      all) of the warnings with the 64-bit build.
      Russell Belfer committed
  26. 06 Mar, 2012 1 commit
  27. 02 Mar, 2012 1 commit
    • Update diff to use iterators · 74fa4bfa
      This is a major reorganization of the diff code.  This changes
      the diff functions to use the iterators for traversing the
      content.  This allowed a lot of code to be simplified.  Also,
      this moved the functions relating to outputting a diff into a
      new file (diff_output.c).
      
      This includes a number of other changes - adding utility
      functions, extending iterators, etc. plus more tests for the
      diff code.  This also takes the example diff.c program much
      further in terms of emulating git-diff command line options.
      Russell Belfer committed
  28. 23 Feb, 2012 1 commit
  29. 22 Feb, 2012 2 commits
    • Fix iterators based on pull request feedback · 0534641d
      This update addresses all of the feedback in pull request #570.
      
      The biggest change was to create actual linked list stacks for
      storing the tree and workdir iterator state.  This cleaned up
      the code a ton.  Additionally, all of the static functions had
      their 'git_' prefix removed, and a lot of other unnecessary
      changes were removed from the original patch.
      Russell Belfer committed
    • Iterator improvements from diff implementation · da337c80
      This makes two changes to iterator behavior: first, advance
      can optionally do the work of returning the new current value.
      This is such a common pattern that it really cleans up usage.
      
      Second, for workdir iterators, this removes automatically
      iterating into directories.  That seemed like a good idea,
      but when an entirely new directory hierarchy is introduced
      into the workdir, there is no reason to iterate into it if
      there are no corresponding entries in the tree/index that it
      is being compared to.
      
      This second change actually wasn't a lot of code because not
      descending into directories was already the behavior for
      ignored directories.  This just extends that to all directories.
      Russell Belfer committed
  30. 21 Feb, 2012 1 commit
    • Uniform iterators for trees, index, and workdir · b6c93aef
      This create a new git_iterator type of object that provides a
      uniform interface for iterating over the index, an arbitrary
      tree, or the working directory of a repository.
      
      As part of this, git ignore support was extended to support
      push and pop of directory-based ignore files as the working
      directory is being traversed (so the array of ignores does
      not have to be recreated at each directory during traveral).
      
      There are a number of other small utility functions in buffer,
      path, vector, and fileops that are included in this patch
      that made the iterator implementation cleaner.
      Russell Belfer committed