fast_ignore 0.16.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7952045a743c12fa1963ffba7aa81a8ca3cc81aec40b0bfc9c0e6bb6424e9433
-  data.tar.gz: dcacd0bdd1873638156c9b2323263cf1ee7fc349b012f40c28caa4fe10d82f91
+  metadata.gz: 78cb85cea0888d67c91de09bd54ad644510167c993dc355d187593003d341393
+  data.tar.gz: fb1fda9c1675ee28f4a6ff23191f95c2dd6e497ca2a70c4791dc5dfb85baecd1
 SHA512:
-  metadata.gz: 35c9fedb895b3e30632b29aab2eba3369ec6512bd6c5b9cfa563156c4c0c291b5c7854877aa4c8da063b54ed97a6f132c5d903622d2a6e2fc69c57c708150c33
-  data.tar.gz: ca894c9a8e11471d3c1f81f959862cd16a60db784898ef0d0e4da880e063257334fdf6aad061d95c23850c726ffde781076e6c248ebecfa808701d0731fbb125
+  metadata.gz: 10531a1d819b74fcc442ce7591be124430d3c55c55afbccb79ba295dd89c0e85e4a1a0a75b11996557057fa2f5dbad71e9284789143395d229e3abbbbd42ba3c
+  data.tar.gz: d0b07a2757c3b962a59973581234ec9e346717d24cdbd5443073c0fd14f840fb287419d63eeb31d4aa52d3fff2e1c0842cc119ed52e836cd55ed73bcd29a3fc7

data/CHANGELOG.md

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

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.x & 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.

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)

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.16.1'
+  VERSION = '0.17.0'
 end

data/lib/fast_ignore.rb

@@ -49,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?
 
@@ -77,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)
@@ -93,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.16.1
+  version: 0.17.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-11 00:00:00.000000000 Z
+date: 2022-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -211,7 +211,7 @@ 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:
   - - ">="