fspath 2.1.0 → 2.1.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZWMyZGJiOTM2MzZkOWQwZTljNjE4Yjc3MmI5MTAxOTliNDU0OTdmZA==
+    YjExMmZkYzEwNGJlMDFiZDhkOTJmZjE2Yzg0M2Y0M2ZhNzI3Nzg5NQ==
   data.tar.gz: !binary |-
-    ZWFkODdkNTRlOTQyYjFmZDVkYjZhM2JjM2VmZTQ2NWZjZGViMzliYw==
-!binary "U0hBNTEy":
+    ZjZlNTBlNzQ0ODQzN2ViOWU1NDM1ZDkzZGNkNDAzNzZhMmM2MWM1OA==
+SHA512:
   metadata.gz: !binary |-
-    ZGVhNmZhYTZjODQzNWYzMzA0OGNkOGRjNjhmNmQyNWYzNDQyMWU3ZThjNDE5
-    MmJmYzc5NTI0NGFlYTE5ZjgxMzE1N2Y2ZDhjOTJiYmJjZjUxNzc4ODA1ZWFi
-    ZGJmN2U4ZjEwM2ExYTk0ZGFhMzJhOWVjYmEyZDZkYjRhMjc2YTU=
+    ZmE5ODRjOWZkMjg1ZWM1NDU0M2NhOGM2MmE1YjVkYjg5NjEyNjJmZWNiMjNl
+    YzdjNzMzZjM4MjkwNGEzMTkyNjY4OTA5MTc0ZDhhOTgzYzZjMDY2YzJmZjYz
+    Y2MzODM0Mzk5OGU0ZmUxNDIwODYyZGNkNzkzZmI2Mzc4Y2U1YzI=
   data.tar.gz: !binary |-
-    ZWU5Yjc2OGViYjkwMDNhNzE4MDNiMjUwZjkzZmY5NTFhYjFkYWQ2Y2RkNGRm
-    MjM5ODE3ODE3ZmI4OGVhZjc1MzI0NmFlNGE1YTdmM2Q0ZWRkNzc2ODg0ZTM3
-    OTI2Y2Q4ZTgyMDRhOTcxOTJkY2E0YzkwOWE1Y2UyZTYwNzBmZmU=
+    YmQzYzg1NTdlZWM3Y2I1OTg5YzUxMTg3ODcwYjk4YzdkMmQ1ZWE0YTJiOTFk
+    MDM1NDliNGRjMjFhOGIyNzY4MzY0MTk2YTlhMzFmMjY3ZTNiZTcyYWQ2ZThl
+    MDFkNjk5NzU0N2I3NjlhMWQwMjZiZTc5ZDgwNDAzYjIzZjFiZDA=

data/.rubocop.yml

@@ -0,0 +1,59 @@
+AllCops:
+  Exclude:
+    - '*.gemspec'
+
+Lint/EndAlignment:
+  AlignWith: variable
+
+Metrics/ClassLength:
+  Max: 175
+
+Metrics/MethodLength:
+  Max: 15
+
+Style/AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/CaseIndentation:
+  IndentWhenRelativeTo: end
+
+Style/DotPosition:
+  EnforcedStyle: trailing
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/Encoding:
+  EnforcedStyle: when_needed
+
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+Style/IfUnlessModifier:
+  MaxLineLength: 40
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/OpMethod: # leave name in `def ~(name = nil)`
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%w': '[]'
+    '%W': '[]'
+
+Style/Semicolon:
+  AllowAsExpressionSeparator: true
+
+Style/SpaceBeforeBlockBraces:
+  EnforcedStyle: no_space
+
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Style/TrailingComma:
+  EnforcedStyleForMultiline: comma

data/.travis.yml

@@ -3,8 +3,20 @@ rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
-  - 2.0.0
+  - '2.0'
+  - '2.1'
+  - '2.2'
   - jruby-18mode
   - jruby-19mode
   - ree
-script: "bundle exec rspec"
+script:
+  if [ -n "$RUBOCOP" ]; then
+    bundle exec rubocop
+  ; else
+    bundle exec rspec
+  ; fi
+matrix:
+  fast_finish: true
+  include:
+    - env: RUBOCOP=true
+      rvm: default

data/Gemfile

@@ -1,3 +1,3 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 gemspec

data/LICENSE.txt

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

data/README.markdown

@@ -1,11 +1,15 @@
+[![Gem Version](https://img.shields.io/gem/v/fspath.svg?style=flat)](https://rubygems.org/gems/fspath)
+[![Build Status](https://img.shields.io/travis/toy/fspath/master.svg?style=flat)](https://travis-ci.org/toy/fspath)
+[![Code Climate](https://img.shields.io/codeclimate/github/toy/fspath.svg?style=flat)](https://codeclimate.com/github/toy/fspath)
+[![Dependency Status](https://img.shields.io/gemnasium/toy/fspath.svg?style=flat)](https://gemnasium.com/toy/fspath)
+[![Inch CI](http://inch-ci.org/github/toy/fspath.svg?branch=master&style=flat)](http://inch-ci.org/github/toy/fspath)
+
 # fspath
 
 Better than Pathname
 
 Check out [fspath-mac](https://rubygems.org/gems/fspath-mac) and [fspath-xattr](https://rubygems.org/gems/fspath-xattr).
 
-[![Build Status](https://travis-ci.org/toy/fspath.png?branch=master)](https://travis-ci.org/toy/fspath)
-
 ## Synopsis
 
 User dir:
@@ -56,4 +60,4 @@ Path parts:
 
 ## Copyright
 
-Copyright (c) 2010-2013 Ivan Kuchin. See LICENSE.txt for details.
+Copyright (c) 2010-2014 Ivan Kuchin. See LICENSE.txt for details.

data/fspath.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'fspath'
-  s.version     = '2.1.0'
+  s.version     = '2.1.1'
   s.summary     = %q{Better than Pathname}
   s.homepage    = "http://github.com/toy/#{s.name}"
   s.authors     = ['Ivan Kuchin']
@@ -15,5 +15,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = %w[lib]
 
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('1.9.3')
+    s.add_development_dependency 'rubocop', '~> 0.28'
+  end
 end

data/lib/fspath.rb

@@ -2,18 +2,26 @@ require 'pathname'
 require 'tempfile'
 require 'tmpdir'
 
+# Extension of Pathname with helpful methods and fixes
 class FSPath < Pathname
+  # Extension of Tempfile returning instance of provided class for path
   class Tempfile < ::Tempfile
+    # Eats first argument which must be a class, and calls super
     def initialize(path_klass, *args)
-      raise ArgumentError.new("#{path_klass.inspect} is not a class") unless path_klass.is_a?(Class)
+      unless path_klass.is_a?(Class)
+        fail ArgumentError, "#{path_klass.inspect} is not a class"
+      end
       @path_klass = path_klass
       super(*args)
     end
 
+    # Returns path wrapped in class provided in initialize
     def path
       @path_klass.new(super)
     end
 
+    # Fixes using appropriate initializer for jruby in 1.8 mode, also returns
+    # result of block in ruby 1.8
     def self.open(*args)
       tempfile = new(*args)
 
@@ -43,14 +51,16 @@ class FSPath < Pathname
       end.inject(:&).first
     end
 
-    # Returns or yields temp file created by Tempfile.new with path returning FSPath
+    # Returns or yields temp file created by Tempfile.new with path returning
+    # FSPath
     def temp_file(*args, &block)
       args = %w[f] if args.empty?
       Tempfile.open(self, *args, &block)
     end
 
     # Returns or yields path as FSPath of temp file created by Tempfile.new
-    # WARNING: loosing reference to returned object will remove file on nearest GC run
+    # WARNING: loosing reference to returned object will remove file on nearest
+    # GC run
     def temp_file_path(*args)
       if block_given?
         temp_file(*args) do |file|
@@ -126,8 +136,8 @@ class FSPath < Pathname
     paths = []
     path = @path
     paths << self
-    while r = chop_basename(path)
-      path, name = r
+    while (r = chop_basename(path))
+      path = r.first
       break if path.empty?
       paths << self.class.new(del_trailing_separator(path))
     end
@@ -158,7 +168,7 @@ class FSPath < Pathname
     split_names(@path).flatten
   end
 
-  unless new('a').basename.is_a?(self)
+  unless pwd.is_a?(self)
     # Fixing glob
     def self.glob(*args)
       if block_given?
@@ -252,10 +262,11 @@ private
   end
 end
 
+# Add FSPath method as alias to FSPath.new
 module Kernel
   # FSPath(path) method
-  def FSPath(path)
+  define_method :FSPath do |path|
     FSPath.new(path)
   end
-  private :Pathname
+  private :FSPath
 end

data/spec/fspath_spec.rb

@@ -1,277 +1,277 @@
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'rspec'
 require 'fspath'
 
 describe FSPath do
   class ZPath < FSPath
   end
 
-  it "should inherit from Pathname" do
-    FSPath.new('.').should be_kind_of(Pathname)
+  it 'inherits from Pathname' do
+    expect(FSPath.new('.')).to be_kind_of(Pathname)
   end
 
-  it "should use shortcut" do
-    FSPath('.').should === FSPath.new('.')
+  it 'uses shortcut' do
+    expect(FSPath('.')).to eql(FSPath.new('.'))
   end
 
-  describe "~" do
-    it "should return current user home directory" do
-      FSPath.~.should == FSPath(File.expand_path('~'))
+  describe '~' do
+    it 'returns current user home directory' do
+      expect(FSPath.~).to eq(FSPath(File.expand_path('~')))
     end
 
-    it "should return other user home directory" do
-      FSPath.~('root').should == FSPath(File.expand_path('~root'))
+    it 'returns other user home directory' do
+      expect(FSPath.~('root')).to eq(FSPath(File.expand_path('~root')))
     end
   end
 
-  describe "common_dir" do
-    it "should return dirname if called with one path" do
-      FSPath.common_dir('/a/b/c').should == FSPath('/a/b')
+  describe 'common_dir' do
+    it 'returns dirname if called with one path' do
+      expect(FSPath.common_dir('/a/b/c')).to eq(FSPath('/a/b'))
     end
 
-    it "should return common path if called with mulpitle paths" do
-      FSPath.common_dir('/a/b/c/d/e', '/a/b/c/d/f', '/a/b/c/z').should == FSPath('/a/b/c')
+    it 'returns common path if called with mulpitle paths' do
+      expect(FSPath.common_dir('/a/b/c/d/e', '/a/b/c/d/f', '/a/b/c/z')).
+        to eq(FSPath('/a/b/c'))
     end
 
-    it "should return nil if there is no common path" do
-      FSPath.common_dir('../a', './b').should be_nil
+    it 'returns nil if there is no common path' do
+      expect(FSPath.common_dir('../a', './b')).to be_nil
     end
   end
 
   [FSPath, ZPath].each do |klass|
     describe "#{klass}.temp_file" do
-      it "should return Tempfile with path returning instance of #{klass}" do
-        klass.temp_file.should be_kind_of(Tempfile)
-        klass.temp_file.path.should be_kind_of(klass)
+      it "returns Tempfile with path returning instance of #{klass}" do
+        expect(klass.temp_file).to be_kind_of(Tempfile)
+        expect(klass.temp_file.path).to be_kind_of(klass)
       end
 
-      it "should yield Tempfile with path returning instance of #{klass}" do
+      it "yields Tempfile with path returning instance of #{klass}" do
         yielded = nil
         klass.temp_file{ |y| yielded = y }
-        yielded.should be_kind_of(Tempfile)
-        yielded.path.should be_kind_of(klass)
+        expect(yielded).to be_kind_of(Tempfile)
+        expect(yielded.path).to be_kind_of(klass)
       end
 
-      it "should return result of block" do
-        klass.temp_file{ :result }.should == :result
+      it 'returns result of block' do
+        expect(klass.temp_file{ :result }).to eq(:result)
       end
 
-      it "should call appropriate initializer (jruby 1.8 mode bug)" do
-        lambda {
+      it 'calls appropriate initializer (jruby 1.8 mode bug)' do
+        expect do
           klass.temp_file('abc', '.'){}
-        }.should_not raise_error
+        end.not_to raise_error
       end
     end
 
     describe "#{klass}.temp_file_path" do
-      it "should return #{klass} with temporary path" do
-        klass.temp_file_path.should be_kind_of(klass)
+      it "returns #{klass} with temporary path" do
+        expect(klass.temp_file_path).to be_kind_of(klass)
       end
 
-      it "should not allow GC to finalize TempFile" do
+      it 'does not allow GC to finalize TempFile' do
         paths = Array.new(1000){ FSPath.temp_file_path }
-        paths.should be_all(&:exist?)
+        expect(paths).to be_all(&:exist?)
         GC.start
-        paths.should be_all(&:exist?)
+        expect(paths).to be_all(&:exist?)
       end
 
-      it "should yield #{klass} with temporary path" do
+      it "yields #{klass} with temporary path" do
         yielded = nil
         klass.temp_file_path{ |y| yielded = y }
-        yielded.should be_kind_of(klass)
+        expect(yielded).to be_kind_of(klass)
       end
     end
   end
 
-  describe "temp_dir" do
-    it "should return result of running Dir.mktmpdir as FSPath instance" do
+  describe 'temp_dir' do
+    it 'returns result of running Dir.mktmpdir as FSPath instance' do
       @path = '/tmp/a/b/1'
-      Dir.stub(:mktmpdir).and_return(@path)
+      allow(Dir).to receive(:mktmpdir).and_return(@path)
 
-      FSPath.temp_dir.should == FSPath('/tmp/a/b/1')
+      expect(FSPath.temp_dir).to eq(FSPath('/tmp/a/b/1'))
     end
 
-    it "should yield path yielded by Dir.mktmpdir as FSPath instance" do
+    it 'yields path yielded by Dir.mktmpdir as FSPath instance' do
       @path = '/tmp/a/b/2'
-      Dir.stub(:mktmpdir).and_yield(@path)
+      allow(Dir).to receive(:mktmpdir).and_yield(@path)
 
       yielded = nil
       FSPath.temp_dir{ |y| yielded = y }
-      yielded.should == FSPath('/tmp/a/b/2')
+      expect(yielded).to eq(FSPath('/tmp/a/b/2'))
     end
   end
 
-  describe "/" do
-    it "should join path with string" do
-      (FSPath('a') / 'b').should == FSPath('a/b')
+  describe '/' do
+    it 'joins path with string' do
+      expect(FSPath('a') / 'b').to eq(FSPath('a/b'))
     end
 
-    it "should join path with another FSPath" do
-      (FSPath('a') / FSPath('b')).should == FSPath('a/b')
+    it 'joins path with another FSPath' do
+      expect(FSPath('a') / FSPath('b')).to eq(FSPath('a/b'))
     end
 
-    it "should join with path starting with slash" do
-      (FSPath('a') / '/b').should == FSPath('a/b')
+    it 'joins with path starting with slash' do
+      expect(FSPath('a') / '/b').to eq(FSPath('a/b'))
     end
   end
 
-  describe "+" do
-    it "should return instance of FSPath" do
-      (FSPath('a') + 'b').should be_instance_of(FSPath)
+  describe '+' do
+    it 'returns instance of FSPath' do
+      expect(FSPath('a') + 'b').to be_instance_of(FSPath)
     end
 
-    it "should join simple paths" do
-      (FSPath('a') + 'b').should == FSPath('a/b')
+    it 'joins simple paths' do
+      expect(FSPath('a') + 'b').to eq(FSPath('a/b'))
     end
 
-    it "should join path starting with slash" do
-      (FSPath('a') + '/b').should == FSPath('/b')
+    it 'joins path starting with slash' do
+      expect(FSPath('a') + '/b').to eq(FSPath('/b'))
     end
   end
 
-  describe "relative_path_from" do
-    it "should return instance of FSPath" do
-      (FSPath('a').relative_path_from('b')).should be_instance_of(FSPath)
+  describe 'relative_path_from' do
+    it 'returns instance of FSPath' do
+      expect(FSPath('a').relative_path_from('b')).to be_instance_of(FSPath)
     end
 
-    it "should return relative path" do
-      (FSPath('b/a').relative_path_from('b')).should == FSPath('a')
+    it 'returns relative path' do
+      expect(FSPath('b/a').relative_path_from('b')).to eq(FSPath('a'))
     end
   end
 
-  describe "writing" do
+  describe 'writing' do
     before do
       @path = FSPath.new('test')
       @file = double(:file)
       @data = double(:data)
       @size = double(:size)
 
-      @path.stub(:open).and_yield(@file)
-      @file.stub(:write).and_return(@size)
+      allow(@path).to receive(:open).and_yield(@file)
+      allow(@file).to receive(:write).and_return(@size)
     end
 
-    describe "write" do
-      it "should open file for writing" do
-        @path.should_receive(:open).with('wb')
+    describe 'write' do
+      it 'opens file for writing' do
+        expect(@path).to receive(:open).with('wb')
         @path.write(@data)
       end
 
-      it "should write data" do
-        @file.should_receive(:write).with(@data)
+      it 'writes data' do
+        expect(@file).to receive(:write).with(@data)
         @path.write(@data)
       end
 
-      it "should return result of write" do
-        @path.write(@data).should == @size
+      it 'returns result of write' do
+        expect(@path.write(@data)).to eq(@size)
       end
     end
 
-    describe "append" do
-      it "should open file for writing" do
-        @path.should_receive(:open).with('ab')
+    describe 'append' do
+      it 'opens file for writing' do
+        expect(@path).to receive(:open).with('ab')
         @path.append(@data)
       end
 
-      it "should write data" do
-        @file.should_receive(:write).with(@data)
+      it 'writes data' do
+        expect(@file).to receive(:write).with(@data)
         @path.append(@data)
       end
 
-      it "should return result of write" do
-        @path.append(@data).should == @size
+      it 'returns result of write' do
+        expect(@path.append(@data)).to eq(@size)
       end
     end
   end
 
-  describe "escape_glob" do
-    it "should escape glob pattern characters" do
-      FSPath('*/**/?[a-z]{abc,def}').escape_glob.should == FSPath('\*/\*\*/\?\[a-z\]\{abc,def\}')
+  describe 'escape_glob' do
+    it 'escapes glob pattern characters' do
+      expect(FSPath('*/**/?[a-z]{abc,def}').escape_glob).
+        to eq(FSPath('\*/\*\*/\?\[a-z\]\{abc,def\}'))
     end
   end
 
-  describe "glob" do
-    it "should join with arguments and expand glob" do
-      FSPath.should_receive(:glob).with('a/b/c/**/*')
+  describe 'glob' do
+    it 'joins with arguments and expands glob' do
+      expect(FSPath).to receive(:glob).with('a/b/c/**/*')
       FSPath('a/b/c').glob('**', '*')
     end
 
-    it "should join with arguments and expand glob" do
-      @flags = 12345
-      FSPath.should_receive(:glob).with('a/b/c/**/*', @flags)
+    it 'joins with arguments and expands glob' do
+      @flags = 12_345
+      expect(FSPath).to receive(:glob).with('a/b/c/**/*', @flags)
       FSPath('a/b/c').glob('**', '*', @flags)
     end
 
-    it "should escape glob characters in path itself" do
-      FSPath.should_receive(:glob).with('somewhere \[a b c\]/**/*')
+    it 'escapes glob characters in path itself' do
+      expect(FSPath).to receive(:glob).with('somewhere \[a b c\]/**/*')
       FSPath('somewhere [a b c]').glob('**', '*')
     end
   end
 
-  describe "path parts" do
-    describe "ascending" do
+  describe 'path parts' do
+    describe 'ascending' do
       before do
         @path = FSPath('/a/b/c')
         @ascendants = %w[/a/b/c /a/b /a /].map(&method(:FSPath))
       end
 
-      describe "ascendants" do
-        it "should return list of ascendants" do
-          @path.ascendants.should == @ascendants
+      describe 'ascendants' do
+        it 'returns list of ascendants' do
+          expect(@path.ascendants).to eq(@ascendants)
         end
       end
 
-      describe "ascend" do
-        it "should return list of ascendants" do
-          @path.ascend.should == @ascendants
+      describe 'ascend' do
+        it 'returns list of ascendants' do
+          expect(@path.ascend).to eq(@ascendants)
         end
 
-        it "should yield and return list of ascendants if called with block" do
+        it 'yields and returns list of ascendants if called with block' do
           ascendants = []
-          @path.ascend do |path|
+          expect(@path.ascend do |path|
             ascendants << path
-          end.should == @ascendants
-          ascendants.should == @ascendants
+          end).to eq(@ascendants)
+          expect(ascendants).to eq(@ascendants)
         end
       end
     end
 
-    describe "descending" do
+    describe 'descending' do
       before do
         @path = FSPath('/a/b/c')
         @descendants = %w[/ /a /a/b /a/b/c].map(&method(:FSPath))
       end
 
-      describe "descendants" do
-        it "should return list of descendants" do
-          @path.descendants.should == @descendants
+      describe 'descendants' do
+        it 'returns list of descendants' do
+          expect(@path.descendants).to eq(@descendants)
         end
       end
 
-      describe "descend" do
-        it "should return list of descendants" do
-          @path.descend.should == @descendants
+      describe 'descend' do
+        it 'returns list of descendants' do
+          expect(@path.descend).to eq(@descendants)
         end
 
-        it "should yield and return list of descendants if called with block" do
+        it 'yields and returns list of descendants if called with block' do
           descendants = []
-          @path.descend do |path|
+          expect(@path.descend do |path|
             descendants << path
-          end.should == @descendants
-          descendants.should == @descendants
+          end).to eq(@descendants)
+          expect(descendants).to eq(@descendants)
         end
       end
     end
 
-    describe "parts" do
-      it "should return path parts as strings" do
-        FSPath('/a/b/c').parts.should == %w[/ a b c]
+    describe 'parts' do
+      it 'returns path parts as strings' do
+        expect(FSPath('/a/b/c').parts).to eq(%w[/ a b c])
       end
     end
   end
 
-  describe "returning/yield instances of FSPath" do
+  describe 'returning/yielding instances' do
     def fspath?(path)
-      path.should be_instance_of(FSPath)
+      expect(path).to be_instance_of(FSPath)
     end
 
     def fspaths?(paths)
@@ -280,7 +280,7 @@ describe FSPath do
       end
     end
 
-    it "should for glob" do
+    it 'uses FSPath for glob' do
       fspaths? FSPath(__FILE__).glob
 
       FSPath(__FILE__).glob do |path|
@@ -288,56 +288,56 @@ describe FSPath do
       end
     end
 
-    it "should for pwd" do
+    it 'uses FSPath for pwd' do
       fspath? FSPath.pwd
     end
 
-    it "should for getwd" do
+    it 'uses FSPath for getwd' do
       fspath? FSPath.getwd
     end
 
-    it "should for basename" do
+    it 'uses FSPath for basename' do
       fspath? FSPath('a/b').basename
     end
 
-    it "should for dirname" do
+    it 'uses FSPath for dirname' do
       fspath? FSPath('a/b').dirname
     end
 
-    it "should for parent" do
+    it 'uses FSPath for parent' do
       fspath? FSPath('a/b').parent
     end
 
-    it "should for cleanpath" do
+    it 'uses FSPath for cleanpath' do
       fspath? FSPath('a/b').cleanpath
     end
 
-    it "should for expand_path" do
+    it 'uses FSPath for expand_path' do
       fspath? FSPath('a/b').expand_path
     end
 
-    it "should for relative_path_from" do
+    it 'uses FSPath for relative_path_from' do
       fspath? FSPath('a').relative_path_from('b')
     end
 
-    it "should for join" do
+    it 'uses FSPath for join' do
       fspath? FSPath('a').join('b', 'c')
     end
 
-    it "should for split" do
+    it 'uses FSPath for split' do
       fspaths? FSPath('a/b').split
     end
 
-    it "should for sub" do
+    it 'uses FSPath for sub' do
       fspath? FSPath('a/b').sub('a', 'c')
       fspath? FSPath('a/b').sub('a'){ 'c' }
     end
 
-    it "should for sub_ext" do
+    it 'uses FSPath for sub_ext' do
       fspath? FSPath('a/b').sub_ext('.rb')
     end if FSPath.method_defined?(:sub_ext)
 
-    it "should for readlink" do
+    it 'uses FSPath for readlink' do
       FSPath.temp_dir do |dir|
         symlink = dir + 'sym'
         symlink.make_symlink __FILE__
@@ -345,51 +345,51 @@ describe FSPath do
       end
     end
 
-    it "should for realdirpath" do
+    it 'uses FSPath for realdirpath' do
       fspath? FSPath(__FILE__).realdirpath
     end if FSPath.method_defined?(:realdirpath)
 
-    it "should for realpath" do
+    it 'uses FSPath for realpath' do
       fspath? FSPath(__FILE__).realpath
     end
 
-    it "should for children" do
+    it 'uses FSPath for children' do
       fspaths? FSPath('.').children
     end
 
-    it "should for dir_foreach" do
+    it 'uses FSPath for dir_foreach' do
       dir = FSPath('.')
-      dir.stub(:warn)
+      allow(dir).to receive(:warn)
       dir.dir_foreach do |entry|
         fspath? entry
       end
     end if FSPath.method_defined?(:dir_foreach)
 
-    it "should for each_child" do
+    it 'uses FSPath for each_child' do
       fspaths? FSPath('.').each_child
       fspaths? FSPath('.').each_child do |child|
         fspath? child
       end
     end if FSPath.method_defined?(:each_child)
 
-    it "should for each_entry" do
+    it 'uses FSPath for each_entry' do
       FSPath('.').each_entry do |entry|
         fspath? entry
       end
     end
 
-    it "should for entries" do
+    it 'uses FSPath for entries' do
       fspaths? FSPath('.').entries
     end
 
-    it "should for find" do
+    it 'uses FSPath for find' do
       FSPath('.').find do |path|
         fspath? path
       end
     end
 
-    it "should for inspect" do
-      FSPath('a').inspect.should include('FSPath')
+    it 'uses FSPath for inspect' do
+      expect(FSPath('a').inspect).to include('FSPath')
     end
   end
 end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: fspath
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Ivan Kuchin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-08 00:00:00.000000000 Z
+date: 2014-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.28'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.28'
 description: 
 email: 
 executables: []
@@ -31,6 +45,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rubocop.yml
 - .travis.yml
 - Gemfile
 - LICENSE.txt
@@ -58,9 +73,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: fspath
-rubygems_version: 2.0.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Better than Pathname
 test_files:
 - spec/fspath_spec.rb
+has_rdoc: