fast_ignore 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69021259195d30c9d3eb2e4461a779ef70b67d664370c5dff06d79f16ff009cb
-  data.tar.gz: f3e60391822c26b461316389277f3901801c89e1dfcea59e819976d2b4c4b761
+  metadata.gz: f3d94c089fb5c75d6c9d0650d2391d03425c487c81296495f44f35ed1f6d80ac
+  data.tar.gz: a9bba05df8121aa49d38b39c7aaaa0e3c7d2b30e4b874d083fe517fa36846b97
 SHA512:
-  metadata.gz: c99e8a9d3be9addeca4d18d327e450b9d6c345b6db354beb612e7f7e999af743d4ee4f62df9b1be0dec4a03820f948c52f8cb53d202ff8d3242499bbc453da87
-  data.tar.gz: 2d17fe903303a913df5d763789517897e7c444c89069b3f81ce28df0136c1c5c6a94fd1c6f8080e17291713a75da4246da67c1c86a90c89a9084137276ba0b4d
+  metadata.gz: e8954fbef86b13d7948744b2c803319b261d67b6afe83412f1e099a377b17adae2aa1106a3445e6f5604449130c8dfc815331fe104f205ca09b87f5ff8caa69e
+  data.tar.gz: e53891e9d8b056a62ede7399695deb2911d5836ad5b8442b2ef90d7876fb4d794f1665697df6e7eeecf616f828217fce841f96c9bdfd39e73ae6c89594a65d5c

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.10.1
+- Add option to follow symlinks (turns out i needed it)
+- performance improvements
+
 # v0.10.0
 - patterns with middle slashes are anchored to the root (like the gitignore documentation, now that it more clearly explains)
 - new shebang pattern (#!:), the previous version was extremely janky.
@@ -6,7 +10,6 @@
 - documentation improvements
 - root can be given as a path relative to PWD
 - includes with 'a/**/d' now matches a/b/c/d properly
--
 
 # v0.9.0
 - speed improvements, which may break things (Specifically, only using relative paths internally, is about 30% faster (depending on root depth))

data/README.md

@@ -50,12 +50,20 @@ FastIgnore.new.each.with_index { |file, index| puts "#{file}#{index}" }
 ```
 
 ### `relative: true`
-By default, FastIgnore will return full paths. To return paths relative to the current working directory, use:
+By default, FastIgnore will return full paths. To return paths relative to the current working directory, or the supplied [`root:`](#root), use:
 
 ```ruby
 FastIgnore.new(relative: true).to_a
 ```
 
+### `follow_symlinks: true`
+By default, FastIgnore will match git's behaviour and not follow symbolic links.
+To make it follow symlinks, use:
+
+```ruby
+FastIgnore.new(follow_symlinks: true).to_a
+```
+
 ### `root:`
 
 By default, root is PWD (the current working directory)
@@ -200,11 +208,10 @@ This does unfortunately lose the file path as the root for `/` and `/**` rules.
 ## Known issues
 - Doesn't take into account project excludes in `.git/info/exclude`
 - Doesn't take into account globally ignored files in `git config core.excludesFile`.
-- Doesn't follow this rule in the gitignore documentation because I don't understand what it means that isn't covered by other rules:
-
-  > [If the pattern does not contain a slash /, Git treats it as a shell glob pattern and checks for a match against the pathname relative to the location of the `.gitignore` file (relative to the toplevel of the work tree if not from a `.gitignore` file)](https://www.git-scm.com/docs/gitignore#_pattern_format)
+- Doesn't know what to do if you change the current working directory inside the `FastIgnore#each` block.
+  So don't do that.
 
-  if someone can explain it with examples [make an issue please](https://github.com/robotdana/fast_ignore/issues/new)
+  (It does handle changing the current working directory between `FastIgnore#allowed?` calls.)
 
 ## Development
 

data/bin/ls

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env ruby --disable-all
 # frozen_string_literal: true
 
 require_relative '../lib/fast_ignore'

data/bin/time

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'open3'
+RUNS = 30
+SCRIPT = "time #{__dir__}/ls"
+Dir.chdir ARGV[0] do
+  times = Array.new(RUNS).map do
+    run_times = Open3.capture3(SCRIPT)[1]
+    puts run_times.lstrip
+    run_times.scan(/(?:\d+(?:.\d+)?)/)
+  end
+
+  puts format(
+    "\e[1mAverage:\n\e[32m%0.2f real         %0.2f user         %0.2f sys\e[0m", # rubocop:disable Style/FormatStringToken
+    *times.transpose.map { |n| (n.map(&:to_f).sum / RUNS) }
+  )
+end

data/fast_ignore.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '>= 1.17'
-  spec.add_development_dependency 'leftovers', '>= 0.2.1'
+  spec.add_development_dependency 'leftovers', '>= 0.2.2'
   spec.add_development_dependency 'pry', '> 0'
   spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'

data/lib/fast_ignore.rb

@@ -2,8 +2,8 @@
 
 require_relative './fast_ignore/backports'
 
-require_relative './fast_ignore/rule_parser'
 require_relative './fast_ignore/rule_set_builder'
+require_relative './fast_ignore/rule_builder'
 require_relative './fast_ignore/rule_set'
 require_relative './fast_ignore/rule'
 
@@ -22,70 +22,61 @@ class FastIgnore
   end
   # :nocov:
 
-  def initialize( # rubocop:disable Metrics/MethodLength
-    relative: false,
-    root: nil,
-    include_shebangs: nil,
-    **rule_set_builder_args
-  )
-    # :nocov:
-    if include_shebangs && !Array(include_shebangs).empty?
-
-      warn <<~WARNING
-        Removed FastIgnore `include_shebangs:` argument.
-        It will be ignored. Please replace with the include_rules: in the shebang format
-        https://github.com/robotdana/fast_ignore#shebang-rules
-      WARNING
-    end
-    # :nocov:
-
-    root = root ? File.expand_path(root, ::Dir.pwd) : ::Dir.pwd
-    @root = "#{root}/"
-
-    @rule_sets = ::FastIgnore::RuleSetBuilder.from_args(root: @root, **rule_set_builder_args)
+  def initialize(relative: false, root: nil, follow_symlinks: false, **rule_set_builder_args)
     @relative = relative
+    @follow_symlinks = follow_symlinks
+    dir_pwd = Dir.pwd
+    @root = "#{::File.expand_path(root.to_s, dir_pwd)}/"
+    @rule_sets = ::FastIgnore::RuleSetBuilder.build(root: @root, **rule_set_builder_args)
 
     freeze
   end
 
   def each(&block)
-    if block_given?
-      each_allowed(&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)
+  end
+
+  def directory?(path)
+    if @follow_symlinks
+      ::File.stat(path).directory?
     else
-      enum_for(:each_allowed)
+      ::File.lstat(path).directory?
     end
   end
 
   def allowed?(path)
     full_path = ::File.expand_path(path, @root)
     return false unless full_path.start_with?(@root)
-
-    dir = ::File.lstat(full_path).directory?
-    return false if dir
+    return false if directory?(full_path)
 
     relative_path = full_path.delete_prefix(@root)
     filename = ::File.basename(relative_path)
 
-    @rule_sets.all? { |r| r.allowed_recursive?(relative_path, dir, filename) }
+    @rule_sets.all? { |r| r.allowed_recursive?(relative_path, false, filename) }
   rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
     false
   end
 
   private
 
-  def each_allowed(full_path = @root, relative_path = '', &block) # rubocop:disable Metrics/MethodLength
-    ::Dir.each_child(full_path) do |filename|
+  def each_recursive(parent_full_path, parent_relative_path, &block) # rubocop:disable Metrics/MethodLength
+    ::Dir.each_child(parent_full_path) do |filename|
       begin
-        full_child = full_path + filename
-        relative_child = relative_path + filename
-        dir = ::File.lstat(full_child).directory?
+        full_path = parent_full_path + filename
+        relative_path = parent_relative_path + filename
+        dir = directory?(full_path)
 
-        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir, filename) }
+        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, dir, filename) }
 
         if dir
-          each_allowed("#{full_child}/", "#{relative_child}/", &block)
+          each_recursive(full_path + '/', relative_path + '/', &block)
         else
-          yield(@relative ? relative_child : full_child)
+          yield(@relative ? relative_path : @root + relative_path)
         end
       rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
         nil

data/lib/fast_ignore/rule.rb

@@ -10,18 +10,20 @@ class FastIgnore
 
     attr_reader :negation
     alias_method :negation?, :negation
+
     attr_reader :dir_only
     alias_method :dir_only?, :dir_only
-    attr_reader :file_only
-    alias_method :file_only?, :file_only
 
     attr_reader :shebang
-    attr_reader :rule
+    alias_method :file_only?, :shebang
+
+    attr_reader :unanchored
+    alias_method :unanchored?, :unanchored
 
-    def initialize(rule, dir_only, file_only, negation, shebang = nil)
+    def initialize(rule, unanchored, dir_only, negation, shebang = nil)
       @rule = rule
+      @unanchored = unanchored
       @dir_only = dir_only
-      @file_only = file_only
       @negation = negation
       @shebang = shebang
 
@@ -31,9 +33,9 @@ class FastIgnore
     # :nocov:
     def inspect
       if shebang
-        "#<Rule #{'allow ' if negation?}#!:#{shebang.to_s[15..-4]}>"
+        "#<Rule #{'allow ' if @negation}#!:#{@shebang.to_s[15..-4]}>"
       else
-        "#<Rule #{'!' if negation?}#{rule}#{'/' if dir_only?}>"
+        "#<Rule #{'!' if @negation}#{@rule}#{'/' if @dir_only}>"
       end
     end
     # :nocov:
@@ -42,6 +44,7 @@ class FastIgnore
       if @shebang
         match_shebang?(path, filename)
       else
+        # 14 = FNMATCH_OPTIONS
         ::File.fnmatch?(@rule, path, 14)
       end
     end

data/lib/fast_ignore/rule_builder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module RuleBuilder
+    # rule or nil
+    class << self
+      # :nocov:
+      if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
+        require_relative 'backports/delete_prefix_suffix'
+        using ::FastIgnore::Backports::DeletePrefixSuffix
+      end
+      # :nocov:
+
+      def build(rule, allow, expand_path, file_root)
+        strip(rule)
+
+        return shebang_rules(rule, allow) if remove_shebang(rule)
+        return [] if skip?(rule)
+
+        gitignore_rules(rule, allow, expand_path, file_root)
+      end
+
+      private
+
+      def strip(rule)
+        rule.chomp!
+        rule.rstrip! unless rule.end_with?('\\ ')
+      end
+
+      def remove_shebang(rule)
+        return unless rule.delete_prefix!('#!:')
+
+        rule.strip!
+
+        true
+      end
+
+      def shebang_rules(rule, allow)
+        rules = [::FastIgnore::Rule.new(nil, true, false, allow, /\A#!.*\b#{Regexp.escape(rule)}\b/.freeze)]
+        return rules unless allow
+
+        rules << ::FastIgnore::Rule.new('**/*', true, true, true)
+        rules
+      end
+
+      def skip?(rule)
+        rule.empty? || rule.start_with?('#')
+      end
+
+      def gitignore_rules(rule, allow, expand_path, file_root)
+        dir_only = extract_dir_only(rule)
+        negation = extract_negation(rule, allow)
+
+        expand_rule_path(rule, expand_path) if expand_path
+        unanchored = unanchored?(rule)
+        rule.delete_prefix!('/')
+
+        rule.prepend("#{file_root}#{'**/' if unanchored}") if file_root || unanchored
+
+        build_gitignore_rules(rule, unanchored, allow, dir_only, negation)
+      end
+
+      def extract_dir_only(rule)
+        rule.delete_suffix!('/')
+      end
+
+      def extract_negation(rule, allow)
+        return allow unless rule.delete_prefix!('!')
+
+        not allow
+      end
+
+      EXPAND_PATH_RE = %r{^(?:[~/]|\.{1,2}/)}.freeze
+      def expand_rule_path(rule, root)
+        rule.replace(::File.expand_path(rule)) if rule.match?(EXPAND_PATH_RE)
+        rule.delete_prefix!(root)
+        rule.prepend('/') unless rule.start_with?('*') || rule.start_with?('/')
+      end
+
+      def unanchored?(rule)
+        not rule.include?('/') # we've already removed the trailing '/' with extract_dir_only
+      end
+
+      def build_gitignore_rules(rule, unanchored, allow, dir_only, negation)
+        rules = [::FastIgnore::Rule.new(rule.freeze, unanchored, dir_only, negation)]
+        return rules unless allow
+
+        rules << ::FastIgnore::Rule.new("#{rule}/**/*", unanchored, false, negation)
+        rules + ancestor_rules(rule, unanchored)
+      end
+
+      def ancestor_rules(parent, unanchored)
+        ancestor_rules = []
+
+        while (parent = ::File.dirname(parent)) != '.'
+          rule = ::File.basename(parent) == '**' ? "#{parent}/*" : parent.freeze
+          ancestor_rules << ::FastIgnore::Rule.new(rule, unanchored, true, true)
+        end
+
+        ancestor_rules
+      end
+    end
+  end
+end

data/lib/fast_ignore/rule_set.rb

@@ -2,12 +2,15 @@
 
 class FastIgnore
   class RuleSet
-    def initialize(allow: false)
-      @dir_rules = []
-      @file_rules = []
+    def initialize(rules, allow)
+      @dir_rules = rules.reject(&:file_only?).freeze
+      @file_rules = rules.reject(&:dir_only?).freeze
+      @any_not_anchored = rules.any?(&:unanchored?)
+      @has_shebang_rules = rules.any?(&:shebang)
       @allowed_recursive = { '.' => true }
-      @any_not_anchored = false
       @allow = allow
+
+      freeze
     end
 
     def freeze
@@ -26,21 +29,10 @@ class FastIgnore
 
     def allowed_unrecursive?(path, dir, filename)
       (dir ? @dir_rules : @file_rules).reverse_each do |rule|
-        # 14 = Rule::FNMATCH_OPTIONS
-
         return rule.negation? if rule.match?(path, filename)
       end
 
-      (not @allow) || (@any_not_anchored if dir)
-    end
-
-    def append_rules(anchored, rules)
-      rules.each do |rule|
-        (@dir_rules << rule) unless rule.file_only?
-        (@file_rules << rule) unless rule.dir_only?
-        @any_not_anchored ||= !anchored
-        @has_shebang_rules ||= rule.shebang
-      end
+      (not @allow) || (dir && @any_not_anchored)
     end
 
     def weight

data/lib/fast_ignore/rule_set_builder.rb

@@ -1,92 +1,87 @@
 # frozen_string_literal: true
 
 class FastIgnore
-  class RuleSetBuilder
-    # :nocov:
-    if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
-      require_relative 'backports/delete_prefix_suffix'
-      using ::FastIgnore::Backports::DeletePrefixSuffix
-    end
-    # :nocov:
+  module RuleSetBuilder
+    class << self
+      # :nocov:
+      if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
+        require_relative 'backports/delete_prefix_suffix'
+        using ::FastIgnore::Backports::DeletePrefixSuffix
+      end
+      # :nocov:
 
-    def self.from_args( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
-      root:,
-      ignore_rules: nil,
-      ignore_files: nil,
-      gitignore: :auto,
-      include_rules: nil,
-      include_files: nil,
-      argv_rules: nil
-    )
-      rule_sets = [
-        from_array(ignore_rules),
-        *from_files(ignore_files, project_root: root),
-        from_array('.git'),
-        from_gitignore_arg(gitignore, project_root: root),
-        from_array(include_rules, allow: true),
-        *from_files(include_files, allow: true, project_root: root),
-        from_array(argv_rules, allow: true, expand_path: root)
-      ]
+      def build( # rubocop:disable Metrics/ParameterLists
+        root:,
+        ignore_rules: nil,
+        ignore_files: nil,
+        gitignore: :auto,
+        include_rules: nil,
+        include_files: nil,
+        argv_rules: nil
+      )
+        prepare [
+          from_array(ignore_rules),
+          *from_files(ignore_files, project_root: root),
+          from_array('.git'),
+          from_gitignore_arg(gitignore, project_root: root),
+          from_array(include_rules, allow: true),
+          *from_files(include_files, allow: true, project_root: root),
+          from_array(argv_rules, allow: true, expand_path: root)
+        ]
+      end
 
-      rule_sets.compact!
-      rule_sets.reject!(&:empty?)
-      rule_sets.sort_by!(&:weight)
-      rule_sets
-    end
+      private
 
-    def self.from_file(filename, project_root:, allow: false)
-      filename = ::File.expand_path(filename, project_root)
-      raise FastIgnore::Error, "#{filename} is not within #{project_root}" unless filename.start_with?(project_root)
+      def prepare(rule_sets)
+        rule_sets.compact!
+        rule_sets.reject!(&:empty?)
+        rule_sets.sort_by!(&:weight)
+        rule_sets
+      end
 
-      file_root = "#{::File.dirname(filename)}/".delete_prefix(project_root)
-      rule_set = ::FastIgnore::RuleSet.new(allow: allow)
+      def from_file(filename, project_root:, allow: false)
+        filename = ::File.expand_path(filename, project_root)
+        raise FastIgnore::Error, "#{filename} is not within #{project_root}" unless filename.start_with?(project_root)
 
-      ::IO.foreach(filename) do |rule_string|
-        parse_rules(rule_string, allow: allow, rule_set: rule_set, file_root: file_root)
+        file_root = "#{::File.dirname(filename)}/".delete_prefix(project_root)
+        build_rule_set(::File.readlines(filename), allow, file_root: file_root)
       end
 
-      rule_set.freeze
-    end
-
-    def self.from_files(files, project_root:, allow: false)
-      Array(files).map do |file|
-        from_file(file, allow: allow, project_root: project_root)
+      def from_files(files, project_root:, allow: false)
+        Array(files).map do |file|
+          from_file(file, project_root: project_root, allow: allow)
+        end
       end
-    end
 
-    def self.from_gitignore_arg(gitignore, project_root:)
-      default_path = ::File.join(project_root, '.gitignore')
-      case gitignore
-      when :auto
-        from_file(default_path, project_root: project_root) if ::File.exist?(default_path)
-      when true
-        from_file(default_path, project_root: project_root)
+      def from_gitignore_arg(gitignore, project_root:)
+        default_path = ::File.join(project_root, '.gitignore')
+        case gitignore
+        when :auto
+          from_file(default_path, project_root: project_root) if ::File.exist?(default_path)
+        when true
+          from_file(default_path, project_root: project_root)
+        end
       end
-    end
 
-    def self.from_array(rules, allow: false, expand_path: false)
-      rules = Array(rules)
-      return if rules.empty?
+      def from_array(rules, allow: false, expand_path: false)
+        return unless rules
 
-      rule_set = ::FastIgnore::RuleSet.new(allow: allow)
+        rules = Array(rules)
 
-      rules.each do |rule_string|
-        rule_string.to_s.each_line do |rule_line|
-          parse_rules(rule_line, rule_set: rule_set, allow: allow, expand_path: expand_path)
-        end
+        return if rules.empty?
+
+        rules = rules.flat_map { |string| string.to_s.lines }
+
+        build_rule_set(rules, allow, expand_path: expand_path)
       end
 
-      rule_set.freeze
-    end
+      def build_rule_set(rules, allow, expand_path: false, file_root: nil)
+        rules = rules.flat_map do |rule|
+          ::FastIgnore::RuleBuilder.build(rule, allow, expand_path, file_root)
+        end
 
-    def self.parse_rules(rule_line, rule_set:, allow: false, expand_path: false, file_root: nil)
-      ::FastIgnore::RuleParser.new_rule(
-        rule_line,
-        rule_set: rule_set,
-        allow: allow,
-        expand_path: expand_path,
-        file_root: file_root
-      )
+        ::FastIgnore::RuleSet.new(rules, allow).freeze
+      end
     end
   end
 end

data/lib/fast_ignore/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-21 00:00:00.000000000 Z
+date: 2020-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.2
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -160,15 +160,15 @@ files:
 - Rakefile
 - bin/console
 - bin/ls
-- bin/ls-disable-gems
 - bin/setup
+- bin/time
 - fast_ignore.gemspec
 - lib/fast_ignore.rb
 - lib/fast_ignore/backports.rb
 - lib/fast_ignore/backports/delete_prefix_suffix.rb
 - lib/fast_ignore/backports/dir_each_child.rb
 - lib/fast_ignore/rule.rb
-- lib/fast_ignore/rule_parser.rb
+- lib/fast_ignore/rule_builder.rb
 - lib/fast_ignore/rule_set.rb
 - lib/fast_ignore/rule_set_builder.rb
 - lib/fast_ignore/version.rb

data/bin/ls-disable-gems

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby --disable-gems
-# frozen_string_literal: true
-
-require_relative '../lib/fast_ignore'
-
-puts FastIgnore.new(relative: true, argv_rules: ARGV).to_a

data/lib/fast_ignore/rule_parser.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-class FastIgnore
-  class RuleParser
-    # :nocov:
-    if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
-      require_relative 'backports/delete_prefix_suffix'
-      using ::FastIgnore::Backports::DeletePrefixSuffix
-    end
-    # :nocov:
-
-    # rule or nil
-    class << self
-      def new_rule(rule, rule_set:, allow: false, expand_path: false, file_root: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        rule = rule.dup
-        strip(rule)
-
-        return rule_set.append_rules(false, shebang_rules(rule, allow)) if extract_shebang(rule)
-
-        return if skip?(rule)
-
-        dir_only = extract_dir_only(rule)
-        negation = extract_negation(rule, allow)
-
-        expand_rule_path(rule, expand_path) if expand_path
-        anchored = anchored?(rule)
-        rule.delete_prefix!('/')
-
-        rule.prepend("#{file_root}#{'**/' unless anchored}") if file_root || (not anchored)
-
-        rule.freeze
-
-        rule_set.append_rules(
-          anchored,
-          rules(rule, allow, dir_only, negation)
-        )
-      end
-
-      private
-
-      def shebang_rules(rule, allow)
-        rules = [::FastIgnore::Rule.new(nil, false, true, allow, /\A#!.*\b#{Regexp.escape(rule)}\b/)]
-        return rules unless allow
-
-        rules << ::FastIgnore::Rule.new('**/*', true, false, true)
-        rules
-      end
-
-      def rules(rule, allow, dir_only, negation)
-        rules = [::FastIgnore::Rule.new(rule, dir_only, false, negation)]
-        return rules unless allow
-
-        rules << ::FastIgnore::Rule.new("#{rule}/**/*", false, false, negation)
-        rules + ancestor_rules(rule)
-      end
-
-      def ancestor_rules(parent)
-        ancestor_rules = []
-
-        while (parent = ::File.dirname(parent)) != '.'
-          rule = ::File.basename(parent) == '**' ? "#{parent}/*" : parent.freeze
-          ancestor_rules << ::FastIgnore::Rule.new(rule, true, false, true)
-        end
-
-        ancestor_rules
-      end
-
-      def extract_negation(rule, allow)
-        return allow unless rule.delete_prefix!('!')
-
-        not allow
-      end
-
-      def extract_dir_only(rule)
-        rule.delete_suffix!('/')
-      end
-
-      def strip(rule)
-        rule.chomp!
-        rule.rstrip! unless rule.end_with?('\\ ')
-      end
-
-      def anchored?(rule)
-        rule.include?('/') # we've already removed the trailing '/' with extract_dir_only
-      end
-
-      EXPAND_PATH_RE = %r{^(?:[~/]|\.{1,2}/)}.freeze
-      def expand_rule_path(rule, root)
-        rule.replace(::File.expand_path(rule)) if rule.match?(EXPAND_PATH_RE)
-        rule.delete_prefix!(root)
-        rule.prepend('/') unless rule.start_with?('*') || rule.start_with?('/')
-      end
-
-      def extract_shebang(rule)
-        rule.delete_prefix!('#!:') && (rule.strip! || true)
-      end
-
-      def skip?(rule)
-        rule.empty? || rule.start_with?('#')
-      end
-    end
-  end
-end