globby 0.0.1 → 0.0.2

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Jon Jensen
+Copyright (c) 2013 Jon Jensen
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,15 +1,23 @@
 # globby
 
-globby is a [.gitignore](http://www.kernel.org/pub/software/scm/git/docs/gitignore.html)-compatible file globber for ruby
+globby is a [`.gitignore`](http://www.kernel.org/pub/software/scm/git/docs/gitignore.html)-compatible
+file globber for ruby.
+
+## Installation
+
+Put `gem 'globby'` in your Gemfile.
 
 ## Usage
 
-    Globby.new(rules).matches
+    Globby.select(rules) # all files matched by the rules
+    Globby.reject(rules) # all other files
 
 ### An example:
 
      > rules = File.read('.gitignore').split(/\n/)
-     > pp Globby.new(rules).matches
+    -> ["Gemfile.lock", "doc", "*.gem"]
+
+     > pp Globby.select(rules)
     ["Gemfile.lock",
      "doc/Foreigner.html",
      "doc/Foreigner/Adapter.html",
@@ -26,9 +34,24 @@ globby is a [.gitignore](http://www.kernel.org/pub/software/scm/git/docs/gitigno
   with those files.
 * You're writing a library/tool that will have its own list of ignored/tracked
   files. My use case is for an I18n library that extracts strings from ruby
-  files... I need to provide users a nice configurable way to whitelist given
+  files... I need to provide users a nice configurable way to blacklist given
   files/directories/patterns.
 
+## Compatibility Notes
+
+globby is compatible with `.gitignore` rules; it respects negated patterns, and
+ignores comments or empty patterns. That said, it supports some things that may
+or may not work in your version of git. These platform-dependent `.gitignore`
+behaviors are platform independent in globby and can always be used:
+
+ * Recursive wildcards à la ant/zsh/ruby. `**` matches directories recursively.
+ * [glob(7)](https://www.kernel.org/doc/man-pages/online/pages/man7/glob.7.html)-style
+   bracket expressions, i.e. character classes, ranges, complementation, named
+   character classes, collating symbols and equivalence class expressions. Note
+   that the syntax for some of these is slightly different than what you would
+   find in regular expressions. Refer to [the documentation](https://www.kernel.org/doc/man-pages/online/pages/man7/glob.7.html)
+   for more info.
+
 ## License
 
-Copyright (c) 2012 Jon Jensen, released under the MIT license
+Copyright (c) 2013 Jon Jensen, released under the MIT license

data/lib/globby.rb

@@ -1,54 +1,53 @@
 require 'set'
+require '../globby/lib/globby/glob'
 
-class Globby
-  def initialize(patterns = [])
-    @patterns = patterns
-  end
-
-  def matches
-    result = Set.new
-    @patterns.each do |pattern|
-      if pattern[0, 1] == '!'
-        result.subtract matches_for(pattern[1..-1])
-      else
-        result.merge matches_for(pattern)
+module Globby
+  class << self
+    def select(patterns, source = get_files_and_dirs, result = {:files => Set.new, :dirs => Set.new})
+      evaluate_patterns(patterns, source, result)
+  
+      if result[:dirs] && result[:dirs].size > 0
+        # now go merge/subtract files under directories
+        dir_patterns = result[:dirs].map{ |dir| "/#{dir}**" }
+        evaluate_patterns(dir_patterns, {:files => source[:files]}, result)
       end
-    end
-    result.to_a.sort
-  end
-
-  def matches_for(pattern)
-    return [] unless pattern = normalize(pattern)
-    expects_dir = pattern.sub!(/\/\z/, '')
 
-    files = Dir.glob(pattern, File::FNM_PATHNAME)
-    result = []
-    files.each do |file|
-      next if ['.', '..'].include?(File.basename(file))
-      if directory?(file)
-        result.concat matches_for("/" + file + "/**/{*,.*}")
-      elsif !expects_dir
-        result << file
+      result[:files].to_a.sort
+    end
+  
+    def reject(patterns = [])
+      source = get_files_and_dirs
+      (source[:files] - select(patterns, source)).sort
+    end
+  
+   private
+  
+    def evaluate_patterns(patterns, source, result)
+      patterns.each do |pattern|
+        next unless pattern =~ /\A[^#]/
+        evaluate_pattern pattern, source, result
       end
     end
-    result
-  end
 
-  def normalize(pattern)
-    pattern = pattern.strip
-    first = pattern[0, 1]
-    if pattern.empty? || first == '#'
-      nil
-    elsif first == '/'
-      pattern[1..-1] 
-    else
-      "**/" + pattern  # could be anywhere
+    def evaluate_pattern(pattern, source, result)
+      glob = Globby::Glob.new(pattern)
+      method, candidates = glob.inverse? ?
+        [:subtract, result] :
+        [:merge, source]
+  
+      dir_matches = glob.match(candidates[:dirs])
+      file_matches = []
+      file_matches = glob.match(candidates[:files]) unless glob.directory? || glob.exact_match? && !dir_matches.empty?
+      result[:dirs].send method, dir_matches unless dir_matches.empty?
+      result[:files].send method, file_matches unless file_matches.empty?
+    end
+  
+    def get_files_and_dirs
+      files, dirs = Dir.glob('**/*', File::FNM_DOTMATCH).
+        reject { |f| f =~ /(\A|\/)\.\.?\z/ }.
+        partition { |f| File.file?(f) || File.symlink?(f) }
+      dirs.map!{ |d| d + "/" }
+      {:files => files, :dirs => dirs}
     end
-  end
-
- protected
-
-  def directory?(pattern)
-    File.directory?(pattern) && !File.symlink?(pattern)
   end
 end

data/lib/globby/glob.rb

@@ -0,0 +1,89 @@
+module Globby
+  class Glob
+    def initialize(pattern)
+      @inverse = pattern.sub!(/\A!/, '')
+      # remove meaningless wildcards
+      @pattern = pattern.
+        sub(/\A\/?(\*\*\/)+/, '').
+        sub(/(\/\*\*)+\/\*\z/, '/**')
+    end
+
+    def match(files)
+      return [] unless files
+      files.grep(to_regexp)
+    end
+
+    def inverse?
+      @inverse
+    end
+
+    def directory?
+      @pattern =~ /\/\z/
+    end
+
+    def exact_match?
+      @pattern =~ /\A\// && @pattern !~ /[\*\?]/
+    end
+
+    # see https://www.kernel.org/doc/man-pages/online/pages/man7/glob.7.html
+    GLOB_BRACKET_EXPR = /
+      \[ # brackets 
+        !? # (maybe) negation
+        \]? # (maybe) right bracket
+        (?: # one or more:
+          \[[^\/\]]+\] # named character class, collating symbol or equivalence class
+          | [^\/\]] # non-right bracket character (could be part of a range)
+        )+
+      \]/x
+    GLOB_ESCAPED_CHAR = /\\./
+    GLOB_RECURSIVE_WILDCARD = /\/\*\*(?:\/|\z)/
+    GLOB_WILDCARD = /[\?\*]/
+
+    GLOB_TOKENIZER = /(
+      #{GLOB_BRACKET_EXPR} |
+      #{GLOB_ESCAPED_CHAR} |
+      #{GLOB_RECURSIVE_WILDCARD}
+    )/x
+
+    def to_regexp
+      parts = @pattern.split(GLOB_TOKENIZER) - [""]
+  
+      result = parts.first.sub!(/\A\//, '') ? '\A' : '(\A|/)'
+      parts.each do |part|
+        result << part_to_regexp(part)
+      end
+      if result[-1, 1] == '/'
+        result << '\z'
+      elsif result[-2, 2] == '.*'
+        result.slice!(-2, 2)
+      else
+        result << '\/?\z'
+      end
+      Regexp.new result
+    end
+
+   private
+
+    def part_to_regexp(part)
+      case part
+      when GLOB_BRACKET_EXPR
+        # fix negation and escape right bracket
+        part.sub(/\A\[!/, '[^').sub(/\A(\[\^?)\]/, '\1\]')
+      when GLOB_ESCAPED_CHAR
+        part
+      when GLOB_RECURSIVE_WILDCARD
+        part[-1, 1] == '/' ? "/(.+/)?" : "/.*"
+      when GLOB_WILDCARD
+        (part.split(/(#{GLOB_WILDCARD})/) - [""]).inject("") do |result, p|
+          result << case p
+            when '?'; '[^/]'
+            when '*'; '[^/]*'
+            else Regexp.escape(p)
+          end
+        end
+      else # literal path component (maybe with slashes)
+        part
+      end
+    end
+  end
+end

data/spec/gitignore_spec.rb

@@ -0,0 +1,100 @@
+require 'globby'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.configure { |config| config.mock_framework = :mocha }
+
+describe Globby do
+  around do |example|
+    gitignore_test { example.run }
+  end
+
+  describe ".select" do
+    it "should match .gitignore perfectly" do
+      rules = prepare_gitignore
+      Globby.select(rules.split(/\n/)).should == all_files - git_files - untracked
+    end
+  end
+
+  describe ".reject" do
+    it "should match the inverse of .gitignore, plus .git" do
+      rules = prepare_gitignore
+      Globby.reject(rules.split(/\n/)).should == git_files + untracked
+    end
+  end
+
+  def gitignore_test
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        prepare_files
+        `git init .`
+        yield
+      end
+    end
+  end
+
+  def prepare_gitignore
+    ignore = <<-IGNORE.gsub(/^ +/, '')
+      # here we go...
+  
+      # some dotfiles
+      .hidden
+  
+      # html, but just in the root
+      /*.html
+  
+      # all rb files anywhere
+      *.rb
+  
+      # except rb files immediately under foobar
+      !foobar/*.rb
+  
+      # this will match foo/bar but not bar
+      bar/
+  
+      # this will match nothing
+      foo*bar/baz.pdf
+  
+      # this will match baz/ and foobar/baz/
+      baz
+    IGNORE
+    File.open('.gitignore', 'w'){ |f| f.write ignore }
+    ignore
+  end
+
+  def prepare_files
+    files = <<-FILES.strip.split(/\s+/)
+      .gitignore
+      foo.rb
+      foo.html
+      bar
+      baz/lol.txt
+      foo/.hidden
+      foo/bar.rb
+      foo/bar.html
+      foo/bar/baz.pdf
+      foobar/.hidden
+      foobar/baz.txt
+      foobar/baz.rb
+      foobar/baz/lol.wut
+    FILES
+    files.each do |file|
+      FileUtils.mkdir_p File.dirname(file)
+      FileUtils.touch file
+    end
+  end
+
+  def untracked
+    `git status -uall`.gsub(/.*#\n|#\s+|^nothing.*/m, '').split(/\n/)
+  end
+
+  def git_files
+    Dir.glob('.git/**/*', File::FNM_DOTMATCH).
+      select{ |f| File.symlink?(f) || File.file?(f) }.sort
+  end
+
+  def all_files
+    Dir.glob('**/*', File::FNM_DOTMATCH).
+      select{ |f| File.symlink?(f) || File.file?(f) }.sort
+  end
+end

data/spec/globby_spec.rb

@@ -1,157 +1,85 @@
 require 'globby'
-RSpec.configure { |config| config.mock_framework = :mocha }
 
-# A blank line matches no files, so it can serve as a separator for
-# readability.
-# 
-# A line starting with # serves as a comment.
-# 
-# An optional prefix ! which negates the pattern; any matching file excluded by
-# a previous pattern will become included again. If a negated pattern matches,
-# this will override lower precedence patterns sources.
-# 
-# If the pattern ends with a slash, it is removed for the purpose of the 
-# following description, but it would only find a match with a directory. In 
-# other words, foo/ will match a directory foo and paths underneath it, but
-# will not match a regular file or a symbolic link foo (this is consistent with
-# the way how pathspec works in general in git).
-# 
-# If the pattern does not contain a slash /, git treats it as a shell glob 
-# pattern and checks for a match against the pathname relative to the location
-# of the .gitignore file (relative to the toplevel of the work tree if not from
-# a .gitignore file).
-# 
-# Otherwise, git treats the pattern as a shell glob suitable for consumption by 
-# fnmatch(3) with the FNM_PATHNAME flag: wildcards in the pattern will not
-# match a / in the pathname. For example, "Documentation/*.html" matches 
-# "Documentation/git.html" but not "Documentation/ppc/ppc.html" or 
-# "tools/perf/Documentation/perf.html".
-# 
-# A leading slash matches the beginning of the pathname. For example, "/*.c" 
-# matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+RSpec.configure { |config| config.mock_framework = :mocha }
 
 describe Globby do
-  describe "#matches_for" do
-
-    let(:globby) { Globby.new }
-  
+  describe ".select" do
     context "a blank line" do
       it "should return nothing" do
-        Dir.expects(:glob).never
-        globby.matches_for("").should == []
+        files = files("foo")
+        Globby.select([""], files).should == []
       end
     end
 
     context "a comment" do
       it "should return nothing" do
-        Dir.expects(:glob).never
-        globby.matches_for("#comment").should == []
+        files = files("foo")
+        Globby.select(["#"], files).should == []
       end
     end
 
     context "a pattern ending in a slash" do
       it "should return a matching directory's contents" do
-        globby.stubs(:directory?).returns true, false
-        Dir.expects(:glob).twice.returns ["foo"], ['foo/bar']
-        globby.matches_for("foo/").should == ['foo/bar']
+        files = files(%w{foo/bar/baz foo/bar/baz2})
+        Globby.select(%w{bar/}, files).should == %w{foo/bar/baz foo/bar/baz2}
       end
 
       it "should ignore symlinks and regular files" do
-        globby.stubs(:directory?).returns false
-        Dir.expects(:glob).once.returns ["foo"]
-        globby.matches_for("foo/").should == []
+        files = files(%w{foo/bar bar/baz})
+        Globby.select(%w{bar/}, files).should == %w{bar/baz}
       end
     end
 
-    context "a pattern without a slash" do
-      it "should return all glob matches" do
-        Dir.expects(:glob).with{ |*args| args.first == "**/*rb"}.returns []
-        globby.matches_for("*rb")
+    context "a pattern starting in a slash" do
+      it "should return only root glob matches" do
+        files = files(%w{foo/bar bar/foo})
+        Globby.select(%w{/foo}, files).should == %w{foo/bar}
       end
     end
 
-    context "a pattern with a slash" do
-      it "should return all glob matches" do
-        Dir.expects(:glob).with{ |*args| args.first == "**/foo/bar"}.returns []
-        globby.matches_for("foo/bar")
+    context "a pattern with a *" do
+      it "should return matching files" do
+        files = files(%w{foo/bar foo/baz})
+        Globby.select(%w{*z}, files).should == %w{foo/baz}
       end
-    end
 
-    context "a pattern starting in a slash" do
-      it "should return all root glob matches" do
-        Dir.expects(:glob).with{ |*args| args.first == "foo/bar"}.returns []
-        globby.matches_for("/foo/bar")
+      it "should not glob slashes" do
+        files = files(%w{foo/bar foo/baz})
+        Globby.select(%w{foo*bar}, files).should == []
       end
     end
-  end
-
-  describe "#matches" do
-    it "should match gitignore perfectly" do
-      require 'tmpdir'
-      require 'fileutils'
-
-      files = <<-FILES.strip.split(/\s+/)
-        .gitignore
-        foo.rb
-        foo.html
-        bar
-        baz/lol.txt
-        foo/.hidden
-        foo/bar.rb
-        foo/bar.html
-        foo/bar/baz.pdf
-        foobar/.hidden
-        foobar/baz.txt
-        foobar/baz.rb
-        foobar/baz/lol.wut
-      FILES
-
-      ignore = <<-IGNORE.gsub(/^ +/, '')
-        # here we go...
-
-        # some dotfiles
-        .hidden
-
-        # html, but just in the root
-        /*.html
 
-        # all rb files anywhere
-        *.rb
-
-        # except rb files immediately under foobar
-        !foobar/*.rb
-
-        # this will match foo/bar but not bar
-        bar/
-
-        # this will match nothing
-        foo*bar/baz.pdf
-
-        # this will match baz/ and foobar/baz/
-        baz
-      IGNORE
+    context "a pattern with a ?" do
+      it "should return matching files" do
+        files = files(%w{foo/bar foo/baz})
+        Globby.select(%w{b?z}, files).should == %w{foo/baz}
+      end
 
-      Dir.mktmpdir do |dir|
-        Dir.chdir(dir) do
-          File.open('.gitignore', 'w'){ |f| f.write ignore }
-          files.each do |file|
-            FileUtils.mkdir_p File.dirname(file)
-            FileUtils.touch file
-          end
+      it "should not glob slashes" do
+        files = files(%w{foo/bar foo/baz})
+        Globby.select(%w{foo?bar}, files).should == []
+      end
+    end
 
-          `git init .`
-          untracked = `git status -uall`.gsub(/.*#\n|#\s+|^nothing.*/m, '').split(/\n/)
+    context "a pattern with a **" do
+      it "should match directories recursively" do
+        files = files(%w{foo/bar foo/baz foo/c/bar foo/c/c/bar})
+        Globby.select(%w{foo/**/bar}, files).should == %w{foo/bar foo/c/bar foo/c/c/bar}
+      end
+    end
 
-          globby = Globby.new(ignore.split(/\n/))
-          ignored = globby.matches
-          
-          all_files = Dir.glob('**/*', File::FNM_DOTMATCH | File::FNM_PATHNAME).
-            reject{ |f| f =~ /^\.git\// }.
-            select{ |f| File.symlink?(f) || File.file?(f) }
-          
-          all_files.sort.should == (untracked + ignored).sort 
-        end
+    context "a pattern with bracket expressions" do
+      it "should return matching files" do
+        files = files(%w{boo fob f0o foo/bar poo/baz})
+        Globby.select(%w{[e-g][0-9[:alpha:]][!b]}, files).should == %w{f0o foo/bar}
       end
     end
   end
+
+  def files(files)
+    files = Array(files)
+    files.sort!
+    dirs = files.grep(/\//).map { |file| file.sub(/[^\/]+\z/, '') }.uniq.sort
+    {:files => files, :dirs => dirs}
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: globby
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Jon Jensen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-01-16 00:00:00 Z
+date: 2013-01-25 00:00:00 Z
 dependencies: []
 
 description: find files using .gitignore-style globs
@@ -30,7 +30,9 @@ files:
 - LICENSE.txt
 - Rakefile
 - README.md
+- lib/globby/glob.rb
 - lib/globby.rb
+- spec/gitignore_spec.rb
 - spec/globby_spec.rb
 homepage: http://github.com/jenseng/globby
 licenses: []