fast_ignore 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55e2502678383f7dec077fb00816f754ca795d6de214ae2950fd2343852e450b
-  data.tar.gz: ef25eca3ec9c85578f4c74a808f5865d5586d2ce5919b976013723f6d17beedc
+  metadata.gz: 69021259195d30c9d3eb2e4461a779ef70b67d664370c5dff06d79f16ff009cb
+  data.tar.gz: f3e60391822c26b461316389277f3901801c89e1dfcea59e819976d2b4c4b761
 SHA512:
-  metadata.gz: 7dbfbe53878ac26d8b857647da3356b47c687f081f5369270d41576b71b414fc5b6417d8ed0b7c9d72a7bd65e1c727760573586a223c23a16126ad64ac72a099
-  data.tar.gz: 761d4d757d5660058be97dff4809415070bf610c8c5aa000e71bec1d36c3b7fcfdfe35e8ab1daf4586154d34d341a93dcf76f9055f942465bc7ae6a7cc280e9d
+  metadata.gz: c99e8a9d3be9addeca4d18d327e450b9d6c345b6db354beb612e7f7e999af743d4ee4f62df9b1be0dec4a03820f948c52f8cb53d202ff8d3242499bbc453da87
+  data.tar.gz: 2d17fe903303a913df5d763789517897e7c444c89069b3f81ce28df0136c1c5c6a94fd1c6f8080e17291713a75da4246da67c1c86a90c89a9084137276ba0b4d

data/.leftovers.yml

@@ -0,0 +1,5 @@
+exclude_paths:
+  - vendor
+rules:
+  - names: allowed? # public api
+    skip: true

data/.rubocop.yml

@@ -211,3 +211,6 @@ Style/HashTransformKeys:
 
 Style/HashTransformValues:
   Enabled: true
+
+Style/CommentedKeyword:
+  Enabled: false

data/.spellr_wordlists/english.txt

@@ -8,15 +8,20 @@ cov
 cyclomatic
 enoent
 enumerables
+env
 errno
 extensionless
 fancyignore
+frotz
 gemfile
 github
 gitignore
 gitkeep
 hashbang
+includefile
+janky
 klass
+llo
 nocov
 noninfringement
 params
@@ -33,9 +38,13 @@ rvm
 sherson
 simplecov
 stdin
+substring
 sudo
+symlinks
 tmp
 toplevel
 txt
 unrecursive
+upcase
+usr
 zsh

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 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.
+  - now you can ignore by shebang pattern
+- symlinks aren't followed when deciding if a path is a directory or not (this now matches git)
+- 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))
 - using a `ignore_files:` or `include_files:` that are outside the `root: (default $PWD)` will now raise an error.

data/README.md

@@ -5,7 +5,7 @@
 This started as a way to quickly and natively ruby-ly parse gitignore files and find matching files.
 It's now gained an equivalent includes file functionality, ARGV awareness, and some shebang matching, while still being extremely fast, to be a one-stop file-list for your linter.
 
-Filter a directory tree using a .gitignore file. Recognises all of the [gitignore rules](https://www.git-scm.com/docs/gitignore#_pattern_format) ([except one](#known-issues))
+Filter a directory tree using a .gitignore file. Recognises all of the [gitignore rules](https://www.git-scm.com/docs/gitignore#_pattern_format)
 
 ```ruby
 FastIgnore.new(relative: true).sort == `git ls-files`.split("\n").sort
@@ -34,61 +34,82 @@ $ gem install fast_ignore
 FastIgnore.new.each { |file| puts "#{file} is not ignored by the .gitignore file" }
 ```
 
-Like many other enumerables, `FastIgnore#each` can return an enumerator
+### `#each`, `#map` etc
+
+The FastIgnore object is an enumerable and responds to all Enumerable methods
+
+```ruby
+FastIgnore.new.to_a
+FastIgnore.new.map { |file| file.upcase }
+```
+
+Like other enumerables, `FastIgnore#each` can return an enumerator
 
 ```ruby
 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:
 
 ```ruby
 FastIgnore.new(relative: true).to_a
 ```
 
-By default, FastIgnore will look at the current working directory (PWD) for looking for .gitignore files, handling array rules, and the path that relative returns.
-To use a different directory:
-```ruby
-FastIgnore.new(root: '/absolute/path/to/root').to_a
-```
+### `root:`
 
-You can specify other gitignore-style files to ignore as well. Missing files will raise an `Errno::ENOENT` error.
+By default, root is PWD (the current working directory)
+This directory is used for:
+- looking for .gitignore files
+- as the root directory for array rules starting with `/` or ending with `/**`
+- and the path that relative is relative to
+- which files get checked
 
+To use a different directory:
 ```ruby
-FastIgnore.new(ignore_files: '/absolute/path/to/my/ignore/file').to_a
-FastIgnore.new(ignore_files: ['/absolute/path/to/my/ignore/file', '/and/another']).to_a
+FastIgnore.new(root: '/absolute/path/to/root').to_a
+FastIgnore.new(root: '../relative/path/to/root').to_a
 ```
 
-You can also supply an array of rule strings.
+### `gitignore:`
 
+By default, the .gitignore file in root directory is loaded.
+To not do this use
 ```ruby
-FastIgnore.new(ignore_rules: '.DS_Store').to_a
-FastIgnore.new(ignore_rules: ['.git', '.gitkeep']).to_a
+FastIgnore.new(gitignore: false).to_a
 ```
 
-To use only another ignore file or an array of rules, and not even try to load a gitignore file:
+To raise an `Errno::ENOENT` error if the .gitignore file is not found use:
 ```ruby
-FastIgnore.new(ignore_files: '/absolute/path/to/my/ignore/file', gitignore: false).to_a
-FastIgnore.new(ignore_rules: %w{my*rule /and/another !rule}, gitignore: false).to_a
+FastIgnore.new(gitignore: true).to_a
 ```
 
-By default, FastIgnore will look in the root directory for a gitignore file. If it's somewhere else:
+If the gitignore file is somewhere else
 ```ruby
 FastIgnore.new(ignore_file: '/absolute/path/to/.gitignore', gitignore: false).to_a
 ```
 Note that the location of the .gitignore file will affect rules beginning with `/` or ending in `/**`
 
-To raise an `Errno::ENOENT` error if the .gitignore file is not found use:
+### `ignore_files:`
+You can specify other gitignore-style files to ignore as well.
+Missing files will raise an `Errno::ENOENT` error.
+
 ```ruby
-FastIgnore.new(gitignore: true).to_a
+FastIgnore.new(ignore_files: '/absolute/path/to/my/ignore/file').to_a
+FastIgnore.new(ignore_files: ['/absolute/path/to/my/ignore/file', '/and/another']).to_a
 ```
 
-To filter by extensionless files shebang/hashbang/etc:
+### `ignore_rules:`
+You can also supply an array of rule strings.
+
 ```ruby
-FastIgnore.new(include_rules: '*.rb', include_shebangs: 'ruby').to_a
-FastIgnore.new(include_rules: '*.sh', include_shebangs: ['sh', 'bash', 'zsh']).to_a
+FastIgnore.new(ignore_rules: '.DS_Store').to_a
+FastIgnore.new(ignore_rules: ['.git', '.gitkeep']).to_a
+FastIgnore.new(ignore_rules: ".git\n.gitkeep").to_a
 ```
 
+# `#allowed?`
+
 To check if a single file is allowed, use
 ```ruby
 FastIgnore.new.allowed?('relative/path')
@@ -97,7 +118,7 @@ FastIgnore.new.allowed?('/absolute/path')
 FastIgnore.new.allowed?('~/home/path')
 ```
 
-### Using an includes list.
+### `include_files:` and `include_rules:`
 
 Building on the gitignore format, FastIgnore also accepts a list of allowed or included files.
 
@@ -132,22 +153,50 @@ It assumes all rules are anchored unless they begin with `*` or `!*`.
 
 Note: it will *not* resolve e.g. `/../` in the middle of a rule that doesn't begin with any of `~`,`../`,`./`,`/`.
 
+### shebang rules
+
+Sometimes you need to match files by their shebang rather than their path or filename
+
+To match extensionless files by shebang/hashbang/etc:
+
+Lines beginning with `#!:` will match whole words in the shebang line of extensionless files.
+e.g.
+```gitignore
+#!:ruby
+```
+will match shebang lines: `#!/usr/bin/env ruby` or `#!/usr/bin/ruby` or `#!/usr/bin/ruby -w`
+e.g.
+```gitignore
+#!:bin/ruby
+```
+will match `#!/bin/ruby` or `#!/usr/bin/ruby` or `#!/usr/bin/ruby -w`
+Currently only exact substring matches are available, There's no special handling of * or / or etc.
+
+```ruby
+FastIgnore.new(include_rules: ['*.rb', '#!:ruby']).to_a
+FastIgnore.new(ignore_rules: ['*.sh', '#!:sh', '#!:bash', '#!:zsh']).to_a
+```
+
 ## Combinations
 
 In the simplest case a file must be allowed by each ignore file, each include file, and each array of rules. That is, they are combined using AND.
 
-To combine files using `OR`, that is, a file may be included by either file it doesn't have to be referred to in both:
-
+To combine files using `OR`, that is, a file may be matched by either file it doesn't have to be referred to in both:
+provide the files as strings to `include_rules:` or `ignore_rules:`
 ```ruby
-FastIgnore.new(include_files: StringIO.new([File.read('/my/path'), File.read('/another/path')]).join("\n")).to_a
+FastIgnore.new(include_rules: [File.read('/my/path'), File.read('/another/path')])).to_a
 ```
+This does unfortunately lose the file path as the root for `/` and `/**` rules.
+If that's important, combine the files in the file system and use `include_files:` or `ignore_files:` as normal.
 
-To use the additional ARGV handling rules mentioned above for files
+To use the additional ARGV handling rules mentioned above for files, read the file into the array as a string.
 
 ```ruby
 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.
+
 ## 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`.

data/Rakefile

@@ -4,9 +4,11 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 require 'spellr/rake_task'
+require 'leftovers/rake_task'
 
 RuboCop::RakeTask.new
 RSpec::Core::RakeTask.new(:spec)
 Spellr::RakeTask.generate_task
+Leftovers::RakeTask.generate_task
 
-task default: [:spec, :rubocop, :spellr]
+task default: [:spec, :rubocop, :spellr, :leftovers]

data/fast_ignore.gemspec

@@ -30,6 +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 'pry', '> 0'
   spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'

data/lib/fast_ignore.rb

@@ -22,22 +22,27 @@ class FastIgnore
   end
   # :nocov:
 
-  def initialize(
+  def initialize( # rubocop:disable Metrics/MethodLength
     relative: false,
-    root: ::Dir.pwd,
+    root: nil,
     include_shebangs: nil,
     **rule_set_builder_args
   )
-    @root = root.end_with?('/') ? root : "#{root}/"
-    @shebang_pattern = prepare_shebang_pattern(include_shebangs)
+    # :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:
 
-    rule_sets = ::FastIgnore::RuleSetBuilder.from_args(
-      root: @root,
-      **rule_set_builder_args
-    )
+    root = root ? File.expand_path(root, ::Dir.pwd) : ::Dir.pwd
+    @root = "#{root}/"
 
-    @include_rule_sets, @ignore_rule_sets = rule_sets.partition(&:allow?)
-    @has_include_rule_sets = !@include_rule_sets.empty?
+    @rule_sets = ::FastIgnore::RuleSetBuilder.from_args(root: @root, **rule_set_builder_args)
     @relative = relative
 
     freeze
@@ -51,52 +56,35 @@ class FastIgnore
     end
   end
 
-  def allowed?(path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def allowed?(path)
     full_path = ::File.expand_path(path, @root)
     return false unless full_path.start_with?(@root)
 
-    dir = ::File.stat(full_path).directory? # shortcut for exists? && directory?
-
+    dir = ::File.lstat(full_path).directory?
     return false if dir
 
     relative_path = full_path.delete_prefix(@root)
+    filename = ::File.basename(relative_path)
 
-    return false unless @ignore_rule_sets.all? { |r| r.allowed_recursive?(relative_path, dir) }
-    return @include_rule_sets.all? { |r| r.allowed_recursive?(relative_path, dir) } unless @shebang_pattern
-
-    (@has_include_rule_sets &&
-      @include_rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, false) }) ||
-      match_shebang?(full_path, ::File.basename(relative_path))
+    @rule_sets.all? { |r| r.allowed_recursive?(relative_path, dir, 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, Metrics/AbcSize
-    ::Dir.each_child(full_path) do |basename|
+  def each_allowed(full_path = @root, relative_path = '', &block) # rubocop:disable Metrics/MethodLength
+    ::Dir.each_child(full_path) do |filename|
       begin
-        full_child = full_path + basename
-        relative_child = relative_path + basename
-        dir = ::File.directory?(full_child)
+        full_child = full_path + filename
+        relative_child = relative_path + filename
+        dir = ::File.lstat(full_child).directory?
 
-        next unless @ignore_rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir) }
+        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir, filename) }
 
         if dir
-          next unless @shebang_pattern || @include_rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir) }
-
           each_allowed("#{full_child}/", "#{relative_child}/", &block)
         else
-          if @shebang_pattern
-            unless (@has_include_rule_sets &&
-                @include_rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir) }) ||
-                match_shebang?(full_child, basename)
-              next
-            end
-          else
-            next unless @include_rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir) }
-          end
-
           yield(@relative ? relative_child : full_child)
         end
       rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
@@ -104,28 +92,4 @@ class FastIgnore
       end
     end
   end
-
-  def match_shebang?(path, basename)
-    return false if basename.include?('.')
-
-    begin
-      f = ::File.new(path)
-      # i can't imagine a shebang being longer than 20 characters, lets multiply that by 10 just in case.
-      fragment = f.sysread(256)
-      f.close
-    rescue ::SystemCallError, ::EOFError
-      return false
-    end
-
-    @shebang_pattern.match?(fragment)
-  end
-
-  def prepare_shebang_pattern(rules)
-    return if !rules || (rules = Array(rules)).empty?
-
-    rules = rules.flat_map { |s| s.to_s.split("\n") }
-    rules_re = rules.map { |s| Regexp.escape(s.to_s) }.join('|')
-
-    /\A#!.*\b(?:#{rules_re})\b/.freeze
-  end
 end

data/lib/fast_ignore/backports/delete_prefix_suffix.rb

@@ -5,22 +5,50 @@ 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)
-          slice!(0..(str.length - 1)) if start_with?(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)
-          slice!(-str.length..-1) if end_with?(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)
-          dup.delete_prefix!(str)
+          s = dup
+          s.delete_prefix!(str)
+          s
         end
 
-        def delete_suffix(str)
-          dup.delete_suffix!(str)
+        # 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

data/lib/fast_ignore/rule.rb

@@ -12,21 +12,57 @@ class FastIgnore
     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
 
-    def initialize(rule, dir_only, negation)
+    def initialize(rule, dir_only, file_only, negation, shebang = nil)
       @rule = rule
       @dir_only = dir_only
+      @file_only = file_only
       @negation = negation
+      @shebang = shebang
 
       freeze
     end
 
     # :nocov:
     def inspect
-      "#<Rule #{'!' if negation?}#{rule}#{'/' if dir_only?}>"
+      if shebang
+        "#<Rule #{'allow ' if negation?}#!:#{shebang.to_s[15..-4]}>"
+      else
+        "#<Rule #{'!' if negation?}#{rule}#{'/' if dir_only?}>"
+      end
     end
     # :nocov:
+
+    def match?(path, filename)
+      if @shebang
+        match_shebang?(path, filename)
+      else
+        ::File.fnmatch?(@rule, path, 14)
+      end
+    end
+
+    def match_shebang?(path, filename)
+      return false if filename.include?('.')
+
+      first_line(path)&.match?(@shebang)
+    end
+
+    def first_line(path)
+      file = ::File.new(path)
+      first_line = file.sysread(25)
+      first_line += file.sysread(50) until first_line.include?("\n")
+      file.close
+      first_line
+    rescue ::EOFError, ::SystemCallError
+      # :nocov:
+      file&.close
+      # :nocov:
+      first_line
+    end
   end
 end

data/lib/fast_ignore/rule_parser.rb

@@ -11,13 +11,15 @@ class FastIgnore
 
     # rule or nil
     class << self
-      def new_rule(rule, rule_set:, allow: false, expand_path: false, file_root: nil) # rubocop:disable Metrics/MethodLength
+      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)
-        dir_only = extract_dir_only(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
@@ -36,34 +38,41 @@ class FastIgnore
 
       private
 
-      DOT = '.'
-      def rules(rule, allow, dir_only, negation)
-        rules = [::FastIgnore::Rule.new(rule, dir_only, negation)]
+      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("#{rule}/**/*", false, negation)
-        parent = File.dirname(rule)
-        while parent != DOT
-          rules << ::FastIgnore::Rule.new(parent.freeze, true, true)
-          parent = File.dirname(parent)
-        end
+        rules << ::FastIgnore::Rule.new('**/*', true, false, true)
         rules
       end
 
-      def extract_negation(rule, allow)
-        return allow unless rule.start_with?('!')
+      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 = []
 
-        rule.slice!(0)
+        while (parent = ::File.dirname(parent)) != '.'
+          rule = ::File.basename(parent) == '**' ? "#{parent}/*" : parent.freeze
+          ancestor_rules << ::FastIgnore::Rule.new(rule, true, false, true)
+        end
 
-        !allow
+        ancestor_rules
       end
 
-      def extract_dir_only(rule)
-        return false unless rule.end_with?('/')
+      def extract_negation(rule, allow)
+        return allow unless rule.delete_prefix!('!')
 
-        rule.chop!
+        not allow
+      end
 
-        true
+      def extract_dir_only(rule)
+        rule.delete_suffix!('/')
       end
 
       def strip(rule)
@@ -72,9 +81,7 @@ class FastIgnore
       end
 
       def anchored?(rule)
-        rule.start_with?('/') ||
-          rule.end_with?('/**') ||
-          rule.include?('/**/')
+        rule.include?('/') # we've already removed the trailing '/' with extract_dir_only
       end
 
       EXPAND_PATH_RE = %r{^(?:[~/]|\.{1,2}/)}.freeze
@@ -84,6 +91,10 @@ class FastIgnore
         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

data/lib/fast_ignore/rule_set.rb

@@ -2,10 +2,6 @@
 
 class FastIgnore
   class RuleSet
-    attr_reader :rules
-    attr_reader :allow
-    alias_method :allow?, :allow
-
     def initialize(allow: false)
       @dir_rules = []
       @file_rules = []
@@ -21,17 +17,18 @@ class FastIgnore
       super
     end
 
-    def allowed_recursive?(path, dir)
+    def allowed_recursive?(path, dir, filename)
       @allowed_recursive.fetch(path) do
         @allowed_recursive[path] =
-          allowed_recursive?(::File.dirname(path), true) && allowed_unrecursive?(path, dir)
+          allowed_recursive?(::File.dirname(path), true, nil) && allowed_unrecursive?(path, dir, filename)
       end
     end
 
-    def allowed_unrecursive?(path, dir)
+    def allowed_unrecursive?(path, dir, filename)
       (dir ? @dir_rules : @file_rules).reverse_each do |rule|
         # 14 = Rule::FNMATCH_OPTIONS
-        return rule.negation? if ::File.fnmatch?(rule.rule, path, 14)
+
+        return rule.negation? if rule.match?(path, filename)
       end
 
       (not @allow) || (@any_not_anchored if dir)
@@ -39,18 +36,19 @@ class FastIgnore
 
     def append_rules(anchored, rules)
       rules.each do |rule|
-        @dir_rules << rule
-        @file_rules << rule unless rule.dir_only?
+        (@dir_rules << rule) unless rule.file_only?
+        (@file_rules << rule) unless rule.dir_only?
         @any_not_anchored ||= !anchored
+        @has_shebang_rules ||= rule.shebang
       end
     end
 
-    def length
-      @dir_rules.length
+    def weight
+      @dir_rules.length + (@has_shebang_rules ? 10 : 0)
     end
 
     def empty?
-      @dir_rules.empty?
+      @dir_rules.empty? && @file_rules.empty?
     end
   end
 end

data/lib/fast_ignore/rule_set_builder.rb

@@ -30,7 +30,7 @@ class FastIgnore
 
       rule_sets.compact!
       rule_sets.reject!(&:empty?)
-      rule_sets.sort_by!(&:length)
+      rule_sets.sort_by!(&:weight)
       rule_sets
     end
 

data/lib/fast_ignore/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-19 00:00:00.000000000 Z
+date: 2020-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: leftovers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -130,6 +144,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".leftovers.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".simplecov"
@@ -146,7 +161,6 @@ files:
 - bin/console
 - bin/ls
 - bin/ls-disable-gems
-- bin/ls-shebangs
 - bin/setup
 - fast_ignore.gemspec
 - lib/fast_ignore.rb

data/bin/ls-shebangs

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