fast_ignore 0.11.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f467113b0ee03faf028758ac176c59b3e51465684f8ffe144d432ba75133c10f
-  data.tar.gz: 2f6f0ce0babec00977a55595baa7ec806d7a9a3f1fec86df46f29475b41238cc
+  metadata.gz: f96030c8670a5d709139689212b3a78a0eb0b5266cbd0057954863ae89e11745
+  data.tar.gz: a2815ec68f6c367a4450efce8799aa359adeee1ad1aaa971b589cd8612ddbb61
 SHA512:
-  metadata.gz: 3a7698e54ab0897b6b50c8638d41f3243bd3ba4ced559a5c7e01f6d365b6fb875b906a1924e96641572815748479eb793dfabc91da6f3bec62115f98ff39a392
-  data.tar.gz: 7e8b85ff838d04d1c16cd3eca5a480d6948342a07667760782840b0e36a706c02db2bb4e09e3370b3ccc1cdc2f38f9e893707c9f2128652a8a4aae4cdb8dd3d0
+  metadata.gz: 5c22c6c79a6605473156a041d5ddb5b81f943605dc4360dd8577acd56718c928c106e044169b13bc73c7e884ffcc5516c7a6b5d6134fee9aaa4aa73d0178b791
+  data.tar.gz: 1d165e44b50d9b1c301c5cad8ff3c443bfb2f9134be09e28a4e90539c960a269083485f6ff30bc6df6e2ec82347630187ebf0082cd2d06ba7416e9c70f37ea6f

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+# v0.15.0
+- fixed a handful of character class edge cases to match git behavior
+  - mostly ranges with - or / as one end of the range
+- major refactoring of the regexp builder that shouldn't have any behaviour implications but should make development easier (e.g. seeing those unhandled edge cases).
+- improved speed of repos with many sub-gitignore files
+- mentioned submodules & sparse checkout in the readme as yet another thing git does that this project doesn't because submodule details are hidden in the git index.
+
+# v0.14.0
+- significant performance improvements ~50% faster
+- add `FastIgnore#to_proc` for no good reason
+
+# 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.

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.
@@ -14,12 +15,15 @@ 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
-- supports all gitignore rule patterns
+- 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_files:`)
-- supports an expansion of include patterns, matching expanded paths (`argv_rules:`)
-- supports matching by shebang rather than filename for extensionless files: `#!:`
+- 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 global gitignore file mentioned in your git config
 
 ## Installation
 
@@ -46,22 +50,26 @@ 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 file is allowed, use
+To check if a single path is allowed, use
 ```ruby
 FastIgnore.new.allowed?('relative/path')
 FastIgnore.new.allowed?('./relative/path')
@@ -69,7 +77,9 @@ FastIgnore.new.allowed?('/absolute/path')
 FastIgnore.new.allowed?('~/home/path')
 ```
 
-This is aliased as `===` so you can use the FastIgnore object in case statements.
+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
@@ -77,18 +87,34 @@ when FastIgnore.new
 end
 ```
 
-It's recommended to memoize the FastIgnore.new object somehow to avoid having to parse the gitignore file repeatedly.
+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.each will yield full paths. To yield paths relative to the current working directory, or if 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
@@ -96,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
@@ -109,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, even as a default value.**
+
 ### `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
@@ -146,84 +189,110 @@ FastIgnore.new(ignore_rules: ['.git', '.gitkeep']).to_a
 FastIgnore.new(ignore_rules: ".git\n.gitkeep").to_a
 ```
 
-### `include_files:` and `include_rules:`
+These rules use the [`root:`](#root) argument to resolve rules containing `/`.
 
-Building on the gitignore format, FastIgnore also accepts a list of allowed or included files.
+### `include_files:`
 
-```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.
+**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.
+
+```ruby
+FastIgnore.new(include_files: 'my_include_file').to_a
+FastIgnore.new(include_files: ['/absolute/include/file', './relative/include/file']).to_a
+```
+
+Missing files will raise an `Errno::ENOENT` error.
+
+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
 ```
 
-These can be passed either as files or as an array or string rules
+**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_files: '/absolute/path/to/my/include/file', gitignore: false).to_a
 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
-
-To match extensionless files by shebang/hashbang/etc:
+Sometimes you need to match files by their shebang/hashbang/etc rather than their path or filename
 
-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?
 
@@ -233,29 +302,39 @@ FastIgnore.new.allowed?('relative/path', directory: false, content: "#!/usr/bin/
 ```
 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.
+## 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.
 
-  (It does handle changing the current working directory between `FastIgnore#allowed?` calls.)
-
-## Development
-
-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`.
+  (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).
+- 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`
+  - Deleted files whose deletions haven't been committed will be returned by `git ls-files`, but not by FastIgnore
+  - On a case insensitive file system, with files that differ only by case, `git ls-files` will include all case variations, while FastIgnore will only include whichever variation git placed in the file system.
+  - FastIgnore is unaware of submodules and just treats them like regular directories. For example: `git ls-files --recurse-submodules` won't use the parent repo's gitignore on a submodule, while FastIgnore doesn't know it's a submodule and will.
+  - FastIgnore will only return the files actually on the file system when using `git sparse-checkout`.
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/robotdana/fast_ignore.
 
+Some tools that may help:
+
+- `bin/setup`: install development dependencies
+- `bundle exec rspec`: run all tests
+- `bundle exec rake`: run all tests and linters
+- `bin/console`: open a `pry` console with everything required for experimenting
+- `bin/ls [argv_rules]`: the equivalent of `git ls-files`
+- `bin/prof/ls [argv_rules]`: ruby-prof report for `bin/ls`
+- `bin/prof/parse [argv_rules]`: ruby-prof report for parsing root and global gitignore files and any arguments.
+- `bin/time [argv_rules]`: the average time for 30 runs of `bin/ls`<br>
+  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.
+- `bin/compare`: compare the speed and output of FastIgnore and `git ls-files`.
+  (suppressing differences that are because of known [limitations](#limitations))
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/fast_ignore.rb

@@ -2,12 +2,20 @@
 
 require_relative './fast_ignore/backports'
 
-require_relative './fast_ignore/rule_set_builder'
-require_relative './fast_ignore/rule_builder'
+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'
-require_relative './fast_ignore/fn_match_to_re'
 
 class FastIgnore
   class Error < StandardError; end
@@ -19,11 +27,13 @@ class FastIgnore
   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
+    @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, **rule_set_builder_args)
+    @rule_sets = ::FastIgnore::RuleSets.new(root: @root, gitignore: gitignore, **rule_set_builder_args)
 
     freeze
   end
@@ -31,7 +41,7 @@ class FastIgnore
   def each(&block)
     return enum_for(:each) unless block_given?
 
-    dir_pwd = Dir.pwd
+    dir_pwd = ::Dir.pwd
     root_from_pwd = @root.start_with?(dir_pwd) ? ".#{@root.delete_prefix(dir_pwd)}" : @root
 
     each_recursive(root_from_pwd, '', &block)
@@ -40,35 +50,53 @@ class FastIgnore
   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.nil? ? directory?(full_path) : directory
+    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, full_path, filename, content) }
+    @rule_sets.allowed_recursive?(relative_path, full_path, filename, content)
   rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
     false
   end
   alias_method :===, :allowed?
 
+  def to_proc
+    method(:allowed?).to_proc
+  end
+
   private
 
-  def directory?(path)
-    if @follow_symlinks
-      ::File.stat(path).directory?
-    else
-      ::File.lstat(path).directory?
+  def load_gitignore_recursive(path)
+    paths = []
+    while (path = ::File.dirname(path)) != '.'
+      paths << path
     end
+
+    paths.reverse_each(&method(:load_gitignore))
   end
 
-  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(parent_path, check_exists: true)
+    return if @loaded_gitignore_files.include?(parent_path)
+
+    @rule_sets.append_subdir_gitignore(relative_path: parent_path + '.gitignore', check_exists: check_exists)
+
+    @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, 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 = directory?(full_path)
+        dir = @follow_symlinks_method.call(full_path).directory?
 
-        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, dir, full_path, filename, nil) }
+        next unless @rule_sets.allowed_unrecursive?(relative_path, dir, full_path, filename)
 
         if dir
           each_recursive(full_path + '/', relative_path + '/', &block)