path_list 0.16

data/lib/path_list/gitignore_rule_scanner.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class PathList
+  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 two_star_end?
+      skip(/\*{2,}\s*\z/)
+    end
+
+    def star_slash_end?
+      skip(%r{\*/\s*\z})
+    end
+
+    def two_star_slash_end?
+      skip(%r{\*{2,}/\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/path_list/global_gitignore.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class PathList
+  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/path_list/matchers/allow_any_dir.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class PathList
+  module Matchers
+    module AllowAnyDir
+      class << self
+        def squash_id
+          :allow
+        end
+
+        def dir_only?
+          true
+        end
+
+        def file_only?
+          false
+        end
+
+        def shebang?
+          false
+        end
+
+        # :nocov:
+        def inspect
+          '#<AllowAnyDir>'
+        end
+        # :nocov:
+
+        def match?(_)
+          :allow
+        end
+      end
+    end
+  end
+end

data/lib/path_list/matchers/allow_path_regexp.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class PathList
+  module Matchers
+    class AllowPathRegexp
+      attr_reader :dir_only
+      alias_method :dir_only?, :dir_only
+      undef :dir_only
+
+      attr_reader :squash_id
+      attr_reader :rule
+
+      def initialize(rule, anchored, dir_only)
+        @rule = rule
+        @dir_only = dir_only
+        @anchored = anchored
+        @squash_id = anchored ? :allow : object_id
+
+        freeze
+      end
+
+      def squash(list)
+        self.class.new(::Regexp.union(list.map(&:rule)), @anchored, @dir_only)
+      end
+
+      def file_only?
+        false
+      end
+
+      def shebang?
+        false
+      end
+
+      # :nocov:
+      def inspect
+        "#<AllowPathRegexp #{'dir_only ' if @dir_only}#{@rule.inspect}>"
+      end
+      # :nocov:
+
+      def match?(candidate)
+        :allow if @rule.match?(candidate.relative_path)
+      end
+    end
+  end
+end

data/lib/path_list/matchers/ignore_path_regexp.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class PathList
+  module Matchers
+    class IgnorePathRegexp
+      attr_reader :dir_only
+      alias_method :dir_only?, :dir_only
+      undef :dir_only
+
+      attr_reader :squash_id
+      attr_reader :rule
+
+      def initialize(rule, anchored, dir_only)
+        @rule = rule
+        @dir_only = dir_only
+        @anchored = anchored
+        @squash_id = anchored ? :ignore : object_id
+
+        freeze
+      end
+
+      def squash(list)
+        self.class.new(::Regexp.union(list.map(&:rule)), @anchored, @dir_only)
+      end
+
+      def file_only?
+        false
+      end
+
+      def shebang?
+        false
+      end
+
+      # :nocov:
+      def inspect
+        "#<IgnorePathRegexp #{'dir_only ' if @dir_only}#{@rule.inspect}>"
+      end
+      # :nocov:
+
+      def match?(candidate)
+        :ignore if @rule.match?(candidate.relative_path)
+      end
+    end
+  end
+end

data/lib/path_list/matchers/shebang_regexp.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class PathList
+  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 shebang?
+        true
+      end
+    end
+  end
+end

data/lib/path_list/matchers/unmatchable.rb

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

data/lib/path_list/matchers/within_dir.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class PathList
+  module Matchers
+    class WithinDir
+      def initialize(matchers, root)
+        @dir_matchers = squash_matchers(matchers.reject(&:file_only?))
+        @file_matchers = squash_matchers(matchers.reject(&:dir_only?))
+        @has_shebang_matchers = matchers.any?(&:shebang?)
+        @root = root
+
+        freeze
+      end
+
+      def match?(root_candidate)
+        relative_candidate = root_candidate.relative_to(@root)
+        return false unless relative_candidate
+
+        (root_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
+
+      def weight
+        @dir_matchers.length + (@has_shebang_matchers ? 10 : 0)
+      end
+
+      private
+
+      def squash_matchers(matchers)
+        return matchers if matchers.empty?
+
+        matchers -= [::PathList::Matchers::Unmatchable]
+        return [::PathList::Matchers::Unmatchable] if matchers.empty?
+
+        matchers.chunk_while { |a, b| a.squash_id == b.squash_id }.map do |chunk|
+          next ::PathList::Matchers::AllowAnyDir if chunk.include?(::PathList::Matchers::AllowAnyDir)
+
+          chunk.uniq!(&:rule)
+          next chunk.first if chunk.length == 1
+
+          chunk.first.squash(chunk)
+        end
+      end
+    end
+  end
+end

data/lib/path_list/path_regexp_builder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class PathList
+  class PathRegexpBuilder < String
+    def to_regexp
+      # Regexp::IGNORECASE = 1
+      ::Regexp.new(self, 1)
+    end
+
+    def append_escaped(value)
+      return unless value
+
+      append_unescaped(::Regexp.escape(value))
+    end
+
+    def append_dir
+      append_unescaped('/')
+    end
+
+    def append_any_dir
+      append_unescaped('(?:.*/)?')
+    end
+
+    def append_one_non_dir
+      append_unescaped('[^/]')
+    end
+
+    def append_any_non_dir
+      append_one_non_dir
+      append_unescaped('*')
+    end
+
+    def append_many_non_dir
+      append_one_non_dir
+      append_unescaped('+')
+    end
+
+    def append_end_anchor
+      append_unescaped('\\z')
+    end
+
+    def append_start_anchor
+      append_unescaped('\\A')
+    end
+
+    def append_dir_or_start_anchor
+      append_unescaped('(?:\\A|/)')
+    end
+
+    def append_dir_or_end_anchor
+      append_unescaped('(?:/|\\z)')
+    end
+
+    def append_character_class_open
+      append_unescaped('(?!/)[')
+    end
+
+    def append_character_class_negation
+      append_unescaped('^')
+    end
+
+    def append_character_class_dash
+      append_unescaped('-')
+    end
+
+    def append_character_class_close
+      append_unescaped(']')
+    end
+
+    private
+
+    def append_unescaped(value)
+      self.<<(value)
+
+      self
+    end
+  end
+end