pa 1.0.3 → 1.1.3

data/lib/pa/dir.rb

@@ -10,9 +10,9 @@
 		filea
 		dira/fileb
 
-	ls("tmp") => ["filea", "dira"]
-	ls_r("tmp") => ["filea", "dira", "dira/fileb"]
-	ls_r("tmp"){|pa, rel| rel.count('/')==1} => ["dira/fileb"]
+	ls2("tmp") => ["filea", "dira"]
+	ls2_r("tmp") => ["filea", "dira", "dira/fileb"]
+	ls2_r("tmp"){|path, rel| rel.count('/')==1} => ["dira/fileb"]
 
 	each("tmp") => Enumerate<Pa>
 	each("tmp") {|pa| Pa.rm pa if pa.file?}
@@ -20,176 +20,216 @@
 
 =end
 class Pa
-module ClassMethods::Dir
-
-	# path globbing, exclude '.' '..' for :dotmatch
-	# @note glob is * ** ? [set] {a,b}
-	#
-	# @overload glob(*paths, o={})
-	# 	@param [String] path
-	# 	@param [Hash] o option
-	# 	@option o [Boolean] :dotmatch glob not match dot file by default.
-	# 	@option o [Boolean] :pathname wildcard doesn't match /
-	# 	@option o [Boolean] :noescape makes '\\' ordinary
-	# 	@return [Array<Pa>] 
-	# @overload glob(*paths, o={})
-	#   @yieldparam [Pa] path
-	#   @return [nil]
-	def glob(*args, &blk)
-		paths, o = args.extract_options
-		paths.map!{|v|get(v)}
-
-		flag = 0
-		o.each do |option, value|
-			flag |= File.const_get("FNM_#{option.upcase}") if value
-		end
-
-		ret = Dir.glob(paths, flag)
-
-		# delete . .. for '.*'
-		ret.tap{|paths| %w(. ..).each{|v| paths.delete(v)}}
-		ret.map!{|path|Pa(path)}
-
-		if blk
-			ret.each {|pa|
-				blk.call pa
-			}
-		else
-			ret
-		end
-	end
-
-	# is directory empty?
-	#
-	# @param [String] path
-	# @return [Boolean]
-	def empty?(path) Dir.entries(get(path)).empty? end
-
-	# traverse directory 
-	# @note raise Errno::ENOTDIR, Errno::ENOENT  
-	#
-	# @example
-	#   each '.' do |pa|
-	#     p pa.path #=> "foo" not "./foo"
-	#   end
-	#   # => '/home' ..
-	#
-	#  each('.', error: true).with_object([]) do |(pa,err),m|
-	#    ...
-	#  end
-	#
-	# @overload each(path=".", o={})
-	#   @param [String,Pa] path
-	#   @prarm [Hash] o
-	#   @option o [Boolean] :nodot (false) include dot file
-	#   @option o [Boolean] :nobackup (false) include backup file
-	#   @option o [Boolean] :error (false) yield(pa, err) instead of raise Errno::EPERM when Dir.open(dir)
-	#   @return [Enumerator<Pa>]
-	# @overload each(path=".", o={})
-	#   @yieldparam [Pa] path
-	#   @return [nil]
-	def each(*args, &blk) 
-		return Pa.to_enum(:each, *args) unless blk
-
-		(path,), o = args.extract_options
-		path = path ? get(path) : "."
-		raise Errno::ENOENT, "`#{path}' doesn't exists."  unless File.exists?(path)
-		raise Errno::ENOTDIR, "`#{path}' not a directoyr."  unless File.directory?(path)
-
-		begin
-			dir = Dir.open(path)
-		rescue Errno::EPERM => err
-		end
-		raise err if err and !o[:error]
-
-		while (entry=dir.read)
-			next if %w(. ..).include? entry
-			next if o[:nodot] and entry=~/^\./
-			next if o[:nobackup] and entry=~/~$/
-
-			# => "foo" not "./foo"
-			pa = path=="." ? Pa(entry) : Pa(File.join(path, entry))
-			if o[:error]
-				blk.call pa, err  
-			else
-				blk.call pa
-			end
-		end
-	end
-
-	# each with recursive
-	# @see each
-	#
-	# * each_r() skip Exception
-	# * each_r(){pa, err}
-	#
-	# @overload each_r(path=".", o={})
-	#   @return [Enumerator<Pa>]
-	# @overload each_r(path=".", o={})
-	#   @yieldparam [Pa] pa
-	#   @yieldparam [String] relative relative path
-	#   @yieldparam [Errno::ENOENT,Errno::EPERM] err 
-	#   @return [nil]
-	def each_r(*args, &blk)
-		return Pa.to_enum(:each_r, *args) if not blk
-
-		(path,), o = args.extract_options
-		path ||= "."
-
-		_each_r(path, "", o, &blk)
-	end
-
-	# @param [String] path
-	def _each_r path, relative, o, &blk
-		o.merge!(error: true)
-		Pa.each(path, o) do |pa1, err|
-			relative1 = Pa.join(relative, pa1.b) 
-
-			blk.call pa1, relative1, err
-
-			if pa1.directory?
-				_each_r(pa1.p, relative1, o, &blk)
-			end
-		end
-	end
-	private :_each_r
-
-	# list directory contents
-	# @see each
-	#
-	# block form is a filter.
-	#
-	# @Example
-	#   Pa.ls(".") {|pa, fname| pa.directory?} # list only directories
-	#
-	# @overload ls(path=".", o={})
-	# 	@return [Array<String>]
-	# @overload ls(path=".", o={})
-	#   @yieldparam [Pa] pa
-	#   @yieldparam [String] fname
-	#   @return [Array<String>]
-	def ls *args, &blk
-		blk ||= proc {true}
-		each(*args).with_object([]) { |pa,m| 
-			m<<pa.fname if blk.call(pa, pa.fname)
-		}
-	end
-
-	# ls with recursive
-	# @see ls
-	#
-	# @overload ls_r(path=".", o={})
-	# 	@return [Array<String>]
-	# @overload ls_r(path=".", o={})
-	#   @yieldparam [Pa] pa
-	#   @yieldparam [String] rel
-	#   @return [Array<String>]
-	def ls_r *args, &blk
-		blk ||= proc {true}
-		each_r(*args).with_object([]) { |(pa,rel),m| 
-			m<<rel if blk.call(pa, rel)
-		}
-	end
-
-end
+  module Dir
+    extend Util::Concern
+
+    module ClassMethods
+      # path globbing, exclude '.' '..' for :dotmatch
+      # @note glob is * ** ? [set] {a,b}
+      #
+      # @overload glob2(*paths, o={})
+      # 	@param [String] path
+      # 	@param [Hash] o option
+      # 	@option o [Boolean] :dotmatch glob not match dot file by default.
+      # 	@option o [Boolean] :pathname wildcard doesn't match /
+      # 	@option o [Boolean] :noescape makes '\\' ordinary
+      # 	@return [Array<String>] 
+      # @overload glob2(*paths, o={})
+      #   @yieldparam [String] path
+      #   @return [nil]
+      def glob2(*args, &blk)
+        paths, o = Util.extract_options(args)
+        paths.map!{|v|get(v)}
+
+        flag = 0
+        o.each do |option, value|
+          next if option==:use_pa
+          flag |= File.const_get("FNM_#{option.upcase}") if value
+        end
+
+        ret = ::Dir.glob(paths, flag)
+
+        # delete . .. for '.*'
+        %w(. ..).each {|v| ret.delete(v)}
+        ret = ret.map{|v| Pa(v)} if o[:use_pa]
+
+        if blk
+          ret.each {|pa|
+            blk.call pa
+          }
+        else
+          ret
+        end
+      end
+
+      def glob(*args, &blk)
+        args, o = Util.extract_options(args)
+        o[:use_pa] = true
+        glob2(*args, o, &blk)
+      end
+
+      # is directory empty?
+      #
+      # @param [String] path
+      # @return [Boolean]
+      def empty?(path)
+        ::Dir.entries(get(path)).empty? 
+      end
+
+      # traverse directory 
+      # @note raise Errno::ENOTDIR, Errno::ENOENT  
+      #
+      # @example
+      #   each '.' do |pa|
+      #     p pa.path #=> "foo" not "./foo"
+      #   end
+      #   # => '/home' ..
+      #
+      #  each('.', error: true).with_object([]) do |(pa,err),m|
+      #    ...
+      #  end
+      #
+      # @overload each(path=".", o={})
+      #   @param [String,Pa] path
+      #   @prarm [Hash] o
+      #   @option o [Boolean] :nodot (false) include dot file
+      #   @option o [Boolean] :nobackup (false) include backup file
+      #   @option o [Boolean] :error (false) yield(pa, err) instead of raise Errno::EPERM when Dir.open(dir)
+      #   @return [Enumerator<String>]
+      # @overload each(path=".", o={})
+      #   @yieldparam [String] path
+      #   @return [nil]
+      def each2(*args, &blk) 
+        return Pa.to_enum(:each2, *args) unless blk
+
+        (path,), o = Util.extract_options(args)
+        path = path ? get(path) : "."
+        raise Errno::ENOENT, "`#{path}' doesn't exists."  unless File.exists?(path)
+        raise Errno::ENOTDIR, "`#{path}' not a directoy."  unless File.directory?(path)
+
+        begin
+          dir = ::Dir.open(path)
+        rescue Errno::EPERM => err
+        end
+        raise err if err and !o[:error]
+
+        while (entry=dir.read)
+          next if %w(. ..).include? entry
+          next if o[:nodot] and entry=~/^\./
+          next if o[:nobackup] and entry=~/~$/
+
+          # => "foo" not "./foo"
+          pa = path=="." ? entry : File.join(path, entry)
+          pa = Pa(pa) if o[:use_pa]
+          if o[:error]
+            blk.call pa, err  
+          else
+            blk.call pa
+          end
+        end
+      end
+
+      def each(*args, &blk)
+        args, o = Util.extract_options(args)
+        o[:use_pa] = true
+        each2(*args, o, &blk)
+      end
+
+      # each with recursive
+      # @see each2
+      #
+      # * each2_r() skip Exception
+      # * each2_r(){path, relative, err}
+      #
+      # @overload each2_r(path=".", o={})
+      #   @return [Enumerator<String>]
+      # @overload each2_r(path=".", o={})
+      #   @yieldparam [String] path
+      #   @yieldparam [String] relative relative path
+      #   @yieldparam [Errno::ENOENT,Errno::EPERM] err 
+      #   @return [nil]
+      def each2_r(*args, &blk)
+        return Pa.to_enum(:each2_r, *args) if not blk
+
+        (path,), o = Util.extract_options(args)
+        path ||= "."
+
+        _each2_r(path, "", o, &blk)
+      end
+
+      def each_r(*args, &blk)
+        args, o = Util.extract_options(args)
+        o[:use_pa] = true
+        each2_r(*args, o, &blk)
+      end
+
+      # list directory contents
+      # @see each2
+      #
+      # block form is a filter.
+      #
+      # @Example
+      #   Pa.ls2(".") {|path, fname| Pa.directory?(path)} # list only directories
+      #
+      # @overload ls2(path=".", o={})
+      # 	@return [Array<String>]
+      # @overload ls2(path=".", o={})
+      #   @yieldparam [String] path
+      #   @yieldparam [String] fname
+      #   @return [Array<String>]
+      def ls2(*args, &blk)
+        blk ||= proc {true}
+        each2(*args).with_object([]) { |path,m| 
+          base = File.basename(path)
+          ret = blk.call(path, base)
+          m << base if ret
+        }
+      end
+
+      def ls(*args, &blk)
+        args, o = Util.extract_options(args)
+        o[:use_pa] = true
+        ls2(*args, o, &blk)
+      end
+
+      # ls2 with recursive
+      # @see ls2
+      #
+      # @overload ls2_r(path=".", o={})
+      # 	@return [Array<String>]
+      # @overload ls2_r(path=".", o={})
+      #   @yieldparam [Pa] pa
+      #   @yieldparam [String] rel
+      #   @return [Array<String>]
+      def ls2_r(*args, &blk)
+        blk ||= proc {true}
+        each2_r(*args).with_object([]) { |(path,rel),m| 
+          m<<rel if blk.call(path, rel)
+        }
+      end
+
+      def ls_r(*args, &blk)
+        args, o = Util.extract_options(args)
+        ls2_r(*args, o, &blk)
+      end
+
+    private
+      # @param [String] path
+      def _each2_r(path, relative, o, &blk)
+        o.merge!(error: true)
+        Pa.each2(path, o) do |path1, err|
+          # fix for File.join with empty string
+          joins=[ relative=="" ? nil : relative, File.basename(path1)].compact
+          relative1 = File.join(*joins)
+
+          path1 = Pa(path1) if o[:use_pa]
+          blk.call path1, relative1, err
+
+          if File.directory?(path1)
+            _each2_r(path1, relative1, o, &blk)
+          end
+        end
+      end
+    end
+  end
 end

data/lib/pa/path.rb

@@ -1,225 +1,9 @@
-class Pa
-	NAME_EXT_PAT = /^(.+?)(?:\.([^.]+))?$/
-module ClassMethods::Path
-
-	# alias from File.absolute_path
-	# @param [String,Pa] path
-	# @return [String]
-	def absolute(path); File.absolute_path(get(path)) end
-
-	# alias from File.expand_path
-	# @param [String,Pa] path
-	# @return [String]
-	def expand(path); File.expand_path(get(path)) end
-
-	# shorten a path,
-	# convert /home/user/file to ~/file
-	#
-	# @param [String,Pa] path
-	# @return [String]
-	def shorten(path);
-		get(path).sub(%r!^#{Regexp.escape(ENV["HOME"])}!, "~")
-	end
-
-	# return current work directory
-	# @return [String] path
-	def pwd() Dir.getwd end
-
-	# @return [Pa] path
-	def pwd2() Pa(Dir.getwd) end
-
-	# change directory
-	#
-	# @param [String,Pa] path
-	def cd(path=ENV["HOME"], &blk) Dir.chdir(get(path), &blk) end
-
-	# get path of an object. 
-	#
-	# return obj#path if object has a 'path' instance method
-	#
-	# @param [String,#path] obj
-	# @return [String,nil] path
-	def get obj
-		if obj.respond_to?(:path)
-			obj.path
-		elsif String === obj 
-			obj
-		else
-			raise Error, "not support type -- #{obj.inspect}(#{obj.class})"
-		end
-	end
-
-	# extname of a path
-	#
-	# @example
-	# 	"a.ogg" => "ogg"
-	# 	"a" => nil
-	#
-	# @param [String,Pa] path
-	# @return [String]
-	def extname path
-		_, ext = get(path).match(/\.([^.]+)$/).to_a
-		ext
-	end
-
-	# is path an absolute path ?
-	#
-	# @param [String,Pa] path
-	# @return [Boolean]
-	def absolute?(path) path=get(path); File.absolute_path(path) == path end
-
-	# get a basename of a path
-	#
-	# @example
-	#   Pa.basename("foo.bar.c", ext: true)  #=> \["foo.bar", "c"]
-	#
-	# @param [String,Pa] name
-	# @param [Hash] o options
-	# @option o [Boolean, String] :ext (false) return \[name, ext] if true
-	#   
-	# @return [String] basename of a path unless o[:ext]
-	# @return [Array<String>] \[name, ext] if o[:ext].  
-	def basename(name, o={})
-		name = File.basename(get(name))
-		if o[:ext]
-			name, ext = name.match(NAME_EXT_PAT).captures
-			[ name, (ext || "")]
-		else
-			name
-		end
-	end
-	 
-	# split path
-	#
-	# @example
-	# 	path="/home/a/file"
-	# 	split(path)  #=> "/home/a", "file"
-	# 	split(path, :all)  #=> "/", "home", "a", "file"
-	#
-	# @param [String,Pa] name
-	# @param [Hash] o option
-	# @option o [Boolean] :all split all parts
-	# @return [Array<String>] 
-	def split(name, o={})
-		dir, fname = File.split(get(name))
-		ret = Array.wrap(basename(fname, o))
-
-		if o[:all]
-			loop do
-				dir1, fname = File.split(dir)
-				break if dir1 == dir
-				ret.unshift fname
-				dir = dir1
-			end
-		end
-		ret.unshift dir
-		ret
-	end
-
-	# join paths, skip nil and empty string.
-	#
-	# @param [*Array<String>] *paths
-	# @return [String]
-	def join *paths
-		paths.map!{|v|get(v)}
-
-		# skip nil
-		paths.compact!
-
-		# skip empty string
-		paths.delete("")
-
-		File.join(*paths)
-	end
-
-	# get parent path
-	# 
-	# @param [String,Pa] path
-	# @param [Fixnum] n up level
-	# @return [String]
-	def parent path, n=1
-		path = get(path)
-		n.times do
-			path = File.dirname(path)
-		end
-		path
-	end
-
-	# link
-	#
-	# @overload ln(src, dest)
-	# @overload ln([src,..], directory)
-	#
-	# @param [Array<String>, String] src_s support globbing
-	# @param [String,Pa] dest
-	# @param [Hash] o option
-	# @option o [Boolean] :force overwrite if exists.
-	# @return [nil]
-	def ln(src_s, dest, o={}) _ln(File.method(:link), src_s, dest, o) end
-
-	# ln force
-	#
-	# @see ln
-	# @return [nil]
-	def ln_f(src_s, dest, o) o[:force]=true; _ln(File.method(:link), src_s, dest, o) end
-
-	# symbol link
-	#
-	# @see ln
-	# @return [nil]
-	def symln(src_s, dest, o) _ln(File.method(:symlink), src_s, dest, o) end
-	alias symlink ln
-
-	# symln force
-	#
-	# @see ln
-	# @return [nil]
-	def symln_f(src_s, dest, o) o[:force]=true; _ln(File.method(:symlink), src_s, dest, o) end
-
-	# @param [Array,String,#path] src_s
-	# @param [String,#path] dest
-	def _ln(method, src_s, dest, o={})
-		dest = get(dest)
-		glob(*Array.wrap(src_s)) {|src|
-			src = get(src)
-			dest = File.join(dest, File.basename(src)) if File.directory?(dest)
-			Pa.rm_r(dest) if o[:force] and File.exists?(dest)
-			method.call(src, dest)
-		}	
-	end
-	private :_ln
-
-	# @see File.readlink
-	def readlink(path) File.readlink(get(path)) end
-
-	# is path a dangling symlink?
-	#
-	# a dangling symlink is a dead symlink.
-	#
-	# @param [String,Pa] path
-	# @return [Boolean]
-	def dangling? path
-		path=get(path)
-		if File.symlink?(path)
-			src = File.readlink(path)
-			not File.exists?(src)
-		else
-			nil
-		end
-	end # def dsymlink?
-
-	def realpath(path) File.realpath(get(path)) end
-
-end
-end
-
-class Pa
 =begin
 
 attribute absolute and dir return String, method absolute_path(), dirname() return Pa
-	
-	Pa("/home/a").dir #=> "/home"
-	Pa("/home/a").dirname #=> Pa("/home")
+  
+  Pa("/home/a").dir #=> "/home"
+  Pa("/home/a").dirname #=> Pa("/home")
 
 == methods from String
 * +
@@ -227,92 +11,284 @@ attribute absolute and dir return String, method absolute_path(), dirname() retu
 * start_with? end_with?
 
 =end
-module Path
-	# @return [String] 
-	attr_reader :absolute, :dir, :base, :name, :short
-
-	# @return [String] ext "", "ogg"
-	attr_reader :ext
-
-	# @return [String] ext "", ".ogg"
-	attr_reader :fext
-
-	attr_reader :absolute_pa, :dir_pa, :base_pa, :name_pa, :ext_pa, :fext_pa, :short_pa
-
-	def initialize_variables
-		super
-		@absolute = File.absolute_path(@path) 
-		@dir = File.dirname(@path)
-		@base = File.basename(@path) 
-		@name, @ext = @base.match(NAME_EXT_PAT).captures
-		@ext ||= ""
-		@fext = @ext.empty? ? "" : "."+@ext
-	end
-
-	def absolute_pa; @absolute_pa ||= Pa(@absolute) end
-	def dir_pa; @dir_pa ||= Pa(@dir) end
-	def base_pa; @base_pa ||= Pa(@base) end
-	def name_pa; @name_pa ||= Pa(@name) end
-	def ext_pa; @ext_pa ||= Pa(@ext) end
-	def fext_pa; @fext_pa ||= Pa(@fext) end
-	def short_pa; @short_pa ||= Pa(@short) end
-
-	alias a absolute
-	alias d dir
-	alias	b base
-	alias n name
-	alias fname base
-	alias fn fname
-	alias e ext
-	alias fe fext
-
-	alias a_pa absolute_pa
-	alias d_pa dir_pa
-	alias	b_pa base_pa
-	alias n_pa name_pa
-	alias fname_pa base_pa
-	alias fn_pa fname_pa
-	alias e_pa ext_pa
-	alias fe_pa fext_pa
-
-	def short
-		@short ||= Pa.shorten(@path) 
-	end
-
-	# add string to path
-	# 
-	# @example 
-	#  pa = Pa('/home/foo/a.txt')
-	#  pa+'~' #=> new Pa('/home/foo/a.txt~')
-	#
-	# @param [String] str
-	# @return [Pa]
-	def +(str) Pa(path+str) end
-
-	# @return [Pa]
-	def sub(*args,&blk) Pa(path.sub(*args,&blk)) end
-
-	# @return [Pa]
-	def gsub(*args,&blk) Pa(path.gsub(*args,&blk)) end
-
-	# @return [Pa]
-	def sub!(*args,&blk) self.replace path.sub(*args,&blk) end
-
-	# @return [Pa]
-	def gsub!(*args,&blk) self.replace path.gsub(*args,&blk) end
-
-	# @return [MatchData]
-	def match(*args,&blk) path.match(*args,&blk) end 
-
-	# @return [Boolean]
-	def start_with?(*args) path.start_with?(*args) end
-
-	# @return [Boolean]
-	def end_with?(*args) path.end_with?(*args) end
-
-	def =~(regexp) path =~ regexp end
-
-	def ==(other) self.path == other.path end
-end
+class Pa
+	NAME_EXT_PAT = /^(.+?)(?:\.([^.]+))?$/
+  module Path
+    extend Util::Concern
+    module ClassMethods
+      # get path of an object. 
+      #
+      # return obj#path if object has a 'path' instance method
+      #
+      # @param [String,#path] obj
+      # @return [String,nil] path
+      def get(obj)
+        if obj.respond_to?(:path)
+          obj.path
+        elsif String === obj 
+          obj
+        else
+          raise Error, "not support type -- #{obj.inspect}(#{obj.class})"
+        end
+      end
+
+      # return current work directory
+      # @return [String] path
+      def pwd2
+        Dir.getwd 
+      end
+
+      def dir2(path)
+        File.dirname(path)
+      end
+
+      # get a basename of a path
+      #
+      # @example
+      #   Pa.basename("foo.bar.c", ext: true)  #=> \["foo.bar", "c"]
+      #
+      # @param [String,Pa] name
+      # @param [Hash] o options
+      # @option o [Boolean, String] :ext (false) return \[name, ext] if true
+      #   
+      # @return [String] basename of a path unless o[:ext]
+      # @return [Array<String>] \[name, ext] if o[:ext].  
+      def base2(name, o={})
+        name = File.basename(get(name))
+        if o[:ext]
+          name, ext = name.match(NAME_EXT_PAT).captures
+          [ name, (ext || "")]
+        else
+          name
+        end
+      end
+
+      # ext of a path
+      #
+      # @example
+      # 	"a.ogg" => "ogg"
+      # 	"a" => nil
+      #
+      # @param [String,Pa] path
+      # @return [String]
+      def ext2 path
+        _, ext = get(path).match(/\.([^.]+)$/).to_a
+        ext
+      end
+
+
+      # alias from File.absolute_path
+      # @param [String,Pa] path
+      # @return [String]
+      def absolute2(path); File.absolute_path(get(path)) end
+
+      # alias from File.expand_path
+      # @param [String,Pa] path
+      # @return [String]
+      def expand2(path); File.expand_path(get(path)) end
+
+      # shorten2 a path,
+      # convert /home/user/file to ~/file
+      #
+      # @param [String,Pa] path
+      # @return [String]
+      def shorten2(path);
+        get(path).sub(%r!^#{Regexp.escape(ENV["HOME"])}!, "~")
+      end
+
+
+
+      # is path an absolute path ?
+      #
+      # @param [String,Pa] path
+      # @return [Boolean]
+      def absolute?(path) path=get(path); File.absolute_path(path) == path end
+       
+      # split path
+      #
+      # @example
+      # 	path="/home/a/file"
+      # 	split(path)  #=> "/home/a", "file"
+      # 	split(path, :all)  #=> "/", "home", "a", "file"
+      #
+      # @param [String,Pa] name
+      # @param [Hash] o option
+      # @option o [Boolean] :all split all parts
+      # @return [Array<String>] 
+      def split2(name, o={})
+        dir, fname = File.split(get(name))
+        ret = Util.wrap_array(basename(fname, o))
+
+        if o[:all]
+          loop do
+            dir1, fname = File.split(dir)
+            break if dir1 == dir
+            ret.unshift fname
+            dir = dir1
+          end
+        end
+        ret.unshift dir
+        ret
+      end
+
+      def split(*args)
+        dir, *names = split2(*args)
+        [ Pa(dir), *names]
+      end
+
+      # join paths, skip nil and empty string.
+      #
+      # @param [*Array<String>] *paths
+      # @return [String]
+      def join2(*paths)
+        paths.map!{|v|get(v)}
+
+        # skip nil
+        paths.compact!
+
+        # skip empty string
+        paths.delete("")
+
+        File.join(*paths)
+      end
+
+      # get parent path
+      # 
+      # @param [String,Pa] path
+      # @param [Fixnum] n up level
+      # @return [String]
+      def parent2(path, n=1)
+        path = get(path)
+        n.times do
+          path = File.dirname(path)
+        end
+        path
+      end
+
+      # is path a dangling symlink?
+      #
+      # a dangling symlink is a dead symlink.
+      #
+      # @param [String,Pa] path
+      # @return [Boolean]
+      def dangling? path
+        path=get(path)
+        if File.symlink?(path)
+          src = File.readlink(path)
+          not File.exists?(src)
+        else
+          nil
+        end
+      end # def dsymlink?
+
+      # real path
+      def real2(path) File.realpath(get(path)) end
+    end
+
+    module InstanceMethods
+      # @return [String] 
+      attr_reader :absolute2, :dir2, :base2, :name2, :short2
+
+      # @return [String] ext "", "ogg"
+      attr_reader :ext2
+
+      # @return [String] ext "", ".ogg"
+      attr_reader :fext2
+
+      def initialize_variables
+        super
+        @absolute2 = File.absolute_path(@path) 
+        @dir2 = File.dirname(@path)
+        @base2 = File.basename(@path) 
+        @name2, @ext2 = @base2.match(NAME_EXT_PAT).captures
+        @ext2 ||= ""
+        @fext2 = @ext2.empty? ? "" : "."+@ext2
+      end
+
+      alias a2 absolute2
+      alias d2 dir2
+      alias	b2 base2
+      alias n2 name2
+      alias fname2 base2
+      alias fn2 fname2
+      alias e2 ext2
+      alias fe2 fext2
+
+      # fix name,2 => String
+      alias name name2
+      alias fname fname2
+      alias ext ext2
+      alias fext fext2
+
+      alias fn fname
+      alias n name
+      alias e ext
+      alias fe fext
+
+      def short2
+        @short2 ||= Pa.shorten2(@path) 
+      end
+
+      # add string to path
+      # 
+      # @example 
+      #  pa = Pa('/home/foo/a.txt')
+      #  pa+'~' #=> new Pa('/home/foo/a.txt~')
+      #
+      # @param [String] str
+      # @return [Pa]
+      def +(str)
+        Pa(path+str)
+      end
+
+      # @return [String]
+      def sub2(*args,&blk)
+        path.sub(*args,&blk)
+      end
+
+      # @return [String]
+      def gsub2(*args,&blk)
+        path.gsub(*args,&blk)
+      end
+
+      # @return [Pa]
+      def sub!(*args,&blk)
+        self.replace path.sub(*args,&blk)
+      end
+
+      # @return [Pa]
+      def gsub!(*args,&blk)
+        self.replace path.gsub(*args,&blk)
+      end
+
+      # @return [MatchData]
+      def match(*args,&blk)
+        path.match(*args,&blk)
+      end 
+
+      # @return [Boolean]
+      def start_with?(*args)
+        path.start_with?(*args)
+      end
+
+      # @return [Boolean]
+      def end_with?(*args)
+        path.end_with?(*args)
+      end
+
+      def =~(regexp)
+        path =~ regexp 
+      end
+
+      def ==(other)
+        case other
+        when Pa
+          self.path == other.path
+        else
+          false
+        end
+      end
+    end
+  end
 end