fast_ignore 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e68a04cc6c34d7f72a6049beb86c9808c43bae4e712a1e9e8462e8e18f331bf0
-  data.tar.gz: 3c015e68f03e9d387064a68d42fe6f367e60894e1a20f02945af2c6669ddcebb
+  metadata.gz: ee7e9eb231ff6441ca703c935e9c270e4cb6c2f8f3216d993d4fc891807e77f6
+  data.tar.gz: 68f1ace7ab6420ce140a43a747a969f29401eba718dd9d1e94b9538774b0ac6d
 SHA512:
-  metadata.gz: 047ec0c2f7fe90a3bf9a23b01ec3aa054bd7770e2f3b9d38dae8e77704ef8dd7d8d1449633faa3c7aae9ecc7b4d236f8b3442e5b3dcf489cf825da85efce19e5
-  data.tar.gz: d9fa32ba54a4268ce530556767972fd60dbf04a24ec8a890110fd084675611721244cbdf1f1722bfc70fe41794458a7fe6a0ecbde388149308ff710e76610a43
+  metadata.gz: 83609a93cf79d3d4063e69d213450d85f81c4b9bb7c1200468e46fa7fce01602c751c4afd6dbaef652d1761c0f180fa5806ff29d0913ca184a5e41850875a8d0
+  data.tar.gz: dbf3e341e671fa1a51dce4c885c04e1eadf0717d78ffd94f1746c63b1024f78bd9d4b6915e7b892ca3af21d27ef2566df980be41101573c3dd586384b6f6d7c6

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.13.0
+- Attempt to improve documentation structure
+- Remove `gitignore: true` raising `Errno::ENOENT` if root:/.gitignore didn't exist. I can't think of a use. Now `gitignore: true` is just the default behaviour.
+- Don't ignore `.git` if `gitignore: false`.
+
 # v0.12.1
 - Reads all relevant git config files when finding a global .gitignore
 

data/README.md

@@ -1,6 +1,7 @@
 # FastIgnore
 
-[![travis](https://travis-ci.org/robotdana/fast_ignore.svg?branch=master)](https://travis-ci.org/robotdana/fast_ignore)
+[![travis](https://travis-ci.com/robotdana/fast_ignore.svg?branch=master)](https://travis-ci.com/robotdana/fast_ignore)
+[![Gem Version](https://badge.fury.io/rb/fast_ignore.svg)](https://rubygems.org/gems/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.
@@ -14,13 +15,15 @@ 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 & jruby
-- supports all gitignore rule patterns
+- Supports ruby 2.4-2.7 & jruby
+- supports all [gitignore rule patterns](https://git-scm.com/docs/gitignore#_pattern_format)
 - 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: `#!:`
-- in addition to .gitignore, reads .git/info/excludes and the ignore file mentioned in your ~/.gitconfig
+- supports a gitignore-esque "include" patterns. ([`include_rules:`](#include_rules)/[`include_files:`](#include_files))
+- supports an expansion of include patterns, expanding and anchoring paths ([`argv_rules:`](#argv_rules))
+- supports [matching by shebang](#shebang_rules) rather than filename for extensionless files: `#!:`
+- reads .gitignore in all subdirectories
+- reads .git/info/excludes
+- reads the ignore file mentioned in your git config
 
 ## Installation
 
@@ -47,22 +50,26 @@ FastIgnore.new.each { |file| puts "#{file} is not ignored by the .gitignore file
 
 ### `#each`, `#map` etc
 
-The FastIgnore object is an enumerable and responds to all Enumerable methods
+This yields paths that are _not_ ignored by the gitignore, i.e. the paths that would be returned by `git ls-files`.
+
+A FastIgnore instance 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
+Like other enumerables, `FastIgnore#each` can return an enumerator:
 
 ```ruby
 FastIgnore.new.each.with_index { |file, index| puts "#{file}#{index}" }
 ```
 
+**Warning: Do not change directory (e.g. `Dir.chdir`) in the block.**
+
 ### `#allowed?`
 
-To check if a single file is allowed, use
+To check if a single path is allowed, use
 ```ruby
 FastIgnore.new.allowed?('relative/path')
 FastIgnore.new.allowed?('./relative/path')
@@ -70,7 +77,9 @@ FastIgnore.new.allowed?('/absolute/path')
 FastIgnore.new.allowed?('~/home/path')
 ```
 
-This is aliased as `===` so you can use the FastIgnore object in case statements.
+Relative paths will be considered relative to the [`root:`](#root) directory, not the current directory.
+
+This is aliased as `===` so you can use a FastIgnore instance in case statements.
 ```ruby
 case my_path
 when FastIgnore.new
@@ -78,18 +87,34 @@ when FastIgnore.new
 end
 ```
 
-It's recommended to memoize the FastIgnore.new object somehow to avoid having to parse the gitignore file repeatedly.
+It's recommended to save the FastIgnore instance to a variable to avoid having to read and parse the gitignore file and gitconfig files repeatedly.
+
+See [Optimising allowed](#optimising_allowed) for ways to make this even faster
+
+**Note: A file must exist at that path and not be a directory for it to be considered allowed.**
+Essentially it can be thought of as `` `git ls-files`.include?(path) `` but much faster.
+This excludes all directories and all possible path names that don't exist.
+
 
 ### `relative: true`
-By default, FastIgnore.each will yield full paths. To yield paths relative to the current working directory, or if supplied, [`root:`](#root), use:
+
+**Default: false**
+
+When `relative: false`: FastIgnore#each will yield full paths.
+When `relative: true`: FastIgnore#each will yield paths relative to the [`root:`](#root) directory
 
 ```ruby
 FastIgnore.new(relative: true).to_a
 ```
 
 ### `follow_symlinks: true`
-By default, FastIgnore will match git's behaviour and not follow symbolic links.
-To make it follow symlinks, use:
+
+**Default: false**
+
+When `follow_symlinks: false`: FastIgnore#each will match git's behaviour and not follow symbolic links.
+When `follow_symlinks: true`: FastIgnore#each will check if a symlink points to a directory, and files in linked directories must also match rules using the symlink path as the directory location, not the real directory location.
+
+**This doesn't use the real path for matching or yield or return it.**
 
 ```ruby
 FastIgnore.new(follow_symlinks: true).to_a
@@ -97,14 +122,16 @@ FastIgnore.new(follow_symlinks: true).to_a
 
 ### `root:`
 
-By default, root is PWD (the current working directory)
+**Default: Dir.pwd ($PWD, the current working directory)**
+
 This directory is used for:
-- the location of .git/core/exclude
-- the outermost directory that project .gitignore files are looked for
-- the root directory for array rules starting with `/` or ending with `/**`
-- and the path that relative is relative to
-- the ancestor of which files get checked
-- the ancestor of all include_files and ignore_files
+- the location of `.git/core/exclude`
+- the ancestor of all non-global [automatically loaded `.gitignore` files](#gitignore_false)
+- the root directory for array rules ([`ignore_rules:`](#ignore_rules), [`include_rules:`](#include_rules), [`argv_rules:`](#argv_rules)) containing `/`
+- the path that [`relative:`](#relative_true) is relative to
+- the ancestor of all paths yielded by [`#each`](#each_map_etc)
+- the path that [`#allowed?`](#allowed) considers relative paths relative to
+- the ancestor of all [`include_files:`](#include_files) and [`ignore_files:`](#ignore_files)
 
 To use a different directory:
 ```ruby
@@ -112,37 +139,49 @@ FastIgnore.new(root: '/absolute/path/to/root').to_a
 FastIgnore.new(root: '../relative/path/to/root').to_a
 ```
 
+A relative root will be found relative to the current working directory when the FastIgnore instance is initialized, and that will be the last time the current working directory is relevant.
+
+**Note: Changes to the current working directory (e.g. with `Dir.chdir`), after initialising a FastIgnore instance, will _not_ affect the FastIgnore instance. `root:` will always be what it was when the instance was initialized.**
+
 ### `gitignore:`
 
-By default, the .gitignore file in the root directory is loaded, plus any .gitignore files in subdirectories, the global ignore file, and .git/info/exclude.
+**Default: true**
+
+When `gitignore: true`: the .gitignore file in the [`root:`](#root) directory is loaded, plus any .gitignore files in its subdirectories, the global git ignore file as described in git config, and .git/info/exclude. `.git` directories are also excluded to match the behaviour of `git ls-files`.
+When `gitignore: false`: no ignore files or git config files are automatically read, and `.git` will not be automatically excluded.
 
-To not do this use
 ```ruby
 FastIgnore.new(gitignore: false).to_a
 ```
 
-To raise an `Errno::ENOENT` error if the .gitignore file is not found use:
-```ruby
-FastIgnore.new(gitignore: true).to_a
-```
+### `ignore_files:`
 
-If the gitignore file is somewhere else
-```ruby
-FastIgnore.new(ignore_file: '/absolute/path/to/.gitignore').to_a
-```
-Note that the location of the .gitignore file will affect rules beginning with `/` or ending in `/**`
+**This is a list of files in the gitignore format to parse and match paths against, not a list of files to ignore**  If you want an array of files use [`ignore_rules:`](#ignore_rules)
+
+Additional gitignore-style files, either as a path or an array of paths.
 
-### `ignore_files:`
 You can specify other gitignore-style files to ignore as well.
 Missing files will raise an `Errno::ENOENT` error.
 
+Relative paths are relative to the [`root:`](#root) directory.
+Absolute paths also need to be within the [`root:`](#root) directory.
+
+
 ```ruby
 FastIgnore.new(ignore_files: 'relative/path/to/my/ignore/file').to_a
 FastIgnore.new(ignore_files: ['/absolute/path/to/my/ignore/file', '/and/another']).to_a
 ```
 
+Note: the location of the files will affect rules beginning with or containing `/`.
+
+To avoid raising `Errno::ENOENT` when the file doesn't exist:
+```ruby
+FastIgnore.new(ignore_files: ['/ignore/file'].select { |f| File.exist?(f) }).to_a
+```
+
 ### `ignore_rules:`
-You can also supply an array of rule strings.
+
+This can be a string, or an array of strings, and multiline strings can be used with one rule per line.
 
 ```ruby
 FastIgnore.new(ignore_rules: '.DS_Store').to_a
@@ -150,84 +189,110 @@ FastIgnore.new(ignore_rules: ['.git', '.gitkeep']).to_a
 FastIgnore.new(ignore_rules: ".git\n.gitkeep").to_a
 ```
 
-### `include_files:` and `include_rules:`
+These rules use the [`root:`](#root) argument to resolve rules containing `/`.
 
-Building on the gitignore format, FastIgnore also accepts a list of allowed or included files.
+### `include_files:`
 
-```gitignore
-# 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/
-fo*
-!foe
-# otherwise this format deals with !'s, *'s and ?'s and etc as you'd expect from gitignore.
+**This is an array of files in the gitignore format to parse and match paths against, not a list of files to include.**  If you want an array of files use [`include_rules:`](#include_rules).
+
+Building on the gitignore format, FastIgnore also accepts rules to include matching paths (rather than ignoring them).
+A rule matching a directory will include all descendants of that directory.
+
+These rules can be provided in files either as absolute or relative paths, or an array of paths.
+Relative paths are relative to the [`root:`](#root) directory.
+Absolute paths also need to be within the [`root:`](#root) directory.
+
+```ruby
+FastIgnore.new(include_files: 'my_include_file').to_a
+FastIgnore.new(include_files: ['/absolute/include/file', './relative/include/file']).to_a
+```
+
+Missing files will raise an `Errno::ENOENT` error.
+
+To avoid raising `Errno::ENOENT` when the file doesn't exist:
+```ruby
+FastIgnore.new(include_files: ['include/file'].select { |f| File.exist?(f) }).to_a
 ```
 
-These can be passed either as files or as an array or string rules
+**Note: All paths checked must not be excluded by any ignore files AND each included by include file separately AND the [`include_rules:`](#include_rules) AND the [`argv_rules:`](#argv_rules). see [Combinations](#combinations) for solutions to using OR.**
+
+### `include_rules:`
+
+Building on the gitignore format, FastIgnore also accepts rules to include matching paths (rather than ignoring them).
+A rule matching a directory will include all descendants of that directory.
+
+This can be a string, or an array of strings, and multiline strings can be used with one rule per line.
 ```ruby
-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.
+Rules use the [`root:`](#root) argument to resolve rules containing `/`.
+
+**Note: All paths checked must not be excluded by any ignore files AND each included by [include file](#include_files) separately AND the `include_rules:` AND the [`argv_rules:`](#argv_rules). see [Combinations](#combinations) for solutions to using OR.**
+
+### `argv_rules:`
+This is like [`include_rules:`](#include_rules) with additional features meant for dealing with humans and `ARGV` values.
+
+It expands rules that are absolute paths, and paths beginning with `~`, `../` and `./` (with and without `!`).
+This means rules beginning with `/` are absolute. Not relative to [`root:`](#root).
+
+Additionally it assumes all rules are relative to the [`root:`](#root) directory (after resolving absolute paths) unless they begin with `*` (or `!*`).
+
+This can be a string, or an array of strings, and multiline strings can be used with one rule per line.
 
 ```ruby
 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 `!`)
-It assumes all rules are anchored unless they begin with `*` or `!*`.
+**Warning: it will *not* expand e.g. `/../` in the middle of a rule that doesn't begin with any of `~`,`../`,`./`,`/`.**
 
-Note: it will *not* resolve e.g. `/../` in the middle of a rule that doesn't begin with any of `~`,`../`,`./`,`/`.
+**Note: All paths checked must not be excluded by any ignore files AND each included by [include file](#include_files) separately AND the [`include_rules:`](#include_rules) AND the `argv_rules:`. see [Combinations](#combinations) for solutions to using OR.**
 
 ### 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:
+Sometimes you need to match files by their shebang/hashbang/etc rather than their path or filename
 
-Lines beginning with `#!:` will match whole words in the shebang line of extensionless files.
+Rules 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.
+Only exact substring matches are available, There's no special handling of * or / or etc.
 
+These rules can be supplied any way regular rules are, whether in a .gitignore file or files mentioned in [`include_files:`](#include_files) or [`ignore_files:`](#ignore_files) or [`include_rules:`](#include_rules) or [`ignore_rules:`](#ignore_rules) or [`argv_rules:`](#argv_rules)
 ```ruby
 FastIgnore.new(include_rules: ['*.rb', '#!:ruby']).to_a
 FastIgnore.new(ignore_rules: ['*.sh', '#!:sh', '#!:bash', '#!:zsh']).to_a
 ```
 
+**Note: git considers rules like this as a comment and will ignore them.**
+
 ## 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.
+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 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:`
+provide the files as strings to [`include_rules:`](#include_rules) or [`ignore_rules:`](#ignore_rules)
 ```ruby
 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.
+This does unfortunately lose the file path as the root for rules containing `/`.
+If that's important, combine the files in the file system and use [`include_files:`](#include_files) or [`ignore_files:`](#ignore_files) as normal.
 
-To use the additional ARGV handling rules mentioned above for files, read the file into the array as a string.
+To use the additional `ARGV` handling of [`argv_rules:`](#argv_rules) on a file, read the file into the array.
 
 ```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.
+This does unfortunately lose the file path as the root `/` and there is no workaround except setting the [`root:`](#root) for the whole FastIgnore instance.
 
 ### optimising #allowed?
 
@@ -239,10 +304,11 @@ This is not required, and if FastIgnore does have to go to the filesystem for th
 
 
 ## Known issues
-- Doesn't know what to do if you change the current working directory inside the `FastIgnore#each` block.
+- Doesn't know what to do if you change the current working directory inside the [`FastIgnore#each`](#each_map_etc) block.
   So don't do that.
 
-  (It does handle changing the current working directory between `FastIgnore#allowed?` calls.)
+  (It does handle changing the current working directory between [`FastIgnore#allowed?`](#allowed) calls) (changing directories doesn't affect the [`root:`](#root) directory, that's frozen at FastIgnore.new (this is a design decision, not an issue)).
+- FastIgnore always matches patterns case-insensitively. (git varies by filesystem).
 
 ## Development
 
@@ -254,6 +320,12 @@ This repo is too small to stress bin/time more than 0.01s, switch to a large rep
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 
+### Goals
+
+1. Match `git ls-files` behaviour quirk for quirk.
+2. Provide a convenient interface for allowlist/denylist files in ruby.
+3. Be fast.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/robotdana/fast_ignore.

data/lib/fast_ignore.rb

@@ -22,9 +22,9 @@ class FastIgnore
 
   def initialize(relative: false, root: nil, gitignore: :auto, follow_symlinks: false, **rule_set_builder_args)
     @relative = relative
-    @follow_symlinks = follow_symlinks
+    @follow_symlinks_method = ::File.method(follow_symlinks ? :stat : :lstat)
     @gitignore_enabled = gitignore
-    @loaded_gitignore_files = Set[''] if gitignore
+    @loaded_gitignore_files = ::Set[''] if gitignore
     @root = "#{::File.expand_path(root.to_s, Dir.pwd)}/"
     @rule_sets = ::FastIgnore::RuleSetBuilder.build(root: @root, gitignore: gitignore, **rule_set_builder_args)
 
@@ -43,7 +43,7 @@ class FastIgnore
   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.nil? ? directory?(full_path) : directory
+    return false if directory.nil? ? @follow_symlinks_method.call(full_path).directory? : directory
 
     relative_path = full_path.delete_prefix(@root)
     load_gitignore_recursive(relative_path) if @gitignore_enabled
@@ -58,14 +58,6 @@ class FastIgnore
 
   private
 
-  def directory?(path)
-    if @follow_symlinks
-      ::File.stat(path).directory?
-    else
-      ::File.lstat(path).directory?
-    end
-  end
-
   def load_gitignore_recursive(path)
     paths = []
     while (path = ::File.dirname(path)) != '.'
@@ -93,7 +85,7 @@ class FastIgnore
       begin
         full_path = parent_full_path + filename
         relative_path = parent_relative_path + filename
-        dir = directory?(full_path)
+        dir = @follow_symlinks_method.call(full_path).directory?
 
         next unless @rule_sets.all? { |r| r.allowed_unrecursive?(relative_path, dir, full_path, filename, nil) }
 

data/lib/fast_ignore/rule_builder.rb

@@ -32,7 +32,7 @@ class FastIgnore
       end
 
       def shebang_rules(rule, allow)
-        rules = [::FastIgnore::ShebangRule.new(/\A#!.*\b#{Regexp.escape(rule)}\b/.freeze, allow)]
+        rules = [::FastIgnore::ShebangRule.new(/\A#!.*\b#{Regexp.escape(rule)}\b/i.freeze, allow)]
         return rules unless allow
 
         rules << ::FastIgnore::Rule.new('**/*', true, true, true)

data/lib/fast_ignore/rule_set.rb

@@ -46,9 +46,10 @@ class FastIgnore
 
     def squash_rules(rules)
       out = rules.chunk_while { |a, b| a.type == b.type }.map do |chunk|
-        next chunk.first if chunk.length == 1
+        first = chunk.first
+        next first if chunk.length == 1
 
-        chunk.first.class.new(Regexp.union(chunk.map(&:rule)), chunk.first.negation?)
+        first.class.new(Regexp.union(chunk.map(&:rule)), first.negation?)
       end
 
       out

data/lib/fast_ignore/rule_set_builder.rb

@@ -11,7 +11,7 @@ class FastIgnore
         root:,
         ignore_rules: nil,
         ignore_files: nil,
-        gitignore: :auto,
+        gitignore: true,
         include_rules: nil,
         include_files: nil,
         argv_rules: nil
@@ -19,7 +19,7 @@ class FastIgnore
         prepare [
           from_array(ignore_rules),
           *from_files(ignore_files, project_root: root),
-          from_array('.git'),
+          (from_array('.git') if gitignore),
           from_gitignore_arg(gitignore, project_root: root),
           from_array(include_rules, allow: true),
           *from_files(include_files, allow: true, project_root: root),
@@ -72,12 +72,12 @@ class FastIgnore
         gi = ::FastIgnore::RuleSet.new([], false, true)
         gi << from_root_gitignore_file(global_gitignore_path(root: project_root))
         gi << from_root_gitignore_file(::File.join(project_root, '.git/info/exclude'))
-        gi << from_root_gitignore_file(::File.join(project_root, '.gitignore'), soft: gitignore == :auto)
+        gi << from_root_gitignore_file(::File.join(project_root, '.gitignore'))
         gi
       end
 
-      def from_root_gitignore_file(path, soft: true)
-        return if soft && !::File.exist?(path)
+      def from_root_gitignore_file(path)
+        return unless ::File.exist?(path)
 
         build_rule_set(::File.readlines(path), false, file_root: '', gitignore: true)
       end

data/lib/fast_ignore/shebang_rule.rb

@@ -15,8 +15,7 @@ class FastIgnore
       @rule = rule
       @negation = negation
 
-      @type = 2
-      @type += 1 if negation
+      @type = negation ? 3 : 2
 
       freeze
     end

data/lib/fast_ignore/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_ignore
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.13.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-24 00:00:00.000000000 Z
+date: 2020-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -143,27 +143,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".leftovers.yml"
-- ".rspec"
-- ".rubocop.yml"
-- ".simplecov"
-- ".spellr.yml"
-- ".spellr_wordlists/english.txt"
-- ".spellr_wordlists/ruby.txt"
-- ".spellr_wordlists/shell.txt"
-- ".travis.yml"
 - CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/console
-- bin/ls
-- bin/ls_seconds
-- bin/setup
-- bin/time
-- fast_ignore.gemspec
 - lib/fast_ignore.rb
 - lib/fast_ignore/backports.rb
 - lib/fast_ignore/fn_match_to_re.rb

data/.gitignore

@@ -1,6 +0,0 @@
-/.bundle/
-/coverage/
-/pkg/
-.rspec_status
-*.gem
-Gemfile.lock

data/.leftovers.yml

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

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.rubocop.yml

@@ -1,216 +0,0 @@
-require: rubocop-rspec
-
-# Reference:
-# https://rubocop.readthedocs.io/en/latest/
-
-# Keep this in alphabetical order.
-# Each override should have a comment (even if it's just "default is bad")
-
-AllCops:
-  NewCops: enable
-  Exclude:
-    - db/schema*
-    - .bundle/**/*
-    - tmp/**/*
-    - vendor/**/*
-  DisplayCopNames: true
-  DisplayStyleGuide: true
-  TargetRubyVersion: 2.4
-
-# all of our layout customisations are because we prefer indentation to be
-# always consistently 2 spaces, for blocks, scopes, multiline expressions, etc
-# e.g.
-# class Klass
-#   def method(arg1,
-#     arg2)
-#     value = if arg1 == 'value' && arg2 == 'value'
-#       method2
-#         .method(arg_a, arg_b,
-#           arg_c, arg_d, keyword1: true,
-#           keyword2: true) do
-#             @last = [
-#               arg_a, arg_b,
-#               arg_c, arg_d
-#             ]
-#           end
-#     end
-#     value
-#   end
-# end
-
-# to match our preference for consistent indentation
-Layout/HashAlignment:
-  EnforcedLastArgumentHashStyle: always_ignore
-
-# to match our preference for consistent indentation
-Layout/ParameterAlignment:
-  EnforcedStyle: with_fixed_indentation
-
-# to match our preference for consistent indentation
-Layout/BlockAlignment:
-  EnforcedStyleAlignWith: start_of_block
-
-# to match our preference for consistent indentation
-Layout/CaseIndentation:
-  EnforcedStyle: end
-
-# to match our preference for consistent indentation
-Layout/EndAlignment:
-  EnforcedStyleAlignWith: start_of_line
-
-# Aligning Assignments, etc makes diffs noisy
-Layout/ExtraSpacing:
-  AllowForAlignment: false
-
-# to match our preference for consistent indentation
-Layout/FirstArrayElementLineBreak:
-  Enabled: true
-
-# to match our preference for consistent indentation
-Layout/FirstHashElementLineBreak:
-  Enabled: true
-
-# to match our preference for consistent indentation
-Layout/FirstArgumentIndentation:
-  EnforcedStyle: consistent
-
-# to match our preference for consistent indentation
-Layout/FirstArrayElementIndentation:
-  EnforcedStyle: consistent
-
-# to match our preference for consistent indentation
-Layout/FirstHashElementIndentation:
-  EnforcedStyle: consistent
-
-Layout/LineLength:
-  Max: 120
-
-# to match our preference for consistent indentation
-# and hanging assignment looks lost
-Layout/MultilineAssignmentLayout:
-  EnforcedStyle: same_line
-
-# this changes our preferred:
-#   value = if thing1 &&
-#     thing2
-# to:
-#   value = if thing1 &&
-#       thing2
-# even though the IndentationWidth is 2
-# but it's right most of the time so I put up with it
-Layout/MultilineOperationIndentation:
-  EnforcedStyle: indented
-
-Layout/MultilineMethodCallIndentation:
-  EnforcedStyle: indented
-
-# Temporarily disable this spec as a recent change has broken it for us:
-# https://github.com/rubocop-hq/rubocop/issues/6254
-Layout/RescueEnsureAlignment:
-  Enabled: false
-
-Metrics:
-  CountComments: false
-
-Metrics/BlockLength:
-  ExcludedMethods:
-    - configure
-    - describe
-    - context
-    - shared_examples
-
-Metrics/CyclomaticComplexity:
-  Enabled: false
-
-Metrics/PerceivedComplexity:
-  Enabled: false
-
-RSpec:
-  Enabled: true
-  Include:
-    - 'spec/**/*.rb'
-
-RSpec/DescribeClass:
-  Enabled: false
-
-# I misuse matchers often
-RSpec/ExpectActual:
-  Enabled: false
-
-RSpec/FilePath:
-  Enabled: false
-
-# Multiple expectations are useful
-# checking you've partially achieved something on the way to completely achieving it is useful for debugging failures
-RSpec/MultipleExpectations:
-  Enabled: false
-
-# It should be obvious from context. Chill out rubocop
-RSpec/NamedSubject:
-  Enabled: false
-
-RSpec/NestedGroups:
-  Max: 7
-
-# This matches the style we've been using all along (ever so slightly more frequently)
-Style/Alias:
-  EnforcedStyle: prefer_alias_method
-
-Style/CollectionMethods:
-  Enabled: true
-
-# we don't rdoc
-Style/Documentation:
-  Enabled: false
-
-# this can mess with the balance of symmetric cases
-Style/IfInsideElse:
-  Enabled: false
-
-# [a, b].include?(x) is more unclear than a == x || b == x
-Style/MultipleComparison:
-  Enabled: false
-
-# it's microscopically faster
-Style/Not:
-  Enabled: false
-
-# we use %w{} pretty frequently
-Style/PercentLiteralDelimiters:
-  PreferredDelimiters:
-    default: '{}'
-    '%w': '{}'
-    '%W': '{}'
-    '%i': '{}'
-    '%I': '{}'
-    '%r': '{}'
-
-# We want this to warn to force consistency within the codebase.
-Style/SafeNavigation:
-  Enabled: true
-
-# different methods calls that do exactly the same thing are a smell, regardless of semantics
-Style/SignalException:
-  EnforcedStyle: only_raise
-
-# this wants less descriptive names
-Style/SingleLineBlockParams:
-  Enabled: false
-
-Style/SymbolArray:
-  Enabled: false
-
-Style/WordArray:
-  Enabled: false
-
-Style/HashEachMethods:
-  Enabled: true
-
-Style/HashTransformKeys:
-  Enabled: true
-
-Style/HashTransformValues:
-  Enabled: true
-
-Style/CommentedKeyword:
-  Enabled: false

data/.simplecov

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-SimpleCov.start do
-  add_filter '/backports'
-  add_filter '/spec/'
-  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/.spellr.yml

@@ -1,5 +0,0 @@
-excludes:
-  - vendor
-languages:
-  english:
-    locale: [US, AU]

data/.spellr_wordlists/english.txt

@@ -1,62 +0,0 @@
-argv
-backports
-baz
-changelog
-codebase
-config
-cov
-cyclomatic
-enoent
-enumerables
-env
-errno
-esque
-excludesfile
-extensionless
-fancyignore
-filesystem
-fnmatch
-frotz
-gemfile
-gitconfig
-github
-gitignore
-gitkeep
-hashbang
-includefile
-janky
-jruby
-klass
-llo
-memoize
-nocov
-noninfringement
-params
-pathspec
-pwd
-rdoc
-regexp
-rspec
-rubo
-rubocop
-rubygems
-rubyish
-rulesets
-rvm
-sherson
-simplecov
-stdin
-subdir
-substring
-sudo
-symlinks
-tmp
-toplevel
-txt
-unrecursive
-upcase
-usr
-webpack
-xconfig
-xdg
-zsh

data/.spellr_wordlists/ruby.txt

@@ -1 +0,0 @@
-rspec

data/.spellr_wordlists/shell.txt

@@ -1,3 +0,0 @@
-env
-euo
-usr

data/.travis.yml

@@ -1,11 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-before_install: gem install bundler
-rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
-  - jruby

data/Gemfile

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
-
-# Specify your gem's dependencies in fast_ignore.gemspec
-
-gemspec

data/Rakefile

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-if RUBY_PLATFORM == 'java'
-  task default: :spec
-else
-  task default: [:spec, :rubocop, :spellr, :leftovers]
-end

data/bin/console

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'fast_ignore'
-
-require 'pry'
-Pry.start

data/bin/ls

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

data/bin/ls_seconds

@@ -1,21 +0,0 @@
-#!/usr/bin/env ruby --disable-all
-# frozen_string_literal: true
-
-require_relative '../lib/fast_ignore'
-
-t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-new_a = FastIgnore.new(relative: true, argv_rules: ARGV).to_a
-t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-puts "new #{new_a.count}: #{t2 - t1}"
-fi = FastIgnore.new(relative: true, argv_rules: ARGV)
-fi.to_a
-t3 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-cached_a = fi.to_a
-t4 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-puts "cached #{cached_a.count}: #{t4 - t3}"
-t5 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-git_a = `git ls-files`.split("\n")
-t6 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-puts "git ls-files #{git_a.count}: #{t6 - t5}"
-
-exit 1 unless new_a.length == cached_a.length && new_a.length == git_a.length

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/bin/time

@@ -1,21 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# use mac terminal not vs code terminal
-# ensure nothing else is watching that dir in the filesystem e.g. webpack
-
-require 'open3'
-require 'shellwords'
-RUNS = 30
-SCRIPT = "time #{__dir__}/ls #{Shellwords.join(ARGV)}"
-
-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/fast_ignore.gemspec

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'fast_ignore/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'fast_ignore'
-  spec.version = FastIgnore::VERSION
-  spec.authors = ['Dana Sherson']
-  spec.email = ['robot@dana.sh']
-
-  spec.summary = 'Parse gitignore files, quickly'
-  spec.homepage = 'https://github.com/robotdana/fast_ignore'
-  spec.license = 'MIT'
-
-  spec.required_ruby_version = '~> 2.4'
-
-  if spec.respond_to?(:metadata)
-    spec.metadata['homepage_uri'] = spec.homepage
-    spec.metadata['source_code_uri'] = 'https://github.com/robotdana/fast_ignore'
-    spec.metadata['changelog_uri'] = 'https://github.com/robotdana/fast_ignore/blob/master/CHANGELOG.md'
-  end
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'bundler', '>= 1.17'
-  spec.add_development_dependency 'leftovers', '>= 0.2.2'
-  spec.add_development_dependency 'pry', '> 0'
-  spec.add_development_dependency 'rake', '>= 12.3.3'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '>= 0.74.0'
-  spec.add_development_dependency 'rubocop-rspec', '~> 1'
-  spec.add_development_dependency 'simplecov', '~> 0.18.5'
-  spec.add_development_dependency 'spellr', '>= 0.8.3'
-end