tagen 0.2.1 → 0.2.3

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

@@ -12,7 +12,7 @@
 	each(".").with_index(2){|pa,i| ... }
 =end
 class Pa
-module Directory
+module ClassMethods::Dir
 
 	# path globbing, exclude '.' '..' for :dotmatch
 	# @note glob is * ** ? [set] {a,b}
@@ -58,7 +58,7 @@ module Directory
 	def empty?(path) Dir.entries(get(path)).empty? end
 
 	# traverse directory 
-	# @note return if not a directory.
+	# @note raise Errno::ENOTDIR, Errno::ENOENT  
 	#
 	# @example
 	#   each '.' do |pa|
@@ -66,29 +66,46 @@ module Directory
 	#   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 (nil) include dot file
-	#   @option o [Boolean] :nobackup (nil) include backup file
+	#   @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) if not blk
+		return Pa.to_enum(:each, *args) unless blk
 
 		(path,), o = args.extract_options
-		pa = Pa(path || ".")
-		return if not pa.directory?
+		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]
 
-		Dir.foreach pa.p do |name|
-			next if %w(. ..).include? name
-			next if o[:nodot] and name=~/^\./
-			next if o[:nobackup] and name=~/~$/
+		while (entry=dir.read)
+			next if %w(. ..).include? entry
+			next if o[:nodot] and entry=~/^\./
+			next if o[:nobackup] and entry=~/~$/
 
 			# => "foo" not "./foo"
-			blk.call pa.p=="." ? Pa(name) : pa.join(name)
+			pa = path=="." ? Pa(entry) : Pa(File.join(path, entry))
+			if o[:error]
+				blk.call pa, err  
+			else
+				blk.call pa
+			end
 		end
 	end
 
@@ -101,7 +118,9 @@ module Directory
 	# @overload each_r(path=".", o={})
 	#   @return [Enumerator<Pa>]
 	# @overload each_r(path=".", o={})
-	#   @yield [pa,err]
+	#   @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
@@ -109,19 +128,21 @@ module Directory
 		(path,), o = args.extract_options
 		path ||= "."
 
-		_each_r(Pa(path), "", o, &blk)
+		_each_r(path, "", o, &blk)
 	end
 
-	def _each_r pa, relative, o, &blk
-		each(pa, o) do |pa1|
+	# @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
+
+			blk.call pa1, relative1, err
+
 			if pa1.directory?
-				_each_r(pa1, relative1, o, &blk)
+				_each_r(pa1.p, relative1, o, &blk)
 			end
 		end
-		rescue Errno::ENOENT, Errno::EPERM => e
-			blk.call pa, relative, e 
 	end
 	private :_each_r
 

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

@@ -1,37 +1,47 @@
 class Pa
-	module Path
+	NAME_EXT_PAT = /^(.+?)(?:\.([^.]+))?$/
+module ClassMethods::Path
 
 	# alias from File.absolute_path
-	# @param [String] path
+	# @param [String,Pa] path
 	# @return [String]
 	def absolute(path); File.absolute_path(get(path)) end
 
 	# alias from File.expand_path
-	# @param [String] 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
+
 	# print current work directory
 	# @return [String] path
 	def pwd() Dir.getwd end
 
 	# change directory
 	#
-	# @param [String] path
+	# @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,Pa] obj
+	# @param [String,#path] obj
 	# @return [String,nil] path
 	def get obj
-		return obj if String === obj
-
-		begin 
+		if obj.respond_to?(:path)
 			obj.path
-		rescue NoMethodError
+		elsif String === obj 
+			obj
+		else
 			raise Error, "not support type -- #{obj.inspect}(#{obj.class})"
 		end
 	end
@@ -42,7 +52,7 @@ class Pa
 	# 	"a.ogg" => "ogg"
 	# 	"a" => nil
 	#
-	# @param [String] path
+	# @param [String,Pa] path
 	# @return [String]
 	def extname path
 		_, ext = get(path).match(/\.([^.]+)$/).to_a
@@ -51,22 +61,25 @@ class Pa
 
 	# is path an absolute path ?
 	#
-	# @param [String] path
+	# @param [String,Pa] path
 	# @return [Boolean]
-	def absolute?(path) absolute(path) == get(path) end
+	def absolute?(path) path=get(path); File.absolute_path(path) == path end
 
 	# get a basename of a path
 	#
-	# @param [String] name
+	# @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 
-	# @return [Array<String,String>] \[name, ext] if o[:ext] is 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(/^(.+?)(\.[^.]+)?$/).to_a
+			name, ext = name.match(NAME_EXT_PAT).captures
 			[ name, (ext || "")]
 		else
 			name
@@ -80,7 +93,7 @@ class Pa
 	# 	split(path)  #=> "/home/a", "file"
 	# 	split(path, :all)  #=> "/", "home", "a", "file"
 	#
-	# @param [String] name
+	# @param [String,Pa] name
 	# @param [Hash] o option
 	# @option o [Boolean] :all split all parts
 	# @return [Array<String>] 
@@ -118,10 +131,15 @@ class Pa
 
 	# get parent path
 	# 
-	# @param [String] path
+	# @param [String,Pa] path
+	# @param [Fixnum] n up level
 	# @return [String]
-	def parent path
-		join(get(path), "..")
+	def parent path, n=1
+		path = get(path)
+		n.times do
+			path = File.dirname(path)
+		end
+		path
 	end
 
 	# link
@@ -130,7 +148,7 @@ class Pa
 	# @overload ln([src,..], directory)
 	#
 	# @param [Array<String>, String] src_s support globbing
-	# @param [String] dest
+	# @param [String,Pa] dest
 	# @param [Hash] o option
 	# @option o [Boolean] :force overwrite if exists.
 	# @return [nil]
@@ -155,13 +173,15 @@ class Pa
 	# @return [nil]
 	def symln_f(src_s, dest, o) o[:force]=true; _ln(File.method(:symlink), src_s, dest, o) end
 
-	# param
+	# @param [Array,String,#path] src_s
+	# @param [String,#path] dest
 	def _ln(method, src_s, dest, o={})
-		dest = Pa(dest)
+		dest = get(dest)
 		glob(*Array.wrap(src_s)) {|src|
-			dest = dest.join(src.b) if dest.directory?
-			rm_r(dest) if o[:force] and dest.exists?
-			method.call(src.p, dest.p)
+			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
@@ -169,22 +189,103 @@ class Pa
 	# @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] path
+	# @param [String,Pa] path
 	# @return [Boolean]
 	def dangling? path
 		path=get(path)
-		if symlink?(path)
-			src = readlink(path)
-			not exists?(src)
+		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 = Pa.absolute(@path) 
+		@dir = Pa.dirname(@path)
+		@base = Pa.basename(@path) 
+		@name, @ext = Pa.basename(@path, ext: true)
+		@fext = @ext.empty? ? "" : "."+@ext
+		@short = Pa.shorten(@path) 
+	end
+
+	alias a absolute
+	alias d dir
+	alias	b base
+	alias n name
+	alias e ext
+	alias fe fext
+
+	# @return [Pa] absolute path
+	def absolute_path() Pa(absolute) end
+	# @return [Pa] dirname
+	# @example
+	#   Pa(__FILE__).dirname.join('.opts')
+	def dirname() 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,5 +1,5 @@
 class Pa
-module State
+module ClassMethods::State
 
 	# @see File.chmod
 	def chmod(mode, *paths) paths.map!{|v|get(v)}; File.chmod(mode, *paths) end
@@ -8,10 +8,10 @@ module State
 	def lchmod(mode, *paths) paths.map!{|v|get(v)}; File.lchmod(mode, *paths) end
 
 	# @see File.chown
-	def chown(user, group, *paths) paths.map!{|v|get(v)}; File.chown(user, group, *paths) end
+	def chown(user, group=nil, *paths) paths.map!{|v|get(v)}; File.chown(user, group, *paths) end
 
 	# @see File.lchown
-	def lchown(user, group, *paths) paths.map!{|v|get(v)}; File.lchown(user, group, *paths) end
+	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
@@ -25,7 +25,7 @@ module State
 	# @param [String] path
 	# @return [String] 
 	def type(path)
-		case (t=ftype(get(path)))
+		case (t=File.ftype(get(path)))
 		when "characterSpecial"
 			"chardev"
 		when "blockSpecial"
@@ -45,12 +45,23 @@ module State
 	def mountpoint? path
 		path=get(path)
 		begin
-			stat1 = path.lstat
-			stat2 = path.parent.lstat
+			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
+
+

data/lib/tagen/core/string/pyformat.rb

@@ -11,12 +11,12 @@ a python like string format libraray.
 use "#{var}" is easy and quick in many cases, but some times we need a more powerful format support.
 
   "I like %s and %s" % %(apple, football)
-  "I like %{fruit} and %{sport}".format(%w(apple football))   # it has semantic meaning.
+  "I like %{fruit} and %{sport}".format('apple', 'football')   # it has semantic meaning.
 
 == Usage
 
   require "tagen/core"
-  "it costs %{:.2f} dollar".format(1.123) #=> "it costs 1.12 dollar"
+  "it costs %{:.2f} dollars".format(1.123) #=> "it costs 1.12 dollars"
 
 * support abritry-argument or hash-argument
   "%{} %{}".format(1,2) #=> "1 2"

data/lib/tagen/erb.rb

@@ -0,0 +1,35 @@
+require 'erb'
+
+class ERB
+	alias original_result result
+
+	# add locals support
+	#
+	# @example
+	#  erb = Erb.new("<%=a%>")
+	#  erb.result(nil, a: 1) #=> "1"
+	#
+	def result bind=nil, locals={}
+		bind ||= TOPLEVEL_BINDING
+		if locals.empty?
+			original_result bind
+		else
+			result_with_locals bind, locals
+		end
+	end
+
+	private
+	def result_with_locals bind, locals
+		@locals = locals
+		evalstr = <<-EOF
+def run_erb
+	#{locals.map{|k,v| "#{k} = @locals[:#{k}]"}.join(';')}
+	#{self.src}
+	_erbout
+end
+		EOF
+		eval evalstr
+		run_erb
+	end
+
+end