fast_ignore 0.14.0 → 0.16.0

data/lib/fast_ignore/gitignore_rule_builder.rb

@@ -2,210 +2,180 @@
 
 class FastIgnore
   class GitignoreRuleBuilder # rubocop:disable Metrics/ClassLength
-    def initialize(rule, negation, dir_only, file_path, allow) # rubocop:disable Metrics/MethodLength
-      @re = ::String.new
-      @segment_re = ::String.new
-      @allow = allow
-      if @allow
-        @segments = 0
-        @parent_re = ::String.new
-      end
-
-      @s = ::StringScanner.new(rule)
+    def initialize(rule, file_path)
+      @re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+      @s = ::FastIgnore::GitignoreRuleScanner.new(rule)
 
-      @dir_only = dir_only
-      @file_path = (file_path if file_path && !file_path.empty?)
-      @negation = negation
+      @file_path = file_path
+      @negation = false
       @anchored = false
-      @trailing_stars = false
+      @dir_only = false
     end
 
-    def process_escaped_char
-      @segment_re << ::Regexp.escape(@s.matched[1]) if @s.scan(/\\./)
+    def break!
+      throw :break
     end
 
-    def process_character_class
-      return unless @s.skip(/\[/)
+    def blank!
+      throw :abort_build, []
+    end
 
-      @segment_re << '['
-      process_character_class_body(false)
+    def unmatchable_rule!
+      throw :abort_build, []
     end
 
-    def process_negated_character_class
-      return unless @s.skip(/\[\^/)
+    def negated!
+      @negation = true
+    end
 
-      @segment_re << '[^'
-      process_character_class_body(true)
+    def anchored!
+      @anchored ||= true
     end
 
-    def unmatchable_rule!
-      throw :unmatchable_rule, (
-        @allow ? ::FastIgnore::UnmatchableRule : []
-      )
+    def never_anchored!
+      @anchored = :never
     end
 
-    def process_character_class_end
-      return unless @s.skip(/\]/)
+    def dir_only!
+      @dir_only = true
+    end
 
-      unmatchable_rule! unless @has_characters_in_group
+    def nothing_emitted?
+      @re.empty?
+    end
 
-      @segment_re << ']'
+    def emit_dir
+      anchored!
+      @re.append_dir
     end
 
-    def process_character_class_body(negated_class) # rubocop:disable Metrics/MethodLength
-      @has_characters_in_group = false
-      until process_character_class_end
-        if @s.eos?
-          unmatchable_rule!
-        elsif process_escaped_char
-          @has_characters_in_group = true
-        elsif @s.skip(%r{/})
-          next unless negated_class
-
-          @has_characters_in_group = true
-          @segment_re << '/'
-        elsif @s.skip(/-/)
-          @has_characters_in_group = true
-          @segment_re << '-'
-        else @s.scan(%r{[^/\]\-]+})
-             @has_characters_in_group = true
-             @segment_re << ::Regexp.escape(@s.matched)
-        end
-      end
+    def emit_end
+      @re.append_end_anchor
+      break!
     end
 
-    def process_star_star_slash
-      return unless @s.skip(%r{\*{2,}/})
+    def process_backslash
+      return unless @s.backslash?
 
-      if @allow
-        if @segment_re.empty?
-          @parent_re << '.*'
-        else
-          process_slash_allow('.*')
-        end
-      end
-      process_slash('(?:.*/)?')
+      @re.append_escaped(@s.next_character) || unmatchable_rule!
     end
 
-    def process_star_slash
-      return unless @s.skip(%r{\*/})
+    def process_star_end_after_slash
+      return true unless @s.star_end?
 
-      process_slash_allow('[^/]*/') if @allow
-      process_slash('[^/]*/')
+      @re.append_many_non_dir
+      emit_end
     end
 
-    def process_no_star_slash
-      return unless @s.skip(%r{/})
+    def process_slash
+      return unless @s.slash?
+      return dir_only! if @s.end?
+      return unmatchable_rule! if @s.slash?
 
-      process_slash_allow('/') if @allow
-      process_slash('/')
+      emit_dir
+      process_star_end_after_slash
     end
 
-    def process_slash(append)
-      @re << @segment_re
-      @re << append
-      @segment_re.clear
-      @anchored = true
-    end
+    def process_two_stars # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      return unless @s.two_stars?
+      return break! if @s.end?
 
-    def process_slash_allow(append)
-      @segments += 1
-      @parent_re << '(?:'
-      @parent_re << @segment_re
-      @parent_re << append
+      if @s.slash?
+        if @s.end?
+          @re.append_any_non_dir
+          dir_only!
+        elsif @s.slash?
+          unmatchable_rule!
+        else
+          if nothing_emitted?
+            never_anchored!
+          else
+            @re.append_any_dir
+            anchored!
+          end
+          process_star_end_after_slash
+        end
+      else
+        @re.append_any_non_dir
+      end
     end
 
-    def process_stars
-      (@segment_re << '[^/]*') if @s.scan(%r{\*+(?=[^*/])})
-    end
+    def process_character_class # rubocop:disable Metrics/MethodLength
+      return unless @s.character_class_start?
 
-    def process_question_mark
-      (@segment_re << '[^/]') if @s.skip(/\?/)
-    end
+      @re.append_character_class_open
+      @re.append_character_class_negation if @s.character_class_negation?
+      unmatchable_rule! if @s.character_class_end?
+
+      until @s.character_class_end?
+        next if process_backslash
+        next @re.append_character_class_dash if @s.dash?
+        next if @re.append_escaped(@s.character_class_literal)
 
-    def process_text
-      (@segment_re << ::Regexp.escape(@s.matched)) if @s.scan(%r{[^*/?\[\\]+})
+        unmatchable_rule!
+      end
+
+      @re.append_character_class_close
     end
 
     def process_end
-      return unless @s.scan(/\*+\z/)
+      blank! if nothing_emitted?
 
-      if @s.matched.length == 1
-        @segment_re << if @segment_re.empty? # at least something. this is to allow subdir negations to work
-          '[^/]+\\z'
-        else
-          '[^/]*\\z'
+      emit_end
+    end
+
+    def process_rule # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      anchored! if @s.slash?
+
+      catch :break do
+        loop do
+          next if process_backslash
+          next if process_slash
+          next if process_two_stars
+          next @re.append_any_non_dir if @s.star?
+          next @re.append_one_non_dir if @s.question_mark?
+          next if process_character_class
+          next if @re.append_escaped(@s.literal)
+          next if @re.append_escaped(@s.significant_whitespace)
+
+          process_end
         end
       end
-      @trailing_stars = true
     end
 
-    def process_rule
-      until @s.eos?
-        process_escaped_char ||
-          process_star_star_slash || process_star_slash || process_no_star_slash ||
-          process_stars || process_question_mark ||
-          process_negated_character_class || process_character_class ||
-          process_text || process_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
+      else
+        if @anchored
+          out.append_start_anchor
+        else
+          out.append_start_dir_or_anchor
+        end
       end
+      out
     end
 
-    def build # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      @anchored = true if @s.skip(%r{/})
-
-      catch :unmatchable_rule do # rubocop:disable Metrics/BlockLength
-        process_rule
+    def build_rule
+      @re.prepend(prefix)
+      ::FastIgnore::Rule.new(@re.to_regexp, @negation, anchored_or_file_path, @dir_only)
+    end
 
-        @re << @segment_re
+    def anchored_or_file_path
+      @anchored || @file_path
+    end
 
-        prefix = if @file_path
-          escaped_file_path = ::Regexp.escape @file_path
-          if @anchored
-            "\\A#{escaped_file_path}"
-          else
-            "\\A#{escaped_file_path}(?:.*/)?"
-          end
-        else
-          if @anchored
-            '\\A'
-          else
-            '(?:\\A|/)'
-          end
-        end
+    def build
+      catch :abort_build do
+        blank! if @s.hash?
+        negated! if @s.exclamation_mark?
+        process_rule
 
-        @re.prepend(prefix)
-        anchored_or_file_path = @anchored || @file_path
-        if @allow
-          if @file_path
-            allow_escaped_file_path = escaped_file_path.gsub(%r{(?<!\\)(?:\\\\)*/}) do |e|
-              @segments += 1
-              "#{e[0..-2]}(?:/"
-            end
-
-            prefix = if @anchored
-              "\\A#{allow_escaped_file_path}"
-            else
-              "\\A#{allow_escaped_file_path}(?:.*/)?"
-            end
-          end
-          @parent_re.prepend(prefix)
-          @parent_re << (')?' * @segments)
-          (@re << '(/|\\z)') unless @dir_only || @trailing_stars
-          rules = [
-            # Regexp::IGNORECASE = 1
-            ::FastIgnore::Rule.new(::Regexp.new(@re, 1), @negation, anchored_or_file_path, @dir_only),
-            ::FastIgnore::Rule.new(::Regexp.new(@parent_re, 1), true, anchored_or_file_path, true)
-          ]
-          if @dir_only
-            (rules << ::FastIgnore::Rule.new(::Regexp.new((@re << '/.*'), 1), @negation, anchored_or_file_path, false))
-          end
-          rules
-        else
-          (@re << '\\z') unless @trailing_stars
+        @anchored = false if @anchored == :never
 
-          # Regexp::IGNORECASE = 1
-          ::FastIgnore::Rule.new(::Regexp.new(@re, 1), @negation, anchored_or_file_path, @dir_only)
-        end
+        build_rule
       end
     end
   end

data/lib/fast_ignore/gitignore_rule_regexp_builder.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class GitignoreRuleRegexpBuilder < String
+    def to_regexp
+      # Regexp::IGNORECASE = 1
+      ::Regexp.new(self, 1)
+    end
+
+    def append(value)
+      self.<<(value)
+
+      self
+    end
+
+    def append_escaped(value)
+      return unless value
+
+      append(::Regexp.escape(value))
+    end
+
+    def append_dir
+      append('/')
+    end
+
+    def append_any_dir
+      append('(?:.*/)?')
+    end
+
+    def append_one_non_dir
+      append('[^/]')
+    end
+
+    def append_any_non_dir
+      append_one_non_dir
+      append('*')
+    end
+
+    def append_many_non_dir
+      append_one_non_dir
+      append('+')
+    end
+
+    def append_end_anchor
+      append('\\z')
+    end
+
+    def append_start_anchor
+      append('\\A')
+    end
+
+    def append_start_dir_or_anchor
+      append('(?:\\A|/)')
+    end
+
+    def append_end_dir_or_anchor
+      append('(?:/|\\z)')
+    end
+
+    def append_character_class_open
+      append('(?!/)[')
+    end
+
+    def append_character_class_negation
+      append('^')
+    end
+
+    def append_character_class_dash
+      append('-')
+    end
+
+    def append_character_class_close
+      append(']')
+    end
+  end
+end

data/lib/fast_ignore/gitignore_rule_scanner.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class GitignoreRuleScanner < StringScanner
+    def character_class_end?
+      skip(/\]/)
+    end
+
+    def character_class_start?
+      skip(/\[/)
+    end
+
+    def character_class_negation?
+      skip(/\^|!/)
+    end
+
+    def end?
+      skip(/\s*\z/)
+    end
+
+    def slash?
+      skip(%r{/})
+    end
+
+    def backslash?
+      skip(/\\/)
+    end
+
+    def two_stars?
+      skip(/\*{2,}/)
+    end
+
+    def star?
+      skip(/\*/)
+    end
+
+    def next_character
+      matched if scan(/./)
+    end
+
+    def star_end?
+      skip(/\*\s*\z/)
+    end
+
+    def question_mark?
+      skip(/\?/)
+    end
+
+    def dash?
+      skip(/-/)
+    end
+
+    def character_class_literal
+      matched if scan(/[^\]\-\\]+/)
+    end
+
+    def literal
+      matched if scan(%r{[^*/?\[\\\s]+})
+    end
+
+    def significant_whitespace
+      matched if scan(/\s+(?!\s|\z)/)
+    end
+
+    def exclamation_mark?
+      skip(/!/)
+    end
+
+    def hash?
+      skip(/#/)
+    end
+  end
+end

data/lib/fast_ignore/global_gitignore.rb

@@ -11,32 +11,40 @@ class FastIgnore
           default_global_gitignore_path
       end
 
+      private
+
       def gitconfig_gitignore_path(config_path)
         return unless config_path
-        return unless ::File.exist?(config_path)
+        return unless ::File.readable?(config_path)
 
-        ignore_path = ::File.readlines(config_path).find { |l| l.sub!(/\A\s*excludesfile\s*=/, '') }
+        ignore_path = ::FastIgnore::GitconfigParser.parse(config_path)
         return unless ignore_path
 
         ignore_path.strip!
-        return ignore_path if ignore_path.empty? # don't expand path in this case
+        return '' if ignore_path.empty? # don't expand path in this case
 
         ::File.expand_path(ignore_path)
       end
 
       def xdg_config_path
-        return unless ::ENV['XDG_CONFIG_HOME'] && !::ENV['XDG_CONFIG_HOME'].empty?
-
-        ::File.expand_path('git/config', ::ENV['XDG_CONFIG_HOME'])
+        xdg_config_home? && ::File.expand_path('git/config', xdg_config_home)
       end
 
       def default_global_gitignore_path
-        if ::ENV['XDG_CONFIG_HOME'] && !::ENV['XDG_CONFIG_HOME'].empty?
-          ::File.expand_path('git/ignore', ::ENV['XDG_CONFIG_HOME'])
+        if xdg_config_home?
+          ::File.expand_path('git/ignore', xdg_config_home)
         else
           ::File.expand_path('~/.config/git/ignore')
         end
       end
+
+      def xdg_config_home
+        ::ENV['XDG_CONFIG_HOME']
+      end
+
+      def xdg_config_home?
+        xdg_config_home && (not xdg_config_home.empty?)
+      end
     end
   end
 end

data/lib/fast_ignore/rule.rb

@@ -7,6 +7,7 @@ class FastIgnore
     undef :negation
 
     attr_reader :component_rules
+    attr_reader :component_rules_count
 
     attr_reader :dir_only
     alias_method :dir_only?, :dir_only
@@ -17,8 +18,11 @@ class FastIgnore
 
     def squash(rules)
       # component rules is to improve the performance of repos with many .gitignore files. e.g. linux.
-      rules = rules.flat_map(&:component_rules)
-      ::FastIgnore::Rule.new(::Regexp.union(rules.map(&:rule)).freeze, @negation, @anchored, @dir_only, rules)
+      component_rules = rules.flat_map(&:component_rules)
+      ::FastIgnore::Rule.new(
+        ::Regexp.union(component_rules.map(&:rule)).freeze,
+        @negation, @anchored, @dir_only, component_rules
+      )
     end
 
     def initialize(rule, negation, anchored, dir_only, component_rules = self) # rubocop:disable Metrics/MethodLength
@@ -27,6 +31,7 @@ class FastIgnore
       @dir_only = dir_only
       @negation = negation
       @component_rules = component_rules
+      @component_rules_count = component_rules == self ? 1 : component_rules.length
 
       @squashable_type = if anchored && negation
         1
@@ -53,7 +58,7 @@ class FastIgnore
     end
     # :nocov:
 
-    def match?(relative_path, _, _, _)
+    def match?(relative_path, _full_path, _filename, _content)
       @rule.match?(relative_path)
     end
   end

data/lib/fast_ignore/rule_builder.rb

@@ -8,64 +8,33 @@ class FastIgnore
       # :nocov:
 
       def build(rule, allow, expand_path_with, file_root)
-        return shebang_rules(rule, allow) if remove_shebang(rule)
-
-        strip(rule)
-        return [] if skip?(rule)
-
-        gitignore_rules(rule, allow, expand_path_with, file_root)
+        if rule.delete_prefix!('#!:')
+          shebang_rules(rule, allow, file_root)
+        else
+          gitignore_rules(rule, allow, file_root, expand_path_with)
+        end
       end
 
       private
 
-      def strip(rule)
-        rule.chomp!
-        rule.rstrip! unless rule.end_with?('\\ ')
-      end
-
-      def remove_shebang(rule)
-        return unless rule.delete_prefix!('#!:')
-
-        rule.strip!
-
-        true
-      end
-
-      def shebang_rules(rule, allow)
-        rule = ::FastIgnore::ShebangRule.new(/\A#!.*\b#{::Regexp.escape(rule)}\b/i, allow)
+      def shebang_rules(shebang, allow, file_root)
+        shebang.strip!
+        pattern = /\A#!.*\b#{::Regexp.escape(shebang)}\b/i
+        rule = ::FastIgnore::ShebangRule.new(pattern, allow, file_root&.shebang_path_pattern)
         return rule unless allow
 
-        [::FastIgnore::Rule.new(//, true, true, true), rule]
-      end
-
-      def skip?(rule)
-        rule.empty? || rule.start_with?('#')
-      end
-
-      def gitignore_rules(rule, allow, expand_path_with, file_root)
-        dir_only = extract_dir_only(rule)
-        negation = extract_negation(rule, allow)
-
-        expand_rule_path(rule, expand_path_with) if expand_path_with
-
-        ::FastIgnore::GitignoreRuleBuilder.new(rule, negation, dir_only, file_root, allow).build
-      end
-
-      def extract_dir_only(rule)
-        rule.delete_suffix!('/')
-      end
-
-      def extract_negation(rule, allow)
-        return allow unless rule.delete_prefix!('!')
-
-        not allow
+        rules = gitignore_rules('*/'.dup, allow, file_root)
+        rules.pop # don't want the include all children one.
+        rules << rule
+        rules
       end
 
-      EXPAND_PATH_RE = %r{(^(?:[~/]|\.{1,2}/)|/\.\./)}.freeze
-      def expand_rule_path(rule, root)
-        rule.replace(::File.expand_path(rule)) if rule.match?(EXPAND_PATH_RE)
-        rule.delete_prefix!(root)
-        rule.prepend('/') unless rule.start_with?('*')
+      def gitignore_rules(rule, allow, file_root, expand_path_with = nil)
+        if allow
+          ::FastIgnore::GitignoreIncludeRuleBuilder.new(rule, file_root, expand_path_with).build
+        else
+          ::FastIgnore::GitignoreRuleBuilder.new(rule, file_root).build
+        end
       end
     end
   end