fast_ignore 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05f6139deefedc14e0c58acd66909aa25af5240a83e67a6463eacedd6cec9eb3
-  data.tar.gz: c6becf91ea8bc9ccf0524309c5cad1e01485c4e2324222f231ade33855c65528
+  metadata.gz: f96030c8670a5d709139689212b3a78a0eb0b5266cbd0057954863ae89e11745
+  data.tar.gz: a2815ec68f6c367a4450efce8799aa359adeee1ad1aaa971b589cd8612ddbb61
 SHA512:
-  metadata.gz: cca040e6401d0c412498dff47b460ba7a19d5c9cb810cc205151a56b9db959a88ea3c4137610537bda43c5520611b1711abc8124b0ab98dd6bda261de9638588
-  data.tar.gz: a3fe257c77f8350c2dde1bcfcde01293b5af87b5d6b627b4e44555b3b6a45154c3d567d1e68f8f03520d21e28e78eda439e92b7a8b5b2d0b43b6f2a23a2f5ae4
+  metadata.gz: 5c22c6c79a6605473156a041d5ddb5b81f943605dc4360dd8577acd56718c928c106e044169b13bc73c7e884ffcc5516c7a6b5d6134fee9aaa4aa73d0178b791
+  data.tar.gz: 1d165e44b50d9b1c301c5cad8ff3c443bfb2f9134be09e28a4e90539c960a269083485f6ff30bc6df6e2ec82347630187ebf0082cd2d06ba7416e9c70f37ea6f

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# v0.15.0
+- fixed a handful of character class edge cases to match git behavior
+  - mostly ranges with - or / as one end of the range
+- major refactoring of the regexp builder that shouldn't have any behaviour implications but should make development easier (e.g. seeing those unhandled edge cases).
+- improved speed of repos with many sub-gitignore files
+- mentioned submodules & sparse checkout in the readme as yet another thing git does that this project doesn't because submodule details are hidden in the git index.
+
 # v0.14.0
 - significant performance improvements ~50% faster
 - add `FastIgnore#to_proc` for no good reason

data/README.md

@@ -309,11 +309,13 @@ 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).
-- 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`
+- 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`
   - Deleted files whose deletions haven't been committed will be returned by `git ls-files`, but not by FastIgnore
   - On a case insensitive file system, with files that differ only by case, `git ls-files` will include all case variations, while FastIgnore will only include whichever variation git placed in the file system.
+  - FastIgnore is unaware of submodules and just treats them like regular directories. For example: `git ls-files --recurse-submodules` won't use the parent repo's gitignore on a submodule, while FastIgnore doesn't know it's a submodule and will.
+  - FastIgnore will only return the files actually on the file system when using `git sparse-checkout`.
 
 ## Contributing
 

data/lib/fast_ignore.rb

@@ -9,6 +9,10 @@ require_relative './fast_ignore/rule_set'
 require_relative './fast_ignore/global_gitignore'
 require_relative './fast_ignore/rule_builder'
 require_relative './fast_ignore/gitignore_rule_builder'
+require_relative './fast_ignore/gitignore_include_rule_builder'
+require_relative './fast_ignore/gitignore_rule_regexp_builder'
+require_relative './fast_ignore/gitignore_rule_scanner'
+require_relative './fast_ignore/file_root'
 require_relative './fast_ignore/rule'
 require_relative './fast_ignore/unmatchable_rule'
 require_relative './fast_ignore/shebang_rule'

data/lib/fast_ignore/file_root.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+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)
+
+      new(file_root) unless file_root.empty?
+    end
+
+    def initialize(file_root)
+      @file_root = file_root
+    end
+
+    def shebang_path_pattern
+      @shebang_path_pattern ||= /\A#{escaped}./
+    end
+
+    def escaped
+      @escaped ||= ::Regexp.escape(@file_root)
+    end
+
+    def escaped_segments
+      @escaped_segments ||= escaped.split('/')
+    end
+
+    def escaped_segments_length
+      @escaped_segments_length ||= escaped_segments.length
+    end
+
+    def escaped_segments_joined
+      @escaped_segments_joined ||= escaped_segments.join('(?:/') + '(?:/'
+    end
+  end
+end

data/lib/fast_ignore/gitignore_include_rule_builder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+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)
+
+      @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!
+      @negation = false
+    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
+    end
+
+    def emit_end
+      @dir_only || @re.append_end_dir_or_anchor
+      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
+
+        if @anchored
+          "\\A#{@file_path.escaped_segments_joined}"
+        else
+          "\\A#{@file_path.escaped_segments_joined}(?:.*/)?"
+        end
+      else
+        prefix
+      end
+
+      out = parent_prefix.dup
+      unless @parent_segments.empty?
+        out << '(?:'
+        out << @parent_segments.join('/(?:')
+        out << '/'
+      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
+
+    def build_child_file_rule
+      # Regexp::IGNORECASE = 1
+      ::FastIgnore::Rule.new(@re.append_dir.to_regexp, @negation, anchored_or_file_path, false)
+    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
+
+      rules = [super, build_parent_dir_rule]
+      (rules << build_child_file_rule) if @dir_only
+      rules
+    end
+
+    def process_rule
+      expand_rule_path if @expand_path_from
+      super
+    end
+  end
+end

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, Metrics/AbcSize
+      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,6 +11,8 @@ class FastIgnore
           default_global_gitignore_path
       end
 
+      private
+
       def gitconfig_gitignore_path(config_path)
         return unless config_path
         return unless ::File.exist?(config_path)
@@ -25,18 +27,24 @@ class FastIgnore
       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

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

data/lib/fast_ignore/rule_set.rb

@@ -6,9 +6,9 @@ class FastIgnore
     alias_method :gitignore?, :gitignore
     undef :gitignore
 
-    def initialize(rules, allow, gitignore)
-      @dir_rules = squash_rules(rules.reject(&:file_only?)).freeze
-      @file_rules = squash_rules(rules.reject(&:dir_only?)).freeze
+    def initialize(rules, allow, gitignore, squash = true)
+      @dir_rules = (squash ? squash_rules(rules.reject(&:file_only?)) : rules.reject(&:file_only?)).freeze
+      @file_rules = (squash ? squash_rules(rules.reject(&:dir_only?)) : rules.reject(&:dir_only?)).freeze
       @has_shebang_rules = rules.any?(&:shebang?)
 
       @allowed_recursive = { '.' => true }
@@ -42,8 +42,16 @@ class FastIgnore
       not @allow
     end
 
-    def squash_rules(rules)
-      rules.chunk_while { |a, b| a.squashable_type == b.squashable_type }.map do |chunk|
+    def squash_rules(rules) # rubocop:disable Metrics/MethodLength
+      running_component_rule_size = rules.first&.component_rules_count || 0
+      rules.chunk_while do |a, b|
+        # a.squashable_type == b.squashable_type
+        next true if a.squashable_type == b.squashable_type &&
+          (running_component_rule_size + b.component_rules_count <= 40)
+
+        running_component_rule_size = b.component_rules_count
+        false
+      end.map do |chunk| # rubocop:disable Style/MultilineBlockChain
         first = chunk.first
         next first if chunk.length == 1
 
@@ -61,6 +69,8 @@ class FastIgnore
 
     protected
 
-    attr_reader :dir_rules, :file_rules, :has_shebang_rules
+    attr_reader :dir_rules
+    attr_reader :file_rules
+    attr_reader :has_shebang_rules
   end
 end

data/lib/fast_ignore/rule_sets.rb

@@ -35,13 +35,16 @@ class FastIgnore
       @array.all? { |r| r.allowed_unrecursive?(relative_path, dir, full_path, filename, nil) }
     end
 
-    def append_subdir_gitignore(relative_path:, check_exists: true)
-      new_gitignore = build_set_from_file(relative_path, gitignore: true, check_exists: check_exists)
-      return if !new_gitignore || new_gitignore.empty?
-
+    def append_subdir_gitignore(relative_path:, check_exists: true) # rubocop:disable Metrics/MethodLength
       if @gitignore_rule_set
+        new_gitignore = build_set_from_file(relative_path, gitignore: true, check_exists: check_exists, squash: false)
+        return if !new_gitignore || new_gitignore.empty?
+
         @gitignore_rule_set << new_gitignore
       else
+        new_gitignore = build_set_from_file(relative_path, gitignore: true, check_exists: check_exists)
+        return if !new_gitignore || new_gitignore.empty?
+
         @array << new_gitignore
         @gitignore_rule_set = new_gitignore
         @array.sort_by!(&:weight) && @array.freeze
@@ -75,23 +78,21 @@ class FastIgnore
       build_rule_set(::File.readlines(path), false, gitignore: true)
     end
 
-    def build_rule_set(rules, allow, expand_path_with: nil, file_root: nil, gitignore: false)
+    def build_rule_set(rules, allow, expand_path_with: nil, file_root: nil, gitignore: false, squash: true) # rubocop:disable Metrics/ParameterLists
       rules = rules.flat_map do |rule|
         ::FastIgnore::RuleBuilder.build(rule, allow, expand_path_with, file_root)
       end
 
-      ::FastIgnore::RuleSet.new(rules, allow, gitignore)
+      ::FastIgnore::RuleSet.new(rules, allow, gitignore, squash)
     end
 
-    def build_set_from_file(filename, allow: false, file_root: nil, gitignore: false, check_exists: false)
+    def build_set_from_file(filename, allow: false, gitignore: false, check_exists: false, squash: true)
       filename = ::File.expand_path(filename, @project_root)
       return if check_exists && !::File.exist?(filename)
-      unless file_root || filename.start_with?(@project_root)
-        raise ::FastIgnore::Error, "#{filename} is not within #{@project_root}"
-      end
+      raise ::FastIgnore::Error, "#{filename} is not within #{@project_root}" unless filename.start_with?(@project_root)
 
-      file_root ||= "#{::File.dirname(filename)}/".delete_prefix(@project_root)
-      build_rule_set(::File.readlines(filename), allow, file_root: file_root, gitignore: gitignore)
+      file_root = ::FastIgnore::FileRoot.build(filename, @project_root)
+      build_rule_set(::File.readlines(filename), allow, file_root: file_root, gitignore: gitignore, squash: squash)
     end
 
     def append_sets_from_files(files, allow: false)

data/lib/fast_ignore/shebang_rule.rb

@@ -8,17 +8,24 @@ class FastIgnore
 
     attr_reader :rule
 
+    attr_reader :file_path_pattern
+
     attr_reader :squashable_type
 
     def squash(rules)
-      ::FastIgnore::ShebangRule.new(::Regexp.union(rules.map(&:rule)).freeze, negation?)
+      ::FastIgnore::ShebangRule.new(::Regexp.union(rules.map(&:rule)).freeze, negation?, file_path_pattern)
+    end
+
+    def component_rules_count
+      1
     end
 
-    def initialize(rule, negation)
+    def initialize(rule, negation, file_path_pattern)
       @rule = rule
       @negation = negation
+      @file_path_pattern = file_path_pattern
 
-      @squashable_type = negation ? 3 : 2
+      @squashable_type = (negation ? 13 : 12) + file_path_pattern.object_id
 
       freeze
     end
@@ -33,12 +40,15 @@ class FastIgnore
 
     # :nocov:
     def inspect
-      "#<ShebangRule #{'allow ' if @negation}#!:#{@rule.to_s[15..-4]}>"
+      allow_fragment = 'allow ' if @negation
+      in_fragment = " in #{@file_path_pattern}" if @file_path_pattern
+      "#<ShebangRule #{allow_fragment}#!:#{@rule.to_s[15..-4]}#{in_fragment}>"
     end
     # :nocov:
 
-    def match?(_, full_path, filename, content)
+    def match?(path, full_path, filename, content)
       return false if filename.include?('.')
+      return false unless (not @file_path_pattern) || @file_path_pattern.match?(path)
 
       (content || first_line(full_path))&.match?(@rule)
     end

data/lib/fast_ignore/unmatchable_rule.rb

@@ -11,6 +11,10 @@ class FastIgnore
         5
       end
 
+      def component_rules_count
+        1
+      end
+
       def dir_only?
         false
       end

data/lib/fast_ignore/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class FastIgnore
-  VERSION = '0.14.0'
+  VERSION = '0.15.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-28 00:00:00.000000000 Z
+date: 2020-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -148,7 +148,11 @@ files:
 - README.md
 - lib/fast_ignore.rb
 - lib/fast_ignore/backports.rb
+- lib/fast_ignore/file_root.rb
+- lib/fast_ignore/gitignore_include_rule_builder.rb
 - lib/fast_ignore/gitignore_rule_builder.rb
+- lib/fast_ignore/gitignore_rule_regexp_builder.rb
+- lib/fast_ignore/gitignore_rule_scanner.rb
 - lib/fast_ignore/global_gitignore.rb
 - lib/fast_ignore/rule.rb
 - lib/fast_ignore/rule_builder.rb