1. 01 Jul, 2013 1 commit
  2. 07 Mar, 2013 1 commit
  3. 30 Jan, 2013 1 commit
    • Add helper for diff line stats · f1e2735c
      This adds a `git_diff_patch_line_stats()` API that gets the total
      number of adds, deletes, and context lines in a patch.  This will
      make it a little easier to emulate `git diff --stat` and the like.
      
      Right now, this relies on generating the `git_diff_patch` object,
      which is a pretty heavyweight way to get stat information.  At
      some future point, it would probably be nice to be able to get
      this information without allocating the entire `git_diff_patch`,
      but that's a much larger project.
      Russell Belfer committed
  4. 08 Jan, 2013 1 commit
  5. 28 Nov, 2012 1 commit
    • Consolidate text buffer functions · 7bf87ab6
      There are many scattered functions that look into the contents of
      buffers to do various text manipulations (such as escaping or
      unescaping data, calculating text stats, guessing if content is
      binary, etc).  This groups all those functions together into a
      new file and converts the code to use that.
      
      This has two enhancements to existing functionality.  The old
      text stats function is significantly rewritten and the BOM
      detection code was extended (although largely we can't deal with
      anything other than a UTF8 BOM).
      Russell Belfer committed
  6. 25 Oct, 2012 1 commit
  7. 11 Oct, 2012 1 commit
  8. 10 Oct, 2012 1 commit
  9. 24 Jul, 2012 1 commit
  10. 11 Jul, 2012 1 commit
    • Add a couple of useful git_buf utilities · 039fc406
      * `git_buf_rfind` (with tests and tests for `git_buf_rfind_next`)
      * `git_buf_puts_escaped` and `git_buf_puts_escaped_regex` (with tests)
        to copy strings into a buffer while injecting an escape sequence
        (e.g. '\') in front of particular characters.
      Russell Belfer committed
  11. 17 May, 2012 2 commits
  12. 15 May, 2012 2 commits
    • Document git_buf_common_prefix · 2c833917
      This function fills in a git_buf with the common prefix of
      an array of strings, but let's make that a little more clear.
      Russell Belfer committed
    • 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
  13. 06 May, 2012 1 commit
  14. 03 May, 2012 1 commit
  15. 29 Apr, 2012 1 commit
  16. 16 Mar, 2012 1 commit
  17. 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
  18. 06 Mar, 2012 1 commit
    • error-handling: Repository · cb8a7961
      This also includes droping `git_buf_lasterror` because it makes no sense
      in the new system. Note that in most of the places were it has been
      dropped, the code needs cleanup. I.e. GIT_ENOMEM is going away, so
      instead it should return a generic `-1` and obviously not throw
      anything.
      Vicent Martí committed
  19. 02 Mar, 2012 1 commit
  20. 27 Feb, 2012 1 commit
    • buffer: Unify `git_fbuffer` and `git_buf` · 13224ea4
      This makes so much sense that I can't believe it hasn't been done
      before. Kill the old `git_fbuffer` and read files straight into
      `git_buf` objects.
      
      Also: In order to fully support 4GB files in 32-bit systems, the
      `git_buf` implementation has been changed from using `ssize_t` for
      storage and storing negative values on allocation failure, to using
      `size_t` and changing the buffer pointer to a magical pointer on
      allocation failure.
      
      Hopefully this won't break anything.
      Vicent Martí committed
  21. 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
  22. 13 Feb, 2012 1 commit
  23. 11 Jan, 2012 1 commit
    • Initial implementation of gitignore support · df743c7d
      Adds support for .gitignore files to git_status_foreach() and
      git_status_file().  This includes refactoring the gitattributes
      code to share logic where possible.  The GIT_STATUS_IGNORED flag
      will now be passed in for files that are ignored (provided they
      are not already in the index or the head of repo).
      Russell Belfer committed
  24. 14 Dec, 2011 1 commit
  25. 08 Dec, 2011 1 commit
    • Use git_buf for path storage instead of stack-based buffers · 97769280
      This converts virtually all of the places that allocate GIT_PATH_MAX
      buffers on the stack for manipulating paths to use git_buf objects
      instead.  The patch is pretty careful not to touch the public API
      for libgit2, so there are a few places that still use GIT_PATH_MAX.
      
      This extends and changes some details of the git_buf implementation
      to add a couple of extra functions and to make error handling easier.
      
      This includes serious alterations to all the path.c functions, and
      several of the fileops.c ones, too.  Also, there are a number of new
      functions that parallel existing ones except that use a git_buf
      instead of a stack-based buffer (such as git_config_find_global_r
      that exists alongsize git_config_find_global).
      
      This also modifies the win32 version of p_realpath to allocate whatever
      buffer size is needed to accommodate the realpath instead of hardcoding
      a GIT_PATH_MAX limit, but that change needs to be tested still.
      Russell Belfer committed
  26. 30 Nov, 2011 2 commits
    • Make initial value of git_buf ptr always be a valid empty string. · 309113c9
      Taking a page from core git's strbuf, this introduces git_buf_initbuf
      which is an empty string that is used to initialize the git_buf ptr
      value even for new buffers.  Now the git_buf ptr will always point to
      a valid NUL-terminated string.
      
      This change required jumping through a few hoops for git_buf_grow
      and git_buf_free to distinguish between a actual allocated buffer
      and the global initial value.  Also, this moves the allocation
      related functions to be next to each other near the top of buffer.c.
      Russell Belfer committed
    • Make git_buf functions always maintain a valid cstr. · c63728cd
      At a tiny cost of 1 extra byte per allocation, this makes
      git_buf_cstr into basically a noop, which simplifies error
      checking when trying to convert things to use dynamic allocation.
      
      This patch also adds a new function (git_buf_copy_cstr) for copying
      the cstr data directly into an external buffer.
      Russell Belfer committed
  27. 28 Nov, 2011 2 commits
    • Add two string git_buf_join and tweak input error checking. · 3aa294fd
      This commit addresses two of the comments:
      * renamed existing n-input git_buf_join to git_buf_join_n
      * added new git_buf_join that always takes two inputs
      * moved some parameter error checking to asserts
      * extended unit tests to cover new version of git_buf_join
      Russell Belfer committed
    • Extend git_buf with new utility functions and unit tests. · 8c74d22e
      Add new functions to git_buf for:
      * initializing a buffer from a string
      * joining one or more strings onto a buffer with separators
      * swapping two buffers in place
      * extracting data from a git_buf (leaving it empty)
      
      Also, make git_buf_free leave a git_buf back in its initted state,
      and slightly tweak buffer allocation sizes and thresholds.
      
      Finally, port unit tests to clay and extend with lots of new tests
      for the various git_buf functions.
      Russell Belfer committed
  28. 18 Sep, 2011 1 commit
    • Cleanup legal data · bb742ede
      1. The license header is technically not valid if it doesn't have a
      copyright signature.
      
      2. The COPYING file has been updated with the different licenses used in
      the project.
      
      3. The full GPLv2 header in each file annoys me.
      Vicent Marti committed
  29. 09 Sep, 2011 2 commits
  30. 09 Jul, 2011 1 commit
    • odb: Direct writes are back · afeecf4f
      DIRECT WRITES ARE BACK AND FASTER THAN EVER. The streaming writer to the
      ODB was an overkill for the smaller objects like Commit and Tags; most
      of the streaming logic was taking too long.
      
      This commit makes Commits, Tags and Trees to be built-up in memory, and
      then written to disk in 2 pushes (header + data), instead of streaming
      everything.
      
      This is *always* faster, even for big files (since the git_filebuf class
      still does streaming writes when the memory cache overflows). This is
      also a gazillion lines of code smaller, because we don't have to
      precompute the final size of the object before starting the stream (this
      was kind of defeating the point of streaming, anyway).
      
      Blobs are still written with full streaming instead of loading them in
      memory, since this is still the fastest way.
      
      A new `git_buf` class has been added. It's missing some features, but
      it'll get there.
      Vicent Marti committed