fast_ignore 0.14.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05f6139deefedc14e0c58acd66909aa25af5240a83e67a6463eacedd6cec9eb3
-  data.tar.gz: c6becf91ea8bc9ccf0524309c5cad1e01485c4e2324222f231ade33855c65528
+  metadata.gz: 88d6249cc842976d1b5c0e984816cfc260cc3edcbe4774ea4580e934bedcf925
+  data.tar.gz: 3ab13efc019bee9b5cadcb45f485021132f07787bce73d66bb9ef63b76bc51ca
 SHA512:
-  metadata.gz: cca040e6401d0c412498dff47b460ba7a19d5c9cb810cc205151a56b9db959a88ea3c4137610537bda43c5520611b1711abc8124b0ab98dd6bda261de9638588
-  data.tar.gz: a3fe257c77f8350c2dde1bcfcde01293b5af87b5d6b627b4e44555b3b6a45154c3d567d1e68f8f03520d21e28e78eda439e92b7a8b5b2d0b43b6f2a23a2f5ae4
+  metadata.gz: 853124ae1ddf1fc599e8a422580ee84ff705907a70c7ece17db72502a4468ca0d5479f918c175f91dc1915c7cccb5ad4cd7eaa956adf2d7b0a5e2fa024821c3d
+  data.tar.gz: b90c827caa6c24c3491237ec5fb538b828b2daea879a4d94d6bc3ac4368807c7040bc0d6ea6405b8e9712483d00fddfb6d43e1a970786f374144a4d6165f59ee

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# v0.16.0
+- Entirely rewrite the way that git config files are read. previously it was just a regexp. now we actually parse git config files according to the same rules as git.
+- Add ruby 3 to the test matrix
+
+# v0.15.2
+- Updated methods with multiple `_` arguments to have different names to make sorbet happy
+
+# v0.15.1
+- Updated dependencies to allow running on ruby 3.0.0.preview1
+
+# v0.15.0
+- fixed a handful of character class edge cases to match git behavior
+  - mostly ranges with - or / as one end of the range
+- major refactoring of the regexp builder that shouldn't have any behaviour implications but should make development easier (e.g. seeing those unhandled edge cases).
+- improved speed of repos with many sub-gitignore files
+- mentioned submodules & sparse checkout in the readme as yet another thing git does that this project doesn't because submodule details are hidden in the git index.
+
 # v0.14.0
 - significant performance improvements ~50% faster
 - add `FastIgnore#to_proc` for no good reason

data/README.md

@@ -1,6 +1,6 @@
 # FastIgnore
 
-[![travis](https://travis-ci.com/robotdana/fast_ignore.svg?branch=master)](https://travis-ci.com/robotdana/fast_ignore)
+[![travis](https://travis-ci.com/robotdana/fast_ignore.svg?branch=main)](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.
@@ -15,7 +15,7 @@ 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 ruby 2.4-3.0.x & 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_rules)/[`include_files:`](#include_files))
@@ -309,11 +309,13 @@ This is not required, and if FastIgnore does have to go to the filesystem for th
   (It does handle changing the current working directory between [`FastIgnore#allowed?`](#allowed) calls)
 - FastIgnore always matches patterns case-insensitively. (git varies by filesystem).
 - FastIgnore always outputs paths as literal UTF-8 characters. (git depends on your core.quotepath setting but by default outputs non ascii paths with octal escapes surrounded by quotes).
-- Because git looks at its own index objects and FastIgnore looks at the file system there may be some differences between FastIgnore and `git ls-files`
+- Because git looks at its own index objects and FastIgnore looks at the file system there may be some differences between FastIgnore and `git ls-files`. To avoid these differences you may want to use the [`git_ls`](https://github.com/robotdana/git_ls) gem instead
   - Tracked files that were committed before the matching ignore rule was committed will be returned by `git ls-files`, but not by FastIgnore.
   - Untracked files will be returned by FastIgnore, but not by `git ls-files`
   - Deleted files whose deletions haven't been committed will be returned by `git ls-files`, but not by FastIgnore
   - On a case insensitive file system, with files that differ only by case, `git ls-files` will include all case variations, while FastIgnore will only include whichever variation git placed in the file system.
+  - FastIgnore is unaware of submodules and just treats them like regular directories. For example: `git ls-files --recurse-submodules` won't use the parent repo's gitignore on a submodule, while FastIgnore doesn't know it's a submodule and will.
+  - FastIgnore will only return the files actually on the file system when using `git sparse-checkout`.
 
 ## Contributing
 

data/lib/fast_ignore/file_root.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class FileRoot
+    # :nocov:
+    using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
+    # :nocov:
+
+    def self.build(file_path, project_root)
+      file_root = "#{::File.dirname(file_path)}/".delete_prefix(project_root)
+
+      new(file_root) unless file_root.empty?
+    end
+
+    def initialize(file_root)
+      @file_root = file_root
+    end
+
+    def shebang_path_pattern
+      @shebang_path_pattern ||= /\A#{escaped}./
+    end
+
+    def escaped
+      @escaped ||= ::Regexp.escape(@file_root)
+    end
+
+    def escaped_segments
+      @escaped_segments ||= escaped.split('/')
+    end
+
+    def escaped_segments_length
+      @escaped_segments_length ||= escaped_segments.length
+    end
+
+    def escaped_segments_joined
+      @escaped_segments_joined ||= escaped_segments.join('(?:/') + '(?:/'
+    end
+  end
+end

data/lib/fast_ignore/gitconfig_parser.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'strscan'
+class FastIgnore
+  class GitconfigParseError < FastIgnore::Error; end
+
+  class GitconfigParser # rubocop:disable Metrics/ClassLength
+    def self.parse(file, root: Dir.pwd, nesting: 1)
+      new(file, root: root, nesting: nesting).parse
+    end
+
+    def initialize(path, root: Dir.pwd, nesting: 1)
+      @path = path
+      @root = root
+      @nesting = nesting
+    end
+
+    def parse
+      raise ::FastIgnore::GitconfigParseError if nesting >= 10
+
+      read_file(path)
+      return unless value
+
+      value
+    end
+
+    private
+
+    attr_reader :nesting
+    attr_reader :path
+    attr_reader :root
+    attr_accessor :value
+    attr_accessor :within_quotes
+    attr_accessor :section
+
+    def read_file(path) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      return unless ::File.readable?(path)
+
+      file = StringScanner.new(::File.read(path))
+
+      until file.eos?
+        if file.skip(/(\s+|[#;].*\n)/)
+          # skip
+        elsif file.skip(/\[core\]/i)
+          self.section = :core
+        elsif file.skip(/\[include\]/i)
+          self.section = :include
+        elsif file.skip(/\[(?i:includeif) +"/)
+          self.section = include_if(file) ? :include : :not_include
+        elsif file.skip(/\[[\w.]+( "([^\0\\"]|\\(\\{2})*"|\\{2}*)+")?\]/)
+          self.section = :other
+        elsif section == :core && file.skip(/excludesfile\s*=(\s|\\\n)*/i)
+          self.value = scan_value(file)
+        elsif section == :include && file.skip(/path\s*=(\s|\\\n)*/)
+          include_path = scan_value(file)
+
+          value = ::FastIgnore::GitconfigParser.parse(
+            ::File.expand_path(include_path, ::File.dirname(path)),
+            root: root,
+            nesting: nesting + 1
+          )
+          self.value = value if value
+          self.section = :include
+        elsif file.skip(/[a-zA-Z0-9]\w*\s*([#;].*)?\n/)
+          nil
+        elsif file.skip(/[a-zA-Z0-9]\w*\s*=(\s|\\\n)*/)
+          skip_value(file)
+        else
+          raise ::FastIgnore::GitconfigParseError
+        end
+      end
+    end
+
+    def scan_condition_value(file)
+      if file.scan(/([^\0\\\n"]|\\(\\{2})*"|\\{2}*)+(?="\])/)
+        value = file.matched
+        file.skip(/"\]/)
+        value
+      else
+        raise ::FastIgnore::GitconfigParseError
+      end
+    end
+
+    def skip_condition_value(file)
+      raise ::FastIgnore::GitconfigParseError unless file.skip(/([^\0\\\n"]|\\(\\{2})*"|\\{2}*)+"\]/)
+    end
+
+    def include_if(file)
+      if file.skip(/onbranch:/)
+        on_branch?(scan_condition_value(file))
+      elsif file.skip(/gitdir:/)
+        gitdir?(scan_condition_value(file), path: path)
+      elsif file.skip(%r{gitdir/i:})
+        gitdir?(scan_condition_value(file), case_insensitive: true, path: path)
+      else
+        skip_condition_value(file)
+        false
+      end
+    end
+
+    def on_branch?(branch_pattern)
+      branch_pattern += '**' if branch_pattern.end_with?('/')
+      current_branch = ::File.readable?("#{root}/.git/HEAD") && ::File.read("#{root}/.git/HEAD").sub!(
+        %r{\Aref: refs/heads/}, ''
+      )
+      return unless current_branch
+
+      # goddamit git what does 'a pattern with standard globbing wildcards' mean
+      ::File.fnmatch(branch_pattern, current_branch, ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH)
+    end
+
+    def gitdir?(gitdir, path:, case_insensitive: false)
+      gitdir += '**' if gitdir.end_with?('/')
+      gitdir.sub!(%r{\A~/}, ENV['HOME'] + '/')
+      gitdir.sub!(/\A\./, path + '/')
+      gitdir = "**/#{gitdir}" unless gitdir.start_with?('/')
+      options = ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH
+      options |= ::File::FNM_CASEFOLD if case_insensitive
+      ::File.fnmatch(gitdir, ::File.join(root, '.git'), options)
+    end
+
+    def scan_value(file) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      value = +''
+      until file.eos?
+        if file.skip(/\\\n/)
+          # continue
+        elsif file.skip(/\\\\/)
+          value << '\\'
+        elsif file.skip(/\\n/)
+          value << "\n"
+        elsif file.skip(/\\t/)
+          value << "\t"
+        elsif file.skip(/\\b/)
+          value.chop!
+        elsif file.skip(/\\"/)
+          value << '"'
+        elsif file.skip(/\\/)
+          raise ::FastIgnore::GitconfigParseError
+        elsif within_quotes
+          if file.skip(/"/)
+            self.within_quotes = false
+          elsif file.scan(/[^"\\\n]+/)
+            value << file.matched
+          elsif file.skip(/\n/)
+            raise ::FastIgnore::GitconfigParseError
+          # :nocov:
+          else
+            raise "Unmatched #{file.rest}"
+            # :nocov:
+          end
+        elsif file.skip(/"/)
+          self.within_quotes = true
+        elsif file.scan(/[^;#"\s\\]+/)
+          value << file.matched
+        elsif file.skip(/\s*[;#\n]/)
+          break
+        elsif file.scan(/\s+/) # rubocop:disable Lint/DuplicateBranch
+          value << file.matched
+        # :nocov:
+        else
+          raise "Unmatched #{file.rest}"
+          # :nocov:
+        end
+      end
+
+      raise ::FastIgnore::GitconfigParseError if within_quotes
+
+      value
+    end
+
+    def skip_value(file) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      until file.eos?
+        if file.skip(/\\(?:\n|\\|n|t|b|")/)
+          nil
+        elsif file.skip(/\\/)
+          raise ::FastIgnore::GitconfigParseError
+        elsif within_quotes
+          if file.skip(/"/)
+            self.within_quotes = false
+          elsif file.skip(/[^"\\\n]+/)
+            nil
+          elsif file.scan(/\n/)
+            raise ::FastIgnore::GitconfigParseError
+          # :nocov:
+          else
+            raise "Unmatched #{file.rest}"
+            # :nocov:
+          end
+        elsif file.skip(/"/)
+          self.within_quotes = true
+        elsif file.skip(/[^;#"\s\\]+/) # rubocop:disable Lint/DuplicateBranch
+          nil
+        elsif file.skip(/\s*[;#\n]/)
+          break
+        elsif file.skip(/\s+/) # rubocop:disable Lint/DuplicateBranch
+          nil
+        # :nocov:
+        else
+          raise "Unmatched #{file.rest}"
+          # :nocov:
+        end
+      end
+
+      raise ::FastIgnore::GitconfigParseError if within_quotes
+    end
+  end
+end

data/lib/fast_ignore/gitignore_include_rule_builder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+class FastIgnore
+  class GitignoreIncludeRuleBuilder < GitignoreRuleBuilder
+    # :nocov:
+    using ::FastIgnore::Backports::DeletePrefixSuffix if defined?(::FastIgnore::Backports::DeletePrefixSuffix)
+    # :nocov:
+
+    def initialize(rule, file_path, expand_path_from = nil)
+      super(rule, file_path)
+
+      @parent_segments = []
+      @negation = true
+      @expand_path_from = expand_path_from
+    end
+
+    def expand_rule_path
+      anchored! unless @s.match?(/\*/)
+      return unless @s.match?(%r{(?:[~/]|\.{1,2}/|.*/\.\./)})
+
+      dir_only! if @s.match?(%r{.*/\s*\z})
+      @s.string.replace(::File.expand_path(@s.rest))
+      @s.string.delete_prefix!(@expand_path_from)
+      @s.pos = 0
+    end
+
+    def negated!
+      @negation = false
+    end
+
+    def unmatchable_rule!
+      throw :abort_build, ::FastIgnore::UnmatchableRule
+    end
+
+    def nothing_emitted?
+      @re.empty? && @parent_segments.empty?
+    end
+
+    def emit_dir
+      anchored!
+
+      @parent_segments << @re
+      @re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+    end
+
+    def emit_end
+      @dir_only || @re.append_end_dir_or_anchor
+      break!
+    end
+
+    def parent_dir_re # rubocop:disable Metrics/MethodLength
+      segment_joins_count = @parent_segments.length
+      parent_prefix = if @file_path
+        segment_joins_count += @file_path.escaped_segments_length
+
+        if @anchored
+          "\\A#{@file_path.escaped_segments_joined}"
+        else
+          "\\A#{@file_path.escaped_segments_joined}(?:.*/)?"
+        end
+      else
+        prefix
+      end
+
+      out = parent_prefix.dup
+      unless @parent_segments.empty?
+        out << '(?:'
+        out << @parent_segments.join('/(?:')
+        out << '/'
+      end
+      out << (')?' * segment_joins_count)
+      out
+    end
+
+    def build_parent_dir_rule
+      # Regexp::IGNORECASE = 1
+      ::FastIgnore::Rule.new(::Regexp.new(parent_dir_re, 1), true, anchored_or_file_path, true)
+    end
+
+    def build_child_file_rule
+      # Regexp::IGNORECASE = 1
+      ::FastIgnore::Rule.new(@re.append_dir.to_regexp, @negation, anchored_or_file_path, false)
+    end
+
+    def build_rule
+      joined_re = ::FastIgnore::GitignoreRuleRegexpBuilder.new
+      joined_re.append(@parent_segments.join('/'))
+      joined_re.append_dir unless @parent_segments.empty?
+      joined_re.append(@re)
+      @re = joined_re
+
+      rules = [super, build_parent_dir_rule]
+      (rules << build_child_file_rule) if @dir_only
+      rules
+    end
+
+    def process_rule
+      expand_rule_path if @expand_path_from
+      super
+    end
+  end
+end