fast_ignore 0.10.1 → 0.13.0

data/lib/fast_ignore/backports.rb

@@ -2,15 +2,65 @@
 
 class FastIgnore
   module Backports
-    module_function
+    ruby_major, ruby_minor = RUBY_VERSION.split('.', 2)
+    unless ruby_major.to_i > 2 || ruby_major.to_i == 2 && ruby_minor.to_i > 5
+      module DirEachChild
+        refine ::Dir.singleton_class do
+          def children(path)
+            Dir.entries(path) - ['.', '..']
+          end
+        end
+      end
 
-    def ruby_version_less_than?(major, minor)
-      ruby_major, ruby_minor = RUBY_VERSION.split('.', 2)
+      module DeletePrefixSuffix
+        refine ::String do
+          # delete_prefix!(prefix) -> self or nil
+          # Deletes leading prefix from str, returning nil if no change was made.
+          #
+          #   "hello".delete_prefix!("hel") #=> "lo"
+          #   "hello".delete_prefix!("llo") #=> nil
+          def delete_prefix!(str)
+            return unless start_with?(str)
 
-      return true if major > ruby_major.to_i
-      return true if minor > ruby_minor.to_i
+            slice!(0..(str.length - 1))
+            self
+          end
 
-      false
+          # delete_suffix!(suffix) -> self or nil
+          # Deletes trailing suffix from str, returning nil if no change was made.
+          #
+          #   "hello".delete_suffix!("llo") #=> "he"
+          #   "hello".delete_suffix!("hel") #=> nil
+          def delete_suffix!(str)
+            return unless end_with?(str)
+
+            slice!(-str.length..-1)
+            self
+          end
+
+          # delete_prefix(prefix) -> new_str click to toggle source
+          # Returns a copy of str with leading prefix deleted.
+          #
+          #   "hello".delete_prefix("hel") #=> "lo"
+          #   "hello".delete_prefix("llo") #=> "hello"
+          def delete_prefix(str)
+            s = dup
+            s.delete_prefix!(str)
+            s
+          end
+
+          # delete_suffix(suffix) -> new_str
+          # Returns a copy of str with trailing suffix deleted.
+          #
+          #   "hello".delete_suffix("llo") #=> "he"
+          #   "hello".delete_suffix("hel") #=> "hello"
+          def delete_suffix(str) # leftovers:allowed
+            s = dup
+            s.delete_suffix!(str)
+            s
+          end
+        end
+      end
     end
   end
 end

data/lib/fast_ignore/fn_match_to_re.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module FNMatchToRegex
+    # This doesn't look rubyish because i ported it from rust (the only rust i ever wrote that worked)
+    class << self
+      def call(pattern) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        re = '\\A'.dup
+
+        in_character_group = false
+        has_characters_in_group = false
+        escape_next_character = false
+        last_char_opened_character_group = false
+        negated_character_group = false
+        stars = 0
+
+        pattern.each_char do |char| # rubocop:disable Metrics/BlockLength
+          if escape_next_character
+            re << Regexp.escape(char)
+            escape_next_character = false
+          elsif char == '\\' # single char, just needs to be escaped
+            escape_next_character = true
+          elsif in_character_group
+            if char == '/'
+              if negated_character_group
+                has_characters_in_group = true
+                re << char
+              end
+            elsif char == '^'
+              if last_char_opened_character_group
+                re << char
+                negated_character_group = true
+              else
+                re << '\\^'
+                has_characters_in_group = true
+              end
+              # not characters in group
+            elsif char == ']'
+              break unless has_characters_in_group
+
+              re << ']'
+              in_character_group = false
+              has_characters_in_group = false
+              negated_character_group = false
+              last_char_opened_character_group = false
+            elsif char == '-'
+              has_characters_in_group = true
+              re << char
+            else
+              has_characters_in_group = true
+              re << Regexp.escape(char)
+            end
+            last_char_opened_character_group = false
+          elsif char == '*'
+            stars += 1
+          elsif char == '/'
+            re << if stars >= 2
+              '(?:.*/)?'
+            elsif stars.positive?
+              '[^/]*/'
+            else
+              char
+            end
+            stars = 0
+          else
+            if stars.positive?
+              re << '[^/]*'
+              stars = 0
+            end
+            if char == '?'
+              re << '[^/]'
+            elsif char == '['
+              re << '['
+              in_character_group = true
+              last_char_opened_character_group = true
+            else
+              re << Regexp.escape(char)
+            end
+          end
+        end
+
+        if in_character_group
+          return /(?!)/ # impossible to match anything
+        end
+
+        if stars >= 2
+          re << '.*'
+        elsif stars.positive?
+          re << '[^/]*'
+        end
+        re << '\\z'
+        Regexp.new(re, Regexp::IGNORECASE)
+      end
+    end
+  end
+end

data/lib/fast_ignore/rule.rb

@@ -2,70 +2,48 @@
 
 class FastIgnore
   class Rule
-    # FNMATCH_OPTIONS = (
-    #   ::File::FNM_DOTMATCH |
-    #   ::File::FNM_PATHNAME |
-    #   ::File::FNM_CASEFOLD
-    # ).freeze # = 14
-
     attr_reader :negation
     alias_method :negation?, :negation
+    undef :negation
 
     attr_reader :dir_only
     alias_method :dir_only?, :dir_only
-
-    attr_reader :shebang
-    alias_method :file_only?, :shebang
+    undef :dir_only
 
     attr_reader :unanchored
     alias_method :unanchored?, :unanchored
+    undef :unanchored
+
+    attr_reader :type
+    attr_reader :rule
 
-    def initialize(rule, unanchored, dir_only, negation, shebang = nil)
-      @rule = rule
+    def initialize(rule, negation, unanchored = nil, dir_only = nil)
+      @rule = rule.is_a?(Regexp) ? rule : ::FastIgnore::FNMatchToRegex.call(rule)
       @unanchored = unanchored
       @dir_only = dir_only
       @negation = negation
-      @shebang = shebang
+
+      @type = negation ? 1 : 0
 
       freeze
     end
 
-    # :nocov:
-    def inspect
-      if shebang
-        "#<Rule #{'allow ' if @negation}#!:#{@shebang.to_s[15..-4]}>"
-      else
-        "#<Rule #{'!' if @negation}#{@rule}#{'/' if @dir_only}>"
-      end
+    def file_only?
+      false
     end
-    # :nocov:
 
-    def match?(path, filename)
-      if @shebang
-        match_shebang?(path, filename)
-      else
-        # 14 = FNMATCH_OPTIONS
-        ::File.fnmatch?(@rule, path, 14)
-      end
+    def shebang
+      nil
     end
 
-    def match_shebang?(path, filename)
-      return false if filename.include?('.')
-
-      first_line(path)&.match?(@shebang)
+    # :nocov:
+    def inspect
+      "#<Rule #{'!' if @negation}#{@rule}#{'/' if @dir_only}>"
     end
+    # :nocov:
 
-    def first_line(path)
-      file = ::File.new(path)
-      first_line = file.sysread(25)
-      first_line += file.sysread(50) until first_line.include?("\n")
-      file.close
-      first_line
-    rescue ::EOFError, ::SystemCallError
-      # :nocov:
-      file&.close
-      # :nocov:
-      first_line
+    def match?(relative_path, _, _, _)
+      @rule.match?(relative_path)
     end
   end
 end

data/lib/fast_ignore/rule_builder.rb

@@ -2,19 +2,15 @@
 
 class FastIgnore
   module RuleBuilder
-    # rule or nil
     class << self
       # :nocov:
-      if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
-        require_relative 'backports/delete_prefix_suffix'
-        using ::FastIgnore::Backports::DeletePrefixSuffix
-      end
+      using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
       # :nocov:
 
       def build(rule, allow, expand_path, file_root)
-        strip(rule)
-
         return shebang_rules(rule, allow) if remove_shebang(rule)
+
+        strip(rule)
         return [] if skip?(rule)
 
         gitignore_rules(rule, allow, expand_path, file_root)
@@ -36,7 +32,7 @@ class FastIgnore
       end
 
       def shebang_rules(rule, allow)
-        rules = [::FastIgnore::Rule.new(nil, true, false, allow, /\A#!.*\b#{Regexp.escape(rule)}\b/.freeze)]
+        rules = [::FastIgnore::ShebangRule.new(/\A#!.*\b#{Regexp.escape(rule)}\b/i.freeze, allow)]
         return rules unless allow
 
         rules << ::FastIgnore::Rule.new('**/*', true, true, true)
@@ -51,8 +47,11 @@ class FastIgnore
         dir_only = extract_dir_only(rule)
         negation = extract_negation(rule, allow)
 
-        expand_rule_path(rule, expand_path) if expand_path
-        unanchored = unanchored?(rule)
+        unanchored = if expand_path
+          expand_rule_path(rule, expand_path)
+        else
+          unanchored?(rule)
+        end
         rule.delete_prefix!('/')
 
         rule.prepend("#{file_root}#{'**/' if unanchored}") if file_root || unanchored
@@ -74,7 +73,7 @@ class FastIgnore
       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?('*') || rule.start_with?('/')
+        rule.start_with?('*')
       end
 
       def unanchored?(rule)
@@ -82,10 +81,10 @@ class FastIgnore
       end
 
       def build_gitignore_rules(rule, unanchored, allow, dir_only, negation)
-        rules = [::FastIgnore::Rule.new(rule.freeze, unanchored, dir_only, negation)]
+        rules = [::FastIgnore::Rule.new(rule, negation, unanchored, dir_only)]
         return rules unless allow
 
-        rules << ::FastIgnore::Rule.new("#{rule}/**/*", unanchored, false, negation)
+        rules << ::FastIgnore::Rule.new("#{rule}/**/*", negation, unanchored, false)
         rules + ancestor_rules(rule, unanchored)
       end
 
@@ -94,7 +93,7 @@ class FastIgnore
 
         while (parent = ::File.dirname(parent)) != '.'
           rule = ::File.basename(parent) == '**' ? "#{parent}/*" : parent.freeze
-          ancestor_rules << ::FastIgnore::Rule.new(rule, unanchored, true, true)
+          ancestor_rules << ::FastIgnore::Rule.new(rule, true, unanchored, true)
         end
 
         ancestor_rules

data/lib/fast_ignore/rule_set.rb

@@ -2,39 +2,59 @@
 
 class FastIgnore
   class RuleSet
-    def initialize(rules, allow)
-      @dir_rules = rules.reject(&:file_only?).freeze
-      @file_rules = rules.reject(&:dir_only?).freeze
+    attr_reader :gitignore
+    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)
+
       @allowed_recursive = { '.' => true }
       @allow = allow
+      @gitignore = gitignore
 
-      freeze
+      freeze unless gitignore?
     end
 
-    def freeze
-      @dir_rules.freeze
-      @file_rules.freeze
+    def <<(other)
+      return unless other
 
-      super
+      @any_not_anchored ||= other.any_not_anchored
+      @has_shebang_rules ||= other.has_shebang_rules
+      @dir_rules += other.dir_rules
+      @file_rules += other.file_rules
     end
 
-    def allowed_recursive?(path, dir, filename)
-      @allowed_recursive.fetch(path) do
-        @allowed_recursive[path] =
-          allowed_recursive?(::File.dirname(path), true, nil) && allowed_unrecursive?(path, dir, filename)
+    def allowed_recursive?(relative_path, dir, full_path, filename, content = nil)
+      @allowed_recursive.fetch(relative_path) do
+        @allowed_recursive[relative_path] =
+          allowed_recursive?(::File.dirname(relative_path), true, nil, nil, nil) &&
+          allowed_unrecursive?(relative_path, dir, full_path, filename, content)
       end
     end
 
-    def allowed_unrecursive?(path, dir, filename)
+    def allowed_unrecursive?(relative_path, dir, full_path, filename, content)
       (dir ? @dir_rules : @file_rules).reverse_each do |rule|
-        return rule.negation? if rule.match?(path, filename)
+        return rule.negation? if rule.match?(relative_path, full_path, filename, content)
       end
 
       (not @allow) || (dir && @any_not_anchored)
     end
 
+    def squash_rules(rules)
+      out = rules.chunk_while { |a, b| a.type == b.type }.map do |chunk|
+        first = chunk.first
+        next first if chunk.length == 1
+
+        first.class.new(Regexp.union(chunk.map(&:rule)), first.negation?)
+      end
+
+      out
+    end
+
     def weight
       @dir_rules.length + (@has_shebang_rules ? 10 : 0)
     end
@@ -42,5 +62,9 @@ class FastIgnore
     def empty?
       @dir_rules.empty? && @file_rules.empty?
     end
+
+    protected
+
+    attr_reader :dir_rules, :file_rules, :any_not_anchored, :has_shebang_rules
   end
 end

data/lib/fast_ignore/rule_set_builder.rb

@@ -1,20 +1,17 @@
 # frozen_string_literal: true
 
 class FastIgnore
-  module RuleSetBuilder
+  module RuleSetBuilder # rubocop:disable Metrics/ModuleLength
     class << self
       # :nocov:
-      if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
-        require_relative 'backports/delete_prefix_suffix'
-        using ::FastIgnore::Backports::DeletePrefixSuffix
-      end
+      using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
       # :nocov:
 
       def build( # rubocop:disable Metrics/ParameterLists
         root:,
         ignore_rules: nil,
         ignore_files: nil,
-        gitignore: :auto,
+        gitignore: true,
         include_rules: nil,
         include_files: nil,
         argv_rules: nil
@@ -22,7 +19,7 @@ class FastIgnore
         prepare [
           from_array(ignore_rules),
           *from_files(ignore_files, project_root: root),
-          from_array('.git'),
+          (from_array('.git') if gitignore),
           from_gitignore_arg(gitignore, project_root: root),
           from_array(include_rules, allow: true),
           *from_files(include_files, allow: true, project_root: root),
@@ -30,6 +27,19 @@ class FastIgnore
         ]
       end
 
+      def append_gitignore(rule_sets, project_root:, relative_path:, soft: true)
+        new_gitignore = from_file(relative_path, project_root: project_root, gitignore: true, soft: soft)
+        return unless new_gitignore
+
+        base_gitignore = rule_sets.find(&:gitignore?)
+        if base_gitignore
+          base_gitignore << new_gitignore
+        else
+          rule_sets << new_gitignore
+          prepare(rule_sets)
+        end
+      end
+
       private
 
       def prepare(rule_sets)
@@ -39,12 +49,15 @@ class FastIgnore
         rule_sets
       end
 
-      def from_file(filename, project_root:, allow: false)
+      def from_file(filename, project_root:, allow: false, file_root: nil, gitignore: false, soft: false) # rubocop:disable Metrics/ParameterLists
         filename = ::File.expand_path(filename, project_root)
-        raise FastIgnore::Error, "#{filename} is not within #{project_root}" unless filename.start_with?(project_root)
+        return if soft && !::File.exist?(filename)
+        unless file_root || filename.start_with?(project_root)
+          raise FastIgnore::Error, "#{filename} is not within #{project_root}"
+        end
 
-        file_root = "#{::File.dirname(filename)}/".delete_prefix(project_root)
-        build_rule_set(::File.readlines(filename), allow, file_root: file_root)
+        file_root ||= "#{::File.dirname(filename)}/".delete_prefix(project_root)
+        build_rule_set(::File.readlines(filename), allow, file_root: file_root, gitignore: gitignore)
       end
 
       def from_files(files, project_root:, allow: false)
@@ -54,12 +67,53 @@ class FastIgnore
       end
 
       def from_gitignore_arg(gitignore, project_root:)
-        default_path = ::File.join(project_root, '.gitignore')
-        case gitignore
-        when :auto
-          from_file(default_path, project_root: project_root) if ::File.exist?(default_path)
-        when true
-          from_file(default_path, project_root: project_root)
+        return unless gitignore
+
+        gi = ::FastIgnore::RuleSet.new([], false, true)
+        gi << from_root_gitignore_file(global_gitignore_path(root: project_root))
+        gi << from_root_gitignore_file(::File.join(project_root, '.git/info/exclude'))
+        gi << from_root_gitignore_file(::File.join(project_root, '.gitignore'))
+        gi
+      end
+
+      def from_root_gitignore_file(path)
+        return unless ::File.exist?(path)
+
+        build_rule_set(::File.readlines(path), false, file_root: '', gitignore: true)
+      end
+
+      def global_gitignore_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
+
+      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
+        return unless ENV['XDG_CONFIG_HOME'] && !ENV['XDG_CONFIG_HOME'].empty?
+
+        ::File.expand_path('git/config', ENV['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'])
+        else
+          ::File.expand_path('~/.config/git/ignore')
         end
       end
 
@@ -75,12 +129,12 @@ class FastIgnore
         build_rule_set(rules, allow, expand_path: expand_path)
       end
 
-      def build_rule_set(rules, allow, expand_path: false, file_root: nil)
+      def build_rule_set(rules, allow, expand_path: false, file_root: nil, gitignore: false)
         rules = rules.flat_map do |rule|
           ::FastIgnore::RuleBuilder.build(rule, allow, expand_path, file_root)
         end
 
-        ::FastIgnore::RuleSet.new(rules, allow).freeze
+        ::FastIgnore::RuleSet.new(rules, allow, gitignore)
       end
     end
   end