fast_ignore 0.17.2 → 0.17.4

data/lib/fast_ignore/matchers/shebang_regexp.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Matchers
+    class ShebangRegexp
+      attr_reader :squash_id
+      attr_reader :rule
+
+      def initialize(rule, negation)
+        @rule = rule
+        @return_value = negation ? :allow : :ignore
+        @squash_id = negation ? :allow_shebang : :ignore_shebang
+
+        freeze
+      end
+
+      def squash(list)
+        self.class.new(::Regexp.union(list.map(&:rule)), @return_value == :allow)
+      end
+
+      def file_only?
+        true
+      end
+
+      def dir_only?
+        false
+      end
+
+      # :nocov:
+      def inspect
+        "#<ShebangRegexp #{@return_value} /#{@rule.to_s[26..-4]}/>"
+      end
+      # :nocov:
+
+      def match?(candidate)
+        return false if candidate.filename.include?('.')
+
+        @return_value if candidate.first_line.match?(@rule)
+      end
+
+      def weight
+        2
+      end
+    end
+  end
+end

data/lib/fast_ignore/matchers/unmatchable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Matchers
+    module Unmatchable
+      class << self
+        def dir_only?
+          false
+        end
+
+        def file_only?
+          false
+        end
+
+        def weight
+          0
+        end
+
+        # :nocov:
+        def inspect
+          '#<Unmatchable>'
+        end
+        # :nocov:
+
+        def match?(_)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/fast_ignore/matchers/within_dir.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Matchers
+    class WithinDir
+      attr_reader :weight
+
+      def initialize(matchers, root)
+        @dir_matchers = squash_matchers(matchers.reject(&:file_only?))
+        @file_matchers = squash_matchers(matchers.reject(&:dir_only?))
+
+        @weight = @dir_matchers.sum(&:weight) + @file_matchers.sum(&:weight)
+        @root = root
+
+        freeze
+      end
+
+      def match?(candidate)
+        relative_candidate = candidate.relative_to(@root)
+        return false unless relative_candidate
+
+        (candidate.directory? ? @dir_matchers : @file_matchers).reverse_each do |rule|
+          val = rule.match?(relative_candidate)
+          return val if val
+        end
+
+        false
+      end
+
+      def empty?
+        @dir_matchers.empty? && @file_matchers.empty?
+      end
+
+      private
+
+      def squash_matchers(matchers)
+        return matchers if matchers.empty?
+
+        matchers -= [::FastIgnore::Matchers::Unmatchable]
+        return [::FastIgnore::Matchers::Unmatchable] if matchers.empty?
+
+        matchers.chunk_while { |a, b| a.squash_id == b.squash_id }.map do |chunk|
+          next chunk.first if chunk.length == 1
+
+          chunk.first.squash(chunk)
+        end
+      end
+    end
+  end
+end

data/lib/fast_ignore/path_expander.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module PathExpander
+    def self.expand_path(path, dir)
+      ::File.expand_path(path, dir)
+    rescue ::ArgumentError
+      ::File.expand_path("./#{path}", dir)
+    end
+  end
+end

data/lib/fast_ignore/path_regexp_builder.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class PathRegexpBuilder
+    def initialize
+      @string = +''
+    end
+
+    def to_regexp
+      # Regexp::IGNORECASE = 1
+      ::Regexp.new(@string, 1)
+    end
+
+    # String methods
+
+    def dup
+      out = super
+
+      @string = @string.dup
+
+      out
+    end
+
+    def to_str
+      @string
+    end
+    alias_method :to_s, :to_str
+
+    def empty?
+      @string.empty?
+    end
+
+    def end_with?(str)
+      @string.end_with?(str)
+    end
+
+    def append(value)
+      @string.<<(value)
+
+      self
+    rescue FrozenError
+      # :nocov:
+      # the string seems to become inadvertently frozen in 2.5 and 2.6 with specific inputs
+      # and i don't understand why
+      # it seems like it's happening during the Regexp.new
+      # for some reason that i don't understand
+      @string = @string.dup
+      append(value)
+      # :nocov:
+    end
+    alias_method :<<, :append
+
+    def prepend(value)
+      @string.prepend(value)
+
+      self
+    rescue FrozenError
+      # :nocov:
+      # the string seems to become inadvertently frozen in 2.5 and 2.6 with specific inputs
+      # and i don't understand why
+      # it seems like it's happening during the Regexp.new
+      # for some reason that i don't understand
+      @string = @string.dup
+      prepend(value)
+      # :nocov:
+    end
+
+    # builder methods
+
+    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_dir_or_start_anchor
+      append('(?:\\A|/)')
+    end
+
+    def append_dir_or_end_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/patterns.rb

@@ -0,0 +1,33 @@
+# frozen-string-literal: true
+
+class FastIgnore
+  class Patterns
+    def initialize(*patterns, from_file: nil, format: :gitignore, root: nil)
+      if from_file
+        @root = root || ::File.dirname(from_file)
+        @patterns = ::File.exist?(from_file) ? ::File.readlines(from_file) : []
+      else
+        @root = root || ::Dir.pwd
+        @patterns = patterns.flatten.flat_map { |string| string.to_s.lines }
+      end
+      @root += '/' unless @root.end_with?('/')
+      @expand_path_with = (@root if format == :expand_path)
+    end
+
+    def build_matchers(allow: false) # rubocop:disable Metrics/MethodLength
+      matchers = @patterns.flat_map do |p|
+        ::FastIgnore::Builders::ShebangOrGitignore.build(p, allow, expand_path_with: @expand_path_with)
+      end
+
+      return if matchers.empty?
+      return [::FastIgnore::Matchers::WithinDir.new(matchers, @root)] unless allow
+
+      [
+        ::FastIgnore::Matchers::WithinDir.new(matchers, @root),
+        ::FastIgnore::Matchers::WithinDir.new(
+          ::FastIgnore::GitignoreIncludeRuleBuilder.new(@root).build_as_parent, '/'
+        )
+      ]
+    end
+  end
+end

data/lib/fast_ignore/relative_candidate.rb

@@ -0,0 +1,20 @@
+# frozen-string-literal: true
+
+class FastIgnore
+  class RelativeCandidate
+    attr_reader :relative_path
+
+    def initialize(relative_path, root_candidate)
+      @relative_path = relative_path
+      @root_candidate = root_candidate
+    end
+
+    def filename
+      @root_candidate.filename
+    end
+
+    def first_line
+      @root_candidate.first_line
+    end
+  end
+end

data/lib/fast_ignore/rule_group.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class RuleGroup
+    def initialize(patterns, allow)
+      @matchers = Array(patterns).flat_map { |x| x.build_matchers(allow: allow) }.compact
+      @allow = allow
+      @allowed_recursive = { ::FastIgnore::Candidate.root.key => true }.compare_by_identity
+    end
+
+    def empty?
+      @matchers.empty? || @matchers.all?(&:empty?)
+    end
+
+    def weight
+      @matchers.sum(&:weight)
+    end
+
+    def freeze
+      @matchers.freeze
+
+      super
+    end
+
+    def allowed_recursive?(candidate)
+      @allowed_recursive.fetch(candidate.key) do
+        @allowed_recursive[candidate.key] =
+          allowed_recursive?(candidate.parent) &&
+          allowed_unrecursive?(candidate)
+      end
+    end
+
+    def allowed_unrecursive?(candidate)
+      @matchers.reverse_each do |matcher|
+        val = matcher.match?(candidate)
+        return val == :allow if val
+      end
+
+      not @allow
+    end
+  end
+end

data/lib/fast_ignore/rule_groups.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class RuleGroups
+    def initialize( # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize, Metrics/MethodLength
+      root:,
+      ignore_rules: nil,
+      ignore_files: nil,
+      gitignore: true,
+      include_rules: nil,
+      include_files: nil,
+      argv_rules: nil
+    )
+      @array = []
+      if gitignore
+        @gitignore_rule_group = ::FastIgnore::GitignoreRuleGroup.new(root)
+        @array << @gitignore_rule_group
+      end
+      @array << ::FastIgnore::RuleGroup.new(::FastIgnore::Patterns.new(ignore_rules, root: root), false).freeze
+      @array << ::FastIgnore::RuleGroup.new(::FastIgnore::Patterns.new(include_rules, root: root), true).freeze
+      @array << ::FastIgnore::RuleGroup.new(
+        ::FastIgnore::Patterns.new(argv_rules, root: root, format: :expand_path),
+        true
+      ).freeze
+
+      Array(ignore_files).each do |f|
+        path = PathExpander.expand_path(f, root)
+        @array << ::FastIgnore::RuleGroup.new(::FastIgnore::Patterns.new(from_file: path), false).freeze
+      end
+      Array(include_files).each do |f|
+        path = PathExpander.expand_path(f, root)
+        @array << ::FastIgnore::RuleGroup.new(::FastIgnore::Patterns.new(from_file: path), true).freeze
+      end
+      @array.reject!(&:empty?)
+      @array.sort_by!(&:weight)
+      @array.freeze
+    end
+
+    def allowed_recursive?(candidate)
+      @array.all? { |r| r.allowed_recursive?(candidate) }
+    end
+
+    def allowed_unrecursive?(candidate)
+      @array.all? { |r| r.allowed_unrecursive?(candidate) }
+    end
+
+    def add_gitignore(dir)
+      @gitignore_rule_group.add_gitignore(dir)
+    end
+
+    def add_gitignore_to_root(path)
+      @gitignore_rule_group.add_gitignore_to_root(path)
+    end
+  end
+end

data/lib/fast_ignore/version.rb

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

data/lib/fast_ignore/walkers/base.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+class FastIgnore
+  module Walkers
+    class Base
+      def initialize(rule_groups, follow_symlinks:)
+        warn 'FastIgnore deprecation: follow_symlinks argument is deprecated' if follow_symlinks
+
+        @follow_symlinks = follow_symlinks
+        @rule_groups = rule_groups
+      end
+
+      private
+
+      def directory?(full_path, directory)
+        if !directory.nil?
+          directory
+        elsif @follow_symlinks
+          ::File.stat(full_path).directory?
+        else
+          ::File.lstat(full_path).directory?
+        end
+      end
+    end
+  end
+end

data/lib/fast_ignore/walkers/file_system.rb

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+
+class FastIgnore
+  module Walkers
+    class FileSystem < Base
+      def allowed?(path, root: Dir.pwd, directory: nil, content: nil, exists: nil, include_directories: false) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+        full_path = PathExpander.expand_path(path, root)
+        return false unless full_path.start_with?(root)
+
+        begin
+          dir = directory?(full_path, directory)
+        rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
+          nil
+        end
+
+        return false if !include_directories && dir
+
+        candidate = ::FastIgnore::Candidate.new(full_path, nil, dir, exists, content)
+
+        return false unless candidate.exists?
+
+        @rule_groups.allowed_recursive?(candidate)
+      end
+
+      def each(parent_full_path, parent_relative_path, &block) # rubocop:disable Metrics/MethodLength
+        ::Dir.children(parent_full_path).each do |filename|
+          full_path = parent_full_path + filename
+          dir = directory?(full_path, nil)
+          candidate = ::FastIgnore::Candidate.new(full_path, filename, dir, true, nil)
+
+          next unless @rule_groups.allowed_unrecursive?(candidate)
+
+          relative_path = parent_relative_path + filename
+
+          if dir
+            each(full_path + '/', relative_path + '/', &block)
+          else
+            yield(relative_path)
+          end
+        rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fast_ignore/walkers/gitignore_collecting_file_system.rb

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+
+class FastIgnore
+  module Walkers
+    class GitignoreCollectingFileSystem < Base
+      def allowed?(path, root: Dir.pwd, directory: nil, content: nil, exists: nil, include_directories: false) # rubocop:disable Metrics/ParameterLists
+        full_path = PathExpander.expand_path(path, root)
+        return false unless full_path.start_with?(root)
+
+        candidate = ::FastIgnore::Candidate.new(full_path, nil, directory, exists, content)
+
+        begin
+          return false if !include_directories && directory?(full_path, directory)
+        rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
+          # nil
+        end
+
+        return false unless candidate.exists?
+
+        @rule_groups.add_gitignore_to_root(full_path)
+        @rule_groups.allowed_recursive?(candidate)
+      end
+
+      def each(parent_full_path, parent_relative_path, &block) # rubocop:disable Metrics/MethodLength
+        children = ::Dir.children(parent_full_path)
+        @rule_groups.add_gitignore(parent_full_path) if children.include?('.gitignore')
+
+        children.each do |filename|
+          full_path = parent_full_path + filename
+          dir = directory?(full_path, nil)
+          candidate = ::FastIgnore::Candidate.new(full_path, filename, dir, true, nil)
+
+          next unless @rule_groups.allowed_unrecursive?(candidate)
+
+          relative_path = parent_relative_path + filename
+
+          if dir
+            each(full_path + '/', relative_path + '/', &block)
+          else
+            yield(relative_path)
+          end
+        rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
+          nil
+        end
+      end
+    end
+  end
+end