fast_ignore 0.12.1 → 0.15.2

data/lib/fast_ignore/backports.rb

@@ -2,12 +2,12 @@
 
 class FastIgnore
   module Backports
-    ruby_major, ruby_minor = RUBY_VERSION.split('.', 2)
+    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) - ['.', '..']
+            ::Dir.entries(path) - ['.', '..']
           end
         end
       end

data/lib/fast_ignore/file_root.rb

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class GitignoreIncludeRuleBuilder < GitignoreRuleBuilder
+    # :nocov:
+    using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
+    # :nocov:
+
+    def initialize(rule, file_path, expand_path_from = nil)
+      super(rule, file_path)
+
+      @parent_segments = []
+      @negation = true
+      @expand_path_from = expand_path_from
+    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, ::FastIgnore::UnmatchableRule
+    end
+
+    def nothing_emitted?
+      @re.empty? && @parent_segments.empty?
+    end
+
+    def emit_dir
+      anchored!
+
+      @parent_segments << @re
+      @re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+    end
+
+    def emit_end
+      @dir_only || @re.append_end_dir_or_anchor
+      break!
+    end
+
+    def parent_dir_re # rubocop:disable Metrics/MethodLength
+      segment_joins_count = @parent_segments.length
+      parent_prefix = if @file_path
+        segment_joins_count += @file_path.escaped_segments_length
+
+        if @anchored
+          "\\A#{@file_path.escaped_segments_joined}"
+        else
+          "\\A#{@file_path.escaped_segments_joined}(?:.*/)?"
+        end
+      else
+        prefix
+      end
+
+      out = parent_prefix.dup
+      unless @parent_segments.empty?
+        out << '(?:'
+        out << @parent_segments.join('/(?:')
+        out << '/'
+      end
+      out << (')?' * segment_joins_count)
+      out
+    end
+
+    def build_parent_dir_rule
+      # Regexp::IGNORECASE = 1
+      ::FastIgnore::Rule.new(::Regexp.new(parent_dir_re, 1), true, anchored_or_file_path, true)
+    end
+
+    def build_child_file_rule
+      # Regexp::IGNORECASE = 1
+      ::FastIgnore::Rule.new(@re.append_dir.to_regexp, @negation, anchored_or_file_path, false)
+    end
+
+    def build_rule
+      joined_re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+      joined_re.append(@parent_segments.join('/'))
+      joined_re.append_dir unless @parent_segments.empty?
+      joined_re.append(@re)
+      @re = joined_re
+
+      rules = [super, build_parent_dir_rule]
+      (rules << build_child_file_rule) if @dir_only
+      rules
+    end
+
+    def process_rule
+      expand_rule_path if @expand_path_from
+      super
+    end
+  end
+end

data/lib/fast_ignore/gitignore_rule_builder.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class GitignoreRuleBuilder # rubocop:disable Metrics/ClassLength
+    def initialize(rule, file_path)
+      @re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+      @s = ::FastIgnore::GitignoreRuleScanner.new(rule)
+
+      @file_path = file_path
+      @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_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
+      return true unless @s.star_end?
+
+      @re.append_many_non_dir
+      emit_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/AbcSize, 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
+            @re.append_any_dir
+            anchored!
+          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 # rubocop:disable Metrics/MethodLength
+      out = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+      if @file_path
+        out.append_start_anchor.append(@file_path.escaped)
+        out.append_any_dir unless @anchored
+      else
+        if @anchored
+          out.append_start_anchor
+        else
+          out.append_start_dir_or_anchor
+        end
+      end
+      out
+    end
+
+    def build_rule
+      @re.prepend(prefix)
+      ::FastIgnore::Rule.new(@re.to_regexp, @negation, anchored_or_file_path, @dir_only)
+    end
+
+    def anchored_or_file_path
+      @anchored || @file_path
+    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/fast_ignore/gitignore_rule_regexp_builder.rb

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  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 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