fspath 2.0.6 → 2.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTE3MTE5ZGQzNTAyZGRiMjUxNTI1M2E4MDMzZGVjM2I3OGUyMDAyOQ==
+    ZWMyZGJiOTM2MzZkOWQwZTljNjE4Yjc3MmI5MTAxOTliNDU0OTdmZA==
   data.tar.gz: !binary |-
-    ZGU1YmZmMDhkMWRmYjQzNDExN2RhNjI3OWIxZjc5NWU2MmFlYTQyZg==
+    ZWFkODdkNTRlOTQyYjFmZDVkYjZhM2JjM2VmZTQ2NWZjZGViMzliYw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YzdiYzcyNTZlNTc1ZTEwMjYxMDY4MWM5ZDNhMzdlNWQ4N2I0Y2I1NTNhY2I5
-    ODE1YjU5NzNlODVhNzFmYTc3YjkxMGZkOGU4MjMwMTUyYzIwYjE2ODg5ZjFk
-    ZTkwNWE5YmM4MTRjOWVjMzI3Y2I0ODcyNzRiNjRiMWZkNGJlNDA=
+    ZGVhNmZhYTZjODQzNWYzMzA0OGNkOGRjNjhmNmQyNWYzNDQyMWU3ZThjNDE5
+    MmJmYzc5NTI0NGFlYTE5ZjgxMzE1N2Y2ZDhjOTJiYmJjZjUxNzc4ODA1ZWFi
+    ZGJmN2U4ZjEwM2ExYTk0ZGFhMzJhOWVjYmEyZDZkYjRhMjc2YTU=
   data.tar.gz: !binary |-
-    ODQ3ZmU3NWQzYjcyZjQ2ZWFiNDUzZjFlZTE3OWEwN2QwZjFhYTI2OTliOGYy
-    MTZiZDA3NDhkZDJkNjY0NTkzNWVmZTg0YzA4ZTQwZGQzMzUxYzFiM2U5MGQw
-    ODBjNGY2ODRhN2ZlZjA4MmQ0MDlkOWRkZDMyZTk3ZjYzMTA5YzA=
+    ZWU5Yjc2OGViYjkwMDNhNzE4MDNiMjUwZjkzZmY5NTFhYjFkYWQ2Y2RkNGRm
+    MjM5ODE3ODE3ZmI4OGVhZjc1MzI0NmFlNGE1YTdmM2Q0ZWRkNzc2ODg0ZTM3
+    OTI2Y2Q4ZTgyMDRhOTcxOTJkY2E0YzkwOWE1Y2UyZTYwNzBmZmU=

data/.travis.yml

@@ -6,7 +6,5 @@ rvm:
   - 2.0.0
   - jruby-18mode
   - jruby-19mode
-  - rbx-18mode
-  - rbx-19mode
   - ree
 script: "bundle exec rspec"

data/README.markdown

@@ -42,10 +42,12 @@ Expand glob:
 
 Ascendants:
 
+    FSPath('a/b/c').ascendants
     FSPath('a/b/c').ascend # => [FSPath('a/b/c'), FSPath('a/b'), FSPath('a')]
 
 Descendants:
 
+    FSPath('a/b/c').descendants
     FSPath('a/b/c').descend # => [FSPath('a'), FSPath('a/b'), FSPath('a/b/c')]
 
 Path parts:

data/fspath.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'fspath'
-  s.version     = '2.0.6'
+  s.version     = '2.1.0'
   s.summary     = %q{Better than Pathname}
   s.homepage    = "http://github.com/toy/#{s.name}"
   s.authors     = ['Ivan Kuchin']

data/lib/fspath.rb

@@ -39,7 +39,7 @@ class FSPath < Pathname
     # Returns common dir for paths
     def common_dir(*paths)
       paths.map do |path|
-        new(path).dirname.ascend
+        new(path).ascendants.drop(1)
       end.inject(:&).first
     end
 
@@ -83,9 +83,9 @@ class FSPath < Pathname
   end
 
   unless (new('a') + 'b').is_a?(self)
-    # Fixing Pathname.+
+    # Fixing Pathname#+
     def +(other)
-      self.class.new(plus(@path, other.to_s))
+      self.class.new(super)
     end
   end
 
@@ -121,36 +121,130 @@ class FSPath < Pathname
     self.class.glob(*args, &block)
   end
 
-  # Iterates over and yields each element in the given path in ascending order
-  def ascend(&block)
-    ascendants = []
+  # Returns list of elements in the given path in ascending order
+  def ascendants
+    paths = []
     path = @path
-    ascendants << self
+    paths << self
     while r = chop_basename(path)
       path, name = r
       break if path.empty?
-      ascendants << self.class.new(del_trailing_separator(path))
-    end
-    if block
-      ascendants.each(&block)
+      paths << self.class.new(del_trailing_separator(path))
     end
-    ascendants
+    paths
+  end
+
+  # Returns list of elements in the given path in descending order
+  def descendants
+    ascendants.reverse
+  end
+
+  # Iterates over and yields each element in the given path in ascending order
+  def ascend(&block)
+    paths = ascendants
+    paths.each(&block) if block
+    paths
   end
 
   # Iterates over and yields each element in the given path in descending order
   def descend(&block)
-    descendants = ascend.reverse
-    if block
-      descendants.each(&block)
-    end
-    descendants
+    paths = descendants
+    paths.each(&block) if block
+    paths
   end
 
   # Returns path parts
-  def parts(&block)
+  def parts
     split_names(@path).flatten
   end
 
+  unless new('a').basename.is_a?(self)
+    # Fixing glob
+    def self.glob(*args)
+      if block_given?
+        super{ |f| yield new(f) }
+      else
+        super.map{ |f| new(f) }
+      end
+    end
+
+    # Fixing getwd
+    def self.getwd
+      new(super)
+    end
+
+    # Fixing pwd
+    def self.pwd
+      new(super)
+    end
+
+    # Fixing basename
+    def basename(*args)
+      self.class.new(super)
+    end
+
+    # Fixing dirname
+    def dirname
+      self.class.new(super)
+    end
+
+    # Fixing expand_path
+    def expand_path(*args)
+      self.class.new(super)
+    end
+
+    # Fixing split
+    def split
+      super.map{ |f| self.class.new(f) }
+    end
+
+    # Fixing sub
+    def sub(pattern, *rest, &block)
+      self.class.new(super)
+    end
+
+    if Pathname.method_defined?(:sub_ext)
+      # Fixing sub_ext
+      def sub_ext(ext)
+        self.class.new(super)
+      end
+    end
+
+    # Fixing realpath
+    def realpath
+      self.class.new(super)
+    end
+
+    if Pathname.method_defined?(:realdirpath)
+      # Fixing realdirpath
+      def realdirpath
+        self.class.new(super)
+      end
+    end
+
+    # Fixing readlink
+    def readlink
+      self.class.new(super)
+    end
+
+    # Fixing each_entry
+    def each_entry
+      super{ |f| yield self.class.new(f) }
+    end
+
+    # Fixing entries
+    def entries
+      super.map{ |f| self.class.new(f) }
+    end
+  end
+
+  unless new('a').inspect.include?('FSPath')
+    # Fixing inspect
+    def inspect
+      "#<#{self.class}:#{@path}>"
+    end
+  end
+
 private
 
   def escape_glob_string

data/spec/fspath_spec.rb

@@ -208,41 +208,57 @@ describe FSPath do
   end
 
   describe "path parts" do
-    describe "ascend" do
+    describe "ascending" do
       before do
         @path = FSPath('/a/b/c')
         @ascendants = %w[/a/b/c /a/b /a /].map(&method(:FSPath))
       end
 
-      it "should return list of ascendants" do
-        @path.ascend.should == @ascendants
+      describe "ascendants" do
+        it "should return list of ascendants" do
+          @path.ascendants.should == @ascendants
+        end
       end
 
-      it "should yield and return list of ascendants if called with block" do
-        ascendants = []
-        @path.ascend do |path|
-          ascendants << path
-        end.should == @ascendants
-        ascendants.should == @ascendants
+      describe "ascend" do
+        it "should return list of ascendants" do
+          @path.ascend.should == @ascendants
+        end
+
+        it "should yield and return list of ascendants if called with block" do
+          ascendants = []
+          @path.ascend do |path|
+            ascendants << path
+          end.should == @ascendants
+          ascendants.should == @ascendants
+        end
       end
     end
 
-    describe "descend" do
+    describe "descending" do
       before do
         @path = FSPath('/a/b/c')
         @descendants = %w[/ /a /a/b /a/b/c].map(&method(:FSPath))
       end
 
-      it "should return list of descendants" do
-        @path.descend.should == @descendants
+      describe "descendants" do
+        it "should return list of descendants" do
+          @path.descendants.should == @descendants
+        end
       end
 
-      it "should yield and return list of descendants if called with block" do
-        descendants = []
-        @path.descend do |path|
-          descendants << path
-        end.should == @descendants
-        descendants.should == @descendants
+      describe "descend" do
+        it "should return list of descendants" do
+          @path.descend.should == @descendants
+        end
+
+        it "should yield and return list of descendants if called with block" do
+          descendants = []
+          @path.descend do |path|
+            descendants << path
+          end.should == @descendants
+          descendants.should == @descendants
+        end
       end
     end
 
@@ -252,4 +268,128 @@ describe FSPath do
       end
     end
   end
+
+  describe "returning/yield instances of FSPath" do
+    def fspath?(path)
+      path.should be_instance_of(FSPath)
+    end
+
+    def fspaths?(paths)
+      paths.each do |path|
+        fspath? path
+      end
+    end
+
+    it "should for glob" do
+      fspaths? FSPath(__FILE__).glob
+
+      FSPath(__FILE__).glob do |path|
+        fspath? path
+      end
+    end
+
+    it "should for pwd" do
+      fspath? FSPath.pwd
+    end
+
+    it "should for getwd" do
+      fspath? FSPath.getwd
+    end
+
+    it "should for basename" do
+      fspath? FSPath('a/b').basename
+    end
+
+    it "should for dirname" do
+      fspath? FSPath('a/b').dirname
+    end
+
+    it "should for parent" do
+      fspath? FSPath('a/b').parent
+    end
+
+    it "should for cleanpath" do
+      fspath? FSPath('a/b').cleanpath
+    end
+
+    it "should for expand_path" do
+      fspath? FSPath('a/b').expand_path
+    end
+
+    it "should for relative_path_from" do
+      fspath? FSPath('a').relative_path_from('b')
+    end
+
+    it "should for join" do
+      fspath? FSPath('a').join('b', 'c')
+    end
+
+    it "should for split" do
+      fspaths? FSPath('a/b').split
+    end
+
+    it "should for sub" do
+      fspath? FSPath('a/b').sub('a', 'c')
+      fspath? FSPath('a/b').sub('a'){ 'c' }
+    end
+
+    it "should for sub_ext" do
+      fspath? FSPath('a/b').sub_ext('.rb')
+    end if FSPath.method_defined?(:sub_ext)
+
+    it "should for readlink" do
+      FSPath.temp_dir do |dir|
+        symlink = dir + 'sym'
+        symlink.make_symlink __FILE__
+        fspath? symlink.readlink
+      end
+    end
+
+    it "should for realdirpath" do
+      fspath? FSPath(__FILE__).realdirpath
+    end if FSPath.method_defined?(:realdirpath)
+
+    it "should for realpath" do
+      fspath? FSPath(__FILE__).realpath
+    end
+
+    it "should for children" do
+      fspaths? FSPath('.').children
+    end
+
+    it "should for dir_foreach" do
+      dir = FSPath('.')
+      dir.stub(:warn)
+      dir.dir_foreach do |entry|
+        fspath? entry
+      end
+    end if FSPath.method_defined?(:dir_foreach)
+
+    it "should 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
+      FSPath('.').each_entry do |entry|
+        fspath? entry
+      end
+    end
+
+    it "should for entries" do
+      fspaths? FSPath('.').entries
+    end
+
+    it "should for find" do
+      FSPath('.').find do |path|
+        fspath? path
+      end
+    end
+
+    it "should for inspect" do
+      FSPath('a').inspect.should include('FSPath')
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fspath
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.1.0
 platform: ruby
 authors:
 - Ivan Kuchin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-06 00:00:00.000000000 Z
+date: 2013-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec