fast_ignore 0.15.2 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9992ae13ee95ee05f55cceda56e5bd1c4210d5817be17d9116193787ac658d38
-  data.tar.gz: '093e221a737476e92c0c6cf1b6632abb4da103ea01ee3d0f66acf067011f092c'
+  metadata.gz: 78cb85cea0888d67c91de09bd54ad644510167c993dc355d187593003d341393
+  data.tar.gz: fb1fda9c1675ee28f4a6ff23191f95c2dd6e497ca2a70c4791dc5dfb85baecd1
 SHA512:
-  metadata.gz: 78db62b2bfa57b7b509b6f326f3b4f3f7371336bf30caa46c2d1b3ccc4086e2bbdb7abf3cc843700d4a93ff82f368a829e0c05da0ceae52f0e8ab2af4eaa32bd
-  data.tar.gz: c0df1d280a71bb7140076d39774a96728f2a1c8e29b756216211467a05eb93f7a3001c4472dc47155d0b57ec40d4d65f83c0f4f813014c01f55f7b9e03ffac67
+  metadata.gz: 10531a1d819b74fcc442ce7591be124430d3c55c55afbccb79ba295dd89c0e85e4a1a0a75b11996557057fa2f5dbad71e9284789143395d229e3abbbbd42ba3c
+  data.tar.gz: d0b07a2757c3b962a59973581234ec9e346717d24cdbd5443073c0fd14f840fb287419d63eeb31d4aa52d3fff2e1c0842cc119ed52e836cd55ed73bcd29a3fc7

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+# v0.17.0
+- allow overriding `exists:` in `allowed?`
+- allow setting `include_directories: true` in `allowed?`
+- subsequent calls to `allowed?` with the same path but different `directory:` or `content:` arguments won't potentially mess up the cache
+- slight performance improvements of the shebang rule matcher loading the first line
+- drop support for ruby 2.4
+- add ruby 3.1 to the test matrix
+
+# v0.16.1
+- respect GIT_CONFIG_SYSTEM, GIT_CONFIG_NOSYSTEM and GIT_CONFIG_GLOBAL env vars the same way git does
+- make the tests more resilient to whatever global config is going on.
+
+# v0.16.0
+- Entirely rewrite the way that git config files are read. previously it was just a regexp. now we actually parse git config files according to the same rules as git.
+- Add ruby 3 to the test matrix
+
 # v0.15.2
 - Updated methods with multiple `_` arguments to have different names to make sorbet happy
 

data/README.md

@@ -15,7 +15,7 @@ FastIgnore.new(relative: true).sort == `git ls-files`.split("\n").sort
 ## Features
 
 - Fast (faster than using `` `git ls-files`.split("\n") `` for small repos (because it avoids the overhead of ``` `` ```))
-- Supports ruby 2.4-3.0.0.preview1 & jruby
+- Supports ruby 2.5-3.1.x & jruby
 - supports all [gitignore rule patterns](https://git-scm.com/docs/gitignore#_pattern_format)
 - doesn't require git to be installed
 - supports a gitignore-esque "include" patterns. ([`include_rules:`](#include_rules)/[`include_files:`](#include_files))
@@ -81,20 +81,79 @@ Relative paths will be considered relative to the [`root:`](#root) directory, no
 
 This is aliased as `===` so you can use a FastIgnore instance in case statements.
 ```ruby
+@path_matcher ||= FastIgnore.new
+
 case my_path
-when FastIgnore.new
+when @path_matcher
   puts(my_path)
 end
 ```
 
 It's recommended to save the FastIgnore instance to a variable to avoid having to read and parse the gitignore file and gitconfig files repeatedly.
 
-See [Optimising allowed](#optimising_allowed) for ways to make this even faster
+#### directory: true/false/nil
+
+If your code already knows the path to test is/not a directory or wants to lie about whether it is/is not a directory, you can pass `directory: true` or `directory: false` as an argument to `allowed?` (to have FastIgnore ask the file system, you can pass `directory: nil` or nothing)
+
+```
+FastIgnore.new.allowed?('relative/path', directory: false) # matches `path` as a file
+FastIgnore.new.allowed?('relative/path', directory: true) # matches `path` as a directory
+FastIgnore.new.allowed?('relative/path', directory: nil) # matches path as whatever it is on the filesystem
+FastIgnore.new.allowed?('relative/path)                  # or as a file if it doesn't exist on the file system
+```
+
+#### content: true/false/nil
+
+default: `nil`
+
+If your code already knows the path to test is has a particular text content or wants to lie about the content, you can pass `directory: true` or `directory: false` as an argument to `allowed?` (to have FastIgnore ask the file system, you can pass `directory: nil` or nothing)
+
+```
+FastIgnore.new.allowed?('relative/path', content: "#!/usr/bin/env ruby\n\nputs 'hello'") # matches ruby shebang
+FastIgnore.new.allowed?('relative/path', content: "#!/usr/bin/env bash\n\necho 'hello'") # matches bash shebang
+FastIgnore.new.allowed?('relative/path', content: nil) # matches path as whatever content is on the filesystem
+FastIgnore.new.allowed?('relative/path)                # or as an empty file if it doesn't actually exist
+```
+
+#### content: true/false/nil
+
+default: `nil`
+
+If your code already knows the path to test is has a particular text content or wants to lie about the content, you can pass `directory: true` or `directory: false` as an argument to `allowed?` (to have FastIgnore ask the file system, you can pass `directory: nil` or nothing)
+
+```
+FastIgnore.new.allowed?('relative/path', content: "#!/usr/bin/env ruby\n\nputs 'hello'") # matches ruby shebang
+FastIgnore.new.allowed?('relative/path', content: "#!/usr/bin/env bash\n\necho 'hello'") # matches bash shebang
+FastIgnore.new.allowed?('relative/path', content: nil) # matches path as whatever content is on the filesystem
+FastIgnore.new.allowed?('relative/path)                # or as an empty file if it doesn't actually exist
+```
 
-**Note: A file must exist at that path and not be a directory for it to be considered allowed.**
-Essentially it can be thought of as `` `git ls-files`.include?(path) `` but much faster.
-This excludes all directories and all possible path names that don't exist.
+#### exist: true/false/nil
 
+default: `nil`
+
+If your code already knows the path to test exists or wants to lie about its existence, you can pass `exists: true` or `exists: false` as an argument to `allowed?` (to have FastIgnore ask the file system, you can pass `exists: nil` or nothing)
+
+```
+FastIgnore.new.allowed?('relative/path', exists: true) # will check the path regardless of whether it actually truly exists
+FastIgnore.new.allowed?('relative/path', exists: false) # will always return false
+FastIgnore.new.allowed?('relative/path', exists: nil) # asks the filesystem
+FastIgnore.new.allowed?('relative/path)               # asks the filesystem
+```
+
+#### include_directories: true/false
+
+default: `false`
+
+By default a file must not be a directory for it to be considered allowed. This is intended to match the behaviour of `git ls-files` which only lists files.
+
+To match directories you can pass `include_directories: true` to `allowed?`
+
+```
+FastIgnore.new.allowed?('relative/path', include_directories: true) # will test the path even if it's a directory
+FastIgnore.new.allowed?('relative/path', include_directories: false) # will always return false if the path is a directory
+FastIgnore.new.allowed?('relative/path)                        # will always return false if the path is a directory
+```
 
 ### `relative: true`
 
@@ -293,15 +352,6 @@ FastIgnore.new(argv_rules: ["my/rule", File.read('/my/path')]).to_a
 ```
 
 This does unfortunately lose the file path as the root `/` and there is no workaround except setting the [`root:`](#root) for the whole FastIgnore instance.
-
-### optimising #allowed?
-
-To avoid unnecessary calls to the filesystem, if your code already knows whether or not it's a directory, or if you're checking shebangs and you have already read the content of the file: use
-```ruby
-FastIgnore.new.allowed?('relative/path', directory: false, content: "#!/usr/bin/ruby\n\nputs 'ok'\n")
-```
-This is not required, and if FastIgnore does have to go to the filesystem for this information it's well optimised to only read what is necessary.
-
 ## Limitations
 - Doesn't know what to do if you change the current working directory inside the [`FastIgnore#each`](#each_map_etc) block.
   So don't do that.
@@ -309,6 +359,7 @@ This is not required, and if FastIgnore does have to go to the filesystem for th
   (It does handle changing the current working directory between [`FastIgnore#allowed?`](#allowed) calls)
 - FastIgnore always matches patterns case-insensitively. (git varies by filesystem).
 - FastIgnore always outputs paths as literal UTF-8 characters. (git depends on your core.quotepath setting but by default outputs non ascii paths with octal escapes surrounded by quotes).
+- git has a system-wide config file installed at `$(prefix)/etc/gitconfig`, where `prefix` is defined for git at install time. FastIgnore assumes that it will always be `/usr/local/etc/gitconfig`. if it's important your system config file is looked at, as that's where you have the core.excludesfile defined, use git's built-in way to override this by adding `export GIT_CONFIG_SYSTEM='/the/actual/location'` to your shell profile.
 - Because git looks at its own index objects and FastIgnore looks at the file system there may be some differences between FastIgnore and `git ls-files`. To avoid these differences you may want to use the [`git_ls`](https://github.com/robotdana/git_ls) gem instead
   - Tracked files that were committed before the matching ignore rule was committed will be returned by `git ls-files`, but not by FastIgnore.
   - Untracked files will be returned by FastIgnore, but not by `git ls-files`

data/lib/fast_ignore/gitconfig_parser.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'strscan'
+class FastIgnore
+  class GitconfigParseError < FastIgnore::Error; end
+
+  class GitconfigParser # rubocop:disable Metrics/ClassLength
+    def self.parse(file, root: Dir.pwd, nesting: 1)
+      new(file, root: root, nesting: nesting).parse
+    end
+
+    def initialize(path, root: Dir.pwd, nesting: 1)
+      @path = path
+      @root = root
+      @nesting = nesting
+    end
+
+    def parse
+      raise ::FastIgnore::GitconfigParseError if nesting >= 10
+
+      read_file(path)
+      return unless value
+
+      value
+    end
+
+    private
+
+    attr_reader :nesting
+    attr_reader :path
+    attr_reader :root
+    attr_accessor :value
+    attr_accessor :within_quotes
+    attr_accessor :section
+
+    def read_file(path) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      return unless ::File.readable?(path)
+
+      file = StringScanner.new(::File.read(path))
+
+      until file.eos?
+        if file.skip(/(\s+|[#;].*\n)/)
+          # skip
+        elsif file.skip(/\[core\]/i)
+          self.section = :core
+        elsif file.skip(/\[include\]/i)
+          self.section = :include
+        elsif file.skip(/\[(?i:includeif) +"/)
+          self.section = include_if(file) ? :include : :not_include
+        elsif file.skip(/\[[\w.]+( "([^\0\\"]|\\(\\{2})*"|\\{2}*)+")?\]/)
+          self.section = :other
+        elsif section == :core && file.skip(/excludesfile\s*=(\s|\\\n)*/i)
+          self.value = scan_value(file)
+        elsif section == :include && file.skip(/path\s*=(\s|\\\n)*/)
+          include_path = scan_value(file)
+
+          value = ::FastIgnore::GitconfigParser.parse(
+            ::File.expand_path(include_path, ::File.dirname(path)),
+            root: root,
+            nesting: nesting + 1
+          )
+          self.value = value if value
+          self.section = :include
+        elsif file.skip(/[a-zA-Z0-9]\w*\s*([#;].*)?\n/)
+          nil
+        elsif file.skip(/[a-zA-Z0-9]\w*\s*=(\s|\\\n)*/)
+          skip_value(file)
+        else
+          raise ::FastIgnore::GitconfigParseError
+        end
+      end
+    end
+
+    def scan_condition_value(file)
+      if file.scan(/([^\0\\\n"]|\\(\\{2})*"|\\{2}*)+(?="\])/)
+        value = file.matched
+        file.skip(/"\]/)
+        value
+      else
+        raise ::FastIgnore::GitconfigParseError
+      end
+    end
+
+    def skip_condition_value(file)
+      raise ::FastIgnore::GitconfigParseError unless file.skip(/([^\0\\\n"]|\\(\\{2})*"|\\{2}*)+"\]/)
+    end
+
+    def include_if(file)
+      if file.skip(/onbranch:/)
+        on_branch?(scan_condition_value(file))
+      elsif file.skip(/gitdir:/)
+        gitdir?(scan_condition_value(file), path: path)
+      elsif file.skip(%r{gitdir/i:})
+        gitdir?(scan_condition_value(file), case_insensitive: true, path: path)
+      else
+        skip_condition_value(file)
+        false
+      end
+    end
+
+    def on_branch?(branch_pattern)
+      branch_pattern += '**' if branch_pattern.end_with?('/')
+      current_branch = ::File.readable?("#{root}/.git/HEAD") && ::File.read("#{root}/.git/HEAD").sub!(
+        %r{\Aref: refs/heads/}, ''
+      )
+      return unless current_branch
+
+      # goddamit git what does 'a pattern with standard globbing wildcards' mean
+      ::File.fnmatch(branch_pattern, current_branch, ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH)
+    end
+
+    def gitdir?(gitdir, path:, case_insensitive: false)
+      gitdir += '**' if gitdir.end_with?('/')
+      gitdir.sub!(%r{\A~/}, ENV['HOME'] + '/')
+      gitdir.sub!(/\A\./, path + '/')
+      gitdir = "**/#{gitdir}" unless gitdir.start_with?('/')
+      options = ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH
+      options |= ::File::FNM_CASEFOLD if case_insensitive
+      ::File.fnmatch(gitdir, ::File.join(root, '.git'), options)
+    end
+
+    def scan_value(file) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      value = +''
+      until file.eos?
+        if file.skip(/\\\n/)
+          # continue
+        elsif file.skip(/\\\\/)
+          value << '\\'
+        elsif file.skip(/\\n/)
+          value << "\n"
+        elsif file.skip(/\\t/)
+          value << "\t"
+        elsif file.skip(/\\b/)
+          value.chop!
+        elsif file.skip(/\\"/)
+          value << '"'
+        elsif file.skip(/\\/)
+          raise ::FastIgnore::GitconfigParseError
+        elsif within_quotes
+          if file.skip(/"/)
+            self.within_quotes = false
+          elsif file.scan(/[^"\\\n]+/)
+            value << file.matched
+          elsif file.skip(/\n/)
+            raise ::FastIgnore::GitconfigParseError
+          # :nocov:
+          else
+            raise "Unmatched #{file.rest}"
+            # :nocov:
+          end
+        elsif file.skip(/"/)
+          self.within_quotes = true
+        elsif file.scan(/[^;#"\s\\]+/)
+          value << file.matched
+        elsif file.skip(/\s*[;#\n]/)
+          break
+        elsif file.scan(/\s+/) # rubocop:disable Lint/DuplicateBranch
+          value << file.matched
+        # :nocov:
+        else
+          raise "Unmatched #{file.rest}"
+          # :nocov:
+        end
+      end
+
+      raise ::FastIgnore::GitconfigParseError if within_quotes
+
+      value
+    end
+
+    def skip_value(file) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      until file.eos?
+        if file.skip(/\\(?:\n|\\|n|t|b|")/)
+          nil
+        elsif file.skip(/\\/)
+          raise ::FastIgnore::GitconfigParseError
+        elsif within_quotes
+          if file.skip(/"/)
+            self.within_quotes = false
+          elsif file.skip(/[^"\\\n]+/)
+            nil
+          elsif file.scan(/\n/)
+            raise ::FastIgnore::GitconfigParseError
+          # :nocov:
+          else
+            raise "Unmatched #{file.rest}"
+            # :nocov:
+          end
+        elsif file.skip(/"/)
+          self.within_quotes = true
+        elsif file.skip(/[^;#"\s\\]+/) # rubocop:disable Lint/DuplicateBranch
+          nil
+        elsif file.skip(/\s*[;#\n]/)
+          break
+        elsif file.skip(/\s+/) # rubocop:disable Lint/DuplicateBranch
+          nil
+        # :nocov:
+        else
+          raise "Unmatched #{file.rest}"
+          # :nocov:
+        end
+      end
+
+      raise ::FastIgnore::GitconfigParseError if within_quotes
+    end
+  end
+end

data/lib/fast_ignore/global_gitignore.rb

@@ -4,46 +4,84 @@ class FastIgnore
   module GlobalGitignore
     class << self
       def path(root:)
-        gitconfig_gitignore_path(::File.expand_path('.git/config', root)) ||
-          gitconfig_gitignore_path(::File.expand_path('~/.gitconfig')) ||
-          gitconfig_gitignore_path(xdg_config_path) ||
-          gitconfig_gitignore_path('/etc/gitconfig') ||
+        ignore_path = gitconfigs_gitignore_path(root) ||
           default_global_gitignore_path
+
+        ignore_path unless ignore_path.empty?
       end
 
       private
 
+      def gitconfigs_gitignore_path(root)
+        gitconfig_gitignore_path(repo_config_path(root)) ||
+          gitconfig_gitignore_path(global_config_path) ||
+          gitconfig_gitignore_path(default_user_config_path) ||
+          gitconfig_gitignore_path(system_config_path)
+      rescue ::FastIgnore::GitconfigParseError
+        ''
+      end
+
       def gitconfig_gitignore_path(config_path)
         return unless config_path
-        return unless ::File.exist?(config_path)
+        return unless ::File.readable?(config_path)
 
-        ignore_path = ::File.readlines(config_path).find { |l| l.sub!(/\A\s*excludesfile\s*=/, '') }
+        ignore_path = ::FastIgnore::GitconfigParser.parse(config_path)
         return unless ignore_path
 
         ignore_path.strip!
-        return ignore_path if ignore_path.empty? # don't expand path in this case
+        return '' if ignore_path.empty? # don't expand path in this case
 
         ::File.expand_path(ignore_path)
       end
 
-      def xdg_config_path
-        xdg_config_home? && ::File.expand_path('git/config', xdg_config_home)
+      def default_user_config_path
+        return if env('GIT_CONFIG_GLOBAL')
+
+        ::File.expand_path('git/config', default_config_home)
       end
 
       def default_global_gitignore_path
-        if xdg_config_home?
-          ::File.expand_path('git/ignore', xdg_config_home)
+        ::File.expand_path('git/ignore', default_config_home)
+      end
+
+      def repo_config_path(root)
+        ::File.expand_path('.git/config', root)
+      end
+
+      def global_config_path
+        ::File.expand_path(env('GIT_CONFIG_GLOBAL', '~/.gitconfig'))
+      end
+
+      def system_config_path
+        return if env?('GIT_CONFIG_NOSYSTEM')
+
+        ::File.expand_path(env('GIT_CONFIG_SYSTEM', '/usr/local/etc/gitconfig'))
+      end
+
+      def default_config_home
+        env('XDG_CONFIG_HOME', '~/.config')
+      end
+
+      def env(env_var, default = nil)
+        value = ::ENV[env_var]
+
+        if value && (not value.empty?)
+          value
         else
-          ::File.expand_path('~/.config/git/ignore')
+          default
         end
       end
 
-      def xdg_config_home
-        ::ENV['XDG_CONFIG_HOME']
-      end
+      def env?(env_var)
+        value = ::ENV[env_var]
 
-      def xdg_config_home?
-        xdg_config_home && (not xdg_config_home.empty?)
+        if value&.match?(/\A(yes|on|true|1)\z/i)
+          true
+        elsif !value || value.match?(/\A(no|off|false|0|)\z/i)
+          false
+        else
+          raise ::FastIgnore::GitconfigParseError
+        end
       end
     end
   end

data/lib/fast_ignore/rule_set.rb

@@ -11,7 +11,7 @@ class FastIgnore
       @file_rules = (squash ? squash_rules(rules.reject(&:dir_only?)) : rules.reject(&:dir_only?)).freeze
       @has_shebang_rules = rules.any?(&:shebang?)
 
-      @allowed_recursive = { '.' => true }
+      @allowed_recursive = { ['.', true, nil] => true }
       @allow = allow
       @gitignore = gitignore
 
@@ -27,8 +27,8 @@ class FastIgnore
     end
 
     def allowed_recursive?(relative_path, dir, full_path, filename, content = nil)
-      @allowed_recursive.fetch(relative_path) do
-        @allowed_recursive[relative_path] =
+      @allowed_recursive.fetch([relative_path, dir, content]) do |key|
+        @allowed_recursive[key] =
           allowed_recursive?(::File.dirname(relative_path), true, nil, nil, nil) &&
           allowed_unrecursive?(relative_path, dir, full_path, filename, content)
       end

data/lib/fast_ignore/rule_sets.rb

@@ -27,8 +27,8 @@ class FastIgnore
       @array.freeze if @gitignore_rule_set
     end
 
-    def allowed_recursive?(relative_path, full_path, filename, content)
-      @array.all? { |r| r.allowed_recursive?(relative_path, false, full_path, filename, content) }
+    def allowed_recursive?(relative_path, dir, full_path, filename, content)
+      @array.all? { |r| r.allowed_recursive?(relative_path, dir, full_path, filename, content) }
     end
 
     def allowed_unrecursive?(relative_path, dir, full_path, filename)
@@ -73,7 +73,7 @@ class FastIgnore
     end
 
     def build_from_root_gitignore_file(path)
-      return unless ::File.exist?(path)
+      return unless path && ::File.exist?(path)
 
       build_rule_set(::File.readlines(path), false, gitignore: true)
     end

data/lib/fast_ignore/shebang_rule.rb

@@ -61,12 +61,9 @@ class FastIgnore
 
     def first_line(path) # rubocop:disable Metrics/MethodLength
       file = ::File.new(path)
-      first_line = new_fragment = file.sysread(64)
+      first_line = file.sysread(64)
       if first_line.start_with?('#!')
-        until new_fragment.include?("\n")
-          new_fragment = file.sysread(64)
-          first_line += new_fragment
-        end
+        first_line += file.readline unless first_line.match?(/\n/)
       else
         file.close
         return

data/lib/fast_ignore/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class FastIgnore
-  VERSION = '0.15.2'
+  VERSION = '0.17.0'
 end

data/lib/fast_ignore.rb

@@ -4,22 +4,24 @@ require_relative './fast_ignore/backports'
 
 require 'set'
 require 'strscan'
-require_relative './fast_ignore/rule_sets'
-require_relative './fast_ignore/rule_set'
-require_relative './fast_ignore/global_gitignore'
-require_relative './fast_ignore/rule_builder'
-require_relative './fast_ignore/gitignore_rule_builder'
-require_relative './fast_ignore/gitignore_include_rule_builder'
-require_relative './fast_ignore/gitignore_rule_regexp_builder'
-require_relative './fast_ignore/gitignore_rule_scanner'
-require_relative './fast_ignore/file_root'
-require_relative './fast_ignore/rule'
-require_relative './fast_ignore/unmatchable_rule'
-require_relative './fast_ignore/shebang_rule'
 
 class FastIgnore
   class Error < StandardError; end
 
+  require_relative './fast_ignore/rule_sets'
+  require_relative './fast_ignore/rule_set'
+  require_relative './fast_ignore/global_gitignore'
+  require_relative './fast_ignore/rule_builder'
+  require_relative './fast_ignore/gitignore_rule_builder'
+  require_relative './fast_ignore/gitignore_include_rule_builder'
+  require_relative './fast_ignore/gitignore_rule_regexp_builder'
+  require_relative './fast_ignore/gitignore_rule_scanner'
+  require_relative './fast_ignore/file_root'
+  require_relative './fast_ignore/rule'
+  require_relative './fast_ignore/unmatchable_rule'
+  require_relative './fast_ignore/shebang_rule'
+  require_relative './fast_ignore/gitconfig_parser'
+
   include ::Enumerable
 
   # :nocov:
@@ -47,19 +49,30 @@ class FastIgnore
     each_recursive(root_from_pwd, '', &block)
   end
 
-  def allowed?(path, directory: nil, content: nil)
+  def allowed?(path, directory: nil, content: nil, exists: nil, include_directories: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     full_path = ::File.expand_path(path, @root)
     return false unless full_path.start_with?(@root)
-    return false if directory.nil? ? @follow_symlinks_method.call(full_path).directory? : directory
+
+    begin
+      directory = directory.nil? ? @follow_symlinks_method.call(full_path).directory? : directory
+    rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
+      exists = false if exists.nil?
+      directory = false
+    end
+
+    return false if !include_directories && directory
+
+    exists = exists.nil? ? ::File.exist?(full_path) : exists
+
+    return false unless exists
 
     relative_path = full_path.delete_prefix(@root)
     load_gitignore_recursive(relative_path) if @gitignore_enabled
 
     filename = ::File.basename(relative_path)
+    content = content.slice(/.*/) if content # we only care about the first line
 
-    @rule_sets.allowed_recursive?(relative_path, full_path, filename, content)
-  rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
-    false
+    @rule_sets.allowed_recursive?(relative_path, directory, full_path, filename, content)
   end
   alias_method :===, :allowed?
 
@@ -75,7 +88,7 @@ class FastIgnore
       paths << path
     end
 
-    paths.reverse_each(&method(:load_gitignore))
+    paths.reverse_each { |p| load_gitignore(p) }
   end
 
   def load_gitignore(parent_path, check_exists: true)
@@ -91,21 +104,19 @@ class FastIgnore
     load_gitignore(parent_relative_path, check_exists: false) if @gitignore_enabled && children.include?('.gitignore')
 
     children.each do |filename|
-      begin
-        full_path = parent_full_path + filename
-        relative_path = parent_relative_path + filename
-        dir = @follow_symlinks_method.call(full_path).directory?
-
-        next unless @rule_sets.allowed_unrecursive?(relative_path, dir, full_path, filename)
-
-        if dir
-          each_recursive(full_path + '/', relative_path + '/', &block)
-        else
-          yield(@relative ? relative_path : @root + relative_path)
-        end
-      rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
-        nil
+      full_path = parent_full_path + filename
+      relative_path = parent_relative_path + filename
+      dir = @follow_symlinks_method.call(full_path).directory?
+
+      next unless @rule_sets.allowed_unrecursive?(relative_path, dir, full_path, filename)
+
+      if dir
+        each_recursive(full_path + '/', relative_path + '/', &block)
+      else
+        yield(@relative ? relative_path : @root + relative_path)
       end
+    rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
+      nil
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.15.2
+  version: 0.17.0
 platform: ruby
 authors:
 - Dana Sherson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-18 00:00:00.000000000 Z
+date: 2022-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,6 +87,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.93.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -94,6 +97,23 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.93.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +142,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.18.5
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: spellr
   requirement: !ruby/object:Gem::Requirement
@@ -136,7 +170,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.3
-description: 
+description:
 email:
 - robot@dana.sh
 executables: []
@@ -149,6 +183,7 @@ files:
 - lib/fast_ignore.rb
 - lib/fast_ignore/backports.rb
 - lib/fast_ignore/file_root.rb
+- lib/fast_ignore/gitconfig_parser.rb
 - lib/fast_ignore/gitignore_include_rule_builder.rb
 - lib/fast_ignore/gitignore_rule_builder.rb
 - lib/fast_ignore/gitignore_rule_regexp_builder.rb
@@ -168,7 +203,7 @@ metadata:
   homepage_uri: https://github.com/robotdana/fast_ignore
   source_code_uri: https://github.com/robotdana/fast_ignore
   changelog_uri: https://github.com/robotdana/fast_ignore/blob/main/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -176,15 +211,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Parse gitignore files, quickly
 test_files: []