fast_ignore 0.17.0 → 0.17.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78cb85cea0888d67c91de09bd54ad644510167c993dc355d187593003d341393
-  data.tar.gz: fb1fda9c1675ee28f4a6ff23191f95c2dd6e497ca2a70c4791dc5dfb85baecd1
+  metadata.gz: c81120885ae42b4893295ecd66b501ed6962d2742adc2bd59433796ca0e41995
+  data.tar.gz: 0a15d4651cc7dfc7eeed32b919da373ebee92195385ff0cf22acd92751258b68
 SHA512:
-  metadata.gz: 10531a1d819b74fcc442ce7591be124430d3c55c55afbccb79ba295dd89c0e85e4a1a0a75b11996557057fa2f5dbad71e9284789143395d229e3abbbbd42ba3c
-  data.tar.gz: d0b07a2757c3b962a59973581234ec9e346717d24cdbd5443073c0fd14f840fb287419d63eeb31d4aa52d3fff2e1c0842cc119ed52e836cd55ed73bcd29a3fc7
+  metadata.gz: c38a391c2a05c7439899144c2af1db29281538c855a18be47725b3e92f8fc40ecca2f69f15a26508d5f63d7f45f998cbba73ac41feaa1541356daf20067b4ce9
+  data.tar.gz: 0e355b08fbb00c9cca020ac06b0062f73477a59f673f6b465bf71d11c0228889dbeeb487e8e519eeccd09afa84290681f65f75300695332b0a4e44ecbec1b445

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+# v0.17.4
+- Deprecated `follow_symlinks:`, it's inaccurately named and awkward.
+
+- Plus lots of refactoring that _should_ have no effect on behaviour
+- Some performance regression due to the deprecation logic. we'll improve more than we lost after the deprecations are gone entirely.
+
+# v0.17.3
+- Add fuzz tests, fix a couple more edge cases it revealed:
+  - `~not_a_user` will be considered literal rather than raising an error, `~a_user` will continue to be expanded to the home directory of `a_user` when used in an `argv_rules:` or `allowed?`
+  - an `include_rule:` with a trailing `/` was raising a FrozenError in some circumstances.
+
+# 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?`

data/README.md

@@ -166,19 +166,6 @@ When `relative: true`: FastIgnore#each will yield paths relative to the [`root:`
 FastIgnore.new(relative: true).to_a
 ```
 
-### `follow_symlinks: true`
-
-**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
-```
-
 ### `root:`
 
 **Default: Dir.pwd ($PWD, the current working directory)**

data/lib/fast_ignore/builders/gitignore.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Builders
+    module Gitignore
+      def self.build(rule, allow, expand_path_with: nil)
+        if allow
+          ::FastIgnore::GitignoreIncludeRuleBuilder.new(rule, expand_path_with: expand_path_with).build
+        else
+          ::FastIgnore::GitignoreRuleBuilder.new(rule, expand_path_with: expand_path_with).build
+        end
+      end
+    end
+  end
+end

data/lib/fast_ignore/builders/shebang.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Builders
+    module Shebang
+      def self.build(shebang, allow)
+        shebang.strip!
+        pattern = /\A#!.*\b#{::Regexp.escape(shebang)}\b/i
+        rule = ::FastIgnore::Matchers::ShebangRegexp.new(pattern, allow)
+        return rule unless allow
+
+        # also allow all directories in case they include a file with the matching shebang file
+        [::FastIgnore::Matchers::AllowAnyDir, rule]
+      end
+    end
+  end
+end

data/lib/fast_ignore/builders/shebang_or_gitignore.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Builders
+    module ShebangOrGitignore
+      def self.build(rule, allow, expand_path_with: nil)
+        if rule.delete_prefix!('#!:')
+          ::FastIgnore::Builders::Shebang.build(rule, allow)
+        else
+          ::FastIgnore::Builders::Gitignore.build(rule, allow, expand_path_with: expand_path_with)
+        end
+      end
+    end
+  end
+end

data/lib/fast_ignore/candidate.rb

@@ -0,0 +1,85 @@
+# frozen-string-literal: true
+
+class FastIgnore
+  class Candidate
+    class << self
+      def root
+        @root ||= new('/', nil, true, true, nil)
+      end
+    end
+
+    def initialize(full_path, filename, directory, exists, content)
+      @full_path = full_path
+      @filename = filename
+      (@directory = directory) unless directory.nil?
+      (@exists = exists) unless exists.nil?
+      (@first_line = content.slice(/.*/)) if content # we only care about the first line
+    end
+
+    def parent
+      @parent ||= ::FastIgnore::Candidate.new(::File.dirname(@full_path), nil, true, true, nil)
+    end
+
+    # use \0 because it can't be in paths
+    def key
+      @key ||= :"#{
+        "\0" if defined?(@directory) && @directory
+      }#{
+        @full_path
+      }\0#{
+        @first_line if defined?(@first_line)
+      }"
+    end
+
+    def relative_to(dir)
+      return unless @full_path.start_with?(dir)
+
+      ::FastIgnore::RelativeCandidate.new(@full_path.delete_prefix(dir), self)
+    end
+
+    def directory?
+      return @directory if defined?(@directory)
+
+      @directory = ::File.lstat(@full_path).directory?
+    rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENAMETOOLONG
+      @exists ||= false
+      @directory = false
+    end
+
+    def exists?
+      return @exists if defined?(@exists)
+
+      @exists = ::File.exist?(@full_path)
+    rescue ::Errno::EACCES, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
+      # :nocov: can't quite get this set up in a test
+      @exists = false
+      # :nocov:
+    end
+
+    def filename
+      @filename ||= ::File.basename(@full_path)
+    end
+
+    # how long can a shebang be?
+    # https://www.in-ulm.de/~mascheck/various/shebang/
+    def first_line # rubocop:disable Metrics/MethodLength
+      @first_line ||= begin
+        file = ::File.new(@full_path)
+        first_line = file.sysread(64)
+        if first_line.start_with?('#!')
+          first_line += file.readline unless first_line.include?("\n")
+          file.close
+          first_line
+        else
+          file.close
+          ''
+        end
+      rescue ::EOFError, ::SystemCallError
+        # :nocov:
+        file&.close
+        # :nocov:
+        ''
+      end
+    end
+  end
+end

data/lib/fast_ignore/gitconfig_parser.rb

@@ -55,7 +55,7 @@ class FastIgnore
           include_path = scan_value(file)
 
           value = ::FastIgnore::GitconfigParser.parse(
-            ::File.expand_path(include_path, ::File.dirname(path)),
+            PathExpander.expand_path(include_path, ::File.dirname(path)),
             root: root,
             nesting: nesting + 1
           )
@@ -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,26 +2,10 @@
 
 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)
+    def initialize(rule, expand_path_with: nil)
+      super
 
-      @parent_segments = []
       @negation = true
-      @expand_path_from = expand_path_from
-    end
-
-    def expand_rule_path
-      anchored! unless @s.match?(/\*/)
-      return unless @s.match?(%r{(?:[~/]|\.{1,2}/|.*/\.\./)})
-
-      dir_only! if @s.match?(%r{.*/\s*\z})
-      @s.string.replace(::File.expand_path(@s.rest))
-      @s.string.delete_prefix!(@expand_path_from)
-      @s.pos = 0
     end
 
     def negated!
@@ -29,74 +13,63 @@ class FastIgnore
     end
 
     def unmatchable_rule!
-      throw :abort_build, ::FastIgnore::UnmatchableRule
-    end
-
-    def nothing_emitted?
-      @re.empty? && @parent_segments.empty?
-    end
-
-    def emit_dir
-      anchored!
-
-      @parent_segments << @re
-      @re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+      throw :abort_build, ::FastIgnore::Matchers::Unmatchable
     end
 
     def emit_end
-      @dir_only || @re.append_end_dir_or_anchor
+      if @dir_only
+        @child_re = @re.dup
+        @re.append_end_anchor
+      else
+        @re.append_dir_or_end_anchor
+      end
+
       break!
     end
 
-    def parent_dir_re # rubocop:disable Metrics/MethodLength
-      segment_joins_count = @parent_segments.length
-      parent_prefix = if @file_path
-        segment_joins_count += @file_path.escaped_segments_length
+    def build_parent_dir_rules
+      return unless @negation
 
-        if @anchored
-          "\\A#{@file_path.escaped_segments_joined}"
-        else
-          "\\A#{@file_path.escaped_segments_joined}(?:.*/)?"
+      if @anchored
+        parent_pattern = @s.string.dup
+        if parent_pattern.sub!(%r{/[^/]+/?\s*\z}, '/')
+          ::FastIgnore::GitignoreIncludeRuleBuilder.new(parent_pattern).build_as_parent
         end
       else
-        prefix
+        [::FastIgnore::Matchers::AllowAnyDir]
       end
+    end
 
-      out = parent_prefix.dup
-      unless @parent_segments.empty?
-        out << '(?:'
-        out << @parent_segments.join('/(?:')
-        out << '/'
+    def build_child_file_rule # rubocop:disable Metrics/MethodLength
+      if @child_re.end_with?('/')
+        @child_re.append_many_non_dir.append_dir if @dir_only
+      else
+        @child_re.append_dir
       end
-      out << (')?' * segment_joins_count)
-      out
-    end
 
-    def build_parent_dir_rule
-      # Regexp::IGNORECASE = 1
-      ::FastIgnore::Rule.new(::Regexp.new(parent_dir_re, 1), true, anchored_or_file_path, true)
-    end
+      @child_re.prepend(prefix)
 
-    def build_child_file_rule
-      # Regexp::IGNORECASE = 1
-      ::FastIgnore::Rule.new(@re.append_dir.to_regexp, @negation, anchored_or_file_path, false)
+      if @negation
+        ::FastIgnore::Matchers::AllowPathRegexp.new(@child_re.to_regexp, @anchored, false)
+      else
+        ::FastIgnore::Matchers::IgnorePathRegexp.new(@child_re.to_regexp, @anchored, false)
+      end
     end
 
-    def build_rule
-      joined_re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
-      joined_re.append(@parent_segments.join('/'))
-      joined_re.append_dir unless @parent_segments.empty?
-      joined_re.append(@re)
-      @re = joined_re
+    def build_as_parent
+      anchored!
+      dir_only!
 
-      rules = [super, build_parent_dir_rule]
-      (rules << build_child_file_rule) if @dir_only
-      rules
+      catch :abort_build do
+        process_rule
+        build_rule(child_file_rule: false)
+      end
     end
 
-    def process_rule
-      expand_rule_path if @expand_path_from
-      super
+    def build_rule(child_file_rule: true)
+      @child_re ||= @re.dup # in case emit_end wasn't called
+
+      [super(), *build_parent_dir_rules, (build_child_file_rule if child_file_rule)].compact
     end
   end
 end

data/lib/fast_ignore/gitignore_rule_builder.rb

@@ -2,11 +2,11 @@
 
 class FastIgnore
   class GitignoreRuleBuilder # rubocop:disable Metrics/ClassLength
-    def initialize(rule, file_path)
-      @re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+    def initialize(rule, expand_path_with: nil)
+      @re = ::FastIgnore::PathRegexpBuilder.new
       @s = ::FastIgnore::GitignoreRuleScanner.new(rule)
 
-      @file_path = file_path
+      @expand_path_with = expand_path_with
       @negation = false
       @anchored = false
       @dir_only = false
@@ -49,6 +49,11 @@ class FastIgnore
       @re.append_dir
     end
 
+    def emit_any_dir
+      anchored!
+      @re.append_any_dir
+    end
+
     def emit_end
       @re.append_end_anchor
       break!
@@ -60,11 +65,22 @@ class FastIgnore
       @re.append_escaped(@s.next_character) || unmatchable_rule!
     end
 
-    def process_star_end_after_slash
-      return true unless @s.star_end?
-
-      @re.append_many_non_dir
-      emit_end
+    def process_star_end_after_slash # rubocop:disable Metrics/MethodLength
+      if @s.star_end?
+        @re.append_many_non_dir
+        emit_end
+      elsif @s.two_star_end?
+        break!
+      elsif @s.star_slash_end?
+        @re.append_many_non_dir
+        dir_only!
+        emit_end
+      elsif @s.two_star_slash_end?
+        dir_only!
+        break!
+      else
+        true
+      end
     end
 
     def process_slash
@@ -76,7 +92,7 @@ class FastIgnore
       process_star_end_after_slash
     end
 
-    def process_two_stars # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def process_two_stars # rubocop:disable Metrics/MethodLength
       return unless @s.two_stars?
       return break! if @s.end?
 
@@ -90,8 +106,7 @@ class FastIgnore
           if nothing_emitted?
             never_anchored!
           else
-            @re.append_any_dir
-            anchored!
+            emit_any_dir
           end
           process_star_end_after_slash
         end
@@ -108,8 +123,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 +133,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?
 
@@ -125,6 +156,7 @@ class FastIgnore
     end
 
     def process_rule # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      expand_rule_path! if @expand_path_with
       anchored! if @s.slash?
 
       catch :break do
@@ -143,28 +175,24 @@ class FastIgnore
       end
     end
 
-    def prefix # rubocop:disable Metrics/MethodLength
-      out = ::FastIgnore::GitignoreRuleRegexpBuilder.new
-      if @file_path
-        out.append_start_anchor.append(@file_path.escaped)
-        out.append_any_dir unless @anchored
+    def prefix
+      out = ::FastIgnore::PathRegexpBuilder.new
+
+      if @anchored
+        out.append_start_anchor
       else
-        if @anchored
-          out.append_start_anchor
-        else
-          out.append_start_dir_or_anchor
-        end
+        out.append_dir_or_start_anchor
       end
       out
     end
 
     def build_rule
       @re.prepend(prefix)
-      ::FastIgnore::Rule.new(@re.to_regexp, @negation, anchored_or_file_path, @dir_only)
-    end
-
-    def anchored_or_file_path
-      @anchored || @file_path
+      if @negation
+        ::FastIgnore::Matchers::AllowPathRegexp.new(@re.to_regexp, @anchored, @dir_only)
+      else
+        ::FastIgnore::Matchers::IgnorePathRegexp.new(@re.to_regexp, @anchored, @dir_only)
+      end
     end
 
     def build
@@ -178,5 +206,16 @@ class FastIgnore
         build_rule
       end
     end
+
+    def expand_rule_path!
+      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})
+
+      @s.string.replace(PathExpander.expand_path(@s.rest, @expand_path_with))
+      @s.string.delete_prefix!(@expand_path_with)
+      @s.pos = 0
+    end
   end
 end

data/lib/fast_ignore/gitignore_rule_group.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+require 'set'
+
+class FastIgnore
+  class GitignoreRuleGroup < ::FastIgnore::RuleGroup
+    def initialize(root)
+      @root = root
+      @loaded_paths = Set[root]
+
+      super([
+        ::FastIgnore::Patterns.new('.git', root: '/'),
+        ::FastIgnore::Patterns.new(from_file: ::FastIgnore::GlobalGitignore.path(root: root), root: root),
+        ::FastIgnore::Patterns.new(from_file: "#{root}.git/info/exclude", root: root),
+        ::FastIgnore::Patterns.new(from_file: "#{root}.gitignore", root: root)
+      ], false)
+    end
+
+    def add_gitignore(dir)
+      return if @loaded_paths.include?(dir)
+
+      @loaded_paths << dir
+      matcher = ::FastIgnore::Patterns.new(from_file: "#{dir}.gitignore").build_matchers(allow: false)
+      @matchers += matcher unless !matcher || matcher.empty?
+    end
+
+    def add_gitignore_to_root(path)
+      add_gitignore(path) until @loaded_paths.include?(path = "#{::File.dirname(path)}/")
+    end
+  end
+end

data/lib/fast_ignore/gitignore_rule_scanner.rb

@@ -42,16 +42,36 @@ class FastIgnore
       skip(/\*\s*\z/)
     end
 
+    def two_star_end?
+      skip(/\*{2,}\s*\z/)
+    end
+
+    def star_slash_end?
+      skip(%r{\*/\s*\z})
+    end
+
+    def two_star_slash_end?
+      skip(%r{\*{2,}/\s*\z})
+    end
+
     def question_mark?
       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/matchers/allow_any_dir.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Matchers
+    module AllowAnyDir
+      class << self
+        def squash_id
+          :allow_any_dir
+        end
+
+        def dir_only?
+          true
+        end
+
+        def file_only?
+          false
+        end
+
+        def squash(_)
+          self
+        end
+
+        def weight
+          0
+        end
+
+        # :nocov:
+        def inspect
+          '#<AllowAnyDir>'
+        end
+        # :nocov:
+
+        def match?(_)
+          :allow
+        end
+      end
+    end
+  end
+end

data/lib/fast_ignore/matchers/allow_path_regexp.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Matchers
+    class AllowPathRegexp
+      attr_reader :dir_only
+      alias_method :dir_only?, :dir_only
+      undef :dir_only
+
+      attr_reader :squash_id
+      attr_reader :rule
+
+      def initialize(rule, squashable, dir_only)
+        @rule = rule
+        @dir_only = dir_only
+        @squashable = squashable
+        @squash_id = squashable ? :allow : object_id
+
+        freeze
+      end
+
+      def squash(list)
+        self.class.new(::Regexp.union(list.map(&:rule)), @squashable, @dir_only)
+      end
+
+      def file_only?
+        false
+      end
+
+      def weight
+        1
+      end
+
+      # :nocov:
+      def inspect
+        "#<AllowPathRegexp #{'dir_only ' if @dir_only}#{@rule.inspect}>"
+      end
+      # :nocov:
+
+      def match?(candidate)
+        :allow if @rule.match?(candidate.relative_path)
+      end
+    end
+  end
+end