fast_ignore 0.17.0 → 0.17.4

data/lib/fast_ignore.rb

@@ -1,78 +1,56 @@
 # frozen_string_literal: true
 
-require_relative './fast_ignore/backports'
-
 require 'set'
 require 'strscan'
 
 class FastIgnore
   class Error < StandardError; end
 
-  require_relative './fast_ignore/rule_sets'
-  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'
-  require_relative './fast_ignore/gitconfig_parser'
+  require_relative 'fast_ignore/rule_groups'
+  require_relative 'fast_ignore/global_gitignore'
+  require_relative 'fast_ignore/gitignore_rule_builder'
+  require_relative 'fast_ignore/gitignore_include_rule_builder'
+  require_relative 'fast_ignore/path_regexp_builder'
+  require_relative 'fast_ignore/gitignore_rule_scanner'
+  require_relative 'fast_ignore/rule_group'
+  require_relative 'fast_ignore/matchers/unmatchable'
+  require_relative 'fast_ignore/matchers/shebang_regexp'
+  require_relative 'fast_ignore/gitconfig_parser'
+  require_relative 'fast_ignore/path_expander'
+  require_relative 'fast_ignore/candidate'
+  require_relative 'fast_ignore/relative_candidate'
+  require_relative 'fast_ignore/matchers/within_dir'
+  require_relative 'fast_ignore/matchers/allow_any_dir'
+  require_relative 'fast_ignore/matchers/allow_path_regexp'
+  require_relative 'fast_ignore/matchers/ignore_path_regexp'
+  require_relative 'fast_ignore/patterns'
+  require_relative 'fast_ignore/walkers/base'
+  require_relative 'fast_ignore/walkers/file_system'
+  require_relative 'fast_ignore/walkers/gitignore_collecting_file_system'
+  require_relative 'fast_ignore/gitignore_rule_group'
+  require_relative 'fast_ignore/builders/shebang'
+  require_relative 'fast_ignore/builders/gitignore'
+  require_relative 'fast_ignore/builders/shebang_or_gitignore'
 
   include ::Enumerable
 
-  # :nocov:
-  using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
-  using ::FastIgnore::Backports::DirEachChild if defined?(::FastIgnore::Backports::DirEachChild)
-  # :nocov:
-
-  def initialize(relative: false, root: nil, gitignore: :auto, follow_symlinks: false, **rule_set_builder_args)
-    @relative = relative
-    @follow_symlinks_method = ::File.method(follow_symlinks ? :stat : :lstat)
-    @gitignore_enabled = gitignore
-    @loaded_gitignore_files = ::Set[''] if gitignore
+  def initialize(relative: false, root: nil, gitignore: :auto, follow_symlinks: false, **rule_group_builder_args)
     @root = "#{::File.expand_path(root.to_s, Dir.pwd)}/"
-    @rule_sets = ::FastIgnore::RuleSets.new(root: @root, gitignore: gitignore, **rule_set_builder_args)
-
-    freeze
-  end
-
-  def each(&block)
-    return enum_for(:each) unless block_given?
-
-    dir_pwd = ::Dir.pwd
-    root_from_pwd = @root.start_with?(dir_pwd) ? ".#{@root.delete_prefix(dir_pwd)}" : @root
-
-    each_recursive(root_from_pwd, '', &block)
+    @gitignore = gitignore
+    @rule_group_builder_args = rule_group_builder_args
+    @follow_symlinks = follow_symlinks
+    @relative = relative
   end
 
-  def allowed?(path, directory: nil, content: nil, exists: nil, include_directories: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    full_path = ::File.expand_path(path, @root)
-    return false unless full_path.start_with?(@root)
-
-    begin
-      directory = directory.nil? ? @follow_symlinks_method.call(full_path).directory? : directory
-    rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
-      exists = false if exists.nil?
-      directory = false
-    end
-
-    return false if !include_directories && directory
-
-    exists = exists.nil? ? ::File.exist?(full_path) : exists
-
-    return false unless exists
-
-    relative_path = full_path.delete_prefix(@root)
-    load_gitignore_recursive(relative_path) if @gitignore_enabled
-
-    filename = ::File.basename(relative_path)
-    content = content.slice(/.*/) if content # we only care about the first line
-
-    @rule_sets.allowed_recursive?(relative_path, directory, full_path, filename, content)
+  def allowed?(path, directory: nil, content: nil, exists: nil, include_directories: false)
+    walker.allowed?(
+      path,
+      root: @root,
+      directory: directory,
+      content: content,
+      exists: exists,
+      include_directories: include_directories
+    )
   end
   alias_method :===, :allowed?
 
@@ -80,43 +58,28 @@ class FastIgnore
     method(:allowed?).to_proc
   end
 
-  private
+  def each(&block)
+    return enum_for(:each) unless block
 
-  def load_gitignore_recursive(path)
-    paths = []
-    while (path = ::File.dirname(path)) != '.'
-      paths << path
-    end
+    prefix = @relative ? '' : @root
 
-    paths.reverse_each { |p| load_gitignore(p) }
+    walker.each(@root, prefix, &block)
   end
 
-  def load_gitignore(parent_path, check_exists: true)
-    return if @loaded_gitignore_files.include?(parent_path)
+  def build
+    rule_groups = ::FastIgnore::RuleGroups.new(root: @root, gitignore: @gitignore, **@rule_group_builder_args)
 
-    @rule_sets.append_subdir_gitignore(relative_path: parent_path + '.gitignore', check_exists: check_exists)
+    walker_class = @gitignore ? ::FastIgnore::Walkers::GitignoreCollectingFileSystem : ::FastIgnore::Walkers::FileSystem
+    @walker = walker_class.new(rule_groups, follow_symlinks: @follow_symlinks)
 
-    @loaded_gitignore_files << parent_path
+    freeze
   end
 
-  def each_recursive(parent_full_path, parent_relative_path, &block) # rubocop:disable Metrics/MethodLength
-    children = ::Dir.children(parent_full_path)
-    load_gitignore(parent_relative_path, check_exists: false) if @gitignore_enabled && children.include?('.gitignore')
-
-    children.each do |filename|
-      full_path = parent_full_path + filename
-      relative_path = parent_relative_path + filename
-      dir = @follow_symlinks_method.call(full_path).directory?
-
-      next unless @rule_sets.allowed_unrecursive?(relative_path, dir, full_path, filename)
-
-      if dir
-        each_recursive(full_path + '/', relative_path + '/', &block)
-      else
-        yield(@relative ? relative_path : @root + relative_path)
-      end
-    rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
-      nil
-    end
+  private
+
+  def walker
+    build unless defined?(@walker)
+
+    @walker
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.17.4
 platform: ruby
 authors:
 - Dana Sherson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-03 00:00:00.000000000 Z
+date: 2022-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,6 +100,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
@@ -181,21 +195,32 @@ files:
 - LICENSE.txt
 - README.md
 - lib/fast_ignore.rb
-- lib/fast_ignore/backports.rb
-- lib/fast_ignore/file_root.rb
+- lib/fast_ignore/builders/gitignore.rb
+- lib/fast_ignore/builders/shebang.rb
+- lib/fast_ignore/builders/shebang_or_gitignore.rb
+- lib/fast_ignore/candidate.rb
 - lib/fast_ignore/gitconfig_parser.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_group.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
-- lib/fast_ignore/rule_set.rb
-- lib/fast_ignore/rule_sets.rb
-- lib/fast_ignore/shebang_rule.rb
-- lib/fast_ignore/unmatchable_rule.rb
+- lib/fast_ignore/matchers/allow_any_dir.rb
+- lib/fast_ignore/matchers/allow_path_regexp.rb
+- lib/fast_ignore/matchers/ignore_path_regexp.rb
+- lib/fast_ignore/matchers/shebang_regexp.rb
+- lib/fast_ignore/matchers/unmatchable.rb
+- lib/fast_ignore/matchers/within_dir.rb
+- lib/fast_ignore/path_expander.rb
+- lib/fast_ignore/path_regexp_builder.rb
+- lib/fast_ignore/patterns.rb
+- lib/fast_ignore/relative_candidate.rb
+- lib/fast_ignore/rule_group.rb
+- lib/fast_ignore/rule_groups.rb
 - lib/fast_ignore/version.rb
+- lib/fast_ignore/walkers/base.rb
+- lib/fast_ignore/walkers/file_system.rb
+- lib/fast_ignore/walkers/gitignore_collecting_file_system.rb
 homepage: https://github.com/robotdana/fast_ignore
 licenses:
 - MIT

data/lib/fast_ignore/backports.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-class FastIgnore
-  module Backports
-    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
-
-      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)
-
-            slice!(0..(str.length - 1))
-            self
-          end
-
-          # 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/file_root.rb

@@ -1,39 +0,0 @@
-# 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_rule_regexp_builder.rb

@@ -1,76 +0,0 @@
-# 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/rule.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-class FastIgnore
-  class Rule
-    attr_reader :negation
-    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 :squashable_type
-    attr_reader :rule
-
-    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
-
-      @squashable_type = if anchored && negation
-        1
-      elsif anchored
-        0
-      else
-        ::Float::NAN # because it doesn't equal itself
-      end
-
-      freeze
-    end
-
-    def file_only?
-      false
-    end
-
-    def shebang?
-      false
-    end
-
-    # :nocov:
-    def inspect
-      "#<Rule #{'!' if @negation}#{'/' if @anchored}#{@rule}#{'/' if @dir_only}>"
-    end
-    # :nocov:
-
-    def match?(relative_path, _full_path, _filename, _content)
-      @rule.match?(relative_path)
-    end
-  end
-end

data/lib/fast_ignore/rule_builder.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-class FastIgnore
-  module RuleBuilder
-    class << self
-      # :nocov:
-      using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
-      # :nocov:
-
-      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 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 = gitignore_rules('*/'.dup, allow, file_root)
-        rules.pop # don't want the include all children one.
-        rules << rule
-        rules
-      end
-
-      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
-end

data/lib/fast_ignore/rule_set.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-class FastIgnore
-  class RuleSet
-    attr_reader :gitignore
-    alias_method :gitignore?, :gitignore
-    undef :gitignore
-
-    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, nil] => true }
-      @allow = allow
-      @gitignore = gitignore
-
-      freeze unless gitignore?
-    end
-
-    def <<(other)
-      return unless other
-
-      @has_shebang_rules ||= other.has_shebang_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)
-      @allowed_recursive.fetch([relative_path, dir, content]) do |key|
-        @allowed_recursive[key] =
-          allowed_recursive?(::File.dirname(relative_path), true, nil, nil, nil) &&
-          allowed_unrecursive?(relative_path, dir, full_path, filename, content)
-      end
-    end
-
-    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?(relative_path, full_path, filename, content)
-      end
-
-      not @allow
-    end
-
-    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
-
-        first.squash(chunk)
-      end
-    end
-
-    def weight
-      @dir_rules.length + (@has_shebang_rules ? 10 : 0)
-    end
-
-    def empty?
-      @dir_rules.empty? && @file_rules.empty?
-    end
-
-    protected
-
-    attr_reader :dir_rules
-    attr_reader :file_rules
-    attr_reader :has_shebang_rules
-  end
-end