fast_ignore 0.12.1 → 0.15.2

data/lib/fast_ignore/global_gitignore.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+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') ||
+          default_global_gitignore_path
+      end
+
+      private
+
+      def gitconfig_gitignore_path(config_path)
+        return unless config_path
+        return unless ::File.exist?(config_path)
+
+        ignore_path = ::File.readlines(config_path).find { |l| l.sub!(/\A\s*excludesfile\s*=/, '') }
+        return unless ignore_path
+
+        ignore_path.strip!
+        return ignore_path if ignore_path.empty? # don't expand path in this case
+
+        ::File.expand_path(ignore_path)
+      end
+
+      def xdg_config_path
+        xdg_config_home? && ::File.expand_path('git/config', xdg_config_home)
+      end
+
+      def default_global_gitignore_path
+        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

@@ -6,24 +6,40 @@ class FastIgnore
     alias_method :negation?, :negation
     undef :negation
 
+    attr_reader :component_rules
+    attr_reader :component_rules_count
+
     attr_reader :dir_only
     alias_method :dir_only?, :dir_only
     undef :dir_only
 
-    attr_reader :unanchored
-    alias_method :unanchored?, :unanchored
-    undef :unanchored
-
-    attr_reader :type
+    attr_reader :squashable_type
     attr_reader :rule
 
-    def initialize(rule, negation, unanchored = nil, dir_only = nil)
-      @rule = rule.is_a?(Regexp) ? rule : ::FastIgnore::FNMatchToRegex.call(rule)
-      @unanchored = unanchored
+    def squash(rules)
+      # component rules is to improve the performance of repos with many .gitignore files. e.g. linux.
+      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
+      @rule = rule
+      @anchored = anchored
       @dir_only = dir_only
       @negation = negation
+      @component_rules = component_rules
+      @component_rules_count = component_rules == self ? 1 : component_rules.length
 
-      @type = negation ? 1 : 0
+      @squashable_type = if anchored && negation
+        1
+      elsif anchored
+        0
+      else
+        ::Float::NAN # because it doesn't equal itself
+      end
 
       freeze
     end
@@ -32,17 +48,17 @@ class FastIgnore
       false
     end
 
-    def shebang
-      nil
+    def shebang?
+      false
     end
 
     # :nocov:
     def inspect
-      "#<Rule #{'!' if @negation}#{@rule}#{'/' if @dir_only}>"
+      "#<Rule #{'!' if @negation}#{'/' if @anchored}#{@rule}#{'/' if @dir_only}>"
     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

@@ -7,96 +7,34 @@ class FastIgnore
       using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
       # :nocov:
 
-      def build(rule, allow, expand_path, file_root)
-        return shebang_rules(rule, allow) if remove_shebang(rule)
-
-        strip(rule)
-        return [] if skip?(rule)
-
-        gitignore_rules(rule, allow, expand_path, file_root)
+      def build(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)
-        rules = [::FastIgnore::ShebangRule.new(/\A#!.*\b#{Regexp.escape(rule)}\b/.freeze, allow)]
-        return rules unless 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
 
-        rules << ::FastIgnore::Rule.new('**/*', true, true, true)
+        rules = gitignore_rules('*/'.dup, allow, file_root)
+        rules.pop # don't want the include all children one.
+        rules << rule
         rules
       end
 
-      def skip?(rule)
-        rule.empty? || rule.start_with?('#')
-      end
-
-      def gitignore_rules(rule, allow, expand_path, file_root)
-        dir_only = extract_dir_only(rule)
-        negation = extract_negation(rule, allow)
-
-        unanchored = if expand_path
-          expand_rule_path(rule, expand_path)
+      def gitignore_rules(rule, allow, file_root, expand_path_with = nil)
+        if allow
+          ::FastIgnore::GitignoreIncludeRuleBuilder.new(rule, file_root, expand_path_with).build
         else
-          unanchored?(rule)
-        end
-        rule.delete_prefix!('/')
-
-        rule.prepend("#{file_root}#{'**/' if unanchored}") if file_root || unanchored
-
-        build_gitignore_rules(rule, unanchored, allow, dir_only, negation)
-      end
-
-      def extract_dir_only(rule)
-        rule.delete_suffix!('/')
-      end
-
-      def extract_negation(rule, allow)
-        return allow unless rule.delete_prefix!('!')
-
-        not allow
-      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.start_with?('*')
-      end
-
-      def unanchored?(rule)
-        not rule.include?('/') # we've already removed the trailing '/' with extract_dir_only
-      end
-
-      def build_gitignore_rules(rule, unanchored, allow, dir_only, negation)
-        rules = [::FastIgnore::Rule.new(rule, negation, unanchored, dir_only)]
-        return rules unless allow
-
-        rules << ::FastIgnore::Rule.new("#{rule}/**/*", negation, unanchored, false)
-        rules + ancestor_rules(rule, unanchored)
-      end
-
-      def ancestor_rules(parent, unanchored)
-        ancestor_rules = []
-
-        while (parent = ::File.dirname(parent)) != '.'
-          rule = ::File.basename(parent) == '**' ? "#{parent}/*" : parent.freeze
-          ancestor_rules << ::FastIgnore::Rule.new(rule, true, unanchored, true)
+          ::FastIgnore::GitignoreRuleBuilder.new(rule, file_root).build
         end
-
-        ancestor_rules
       end
     end
   end

data/lib/fast_ignore/rule_set.rb

@@ -6,11 +6,10 @@ 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
-      @any_not_anchored = rules.any?(&:unanchored?)
-      @has_shebang_rules = rules.any?(&:shebang)
+    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 }
       @allow = allow
@@ -22,10 +21,9 @@ class FastIgnore
     def <<(other)
       return unless other
 
-      @any_not_anchored ||= other.any_not_anchored
       @has_shebang_rules ||= other.has_shebang_rules
-      @dir_rules += other.dir_rules
-      @file_rules += other.file_rules
+      @dir_rules = squash_rules(@dir_rules + other.dir_rules)
+      @file_rules = squash_rules(@file_rules + other.file_rules)
     end
 
     def allowed_recursive?(relative_path, dir, full_path, filename, content = nil)
@@ -41,17 +39,24 @@ class FastIgnore
         return rule.negation? if rule.match?(relative_path, full_path, filename, content)
       end
 
-      (not @allow) || (dir && @any_not_anchored)
+      not @allow
     end
 
-    def squash_rules(rules)
-      out = rules.chunk_while { |a, b| a.type == b.type }.map do |chunk|
-        next chunk.first if chunk.length == 1
+    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)
 
-        chunk.first.class.new(Regexp.union(chunk.map(&:rule)), chunk.first.negation?)
-      end
+        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
 
-      out
+        first.squash(chunk)
+      end
     end
 
     def weight
@@ -64,6 +69,8 @@ class FastIgnore
 
     protected
 
-    attr_reader :dir_rules, :file_rules, :any_not_anchored, :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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class RuleSets
+    # :nocov:
+    using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
+    # :nocov:
+
+    def initialize( # rubocop:disable Metrics/ParameterLists
+      root:,
+      ignore_rules: nil,
+      ignore_files: nil,
+      gitignore: true,
+      include_rules: nil,
+      include_files: nil,
+      argv_rules: nil
+    )
+      @array = []
+      @project_root = root
+      append_root_gitignore(gitignore)
+      append_set_from_array(ignore_rules)
+      append_set_from_array(include_rules, allow: true)
+      append_set_from_array(argv_rules, allow: true, expand_path_with: @project_root)
+      append_sets_from_files(ignore_files)
+      append_sets_from_files(include_files, allow: true)
+      @array.sort_by!(&:weight)
+      @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) }
+    end
+
+    def allowed_unrecursive?(relative_path, dir, full_path, filename)
+      @array.all? { |r| r.allowed_unrecursive?(relative_path, dir, full_path, filename, nil) }
+    end
+
+    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
+      end
+      new_gitignore
+    end
+
+    private
+
+    def append_and_return_if_present(value)
+      return unless value && !value.empty?
+
+      @array << value
+      value
+    end
+
+    def append_root_gitignore(gitignore)
+      return @gitignore_rule_set = nil unless gitignore
+
+      append_set_from_array('.git')
+      gi = ::FastIgnore::RuleSet.new([], false, true)
+      gi << build_from_root_gitignore_file(::FastIgnore::GlobalGitignore.path(root: @project_root))
+      gi << build_from_root_gitignore_file("#{@project_root}.git/info/exclude")
+      gi << build_from_root_gitignore_file("#{@project_root}.gitignore")
+      @gitignore_rule_set = append_and_return_if_present(gi)
+    end
+
+    def build_from_root_gitignore_file(path)
+      return unless ::File.exist?(path)
+
+      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, 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, squash)
+    end
+
+    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)
+      raise ::FastIgnore::Error, "#{filename} is not within #{@project_root}" unless filename.start_with?(@project_root)
+
+      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)
+      Array(files).each do |file|
+        append_and_return_if_present(build_set_from_file(file, allow: allow))
+      end
+    end
+
+    def append_set_from_array(rules, allow: false, expand_path_with: nil)
+      return unless rules
+
+      rules = Array(rules).flat_map { |string| string.to_s.lines }
+      return if rules.empty?
+
+      append_and_return_if_present(build_rule_set(rules, allow, expand_path_with: expand_path_with))
+    end
+  end
+end

data/lib/fast_ignore/shebang_rule.rb

@@ -7,16 +7,25 @@ class FastIgnore
     undef :negation
 
     attr_reader :rule
-    alias_method :shebang, :rule
 
-    attr_reader :type
+    attr_reader :file_path_pattern
 
-    def initialize(rule, negation)
+    attr_reader :squashable_type
+
+    def squash(rules)
+      ::FastIgnore::ShebangRule.new(::Regexp.union(rules.map(&:rule)).freeze, negation?, file_path_pattern)
+    end
+
+    def component_rules_count
+      1
+    end
+
+    def initialize(rule, negation, file_path_pattern)
       @rule = rule
       @negation = negation
+      @file_path_pattern = file_path_pattern
 
-      @type = 2
-      @type += 1 if negation
+      @squashable_type = (negation ? 13 : 12) + file_path_pattern.object_id
 
       freeze
     end
@@ -29,28 +38,39 @@ class FastIgnore
       false
     end
 
-    def unanchored?
-      true
-    end
-
     # :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?(relative_path, full_path, filename, content)
       return false if filename.include?('.')
+      return false unless (not @file_path_pattern) || @file_path_pattern.match?(relative_path)
 
       (content || first_line(full_path))&.match?(@rule)
     end
 
+    def shebang?
+      true
+    end
+
     private
 
-    def first_line(path)
+    def first_line(path) # rubocop:disable Metrics/MethodLength
       file = ::File.new(path)
-      first_line = file.sysread(25)
-      first_line += file.sysread(50) until first_line.include?("\n")
+      first_line = new_fragment = file.sysread(64)
+      if first_line.start_with?('#!')
+        until new_fragment.include?("\n")
+          new_fragment = file.sysread(64)
+          first_line += new_fragment
+        end
+      else
+        file.close
+        return
+      end
       file.close
       first_line
     rescue ::EOFError, ::SystemCallError