fast_ignore 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b87f43721c846fb9a6580451cb7fe607f40de8dd57bfab60c3e48454404c3456
-  data.tar.gz: d1b79c925d24ff57b3e0a6d7d74923d241807d6015f1570ba17c58bb9458493e
+  metadata.gz: 7129d0d60e64bc8b51ab8facc44ddba880dcdf826827a740e813505ac6ce44f1
+  data.tar.gz: 38006fd4177cbed4e0d8680a151b1ade36baf50e3ab3d3048059537a5c714bba
 SHA512:
-  metadata.gz: ff71be320a1218b786037efa9132d2167e80e899012afb843a59f03b7df414448892c2a71efa9e6504c2b558724a43fb1c17cd688802e0e3bbdf494ff9e7a714
-  data.tar.gz: 0a4f3bd777b3f8ca63086cbe63a61f759ca4915e4e6f80db74f69310d3ad59e997706fca8e6252326b2d217e2a79e6f3c4020eddb4eb646d6870fdc6cec44847
+  metadata.gz: 9ccace7734a566cbaee998a5fc44e646aa166fdd62929f79073d11b4062ec2d2cebebbfd6bfa59872e3e88f8c06c46bbb6a02aaa4a6b74411618875c4f2ccd7e
+  data.tar.gz: 90d37e05acfe7d6c0dedf4e28b76b631c121a190b8499daa8b620538b7e682637dc1b55b29a7efb8e98af687077fc4e766b5096455109cc4008dd1feff024059

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.4.0
+- include_rules support
+- to make room for this, `:rules` and `:files` keyword arguments are deprecated.
+  Please use `:ignore_rules` and `:ignore_files` instead.
+
 # v0.3.3
 - some performance improvements. maybe
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fast_ignore (0.3.3)
+    fast_ignore (0.4.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -28,7 +28,7 @@ $ gem install fast_ignore
 ## Usage
 
 ```ruby
-FastIgnore.new.each { |file| puts "#{file} is not ignored by the .gitignore" }
+FastIgnore.new.each { |file| puts "#{file} is not ignored by the .gitignore file" }
 ```
 
 Like many other enumerables, `FastIgnore#each` can return an enumerator
@@ -45,32 +45,64 @@ FastIgnore.new(relative: true).to_a
 
 You can specify other gitignore-style files to ignore as well. These rules will be appended after the gitignore file in order (order matters for negations)
 ```ruby
-FastIgnore.new(files: '/absolute/path/to/my/ignore/file').to_a
-FastIgnore.new(files: ['/absolute/path/to/my/ignore/file', '/and/another']).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
 ```
-You can also supply an array of rule lines. These rules will be appended after the gitignore and any other files in order (order matters for negations)
+You can also supply an array of rule strings. These rules will be appended after the gitignore and any other files in order (order matters for negations)
 ```ruby
-FastIgnore.new(rules: '.DS_Store').to_a
-FastIgnore.new(rules: ['.git', '.gitkeep']).to_a
+FastIgnore.new(ignore_rules: '.DS_Store').to_a
+FastIgnore.new(ignore_rules: ['.git', '.gitkeep']).to_a
 ```
 
-To only use another ignore file or set of rules, and not try to load a gitignore file:
+To use only another ignore file or an array of rules, and not try to load a gitignore file:
 ```ruby
-FastIgnore.new(files: 'absolute/path/to/my/ignore/file', gitignore: false)
-FastIgnore.new(rules: %w{my*rule /and/another !rule}, gitignore: false)
+FastIgnore.new(ignore_files: '/absolute/path/to/my/ignore/file', gitignore: false)
+FastIgnore.new(ignore_rules: %w{my*rule /and/another !rule}, gitignore: false)
 ```
 
 By default, FastIgnore will look in the directory the script is run in (`PWD`) for a gitignore file. If it's somewhere else:
 ```ruby
 FastIgnore.new(gitignore: '/absolute/path/to/.gitignore').to_a
 ```
-Note that the location of the .gitignore file will affect things like rules beginning with `/` or ending in `/**`
+Note that the location of the .gitignore file will affect rules beginning with `/` or ending in `/**`
 
 To check if a single file is allowed, use
 ```ruby
-FastIgnore.new.allowed?('/absolute/path/to/file')
+FastIgnore.new.allowed?('relative/path')
+FastIgnore.new.allowed?('./relative/path')
+FastIgnore.new.allowed?('/absolute/path')
+FastIgnore.new.allowed?('~/home/path')
 ```
 
+### Using an includes list.
+
+Building on the gitignore format, FastIgnore also accepts a list of allowed or included files.
+
+```
+# a line like this means any files named foo will be included
+# as well as any files within directories named foo
+foo
+# a line beginning with a slash will be anything in a directory that is a child of the PWD
+/foo
+# a line ending in a slash will will include any files in any directories named foo
+# but not any files named foo
+foo/
+# negated rules are slightly different from gitignore
+# in that they're evaluated after all the other the matching files rather than
+# in sequence with other rules
+fo*
+!foe
+# otherwise this format deals with *'s and ?'s and etc as you'd expect from gitignore.
+```
+
+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)
+```
+
+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.
+
 ## 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/bin/ls

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require_relative '../lib/fast_ignore'
 
-puts FastIgnore.new(relative: true).to_a.join("\n")
+puts FastIgnore.new(relative: true, include_rules: ARGV).to_a

data/lib/fast_ignore.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative './fast_ignore/delete_prefix_suffix'
 require_relative './fast_ignore/rule'
 require_relative './fast_ignore/rule_list'
 require_relative './fast_ignore/file_rule_list'
@@ -8,32 +7,60 @@ require_relative './fast_ignore/gitignore_rule_list'
 
 require 'find'
 
-class FastIgnore
-  include Enumerable
-  using DeletePrefixSuffix unless RUBY_VERSION >= '2.5'
+class FastIgnore # rubocop:disable Metrics/ClassLength
+  include ::Enumerable
+
+  unless ::RUBY_VERSION >= '2.5'
+    require_relative 'fast_ignore/backports/delete_prefix_suffix'
+    using ::FastIgnore::Backports::DeletePrefixSuffix
+  end
 
-  attr_reader :rules
   attr_reader :relative
   alias_method :relative?, :relative
   attr_reader :root
 
-  def initialize(
+  def initialize( # rubocop:disable Metrics/ParameterLists
+    relative: false,
+    root: ::Dir.pwd,
     rules: nil,
+    ignore_rules: rules,
     files: nil,
-    relative: false,
-    root: Dir.pwd,
-    gitignore: File.join(root, '.gitignore')
+    ignore_files: files,
+    gitignore: ::File.join(root, '.gitignore'),
+    include_rules: nil,
+    include_files: nil
   )
-    @rules = []
-    @rules += FastIgnore::RuleList.new(*Array(rules)).to_a
-    Array(files).reverse_each do |file|
-      @rules += FastIgnore::FileRuleList.new(file).to_a
+    if rules || files
+      warn <<~WARNING
+        \e[33mFastIgnore.new `:rules` and `:files` keyword arguments are deprecated.
+        Please use `:ignore_rules` and `:ignore_files` instead.\e[0m
+      WARNING
     end
-    @rules += FastIgnore::GitignoreRuleList.new(gitignore).to_a if gitignore
+    prepare_include_rules(include_rules, include_files)
+    prepare_ignore_rules(ignore_rules, ignore_files, gitignore)
     @relative = relative
     @root = root
   end
 
+  def prepare_ignore_rules(ignore_rules, ignore_files, gitignore)
+    @ignore_rules += ::FastIgnore::RuleList.new(*Array(ignore_rules)).to_a
+    Array(ignore_files).reverse_each do |file|
+      @ignore_rules += ::FastIgnore::FileRuleList.new(file).to_a
+    end
+
+    @ignore_rules += ::FastIgnore::GitignoreRuleList.new(gitignore).to_a if gitignore
+  end
+
+  def prepare_include_rules(include_rules, include_files)
+    include_rules = ::FastIgnore::RuleList.new(*Array(include_rules), expand_path: true).to_a
+    Array(include_files).reverse_each do |file|
+      include_rules += ::FastIgnore::FileRuleList.new(file).to_a
+    end
+
+    @include_rules = include_rules.reject(&:negation?)
+    @ignore_rules = include_rules.select(&:negation?).each(&:invert)
+  end
+
   def each(&block)
     if block_given?
       enumerator.each(&block)
@@ -42,33 +69,105 @@ class FastIgnore
     end
   end
 
-  def allowed?(path, dir: File.directory?(path))
-    return true if path == root
-
-    allowed?(File.dirname(path), dir: true) && pruned_allowed?(path, dir: dir)
+  def allowed?(path)
+    allowed_expanded?(::File.expand_path(path))
   end
 
   private
 
-  def enumerator # rubocop:disable Metrics/MethodLength
-    Enumerator.new do |yielder|
-      Find.find(root) do |path|
-        dir = File.directory?(path)
+  def enumerator
+    if !@include_rules.empty? && @include_rules.all?(&:globbable?)
+      glob_enumerator
+    else
+      find_enumerator
+    end
+  end
+
+  def allowed_expanded?(path, dir = ::File.directory?(path))
+    not_excluded_recursive?(path, dir) && not_ignored_recursive?(path, dir)
+  end
+
+  def glob_enumerator # rubocop:disable Metrics/MethodLength
+    seen = {}
+    ::Enumerator.new do |yielder|
+      ::Dir.glob(@include_rules.flat_map(&:glob_pattern), ::FastIgnore::Rule::FNMATCH_OPTIONS) do |path|
+        next if seen[path]
+
+        seen[path] = true
+        next if ::File.directory?(path)
+        next unless ::File.readable?(path)
+        next unless not_ignored_recursive?(path, false)
+
+        path = path.delete_prefix("#{root}/") if @relative
+
+        yielder << path
+      end
+    end
+  end
+
+  def find_enumerator # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    ::Enumerator.new do |yielder|
+      ::Find.find(root) do |path|
         next if path == root
-        next unless File.readable?(path)
-        next Find.prune unless pruned_allowed?(path, dir: dir)
+        next unless ::File.readable?(path)
+
+        dir = ::File.directory?(path)
+        next ::Find.prune unless not_ignored?(path, dir)
+        next unless not_excluded_recursive?(path, dir)
         next if dir
 
-        path = path.delete_prefix("#{root}/") if relative?
+        path = path.delete_prefix("#{root}/") if @relative
 
         yielder << path
       end
     end
   end
 
-  def pruned_allowed?(path, dir = File.directory?(path))
-    rules.each do |rule|
-      return rule.negation? if rule.match?(path, dir = dir)
+  def not_ignored_recursive?(path, dir = ::File.directory?(path))
+    @not_ignored ||= {}
+    @not_ignored.fetch(path) do
+      @not_ignored[path] = if path == root
+        true
+      else
+        not_ignored_recursive?(::File.dirname(path), true) && not_ignored?(path, dir)
+      end
+    end
+  end
+
+  def not_excluded_recursive?(path, dir = ::File.directory?(path))
+    return true if @include_rules.empty?
+
+    @not_excluded ||= {}
+    @not_excluded.fetch(path) do
+      @not_excluded[path] = if path == root
+        false
+      else
+        not_excluded_recursive?(::File.dirname(path), true) || not_excluded?(path, dir)
+      end
     end
   end
+
+  def non_dir_ignore_rules
+    @non_dir_ignore_rules ||= @ignore_rules.reject(&:dir_only?)
+  end
+
+  def non_dir_include_rules
+    @non_dir_include_rules ||= @include_rules.reject(&:dir_only?)
+  end
+
+  def not_excluded?(path, dir)
+    return true if @include_rules.empty?
+
+    (dir ? @include_rules : non_dir_include_rules).find do |rule|
+      rule.match?(path)
+    end
+  end
+
+  def not_ignored?(path, dir)
+    (dir ? @ignore_rules : non_dir_ignore_rules).each do |rule|
+      return rule.negation? if rule.match?(path)
+    end
+
+    true
+  end
 end

data/lib/fast_ignore/backports/delete_prefix_suffix.rb

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

data/lib/fast_ignore/backports/match.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# This is a backport of ruby 2.4's match? method
+class FastIgnore
+  module Backports
+    module Match
+      refine ::String do
+        alias_method :match?, :match
+      end
+
+      refine ::Regexp do
+        alias_method :match?, :match
+      end
+    end
+  end
+end

data/lib/fast_ignore/file_rule_list.rb

@@ -3,9 +3,9 @@
 require_relative './rule'
 
 class FastIgnore
-  class FileRuleList < FastIgnore::RuleList
-    def initialize(file, root: File.dirname(file))
-      @lines = IO.foreach(file)
+  class FileRuleList < ::FastIgnore::RuleList
+    def initialize(file, root: ::File.dirname(file))
+      @lines = ::IO.foreach(file)
       @root = root
     end
   end

data/lib/fast_ignore/gitignore_rule_list.rb

@@ -2,15 +2,15 @@
 
 class FastIgnore
   class GitignoreRuleList
-    include Enumerable
+    include ::Enumerable
 
     def initialize(file)
       @file = file
     end
 
     def each(&block)
-      FastIgnore::RuleList.new('.git').each(&block)
-      FastIgnore::FileRuleList.new(file).each(&block)
+      ::FastIgnore::RuleList.new('.git').each(&block)
+      ::FastIgnore::FileRuleList.new(file).each(&block)
     end
 
     private

data/lib/fast_ignore/rule.rb

@@ -2,17 +2,28 @@
 
 class FastIgnore
   class Rule
-    using DeletePrefixSuffix unless RUBY_VERSION >= '2.5'
+    unless ::RUBY_VERSION >= '2.5'
+      require_relative 'backports/delete_prefix_suffix'
+      using ::FastIgnore::Backports::DeletePrefixSuffix
+    end
+
+    unless ::RUBY_VERSION >= '2.4'
+      require_relative 'backports/match'
+      using ::FastIgnore::Backports::Match
+    end
+
+    FNMATCH_OPTIONS = (::File::FNM_DOTMATCH | ::File::FNM_PATHNAME | ::File::FNM_CASEFOLD).freeze
 
-    FNMATCH_OPTIONS = File::FNM_DOTMATCH | File::FNM_PATHNAME
+    attr_reader :rule, :glob_prefix
 
-    def initialize(rule, root:)
+    def initialize(rule, root:, expand_path: false)
       @rule = rule
       strip!
+      extract_dir_only
+      expand_path(root) if expand_path
       return if skip?
 
       extract_negation
-      extract_dir_only
 
       @rule = "#{root}#{prefix}#{@rule}"
     end
@@ -21,6 +32,22 @@ class FastIgnore
       @negation
     end
 
+    def invert
+      @negation = !@negation
+    end
+
+    def glob_pattern
+      @glob_pattern ||= if @dir_only
+        "#{@rule}/**/*"
+      else
+        [@rule, "#{@rule}/**/*"]
+      end
+    end
+
+    def globbable?
+      !@rule.match?(%r{/\*\*/.*[^*/]})
+    end
+
     def extract_negation
       @negation = false
       return unless @rule.start_with?('!')
@@ -31,18 +58,18 @@ class FastIgnore
 
     def extract_dir_only
       @dir_only = false
-      @not_dir_only = true
       return unless @rule.end_with?('/')
 
       @rule = @rule[0..-2]
       @dir_only = true
-      @not_dir_only = false
     end
 
-    def match?(path, dir = File.directory?(path))
-      return false unless dir || @not_dir_only
+    def dir_only?
+      @dir_only
+    end
 
-      File.fnmatch?(@rule, path, FNMATCH_OPTIONS)
+    def match?(path)
+      ::File.fnmatch?(@rule, path, ::FastIgnore::Rule::FNMATCH_OPTIONS)
     end
 
     def empty?
@@ -63,7 +90,9 @@ class FastIgnore
 
     private
 
-    attr_reader :root
+    def expand_path(root)
+      @rule = ::File.expand_path(@rule).delete_prefix(root) if @rule.match?(%r{^(?:[~/]|..?/)})
+    end
 
     def prefix
       @prefix ||= if @rule.start_with?('/')

data/lib/fast_ignore/rule_list.rb

@@ -2,11 +2,12 @@
 
 class FastIgnore
   class RuleList
-    include Enumerable
+    include ::Enumerable
 
-    def initialize(*lines, root: Dir.pwd)
+    def initialize(*lines, root: ::Dir.pwd, expand_path: false)
       @lines = lines
       @root = root
+      @expand_path = expand_path
     end
 
     def each(&block)
@@ -17,12 +18,12 @@ class FastIgnore
 
     private
 
-    attr_reader :lines, :root
+    attr_reader :lines, :root, :expand_path
 
     def enumerator
-      Enumerator.new do |yielder|
+      ::Enumerator.new do |yielder|
         lines.reverse_each do |rule|
-          rule = FastIgnore::Rule.new(rule, root: root)
+          rule = ::FastIgnore::Rule.new(rule, root: root, expand_path: expand_path)
           yielder << rule unless rule.skip?
         end
       end

data/lib/fast_ignore/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-27 00:00:00.000000000 Z
+date: 2019-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -116,7 +116,8 @@ files:
 - bin/setup
 - fast_ignore.gemspec
 - lib/fast_ignore.rb
-- lib/fast_ignore/delete_prefix_suffix.rb
+- lib/fast_ignore/backports/delete_prefix_suffix.rb
+- lib/fast_ignore/backports/match.rb
 - lib/fast_ignore/file_rule_list.rb
 - lib/fast_ignore/gitignore_rule_list.rb
 - lib/fast_ignore/rule.rb

data/lib/fast_ignore/delete_prefix_suffix.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-# This is a backport of ruby 2.5's delete_prefix/delete_suffix methods
-module DeletePrefixSuffix
-  refine String do
-    def delete_prefix!(str)
-      slice!(0..(str.length - 1)) if start_with?(str)
-      self
-    end
-
-    def delete_suffix!(str)
-      slice!(-str.length..-1) if end_with?(str)
-      self
-    end
-
-    def delete_prefix(str)
-      dup.delete_prefix!(str)
-    end
-
-    def delete_suffix(str)
-      dup.delete_suffix!(str)
-    end
-  end
-end