pa 1.3.0 → 1.3.1

data/lib/pa/util.rb

@@ -1,41 +1,138 @@
+require "rbconfig"
+
 class Pa
+  # In order to reduce the dependencies, this Util class contains some util functions.
   class Util
     module Concern
       def included(base)
         base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
-        base.send :include, const_get(:InstanceMethods) if const_defined?(:InstanceMethods)
       end
     end
 
     class << self
-      # extract options
-      # @see extract_options!
+      # Extracts options from a set of arguments. 
+      #
       # @example
-      #   def mkdir(*args)
-      #     paths, o = args.extract_options
-      #   end
+      #
+      #   dirs, o = Util.extract_options(["foo", "bar", {a: 1}], b: 2)  
+      #     -> ["foo", "bar"], {a: 1, b: 2}
+      #
+      #   (dir,) o = Util.extract_options(["foo", {a: 1}])
+      #     -> "foo", {a: 1}
       #
       # @return [Array<Array,Hash>] 
-      def extract_options(ary, default={})
-        if ary.last.is_a?(Hash) && ary.last.instance_of?(Hash)
-          [ary[0...-1], ary[-1].merge(default)]
+      def extract_options(args, default={})
+        if args.last.instance_of?(Hash)
+          [args[0...-1], default.merge(args[-1])]
         else
-          [ary, default]
+          [args, default]
         end
       end
 
-      def wrap_array(value)
-        Array === value ? value : [value]
+      # Wraps its argument in an array unless it is already an array (or array-like).
+      #
+      # Specifically:
+      #
+      # * If the argument is +nil+ an empty list is returned.
+      # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
+      # * Otherwise, returns an array with the argument as its single element.
+      #
+      #   Array.wrap(nil)       # => []
+      #   Array.wrap([1, 2, 3]) # => [1, 2, 3]
+      #   Array.wrap(0)         # => [0]
+      #
+      # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
+      #
+      # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
+      # moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
+      # such a +nil+ right away.
+      # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
+      # raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
+      # * It does not call +to_a+ on the argument, though special-cases +nil+ to return an empty array.
+      #
+      # The last point is particularly worth comparing for some enumerables:
+      #
+      #   Array(:foo => :bar)      # => [[:foo, :bar]]
+      #   Array.wrap(:foo => :bar) # => [{:foo => :bar}]
+      #
+      #   Array("foo\nbar")        # => ["foo\n", "bar"], in Ruby 1.8
+      #   Array.wrap("foo\nbar")   # => ["foo\nbar"]
+      #
+      # There's also a related idiom that uses the splat operator:
+      #
+      #   [*object]
+      #
+      # which returns <tt>[nil]</tt> for +nil+, and calls to <tt>Array(object)</tt> otherwise.
+      #
+      # Thus, in this case the behavior is different for +nil+, and the differences with
+      # <tt>Kernel#Array</tt> explained above apply to the rest of +object+s.
+      def wrap_array(object)
+        if object.nil?
+          []
+        elsif object.respond_to?(:to_ary)
+          object.to_ary || [object]
+        else
+          [object]
+        end
       end
 
-      def win32? 
-        RUBY_PLATFORM =~ /mingw32|mswin/ 
-      end 
+      # Slice a hash to include only the given keys. This is useful for
+      # limiting an options hash to valid keys before passing to a method:
+      #
+      # @example
+      #
+      #    a = {a: 1, b: 2, c: 3}
+      #    a.slaice(:a, :b)                -> {a: 1, b: 2}
+      def slice(hash, *keys)
+        keys = keys.map! { |key| hash.convert_key(key) } if hash.respond_to?(:convert_key)
+        h = hash.class.new
+        keys.each { |k| h[k] = hash[k] if hash.has_key?(k) }
+        h
+      end
 
-      # join(".", "foo") => "foo" not "./foo"
-      def join(dir, *names)
+      # different to File.join. 
+      #
+      # @example
+      #
+      #   join_path(".", "foo")  -> "foo" not "./foo"
+      #
+      def join_path(dir, *names)
         dir == "." ? File.join(*names) : File.join(dir, *names)
       end
+
+      def linux?
+        RbConfig::CONFIG["host_os"] =~ /linux|cygwin/
+      end
+
+      def mac?
+        RbConfig::CONFIG["host_os"] =~ /mac|darwin/
+      end
+
+      def bsd?
+        RbConfig::CONFIG["host_os"] =~ /bsd/
+      end
+
+      def windows?
+        RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
+      end
+
+      def solaris?
+        RbConfig::CONFIG["host_os"] =~ /solaris|sunos/
+      end
+
+      # TODO: who knows what symbian returns?
+      def symbian?
+        RbConfig::CONFIG["host_os"] =~ /symbian/
+      end
+
+      def posix?
+        linux? or mac? or bsd? or solaris? or begin 
+          fork do end
+          true
+        rescue NotImplementedError, NoMethodError
+          false
+        end
+      end
     end
   end
 end

data/lib/pa/version.rb

@@ -1,3 +1,3 @@
 class Pa
-  VERSION = "1.3.0"
+  VERSION = "1.3.1"
 end

data/pa.gemspec

@@ -14,5 +14,6 @@ a path library for Ruby
 	s.rubyforge_project = "xx"
 
 	s.files = `git ls-files`.split("\n")
+
   s.add_dependency "pd"
 end

data/pa.watchr

@@ -14,9 +14,9 @@ Signal.trap('QUIT') do
 	test "spec"
 end
 
-def test path
-	cmd = "rspec #{path}"
+def test(path)
+  system "clear"
+	cmd = "bundle exec rspec #{path}"
 	puts cmd
 	system cmd
 end
-

data/spec/pa/cmd_spec.rb

@@ -2,9 +2,7 @@ require "spec_helper"
 require "fileutils"
 require "tmpdir"
 
-module Pa::Cmd::ClassMethods
-	public :_copy, :_touch, :_mkdir, :_mktmpname, :_rmdir, :_copy, :_move, :_ln
-end
+public_all_methods Pa::Cmd::ClassMethods
 
 describe Pa do
 	before :all do
@@ -13,16 +11,16 @@ describe Pa do
 		Dir.chdir @tmpdir
 	end
 
-	after :all do
-		Dir.chdir @curdir
-		FileUtils.rm_r @tmpdir
-	end
-
   # clean up directory after each run
   after :each do
     FileUtils.rm_r Dir.glob("*", File::FNM_DOTMATCH)-%w[. ..]
   end
 
+	after :all do
+		Dir.chdir @curdir
+		FileUtils.rm_r @tmpdir
+	end
+
   describe "#home2" do
     it "works" do
       Pa.home2.should == Dir.home
@@ -36,7 +34,7 @@ describe Pa do
     end
 
     it "works" do
-      output = capture :stdout do
+      output = capture do
         Pa._ln(:link, "_lna", "_lnb", :verbose => true) 
       end
 
@@ -86,7 +84,7 @@ describe Pa do
     it "doesn't raise Errno::EEXIST with :force" do
       lambda{ Pa.symln("file1", "file2", :force => true) }.should_not raise_error(Errno::EEXIST) 
       File.symlink?("file2").should be_true
-      File.readlink("file2").should == "file1"
+      File.readlink(File.absolute_path("file2")).should == "file1"
     end
   end
 
@@ -196,7 +194,7 @@ describe Pa do
 
       path = Pa.mktmpdir("foo")
 
-      path.should =~ %r~#{Regexp.escape(ENV["TEMP"])}/foo~
+      path.should =~ %r~#{Regexp.escape(Dir.tmpdir)}/foo~
     end
   end
 
@@ -547,7 +545,7 @@ describe Pa do
 		end
 	end
 
-  describe "class DELEGATE_METHODS" do
+  describe "DELEGATE_CLASS_METHODS" do
     it "works" do
       Pa.stub(:home2) { "/home/foo" } 
       Pa.home.should == Pa("/home/foo")

data/spec/pa/directory_spec.rb

@@ -2,11 +2,7 @@ require "spec_helper"
 require "fileutils"
 require "tmpdir"
 
-class Pa
-	class << self
-		public :_copy, :_move, :_rmdir, :_mktmpname, :_mkdir, :_touch
-	end
-end
+public_all_methods Pa
 
 describe Pa do
 	before :all do
@@ -121,7 +117,6 @@ describe Pa do
         break
       }
     end
-
 	end
 
   describe ".each" do
@@ -276,20 +271,20 @@ describe Pa do
 		end
 
 		it "works" do
-			Pa.ls.should == %w[filea dira].map{|v|Pa(v)}
-      Pa.ls(Dir.pwd).should == %w[filea dira].map{|v|Pa(v)}
+			Pa.ls.sort.should == %w[filea dira].map{|v|Pa(v)}.sort
+      Pa.ls(Dir.pwd).sort.should == %w[filea dira].map{|v|Pa(v)}.sort
 		end
 
     it "list multi paths" do
-      Pa.ls(".", "dira").should == %w[filea dira fileb].map{|v|Pa(v)}
+      Pa.ls(".", "dira").sort.should == %w[filea dira fileb].map{|v|Pa(v)}.sort
     end
 
     it "with :absolute => true" do
-      Pa.ls(:absolute => true).should == %w[filea dira].map{|v|Pa(File.join(Dir.pwd, v))}
+      Pa.ls(:absolute => true).sort.should == %w[filea dira].map{|v|Pa(File.join(Dir.pwd, v))}.sort
     end
 
 		it "call a block" do
-			Pa.ls{|p, fn| p.directory? }.should == %w[dira].map{|v|Pa(v)}
+			Pa.ls{|p, fn| p.directory? }.sort.should == %w[dira].map{|v|Pa(v)}.sort
 		end
   end
 

data/spec/pa/path_spec.rb

@@ -18,7 +18,7 @@ describe Pa do
   describe ".dangling?" do 
     it "works" do
       olddir=Dir.pwd
-      Dir.chdir("#{$specdir}/data/tmp")
+      Dir.chdir("#{$spec_dir}/data/tmp")
 
       begin
         File.open("fa", "w"){|f| f.puts "guten" }
@@ -44,60 +44,66 @@ describe Pa do
     end
   end
 
-  describe ".dir2" do
-    it "get a path's directory name" do
-      Pa.dir2("/home/guten").should == "/home"
+  describe ".expand2" do
+    it "expand_path" do
+      Pa.expand2("~").should == File.expand_path("~") 
     end
   end
 
-	describe ".base2" do
-		it "get name, ext with :ext => true" do
-			Pa.base2("/home/foo.bar", ext: true).should == ["foo", "bar"]
-		end
-	end
-
-  describe ".base" do
-    it "works" do
-			Pa.base("/home/foo.bar", ext: true).should == [Pa("foo"), "bar"]
+  describe ".relative_to?" do
+    it do
+      expect(Pa.relative_to?("/home/foo", "/home")).to be_true
+      expect(Pa.relative_to?("/home1/foo", "/home")).to be_false
     end
   end
 
-  describe ".ext2" do
-    it "get a path's extension" do
-      Pa.ext2("/home/a.txt").should == "txt"
-    end
+	describe ".relative_to2" do
+		it do
+      expect(Pa.relative_to2("/home/foo", "/home")).to eq("foo")
+      expect(Pa.relative_to2("/home/foo", "/home/foo")).to eq(".")
+      expect(Pa.relative_to2("/home/foo", "/bin")).to eq("/home/foo")
 
-    it "return nil when don extension" do
-      Pa.ext2("/home/a").should == nil
-    end
+      expect(Pa.relative_to2("/home/foo", "/home/foo/")).to eq(".")
+      expect(Pa.relative_to2("/home/foo/", "/home/foo")).to eq(".")
+
+      expect(Pa.relative_to2("/home1/foo", "/home")).to eq("/home1/foo")
+		end
+	end
 
-    it "with complex" do
-      Pa.ext2("/home/a.b.c.txt").should == "txt"
+  describe ".has_ext?" do
+    it do
+      expect(Pa.has_ext?("foo.txt", ".txt")).to be_true
+      expect(Pa.has_ext?("foo", ".txt")).to be_false
+      expect(Pa.has_ext?("foo.1txt", ".txt")).to be_false
     end
   end
 
-  describe ".absolute2" do
-    it "returns absolute_path" do
-      Pa.absolute2(".").should == File.absolute_path(".")
+  describe ".delete_ext2" do
+    it do
+      expect(Pa.delete_ext2("foo.txt", ".txt")).to eq("foo")
+      expect(Pa.delete_ext2("foo", ".txt")).to eq("foo")
+      expect(Pa.delete_ext2("foo.epub", ".txt")).to eq("foo.epub")
     end
   end
 
-  describe ".expand2" do
-    it "expand_path" do
-      Pa.expand2("~").should == File.expand_path("~") 
+  describe ".add_ext2" do
+    it do
+      expect(Pa.add_ext2("foo", ".txt")).to eq("foo.txt")
+      expect(Pa.add_ext2("foo.txt", ".txt")).to eq("foo.txt")
+      expect(Pa.add_ext2("foo.epub", ".txt")).to eq("foo.epub.txt")
     end
   end
 
+
 	describe ".shorten2" do
-		it "short /home/usr/file into ~/file" do
-			ENV["HOME"] = "/home/foo"
-			Pa.shorten2("/home/foo/file").should == "~/file"
-		end
+    it do
+      Pa.stub(:home2) { "/home"}
+			expect(Pa.shorten2("/home/file")).to eq("~/file")
+			expect(Pa.shorten2("/home1/file")).to eq("/home1/file")
 
-		it "not short /home/other-user/file" do
-			ENV["HOME"] = "/home/foo"
-			Pa.shorten2("/home/bar/file").should == "/home/bar/file"
-		end
+      Pa.stub(:home2) { "" }
+			expect(Pa.shorten2("/home/file")).to eq("/home/file")
+    end
 	end
 
   describe ".real2" do
@@ -118,24 +124,24 @@ describe Pa do
 		end
 	end
 
-  describe "class DELEGATE_METHODS" do
-    it "works" do
+  describe "DELEGATE_CLASS_METHODS" do
+    it do
       Pa.should_receive(:pwd2).with(1,2)
 
       Pa.pwd(1,2)
     end
   end
 
-  describe "instance DELEGATE_METHODS2" do
-    it "works" do
+  describe "DELEGATE_METHODS2" do
+    it do
       Pa.should_receive(:parent2).with("foo", 1, 2)
 
       Pa.new("foo").parent2(1, 2)
     end
   end
 
-  describe "instance DELEGATE_METHODS" do
-    it "works" do
+  describe "DELEGATE_METHODS" do
+    it do
       p = Pa.new("foo")
 
       p.should_receive(:parent2).with(1,2)

data/spec/pa_spec.rb

@@ -1,40 +1,11 @@
 require "spec_helper"
 
-class Pa
-  class <<self
-    public :_wrap, :build_path2
-  end
-end
+public_all_methods Pa
 
 describe Pa do
   it "._wrap" do
-    Pa._wrap("foo").should == Pa("foo")
-    Pa._wrap(["guten", "tag"]).should == [Pa("guten"), Pa("tag")]
-  end
-
-  describe ".build_path2" do
-    it "works" do
-      Pa.build_path2(path: "foo/bar.avi").should == "foo/bar.avi"
-      Pa.build_path2(dir: "foo", name: "bar", ext: "avi").should == "foo/bar.avi"
-    end
-
-    it "complex examples" do
-      Pa.build_path2(dir: "foo").should == "foo"
-      Pa.build_path2(fname: "bar.avi").should == "bar.avi"
-      Pa.build_path2(base: "bar.avi").should == "bar.avi"
-      Pa.build_path2(name: "bar").should == "bar"
-      Pa.build_path2(fext: ".avi").should == ".avi"
-      Pa.build_path2(ext: "avi").should == ".avi"
-      Pa.build_path2(dir: "", fname: "bar.avi").should == "bar.avi"
-    end
-
-    it "percedure" do
-      Pa.build_path2(path: "foo", fname: "bar").should == "foo"
-      Pa.build_path2(fname: "foo", name: "bar").should == "foo"
-      Pa.build_path2(fname: "foo", ext: "bar").should == "foo" 
-      Pa.build_path2(fname: "foo", fext: ".bar").should == "foo" 
-      Pa.build_path2(fext: "foo", ext: "bar").should == "foo" 
-    end
+    expect(Pa._wrap("foo")).to eq(Pa("foo"))
+    expect(Pa._wrap(["guten", "tag"])).to eq([Pa("guten"), Pa("tag")])
   end
 
   describe ".get" do
@@ -43,144 +14,219 @@ describe Pa do
       def path.path
         "hello"
       end
-      Pa.get(path).should == "hello"
+      expect(Pa.get(path)).to eq("hello")
     end
 
     it "get path from a string" do
-      Pa.get("foo").should == "foo"
+      expect(Pa.get("foo")).to eq("foo")
     end
 
     it "get nil from nil" do
-      Pa.get(nil).should == nil
+      expect(Pa.get(nil)).to eq(nil)
     end
 
     it "otherwise raise ArgumentError" do
-      lambda { Pa.get([]) }.should raise_error(ArgumentError)
+      expect{ Pa.get([]) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ".absolute2" do
+    it do
+      expect(Pa.absolute2("a.txt")).to eq(File.join(File.absolute_path(".", "."), "a.txt")) # rbx
+    end
+  end
+
+  describe ".dir2" do
+    it do
+      expect(Pa.dir2("/home/foo.txt")).to eq("/home")
+      expect(Pa.dir2("foo.txt")).to eq(".")
+    end
+  end
+
+  describe ".dir_strict2" do
+    it do
+      expect(Pa.dir_strict2("foo.txt")).to eq("")
+      expect(Pa.dir_strict2("./foo.txt")).to eq(".")
+      expect(Pa.dir_strict2("../foo.txt")).to eq("..")
+      expect(Pa.dir_strict2("/foo.txt")).to eq("/")
+    end
+  end
+
+  describe ".base2" do
+    it do
+      expect(Pa.base2("foo.txt")).to eq("foo.txt")
+      expect(Pa.base2("/home/foo.txt")).to eq("foo.txt")
+    end
+
+
+    it "(ext: true)" do
+			expect(Pa.base2("/home/foo.bar", ext: true)).to eq(["foo", "bar"])
+    end
+  end
+
+  describe ".base" do
+    it do
+      expect(Pa.base("/home/foo.txt")).to eq(Pa("foo.txt"))
+			expect(Pa.base("/home/foo.bar", ext: true)).to eq([Pa("foo"), "bar"])
+    end
+  end
+
+  describe ".name2" do
+    it do
+      expect(Pa.name2("foo.txt")).to eq("foo")
+      expect(Pa.name2("/home/foo.txt")).to eq("foo")
+    end
+  end
+
+  describe ".ext2" do
+    it do
+      expect(Pa.ext2("foo.txt")).to eq(".txt")
+      expect(Pa.ext2("foo")).to eq("")
+      expect(Pa.ext2("/home/foo.txt")).to eq(".txt")
+    end
+  end
+
+  describe ".fext2" do
+    it do
+      expect(Pa.fext2("foo.txt")).to eq("txt")
+      expect(Pa.fext2("foo")).to eq("")
+      expect(Pa.fext2("/home/foo.txt")).to eq("txt")
     end
   end
 
   describe "split2" do
     it "split a path into two part: dirname and basename" do
-      Pa.split2("/home/b/a.txt").should == ["/home/b", "a.txt"]
+      expect(Pa.split2("/home/b/a.txt")).to eq(["/home/b", "a.txt"])
     end
 
     it "with :all options: split all parts" do
-      Pa.split2("/home/b/a.txt", :all => true).should == ["/", "home", "b", "a.txt"]
+      expect(Pa.split2("/home/b/a.txt", :all => true)).to eq(["/", "home", "b", "a.txt"])
     end
   end
 
   describe "split" do
     it "is a special case" do
-      Pa.split("/home/b/a.txt").should == [Pa("/home/b"), "a.txt"]
+      expect(Pa.split("/home/b/a.txt")).to eq([Pa("/home/b"), "a.txt"])
     end
   end
 
   describe ".join2" do
     it "join a path" do
-      Pa.join2("/a", "b").should == "/a/b"
+      expect(Pa.join2("/a", "b")).to eq("/a/b")
     end
 
     it "skip nil values" do
-      Pa.join2("/a", "b", nil).should == "/a/b"
+      expect(Pa.join2("/a", "b", nil)).to eq("/a/b")
     end
 
     it "skip empty values" do
-      Pa.join2("/a", "b", "").should == "/a/b"
+      expect(Pa.join2("/a", "b", "")).to eq("/a/b")
     end
   end
 
-  describe ".build2" do
-    it "works" do
-      Pa.build2("/home/guten.avi"){ |p| "#{p.dir}/foo.#{p.ext}" }.should == "/home/foo.avi"
-      Pa.build2(dir: "/home", name: "guten", ext: "avi").should == "/home/guten.avi"
-      Pa.build2(path: "/home/guten.avi"){ |p| "#{p.dir}/foo.#{p.ext}" }.should == "/home/foo.avi"
-    end
-  end
-
-  describe "class DELEGATE_METHODS" do
-    it "works" do
-      Pa.stub(:build2){|arg| arg }
-
-      Pa.build("foo").should == Pa("foo")
+  describe "DELEGATE_CLASS_METHODS" do
+    it do
+      Pa.stub(:dir2) { "foo" }
+      expect(Pa.dir).to eq(Pa("foo"))
     end
   end
 
   describe "#initilaize" do
     it "support ~/foo path" do
-      Pa.new("~/foo").should == Pa("#{ENV['HOME']}/foo")
+      expect(Pa.new("~/foo")).to eq(Pa("#{ENV['HOME']}/foo"))
     end
   end
 
-  it "#absolute2" do
-    Pa.new("foo.avi").absolute2.should == File.join(File.absolute_path("."), "foo.avi")
-  end
+  describe "DELEGATE_ATTR_METHODS2" do
+    it do
+      Pa.stub(:dir2) { "foo" }
 
-  it "#dir2" do
-    Pa.new("foo.avi").dir2.should == "."
+      a = Pa("foo")
+      expect(a.dir2).to eq("foo")
+      expect(a.instance_variable_get(:@dir2)).to eq("foo")
+    end
   end
 
-  it "#dir_strict2" do
-    Pa.new("foo.avi").dir_strict2.should == ""
-    Pa.new("./foo.avi").dir_strict2.should == "."
-    Pa.new("../foo.avi").dir_strict2.should == ".."
-    Pa.new("/foo.avi").dir_strict2.should == "/"
+  describe "DELEGATE_ATTR_METHODS" do
+    it do
+      a = Pa("foo")
+      a.stub(:dir2) { "foo" }
+
+      expect(a.dir).to eq(Pa("foo"))
+      expect(a.instance_variable_get(:@dir)).to eq(Pa("foo"))
+    end
   end
 
-  it "#base2" do
-    Pa.new("foo.avi").base2.should == "foo.avi"
+  describe "DELEGATE_METHODS2" do
+    it do
+      Pa.stub(:join2) { "foo" }
+
+      expect(Pa("foo").join2).to eq("foo")
+    end
   end
 
-  it "#name2" do
-    Pa.new("foo.avi").name2.should == "foo"
+  describe "DELEGATE_METHODS" do
+    it do
+      Pa.stub(:join2) { "foo" }
+
+      expect(Pa("foo").join).to eq(Pa("foo"))
+    end
   end
 
-  it "#ext2" do
-    Pa.new("foo.avi").ext2.should == "avi"
-    Pa.new("foo").ext2.should == ""
+  describe "DELEGATE_TO_PATH2" do
+    it do
+      a = Pa("foo")
+      a.path.stub("sub"){ "bar" }
+
+      expect(a.sub2).to eq("bar")
+    end
   end
 
-  it "#fext2" do
-    Pa.new("foo.avi").fext2.should == ".avi"
-    Pa.new("foo").ext2.should == ""
+  describe "DELEGATE_TO_PATH" do
+    it do
+      a = Pa("foo")
+      a.path.stub("start_with?"){ "bar" }
+
+      expect(a.start_with?).to eq("bar")
+    end
   end
 
-  it "#inspect" do
-    Pa.new("/foo/bar.avi").inspect.should =~ /path|absolute/
+  describe "#inspect" do
+    it do
+      expect(Pa("/foo/bar.txt").inspect).to match(/path|absolute/)
+    end
   end
 
-  it "#to_s" do
-    Pa.new("bar.avi").to_s.should == "bar.avi"
+  describe "#to_s" do
+    it do
+      expect(Pa("bar.txt").to_s).to eq("bar.txt")
+    end
   end
 
-  it "#replace" do
-    a = Pa.new("/home/guten")
-    a.replace "/bar/foo.avi"
-
-    a.path.should == "/bar/foo.avi"
-    a.absolute2.should == "/bar/foo.avi"
-    a.dir2.should == "/bar"
-    a.fname2.should == "foo.avi"
-    a.base2.should == "foo.avi"
-    a.name2.should == "foo"
-    a.ext2.should == "avi"
-    a.fext2.should == ".avi"
+  describe "#replace" do
+    it do
+      a = Pa("/home/guten")
+      a.replace "/bar/foo.txt"
+
+      expect(a.path     ).to eq("/bar/foo.txt")
+      expect(a.absolute2).to eq("/bar/foo.txt")
+      expect(a.dir2     ).to eq("/bar")
+      expect(a.base2    ).to eq("foo.txt")
+      expect(a.name2    ).to eq("foo")
+      expect(a.ext2     ).to eq(".txt")
+      expect(a.fext2    ).to eq("txt")
+    end
   end
 
 	describe "#<=>" do
 		it "runs ok" do
-			(Pa("/home/b") <=> Pa("/home/a")).should == 1
+			expect(Pa("/home/b") <=> Pa("/home/a")).to eq(1)
 		end
 	end
 
 	describe "#+" do
 		it "runs ok" do
-			(Pa("/home")+"~").should == Pa("/home~")
-		end
-	end
-
-	describe "#sub2" do
-		it "runs ok" do
-			Pa("/home/foo").sub2(/o/,"").should == "/hme/foo"
+			expect(Pa("/home")+"~").to eq(Pa("/home~"))
 		end
 	end
 
@@ -188,13 +234,7 @@ describe Pa do
 		it "runs ok" do
 			pa = Pa("/home/foo")
 			pa.sub!(/o/,"")
-			pa.should == Pa("/hme/foo")
-		end
-	end
-
-	describe "#gsub2" do
-		it "runs ok" do
-			Pa("/home/foo").gsub2(/o/,"").should == "/hme/f"
+			expect(pa).to eq(Pa("/hme/foo"))
 		end
 	end
 
@@ -202,67 +242,40 @@ describe Pa do
 		it "runs ok" do
 			pa = Pa("/home/foo")
 			pa.gsub!(/o/,"")
-			pa.should == Pa("/hme/f")
-		end
-	end
-
-	describe "#match" do
-		it "runs ok" do
-			Pa("/home/foo").match(/foo/)[0].should == "foo"
-		end
-	end
-
-	describe "#start_with?" do
-		it "runs ok" do
-			Pa("/home/foo").start_with?("/home").should be_true
-		end
-	end
-
-	describe "#end_with?" do
-		it "runs ok" do
-			Pa("/home/foo").end_with?("foo").should be_true
+			expect(pa).to eq(Pa("/hme/f"))
 		end
 	end
 
 	describe "#=~" do
 		it "runs ok" do
-			(Pa("/home/foo") =~ /foo/).should be_true
+			expect((Pa("/home/foo") =~ /foo/)).to be_true
 		end
 	end
 
-  describe "#build2" do
-    it "works" do
-      Pa.new("/home/guten.avi").build2(path: "/foo/bar.avi").should == "/foo/bar.avi"
-      Pa.new("/home/guten.avi").build2(dir: "foo").should == "foo/guten.avi"
-      Pa.new("/home/guten.avi").build2(fname: "bar").should == "/home/bar"
-      Pa.new("/home/guten.avi").build2(base: "bar").should == "/home/bar"
-      Pa.new("/home/guten.avi").build2(name: "bar").should == "/home/bar.avi"
-      Pa.new("/home/guten.avi").build2(ext: "ogg").should == "/home/guten.ogg"
-      Pa.new("/home/guten.avi").build2(fext: ".ogg").should == "/home/guten.ogg"
-      Pa.new("/home/guten.avi").build2(dir: "foo", name: "bar", ext: "ogg").should == "foo/bar.ogg"
-    end
-
-    it "percedure" do
-      Pa.new("/home/guten.avi").build2(path: "foo", fname: "bar").should == "foo"
-      Pa.new("/home/guten.avi").build2(fname: "foo", name: "bar").should == "/home/foo"
-      Pa.new("/home/guten.avi").build2(fname: "foo", ext: "ogg").should == "/home/foo"
-      Pa.new("/home/guten.avi").build2(fname: "foo", fext: ".ogg").should == "/home/foo"
-      Pa.new("/home/guten.avi").build2(fext: ".ogg", ext: "mp3").should == "/home/guten.ogg"
+  describe "#change2" do
+    before :all do
+      @a = Pa("/home/a.txt")
     end
-  end
 
-  describe "instance DELEGATE_METHODS2" do
-    it "works" do
-      Pa.stub(:join2) { "foo" }
-      Pa.new("foo").join2.should == "foo"
+    it do
+      expect(@a.change2(path: "foo")).to eq("foo")
+      expect(@a.change2(dir: "foo")).to eq("foo/a.txt")
+      expect(@a.change2(base: "bar")).to eq("/home/bar")
+      expect(@a.change2(name: "bar")).to eq("/home/bar.txt")
+      expect(@a.change2(ext: ".epub")).to eq("/home/a.epub")
     end
-  end
 
-  describe "instance DELEGATE_METHODS" do
-    it "works" do
-      Pa.stub(:build2) { "foo" }
+    it "(complex)" do
+      expect(@a.change2(dir: "foo", base: "bar")).to eq("foo/bar")
+      expect(@a.change2(dir: "foo", name: "bar", ext: ".epub")).to eq("foo/bar.epub")
+      expect(@a.change2(dir: "foo", name: "bar")).to eq("foo/bar.txt")
+      expect(@a.change2(name: "bar", ext: ".epub")).to eq("/home/bar.epub")
+    end
 
-      Pa.new("foo").build.should == Pa("foo")
+    it "has a percudure" do
+      expect(@a.change2(path: "foo", dir: "bar")).to eq("foo")
+      expect(@a.change2(base: "foo", name: "bar")).to eq("/home/foo")
+      expect(@a.change2(base: "foo", ext: ".ogg")).to eq("/home/foo")
     end
   end
 end