fast_ignore 0.10.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3d94c089fb5c75d6c9d0650d2391d03425c487c81296495f44f35ed1f6d80ac
-  data.tar.gz: a9bba05df8121aa49d38b39c7aaaa0e3c7d2b30e4b874d083fe517fa36846b97
+  metadata.gz: ee7e9eb231ff6441ca703c935e9c270e4cb6c2f8f3216d993d4fc891807e77f6
+  data.tar.gz: 68f1ace7ab6420ce140a43a747a969f29401eba718dd9d1e94b9538774b0ac6d
 SHA512:
-  metadata.gz: e8954fbef86b13d7948744b2c803319b261d67b6afe83412f1e099a377b17adae2aa1106a3445e6f5604449130c8dfc815331fe104f205ca09b87f5ff8caa69e
-  data.tar.gz: e53891e9d8b056a62ede7399695deb2911d5836ad5b8442b2ef90d7876fb4d794f1665697df6e7eeecf616f828217fce841f96c9bdfd39e73ae6c89594a65d5c
+  metadata.gz: 83609a93cf79d3d4063e69d213450d85f81c4b9bb7c1200468e46fa7fce01602c751c4afd6dbaef652d1761c0f180fa5806ff29d0913ca184a5e41850875a8d0
+  data.tar.gz: dbf3e341e671fa1a51dce4c885c04e1eadf0717d78ffd94f1746c63b1024f78bd9d4b6915e7b892ca3af21d27ef2566df980be41101573c3dd586384b6f6d7c6

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+# v0.13.0
+- Attempt to improve documentation structure
+- Remove `gitignore: true` raising `Errno::ENOENT` if root:/.gitignore didn't exist. I can't think of a use. Now `gitignore: true` is just the default behaviour.
+- Don't ignore `.git` if `gitignore: false`.
+
+# v0.12.1
+- Reads all relevant git config files when finding a global .gitignore
+
+# v0.12.0
+- Reads all relevant gitignore files (nested .gitignore files, global .gitignore referred to in .gitconfig, and .git/info/exclude)
+
+# v0.11.0
+- major performance improvement (use regexp rather than fnmatch)
+- optionally pass directory: and content: into allowed? if these are already loaded.
+
+# v0.10.2
+- add FastIgnore#=== as an alias for FastIgnore#allowed? so that FastIgnore objects can be used for case statements.
+- Fix shebangs in non-pwd-root situations
+
 # v0.10.1
 - Add option to follow symlinks (turns out i needed it)
 - performance improvements

data/README.md

@@ -1,6 +1,7 @@
 # FastIgnore
 
-[![travis](https://travis-ci.org/robotdana/fast_ignore.svg?branch=master)](https://travis-ci.org/robotdana/fast_ignore)
+[![travis](https://travis-ci.com/robotdana/fast_ignore.svg?branch=master)](https://travis-ci.com/robotdana/fast_ignore)
+[![Gem Version](https://badge.fury.io/rb/fast_ignore.svg)](https://rubygems.org/gems/fast_ignore)
 
 This started as a way to quickly and natively ruby-ly parse gitignore files and find matching files.
 It's now gained an equivalent includes file functionality, ARGV awareness, and some shebang matching, while still being extremely fast, to be a one-stop file-list for your linter.
@@ -11,6 +12,19 @@ Filter a directory tree using a .gitignore file. Recognises all of the [gitignor
 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-2.7 & 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))
+- supports an expansion of include patterns, expanding and anchoring paths ([`argv_rules:`](#argv_rules))
+- supports [matching by shebang](#shebang_rules) rather than filename for extensionless files: `#!:`
+- reads .gitignore in all subdirectories
+- reads .git/info/excludes
+- reads the ignore file mentioned in your git config
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -36,29 +50,71 @@ FastIgnore.new.each { |file| puts "#{file} is not ignored by the .gitignore file
 
 ### `#each`, `#map` etc
 
-The FastIgnore object is an enumerable and responds to all Enumerable methods
+This yields paths that are _not_ ignored by the gitignore, i.e. the paths that would be returned by `git ls-files`.
+
+A FastIgnore instance is an Enumerable and responds to all Enumerable methods:
 
 ```ruby
 FastIgnore.new.to_a
 FastIgnore.new.map { |file| file.upcase }
 ```
 
-Like other enumerables, `FastIgnore#each` can return an enumerator
+Like other enumerables, `FastIgnore#each` can return an enumerator:
 
 ```ruby
 FastIgnore.new.each.with_index { |file, index| puts "#{file}#{index}" }
 ```
 
+**Warning: Do not change directory (e.g. `Dir.chdir`) in the block.**
+
+### `#allowed?`
+
+To check if a single path is allowed, use
+```ruby
+FastIgnore.new.allowed?('relative/path')
+FastIgnore.new.allowed?('./relative/path')
+FastIgnore.new.allowed?('/absolute/path')
+FastIgnore.new.allowed?('~/home/path')
+```
+
+Relative paths will be considered relative to the [`root:`](#root) directory, not the current directory.
+
+This is aliased as `===` so you can use a FastIgnore instance in case statements.
+```ruby
+case my_path
+when FastIgnore.new
+  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
+
+**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.
+
+
 ### `relative: true`
-By default, FastIgnore will return full paths. To return paths relative to the current working directory, or the supplied [`root:`](#root), use:
+
+**Default: false**
+
+When `relative: false`: FastIgnore#each will yield full paths.
+When `relative: true`: FastIgnore#each will yield paths relative to the [`root:`](#root) directory
 
 ```ruby
 FastIgnore.new(relative: true).to_a
 ```
 
 ### `follow_symlinks: true`
-By default, FastIgnore will match git's behaviour and not follow symbolic links.
-To make it follow symlinks, use:
+
+**Default: false**
+
+When `follow_symlinks: false`: FastIgnore#each will match git's behaviour and not follow symbolic links.
+When `follow_symlinks: true`: FastIgnore#each will check if a symlink points to a directory, and files in linked directories must also match rules using the symlink path as the directory location, not the real directory location.
+
+**This doesn't use the real path for matching or yield or return it.**
 
 ```ruby
 FastIgnore.new(follow_symlinks: true).to_a
@@ -66,12 +122,16 @@ FastIgnore.new(follow_symlinks: true).to_a
 
 ### `root:`
 
-By default, root is PWD (the current working directory)
+**Default: Dir.pwd ($PWD, the current working directory)**
+
 This directory is used for:
-- looking for .gitignore files
-- as the root directory for array rules starting with `/` or ending with `/**`
-- and the path that relative is relative to
-- which files get checked
+- the location of `.git/core/exclude`
+- the ancestor of all non-global [automatically loaded `.gitignore` files](#gitignore_false)
+- the root directory for array rules ([`ignore_rules:`](#ignore_rules), [`include_rules:`](#include_rules), [`argv_rules:`](#argv_rules)) containing `/`
+- the path that [`relative:`](#relative_true) is relative to
+- the ancestor of all paths yielded by [`#each`](#each_map_etc)
+- the path that [`#allowed?`](#allowed) considers relative paths relative to
+- the ancestor of all [`include_files:`](#include_files) and [`ignore_files:`](#ignore_files)
 
 To use a different directory:
 ```ruby
@@ -79,36 +139,49 @@ FastIgnore.new(root: '/absolute/path/to/root').to_a
 FastIgnore.new(root: '../relative/path/to/root').to_a
 ```
 
+A relative root will be found relative to the current working directory when the FastIgnore instance is initialized, and that will be the last time the current working directory is relevant.
+
+**Note: Changes to the current working directory (e.g. with `Dir.chdir`), after initialising a FastIgnore instance, will _not_ affect the FastIgnore instance. `root:` will always be what it was when the instance was initialized.**
+
 ### `gitignore:`
 
-By default, the .gitignore file in root directory is loaded.
-To not do this use
-```ruby
-FastIgnore.new(gitignore: false).to_a
-```
+**Default: true**
 
-To raise an `Errno::ENOENT` error if the .gitignore file is not found use:
-```ruby
-FastIgnore.new(gitignore: true).to_a
-```
+When `gitignore: true`: the .gitignore file in the [`root:`](#root) directory is loaded, plus any .gitignore files in its subdirectories, the global git ignore file as described in git config, and .git/info/exclude. `.git` directories are also excluded to match the behaviour of `git ls-files`.
+When `gitignore: false`: no ignore files or git config files are automatically read, and `.git` will not be automatically excluded.
 
-If the gitignore file is somewhere else
 ```ruby
-FastIgnore.new(ignore_file: '/absolute/path/to/.gitignore', gitignore: false).to_a
+FastIgnore.new(gitignore: false).to_a
 ```
-Note that the location of the .gitignore file will affect rules beginning with `/` or ending in `/**`
 
 ### `ignore_files:`
+
+**This is a list of files in the gitignore format to parse and match paths against, not a list of files to ignore**  If you want an array of files use [`ignore_rules:`](#ignore_rules)
+
+Additional gitignore-style files, either as a path or an array of paths.
+
 You can specify other gitignore-style files to ignore as well.
 Missing files will raise an `Errno::ENOENT` error.
 
+Relative paths are relative to the [`root:`](#root) directory.
+Absolute paths also need to be within the [`root:`](#root) directory.
+
+
 ```ruby
-FastIgnore.new(ignore_files: '/absolute/path/to/my/ignore/file').to_a
+FastIgnore.new(ignore_files: 'relative/path/to/my/ignore/file').to_a
 FastIgnore.new(ignore_files: ['/absolute/path/to/my/ignore/file', '/and/another']).to_a
 ```
 
+Note: the location of the files will affect rules beginning with or containing `/`.
+
+To avoid raising `Errno::ENOENT` when the file doesn't exist:
+```ruby
+FastIgnore.new(ignore_files: ['/ignore/file'].select { |f| File.exist?(f) }).to_a
+```
+
 ### `ignore_rules:`
-You can also supply an array of rule strings.
+
+This can be a string, or an array of strings, and multiline strings can be used with one rule per line.
 
 ```ruby
 FastIgnore.new(ignore_rules: '.DS_Store').to_a
@@ -116,108 +189,142 @@ FastIgnore.new(ignore_rules: ['.git', '.gitkeep']).to_a
 FastIgnore.new(ignore_rules: ".git\n.gitkeep").to_a
 ```
 
-# `#allowed?`
+These rules use the [`root:`](#root) argument to resolve rules containing `/`.
+
+### `include_files:`
+
+**This is an array of files in the gitignore format to parse and match paths against, not a list of files to include.**  If you want an array of files use [`include_rules:`](#include_rules).
+
+Building on the gitignore format, FastIgnore also accepts rules to include matching paths (rather than ignoring them).
+A rule matching a directory will include all descendants of that directory.
+
+These rules can be provided in files either as absolute or relative paths, or an array of paths.
+Relative paths are relative to the [`root:`](#root) directory.
+Absolute paths also need to be within the [`root:`](#root) directory.
 
-To check if a single file is allowed, use
 ```ruby
-FastIgnore.new.allowed?('relative/path')
-FastIgnore.new.allowed?('./relative/path')
-FastIgnore.new.allowed?('/absolute/path')
-FastIgnore.new.allowed?('~/home/path')
+FastIgnore.new(include_files: 'my_include_file').to_a
+FastIgnore.new(include_files: ['/absolute/include/file', './relative/include/file']).to_a
 ```
 
-### `include_files:` and `include_rules:`
+Missing files will raise an `Errno::ENOENT` error.
 
-Building on the gitignore format, FastIgnore also accepts a list of allowed or included files.
+To avoid raising `Errno::ENOENT` when the file doesn't exist:
+```ruby
+FastIgnore.new(include_files: ['include/file'].select { |f| File.exist?(f) }).to_a
+```
 
-```gitignore
-# a line like this means any files named foo will be included
-# as well as any files within directories named foo
-foo
-# a line beginning with a slash will be anything in a directory that is a child of the $PWD
-/foo
-# a line ending in a slash will will include any files in any directories named foo
-# but not any files named foo
-foo/
-fo*
-!foe
-# otherwise this format deals with !'s, *'s and ?'s and etc as you'd expect from gitignore.
-```
-
-These can be passed either as files or as an array or string rules
-```ruby
-FastIgnore.new(include_files: '/absolute/path/to/my/include/file', gitignore: false).to_a
+**Note: All paths checked must not be excluded by any ignore files AND each included by include file separately AND the [`include_rules:`](#include_rules) AND the [`argv_rules:`](#argv_rules). see [Combinations](#combinations) for solutions to using OR.**
+
+### `include_rules:`
+
+Building on the gitignore format, FastIgnore also accepts rules to include matching paths (rather than ignoring them).
+A rule matching a directory will include all descendants of that directory.
+
+This can be a string, or an array of strings, and multiline strings can be used with one rule per line.
+```ruby
 FastIgnore.new(include_rules: %w{my*rule /and/another !rule}, gitignore: false).to_a
 ```
 
-There is an additional argument meant for dealing with humans and `ARGV` values.
+Rules use the [`root:`](#root) argument to resolve rules containing `/`.
+
+**Note: All paths checked must not be excluded by any ignore files AND each included by [include file](#include_files) separately AND the `include_rules:` AND the [`argv_rules:`](#argv_rules). see [Combinations](#combinations) for solutions to using OR.**
+
+### `argv_rules:`
+This is like [`include_rules:`](#include_rules) with additional features meant for dealing with humans and `ARGV` values.
+
+It expands rules that are absolute paths, and paths beginning with `~`, `../` and `./` (with and without `!`).
+This means rules beginning with `/` are absolute. Not relative to [`root:`](#root).
+
+Additionally it assumes all rules are relative to the [`root:`](#root) directory (after resolving absolute paths) unless they begin with `*` (or `!*`).
+
+This can be a string, or an array of strings, and multiline strings can be used with one rule per line.
 
 ```ruby
 FastIgnore.new(argv_rules: ['./a/pasted/path', '/or/a/path/from/stdin', 'an/argument', '*.txt']).to_a
 ```
 
-It resolves absolute paths, and paths beginning with `~`, `../` and `./` (with and without `!`)
-It assumes all rules are anchored unless they begin with `*` or `!*`.
+**Warning: it will *not* expand e.g. `/../` in the middle of a rule that doesn't begin with any of `~`,`../`,`./`,`/`.**
 
-Note: it will *not* resolve e.g. `/../` in the middle of a rule that doesn't begin with any of `~`,`../`,`./`,`/`.
+**Note: All paths checked must not be excluded by any ignore files AND each included by [include file](#include_files) separately AND the [`include_rules:`](#include_rules) AND the `argv_rules:`. see [Combinations](#combinations) for solutions to using OR.**
 
 ### shebang rules
 
-Sometimes you need to match files by their shebang rather than their path or filename
+Sometimes you need to match files by their shebang/hashbang/etc rather than their path or filename
 
-To match extensionless files by shebang/hashbang/etc:
-
-Lines beginning with `#!:` will match whole words in the shebang line of extensionless files.
+Rules beginning with `#!:` will match whole words in the shebang line of extensionless files.
 e.g.
 ```gitignore
 #!:ruby
 ```
 will match shebang lines: `#!/usr/bin/env ruby` or `#!/usr/bin/ruby` or `#!/usr/bin/ruby -w`
+
 e.g.
 ```gitignore
 #!:bin/ruby
 ```
 will match `#!/bin/ruby` or `#!/usr/bin/ruby` or `#!/usr/bin/ruby -w`
-Currently only exact substring matches are available, There's no special handling of * or / or etc.
+Only exact substring matches are available, There's no special handling of * or / or etc.
 
+These rules can be supplied any way regular rules are, whether in a .gitignore file or files mentioned in [`include_files:`](#include_files) or [`ignore_files:`](#ignore_files) or [`include_rules:`](#include_rules) or [`ignore_rules:`](#ignore_rules) or [`argv_rules:`](#argv_rules)
 ```ruby
 FastIgnore.new(include_rules: ['*.rb', '#!:ruby']).to_a
 FastIgnore.new(ignore_rules: ['*.sh', '#!:sh', '#!:bash', '#!:zsh']).to_a
 ```
 
+**Note: git considers rules like this as a comment and will ignore them.**
+
 ## Combinations
 
-In the simplest case a file must be allowed by each ignore file, each include file, and each array of rules. That is, they are combined using AND.
+In the simplest case a file must be allowed by each ignore file, each include file, and each array of rules. That is, they are combined using `AND`.
 
 To combine files using `OR`, that is, a file may be matched by either file it doesn't have to be referred to in both:
-provide the files as strings to `include_rules:` or `ignore_rules:`
+provide the files as strings to [`include_rules:`](#include_rules) or [`ignore_rules:`](#ignore_rules)
 ```ruby
 FastIgnore.new(include_rules: [File.read('/my/path'), File.read('/another/path')])).to_a
 ```
-This does unfortunately lose the file path as the root for `/` and `/**` rules.
-If that's important, combine the files in the file system and use `include_files:` or `ignore_files:` as normal.
+This does unfortunately lose the file path as the root for rules containing `/`.
+If that's important, combine the files in the file system and use [`include_files:`](#include_files) or [`ignore_files:`](#ignore_files) as normal.
 
-To use the additional ARGV handling rules mentioned above for files, read the file into the array as a string.
+To use the additional `ARGV` handling of [`argv_rules:`](#argv_rules) on a file, read the file into the array.
 
 ```ruby
 FastIgnore.new(argv_rules: ["my/rule", File.read('/my/path')]).to_a
 ```
 
-This does unfortunately lose the file path as the root for `/` and `/**` rules.
+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.
+
 
 ## Known issues
-- Doesn't take into account project excludes in `.git/info/exclude`
-- Doesn't take into account globally ignored files in `git config core.excludesFile`.
-- Doesn't know what to do if you change the current working directory inside the `FastIgnore#each` block.
+- 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.
 
-  (It does handle changing the current working directory between `FastIgnore#allowed?` calls.)
+  (It does handle changing the current working directory between [`FastIgnore#allowed?`](#allowed) calls) (changing directories doesn't affect the [`root:`](#root) directory, that's frozen at FastIgnore.new (this is a design decision, not an issue)).
+- FastIgnore always matches patterns case-insensitively. (git varies by filesystem).
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run the tests and linters.
+
+You can run `bin/console` for an interactive prompt that will allow you to experiment.
+`bin/ls [argv_rules]` will return something equivalent to `git ls-files` and `bin/time [argv_rules]` will give you the average time for 30 runs.
+This repo is too small to stress bin/time more than 0.01s, switch to a large repo and find the average time before and after changes.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+### Goals
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+1. Match `git ls-files` behaviour quirk for quirk.
+2. Provide a convenient interface for allowlist/denylist files in ruby.
+3. Be fast.
 
 ## Contributing
 

data/lib/fast_ignore.rb

@@ -2,10 +2,13 @@
 
 require_relative './fast_ignore/backports'
 
+require 'set'
 require_relative './fast_ignore/rule_set_builder'
 require_relative './fast_ignore/rule_builder'
 require_relative './fast_ignore/rule_set'
 require_relative './fast_ignore/rule'
+require_relative './fast_ignore/shebang_rule'
+require_relative './fast_ignore/fn_match_to_re'
 
 class FastIgnore
   class Error < StandardError; end
@@ -13,21 +16,17 @@ class FastIgnore
   include ::Enumerable
 
   # :nocov:
-  if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
-    require_relative 'fast_ignore/backports/delete_prefix_suffix'
-    using ::FastIgnore::Backports::DeletePrefixSuffix
-
-    require_relative 'fast_ignore/backports/dir_each_child'
-    using ::FastIgnore::Backports::DirEachChild
-  end
+  using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
+  using ::FastIgnore::Backports::DirEachChild if defined?(::FastIgnore::Backports::DirEachChild)
   # :nocov:
 
-  def initialize(relative: false, root: nil, follow_symlinks: false, **rule_set_builder_args)
+  def initialize(relative: false, root: nil, gitignore: :auto, follow_symlinks: false, **rule_set_builder_args)
     @relative = relative
-    @follow_symlinks = follow_symlinks
-    dir_pwd = Dir.pwd
-    @root = "#{::File.expand_path(root.to_s, dir_pwd)}/"
-    @rule_sets = ::FastIgnore::RuleSetBuilder.build(root: @root, **rule_set_builder_args)
+    @follow_symlinks_method = ::File.method(follow_symlinks ? :stat : :lstat)
+    @gitignore_enabled = gitignore
+    @loaded_gitignore_files = ::Set[''] if gitignore
+    @root = "#{::File.expand_path(root.to_s, Dir.pwd)}/"
+    @rule_sets = ::FastIgnore::RuleSetBuilder.build(root: @root, gitignore: gitignore, **rule_set_builder_args)
 
     freeze
   end
@@ -41,37 +40,54 @@ class FastIgnore
     each_recursive(root_from_pwd, '', &block)
   end
 
-  def directory?(path)
-    if @follow_symlinks
-      ::File.stat(path).directory?
-    else
-      ::File.lstat(path).directory?
-    end
-  end
-
-  def allowed?(path)
+  def allowed?(path, directory: nil, content: nil)
     full_path = ::File.expand_path(path, @root)
     return false unless full_path.start_with?(@root)
-    return false if directory?(full_path)
+    return false if directory.nil? ? @follow_symlinks_method.call(full_path).directory? : directory
 
     relative_path = full_path.delete_prefix(@root)
+    load_gitignore_recursive(relative_path) if @gitignore_enabled
+
     filename = ::File.basename(relative_path)
 
-    @rule_sets.all? { |r| r.allowed_recursive?(relative_path, false, filename) }
+    @rule_sets.all? { |r| r.allowed_recursive?(relative_path, false, full_path, filename, content) }
   rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
     false
   end
+  alias_method :===, :allowed?
 
   private
 
-  def each_recursive(parent_full_path, parent_relative_path, &block) # rubocop:disable Metrics/MethodLength
-    ::Dir.each_child(parent_full_path) do |filename|
+  def load_gitignore_recursive(path)
+    paths = []
+    while (path = ::File.dirname(path)) != '.'
+      paths << path
+    end
+
+    paths.reverse_each(&method(:load_gitignore))
+  end
+
+  def load_gitignore(parent_path, soft: true)
+    return if @loaded_gitignore_files.include?(parent_path)
+
+    ::FastIgnore::RuleSetBuilder.append_gitignore(
+      @rule_sets, project_root: @root, relative_path: parent_path + '.gitignore', soft: soft
+    )
+    @loaded_gitignore_files << parent_path
+  end
+
+  def each_recursive(parent_full_path, parent_relative_path, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    children = ::Dir.children(parent_full_path)
+
+    load_gitignore(parent_relative_path, soft: 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 = directory?(full_path)
+        dir = @follow_symlinks_method.call(full_path).directory?
 
-        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, dir, filename) }
+        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, dir, full_path, filename, nil) }
 
         if dir
           each_recursive(full_path + '/', relative_path + '/', &block)