1. 01 Dec, 2018 2 commits
  2. 13 Jul, 2018 1 commit
    • treewide: remove use of C++ style comments · 9994cd3f
      C++ style comment ("//") are not specified by the ISO C90 standard and
      thus do not conform to it. While libgit2 aims to conform to C90, we did
      not enforce it until now, which is why quite a lot of these
      non-conforming comments have snuck into our codebase. Do a tree-wide
      conversion of all C++ style comments to the supported C style comments
      to allow us enforcing strict C90 compliance in a later commit.
      Patrick Steinhardt committed
  3. 10 Jun, 2018 1 commit
  4. 06 Jun, 2018 2 commits
    • ignore: fix negative leading directory rules unignoring subdirectory files · 20b4c175
      When computing whether a file is ignored, we simply search for the first
      matching rule and return whether it is a positive ignore rule (the file
      is really ignored) or whether it is a negative ignore rule (the file is
      being unignored). Each rule has a set of flags which are being passed to
      `fnmatch`, depending on what kind of rule it is. E.g. in case it is a
      negative ignore we add a flag `GIT_ATTR_FNMATCH_NEGATIVE`, in case it
      contains a glob we set the `GIT_ATTR_FNMATCH_HASGLOB` flag.
      
      One of these flags is the `GIT_ATTR_FNMATCH_LEADINGDIR` flag, which is
      always set in case the pattern has a trailing "/*" or in case the
      pattern is negative. The flag causes the `fnmatch` function to return a
      match in case a string is a leading directory of another, e.g. "dir/"
      matches "dir/foo/bar.c". In case of negative patterns, this is wrong in
      certain cases.
      
      Take the following simple example of a gitignore:
      
          dir/
          !dir/
      
      The `LEADINGDIR` flag causes "!dir/" to match "dir/foo/bar.c", and we
      correctly unignore the directory. But take this example:
      
          *.test
          !dir/*
      
      We expect everything in "dir/" to be unignored, but e.g. a file in a
      subdirectory of dir should be ignored, as the "*" does not cross
      directory hierarchies. With `LEADINGDIR`, though, we would just see that
      "dir/" matches and return that the file is unignored, even if it is
      contained in a subdirectory. Instead, we want to ignore leading
      directories here and check "*.test". Afterwards, we have to iterate up
      to the parent directory and do the same checks.
      
      To fix the issue, disallow matching against leading directories in
      gitignore files. This can be trivially done by just adding the
      `GIT_ATTR_FNMATCH_NOLEADINGDIR` to the spec passed to
      `git_attr_fnmatch__parse`. Due to a bug in that function, though, this
      flag is being ignored for negative patterns, which is fixed in this
      commit, as well. As a last fix, we need to ignore rules that are
      supposed to match a directory when our path itself is a file.
      
      All together, these changes fix the described error case.
      Patrick Steinhardt committed
  5. 21 Jan, 2018 1 commit
    • status::renames: write NFD instead of NFC filename · 9af7fbc3
      Update the status::renames test to create an NFD format filename in the
      core.precomposedunicode tests.
      
      Previously, we would create an NFC format filename.  This was to take
      advantage of HFS+ filesystems, which always use canonically decomposed
      formats, and would actually write the filename to disk as an NFD
      filename.  So previously, we could create an NFC filename, but read it
      normally as an NFD filename.
      
      But APFS formats do not force canonically decomposed formats for
      filenames, so creating an NFC filename does not get converted to NFD.
      Instead, the filename will be written in NFC format.  Our test,
      therefore, does not work - when we write an NFC filename, it will
      _remain_ NFC.
      
      Update the test to write NFD always.  This will ensure that the file
      will actually be canonically decomposed on all platforms:  HFS+, which
      forces NFD, and APFS, which does not.
      
      Thus, our test will continue to ensure that an NFD filename is
      canonically precomposed on all filesystems.
      Edward Thomson committed
  6. 03 Jan, 2018 1 commit
    • tests: status::worktree: indicate skipped tests on Win32 · 72c28ab0
      Some function bodies of tests which are not applicable to the Win32
      platform are completely #ifdef'd out instead of calling `cl_skip()`.
      This leaves us with no indication that these tests are not being
      executed at all and may thus cause decreased scrutiny when investigating
      skipped tests. Improve the situation by calling `cl_skip()` instead of
      just doing nothing.
      Patrick Steinhardt committed
  7. 30 Nov, 2017 1 commit
  8. 25 Aug, 2017 1 commit
  9. 17 May, 2017 1 commit
  10. 17 Feb, 2017 2 commits
  11. 12 Aug, 2016 1 commit
    • ignore: allow unignoring basenames in subdirectories · fcb2c1c8
      The .gitignore file allows for patterns which unignore previous
      ignore patterns. When unignoring a previous pattern, there are
      basically three cases how this is matched when no globbing is
      used:
      
      1. when a previous file has been ignored, it can be unignored by
         using its exact name, e.g.
      
         foo/bar
         !foo/bar
      
      2. when a file in a subdirectory has been ignored, it can be
         unignored by using its basename, e.g.
      
         foo/bar
         !bar
      
      3. when all files with a basename are ignored, a specific file
         can be unignored again by specifying its path in a
         subdirectory, e.g.
      
         bar
         !foo/bar
      
      The first problem in libgit2 is that we did not correctly treat
      the second case. While we verified that the negative pattern
      matches the tail of the positive one, we did not verify if it
      only matches the basename of the positive pattern. So e.g. we
      would have also negated a pattern like
      
          foo/fruz_bar
          !bar
      
      Furthermore, we did not check for the third case, where a
      basename is being unignored in a certain subdirectory again.
      
      Both issues are fixed with this commit.
      Patrick Steinhardt committed
  12. 11 Apr, 2016 1 commit
  13. 31 Mar, 2016 2 commits
  14. 23 Mar, 2016 3 commits
  15. 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
  16. 13 Sep, 2015 1 commit
  17. 30 Aug, 2015 1 commit
  18. 22 Jun, 2015 1 commit
    • diff: check files with the same or newer timestamps · ff475375
      When a file on the workdir has the same or a newer timestamp than the
      index, we need to perform a full check of the contents, as the update of
      the file may have happened just after we wrote the index.
      
      The iterator changes are such that we can reach inside the workdir
      iterator from the diff, though it may be better to have an accessor
      instead of moving these structs into the header.
      Carlos Martín Nieto committed
  19. 20 Jun, 2015 1 commit
  20. 16 Jun, 2015 1 commit
  21. 02 Jun, 2015 1 commit
  22. 28 May, 2015 4 commits
  23. 20 May, 2015 1 commit
  24. 04 May, 2015 1 commit
  25. 17 Apr, 2015 1 commit
  26. 03 Mar, 2015 2 commits
  27. 05 Dec, 2014 1 commit
  28. 23 Nov, 2014 1 commit
  29. 09 Nov, 2014 1 commit
  30. 07 Nov, 2014 1 commit