pathspec 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0eb87d15ea86cb98dce7e2ca41f6939418c3b57
-  data.tar.gz: 084dc186f9fbf2f8c4a7ed8268cfa1c78e296728
+  metadata.gz: 3241bfa1371172a86936a49ce7f977ab8c8d9edb
+  data.tar.gz: 9c1e2d50895f2c65943e2158b63e818b80c8d2e3
 SHA512:
-  metadata.gz: 17ccc33fba7022b67fe0da1f9c02fbb6bd4e2d6d8e40fcb0d8ed0420f9733ace1692de35e69151e948b788cf007d7ea49f8c1760809ab02b672e61af16aac9e0
-  data.tar.gz: a1d2fa238ea0fbc47083c25a4372a6d55848e200b1b850701e63ef12a191c06141b00f0a1871c14b46fe3e8366dcf1dfcf3b588a99f81b2d48117fbefe6eadd5
+  metadata.gz: 66082a9cf1cd342c1e636c5243e424c6649418193ce34fe65b1e1b8e62c9f241c289baf3c5a0c48cc3b870bbb7650540e833fd0400454537f8ec1c9f76ba5f8d
+  data.tar.gz: 6fbca7071256e9024293d6e0ed69eed42bb7118cc95e80d8f359a81e32e3d6cbf7e520270ad7ca94127936ec7c925efddfcba0ce3b3224a7c2f32bbeb459d0f9

data/CHANGELOG.md

@@ -1 +1,15 @@
-0.0.1: Initial version.
+# pathspec-ruby CHANGELOG
+
+## 0.1.0
+- Port new edgecase handling from [python-path-specification](https://github.com/cpburnz/python-path-specification/pull/8). Many thanks to @jdpace! :)
+- Removed EOL Ruby support
+- Added current Ruby stable to Travis testing
+
+## 0.0.2
+- Fixed issues with Ruby 1.8.7/2.1.1
+- Added more testing scripts
+- Fixed Windows path related issues
+- Cleanup unnecessary things in gem
+
+## 0.0.1
+- Initial version.

data/README.md

@@ -1,14 +1,19 @@
 pathspec-ruby
 =============
 
+[![Build Status](https://travis-ci.org/highb/pathspec-ruby.svg?branch=master)](https://travis-ci.org/highb/pathspec-ruby) [![codecov](https://codecov.io/gh/highb/pathspec-ruby/branch/master/graph/badge.svg)](https://codecov.io/gh/highb/pathspec-ruby)
+
+Supported Rubies:
+- 2.2.7 (Maintenance)
+- 2.3.4 (Stable)
+- 2.4.1 (Stable)
+
 Match Path Specifications, such as .gitignore, in Ruby!
 
 Follows .gitignore syntax defined on [gitscm](http://git-scm.com/docs/gitignore)
 
 .gitignore functionality ported from [Python pathspec](https://pypi.python.org/pypi/pathspec/0.2.2) by [@cpburnz](https://github.com/cpburnz/python-path-specification)
 
-[Travis Status](https://travis-ci.org/highb/pathspec-ruby) ![Travis CI Status](https://travis-ci.org/highb/pathspec-ruby.svg?branch=master)
-
 ## Build/Install from Rubygems
 ```shell
 gem install pathspec

data/lib/pathspec/gitignorespec.rb

@@ -27,6 +27,12 @@ class GitIgnoreSpec < RegexSpec
       @regex = nil
       @inclusive = nil
 
+    # EDGE CASE: According to git check-ignore (v2.4.1)), a single '/'
+    # does not match any file
+    elsif pattern == '/'
+      @regex = nil
+      @inclusive = nil
+
     # We have a valid pattern!
     else
       # A pattern starting with an exclamation mark ('!') negates the
@@ -58,12 +64,15 @@ class GitIgnoreSpec < RegexSpec
       # to root.
       if pattern_segs[0].empty?
         pattern_segs.shift
-      else
+      elsif pattern_segs.length == 1 ||
+        pattern_segs.length == 2 && pattern_segs[-1].empty?
         # A pattern without a beginning slash ('/') will match any
         # descendant path. This is equivilent to "**/{pattern}". So,
         # prepend with double-asterisks to make pattern relative to
         # root.
-        if pattern_segs.length == 1 && pattern_segs[0] != '**'
+        # EDGE CASE: This also holds for a single pattern with a
+        # trailing slash (e.g. dir/).
+        if pattern_segs[0] != '**'
           pattern_segs.insert(0, '**')
         end
       end
@@ -72,7 +81,7 @@ class GitIgnoreSpec < RegexSpec
       # paths of if it is a directory but not if it is a regular file.
       # This is equivilent to "{pattern}/**". So, set last segment to
       # double asterisks to include all descendants.
-      if pattern_segs[-1].empty?
+      if pattern_segs[-1].empty? && pattern_segs.length > 1
         pattern_segs[-1] = '**'
       end
 
@@ -131,6 +140,16 @@ class GitIgnoreSpec < RegexSpec
           end
 
           regex.concat(translate_segment_glob(seg))
+
+          if i == regex_end && @inclusive
+            # A pattern ending without a slash ('/') will match a file
+            # or a directory (with paths underneath it).
+            # e.g. foo matches: foo, foo/bar, foo/bar/baz, etc.
+            # EDGE CASE: However, this does not hold for exclusion cases
+            # according to `git check-ignore` (v2.4.1).
+            regex.concat("(?:#{path_sep}.*)?")
+          end
+
           need_slash = true
         end
       end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+begin
+  require 'simplecov'
+  SimpleCov.start
+
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+rescue
+  puts 'SimpleCov failed to start, most likely this due to running Ruby 1.8.7'
+end

data/spec/unit/pathspec/gitignorespec_spec.rb

@@ -0,0 +1,305 @@
+require 'spec_helper'
+require 'pathspec/gitignorespec'
+
+describe GitIgnoreSpec do
+  # Original specification by http://git-scm.com/docs/gitignore
+
+  # A blank line matches no files, so it can serve as a separator for
+  # readability.
+  describe 'does nothing for newlines' do
+    subject { GitIgnoreSpec.new "\n" }
+    it { is_expected.to_not match('foo.tmp') }
+    it { is_expected.to_not match(' ') }
+    it { is_expected.to_not be_inclusive }
+  end
+
+  describe 'does nothing for blank strings' do
+    subject { GitIgnoreSpec.new '' }
+    it { is_expected.to_not match 'foo.tmp' }
+    it { is_expected.to_not match ' ' }
+    it { is_expected.to_not be_inclusive }
+  end
+
+  # A line starting with # serves as a comment. Put a backslash ("\") in front
+  # of the first hash for patterns that begin with a hash.
+  describe 'does nothing for comments' do
+    subject { GitIgnoreSpec.new '# this is a gitignore style comment' }
+    it { is_expected.to_not match('foo.tmp') }
+    it { is_expected.to_not match(' ') }
+    it { is_expected.to_not be_inclusive }
+  end
+
+  describe 'ignores comment char with a slash' do
+    subject { GitIgnoreSpec.new '\#averystrangefile' }
+    it { is_expected.to match('#averystrangefile') }
+    it { is_expected.to_not match('foobar') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'escapes characters with slashes' do
+    subject { GitIgnoreSpec.new 'twinkletwinkle\*' }
+    it { is_expected.to match('twinkletwinkle*') }
+    it { is_expected.to_not match('twinkletwinkletwinkle') }
+    it { is_expected.to be_inclusive }
+  end
+
+  # Trailing spaces are ignored unless they are quoted with backlash ("\").
+  describe 'ignores trailing spaces' do
+    subject { GitIgnoreSpec.new 'foo        ' }
+    it { is_expected.to match('foo') }
+    it { is_expected.to_not match('foo        ') }
+    it { is_expected.to be_inclusive }
+  end
+
+  # This is not handled properly yet
+  describe 'does not ignore escaped trailing spaces'
+
+  # An optional prefix "!" which negates the pattern; any matching file excluded
+  # by a previous pattern will become included again. It is not possible to
+  # re-include a file if a parent directory of that file is excluded. Git
+  # doesn't list excluded directories for performance reasons, so any patterns
+  # on contained files have no effect, no matter where they are defined. Put a
+  # backslash ("\") in front of the first "!" for patterns that begin with a
+  # literal "!", for example, "\!important!.txt".
+  describe 'is exclusive of !' do
+    subject { GitIgnoreSpec.new '!important.txt' }
+    it { is_expected.to match('important.txt') }
+    it { is_expected.to_not be_inclusive }
+    it { is_expected.to_not match('!important.txt') }
+  end
+
+  # 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).
+  describe 'trailing slashes match directories and their contents but not regular files or symlinks' do
+    subject { GitIgnoreSpec.new 'foo/' }
+    it { is_expected.to match('foo/') }
+    it { is_expected.to match('foo/bar') }
+    it { is_expected.to match('baz/foo/bar') }
+    it { is_expected.to_not match('foo') }
+    it { is_expected.to be_inclusive }
+  end
+
+  # 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).
+  describe 'handles basic globbing' do
+    subject { GitIgnoreSpec.new '*.tmp' }
+    it { is_expected.to match('foo.tmp') }
+    it { is_expected.to match('foo/bar.tmp') }
+    it { is_expected.to match('foo/bar.tmp/baz') }
+    it { is_expected.to_not match('foo.rb') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles inner globs' do
+    subject { GitIgnoreSpec.new 'foo-*-bar' }
+    it { is_expected.to match('foo--bar') }
+    it { is_expected.to match('foo-hello-bar') }
+    it { is_expected.to match('a/foo-hello-bar') }
+    it { is_expected.to match('foo-hello-bar/b') }
+    it { is_expected.to match('a/foo-hello-bar/b') }
+    it { is_expected.to_not match('foo.tmp') }
+  end
+
+  describe 'handles postfix globs' do
+    subject { GitIgnoreSpec.new '~temp-*' }
+    it { is_expected.to match('~temp-') }
+    it { is_expected.to match('~temp-foo') }
+    it { is_expected.to match('foo/~temp-bar') }
+    it { is_expected.to match('foo/~temp-bar/baz') }
+    it { is_expected.to_not match('~temp') }
+  end
+
+  describe 'handles multiple globs' do
+    subject { GitIgnoreSpec.new '*.middle.*' }
+    it { is_expected.to match('hello.middle.rb') }
+    it { is_expected.to_not match('foo.rb') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles dir globs' do
+    subject { GitIgnoreSpec.new 'dir/*' }
+    it { is_expected.to match('dir/foo') }
+    it { is_expected.to_not match('foo/') }
+    it { is_expected.to be_inclusive }
+  end
+
+  # 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".
+  describe 'handles dir globs' do
+    subject { GitIgnoreSpec.new 'dir/*' }
+    it { is_expected.to match('dir/foo') }
+    it { is_expected.to_not match('foo/') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles globs inside of dirs' do
+    subject { GitIgnoreSpec.new 'Documentation/*.html' }
+    it { is_expected.to match('Documentation/git.html') }
+    it { is_expected.to_not match('Documentation/ppc/ppc.html') }
+    it { is_expected.to_not match('tools/perf/Documentation/perf.html') } # TODO: Or is it? Git 2 weirdness?
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles wildcards' do
+    subject { GitIgnoreSpec.new 'jokeris????' }
+    it { is_expected.to match('jokeriswild') }
+    it { is_expected.to_not match('jokerisfat') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles brackets' do
+    subject { GitIgnoreSpec.new '*[eu][xl]*' }
+    it { is_expected.to match('youknowregex') }
+    it { is_expected.to match('youknowregularexpressions') }
+    it { is_expected.to_not match('youknownothing') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles unmatched brackets' do
+    subject { GitIgnoreSpec.new '*[*[*' }
+    it { is_expected.to match('bracket[oh[wow') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles brackets with carats' do
+    subject { GitIgnoreSpec.new '*[^]' }
+    it { is_expected.to match('myfavorite^') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles brackets for brackets' do
+    subject { GitIgnoreSpec.new '*[]]' }
+    it { is_expected.to match('yodawg[]]') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles brackets with escaped characters' do
+    # subject { GitIgnoreSpec.new 'back[\\]slash' }
+    # it { is_expected.to match('back\\slash') }
+    # it { is_expected.to_not match('back\\\\slash') }
+    # it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles negated brackets' do
+    subject { GitIgnoreSpec.new 'ab[!cd]ef' }
+    it { is_expected.to_not match('abcef') }
+    it { is_expected.to match('abzef') }
+    it { is_expected.to be_inclusive }
+  end
+
+  # A leading slash matches the beginning of the pathname. For example, "/*.c"
+  # matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+  describe 'handles leading / as relative to base directory' do
+    subject { GitIgnoreSpec.new '/*.c' }
+    it { is_expected.to match('cat-file.c') }
+    it { is_expected.to_not match('mozilla-sha1/sha1.c') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles simple single paths' do
+    subject { GitIgnoreSpec.new 'spam' }
+    it { is_expected.to match('spam') }
+    it { is_expected.to match('spam/') }
+    it { is_expected.to match('foo/spam') }
+    it { is_expected.to match('spam/foo') }
+    it { is_expected.to match('foo/spam/bar') }
+    it { is_expected.to_not match('foo') }
+  end
+
+  # Two consecutive asterisks ("**") in patterns matched against full pathname
+  # may have special meaning:
+
+  # A leading "**" followed by a slash means match in all directories. For
+  # example, "**/foo" matches file or directory "foo" anywhere, the same as
+  # pattern "foo". "**/foo/bar" matches file or directory "bar" anywhere that is
+  # directly under directory "foo".
+  describe 'handles prefixed ** as searching any location' do
+    subject { GitIgnoreSpec.new '**/foo' }
+    it { is_expected.to match('foo') }
+    it { is_expected.to match('bar/foo') }
+    it { is_expected.to match('baz/bar/foo') }
+    it { is_expected.to_not match('baz/bar/foo.rb') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'handles prefixed ** with a directory as searching a file under a directory in any location' do
+    subject { GitIgnoreSpec.new '**/foo/bar' }
+    it { is_expected.to_not match('foo') }
+    it { is_expected.to match('foo/bar') }
+    it { is_expected.to match('baz/foo/bar') }
+    it { is_expected.to match('baz/foo/bar/sub') }
+    it { is_expected.to_not match('baz/foo/bar.rb') }
+    it { is_expected.to_not match('baz/bananafoo/bar') }
+    it { is_expected.to be_inclusive }
+  end
+
+  # A trailing "/**" matches everything inside. For example, "abc/**" matches
+  # all files inside directory "abc", relative to the location of the .gitignore
+  # file, with infinite depth.
+  describe 'handles leading /** as all files inside a directory' do
+    subject { GitIgnoreSpec.new 'abc/**' }
+    it { is_expected.to match('abc/') }
+    it { is_expected.to match('abc/def') }
+    it { is_expected.to_not match('123/abc/def') }
+    it { is_expected.to_not match('123/456/abc/') }
+    it { is_expected.to be_inclusive }
+  end
+
+  # A slash followed by two consecutive asterisks then a slash matches zero or
+  # more directories. For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b"
+  # and so on.
+  describe 'handles /** in the middle of a path' do
+    subject { GitIgnoreSpec.new 'a/**/b' }
+    it { is_expected.to match('a/b') }
+    it { is_expected.to match('a/x/b') }
+    it { is_expected.to match('a/x/y/b') }
+    it { is_expected.to_not match('123/a/b') }
+    it { is_expected.to_not match('123/a/x/b') }
+    it { is_expected.to be_inclusive }
+  end
+
+  describe 'matches all paths when given **' do
+    subject { GitIgnoreSpec.new '**' }
+
+    it { is_expected.to match('a/b') }
+    it { is_expected.to match('a/x/b') }
+    it { is_expected.to match('a/x/y/b') }
+    it { is_expected.to match('123/a/b') }
+    it { is_expected.to match('123/a/x/b') }
+  end
+
+  # Other consecutive asterisks are considered invalid.
+  describe 'considers other consecutive asterisks invalid' do
+    subject { GitIgnoreSpec.new 'a/***/b' }
+    it { is_expected.to_not match('a/b') }
+    it { is_expected.to_not match('a/x/b') }
+    it { is_expected.to_not match('a/x/y/b') }
+    it { is_expected.to_not match('123/a/b') }
+    it { is_expected.to_not match('123/a/x/b') }
+    it { is_expected.to_not be_inclusive }
+  end
+
+  describe 'does not match single absolute paths' do
+    subject { GitIgnoreSpec.new "/" }
+    it { is_expected.to_not match('foo.tmp') }
+    it { is_expected.to_not match(' ') }
+    it { is_expected.to_not match('a/b') }
+  end
+
+  describe 'nested paths are relative to the file' do
+    subject { GitIgnoreSpec.new 'foo/spam' }
+    it { is_expected.to match('foo/spam') }
+    it { is_expected.to match('foo/spam/bar') }
+    it { is_expected.to_not match('bar/foo/spam') }
+  end
+
+
+end

data/spec/unit/pathspec/spec_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'pathspec/spec'
+
+describe Spec do
+  subject { Spec.new }
+
+  it "does not allow matching" do
+    expect { subject.match "anything" }.to raise_error
+  end
+
+  it { is_expected.to be_inclusive  }
+end

data/spec/unit/pathspec_spec.rb

@@ -0,0 +1,322 @@
+require 'spec_helper'
+require 'fakefs/safe'
+require 'pathspec'
+require 'fakefs/spec_helpers'
+
+describe PathSpec do
+  shared_examples "standard gitignore negation" do
+    it { is_expected.to_not match('important.txt') }
+    it { is_expected.to_not match('foo/important.txt') }
+    it { is_expected.to match('foo/bar/') }
+  end
+
+  context "initialization" do
+    context "from multilines" do
+      context "#new" do
+        subject { PathSpec.new <<-IGNORELINES
+!important.txt
+foo/**
+/bar/baz
+IGNORELINES
+        }
+
+        it_behaves_like "standard gitignore negation"
+      end
+    end
+
+    context "from a string with no newlines" do
+      let(:str) { "foo/**" }
+
+      context "#new" do
+        subject { PathSpec.new str }
+
+        it { is_expected.to match('foo/important.txt') }
+        it { is_expected.to match('foo/bar/') }
+      end
+    end
+
+    context "from a non-string/non-enumerable" do
+      it "throws an exception" do
+        expect { PathSpec.new Object.new }.to raise_error
+      end
+    end
+
+    context "from array of gitignore strings" do
+      let(:arr) { ["!important.txt", "foo/**", "/bar/baz"] }
+
+      context "#new" do
+        subject { PathSpec.new arr }
+
+        it_behaves_like "standard gitignore negation"
+      end
+
+      context "#from_lines" do
+        subject {
+          PathSpec.from_lines(arr)
+        }
+
+        it_behaves_like "standard gitignore negation"
+      end
+
+      context "#add array" do
+        subject {
+          ps = PathSpec.new []
+          ps.add arr
+        }
+
+        it_behaves_like "standard gitignore negation"
+      end
+    end
+
+    context "from linedelimited gitignore string" do
+      let(:line) { "!important.txt\nfoo/**\n/bar/baz\n" }
+
+      context "#new" do
+        subject { PathSpec.new line }
+
+        it_behaves_like "standard gitignore negation"
+      end
+
+      context "#from_lines" do
+        subject {
+          PathSpec.from_lines(line)
+        }
+
+        it_behaves_like "standard gitignore negation"
+      end
+
+      context "#add" do
+        subject {
+          ps = PathSpec.new
+          ps.add line
+        }
+
+        it_behaves_like "standard gitignore negation"
+      end
+    end
+
+    context "from a gitignore file" do
+      include FakeFS::SpecHelpers
+
+      let(:filename) { '.gitignore' }
+      before(:each) do
+        file = File.open(filename, 'w') { |f|
+          f << "!important.txt\n"
+          f << "foo/**\n"
+          f << "/bar/baz\n"
+        }
+      end
+
+      context "#new" do
+        subject {
+          PathSpec.new File.open(filename, 'r')
+        }
+
+        it_behaves_like "standard gitignore negation"
+      end
+
+      context "#from_filename" do
+        subject {
+          PathSpec.from_filename(filename)
+        }
+
+        it_behaves_like "standard gitignore negation"
+      end
+    end
+
+    context "from multiple gitignore files" do
+      include FakeFS::SpecHelpers
+
+      let(:filenames) { ['.gitignore', '.otherignore'] }
+      before(:each) do
+        file = File.open('.gitignore', 'w') { |f|
+          f << "!important.txt\n"
+          f << "foo/**\n"
+          f << "/bar/baz\n"
+        }
+
+        file = File.open('.otherignore', 'w') { |f|
+          f << "ban*na\n"
+          f << "!banana\n"
+        }
+      end
+
+      context "#new" do
+        subject {
+          arr = filenames.collect { |f| File.open(f, 'r') }
+          PathSpec.new arr
+        }
+
+        it_behaves_like "standard gitignore negation"
+
+        it { is_expected.to_not match('banana') }
+        it { is_expected.to match('banananananana') }
+      end
+
+      context "#add" do
+        subject {
+          arr = filenames.collect { |f| File.open(f, 'r') }
+          ps = PathSpec.new
+          ps.add arr
+        }
+
+        it_behaves_like "standard gitignore negation"
+
+        it { is_expected.to_not match('banana') }
+        it { is_expected.to match('banananananana') }
+      end
+    end
+  end
+
+  context "#match_tree" do
+    include FakeFS::SpecHelpers
+
+    context "unix" do
+      let(:root) {'/tmp/project'}
+      let(:gitignore) { <<-GITIGNORE
+  !**/important.txt
+  abc/**
+  GITIGNORE
+      }
+
+      before(:each) {
+        FileUtils.mkdir_p root
+        FileUtils.mkdir_p "#{root}/abc"
+        FileUtils.touch "#{root}/abc/1"
+        FileUtils.touch "#{root}/abc/2"
+        FileUtils.touch "#{root}/abc/important.txt"
+      }
+
+      subject {
+        PathSpec.new(gitignore).match_tree(root)
+      }
+
+      it { is_expected.to include "#{root}/abc".to_s }
+      it { is_expected.to include "#{root}/abc/1".to_s }
+      it { is_expected.not_to include "#{root}/abc/important.txt".to_s }
+      it { is_expected.not_to include "#{root}".to_s }
+    end
+
+    context "windows" do
+      let(:root) {'C:/project'}
+      let(:gitignore) { <<-GITIGNORE
+  !**/important.txt
+  abc/**
+  GITIGNORE
+      }
+
+      before(:each) {
+        FileUtils.mkdir_p root
+        FileUtils.mkdir_p "#{root}/abc"
+        FileUtils.touch "#{root}/abc/1"
+        FileUtils.touch "#{root}/abc/2"
+        FileUtils.touch "#{root}/abc/important.txt"
+      }
+
+      subject {
+        PathSpec.new(gitignore).match_tree(root)
+      }
+
+      it { is_expected.to include "#{root}/abc".to_s }
+      it { is_expected.to include "#{root}/abc/1".to_s }
+      it { is_expected.not_to include "#{root}/abc/important.txt".to_s }
+      it { is_expected.not_to include "#{root}".to_s }
+    end
+  end
+
+  context "#match_paths" do
+    let(:gitignore) { <<-GITIGNORE
+!**/important.txt
+/abc/**
+GITIGNORE
+    }
+
+    context "with no root arg" do
+      subject { PathSpec.new(gitignore).match_paths(['/abc/important.txt', '/abc/', '/abc/1']) }
+
+      it { is_expected.to include "/abc/" }
+      it { is_expected.to include "/abc/1" }
+      it { is_expected.not_to include "/abc/important.txt" }
+    end
+
+    context 'relative to non-root dir' do
+      subject { PathSpec.new(gitignore).match_paths([
+        '/def/abc/important.txt',
+        '/def/abc/',
+        '/def/abc/1'], '/def') }
+
+      it { is_expected.to include "/def/abc/" }
+      it { is_expected.to include "/def/abc/1" }
+      it { is_expected.not_to include "/def/abc/important.txt" }
+    end
+
+    context 'relative to windows drive letter' do
+      subject { PathSpec.new(gitignore).match_paths([
+        'C:/def/abc/important.txt',
+        'C:/def/abc/',
+        'C:/def/abc/1'], 'C:/def/') }
+
+      it { is_expected.to include "C:/def/abc/" }
+      it { is_expected.to include "C:/def/abc/1" }
+      it { is_expected.not_to include "C:/def/abc/important.txt" }
+    end
+  end
+
+  # Example to exclude everything except a specific directory foo/bar (note
+  # the /* - without the slash, the wildcard would also exclude everything
+  # within foo/bar): (from git-scm.com)
+  context "very specific gitignore" do
+    let(:gitignore) { <<-GITIGNORE
+# exclude everything except directory foo/bar
+/*
+!/foo
+/foo/*
+!/foo/bar
+GITIGNORE
+    }
+
+    subject { PathSpec.new(gitignore) }
+
+    it { is_expected.not_to match("foo/bar") }
+    it { is_expected.to match("anything") }
+    it { is_expected.to match("foo/otherthing") }
+  end
+
+  context "#empty" do
+    let(:gitignore) { <<-GITIGNORE
+# A comment
+GITIGNORE
+    }
+
+    subject { PathSpec.new gitignore }
+
+    it 'is empty when there are no valid lines' do
+      expect(subject.empty?).to be true
+    end
+  end
+
+  context "regex file" do
+    let(:regexfile) { <<-REGEX
+ab*a
+REGEX
+    }
+
+    subject { PathSpec.new regexfile, :regex}
+
+    it "matches the regex" do
+      expect(subject.match('anna')).to be false
+      expect(subject.match('abba')).to be true
+    end
+  end
+
+  context "unsuppored spec type" do
+    let(:file) { <<-REGEX
+This is some kind of nonsense.
+REGEX
+    }
+
+    it "does not allow an unknown spec type" do
+      expect { PathSpec.new file, :foo}.to raise_error
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pathspec
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Brandon High
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-11 00:00:00.000000000 Z
+date: 2017-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -51,7 +51,11 @@ files:
 - lib/pathspec/gitignorespec.rb
 - lib/pathspec/regexspec.rb
 - lib/pathspec/spec.rb
-homepage: http://rubygems.org/gems/pathspec
+- spec/spec_helper.rb
+- spec/unit/pathspec/gitignorespec_spec.rb
+- spec/unit/pathspec/spec_spec.rb
+- spec/unit/pathspec_spec.rb
+homepage: https://github.com/highb/pathspec-ruby
 licenses:
 - Apache
 metadata: {}
@@ -75,4 +79,8 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: 'PathSpec: for matching path patterns'
-test_files: []
+test_files:
+- spec/spec_helper.rb
+- spec/unit/pathspec/gitignorespec_spec.rb
+- spec/unit/pathspec/spec_spec.rb
+- spec/unit/pathspec_spec.rb