1. 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
  2. 06 Dec, 2013 1 commit
  3. 05 Dec, 2013 2 commits
  4. 02 Dec, 2013 3 commits
  5. 14 Nov, 2013 1 commit
  6. 15 Oct, 2013 1 commit
    • Diff API cleanup · 10672e3e
      This lays groundwork for separating formatting options from diff
      creation options.  This groups the formatting flags separately
      from the diff list creation flags and reorders the options.  This
      also tweaks some APIs to further separate code that uses patches
      from code that just looks at git_diffs.
      Russell Belfer committed
  7. 11 Oct, 2013 1 commit
  8. 17 Sep, 2013 1 commit
  9. 05 Sep, 2013 1 commit
  10. 28 Aug, 2013 1 commit
  11. 05 Aug, 2013 1 commit
  12. 04 Aug, 2013 3 commits
  13. 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
  14. 25 Jul, 2013 1 commit
    • Fix rename detection for tree-to-tree diffs · a5140f4d
      The performance improvements I introduced for rename detection
      were not able to run successfully for tree-to-tree diffs because
      the blob size was not known early enough and so the file signature
      always had to be calculated nonetheless.
      
      This change separates loading blobs into memory from calculating
      the signature.  I can't avoid having to load the large blobs into
      memory, but by moving it forward, I'm able to avoid the signature
      calculation if the blob won't come into play for renames.
      Russell Belfer committed
  15. 24 Jul, 2013 1 commit
  16. 29 Jun, 2013 1 commit
  17. 24 Jun, 2013 1 commit
  18. 18 Jun, 2013 3 commits
  19. 17 Jun, 2013 4 commits
  20. 14 Jun, 2013 1 commit
  21. 11 Jun, 2013 1 commit
    • Implement regex pattern diff driver · 5dc98298
      This implements the loading of regular expression pattern lists
      for diff drivers that search for function context in that way.
      This also changes the way that diff drivers update options and
      interface with xdiff APIs to make them a little more flexible.
      Russell Belfer committed
  22. 10 Jun, 2013 2 commits
    • 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
  23. 23 May, 2013 2 commits
    • Fill out diff rename test coverage · 49f70f2c
      This extends the rename tests to make sure that every rename
      scenario in the inner loop of git_diff_find_similar is actually
      exercised.  Also, fixes an incorrect assert that was in one of
      the clauses that was not previously being exercised.
      Russell Belfer committed
    • More diff rename tests; better split swap handling · 67db583d
      This adds a couple more tests of different rename scenarios.
      
      Also, this fixes a problem with the case where you have two
      "split" deltas and the left half of one matches the right half of
      the other.  That case was already being handled, but in the wrong
      order in a way that could result in bad output.  Also, if the swap
      also happened to put the other two halves into the correct place
      (i.e. two files exchanged places with each other), then the second
      delta was left with the SPLIT flag set when it really should be
      cleared.
      Russell Belfer committed
  24. 22 May, 2013 1 commit
    • Significant rename detection rewrite · a21cbb12
      This flips rename detection around so instead of creating a
      forward mapping from deltas to possible rename targets, instead
      it creates a reverse mapping, looking at possible targets and
      trying to find a source that they could have been renamed or
      copied from.  This is important because each output can only
      have a single source, but a given source could map to multiple
      outputs (in the form of COPIED records).
      
      Additionally, this makes a couple of tweaks to the public rename
      detection APIs, mostly renaming a couple of options that control
      the behavior to make more sense and to be more like core Git.
      
      I walked through the tests looking at the exact results and
      updated the expectations based on what I saw.  The new code is
      different from the old because it cannot give some nonsense
      results (like A was renamed to both B and C) which were part of
      the outputs previously.
      Russell Belfer committed
  25. 20 May, 2013 1 commit
    • Add more diff rename detection tests · 4742148d
      This adds a bunch more rename detection tests including checks
      vs the working directory, the new exact match options, some more
      whitespace variants, etc.
      
      This also adds a git_futils_writebuffer helper function and uses
      it in checkout.  This is mainly added because I wanted an easy
      way to write out a git_buf to disk inside my test code.
      Russell Belfer committed
  26. 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
  27. 14 May, 2013 1 commit
  28. 10 May, 2013 1 commit
    • Fix diff output for renames and copies · e9ba61f3
      If you use rename detection, the renamed and copied files would
      not show any text diffs because the function that decides if
      data should be loaded didn't know which sides of the diff to
      load for those cases.
      
      This adds a test that looks at the patch generated for diff
      entries that are COPIED or RENAMED.
      Russell Belfer committed