fast_ignore 0.10.2 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dd945c76bf226766ac86086faf839eac44c4c0cce452e2a3a44e7c47964b7f5
-  data.tar.gz: a72de31878713db71c94aa8067c87b807f19833eb008a1a6d6e673fcdeff5a7a
+  metadata.gz: 05f6139deefedc14e0c58acd66909aa25af5240a83e67a6463eacedd6cec9eb3
+  data.tar.gz: c6becf91ea8bc9ccf0524309c5cad1e01485c4e2324222f231ade33855c65528
 SHA512:
-  metadata.gz: cff75a6418ecc958f2a839b9617554e3857763611248063aef27ec244dd0d1b433d61b81bfdb85a74dd8497fea8599f146ae723fd76023aef72285f53a620ecd
-  data.tar.gz: 39aeceb2cd078c8b873019b9763eccb01450e408a24c3fb04005f9451879e1a125bcd73f26a1c4e67e6c999e7d6d0f78b4a1b41abbc0a2650ec36bb1ac7adde6
+  metadata.gz: cca040e6401d0c412498dff47b460ba7a19d5c9cb810cc205151a56b9db959a88ea3c4137610537bda43c5520611b1711abc8124b0ab98dd6bda261de9638588
+  data.tar.gz: a3fe257c77f8350c2dde1bcfcde01293b5af87b5d6b627b4e44555b3b6a45154c3d567d1e68f8f03520d21e28e78eda439e92b7a8b5b2d0b43b6f2a23a2f5ae4

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+# 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.
+
 # 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

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 global gitignore file mentioned in your git config
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -36,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')
@@ -59,25 +77,44 @@ 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 then puts my_path
+when FastIgnore.new
+  puts(my_path)
 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
@@ -85,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
@@ -98,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
@@ -135,103 +189,150 @@ 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.
-```
-
-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
+**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
+```
+
+**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.
-
-## 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.
-  So don't do that.
+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.
 
-  (It does handle changing the current working directory between `FastIgnore#allowed?` calls.)
+### optimising #allowed?
 
-## Development
+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.
 
-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.
+## 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.
 
-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).
+  (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`
+  - 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.
 
 ## 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,10 +2,15 @@
 
 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/rule'
+require_relative './fast_ignore/unmatchable_rule'
 require_relative './fast_ignore/shebang_rule'
 
 class FastIgnore
@@ -14,20 +19,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
+    @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
@@ -35,44 +37,62 @@ 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)
   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, full_path, filename) }
+    @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 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, 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) }
+        next unless @rule_sets.allowed_unrecursive?(relative_path, dir, full_path, filename)
 
         if dir
           each_recursive(full_path + '/', relative_path + '/', &block)