1. 14 Jul, 2022 1 commit
  2. 20 Jun, 2022 2 commits
  3. 15 Jun, 2022 1 commit
  4. 23 Feb, 2022 1 commit
  5. 12 Feb, 2022 3 commits
  6. 17 Oct, 2021 1 commit
    • str: introduce `git_str` for internal, `git_buf` is external · f0e693b1
      libgit2 has two distinct requirements that were previously solved by
      `git_buf`.  We require:
      
      1. A general purpose string class that provides a number of utility APIs
         for manipulating data (eg, concatenating, truncating, etc).
      2. A structure that we can use to return strings to callers that they
         can take ownership of.
      
      By using a single class (`git_buf`) for both of these purposes, we have
      confused the API to the point that refactorings are difficult and
      reasoning about correctness is also difficult.
      
      Move the utility class `git_buf` to be called `git_str`: this represents
      its general purpose, as an internal string buffer class.  The name also
      is an homage to Junio Hamano ("gitstr").
      
      The public API remains `git_buf`, and has a much smaller footprint.  It
      is generally only used as an "out" param with strict requirements that
      follow the documentation.  (Exceptions exist for some legacy APIs to
      avoid breaking callers unnecessarily.)
      
      Utility functions exist to convert a user-specified `git_buf` to a
      `git_str` so that we can call internal functions, then converting it
      back again.
      Edward Thomson committed
  7. 06 May, 2021 1 commit
    • filter: internal git_buf filter handling function · 31d9c24b
      Introduce `git_filter_list__convert_buf` which behaves like the old
      implementation of `git_filter_list__apply_data`, where it might move the
      input data buffer over into the output data buffer space for efficiency.
      
      This new implementation will do so in a more predictible way, always
      freeing the given input buffer (either moving it to the output buffer or
      filtering it into the output buffer first).
      
      Convert internal users to it.
      Edward Thomson committed
  8. 28 Apr, 2021 1 commit
  9. 30 Jun, 2020 1 commit
  10. 18 Jan, 2020 1 commit
  11. 22 Nov, 2019 2 commits
  12. 20 Jul, 2019 1 commit
  13. 18 Jul, 2019 1 commit
  14. 15 Jun, 2019 1 commit
  15. 22 Jan, 2019 1 commit
  16. 01 Dec, 2018 1 commit
  17. 10 Jun, 2018 1 commit
  18. 03 Jan, 2018 1 commit
    • diff_generate: avoid excessive stats of .gitattribute files · d8896bda
      When generating a diff between two trees, for each file that is to be
      diffed we have to determine whether it shall be treated as text or as
      binary files. While git has heuristics to determine which kind of diff
      to generate, users can also that default behaviour by setting or
      unsetting the 'diff' attribute for specific files.
      
      Because of that, we have to query gitattributes in order to determine
      how to diff the current files. Instead of hitting the '.gitattributes'
      file every time we need to query an attribute, which can get expensive
      especially on networked file systems, we try to cache them instead. This
      works perfectly fine for every '.gitattributes' file that is found, but
      we hit cache invalidation problems when we determine that an attribuse
      file is _not_ existing. We do create an entry in the cache for missing
      '.gitattributes' files, but as soon as we hit that file again we
      invalidate it and stat it again to see if it has now appeared.
      
      In the case of diffing large trees with each other, this behaviour is
      very suboptimal. For each pair of files that is to be diffed, we will
      repeatedly query every directory component leading towards their
      respective location for an attributes file. This leads to thousands or
      even hundreds of thousands of wasted syscalls.
      
      The attributes cache already has a mechanism to help in that scenario in
      form of the `git_attr_session`. As long as the same attributes session
      is still active, we will not try to re-query the gitmodules files at all
      but simply retain our currently cached results. To fix our problem, we
      can create a session at the top-most level, which is the initialization
      of the `git_diff` structure, and use it in order to look up the correct
      diff driver. As the `git_diff` structure is used to generate patches for
      multiple files at once, this neatly solves our problem by retaining the
      session until patches for all files have been generated.
      
      The fix has been tested with linux.git by calling
      `git_diff_tree_to_tree` and `git_diff_to_buf` with v4.10^{tree} and
      v4.14^{tree}.
      
                      | time    | .gitattributes stats
          without fix | 33.201s | 844614
          with fix    | 30.327s | 4441
      
      While execution only improved by roughly 10%, the stat(3) syscalls for
      .gitattributes files decreased by 99.5%. The benchmarks were quite
      simple with best-of-three timings on Linux ext4 systems. One can assume
      that for network based file systems the performance gain will be a lot
      larger due to a much higher latency.
      Patrick Steinhardt committed
  19. 15 Dec, 2017 1 commit
    • diff_file: properly refcount blobs when initializing file contents · 2388a9e2
      When initializing a `git_diff_file_content` from a source whose data is
      derived from a blob, we simply assign the blob's pointer to the
      resulting struct without incrementing its refcount. Thus, the structure
      can only be used as long as the blob is kept alive by the caller.
      
      Fix the issue by using `git_blob_dup` instead of a direct assignment.
      This function will increment the refcount of the blob without allocating
      new memory, so it does exactly what we want. As
      `git_diff_file_content__unload` already frees the blob when
      `GIT_DIFF_FLAG__FREE_BLOB` is set, we don't need to add new code
      handling the free but only have to set that flag correctly.
      Patrick Steinhardt committed
  20. 03 Jul, 2017 1 commit
    • Make sure to always include "common.h" first · 0c7f49dd
      Next to including several files, our "common.h" header also declares
      various macros which are then used throughout the project. As such, we
      have to make sure to always include this file first in all
      implementation files. Otherwise, we might encounter problems or even
      silent behavioural differences due to macros or defines not being
      defined as they should be. So in fact, our header and implementation
      files should make sure to always include "common.h" first.
      
      This commit does so by establishing a common include pattern. Header
      files inside of "src" will now always include "common.h" as its first
      other file, separated by a newline from all the other includes to make
      it stand out as special. There are two cases for the implementation
      files. If they do have a matching header file, they will always include
      this one first, leading to "common.h" being transitively included as
      first file. If they do not have a matching header file, they instead
      include "common.h" as first file themselves.
      
      This fixes the outlined problems and will become our standard practice
      for header and source files inside of the "src/" from now on.
      Patrick Steinhardt committed
  21. 29 Dec, 2016 1 commit
  22. 26 May, 2016 2 commits
  23. 03 Nov, 2015 1 commit
  24. 25 Jun, 2015 1 commit
  25. 22 Jun, 2015 2 commits
    • submodule: add an ignore option to status · c6f489c9
      This lets us specify in the status call which ignore rules we want to
      use (optionally falling back to whatever the submodule has in its
      configuration).
      
      This removes one of the reasons for having `_set_ignore()` set the value
      in-memory. We re-use the `IGNORE_RESET` value for this as it is no
      longer relevant but has a similar purpose to `IGNORE_FALLBACK`.
      
      Similarly, we remove `IGNORE_DEFAULT` which does not have use outside of
      initializers and move that to fall back to the configuration as well.
      Carlos Martín Nieto committed
    • submodule: don't let status change an existing instance · 64bbd47a
      As submodules are becomes more like values, we should not let a status
      check to update its properties. Instead of taking a submodule, have
      status take a repo and submodule name.
      Carlos Martín Nieto committed
  26. 12 Jun, 2015 1 commit
  27. 19 Feb, 2015 1 commit
  28. 20 May, 2014 1 commit
  29. 06 May, 2014 1 commit
    • 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
  30. 25 Mar, 2014 2 commits
    • Fix submodule leaks and invalid references · 591e8295
      This cleans up some places I missed that could hold onto submodule
      references and cleans up the way in which the repository cache is
      both reloaded and released so that existing submodule references
      aren't destroyed inappropriately.
      Russell Belfer committed
    • 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
  31. 27 Feb, 2014 1 commit
    • Add buffer to buffer diff and patch APIs · 6789b7a7
      This adds `git_diff_buffers` and `git_patch_from_buffers`.  This
      also includes a bunch of internal refactoring to increase the
      shared code between these functions and the blob-to-blob and
      blob-to-buffer APIs, as well as some higher level assert helpers
      in the tests to also remove redundancy.
      Russell Belfer committed
  32. 25 Jan, 2014 1 commit
  33. 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