1. 31 May, 2014 1 commit
  2. 02 May, 2014 2 commits
  3. 23 Apr, 2014 1 commit
  4. 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
  5. 11 Apr, 2014 1 commit
  6. 05 Feb, 2014 2 commits
  7. 01 Oct, 2013 1 commit
  8. 30 Sep, 2013 1 commit
    • Initial Implementation of progress reports during push · b176eded
      This adds the basics of progress reporting during push. While progress
      for all aspects of a push operation are not reported with this change,
      it lays the foundation to add these later. Push progress reporting
      can be improved in the future - and consumers of the API should
      just get more accurate information at that point.
      
      The main areas where this is lacking are:
      
      1) packbuilding progress: does not report progress during deltafication,
         as this involves coordinating progress from multiple threads.
      
      2) network progress: reports progress as objects and bytes are going
         to be written to the subtransport (instead of as client gets
         confirmation that they have been received by the server) and leaves
         out some of the bytes that are transfered as part of the push protocol.
         Basically, this reports the pack bytes that are written to the
         subtransport. It does not report the bytes sent on the wire that
         are received by the server. This should be a good estimate of
         progress (and an improvement over no progress).
      Jameson Miller committed
  9. 27 Aug, 2013 1 commit
  10. 08 Aug, 2013 1 commit
  11. 31 Jul, 2013 1 commit
    • Major rename detection changes · d730d3f4
      After doing further profiling, I found that a lot of time was
      being spent attempting to insert hashes into the file hash
      signature when using the rolling hash because the rolling hash
      approach generates a hash per byte of the file instead of one
      per run/line of data.
      
      To optimize this, I decided to convert back to a run-based file
      signature algorithm which would be more like core Git.
      
      After changing this, a number of the existing tests started to
      fail.  In some cases, this appears to have been because the test
      was coded to be too specific to the particular results of the file
      similarity metric and in some cases there appear to have been bugs
      in the core rename detection code where only by the coincidence
      of the file similarity scoring were the expected results being
      generated.
      
      This renames all the variables in the core rename detection code
      to be more consistent and hopefully easier to follow which made it
      a bit easier to reason about the behavior of that code and fix the
      problems that I was seeing.  I think it's in better shape now.
      
      There are a couple of tests now that attempt to stress test the
      rename detection code and they are quite slow.  Most of the time
      is spent setting up the test data on disk and in the index.  When
      we roll out performance improvements for index insertion, it
      should also speed up these tests I hope.
      Russell Belfer committed
  12. 10 Jul, 2013 1 commit
  13. 17 Jun, 2013 2 commits
  14. 12 Jun, 2013 1 commit
  15. 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
  16. 07 Jun, 2013 1 commit
  17. 18 May, 2013 1 commit
    • Fix issues with git_diff_find_similar · d958e37a
      There are a number of bugs in the rename code that only were
      obvious when I started testing it against large old repos with
      more complex patterns.  (The code to do that testing is not ready
      to merge with libgit2, but I do plan to add more thorough tests.)
      
      This contains a significant number of changes and also tweaks the
      public API slightly to make emulating core git easier.
      
      Most notably, this separates the GIT_DIFF_FIND_AND_BREAK_REWRITES
      flag into FIND_REWRITES (which adds a self-similarity score to
      every modified file) and BREAK_REWRITES (which splits the modified
      deltas into add/remove pairs in the diff list).  When you do a raw
      output of core git, rewrites show up as M090 or such, not at A and
      D output, so I wanted to be able to emulate that.
      
      Publicly, this also changes the flags to be uint16_t since we
      don't need values out of that range.
      
      Internally, this contains significant changes from a number of
      small bug fixes (like using the wrong side of the diff to decide
      if the object could be found in the ODB vs the workdir) to larger
      issues about which files can and should be compared and how the
      various edge cases of similarity scores should be treated.
      
      Honestly, I don't think this is the last update that will have to
      be made to this code, but I think this moves us closer to correct
      behavior and I tried to document the code so it would be easier
      to follow..
      Russell Belfer committed
  18. 15 May, 2013 1 commit
  19. 22 Apr, 2013 3 commits
    • Add git__compare_and_swap and use it · e976b56d
      This removes the lock from the repository object and changes the
      internals to use the new atomic git__compare_and_swap to update
      the _odb, _config, _index, and _refdb variables in a threadsafe
      manner.
      Russell Belfer committed
    • Further threading fixes · 53607868
      This builds on the earlier thread safety work to make it so that
      setting the odb, index, refdb, or config for a repository is done
      in a threadsafe manner with minimized locking time.  This is done
      by adding a lock to the repository object and using it to guard
      the assignment of the above listed pointers.  The lock is only
      held to assign the pointer value.
      
      This also contains some minor fixes to the other work with pack
      files to reduce the time that locks are being held to and fix an
      apparently memory leak.
      Russell Belfer committed
  20. 21 Apr, 2013 1 commit
    • Move refdb_backend to include/git2/sys · 4dcd8780
      This moves most of the refdb stuff over to the include/git2/sys
      directory, with some minor shifts in function organization.
      
      While I was making the necessary updates, I also removed the
      trailing whitespace in a few files that I modified just because I
      was there and it was bugging me.
      Russell Belfer committed
  21. 11 Mar, 2013 1 commit
  22. 09 Mar, 2013 1 commit
    • Make tree iterator handle icase equivalence · e40f1c2d
      There is a serious bug in the previous tree iterator implementation.
      If case insensitivity resulted in member elements being equivalent
      to one another, and those member elements were trees, then the
      children of the colliding elements would be processed in sequence
      instead of in a single flattened list.  This meant that the tree
      iterator was not truly acting like a case-insensitive list.
      
      This completely reworks the tree iterator to manage lists with
      case insensitive equivalence classes and advance through the items
      in a unified manner in a single sorted frame.
      
      It is possible that at a future date we might want to update this
      to separate the case insensitive and case sensitive tree iterators
      so that the case sensitive one could be a minimal amount of code
      and the insensitive one would always know what it needed to do
      without checking flags.
      
      But there would be so much shared code between the two, that I'm
      not sure it that's a win.  For now, this gets what we need.
      
      More tests are needed, though.
      Russell Belfer committed
  23. 20 Feb, 2013 1 commit
  24. 02 Feb, 2013 1 commit
  25. 01 Feb, 2013 1 commit
  26. 27 Jan, 2013 1 commit
  27. 15 Jan, 2013 1 commit
    • Add payload "_r" versions of bsearch and tsort · 851ad650
      git__bsearch and git__tsort did not pass a payload through to the
      comparison function.  This makes it impossible to implement sorted
      lists where the sort order depends on external data (e.g. building
      a secondary sort order for the entries in a tree).  This commit
      adds git__bsearch_r and git__tsort_r versions that pass a third
      parameter to the cmp function of a user payload.
      Russell Belfer committed
  28. 08 Jan, 2013 1 commit
  29. 19 Dec, 2012 1 commit
  30. 15 Nov, 2012 1 commit
  31. 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
  32. 17 Sep, 2012 1 commit
  33. 24 Jul, 2012 1 commit
  34. 11 Jul, 2012 1 commit