tagen 1.0.0 → 1.0.1

data/version.rb

@@ -2,7 +2,7 @@ module Tagen
 	module VERSION
 		MAJOR = 1
 		MINOR = 0
-		PATCH = 0
+		PATCH = 1
 
 		IS = [MAJOR, MINOR, PATCH].join(".") 
 	end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Guten
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-07 00:00:00 +08:00
+date: 2011-06-08 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -81,11 +81,6 @@ files:
 - lib/tagen/core/numeric.rb
 - lib/tagen/core/object.rb
 - lib/tagen/core/open_option.rb
-- lib/tagen/core/pa.rb
-- lib/tagen/core/pa/cmd.rb
-- lib/tagen/core/pa/dir.rb
-- lib/tagen/core/pa/path.rb
-- lib/tagen/core/pa/state.rb
 - lib/tagen/core/process.rb
 - lib/tagen/core/re.rb
 - lib/tagen/core/string.rb

data/lib/tagen/core/pa.rb

@@ -1,165 +0,0 @@
-=begin rdoc
-Pa(Path) is similary to Pathname, but more powerful.
-it combines fileutils, tmpdir, find, tempfile, File, Dir, Pathname
-
-all class methods support Pa as parameter.
-
-Examples:
----------
-	pa = Pa('/home/a.vim')
-	pa.dir  	#=> '/home'
-	pa.base 	#=> 'a.vim'
-	pa.name 	#=> 'a'
-	pa.ext  	#=> 'vim'
-	pa.fext		#=> '.vim'
-
-Filename parts:
----------
-	/home/guten.ogg
-	  base: guten.ogg
-	  dir: /home
-	  ext: ogg
-	  name: guten
-
-Additional method list
----------------------
-* Pa.absolute _alias from `File.absolute_path`_
-* Pa.expand _aliss from `File.expand_path`_
-
-=== create, modify path
-Example1:
-	pa = Pa('/home/foo')
-	pa.join('a.txt') #=> new Pa('/home/foo/a.txt')
-
-Example2:
-	pa1 = Pa('/home/foo/a.txt')
-	pa2 = Pa('/home/bar/b.txt')
-	pa1+'~' #=> new Pa('/home/foo/a.txt~')
-	Pa.join(pa1.dir, pa2.base) #=> '/home/foo/b.txt'
-
-Example3:
-	pa1 = Pa('/home/foo/a.txt')
-	pa2 = Pa('/home/bar')
-	pa2.join(pa1.base)  #=> new Pa('/home/bar/a.txt')
-		
-**Attributes**
-
-  name     abbr    description
-
-  path      p      
-  absolute  a      absolute path
-  dir       d      dirname of a path
-  base      b      basename of a path
-  name      n      filename of a path
-  ext       e      extname of a path,  return "" or "ogg"  
-  fext      fe     return "" or ".ogg"
-
-== used with rspec
-
-	File.exists?(path).should be_true
-	Pa(path).should be_exists
-
-=end
-class Pa 
-	Error = Class.new Exception
-	EUnkonwType = Class.new Error
-
-	attr_reader :path
-
-	# @param [String,#path] path
-	def initialize path
-		@path = path.respond_to?(:path) ? path.path : path
-		initialize_variables
-	end
-
-	chainable = Module.new do
-		def initialize_variables; end
-	end
-	include chainable
-
-	alias p path
-
-	# @param [String,#path]
-	# @return [Pa] the same Pa object
-	def replace path
-		@path = path.respond_to?(:path) ? path.path : path
-		initialize_variables
-	end
-
-	# return '#<Pa @path="foo", @absolute="/home/foo">'
-	#
-	# @return [String]
-	def inspect
-		ret="#<" + self.class.to_s + " "
-		ret += "@path=\"#{path}\", @absolute=\"#{absolute}\""
-		ret += " >"
-		ret
-	end
-
-	# return '/home/foo'
-	#
-	# @return [String] path
-	def to_s
-		@path
-	end
-
-	# missing method goes to Pa.class-method 
-	def method_missing(name, *args, &blk)
-		ret = self.class.__send__(name, path, *args, &blk)
-
-		case ret	
-
-		# e.g. readlink ..
-		when String
-			Pa(ret)
-
-		# e.g. directory? 
-		else
-			ret
-		end
-
-	end
-
-
-end
-
-class Pa
-module ClassMethods
-	UNDEFS = [:open, :fstat]
-
-	# missing method goes to File class method
-	def method_missing name, *args, &blk
-		raise NoMethodError, name.inspect if UNDEFS.include?(name)
-		return if args.size>1 
-		File.__send__ name, get(args[0]), &blk
-	end
-end
-end
-
-require_relative "pa/path"
-require_relative "pa/cmd"
-require_relative "pa/dir"
-require_relative "pa/state"
-class Pa
-  extend ClassMethods
-  extend ClassMethods::Path
-  extend ClassMethods::Dir
-  extend ClassMethods::State
-  extend ClassMethods::Cmd
-
-  include Path
-  include State
-end
-
-module Kernel
-private
-	# a very convient function.
-	# 
-	# @example
-	#   Pa('/home').exists? 
-	def Pa(path)
-		return path if Pa===path
-		Pa.new path
-	end
-end
-

data/lib/tagen/core/pa/cmd.rb

@@ -1,409 +0,0 @@
-=begin
-rm family
-	* rm     _rm file only_
-	* rmdir  _rm directory only_
-	* rm_r   _rm recurive, both file and directory_
-	* rm_if  _with condition, use rm_r_
-=== Example 
-  rm path # it's clear: remove a file
-  rmdir path #  it's clear: remove a directory
-=end
-class Pa
-module ClassMethods::Cmd
-
-	# chroot
-	# @see {Dir.chroot}
-	#
-	# @param [String] path
-	# @return [nil]
-	def chroot(path) Dir.chroot(get(path)) end
-
-	# touch a blank file
-	#
-	# @overload touch(*paths, o={})
-	#   @param [String] *paths
-	#   @param [Hash] o option
-	#   @option o [Fixnum,String] :mode
-	#   @option o [Boolean] :mkdir auto mkdir if path contained directory not exists.
-	#   @option o [Boolean] :force 
-	#   @return [nil]
-	def touch(*args) paths, o = args.extract_options; _touch(*paths, o) end
-
-	# touch force
-	# @see touch
-	#
-	# @overload touch_f(*paths, o={})
-	#   @return [nil]
-	def touch_f(*args) paths, o = args.extract_options; o[:force]=true; 	_touch(*paths, o) end
-
-	def _touch(paths, o)
-		o[:mode] ||= 0644
-		paths.map!{|v|get(v)}
-		paths.each {|path|
-			if File.exists?(path) 
-				o[:force] ? next : raise(Errno::EEXIST, "File exist -- #{path}")
-			end
-
-			mkdir(File.dirname(p)) if o[:mkdir]
-
-			if win32?
-				# win32 BUG. must f.write("") then file can be deleted.
-				File.open(p, "w"){|f| f.chmod(o[:mode]); f.write("")} 
-			else
-				File.open(p, "w"){|f| f.chmod(o[:mode])}
-			end
-		}
-	end
-	private :_touch
-
-	# make a directory
-	#
-	# @overload mkdir(*paths, o={})
-	#   @param [String, Pa] *paths
-	#   @param [Hash] o option
-	#   @option o [Fixnum] :mode
-	#   @option o [Boolean] :force
-	#   @return [nil]
-	def mkdir(*args) paths, o = args.extract_options; _mkdir(paths, o) end
-
-	# mkdir force
-	# @see mkdir
-	#
-	# @overload mkdir_f(*paths, o={})
-	#   @return [nil]
-	def mkdir_f(*args) paths, o = args.extract_options; o[:force]=true; _mkdir(paths, o) end
-
-	def _mkdir(paths, o)
-		o[:mode] ||= 0744
-		paths.map!{|v|get(v)}
-		paths.each {|p|
-			if File.exists?(p)
-				o[:force] ? next : raise(Errno::EEXIST, "File exist -- #{p}")
-			end
-
-			stack = []
-			until p == stack.last
-				break if File.exists?(p)
-				stack << p
-				p = File.dirname(p)
-			end
-
-			stack.reverse.each do |path|
-				Dir.mkdir(path)
-				File.chmod(o[:mode], path)
-			end
-		}
-	end
-	private :_mkdir
-
-	# make temp directory
-	#
-	# @param [Hash] o options
-	# @option o [Symbol] :prefix ("")
-	# @option o [Symbol] :suffix ("")
-	# @option o [Symbol] :tmpdir (ENV["TEMP"])
-	# @return [String] path
-	def mktmpdir(o={}, &blk) 
-		p = _mktmpname(o)
-		File.mkdir(p)
-		begin blk.call(p) ensure Dir.delete(p) end if blk
-		p
-	end # def mktmpdir
-
-	def home(user=nil) Dir.home end
-
-	# make temp file
-	# @see mktmpdir
-	#
-	# @param [Hash] o options
-	# @return [String] path
-	def mktmpfile(o={}, &blk) 
-		p = _mktmpname(o) 
-		begin blk.call(p) ensure File.delete(p) end if blk
-		p
-	end # mktmpfile
-
-	def _mktmpname(o={})
-		# :prefix :suffix :tmpdir
-		# $$-(time*100_000).to_i.to_s(36)
-		# parse o
-		o[:dir] ||= ENV["TEMP"]
-		o[:prefix] ||= ""
-		o[:suffix] ||= ""
-
-		# begin
-		collision = 0
-		path = "#{o[:dir]}/#{o[:prefix]}#{$$}-#{(Time.time*100_000).to_i.to_s(36)}"
-		orgi_path = path.dup
-		while File.exists?(path)
-			path = orgi_path+ collision.to_s
-			collision +=1
-		end
-		path << o[:suffix]
-
-		path
-	end # def mktmpname
-	private :_mktmpname
-
-	# rm file only
-	#
-	# @param [String] *paths support globbing
-	# @return [nil]
-	def rm *paths
-		paths, o = paths.extract_options
-		glob(*paths) { |pa|
-			if File.directory?(pa.p)
-				if o[:force]; next else raise Errno::EISDIR, "is a directory -- #{pa.p}" end
-			end
-			next if pa.directory?
-			File.delete(pa.p)
-		}
-	end
-
-	def rm_f *paths
-		paths, o = paths.extract_options
-		o[:force] = true
-		rm *paths, o
-	end
-
-	# rm directory only. still remove if directory is not empty.
-	#
-	# @param [String] *paths support globbing
-	# @return [nil]
-	def rmdir *paths
-		paths, o = paths.extract_options
-		glob(*paths) { |pa|
-			if not File.directory?(pa.p)
-				if o[:force]; next else raise Errno::ENOTDIR, "not a directory -- #{pa.p}" end
-			end
-			_rmdir(pa)
-		}
-	end
-
-	def rmdir_f *paths
-		paths, o = paths.extract_options
-		o[:force] = true
-		rmdir *paths, o
-	end
-
-	# rm recusive, rm both file and directory
-	#
-	# @see rm
-	# @return [nil]
-	def rm_r *paths
-		glob(*paths){ |pa|
-			File.directory?(pa.p)  ? _rmdir(pa) : File.delete(pa.p)
-		}
-	end
-	alias rm_rf rm_r
-
-
-	# rm_if(path) if condition is true
-	#
-	# @example
-	#   Pa.rm_if '/tmp/**/*.rb' do |pa|
-	#     pa.name == 'old'
-	#   end
-	#
-	# @param [String] *paths support globbing
-	# @yield [path]
-	# @yieldparam [Pa] path
-	# @yieldreturn [Boolean] rm_r path if true
-	# @return [nil]
-	def rm_if(*paths, &blk)
-		glob(*paths) do |pa|
-			rm_r pa if blk.call(pa)
-		end
-	end
-
-	# I'm recusive 
-	# param@ [Pa] path
-	def _rmdir(pa, o={})
-		return if not File.exists?(pa.p)
-		pa.each {|pa1|
-			File.directory?(pa1.p) ? _rmdir(pa1, o) : File.delete(pa1.p)
-		}
-		File.directory?(pa.p) ? Dir.rmdir(pa.p) : File.delete(pa.p)
-	end
-	private :_rmdir
-
-	# copy
-	#
-	# cp file dir
-	#  cp 'a', 'dir' #=> dir/a 
-	#  cp 'a', 'dir/a' #=> dir/a
-	#
-	# cp file1 file2 .. dir
-	#  cp ['a','b'], 'dir' #=> dir/a dir/b
-	#
-	# @example
-	#  cp '*', 'dir' do |src, dest, o|
-	#    skip if src.name=~'.o$'
-	#    dest.replace 'dirc' if src.name=="foo"
-	#    yield  # use yield to do the actuactal cp work
-	#  end
-	#
-	# @overload cp(src_s, dest, o)
-	#   @param [Array<String>, String] src_s support globbing
-	#   @param [String,Pa] dest
-	#   @param [Hash] o option
-	#   @option o [Boolean] :mkdir mkdir(dest) if dest not exists.
-	#   @option o [Boolean] :verbose puts cmd when execute
-	#   @option o [Boolean] :folsymlink follow symlink
-	#   @option o [Boolean] :force force dest file if dest is a file
-	#   @option o [Boolean] :special special copy, when cp a directory, only mkdir, not cp the directory's content, usefull in Pa.each_r
-	#   @return [nil]
-	# @overload cp(src_s, dest, o)
-	#   @yield [src,dest,o]
-	#   @return [nil]
-	def cp(src_s, dest, o={}, &blk)
-		srcs = glob(*Array.wrap(src_s)).map{|v| v.path}
-		dest = Pa.get(dest)
-
-		if o[:mkdir] and (not File.exists?(dest))
-			Pa.mkdir dest
-		end
-
-		# cp file1 file2 .. dir
-		if srcs.size>1 and (not File.directory?(dest))
-			raise Errno::ENOTDIR, "dest not a directory when cp more than one src -- #{dest}"  
-		end
-
-		srcs.each do |src|
-			dest1 = File.directory?(dest) ? File.join(dest, File.basename(src)) : dest
-
-			if blk
-				blk.call src, dest1, o, proc{_copy(src, dest1, o)}
-			else
-				_copy src, dest1, o
-			end
-
-		end
-	end
-
-	def cp_f src_s, dest, o={}, &blk
-		o[:force] = true
-		cp src_s, dest, o, &blk
-	end
-
-	# I'm recursive 
-	#
-	# @param [String] src
-	# @param [String] dest
-	def _copy(src, dest, o={})  
-		raise Errno::EEXIST, "dest exists -- #{dest}" if File.exists?(dest) and (not o[:force])
-
-		case type=File.ftype(src)
-
-		when "file", "socket"
-			puts "cp #{src} #{dest}" if o[:verbose]
-			File.copy_stream(src, dest)
-
-		when "directory"
-			begin
-				Pa.mkdir dest
-				puts "mkdir #{dest}" if o[:verbose]
-			rescue Errno::EEXIST
-			end
-
-			return if o[:special]
-
-			each(src) { |pa|
-				_copy(pa.p, File.join(dest, File.basename(pa.p)), o)
-			}
-
-		when "link" # symbol link
-			if o[:folsymlink] 
-				_copy(Pa.readlink(src), dest) 
-			else
-				Pa.symln(Pa.readlink(src), dest, force: true)	
-				puts "symlink #{src} #{dest}" if o[:verbose]
-			end
-
-		when "unknow"
-			raise EUnKnownType, "Can't handle unknow type(#{:type}) -- #{src}"
-		end
-
-		# chmod chown utime
-		src_stat = o[:folsymlink] ? File.stat(src) : File.lstat(src)
-		begin
-			File.chmod(src_stat.mode, dest)
-			#File.chown(src_stat.uid, src_stat.gid, dest)
-			File.utime(src_stat.atime, src_stat.mtime, dest)
-		rescue Errno::ENOENT
-		end
-	end # _copy
-	private :_copy
-
-	# move, use rename for same device. and cp for cross device.
-	# @see cp
-	#
-	# @param [Hash] o option
-	# @option o [Boolean] :verbose
-	# @option o [Boolean] :mkdir
-	# @option o [Boolean] :fore
-	# @return [nil]
-	def mv(src_s, dest, o={}, &blk)
-		srcs = glob(*Array.wrap(src_s)).map{|v| get(v)}
-		dest = get(dest)
-
-		if o[:mkdir] and (not File.exists?(dest))
-			mkdir dest
-		end
-
-		# mv file1 file2 .. dir
-		if srcs.size>1 and (not File.directory?(dest))
-			raise Errno::ENOTDIR, "dest not a directory when mv more than one src -- #{dest}"  
-		end
-
-		srcs.each do |src|
-			dest1 = File.directory?(dest) ? File.join(dest, File.basename(src)) : dest
-
-			if blk
-				blk.call src, dest1, o, proc{_move(src, dest1, o)}
-			else
-				_move src, dest1, o
-			end
-
-		end
-	end
-
-	def mv_f src_s, dest, o={}, &blk
-		o[:force] = true
-		mv src_s, dest, o, &blk
-	end
-
-	# I'm recusive
-	#
-	# _move "file", "dir/file"
-	#
-	# @param [String] src
-	# @param [String] dest
-	def _move(src, dest, o)
-		raise Errno::EEXIST, "dest exists -- #{dest}" if File.exists?(dest) and (not o[:force])
-
-		# :force. mv "dir", "dira" and 'dira' exists and is a directory. 
-		if File.exists?(dest) and File.directory?(dest)
-				ls(src) { |pa|
-					dest1 = File.join(dest, File.basename(pa.p))
-					_move pa.p, dest1, o
-				}
-				Pa.rm_r src
-
-		else
-			begin
-				Pa.rm_r dest if o[:force] and File.exists?(dest)
-				puts "rename #{src} #{dest}" if o[:verbose]
-				File.rename(src, dest)
-			rescue Errno::EXDEV # cross-device
-				_copy(src, dest, o)
-				Pa.rm_r src
-			end
-
-		end
-	end # def _move
-	private :_move
-
-
-end
-end

data/lib/tagen/core/pa/dir.rb

@@ -1,166 +0,0 @@
-=begin
-== ls family
-	* Dir[*path] _support globbing_
-	* Pa.glob(*path,o),(){} _support globbing with option and block_
-	* each(path),(){} each_r(),(){} _support Enumerator. not support globbing_
-	* ls(path) ls_r(path) _sample ls. not support globbing._
-=== Example	
-	each(".") do |pa|
-	  p pa
-	end
-
-	each(".").with_index(2){|pa,i| ... }
-=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{|v|v.delete(*%w(. ..))}
-		ret.map!{|v|Pa(v)}
-
-		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
-	#
-	# @return [Array<String>]
-	def ls(*args)
-		each(*args).with_object([]){|pa,m| m<<pa.b}
-	end
-
-	# ls with recursive
-	# @see each
-	#
-	# @return [Array<String>]
-	def ls_r(*args)
-		each_r(*args).with_object([]){|pa,m| m<<pa.base}
-	end
-
-end
-end

data/lib/tagen/core/pa/path.rb

@@ -1,301 +0,0 @@
-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")
-
-== methods from String
-* +
-* [g]sub[!] match =~ 
-* start_with? end_with?
-
-=end
-module Path
-	# @return [String] 
-	attr_reader :absolute, :dir, :base, :name, :ext, :fext, :short
-
-	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
-
-	alias a absolute
-	alias d dir
-	alias	b base
-	alias n name
-	alias fname base
-	alias fn fname
-	alias e ext
-	alias fe fext
-
-	def short
-		@short ||= Pa.shorten(@path) 
-	end
-
-	# @return [Pa] absolute path
-	def absolute2() @absolute2 ||= Pa(absolute) end
-
-	# @return [Pa] dirname
-	# @example
-	#   Pa(__FILE__).dirname.join('.opts')
-	def dir2() @dir2 ||= Pa(dir) 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
-end
-

data/lib/tagen/core/pa/state.rb

@@ -1,67 +0,0 @@
-class Pa
-module ClassMethods::State
-
-	# @see File.chmod
-	def chmod(mode, *paths) paths.map!{|v|get(v)}; File.chmod(mode, *paths) end
-
-	# @see File.lchmod
-	def lchmod(mode, *paths) paths.map!{|v|get(v)}; File.lchmod(mode, *paths) end
-
-	# @see File.chown
-	def chown(user, group=nil, *paths) paths.map!{|v|get(v)}; File.chown(user, group, *paths) end
-
-	# @see File.lchown
-	def lchown(user, group=nil, *paths) paths.map!{|v|get(v)}; File.lchown(user, group, *paths) end
-
-	# @see File.utime
-	def utime(atime, mtime, *paths) paths.map!{|v|get(v)}; File.utime(atime, mtime, *paths) end
-
-
-	# get file type
-	#
-	# file types:
-	#   "chardev" "blockdev" "symlink" ..
-	#
-	# @param [String] path
-	# @return [String] 
-	def type(path)
-		case (t=File.ftype(get(path)))
-		when "characterSpecial"
-			"chardev"
-		when "blockSpecial"
-			"blockdev"
-		when "link"
-			"symlink"
-		else
-			t
-		end
-	end # def type
-
-
-	# is path a mountpoint?
-	#
-	# @param[String] path
-	# @return [Boolean]
-	def mountpoint? path
-		path=get(path)
-		begin
-			stat1 = File.lstat(path)
-			stat2 = File.lstat(File.join(path, '..'))
-			stat1.dev == stat2.dev && stat1.ino == stat2.ino || stat1.dev != stat2.dev
-		rescue Errno::ENOENT
-			false
-		end
-	end
-end
-
-module State
-	def chmod(mode); File.chmod(mode, path) end
-	def lchmod(mode); File.lchmod(mode, path) end
-	def chown(uid, gid=nil); File.chown(uid, gid, path) end
-	def lchown(uid, gid=nil); File.lchown(uid, gid, path) end
-	def utime(atime, mtime); File.utime(atime, mtime, path) end
-end
-
-end
-
-