fast_ignore 0.16.1 → 0.17.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7952045a743c12fa1963ffba7aa81a8ca3cc81aec40b0bfc9c0e6bb6424e9433
-  data.tar.gz: dcacd0bdd1873638156c9b2323263cf1ee7fc349b012f40c28caa4fe10d82f91
+  metadata.gz: 56582bce9b3eae6e761585c77846530bb96b287c2d6938dd7213c31b84567560
+  data.tar.gz: c2aabc49876831524acc8f14bc483aa8ec44ec715941a562bf4a6d5c4ac76b5c
 SHA512:
-  metadata.gz: 35c9fedb895b3e30632b29aab2eba3369ec6512bd6c5b9cfa563156c4c0c291b5c7854877aa4c8da063b54ed97a6f132c5d903622d2a6e2fc69c57c708150c33
-  data.tar.gz: ca894c9a8e11471d3c1f81f959862cd16a60db784898ef0d0e4da880e063257334fdf6aad061d95c23850c726ffde781076e6c248ebecfa808701d0731fbb125
+  metadata.gz: bc5e6b69f903bf2bb0beed6001bfa01bfa2f8b7e452eca9270884a38a1924649e336866d94085bd59ff72549d495d3857035227a7b3b0cf22859fd939c1e32ac
+  data.tar.gz: e286d5802e0a0857552b9c9dbe03999546817478f2960fdbd057709485a862e876e3e9328a12fafc34388ba1aad0893f10ea318e7bdff728fb3ef41facc1568a

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+# v0.17.2
+- Remove unnecessary backport code that was leftover when support for 2.4 was dropped
+- Tiny performance improvements from rubocop-performance's suggestions
+
+# v0.17.1
+- fix handling of backward character classes `[z-a]`
+  previously this raised a RegexpError, but git just considered it to be identical to `[z]`, now we match the git behaviour (but why would you ever do this?, i only found it because of the fuzz spec in the `leftovers` gem)
+
+# 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/file_root.rb

@@ -2,10 +2,6 @@
 
 class FastIgnore
   class FileRoot
-    # :nocov:
-    using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
-    # :nocov:
-
     def self.build(file_path, project_root)
       file_root = "#{::File.dirname(file_path)}/".delete_prefix(project_root)
 

data/lib/fast_ignore/gitconfig_parser.rb

@@ -100,9 +100,8 @@ class FastIgnore
 
     def on_branch?(branch_pattern)
       branch_pattern += '**' if branch_pattern.end_with?('/')
-      current_branch = ::File.readable?("#{root}/.git/HEAD") && ::File.read("#{root}/.git/HEAD").sub!(
-        %r{\Aref: refs/heads/}, ''
-      )
+      current_branch = ::File.readable?("#{root}/.git/HEAD") &&
+        ::File.read("#{root}/.git/HEAD").delete_prefix('ref: refs/heads/')
       return unless current_branch
 
       # goddamit git what does 'a pattern with standard globbing wildcards' mean

data/lib/fast_ignore/gitignore_include_rule_builder.rb

@@ -2,10 +2,6 @@
 
 class FastIgnore
   class GitignoreIncludeRuleBuilder < GitignoreRuleBuilder
-    # :nocov:
-    using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
-    # :nocov:
-
     def initialize(rule, file_path, expand_path_from = nil)
       super(rule, file_path)
 
@@ -15,7 +11,7 @@ class FastIgnore
     end
 
     def expand_rule_path
-      anchored! unless @s.match?(/\*/)
+      anchored! unless @s.match?(/\*/) # rubocop:disable Performance/StringInclude # it's StringScanner#match?
       return unless @s.match?(%r{(?:[~/]|\.{1,2}/|.*/\.\./)})
 
       dir_only! if @s.match?(%r{.*/\s*\z})

data/lib/fast_ignore/gitignore_rule_builder.rb

@@ -108,8 +108,8 @@ class FastIgnore
       unmatchable_rule! if @s.character_class_end?
 
       until @s.character_class_end?
+        next if process_character_class_range
         next if process_backslash
-        next @re.append_character_class_dash if @s.dash?
         next if @re.append_escaped(@s.character_class_literal)
 
         unmatchable_rule!
@@ -118,6 +118,22 @@ class FastIgnore
       @re.append_character_class_close
     end
 
+    def process_character_class_range
+      start = @s.character_class_range_start
+      return unless start
+
+      start = start.delete_prefix('\\')
+
+      @re.append_escaped(start)
+
+      finish = @s.character_class_range_end.delete_prefix('\\')
+
+      return true unless start < finish
+
+      @re.append_character_class_dash
+      @re.append_escaped(finish)
+    end
+
     def process_end
       blank! if nothing_emitted?
 

data/lib/fast_ignore/gitignore_rule_scanner.rb

@@ -46,12 +46,20 @@ class FastIgnore
       skip(/\?/)
     end
 
-    def dash?
-      skip(/-/)
+    def character_class_literal
+      matched if scan(/[^\]\\][^\]\\-]*(?!-)/)
     end
 
-    def character_class_literal
-      matched if scan(/[^\]\-\\]+/)
+    def character_class_range_start
+      matched if scan(/(\\.|[^\\\]])(?=-(\\.|[^\\\]]))/)
+    end
+
+    def character_class_range_end
+      # we already confirmed this was going to match
+      # with the lookahead in character_class_range_start
+      skip(/-/)
+      scan(/(\\.|[^\\\]])/)
+      matched
     end
 
     def literal

data/lib/fast_ignore/rule_builder.rb

@@ -3,10 +3,6 @@
 class FastIgnore
   module RuleBuilder
     class << self
-      # :nocov:
-      using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
-      # :nocov:
-
       def build(rule, allow, expand_path_with, file_root)
         if rule.delete_prefix!('#!:')
           shebang_rules(rule, allow, file_root)
@@ -23,7 +19,7 @@ class FastIgnore
         rule = ::FastIgnore::ShebangRule.new(pattern, allow, file_root&.shebang_path_pattern)
         return rule unless allow
 
-        rules = gitignore_rules('*/'.dup, allow, file_root)
+        rules = gitignore_rules(+'*/', allow, file_root)
         rules.pop # don't want the include all children one.
         rules << rule
         rules

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

@@ -2,10 +2,6 @@
 
 class FastIgnore
   class RuleSets
-    # :nocov:
-    using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
-    # :nocov:
-
     def initialize( # rubocop:disable Metrics/ParameterLists
       root:,
       ignore_rules: nil,
@@ -27,8 +23,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.include?("\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.2'
 end

data/lib/fast_ignore.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative './fast_ignore/backports'
-
 require 'set'
 require 'strscan'
 
@@ -24,11 +22,6 @@ class FastIgnore
 
   include ::Enumerable
 
-  # :nocov:
-  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, gitignore: :auto, follow_symlinks: false, **rule_set_builder_args)
     @relative = relative
     @follow_symlinks_method = ::File.method(follow_symlinks ? :stat : :lstat)
@@ -41,7 +34,7 @@ class FastIgnore
   end
 
   def each(&block)
-    return enum_for(:each) unless block_given?
+    return enum_for(:each) unless block
 
     dir_pwd = ::Dir.pwd
     root_from_pwd = @root.start_with?(dir_pwd) ? ".#{@root.delete_prefix(dir_pwd)}" : @root
@@ -49,19 +42,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 +81,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 +97,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.2
 platform: ruby
 authors:
 - Dana Sherson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-11 00:00:00.000000000 Z
+date: 2022-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,6 +100,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
@@ -181,7 +195,6 @@ files:
 - LICENSE.txt
 - README.md
 - lib/fast_ignore.rb
-- lib/fast_ignore/backports.rb
 - lib/fast_ignore/file_root.rb
 - lib/fast_ignore/gitconfig_parser.rb
 - lib/fast_ignore/gitignore_include_rule_builder.rb
@@ -211,14 +224,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Parse gitignore files, quickly

data/lib/fast_ignore/backports.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-class FastIgnore
-  module Backports
-    ruby_major, ruby_minor = ::RUBY_VERSION.split('.', 2)
-    unless ruby_major.to_i > 2 || ruby_major.to_i == 2 && ruby_minor.to_i > 5
-      module DirEachChild
-        refine ::Dir.singleton_class do
-          def children(path)
-            ::Dir.entries(path) - ['.', '..']
-          end
-        end
-      end
-
-      module DeletePrefixSuffix
-        refine ::String do
-          # delete_prefix!(prefix) -> self or nil
-          # Deletes leading prefix from str, returning nil if no change was made.
-          #
-          #   "hello".delete_prefix!("hel") #=> "lo"
-          #   "hello".delete_prefix!("llo") #=> nil
-          def delete_prefix!(str)
-            return unless start_with?(str)
-
-            slice!(0..(str.length - 1))
-            self
-          end
-
-          # delete_suffix!(suffix) -> self or nil
-          # Deletes trailing suffix from str, returning nil if no change was made.
-          #
-          #   "hello".delete_suffix!("llo") #=> "he"
-          #   "hello".delete_suffix!("hel") #=> nil
-          def delete_suffix!(str)
-            return unless end_with?(str)
-
-            slice!(-str.length..-1)
-            self
-          end
-
-          # delete_prefix(prefix) -> new_str click to toggle source
-          # Returns a copy of str with leading prefix deleted.
-          #
-          #   "hello".delete_prefix("hel") #=> "lo"
-          #   "hello".delete_prefix("llo") #=> "hello"
-          def delete_prefix(str)
-            s = dup
-            s.delete_prefix!(str)
-            s
-          end
-
-          # delete_suffix(suffix) -> new_str
-          # Returns a copy of str with trailing suffix deleted.
-          #
-          #   "hello".delete_suffix("llo") #=> "he"
-          #   "hello".delete_suffix("hel") #=> "hello"
-          def delete_suffix(str) # leftovers:allowed
-            s = dup
-            s.delete_suffix!(str)
-            s
-          end
-        end
-      end
-    end
-  end
-end