path_list 0.16

data/lib/path_list.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative './path_list/backports'
+
+require 'set'
+require 'strscan'
+require_relative 'path_list/rule_groups'
+require_relative 'path_list/global_gitignore'
+require_relative 'path_list/rule_builder'
+require_relative 'path_list/gitignore_rule_builder'
+require_relative 'path_list/gitignore_include_rule_builder'
+require_relative 'path_list/path_regexp_builder'
+require_relative 'path_list/gitignore_rule_scanner'
+require_relative 'path_list/rule_group'
+require_relative 'path_list/matchers/unmatchable'
+require_relative 'path_list/matchers/shebang_regexp'
+require_relative 'path_list/root_candidate'
+require_relative 'path_list/relative_candidate'
+require_relative 'path_list/matchers/within_dir'
+require_relative 'path_list/matchers/allow_any_dir'
+require_relative 'path_list/matchers/allow_path_regexp'
+require_relative 'path_list/matchers/ignore_path_regexp'
+require_relative 'path_list/patterns'
+require_relative 'path_list/walkers/file_system'
+require_relative 'path_list/walkers/gitignore_collecting_file_system'
+require_relative 'path_list/gitignore_rule_group'
+
+class PathList
+  class Error < StandardError; end
+
+  include ::Enumerable
+
+  # :nocov:
+  using ::PathList::Backports::DeletePrefixSuffix if defined?(::PathList::Backports::DeletePrefixSuffix)
+  using ::PathList::Backports::DirEachChild if defined?(::PathList::Backports::DirEachChild)
+  # :nocov:
+
+  def initialize(root: nil, gitignore: :auto, **rule_group_builder_args)
+    @root = "#{::File.expand_path(root.to_s, Dir.pwd)}/"
+    rule_groups = ::PathList::RuleGroups.new(root: @root, gitignore: gitignore, **rule_group_builder_args)
+
+    walker_class = gitignore ? ::PathList::Walkers::GitignoreCollectingFileSystem : ::PathList::Walkers::FileSystem
+    @walker = walker_class.new(rule_groups)
+    freeze
+  end
+
+  def allowed?(path, directory: nil, content: nil)
+    @walker.allowed?(path, directory: directory, content: content)
+  end
+  alias_method :===, :allowed?
+
+  def to_proc
+    method(:allowed?).to_proc
+  end
+
+  def each(root = ::Dir.pwd, &block)
+    return enum_for(:each, root) unless block_given?
+
+    root = "#{::File.expand_path(root.to_s, Dir.pwd)}/"
+    @walker.each(root, '', &block)
+  end
+end

data/lib/path_list/backports.rb

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class PathList
+  class GitignoreIncludeRuleBuilder < GitignoreRuleBuilder
+    # :nocov:
+    using ::PathList::Backports::DeletePrefixSuffix if defined?(::PathList::Backports::DeletePrefixSuffix)
+    # :nocov:
+
+    def initialize(rule, expand_path_with: nil)
+      super(rule)
+
+      @negation = true
+      @expand_path_from = expand_path_with
+    end
+
+    def expand_rule_path
+      anchored! unless @s.match?(/\*/)
+      return unless @s.match?(%r{(?:[~/]|\.{1,2}/|.*/\.\./)})
+
+      dir_only! if @s.match?(%r{.*/\s*\z})
+      @s.string.replace(::File.expand_path(@s.rest))
+      @s.string.delete_prefix!(@expand_path_from)
+      @s.pos = 0
+    end
+
+    def negated!
+      @negation = false
+    end
+
+    def unmatchable_rule!
+      throw :abort_build, ::PathList::Matchers::Unmatchable
+    end
+
+    def emit_end
+      if @dir_only
+        @child_re = @re.dup
+        @re.append_end_anchor
+      else
+        @re.append_dir_or_end_anchor
+      end
+
+      break!
+    end
+
+    def build_parent_dir_rules
+      return unless @negation
+
+      if @anchored
+        parent_pattern = @s.string.dup
+        if parent_pattern.sub!(%r{/[^/]+/?\s*\z}, '/')
+          ::PathList::GitignoreIncludeRuleBuilder.new(parent_pattern).build_as_parent
+        end
+      else
+        [::PathList::Matchers::AllowAnyDir]
+      end
+    end
+
+    def build_child_file_rule # rubocop:disable Metrics/MethodLength
+      if @child_re.end_with?('/')
+        @child_re.append_many_non_dir.append_dir if @dir_only
+      else
+        @child_re.append_dir
+      end
+
+      @child_re.prepend(prefix)
+
+      if @negation
+        ::PathList::Matchers::AllowPathRegexp.new(@child_re.to_regexp, @anchored, false)
+      else
+        ::PathList::Matchers::IgnorePathRegexp.new(@child_re.to_regexp, @anchored, false)
+      end
+    end
+
+    def build_as_parent
+      anchored!
+      dir_only!
+
+      catch :abort_build do
+        process_rule
+        build_rule(child_file_rule: false)
+      end
+    end
+
+    def build_rule(child_file_rule: true)
+      @child_re ||= @re.dup # in case emit_end wasn't called
+
+      [super(), *build_parent_dir_rules, (build_child_file_rule if child_file_rule)].compact
+    end
+
+    def process_rule
+      expand_rule_path if @expand_path_from
+      super
+    end
+  end
+end

data/lib/path_list/gitignore_rule_builder.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+class PathList
+  class GitignoreRuleBuilder # rubocop:disable Metrics/ClassLength
+    def initialize(rule)
+      @re = ::PathList::PathRegexpBuilder.new
+      @s = ::PathList::GitignoreRuleScanner.new(rule)
+
+      @negation = false
+      @anchored = false
+      @dir_only = false
+    end
+
+    def break!
+      throw :break
+    end
+
+    def blank!
+      throw :abort_build, []
+    end
+
+    def unmatchable_rule!
+      throw :abort_build, []
+    end
+
+    def negated!
+      @negation = true
+    end
+
+    def anchored!
+      @anchored ||= true
+    end
+
+    def never_anchored!
+      @anchored = :never
+    end
+
+    def dir_only!
+      @dir_only = true
+    end
+
+    def nothing_emitted?
+      @re.empty?
+    end
+
+    def emit_dir
+      anchored!
+      @re.append_dir
+    end
+
+    def emit_any_dir
+      anchored!
+      @re.append_any_dir
+    end
+
+    def emit_end
+      @re.append_end_anchor
+      break!
+    end
+
+    def process_backslash
+      return unless @s.backslash?
+
+      @re.append_escaped(@s.next_character) || unmatchable_rule!
+    end
+
+    def process_star_end_after_slash # rubocop:disable Metrics/MethodLength
+      if @s.star_end?
+        @re.append_many_non_dir
+        emit_end
+      elsif @s.two_star_end?
+        break!
+      elsif @s.star_slash_end?
+        @re.append_many_non_dir
+        dir_only!
+        emit_end
+      elsif @s.two_star_slash_end?
+        dir_only!
+        break!
+      else
+        true
+      end
+    end
+
+    def process_slash
+      return unless @s.slash?
+      return dir_only! if @s.end?
+      return unmatchable_rule! if @s.slash?
+
+      emit_dir
+      process_star_end_after_slash
+    end
+
+    def process_two_stars # rubocop:disable Metrics/MethodLength
+      return unless @s.two_stars?
+      return break! if @s.end?
+
+      if @s.slash?
+        if @s.end?
+          @re.append_any_non_dir
+          dir_only!
+        elsif @s.slash?
+          unmatchable_rule!
+        else
+          if nothing_emitted?
+            never_anchored!
+          else
+            emit_any_dir
+          end
+          process_star_end_after_slash
+        end
+      else
+        @re.append_any_non_dir
+      end
+    end
+
+    def process_character_class # rubocop:disable Metrics/MethodLength
+      return unless @s.character_class_start?
+
+      @re.append_character_class_open
+      @re.append_character_class_negation if @s.character_class_negation?
+      unmatchable_rule! if @s.character_class_end?
+
+      until @s.character_class_end?
+        next if process_backslash
+        next @re.append_character_class_dash if @s.dash?
+        next if @re.append_escaped(@s.character_class_literal)
+
+        unmatchable_rule!
+      end
+
+      @re.append_character_class_close
+    end
+
+    def process_end
+      blank! if nothing_emitted?
+
+      emit_end
+    end
+
+    def process_rule # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      anchored! if @s.slash?
+
+      catch :break do
+        loop do
+          next if process_backslash
+          next if process_slash
+          next if process_two_stars
+          next @re.append_any_non_dir if @s.star?
+          next @re.append_one_non_dir if @s.question_mark?
+          next if process_character_class
+          next if @re.append_escaped(@s.literal)
+          next if @re.append_escaped(@s.significant_whitespace)
+
+          process_end
+        end
+      end
+    end
+
+    def prefix
+      out = ::PathList::PathRegexpBuilder.new
+
+      if @anchored
+        out.append_start_anchor
+      else
+        out.append_dir_or_start_anchor
+      end
+      out
+    end
+
+    def build_rule
+      @re.prepend(prefix)
+      if @negation
+        ::PathList::Matchers::AllowPathRegexp.new(@re.to_regexp, @anchored, @dir_only)
+      else
+        ::PathList::Matchers::IgnorePathRegexp.new(@re.to_regexp, @anchored, @dir_only)
+      end
+    end
+
+    def build
+      catch :abort_build do
+        blank! if @s.hash?
+        negated! if @s.exclamation_mark?
+        process_rule
+
+        @anchored = false if @anchored == :never
+
+        build_rule
+      end
+    end
+  end
+end

data/lib/path_list/gitignore_rule_group.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+require 'set'
+
+class PathList
+  class GitignoreRuleGroup < ::PathList::RuleGroup
+    def initialize(root)
+      @root = root
+      @loaded_paths = Set[root]
+
+      super([
+        ::PathList::Patterns.new('.git', root: '/'),
+        ::PathList::Patterns.new(from_file: ::PathList::GlobalGitignore.path(root: root), root: root),
+        ::PathList::Patterns.new(from_file: "#{root}.git/info/exclude", root: root),
+        ::PathList::Patterns.new(from_file: "#{root}.gitignore", root: root)
+      ], false)
+    end
+
+    def add_gitignore(dir)
+      return if @loaded_paths.include?(dir)
+
+      @loaded_paths << dir
+      matcher = ::PathList::Patterns.new(from_file: "#{dir}.gitignore").build_matchers(include: false)
+      @matchers += matcher unless !matcher || matcher.empty?
+    end
+
+    def add_gitignore_to_root(path)
+      add_gitignore(path) until @loaded_paths.include?(path = "#{::File.dirname(path)}/")
+    end
+  end
+end