fast_ignore 0.16.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88d6249cc842976d1b5c0e984816cfc260cc3edcbe4774ea4580e934bedcf925
-  data.tar.gz: 3ab13efc019bee9b5cadcb45f485021132f07787bce73d66bb9ef63b76bc51ca
+  metadata.gz: 88853f2613fe610772a13666845d500a4b377bbf5606e3fba3bd8842d66c17a2
+  data.tar.gz: c158117c0234816a067b3e68d7686e247bf18ea81e39b3c339fcf06ecc4026ae
 SHA512:
-  metadata.gz: 853124ae1ddf1fc599e8a422580ee84ff705907a70c7ece17db72502a4468ca0d5479f918c175f91dc1915c7cccb5ad4cd7eaa956adf2d7b0a5e2fa024821c3d
-  data.tar.gz: b90c827caa6c24c3491237ec5fb538b828b2daea879a4d94d6bc3ac4368807c7040bc0d6ea6405b8e9712483d00fddfb6d43e1a970786f374144a4d6165f59ee
+  metadata.gz: a409a69b31021dedca95858ebed16abb4a36efbb758067dcab41bd6cbeb988acf0a62d4324f31cbb68ba4787efca4564cfc51721a50dc710f3357923775cc6e2
+  data.tar.gz: 4f0e0a8f900d6c0d008850eb8899c1c4446914149697539b9f708620054b614b310305e83df8743a3d5fb558a82ac08f0d48e44450486ad5de966943916a6ac2

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+# 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.
+
 # v0.16.0
 - Entirely rewrite the way that git config files are read. previously it was just a regexp. now we actually parse git config files according to the same rules as git.
 - Add ruby 3 to the test matrix

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.
@@ -309,6 +359,7 @@ This is not required, and if FastIgnore does have to go to the filesystem for th
   (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).
+- git has a system-wide config file installed at `$(prefix)/etc/gitconfig`, where `prefix` is defined for git at install time. FastIgnore assumes that it will always be `/usr/local/etc/gitconfig`. if it's important your system config file is looked at, as that's where you have the core.excludesfile defined, use git's built-in way to override this by adding `export GIT_CONFIG_SYSTEM='/the/actual/location'` to your shell profile.
 - 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`

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/global_gitignore.rb

@@ -4,15 +4,23 @@ class FastIgnore
   module GlobalGitignore
     class << self
       def path(root:)
-        gitconfig_gitignore_path(::File.expand_path('.git/config', root)) ||
-          gitconfig_gitignore_path(::File.expand_path('~/.gitconfig')) ||
-          gitconfig_gitignore_path(xdg_config_path) ||
-          gitconfig_gitignore_path('/etc/gitconfig') ||
+        ignore_path = gitconfigs_gitignore_path(root) ||
           default_global_gitignore_path
+
+        ignore_path unless ignore_path.empty?
       end
 
       private
 
+      def gitconfigs_gitignore_path(root)
+        gitconfig_gitignore_path(repo_config_path(root)) ||
+          gitconfig_gitignore_path(global_config_path) ||
+          gitconfig_gitignore_path(default_user_config_path) ||
+          gitconfig_gitignore_path(system_config_path)
+      rescue ::FastIgnore::GitconfigParseError
+        ''
+      end
+
       def gitconfig_gitignore_path(config_path)
         return unless config_path
         return unless ::File.readable?(config_path)
@@ -26,24 +34,54 @@ class FastIgnore
         ::File.expand_path(ignore_path)
       end
 
-      def xdg_config_path
-        xdg_config_home? && ::File.expand_path('git/config', xdg_config_home)
+      def default_user_config_path
+        return if env('GIT_CONFIG_GLOBAL')
+
+        ::File.expand_path('git/config', default_config_home)
       end
 
       def default_global_gitignore_path
-        if xdg_config_home?
-          ::File.expand_path('git/ignore', xdg_config_home)
+        ::File.expand_path('git/ignore', default_config_home)
+      end
+
+      def repo_config_path(root)
+        ::File.expand_path('.git/config', root)
+      end
+
+      def global_config_path
+        ::File.expand_path(env('GIT_CONFIG_GLOBAL', '~/.gitconfig'))
+      end
+
+      def system_config_path
+        return if env?('GIT_CONFIG_NOSYSTEM')
+
+        ::File.expand_path(env('GIT_CONFIG_SYSTEM', '/usr/local/etc/gitconfig'))
+      end
+
+      def default_config_home
+        env('XDG_CONFIG_HOME', '~/.config')
+      end
+
+      def env(env_var, default = nil)
+        value = ::ENV[env_var]
+
+        if value && (not value.empty?)
+          value
         else
-          ::File.expand_path('~/.config/git/ignore')
+          default
         end
       end
 
-      def xdg_config_home
-        ::ENV['XDG_CONFIG_HOME']
-      end
+      def env?(env_var)
+        value = ::ENV[env_var]
 
-      def xdg_config_home?
-        xdg_config_home && (not xdg_config_home.empty?)
+        if value&.match?(/\A(yes|on|true|1)\z/i)
+          true
+        elsif !value || value.match?(/\A(no|off|false|0|)\z/i)
+          false
+        else
+          raise ::FastIgnore::GitconfigParseError
+        end
       end
     end
   end

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)
@@ -73,7 +73,7 @@ class FastIgnore
     end
 
     def build_from_root_gitignore_file(path)
-      return unless ::File.exist?(path)
+      return unless path && ::File.exist?(path)
 
       build_rule_set(::File.readlines(path), false, gitignore: true)
     end

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.0'
+  VERSION = '0.17.1'
 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.0
+  version: 0.17.1
 platform: ruby
 authors:
 - Dana Sherson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-09 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-rake
+  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-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -197,14 +211,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