1. 04 Jun, 2014 1 commit
  2. 22 May, 2014 2 commits
  3. 21 May, 2014 2 commits
  4. 20 May, 2014 2 commits
  5. 13 May, 2014 1 commit
  6. 06 May, 2014 2 commits
    • Add filter options and ALLOW_UNSAFE · 5269008c
      Diff and status do not want core.safecrlf to actually raise an
      error regardless of the setting, so this extends the filter API
      with an additional options flags parameter and adds a flag so that
      filters can be applied with GIT_FILTER_OPT_ALLOW_UNSAFE, indicating
      that unsafe filter application should be downgraded from a failure
      to a warning.
      Russell Belfer committed
    • Improve checks for ignore containment · f554611a
      The diff code was using an "ignored_prefix" directory to track if
      a parent directory was ignored that contained untracked files
      alongside tracked files. Unfortunately, when negative ignore rules
      were used for directories inside ignored parents, the wrong rules
      were applied to untracked files inside the negatively ignored
      child directories.
      
      This commit moves the logic for ignore containment into the workdir
      iterator (which is a better place for it), so the ignored-ness of
      a directory is contained in the frame stack during traversal.  This
      allows a child directory to override with a negative ignore and yet
      still restore the ignored state of the parent when we traverse out
      of the child.
      
      Along with this, there are some problems with "directory only"
      ignore rules on container directories.  Given "a/*" and "!a/b/c/"
      (where the second rule is a directory rule but the first rule is
      just a generic prefix rule), then the directory only constraint
      was having "a/b/c/d/file" match the first rule and not the second.
      This was fixed by having ignore directory-only rules test a rule
      against the prefix of a file with LEADINGDIR enabled.
      
      Lastly, spot checks for ignores using `git_ignore_path_is_ignored`
      were tested from the top directory down to the bottom to deal with
      the containment problem, but this is wrong. We have to test bottom
      to top so that negative subdirectory rules will be checked before
      parent ignore rules.
      
      This does change the behavior of some existing tests, but it seems
      only to bring us more in line with core Git, so I think those
      changes are acceptable.
      Russell Belfer committed
  7. 02 May, 2014 10 commits
  8. 23 Apr, 2014 2 commits
    • Treat ignored, empty, and untracked dirs different · 219c89d1
      In the iterator, distinguish between ignores and empty directories
      so that diff and status can ignore empty directories, but checkout
      and stash can treat them as untracked items.
      Russell Belfer committed
    • Make checkout match diff for untracked/ignored dir · 37da3685
      When diff finds an untracked directory, it emulates Git behavior
      by looking inside the directory to see if there are any untracked
      items inside it. If there are only ignored items inside the dir,
      then diff considers it ignored, even if there is no direct ignore
      rule for it.
      
      Checkout was not copying this behavior - when it found an untracked
      directory, it just treated it as untracked.  Unfortunately, when
      combined with GIT_CHECKOUT_REMOVE_UNTRACKED, this made is seem that
      checkout (and stash, which uses checkout) was removing ignored
      items when you had only asked it to remove untracked ones.
      
      This commit moves the logic for advancing past an untracked dir
      while scanning for non-ignored items into an iterator helper fn,
      and uses that for both diff and checkout.
      Russell Belfer committed
  9. 22 Apr, 2014 1 commit
    • Use git_diff_get_stats in example/diff + refactor · 8d09efa2
      This takes the `--stat` and related example options in the example
      diff.c program and converts them to use the `git_diff_get_stats`
      API which nicely formats stats for you.
      
      I went to add bar-graph scaling to the stats formatter and noticed
      that the `git_diff_stats` structure was holding on to all of the
      `git_patch` objects.  Unfortunately, each of these objects keeps
      the full text of the diff in memory, so this is very expensive.  I
      ended up modifying `git_diff_stats` to keep just the data that it
      needs to keep and allowed it to release the patches.  Then, I added
      width scaling to the output on top of that.
      
      In making the diff example program match 'git diff' output, I ended
      up removing an newline from the sumamry output which I then had to
      compensate for in the email formatting to match the expectations.
      
      Lastly, I went through and refactored the tests to use a couple of
      helper functions and reduce the overall amount of code there.
      Russell Belfer committed
  10. 17 Apr, 2014 1 commit
    • Decouple index iterator sort from index · 3b4c401a
      This makes the index iterator honor the GIT_ITERATOR_IGNORE_CASE
      and GIT_ITERATOR_DONT_IGNORE_CASE flags without modifying the
      index data itself.  To take advantage of this, I had to export a
      number of the internal index entry comparison functions.  I also
      wrote some new tests to exercise the capability.
      Russell Belfer committed
  11. 15 Apr, 2014 2 commits
  12. 08 Apr, 2014 1 commit
    • Update submodules with parent-tracked content · eb7e17cc
      This updates how libgit2 treats submodule-like directories that
      actually have tracked content inside of them.  This is a strange
      corner case, but it seems that many people have abortive submodule
      setups and then just went ahead and added the files into the
      parent repository.  In this case, we should just treat the
      submodule as if it was a normal directory.
      
      Libgit2 will still try to skip over real submodules and contained
      repositories that do not have tracked files inside them, but this
      adds some new handling for cases where the apparently submodule
      data is in conflict with the actual list of tracked files.
      Russell Belfer committed
  13. 02 Apr, 2014 1 commit
    • Fix skipping content of contained repos · ea1ca3c9
      When doing a diff for use in status, we should never show the
      content of a git repository contained inside another one.  The
      logic to do this was looking for a .git directory and so when a
      gitlink plain .git file was used, it was failing to exclude the
      directory content.
      Russell Belfer committed
  14. 25 Mar, 2014 1 commit
    • Make submodules externally refcounted · a15c7802
      `git_submodule` objects were already refcounted internally in case
      the submodule name was different from the path at which it was
      stored.  This makes that refcounting externally used as well, so
      `git_submodule_lookup` and `git_submodule_add_setup` return an
      object that requires a `git_submodule_free` when done.
      Russell Belfer committed
  15. 06 Mar, 2014 1 commit
  16. 25 Jan, 2014 2 commits
  17. 12 Dec, 2013 1 commit
    • Cleanups, renames, and leak fixes · 9cfce273
      This renames git_vector_free_all to the better git_vector_free_deep
      and also contains a couple of memory leak fixes based on valgrind
      checks.  The fixes are specifically: failure to free global dir
      path variables when not compiled with threading on and failure to
      free filters from the filter registry that had not be initialized
      fully.
      Russell Belfer committed
  18. 11 Dec, 2013 6 commits
    • Some callback error check style cleanups · c7b3e1b3
      I find this easier to read...
      Russell Belfer committed
    • Remove converting user error to GIT_EUSER · 25e0b157
      This changes the behavior of callbacks so that the callback error
      code is not converted into GIT_EUSER and instead we propagate the
      return value through to the caller.  Instead of using the
      giterr_capture and giterr_restore functions, we now rely on all
      functions to pass back the return value from a callback.
      
      To avoid having a return value with no error message, the user
      can call the public giterr_set_str or some such function to set
      an error message.  There is a new helper 'giterr_set_callback'
      that functions can invoke after making a callback which ensures
      that some error message was set in case the callback did not set
      one.
      
      In places where the sign of the callback return value is
      meaningful (e.g. positive to skip, negative to abort), only the
      negative values are returned back to the caller, obviously, since
      the other values allow for continuing the loop.
      
      The hardest parts of this were in the checkout code where positive
      return values were overloaded as meaningful values for checkout.
      I fixed this by adding an output parameter to many of the internal
      checkout functions and removing the overload.  This added some
      code, but it is probably a better implementation.
      
      There is some funkiness in the network code where user provided
      callbacks could be returning a positive or a negative value and
      we want to rely on that to cancel the loop.  There are still a
      couple places where an user error might get turned into GIT_EUSER
      there, I think, though none exercised by the tests.
      Russell Belfer committed
    • Add git_vector_free_all · fcd324c6
      There are a lot of places that we call git__free on each item in
      a vector and then call git_vector_free on the vector itself.  This
      just wraps that up into one convenient helper function.
      Russell Belfer committed
    • Improve GIT_EUSER handling · 96869a4e
      This adds giterr_user_cancel to return GIT_EUSER and clear any
      error message that is sitting around.  As a result of using that
      in places, we need to be more thorough with capturing errors that
      happen inside a callback when used internally.  To help with that,
      this also adds giterr_capture and giterr_restore so that when we
      internally use a foreach-type function that clears errors and
      converts them to GIT_EUSER, it is easier to restore not just the
      return value, but the actual error message text.
      Russell Belfer committed
    • Add config read fns with controlled error behavior · 9f77b3f6
      This adds `git_config__lookup_entry` which will look up a key in
      a config and return either the entry or NULL if the key was not
      present.  Optionally, it can either suppress all errors or can
      return them (although not finding the key is not an error for this
      function).  Unlike other accessors, this does not normalize the
      config key string, so it must only be used when the key is known
      to be in normalized form (i.e. all lower-case before the first dot
      and after the last dot, with no invalid characters).
      
      This also adds three high-level helper functions to look up config
      values with no errors and a fallback value.  The three functions
      are for string, bool, and int values, and will resort to the
      fallback value for any error that arises.  They are:
      
      * `git_config__get_string_force`
      * `git_config__get_bool_force`
      * `git_config__get_int_force`
      
      None of them normalize the config `key` either, so they can only
      be used for internal cases where the key is known to be in normal
      format.
      Russell Belfer committed
  19. 01 Nov, 2013 1 commit
    • Fix --assume-unchanged support · 3e57069e
      This was never really working right because we were checking the
      wrong flag and not checking it in all the places that we need to
      be checking it.  I finally got around to writing a test and adding
      actual support for it.
      Russell Belfer committed