fast_ignore 0.10.2 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dd945c76bf226766ac86086faf839eac44c4c0cce452e2a3a44e7c47964b7f5
-  data.tar.gz: a72de31878713db71c94aa8067c87b807f19833eb008a1a6d6e673fcdeff5a7a
+  metadata.gz: f467113b0ee03faf028758ac176c59b3e51465684f8ffe144d432ba75133c10f
+  data.tar.gz: 2f6f0ce0babec00977a55595baa7ec806d7a9a3f1fec86df46f29475b41238cc
 SHA512:
-  metadata.gz: cff75a6418ecc958f2a839b9617554e3857763611248063aef27ec244dd0d1b433d61b81bfdb85a74dd8497fea8599f146ae723fd76023aef72285f53a620ecd
-  data.tar.gz: 39aeceb2cd078c8b873019b9763eccb01450e408a24c3fb04005f9451879e1a125bcd73f26a1c4e67e6c999e7d6d0f78b4a1b41abbc0a2650ec36bb1ac7adde6
+  metadata.gz: 3a7698e54ab0897b6b50c8638d41f3243bd3ba4ced559a5c7e01f6d365b6fb875b906a1924e96641572815748479eb793dfabc91da6f3bec62115f98ff39a392
+  data.tar.gz: 7e8b85ff838d04d1c16cd3eca5a480d6948342a07667760782840b0e36a706c02db2bb4e09e3370b3ccc1cdc2f38f9e893707c9f2128652a8a4aae4cdb8dd3d0

data/.spellr_wordlists/english.txt

@@ -10,8 +10,11 @@ enoent
 enumerables
 env
 errno
+esque
 extensionless
 fancyignore
+filesystem
+fnmatch
 frotz
 gemfile
 github
@@ -34,6 +37,7 @@ rspec
 rubo
 rubocop
 rubygems
+rubyish
 rulesets
 rvm
 sherson

data/.travis.yml

@@ -2,6 +2,7 @@
 sudo: false
 language: ruby
 cache: bundler
+before_install: gem install bundler
 rvm:
   - 2.4
   - 2.5

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.11.0
+- major performance improvement (use regexp rather than fnmatch)
+- optionally pass directory: and content: into allowed? if these are already loaded.
+
 # v0.10.2
 - add FastIgnore#=== as an alias for FastIgnore#allowed? so that FastIgnore objects can be used for case statements.
 - Fix shebangs in non-pwd-root situations

data/README.md

@@ -11,6 +11,16 @@ Filter a directory tree using a .gitignore file. Recognises all of the [gitignor
 FastIgnore.new(relative: true).sort == `git ls-files`.split("\n").sort
 ```
 
+## Features
+
+- Fast (faster than using `` `git ls-files`.split("\n") `` for small repos (because it avoids the overhead of ``` `` ```))
+- Supports ruby 2.4 - 2.7
+- supports all gitignore rule patterns
+- doesn't require git to be installed
+- supports a gitignore-esque "include" patterns. (`include_rules:`/`include_files:`)
+- supports an expansion of include patterns, matching expanded paths (`argv_rules:`)
+- supports matching by shebang rather than filename for extensionless files: `#!:`
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -62,7 +72,8 @@ FastIgnore.new.allowed?('~/home/path')
 This is aliased as `===` so you can use the FastIgnore object in case statements.
 ```ruby
 case my_path
-when FastIgnore.new then puts my_path
+when FastIgnore.new
+  puts(my_path)
 end
 ```
 
@@ -214,6 +225,15 @@ FastIgnore.new(argv_rules: ["my/rule", File.read('/my/path')]).to_a
 
 This does unfortunately lose the file path as the root for `/` and `/**` rules.
 
+### optimising #allowed?
+
+To avoid unnecessary calls to the filesystem, if your code already knows whether or not it's a directory, or if you're checking shebangs and you have already read the content of the file: use
+```ruby
+FastIgnore.new.allowed?('relative/path', directory: false, content: "#!/usr/bin/ruby\n\nputs 'ok'\n")
+```
+This is not required, and if FastIgnore does have to go to the filesystem for this information it's well optimised to only read what is necessary.
+
+
 ## 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`.
@@ -224,9 +244,13 @@ This does unfortunately lose the file path as the root for `/` and `/**` rules.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run the tests and linters.
+
+You can run `bin/console` for an interactive prompt that will allow you to experiment.
+`bin/ls [argv_rules]` will return something equivalent to `git ls-files` and `bin/time [argv_rules]` will give you the average time for 30 runs.
+This repo is too small to stress bin/time more than 0.01s, switch to a large repo and find the average time before and after changes.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 

data/bin/time

@@ -5,17 +5,17 @@
 # ensure nothing else is watching that dir in the filesystem e.g. webpack
 
 require 'open3'
+require 'shellwords'
 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
+SCRIPT = "time #{__dir__}/ls #{Shellwords.join(ARGV)}"
 
-  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) }
-  )
+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) }
+)

data/lib/fast_ignore.rb

@@ -7,6 +7,7 @@ require_relative './fast_ignore/rule_builder'
 require_relative './fast_ignore/rule_set'
 require_relative './fast_ignore/rule'
 require_relative './fast_ignore/shebang_rule'
+require_relative './fast_ignore/fn_match_to_re'
 
 class FastIgnore
   class Error < StandardError; end
@@ -14,13 +15,8 @@ class FastIgnore
   include ::Enumerable
 
   # :nocov:
-  if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
-    require_relative 'fast_ignore/backports/delete_prefix_suffix'
-    using ::FastIgnore::Backports::DeletePrefixSuffix
-
-    require_relative 'fast_ignore/backports/dir_each_child'
-    using ::FastIgnore::Backports::DirEachChild
-  end
+  using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
+  using ::FastIgnore::Backports::DirEachChild if defined?(::FastIgnore::Backports::DirEachChild)
   # :nocov:
 
   def initialize(relative: false, root: nil, follow_symlinks: false, **rule_set_builder_args)
@@ -41,23 +37,15 @@ class FastIgnore
     each_recursive(root_from_pwd, '', &block)
   end
 
-  def directory?(path)
-    if @follow_symlinks
-      ::File.stat(path).directory?
-    else
-      ::File.lstat(path).directory?
-    end
-  end
-
-  def allowed?(path)
+  def allowed?(path, directory: nil, content: nil)
     full_path = ::File.expand_path(path, @root)
     return false unless full_path.start_with?(@root)
-    return false if directory?(full_path)
+    return false if directory.nil? ? directory?(full_path) : directory
 
     relative_path = full_path.delete_prefix(@root)
     filename = ::File.basename(relative_path)
 
-    @rule_sets.all? { |r| r.allowed_recursive?(relative_path, false, full_path, filename) }
+    @rule_sets.all? { |r| r.allowed_recursive?(relative_path, false, full_path, filename, content) }
   rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
     false
   end
@@ -65,6 +53,14 @@ class FastIgnore
 
   private
 
+  def directory?(path)
+    if @follow_symlinks
+      ::File.stat(path).directory?
+    else
+      ::File.lstat(path).directory?
+    end
+  end
+
   def each_recursive(parent_full_path, parent_relative_path, &block) # rubocop:disable Metrics/MethodLength
     ::Dir.each_child(parent_full_path) do |filename|
       begin
@@ -72,7 +68,7 @@ class FastIgnore
         relative_path = parent_relative_path + filename
         dir = directory?(full_path)
 
-        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, dir, full_path, filename) }
+        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, dir, full_path, filename, nil) }
 
         if dir
           each_recursive(full_path + '/', relative_path + '/', &block)

data/lib/fast_ignore/backports.rb

@@ -2,15 +2,69 @@
 
 class FastIgnore
   module Backports
-    module_function
+    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 each_child(path, &block)
+            Dir.entries(path).each do |entry|
+              next if entry == '.' || entry == '..'
 
-    def ruby_version_less_than?(major, minor)
-      ruby_major, ruby_minor = RUBY_VERSION.split('.', 2)
+              block.call entry
+            end
+          end
+        end
+      end
 
-      return true if major > ruby_major.to_i
-      return true if minor > ruby_minor.to_i
+      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)
 
-      false
+            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/fast_ignore/fn_match_to_re.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module FNMatchToRegex
+    # This doesn't look rubyish because i ported it from rust (the only rust i ever wrote that worked)
+    class << self
+      def call(pattern) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        re = '\\A'.dup
+
+        in_character_group = false
+        has_characters_in_group = false
+        escape_next_character = false
+        last_char_opened_character_group = false
+        negated_character_group = false
+        stars = 0
+
+        pattern.each_char do |char| # rubocop:disable Metrics/BlockLength
+          if escape_next_character
+            re << Regexp.escape(char)
+            escape_next_character = false
+          elsif char == '\\' # single char, just needs to be escaped
+            escape_next_character = true
+          elsif in_character_group
+            if char == '/'
+              if negated_character_group
+                has_characters_in_group = true
+                re << char
+              end
+            elsif char == '^'
+              if last_char_opened_character_group
+                re << char
+                negated_character_group = true
+              else
+                re << '\\^'
+                has_characters_in_group = true
+              end
+              # not characters in group
+            elsif char == ']'
+              break unless has_characters_in_group
+
+              re << ']'
+              in_character_group = false
+              has_characters_in_group = false
+              negated_character_group = false
+              last_char_opened_character_group = false
+            elsif char == '-'
+              has_characters_in_group = true
+              re << char
+            else
+              has_characters_in_group = true
+              re << Regexp.escape(char)
+            end
+            last_char_opened_character_group = false
+          elsif char == '*'
+            stars += 1
+          elsif char == '/'
+            re << if stars >= 2
+              '(?:.*/)?'
+            elsif stars.positive?
+              '[^/]*/'
+            else
+              char
+            end
+            stars = 0
+          else
+            if stars.positive?
+              re << '[^/]*'
+              stars = 0
+            end
+            if char == '?'
+              re << '[^/]'
+            elsif char == '['
+              re << '['
+              in_character_group = true
+              last_char_opened_character_group = true
+            else
+              re << Regexp.escape(char)
+            end
+          end
+        end
+
+        if in_character_group
+          return /(?!)/ # impossible to match anything
+        end
+
+        if stars >= 2
+          re << '.*'
+        elsif stars.positive?
+          re << '[^/]*'
+        end
+        re << '\\z'
+        Regexp.new(re, Regexp::IGNORECASE)
+      end
+    end
+  end
+end

data/lib/fast_ignore/rule.rb

@@ -2,12 +2,6 @@
 
 class FastIgnore
   class Rule
-    # FNMATCH_OPTIONS = (
-    #   ::File::FNM_DOTMATCH |
-    #   ::File::FNM_PATHNAME |
-    #   ::File::FNM_CASEFOLD
-    # ).freeze # = 14
-
     attr_reader :negation
     alias_method :negation?, :negation
     undef :negation
@@ -20,12 +14,16 @@ class FastIgnore
     alias_method :unanchored?, :unanchored
     undef :unanchored
 
-    def initialize(rule, unanchored, dir_only, negation)
-      @rule = rule
+    attr_reader :type
+    attr_reader :rule
+
+    def initialize(rule, negation, unanchored = nil, dir_only = nil)
+      @rule = rule.is_a?(Regexp) ? rule : ::FastIgnore::FNMatchToRegex.call(rule)
       @unanchored = unanchored
       @dir_only = dir_only
       @negation = negation
-      @shebang = shebang
+
+      @type = negation ? 1 : 0
 
       freeze
     end
@@ -44,8 +42,8 @@ class FastIgnore
     end
     # :nocov:
 
-    def match?(relative_path, _, _)
-      ::File.fnmatch?(@rule, relative_path, 14)
+    def match?(relative_path, _, _, _)
+      @rule.match?(relative_path)
     end
   end
 end

data/lib/fast_ignore/rule_builder.rb

@@ -4,10 +4,7 @@ class FastIgnore
   module RuleBuilder
     class << self
       # :nocov:
-      if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
-        require_relative 'backports/delete_prefix_suffix'
-        using ::FastIgnore::Backports::DeletePrefixSuffix
-      end
+      using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
       # :nocov:
 
       def build(rule, allow, expand_path, file_root)
@@ -50,8 +47,11 @@ class FastIgnore
         dir_only = extract_dir_only(rule)
         negation = extract_negation(rule, allow)
 
-        expand_rule_path(rule, expand_path) if expand_path
-        unanchored = unanchored?(rule)
+        unanchored = if expand_path
+          expand_rule_path(rule, expand_path)
+        else
+          unanchored?(rule)
+        end
         rule.delete_prefix!('/')
 
         rule.prepend("#{file_root}#{'**/' if unanchored}") if file_root || unanchored
@@ -73,7 +73,7 @@ class FastIgnore
       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?('/')
+        rule.start_with?('*')
       end
 
       def unanchored?(rule)
@@ -81,10 +81,10 @@ class FastIgnore
       end
 
       def build_gitignore_rules(rule, unanchored, allow, dir_only, negation)
-        rules = [::FastIgnore::Rule.new(rule.freeze, unanchored, dir_only, negation)]
+        rules = [::FastIgnore::Rule.new(rule, negation, unanchored, dir_only)]
         return rules unless allow
 
-        rules << ::FastIgnore::Rule.new("#{rule}/**/*", unanchored, false, negation)
+        rules << ::FastIgnore::Rule.new("#{rule}/**/*", negation, unanchored, false)
         rules + ancestor_rules(rule, unanchored)
       end
 
@@ -93,7 +93,7 @@ class FastIgnore
 
         while (parent = ::File.dirname(parent)) != '.'
           rule = ::File.basename(parent) == '**' ? "#{parent}/*" : parent.freeze
-          ancestor_rules << ::FastIgnore::Rule.new(rule, unanchored, true, true)
+          ancestor_rules << ::FastIgnore::Rule.new(rule, true, unanchored, true)
         end
 
         ancestor_rules

data/lib/fast_ignore/rule_set.rb

@@ -3,39 +3,43 @@
 class FastIgnore
   class RuleSet
     def initialize(rules, allow)
-      @dir_rules = rules.reject(&:file_only?).freeze
-      @file_rules = rules.reject(&:dir_only?).freeze
+      @dir_rules = squash_rules(rules.reject(&:file_only?)).freeze
+      @file_rules = squash_rules(rules.reject(&:dir_only?)).freeze
       @any_not_anchored = rules.any?(&:unanchored?)
       @has_shebang_rules = rules.any?(&:shebang)
+
       @allowed_recursive = { '.' => true }
       @allow = allow
 
       freeze
     end
 
-    def freeze
-      @dir_rules.freeze
-      @file_rules.freeze
-
-      super
-    end
-
-    def allowed_recursive?(relative_path, dir, full_path, filename)
+    def allowed_recursive?(relative_path, dir, full_path, filename, content = nil)
       @allowed_recursive.fetch(relative_path) do
         @allowed_recursive[relative_path] =
-          allowed_recursive?(::File.dirname(relative_path), true, nil, nil) &&
-          allowed_unrecursive?(relative_path, dir, full_path, filename)
+          allowed_recursive?(::File.dirname(relative_path), true, nil, nil, nil) &&
+          allowed_unrecursive?(relative_path, dir, full_path, filename, content)
       end
     end
 
-    def allowed_unrecursive?(relative_path, dir, full_path, filename)
+    def allowed_unrecursive?(relative_path, dir, full_path, filename, content)
       (dir ? @dir_rules : @file_rules).reverse_each do |rule|
-        return rule.negation? if rule.match?(relative_path, full_path, filename)
+        return rule.negation? if rule.match?(relative_path, full_path, filename, content)
       end
 
       (not @allow) || (dir && @any_not_anchored)
     end
 
+    def squash_rules(rules)
+      out = rules.chunk_while { |a, b| a.type == b.type }.map do |chunk|
+        next chunk.first if chunk.length == 1
+
+        chunk.first.class.new(Regexp.union(chunk.map(&:rule)), chunk.first.negation?)
+      end
+
+      out
+    end
+
     def weight
       @dir_rules.length + (@has_shebang_rules ? 10 : 0)
     end

data/lib/fast_ignore/rule_set_builder.rb

@@ -4,10 +4,7 @@ class FastIgnore
   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
+      using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
       # :nocov:
 
       def build( # rubocop:disable Metrics/ParameterLists

data/lib/fast_ignore/shebang_rule.rb

@@ -6,12 +6,18 @@ class FastIgnore
     alias_method :negation?, :negation
     undef :negation
 
-    attr_reader :shebang
+    attr_reader :rule
+    alias_method :shebang, :rule
 
-    def initialize(shebang, negation)
-      @shebang = shebang
+    attr_reader :type
+
+    def initialize(rule, negation)
+      @rule = rule
       @negation = negation
 
+      @type = 2
+      @type += 1 if negation
+
       freeze
     end
 
@@ -29,14 +35,14 @@ class FastIgnore
 
     # :nocov:
     def inspect
-      "#<ShebangRule #{'allow ' if @negation}#!:#{@shebang.to_s[15..-4]}>"
+      "#<ShebangRule #{'allow ' if @negation}#!:#{@rule.to_s[15..-4]}>"
     end
     # :nocov:
 
-    def match?(_, full_path, filename)
+    def match?(_, full_path, filename, content)
       return false if filename.include?('.')
 
-      first_line(full_path)&.match?(@shebang)
+      (content || first_line(full_path))&.match?(@rule)
     end
 
     private

data/lib/fast_ignore/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.11.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-26 00:00:00.000000000 Z
+date: 2020-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -165,8 +165,7 @@ files:
 - 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/fn_match_to_re.rb
 - lib/fast_ignore/rule.rb
 - lib/fast_ignore/rule_builder.rb
 - lib/fast_ignore/rule_set.rb

data/lib/fast_ignore/backports/delete_prefix_suffix.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-# This is a backport of ruby 2.5's delete_prefix/delete_suffix methods
-class FastIgnore
-  module Backports
-    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

data/lib/fast_ignore/backports/dir_each_child.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-# This is a backport of ruby 2.5's each_child method
-class FastIgnore
-  module Backports
-    module DirEachChild
-      refine ::Dir.singleton_class do
-        def each_child(path, &block)
-          Dir.entries(path).each do |entry|
-            next if entry == '.' || entry == '..'
-
-            block.call entry
-          end
-        end
-      end
-    end
-  end
-end