fast_ignore 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35a905f9dd8c28df7b46d6c0c61ad1fcaf44a9566c19b704a88584668f49ba20
-  data.tar.gz: 620917002cd9696bb5787819675034d6b5269d70812f0e5247523b10091d37b9
+  metadata.gz: 85adcabd5164bc3c1cf44af50ff5565b8ce00d6c69f8145eab0634fbaef551fb
+  data.tar.gz: de0192432d8423e5fee408aa7d3a052bc008d96b5cacadf7d2d6b66da3527030
 SHA512:
-  metadata.gz: 6406dd9e6998fb9a3345981239e7fa0046f1356852a599f2c347d4b7bec4654069ac5704351c3079ce79c0965925a601dbcf56990ac6850aefef5f3a109793fa
-  data.tar.gz: 83a7aacfd25b3350a4100d6247c683f6b4f1754c6311d9b6064631e5033890ea2fcc0c8dd5b5757f8f0e9a39af55cfc3f7560918813e69ab6e9139734abc4fa1
+  metadata.gz: 8507d8f07c51e0cb2b00a0ea619683bc41ca85b0a89d7e4787f5b0aa9157d255ec261a4ffab130982c89f1c85b4a0dd5f7030bb18de20186362eaf894b816b65
+  data.tar.gz: 661628a1913544cc67d1833ddb84218db6b85de165ba11fb39dd1f62c014638b9fd72d8f3efe0bc8ce2f1379acf43a63a2bedf016e9ff5927d400e8c4932a57c

data/.rubocop.yml

@@ -169,6 +169,10 @@ Style/IfInsideElse:
 Style/MultipleComparison:
   Enabled: false
 
+# it's microscopically faster
+Style/Not:
+  Enabled: false
+
 # we use %w{} pretty frequently
 Style/PercentLiteralDelimiters:
   PreferredDelimiters:

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# v0.6.0
+- nicer argv handling
+  - add `argv_rules:` option, which resolves paths and considers everything that doesn't start with a `*` to start with a `/`
+- combine the different includes methods and files using AND
+- slightly more realistic version comparison just in case someone releases ruby 2.10
+- can be run with --disable-gems
+- `.allowed?` now more exactly matches `.each`, it returns false for directories and unreadable files.
+
 # v0.5.2
 - performance improvements
 

data/README.md

@@ -66,6 +66,11 @@ FastIgnore.new(gitignore: '/absolute/path/to/.gitignore').to_a
 ```
 Note that the location of the .gitignore file will affect rules beginning with `/` or ending in `/**`
 
+To raise if the gitignore file is not found use:
+```ruby
+FastIgnore.new(gitignore: true)
+```
+
 To check if a single file is allowed, use
 ```ruby
 FastIgnore.new.allowed?('relative/path')
@@ -78,7 +83,7 @@ FastIgnore.new.allowed?('~/home/path')
 
 Building on the gitignore format, FastIgnore also accepts a list of allowed or included files.
 
-```
+```gitignore
 # a line like this means any files named foo will be included
 # as well as any files within directories named foo
 foo
@@ -98,7 +103,32 @@ FastIgnore.new(include_files: '/absolute/path/to/my/include/file', gitignore: fa
 FastIgnore.new(include_rules: %w{my*rule /and/another !rule}, gitignore: false)
 ```
 
-The string array rules additionally expects to handle all kinds of `ARGV` values, so will correctly resolve absolute paths and paths beginning with `~`, `../` and `./`. Note: it will *not* resolve e.g. `/../` in the middle of a rule that doesn't begin with any of `~`,`../`,`./`,`/`. This is not available for the file form.
+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'])
+```
+
+It resolves absolute paths, and paths beginning with `~`, `../` and `./` (with and without `!`)
+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 `~`,`../`,`./`,`/`.
+
+## 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:
+
+```ruby
+FastIgnore.new(include_files: StringIO.new([File.read('/my/path'), File.read('/another/path')]).join("\n"))
+```
+
+To use the additional ARGV handling rules mentioned above for files
+
+```ruby
+FastIgnore.new(include_rules: ["my/rule", File.read('/my/path')])
+```
 
 ## Known issues
 - Doesn't take into account project excludes in `.git/info/exclude`

data/bin/ls

@@ -3,4 +3,4 @@
 
 require_relative '../lib/fast_ignore'
 
-puts FastIgnore.new(relative: true, include_rules: ARGV).to_a
+puts FastIgnore.new(relative: true, argv_rules: ARGV).to_a

data/bin/ls-disable-gems

@@ -0,0 +1,6 @@
+#!/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/backports.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  module Backports
+    module_function
+
+    def ruby_version_less_than?(major, minor)
+      ruby_major, ruby_minor = RUBY_VERSION.split('.', 2)
+
+      return true if major > ruby_major.to_i
+      return true if minor > ruby_minor.to_i
+
+      false
+    end
+  end
+end

data/lib/fast_ignore/rule_parser.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
 require_relative 'rule'
+require_relative 'backports'
 
 class FastIgnore
   class RuleParser
-    unless ::RUBY_VERSION >= '2.4'
-      require_relative 'backports/match'
-      using ::FastIgnore::Backports::Match
-    end
-
-    unless ::RUBY_VERSION >= '2.5'
+    if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
       require_relative 'backports/delete_prefix_suffix'
       using ::FastIgnore::Backports::DeletePrefixSuffix
+
+      if ::FastIgnore::Backports.ruby_version_less_than?(2, 4)
+        require_relative 'backports/match'
+        using ::FastIgnore::Backports::Match
+      end
     end
 
     # rule or nil
@@ -19,11 +20,11 @@ class FastIgnore
       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)
-        rule = expand_path(rule, root) if expand_path
 
         return if skip?(rule)
 
         rule, negation = extract_negation(rule, allow)
+        rule = expand_path(rule, root) if expand_path
 
         anchored, prefix = prefix(rule)
 
@@ -79,23 +80,15 @@ class FastIgnore
       end
 
       def expand_path(rule, root)
-        if rule.match?(%r{^(?:[~/]|\.{1,2}/)})
-          ::File.expand_path(rule).delete_prefix(root)
-        else
-          rule
-        end
-      end
+        rule = ::File.expand_path(rule).delete_prefix(root) if rule.match?(%r{^(?:[~/]|\.{1,2}/)})
 
-      def skip?(rule)
-        empty?(rule) || comment?(rule)
-      end
+        rule = "/#{rule}" unless rule.start_with?('*') || rule.start_with?('/')
 
-      def empty?(rule)
-        rule.empty?
+        rule
       end
 
-      def comment?(rule)
-        rule.start_with?('#')
+      def skip?(rule)
+        rule.empty? || rule.start_with?('#')
       end
     end
   end

data/lib/fast_ignore/rule_set.rb

@@ -12,8 +12,8 @@ class FastIgnore
       @project_root = project_root
 
       @any_not_anchored = false
-      @empty = true
       @allow = allow
+      @default = true unless allow
     end
 
     def allowed_recursive?(path, dir)
@@ -30,35 +30,23 @@ class FastIgnore
         return rule.negation? if ::File.fnmatch?(rule.rule, path, 14)
       end
 
-      default?(dir)
-    end
-
-    def parse_rules(rule_line, root: @root, expand_path: false)
-      ::FastIgnore::RuleParser.new_rule(rule_line, rule_set: self, allow: @allow, root: root, expand_path: expand_path)
+      (not @allow) || (@any_not_anchored if dir)
     end
 
     def append_rules(anchored, rules)
       rules.each do |rule|
-        @empty = false
         @rules << rule
         @non_dir_only_rules << rule unless rule.dir_only?
         @any_not_anchored ||= !anchored
       end
     end
 
-    def clear_cache
-      @allowed_recursive = nil
+    def length
+      @rules.length
     end
 
-    private
-
-    def default?(dir)
-      return true unless @allow
-      return true if @empty
-      return false unless dir
-      return true if @any_not_anchored
-
-      false
+    def empty?
+      @rules.empty?
     end
   end
 end

data/lib/fast_ignore/rule_set_builder.rb

@@ -1,37 +1,88 @@
 # frozen_string_literal: true
 
 require_relative 'rule_set'
+require_relative 'rule_parser'
 
 class FastIgnore
   class RuleSetBuilder
-    attr_reader :rule_set
+    def self.from_args( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+      root: Dir.pwd,
+      ignore_rules: nil,
+      ignore_files: nil,
+      gitignore: :auto,
+      include_rules: nil,
+      include_files: nil,
+      argv_rules: nil
+    )
+      rule_sets = [
+        from_array(ignore_rules, root: root),
+        *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_files(include_files, allow: true, project_root: root),
+        from_array(argv_rules, root: root, allow: true, expand_path: true)
+      ]
 
-    def initialize(root:, allow: false)
-      @rule_set = RuleSet.new(project_root: root, allow: allow)
-      @root = root
-      @allow = allow
+      rule_sets.compact!
+      rule_sets.reject!(&:empty?)
+      rule_sets.sort_by!(&:length)
+      rule_sets
     end
 
-    def add_rules(rules, expand_path: false)
-      rules.each do |rule_string|
-        rule_string.each_line do |rule_line|
-          @rule_set.parse_rules(rule_line, root: @root, expand_path: expand_path)
-        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)
+
+      ::IO.foreach(filename) do |rule_string|
+        parse_rules(rule_string, allow: allow, rule_set: rule_set, root: root)
       end
 
-      @rule_set.clear_cache
+      rule_set
     end
 
-    def add_files(files)
-      files.each do |filename|
-        filename = ::File.expand_path(filename)
-        root = ::File.dirname(filename)
-        ::IO.foreach(filename) do |rule_string|
-          @rule_set.parse_rules(rule_string, root: root)
+    def self.from_files(files, allow: false, project_root: Dir.pwd)
+      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')
+      case gitignore
+      when :auto
+        from_file(default_path, project_root: root) if ::File.exist?(default_path)
+      when true
+        from_file(default_path, project_root: root)
+      when false
+        nil
+      else
+        from_file(gitignore, project_root: root)
+      end
+    end
+
+    def self.from_array(rules, allow: false, expand_path: false, root: Dir.pwd)
+      rules = Array(rules)
+      return if rules.empty?
+
+      rule_set = ::FastIgnore::RuleSet.new(project_root: root, allow: allow)
+
+      rules.each_with_object(rule_set) do |rule_string, set|
+        rule_string.each_line do |rule_line|
+          parse_rules(rule_line, rule_set: set, allow: allow, root: root, expand_path: expand_path)
         end
       end
+    end
 
-      @rule_set.clear_cache
+    def self.parse_rules(rule_line, rule_set:, allow: false, root: Dir.pwd, expand_path: false)
+      ::FastIgnore::RuleParser.new_rule(
+        rule_line,
+        rule_set: rule_set,
+        allow: allow,
+        root: root,
+        expand_path: expand_path
+      )
     end
   end
 end

data/lib/fast_ignore/version.rb

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

data/lib/fast_ignore.rb

@@ -1,69 +1,63 @@
 # frozen_string_literal: true
 
 require_relative './fast_ignore/rule_set_builder'
+require_relative './fast_ignore/backports'
 
 class FastIgnore
   include ::Enumerable
 
-  unless ::RUBY_VERSION >= '2.5'
+  if ::FastIgnore::Backports.ruby_version_less_than?(2, 5)
     require_relative 'fast_ignore/backports/delete_prefix_suffix'
     using ::FastIgnore::Backports::DeletePrefixSuffix
-  end
 
-  unless ::RUBY_VERSION >= '2.5'
     require_relative 'fast_ignore/backports/dir_each_child'
     using ::FastIgnore::Backports::DirEachChild
   end
 
-  def initialize( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength, Metrics/AbcSize
+  def initialize( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
     relative: false,
     root: ::Dir.pwd,
     ignore_rules: nil,
     ignore_files: nil,
-    gitignore: ::File.join(root, '.gitignore'),
+    gitignore: :auto,
     include_rules: nil,
-    include_files: nil
+    include_files: nil,
+    argv_rules: nil
   )
     @root = root.delete_suffix('/')
     @root_trailing_slash = "#{@root}/"
-    ignore = ::FastIgnore::RuleSetBuilder.new(root: @root)
-    only = ::FastIgnore::RuleSetBuilder.new(allow: true, root: @root)
-    only.add_files(Array(include_files))
-    only.add_rules(Array(include_rules), expand_path: true)
-    @only = only.rule_set
 
-    ignore.add_rules(['.git'])
-    ignore.add_files([gitignore]) if gitignore && ::File.exist?(gitignore)
-    ignore.add_files(Array(ignore_files))
-    ignore.add_rules(Array(ignore_rules))
-    @ignore = ignore.rule_set
+    @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
+    )
+
     @relative = relative
   end
 
   def each(&block)
     if block_given?
-      all_allowed(&block)
+      each_allowed(&block)
     else
-      enum_for(:all_allowed)
+      enum_for(:each_allowed)
     end
   end
 
   def allowed?(path)
     path = ::File.expand_path(path)
-    dir = ::File.directory?(path)
-    @ignore.allowed_recursive?(path, dir) && @only.allowed_recursive?(path, dir)
-  end
-
-  def all_allowed
-    find_children(@root_trailing_slash) do |path, dir|
-      next false unless @ignore.allowed_unrecursive?(path, dir)
-      next false unless @only.allowed_unrecursive?(path, dir)
-      next true if dir
+    stat = ::File.stat(path)
+    dir = stat.directory?
+    return false unless stat.readable?
+    return false if dir
 
-      yield prepare_path(path)
-
-      false
-    end
+    @rule_sets.all? { |r| r.allowed_recursive?(path, dir) }
+  rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+    false
   end
 
   private
@@ -72,15 +66,21 @@ class FastIgnore
     @relative ? path.delete_prefix(@root_trailing_slash) : path
   end
 
-  def find_children(path, &block) # rubocop:disable Metrics/MethodLength
+  def each_allowed(path = @root_trailing_slash, &block) # rubocop:disable Metrics/MethodLength
     Dir.each_child(path) do |child|
       begin
         child = path + child
         stat = ::File.stat(child)
         next unless stat.readable?
 
-        look_at_children = block.call child, stat.directory?
-        find_children("#{child}/", &block) if look_at_children
+        dir = stat.directory?
+        next unless @rule_sets.all? { |r| r.allowed_unrecursive?(child, dir) }
+
+        if dir
+          each_allowed("#{child}/", &block)
+        else
+          yield prepare_path(child)
+        end
       rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
         nil
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-20 00:00:00.000000000 Z
+date: 2020-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,9 +112,11 @@ files:
 - Rakefile
 - bin/console
 - bin/ls
+- bin/ls-disable-gems
 - bin/setup
 - 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/backports/match.rb