1. 09 Mar, 2016 1 commit
  2. 08 Mar, 2016 2 commits
  3. 07 Mar, 2016 1 commit
  4. 14 Oct, 2015 1 commit
    • odb: Prioritize alternate backends · a0a1b19a
      For most real use cases, repositories with alternates use them as main
      object storage. Checking the alternate for objects before the main
      repository should result in measurable speedups.
      
      Because of this, we're changing the sorting algorithm to prioritize
      alternates *in cases where two backends have the same priority*. This
      means that the pack backend for the alternate will be checked before the
      pack backend for the main repository *but* both of them will be checked
      before any loose backends.
      Vicent Marti committed
  5. 30 Sep, 2015 1 commit
    • refdb and odb backends must provide `free` function · d3b29fb9
      As refdb and odb backends can be allocated by client code, libgit2
      can’t know whether an alternative memory allocator was used, and thus
      should not try to call `git__free` on those objects.
      
      Instead, odb and refdb backend implementations must always provide
      their own `free` functions to ensure memory gets freed correctly.
      Arthur Schreiber committed
  6. 17 Sep, 2015 1 commit
    • git_futils_mkdir_*: make a relative-to-base mkdir · ac2fba0e
      Untangle git_futils_mkdir from git_futils_mkdir_ext - the latter
      assumes that we own everything beneath the base, as if it were
      being called with a base of the repository or working directory,
      and is tailored towards checkout and ensuring that there is no
      bogosity beneath the base that must be cleaned up.
      
      This is (at best) slow and (at worst) unsafe in the larger context
      of a filesystem where we do not own things and cannot do things like
      unlink symlinks that are in our way.
      Edward Thomson committed
  7. 06 Jun, 2015 1 commit
  8. 21 Nov, 2014 1 commit
  9. 08 Nov, 2014 1 commit
    • odb: hardcode the empty blob and tree · e1ac0101
      git hardocodes these as objects which exist regardless of whether they
      are in the odb and uses them in the shell interface as a way of
      expressing the lack of a blob or tree for one side of e.g. a diff.
      
      In the library we use each language's natural way of declaring a lack of
      value which makes a workaround like this unnecessary. Since git uses it,
      it does however mean each shell application would need to perform this
      check themselves.
      
      This makes it common work across a range of applications and an issue
      with compatibility with git, which fits right into what the library aims
      to provide.
      
      Thus we introduce the hard-coded empty blob and tree in the odb
      frontend. These hard-coded objects are checked for before going to the
      backends, but after the cache check, which means the second time they're
      used, they will be treated as normal cached objects instead of creating
      new ones.
      Carlos Martín Nieto committed
  10. 26 Sep, 2014 1 commit
  11. 01 Jul, 2014 1 commit
  12. 20 May, 2014 1 commit
  13. 05 May, 2014 1 commit
  14. 10 Mar, 2014 1 commit
    • Fix a number of git_odb_exists_prefix bugs · 89499078
      The git_odb_exists_prefix API was not dealing correctly when a
      later backend returned GIT_ENOTFOUND even if an earlier backend
      had found the object.
      
      Additionally, the unit tests were not properly exercising the API
      and had a couple mistakes in checking the results.
      
      Lastly, since the backends are not expected to behavior correctly
      unless all bytes of the short id are zero except for the prefix,
      this makes the ODB prefix APIs explicitly clear out the extra
      bytes so the user doesn't have to be as careful.
      Russell Belfer committed
  15. 07 Mar, 2014 1 commit
  16. 05 Mar, 2014 1 commit
  17. 04 Mar, 2014 1 commit
  18. 11 Dec, 2013 1 commit
    • 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
  19. 14 Nov, 2013 2 commits