pa 1.0.0

data/lib/pa/dir.rb

@@ -0,0 +1,195 @@
+=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	
+	tmp/
+		filea
+		dira/fileb
+
+	ls("tmp") => ["filea", "dira"]
+	ls_r("tmp") => ["filea", "dira", "dira/fileb"]
+	ls_r("tmp"){|pa, rel| rel.count('/')==1} => ["dira/fileb"]
+
+	each("tmp") => Enumerate<Pa>
+	each("tmp") {|pa| Pa.rm pa if pa.file?}
+	each("tmp").with_object([]){|pa,m| m<<pa.dir} #=> ["tmp", "tmp/dira"]
+
+=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
+end

data/lib/pa/path.rb

@@ -0,0 +1,301 @@
+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/pa/state.rb

@@ -0,0 +1,67 @@
+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
+
+