fast_ignore 0.8.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9218ac549a0d5f73ff24a656320561307b89c7137f105e2921d4adb81074bcd8
-  data.tar.gz: 6ed5b5a316d48e7a10bd87b3159fa61f750154c7614c9ad11a1ceb992df0bace
+  metadata.gz: 55e2502678383f7dec077fb00816f754ca795d6de214ae2950fd2343852e450b
+  data.tar.gz: ef25eca3ec9c85578f4c74a808f5865d5586d2ce5919b976013723f6d17beedc
 SHA512:
-  metadata.gz: 366a9500c6a9e1b725bb7fcb691040bbd0385b20f4e8e496f7199f4640c05bbc51de4593a634f82166ec81d5c9a1fd2251c38a1bfc37a5bacf06934154965c94
-  data.tar.gz: 11b0afcc962cd225be140384dd3dc3e61c4006c699b22b1016e6b339b11fae26f30a59f4f98740ad46769653761850b4385b04e9c62b53457a1244075dec8dbe
+  metadata.gz: 7dbfbe53878ac26d8b857647da3356b47c687f081f5369270d41576b71b414fc5b6417d8ed0b7c9d72a7bd65e1c727760573586a223c23a16126ad64ac72a099
+  data.tar.gz: 761d4d757d5660058be97dff4809415070bf610c8c5aa000e71bec1d36c3b7fcfdfe35e8ab1daf4586154d34d341a93dcf76f9055f942465bc7ae6a7cc280e9d

data/.simplecov

@@ -1,6 +1,10 @@
 SimpleCov.start do
   add_filter '/backports'
   add_filter '/spec/'
-  enable_coverage(:branch)
-  minimum_coverage 100
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5')
+    enable_coverage(:branch)
+    minimum_coverage line: 100, branch: 100
+  else
+    minimum_coverage 100
+  end
 end

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 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.
+- remove deprecated `gitignore:` a path (e.g. `gitignore: '/path/to/gitignore'`). please use `gitignore: false, ignore_files: '/path/to/gitignore'` instead.
+
 # v0.8.3
 - fix `ignore_rules` not matching directories when using `include_shebangs:`
 

data/README.md

@@ -2,6 +2,9 @@
 
 [![travis](https://travis-ci.org/robotdana/fast_ignore.svg?branch=master)](https://travis-ci.org/robotdana/fast_ignore)
 
+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))
 
 ```ruby
@@ -43,6 +46,12 @@ By default, FastIgnore will return full paths. To return paths relative to the c
 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
+```
+
 You can specify other gitignore-style files to ignore as well. Missing files will raise an `Errno::ENOENT` error.
 
 ```ruby
@@ -59,11 +68,11 @@ FastIgnore.new(ignore_rules: ['.git', '.gitkeep']).to_a
 
 To use only another ignore file or an array of rules, and not even try to load a gitignore file:
 ```ruby
-FastIgnore.new(ignore_files: '/absolute/path/to/my/ignore/file', gitignore: false)
-FastIgnore.new(ignore_rules: %w{my*rule /and/another !rule}, gitignore: false)
+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
 ```
 
-By default, FastIgnore will look in the directory the script is run in (`PWD`) for a gitignore file. If it's somewhere else:
+By default, FastIgnore will look in the root directory for a gitignore file. If it's somewhere else:
 ```ruby
 FastIgnore.new(ignore_file: '/absolute/path/to/.gitignore', gitignore: false).to_a
 ```
@@ -108,14 +117,14 @@ fo*
 
 These can be passed either as files or as an array or string rules
 ```ruby
-FastIgnore.new(include_files: '/absolute/path/to/my/include/file', gitignore: false)
-FastIgnore.new(include_rules: %w{my*rule /and/another !rule}, gitignore: false)
+FastIgnore.new(include_files: '/absolute/path/to/my/include/file', gitignore: false).to_a
+FastIgnore.new(include_rules: %w{my*rule /and/another !rule}, gitignore: false).to_a
 ```
 
 There is an additional argument meant for dealing with humans and `ARGV` values.
 
 ```ruby
-FastIgnore.new(argv_rules: ['./a/pasted/path', '/or/a/path/from/stdin', 'an/argument', '*.txt'])
+FastIgnore.new(argv_rules: ['./a/pasted/path', '/or/a/path/from/stdin', 'an/argument', '*.txt']).to_a
 ```
 
 It resolves absolute paths, and paths beginning with `~`, `../` and `./` (with and without `!`)
@@ -130,13 +139,13 @@ In the simplest case a file must be allowed by each ignore file, each include fi
 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:
 
 ```ruby
-FastIgnore.new(include_files: StringIO.new([File.read('/my/path'), File.read('/another/path')]).join("\n"))
+FastIgnore.new(include_files: StringIO.new([File.read('/my/path'), File.read('/another/path')]).join("\n")).to_a
 ```
 
 To use the additional ARGV handling rules mentioned above for files
 
 ```ruby
-FastIgnore.new(argv_rules: ["my/rule", File.read('/my/path')])
+FastIgnore.new(argv_rules: ["my/rule", File.read('/my/path')]).to_a
 ```
 
 ## Known issues

data/lib/fast_ignore.rb

@@ -8,6 +8,8 @@ require_relative './fast_ignore/rule_set'
 require_relative './fast_ignore/rule'
 
 class FastIgnore
+  class Error < StandardError; end
+
   include ::Enumerable
 
   # :nocov:
@@ -20,34 +22,25 @@ class FastIgnore
   end
   # :nocov:
 
-  def initialize( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+  def initialize(
     relative: false,
     root: ::Dir.pwd,
-    ignore_rules: nil,
-    ignore_files: nil,
-    gitignore: :auto,
-    include_rules: nil,
-    include_files: nil,
     include_shebangs: nil,
-    argv_rules: nil
+    **rule_set_builder_args
   )
-    @root = root.delete_suffix('/')
-    @root_trailing_slash = "#{@root}/"
+    @root = root.end_with?('/') ? root : "#{root}/"
     @shebang_pattern = prepare_shebang_pattern(include_shebangs)
 
     rule_sets = ::FastIgnore::RuleSetBuilder.from_args(
       root: @root,
-      ignore_rules: ignore_rules,
-      ignore_files: ignore_files,
-      gitignore: gitignore,
-      include_rules: include_rules,
-      include_files: include_files,
-      argv_rules: argv_rules
+      **rule_set_builder_args
     )
 
     @include_rule_sets, @ignore_rule_sets = rule_sets.partition(&:allow?)
     @has_include_rule_sets = !@include_rule_sets.empty?
     @relative = relative
+
+    freeze
   end
 
   def each(&block)
@@ -58,53 +51,55 @@ class FastIgnore
     end
   end
 
-  def allowed?(path)
-    path = ::File.expand_path(path)
-    dir = ::File.stat(path).directory? # equivalent to directory? and exist?
+  def allowed?(path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    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?
 
     return false if dir
-    return false unless @ignore_rule_sets.all? { |r| r.allowed_recursive?(path, dir) }
-    return @include_rule_sets.all? { |r| r.allowed_recursive?(path, dir) } unless @shebang_pattern
+
+    relative_path = full_path.delete_prefix(@root)
+
+    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?(path, false) }) ||
-      match_shebang?(path, ::File.basename(path))
-  rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+      @include_rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, false) }) ||
+      match_shebang?(full_path, ::File.basename(relative_path))
+  rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
     false
   end
 
   private
 
-  def prepare_path(path)
-    @relative ? path.delete_prefix(@root_trailing_slash) : path
-  end
-
-  def each_allowed(path = @root_trailing_slash, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-    Dir.each_child(path) do |basename|
+  def each_allowed(full_path = @root, relative_path = '', &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    ::Dir.each_child(full_path) do |basename|
       begin
-        child = path + basename
-        dir = ::File.stat(child).directory? # equivalent to directory? and exist?
+        full_child = full_path + basename
+        relative_child = relative_path + basename
+        dir = ::File.directory?(full_child)
 
-        next unless @ignore_rule_sets.all? { |r| r.allowed_unrecursive?(child, dir) }
+        next unless @ignore_rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir) }
 
         if dir
-          next unless @shebang_pattern || @include_rule_sets.all? { |r| r.allowed_unrecursive?(child, dir) }
+          next unless @shebang_pattern || @include_rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir) }
 
-          each_allowed("#{child}/", &block)
+          each_allowed("#{full_child}/", "#{relative_child}/", &block)
         else
           if @shebang_pattern
             unless (@has_include_rule_sets &&
-                @include_rule_sets.all? { |r| r.allowed_unrecursive?(child, dir) }) ||
-                match_shebang?(child, basename)
+                @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?(child, dir) }
+            next unless @include_rule_sets.all? { |r| r.allowed_unrecursive?(relative_child, dir) }
           end
 
-          yield prepare_path(child)
+          yield(@relative ? relative_child : full_child)
         end
-      rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+      rescue ::Errno::ENOENT, ::Errno::EACCES, ::Errno::ENOTDIR, ::Errno::ELOOP, ::Errno::ENAMETOOLONG
         nil
       end
     end
@@ -118,7 +113,7 @@ class FastIgnore
       # 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
+    rescue ::SystemCallError, ::EOFError
       return false
     end
 

data/lib/fast_ignore/rule.rb

@@ -2,7 +2,11 @@
 
 class FastIgnore
   class Rule
-    FNMATCH_OPTIONS = (::File::FNM_DOTMATCH | ::File::FNM_PATHNAME | ::File::FNM_CASEFOLD).freeze # = 14
+    # FNMATCH_OPTIONS = (
+    #   ::File::FNM_DOTMATCH |
+    #   ::File::FNM_PATHNAME |
+    #   ::File::FNM_CASEFOLD
+    # ).freeze # = 14
 
     attr_reader :negation
     alias_method :negation?, :negation
@@ -15,6 +19,8 @@ class FastIgnore
       @rule = rule
       @dir_only = dir_only
       @negation = negation
+
+      freeze
     end
 
     # :nocov:

data/lib/fast_ignore/rule_parser.rb

@@ -11,74 +11,77 @@ class FastIgnore
 
     # rule or nil
     class << self
-      def new_rule(rule, root:, rule_set:, allow: false, expand_path: false) # rubocop:disable Metrics/MethodLength
-        rule = strip(rule)
-        rule, dir_only = extract_dir_only(rule)
+      def new_rule(rule, rule_set:, allow: false, expand_path: false, file_root: nil) # rubocop:disable Metrics/MethodLength
+        rule = rule.dup
+        strip(rule)
+        dir_only = extract_dir_only(rule)
 
         return if skip?(rule)
 
-        rule, negation = extract_negation(rule, allow)
-        rule = expand_path(rule, root) if expand_path
+        negation = extract_negation(rule, allow)
 
-        anchored, prefix = prefix(rule)
+        expand_rule_path(rule, expand_path) if expand_path
+        anchored = anchored?(rule)
+        rule.delete_prefix!('/')
 
-        rule = "#{root}#{prefix}#{rule}"
+        rule.prepend("#{file_root}#{'**/' unless anchored}") if file_root || (not anchored)
+
+        rule.freeze
 
         rule_set.append_rules(
           anchored,
-          rules(rule, allow, root, dir_only, negation)
+          rules(rule, allow, dir_only, negation)
         )
       end
 
       private
 
-      def rules(rule, allow, root, dir_only, negation)
+      DOT = '.'
+      def rules(rule, allow, dir_only, negation)
         rules = [::FastIgnore::Rule.new(rule, dir_only, negation)]
         return rules unless allow
 
         rules << ::FastIgnore::Rule.new("#{rule}/**/*", false, negation)
         parent = File.dirname(rule)
-        while parent != root
-          rules << ::FastIgnore::Rule.new(parent, true, true)
+        while parent != DOT
+          rules << ::FastIgnore::Rule.new(parent.freeze, true, true)
           parent = File.dirname(parent)
         end
         rules
       end
 
       def extract_negation(rule, allow)
-        return [rule, allow] unless rule.start_with?('!')
+        return allow unless rule.start_with?('!')
+
+        rule.slice!(0)
 
-        [rule[1..-1], !allow]
+        !allow
       end
 
       def extract_dir_only(rule)
-        return [rule, false] unless rule.end_with?('/')
+        return false unless rule.end_with?('/')
+
+        rule.chop!
 
-        [rule[0..-2], true]
+        true
       end
 
       def strip(rule)
-        rule = rule.chomp
-        rule = rule.rstrip unless rule.end_with?('\\ ')
-        rule
+        rule.chomp!
+        rule.rstrip! unless rule.end_with?('\\ ')
       end
 
-      def prefix(rule)
-        if rule.start_with?('/')
-          [true, '']
-        elsif rule.end_with?('/**') || rule.include?('/**/')
-          [true, '/']
-        else
-          [false, '/**/']
-        end
+      def anchored?(rule)
+        rule.start_with?('/') ||
+          rule.end_with?('/**') ||
+          rule.include?('/**/')
       end
 
-      def expand_path(rule, root)
-        rule = ::File.expand_path(rule).delete_prefix(root) if rule.match?(%r{^(?:[~/]|\.{1,2}/)})
-
-        rule = "/#{rule}" unless rule.start_with?('*') || rule.start_with?('/')
-
-        rule
+      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 skip?(rule)

data/lib/fast_ignore/rule_set.rb

@@ -6,18 +6,22 @@ class FastIgnore
     attr_reader :allow
     alias_method :allow?, :allow
 
-    def initialize(project_root: Dir.pwd, allow: false)
+    def initialize(allow: false)
       @dir_rules = []
       @file_rules = []
-      @project_root = project_root
-
+      @allowed_recursive = { '.' => true }
       @any_not_anchored = false
       @allow = allow
-      @default = true unless allow
+    end
+
+    def freeze
+      @dir_rules.freeze
+      @file_rules.freeze
+
+      super
     end
 
     def allowed_recursive?(path, dir)
-      @allowed_recursive ||= { @project_root => true }
       @allowed_recursive.fetch(path) do
         @allowed_recursive[path] =
           allowed_recursive?(::File.dirname(path), true) && allowed_unrecursive?(path, dir)

data/lib/fast_ignore/rule_set_builder.rb

@@ -2,8 +2,15 @@
 
 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:
+
     def self.from_args( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
-      root: Dir.pwd,
+      root:,
       ignore_rules: nil,
       ignore_files: nil,
       gitignore: :auto,
@@ -12,13 +19,13 @@ class FastIgnore
       argv_rules: nil
     )
       rule_sets = [
-        from_array(ignore_rules, root: root),
+        from_array(ignore_rules),
         *from_files(ignore_files, project_root: root),
-        from_array('.git', root: root),
-        from_gitignore_arg(gitignore, root: root),
-        from_array(include_rules, root: root, allow: true),
+        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, root: root, allow: true, expand_path: true)
+        from_array(argv_rules, allow: true, expand_path: root)
       ]
 
       rule_sets.compact!
@@ -27,62 +34,58 @@ class FastIgnore
       rule_sets
     end
 
-    def self.from_file(filename, allow: false, project_root: Dir.pwd)
-      filename = ::File.expand_path(filename)
-      root = ::File.dirname(filename)
-      rule_set = ::FastIgnore::RuleSet.new(project_root: project_root, allow: allow)
+    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)
+
+      file_root = "#{::File.dirname(filename)}/".delete_prefix(project_root)
+      rule_set = ::FastIgnore::RuleSet.new(allow: allow)
 
       ::IO.foreach(filename) do |rule_string|
-        parse_rules(rule_string, allow: allow, rule_set: rule_set, root: root)
+        parse_rules(rule_string, allow: allow, rule_set: rule_set, file_root: file_root)
       end
 
-      rule_set
+      rule_set.freeze
     end
 
-    def self.from_files(files, allow: false, project_root: Dir.pwd)
+    def self.from_files(files, project_root:, allow: false)
       Array(files).map do |file|
         from_file(file, allow: allow, project_root: project_root)
       end
     end
 
-    def self.from_gitignore_arg(gitignore, root: Dir.pwd) # rubocop:disable Metrics/MethodLength
-      default_path = ::File.join(root, '.gitignore')
+    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: root) if ::File.exist?(default_path)
+        from_file(default_path, project_root: project_root) if ::File.exist?(default_path)
       when true
-        from_file(default_path, project_root: root)
-      when false
-        nil
-      else
-        warn 'Deprecation warning! supplying gitignore file path directly is deprecated. '\
-          'Please use gitignore: false and add your path to the ignore_files array'
-        from_file(gitignore, project_root: root)
+        from_file(default_path, project_root: project_root)
       end
     end
 
-    def self.from_array(rules, allow: false, expand_path: false, root: Dir.pwd)
+    def self.from_array(rules, allow: false, expand_path: false)
       rules = Array(rules)
       return if rules.empty?
 
-      rule_set = ::FastIgnore::RuleSet.new(project_root: root, allow: allow)
+      rule_set = ::FastIgnore::RuleSet.new(allow: allow)
 
       rules.each do |rule_string|
         rule_string.to_s.each_line do |rule_line|
-          parse_rules(rule_line, rule_set: rule_set, allow: allow, root: root, expand_path: expand_path)
+          parse_rules(rule_line, rule_set: rule_set, allow: allow, expand_path: expand_path)
         end
       end
 
-      rule_set
+      rule_set.freeze
     end
 
-    def self.parse_rules(rule_line, rule_set:, allow: false, root: Dir.pwd, expand_path: false)
+    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,
-        root: root,
-        expand_path: expand_path
+        expand_path: expand_path,
+        file_root: file_root
       )
     end
   end

data/lib/fast_ignore/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.9.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-18 00:00:00.000000000 Z
+date: 2020-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler