GlobGitignore doesn't preprocess patterns

.spellr_wordlists/english.txt

@@ -136,13 +136,15 @@ torvolds
 tsx
 ttributes
 txt
+umc
 unanchorable
 unc
 unexpandable
 unfuck
 unnegated
 unrecursive
 unstaged
+unstub
 untr
 upcase
 urrent

lib/path_list/autoloader.rb

@@ -19,7 +19,7 @@ def autoload(klass)
       def class_from_path(path)
         name = ::File.basename(path).delete_suffix('.rb')
 
-        if name == 'version' || name == 'expandable_path'
+        if name == 'version' || name == 'scanner'
           name.upcase
         else
           name.gsub(/(?:^|_)(\w)/, &:upcase).delete('_')

lib/path_list/candidate.rb

@@ -4,6 +4,27 @@ class PathList
   # @api private
   # The object that gets passed to all {PathList::Matcher} subclasses #match
   class Candidate
+    # :nocov:
+    # https://github.com/jruby/jruby/issues/8018
+    # ftype follows symlinks on jruby on windows.
+    if ::RUBY_PLATFORM == 'java' && ::RbConfig::CONFIG['host_os'].match?(/mswin|mingw/)
+      # :nodoc:
+      module FileFtypeFix
+        refine ::File do
+          # :nodoc:
+          def ftype(path)
+            if ::File.symlink?(path)
+              'link'
+            else
+              super
+            end
+          end
+        end
+      end
+      using FileFtypeFix
+    end
+    # :nocov:
+
     attr_reader :full_path
 
     # @param full_path [String] resolved absolute path
@@ -105,23 +126,6 @@ def shebang
 
     private
 
-    # :nocov:
-    # https://github.com/jruby/jruby/issues/8018
-    # ftype follows symlinks on jruby on windows.
-    if ::RUBY_PLATFORM == 'java' && ::RbConfig::CONFIG['host_os'].match?(/mswin|mingw/)
-      refine ::File do
-        # :nodoc:
-        def ftype(path)
-          if ::File.symlink?(path)
-            'link'
-          else
-            super
-          end
-        end
-      end
-    end
-    # :nocov:
-
     def ftype
       return @ftype if @ftype
 

lib/path_list/canonical_path.rb

@@ -10,20 +10,23 @@ class << self
       class_eval <<~RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
         def case_insensitive?
           #{
-            pwd = ::Dir.pwd
-            pwd_swapcase = pwd.swapcase
-            # :nocov:
-            # if the current directory has no casing differences
-            # (maybe because it's at /)
-            # then:
-            if pwd == pwd_swapcase
+            test_dir = ::Dir.pwd
+            test_dir_swapcase = test_dir.swapcase
+
+            if test_dir == test_dir_swapcase
+              # :nocov:
+              # this is copied into the canonical_path_spec to be tested there.
+              # if the current directory has no casing differences
+              # (maybe because it's at /)
+              # then:
               require 'tmpdir'
-              pwd = ::File.write(::Dir.mktmpdir + '/case_test', '')
-              pwd_swapcase = pwd.swapcase
+              test_file = ::Dir.mktmpdir + '/case_test'
+              ::File.write(test_file, '')
+              ::File.exist?(test_file.swapcase)
+              # :nocov:
+            else
+              ::File.identical?(test_dir, test_dir_swapcase)
             end
-            # :nocov:
-
-            ::File.identical?(pwd, pwd_swapcase)
           }
         end
       RUBY

lib/path_list/pattern_parser/gitignore.rb

@@ -15,12 +15,14 @@ class PatternParser
     class Gitignore
       Autoloader.autoload(self)
 
+      SCANNER = RuleScanner
+
       # @api private
       # @param pattern [String]
       # @param polarity [:ignore, :allow]
       # @param root [String]
       def initialize(pattern, polarity, root)
-        @s = RuleScanner.new(pattern)
+        @s = self.class::SCANNER.new(pattern)
         @default_polarity = polarity
         @rule_polarity = polarity
         @root = root
@@ -51,9 +53,7 @@ def implicit_matcher
       private
 
       def prepare_regexp_builder
-        @re = if @root.nil?
-          TokenRegexp::Path.new([:start_anchor])
-        elsif @root.end_with?('/')
+        @re = if @root.end_with?('/')
           TokenRegexp::Path.new_from_path(@root, [:any_dir])
         else
           TokenRegexp::Path.new_from_path(@root, [:dir, :any_dir])
@@ -117,12 +117,13 @@ def append_string(string)
       end
 
       def emit_end
+        @re.remove_trailing_dir
         append_part :end_anchor
         break!
       end
 
-      def process_backslash
-        return unless @s.backslash?
+      def process_escape
+        return unless @s.escape?
 
         if @re.append_string(@s.next_character)
           emitted!
@@ -142,7 +143,7 @@ def process_character_class
 
         until @s.character_class_end?
           next if process_character_class_range
-          next if process_backslash
+          next if process_escape
           next if append_string(@s.character_class_literal)
 
           unmatchable_rule!
@@ -158,11 +159,9 @@ def process_character_class_range
         start = @s.character_class_range_start
         return unless start
 
-        start = start.delete_prefix('\\')
-
         append_string(start)
 
-        finish = @s.character_class_range_end.delete_prefix('\\')
+        finish = @s.character_class_range_end
 
         return true unless start < finish
 
@@ -184,31 +183,39 @@ def process_rule
         catch :abort_build do
           blank! if @s.hash?
           negated! if @s.exclamation_mark?
-          prepare_regexp_builder
-          anchored! if !@anchored && @s.slash?
+          process_first_characters
 
           catch :break do
             loop do
-              next if process_backslash
-              next unmatchable_rule! if @s.star_star_slash_slash?
-              next append_part(:any) && dir_only! if @s.star_star_slash_end?
-              next append_part(:any_dir) && anchored! if @s.star_star_slash?
-              next unmatchable_rule! if @s.slash_slash?
-              next append_part(:dir) && append_part(:any) && anchored! if @s.slash_star_star_end?
-              next append_part(:any_non_dir) if @s.star?
-              next dir_only! if @s.slash_end?
-              next append_part(:dir) && anchored! if @s.slash?
-              next append_part(:one_non_dir) if @s.question_mark?
-              next if process_character_class
-              next if append_string(@s.literal)
-              next if append_string(@s.significant_whitespace)
-
-              process_end
+              process_next_characters
             end
           end
         end
       end
 
+      def process_first_characters
+        prepare_regexp_builder
+        anchored! if !@anchored && @s.slash?
+      end
+
+      def process_next_characters
+        return if process_escape
+        return unmatchable_rule! if @s.star_star_slash_slash?
+        return append_part(:any) && dir_only! if @s.star_star_slash_end?
+        return append_part(:any_dir) && anchored! if @s.star_star_slash?
+        return unmatchable_rule! if @s.slash_slash?
+        return append_part(:dir) && append_part(:any) && anchored! if @s.slash_star_star_end?
+        return append_part(:any_non_dir) if @s.star?
+        return dir_only! if @s.slash_end?
+        return append_part(:dir) && anchored! if @s.slash?
+        return append_part(:one_non_dir) if @s.question_mark?
+        return if process_character_class
+        return if append_string(@s.literal)
+        return if append_string(@s.significant_whitespace)
+
+        process_end
+      end
+
       def build_matcher
         @main_re ||= @re.dup.compress
 

lib/path_list/pattern_parser/gitignore/rule_scanner.rb

@@ -27,13 +27,53 @@ def slash?
           skip(%r{/})
         end
 
+        # @return [String, nil]
+        def root_end
+          matched if scan(%r{/\s*\z})
+        end
+
+        # @return [String, nil]
+        def root
+          matched if scan(%r{/})
+        end
+
+        # @return [String, nil]
+        def home_slash_end
+          self[1] if scan(%r{(~[^/]*)/\s*\z})
+        end
+
+        # @return [String, nil]
+        def home_slash_or_end
+          self[1] if scan(%r{(~[^/]*)(?:/|\s*\z)})
+        end
+
+        # @return [Boolean]
+        def dot_slash_or_end?
+          skip(%r{\.(?:/|\s*\z)})
+        end
+
+        # @return [Boolean]
+        def dot_slash_end?
+          skip(%r{\./\s*\z})
+        end
+
+        # @return [Boolean]
+        def dot_dot_slash_end?
+          skip(%r{\.\./\s*\z})
+        end
+
+        # @return [Boolean]
+        def dot_dot_slash_or_end?
+          skip(%r{\.\.(?:/|\s*\z)})
+        end
+
         # @return [Boolean]
         def slash_end?
           skip(%r{/\s*\z})
         end
 
         # @return [Boolean]
-        def backslash?
+        def escape?
           skip(/\\/)
         end
 
@@ -84,7 +124,7 @@ def character_class_literal
 
         # @return [String, nil]
         def character_class_range_start
-          matched if scan(/(\\.|[^\\\]])(?=-(\\.|[^\\\]]))/)
+          matched.delete_prefix('\\') if scan(/(\\.|[^\\\]])(?=-(\\.|[^\\\]]))/)
         end
 
         # @return [String, nil]
@@ -93,7 +133,7 @@ def character_class_range_end
           # with the lookahead in character_class_range_start
           skip(/-/)
           scan(/(\\.|[^\\\]])/)
-          matched
+          matched.delete_prefix('\\')
         end
 
         # @return [String, nil]