tagen 0.1.0

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

@@ -0,0 +1,190 @@
+class Pa
+	module Path
+
+	# alias from File.absolute_path
+	# @param [String] path
+	# @return [String]
+	def absolute(path); File.absolute_path(get(path)) end
+
+	# alias from File.expand_path
+	# @param [String] path
+	# @return [String]
+	def expand(path); File.expand_path(get(path)) end
+
+	# print current work directory
+	# @return [String] path
+	def pwd() Dir.getwd end
+
+	# change directory
+	#
+	# @param [String] 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
+	# @return [String,nil] path
+	def get obj
+		return obj if String === obj
+
+		begin 
+			obj.path
+		rescue NoMethodError
+			raise Error, "not support type -- #{obj.inspect}(#{obj.class})"
+		end
+	end
+
+	# extname of a path
+	#
+	# @example
+	# 	"a.ogg" => "ogg"
+	# 	"a" => nil
+	#
+	# @param [String] path
+	# @return [String]
+	def extname path
+		_, ext = get(path).match(/\.([^.]+)$/).to_a
+		ext
+	end
+
+	# is path an absolute path ?
+	#
+	# @param [String] path
+	# @return [Boolean]
+	def absolute?(path) absolute(path) == get(path) end
+
+	# get a basename of a path
+	#
+	# @param [String] 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
+	def basename(name, o={})
+		name = File.basename(get(name))
+		if o[:ext]
+			_, name, ext = name.match(/^(.+?)(\.[^.]+)?$/).to_a
+			[ 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] 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] path
+	# @return [String]
+	def parent path
+		join(get(path), "..")
+	end
+
+	# link
+	#
+	# @overload ln(src, dest)
+	# @overload ln([src,..], directory)
+	#
+	# @param [Array<String>, String] src_s support globbing
+	# @param [String] 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
+	def _ln(method, src_s, dest, o={})
+		dest = Pa(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)
+		}	
+	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] path
+	# @return [Boolean]
+	def dangling? path
+		path=get(path)
+		if symlink?(path)
+			src = readlink(path)
+			not exists?(src)
+		else
+			nil
+		end
+	end # def dsymlink?
+
+end
+end

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

@@ -0,0 +1,56 @@
+class Pa
+module 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, *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
+
+	# @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=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 = path.lstat
+			stat2 = path.parent.lstat
+			stat1.dev == stat2.dev && stat1.ino == stat2.ino || stat1.dev != stat2.dev
+		rescue Errno::ENOENT
+			false
+		end
+	end
+end
+end

data/lib/tagen/core/process.rb

@@ -0,0 +1,11 @@
+module Process
+	# check if the pid's process is running. 
+	#
+	# @note for linux only
+	# @param [String, Integer] pid process id
+	# @return [Boolean]
+	def self.exists?(pid)
+		raise NotImplementError unless linux?
+		File.exists?("/proc/#{pid}")
+	end
+end

data/lib/tagen/core/re.rb

@@ -0,0 +1,8 @@
+class MatchData
+	# group-name regexp
+	# @return [Hash] {:name => "mathed-data"}
+	def to_hash
+		Hash[names.map(&:to_sym).zip(captures)]
+	end
+end
+

data/lib/tagen/core/string.rb

@@ -0,0 +1,43 @@
+class String 
+	@@didits = "0123456789" 
+	@@hexdigits = "01234567890ABCDEF" 
+	@@octdigits = "01234567" 
+	@@uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
+	@@lowercase = "abcdefghijklmnopqrstuvwxyz"
+	@@letters = @@uppercase + @@lowercase 
+
+	class << self
+
+		# "0123456789"
+		#
+		# @return [String]
+		def digits; @@digits end
+
+		# "01234567890ABCDEF" 
+		#
+		# @return [String]
+		def hexdigits; @@hexdigits end
+
+		# "01234567" 
+		#
+		# @return [String]
+		def octdigits; @@octdigits end
+
+		# "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
+		#
+		# @return [String]
+		def uppercase; @@uppercase end
+
+		# "abcdefghijklmnopqrstuvwxyz"
+		#
+		# @return [String]
+		def lowercase; @@lowercase end
+
+		# "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+		#
+		# @return [String]
+		def letters; @@letters end
+	end
+end # class String
+
+require_relative "string/pyformat"

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

@@ -0,0 +1,322 @@
+=begin
+== Overview 
+a python like string format libraray.
+
+1. "this is #{guten}"  # Ruby Builtin											
+2. "this is %s" % "guten"  # Ruby Builtin
+3. "this is {guten}".format(guten: 'x')
+
+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.
+
+== Usage
+	require "tagen/core"
+	"it costs {:.2f} dollar".format(1.123) #=> "it costs 1.12 dollar"
+
+* support abritry-argument or hash-argument
+	"{} {}".format(1,2) #=> "1 2"
+	"{a} {b}".format(a:1, b:2) #=> "1 2"
+	"{a} {b}".format(1, b:2) #=> "1 2"
+
+* escape 
+	"my {{name}} is {name}".format("guten") #=> my name is guten.
+
+== Examples
+	"{:.2f}" 
+	"{name:.2f}" 
+
+== Specification
+	format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
+	fill        ::=  <a character other than '}'> default is " " 
+	align       ::=  "<" | ">" | "=" | "^" 	default is >.  = is padding after sign. eg. +000000120
+	sign        ::=  "+" | "-" | " "
+	#						::=  <prefix 0b 0o 0x>
+	0						::=  <zero_padding>  equal to fill is 0
+	,						::=  <comma_sep> also type n
+	precision		::=  string truncate with 
+	type        ::=  s c b o d x X ¦ f/F g/G e/E n % 
+
+	f/F 	fixed point. nan/NAN inf/INF
+	e/E 	exponent notation. 
+	g/G 	gernal format.  1.0 => 1
+	n 		number. thounds sep based on local setting
+
+== Resources
+* http://docs.python.org/py3k/library/string.html#formatstrings
+
+=end
+class PyFormat
+	Error = Class.new Exception
+	EFormatSpec = Class.new Error
+	EFieldName 	= Class.new Error
+
+	# @param [String] fmt
+	def initialize fmt
+		@fmt = fmt
+	end
+	
+	# format a string
+	#
+	# @param [Object] *args
+	# @return [String]
+	def format *args
+		# if 'field' in argh
+		#   return argh[field]
+		# else
+		#   return args.shift
+		# end
+
+		# args -> argh and args
+		argh = Hash===args[-1] ? args.pop : {}
+
+		# "{0:.5f}"
+		pat = /{{.*?}} | { (.*?)? (?: :(.*?) )? } /x
+		ret = @fmt.gsub(pat) do |m|
+			if m.start_with? "{{"
+				m
+			else
+				field, spec = $1, $2
+				field = field.to_sym
+
+				if argh.has_key? field
+					arg = argh[field]
+				else
+					arg = args.shift
+
+					# can't use if arg==nil then .. 
+					#
+					# class Guten
+					#   def <=> other
+					#     "{}".format(self)
+					#   end
+					# 
+					# => SystemStackError
+					#
+					if NilClass === arg then raise EFieldName, "not enought arguments --#{args}" end
+				end
+
+				Field.parse spec, arg
+			end
+		end
+		ret
+	end
+
+	class Field
+		PAT = /^ 
+					(?: (?<fill>[^}]+)?  (?<align>[<>=^]) )? 
+					(?<sign>[ +-])? 
+					(?<alternate>\#)? 
+					(?<zero_padding>0)? 
+					(?<width>\d+)? 
+					(?<comma_sep>,)? 
+					(?: \.(?<precision>\d+) )? 
+					(?<type>[bcdeEfFgGnosxX%])? /x
+
+
+		def self.parse spec, arg
+			f = self.new 
+			f.parse_spec spec if spec
+			f.format arg
+		end
+
+		def initialize
+			# default options
+			@o = {
+				fill: " ",
+				align: ">",
+				sign: "-",
+				alternate: false,
+				zero_padding: false,
+				width: 0,
+				comma_sep: false,
+				precision: nil,
+				type: nil,
+			}
+		end
+
+		# parse a spec string
+		#
+		# 	parse_spec "this is {:.2f}"
+		# 	return @o
+		#
+		# @param [String] spec
+		# @return [nil] 
+		def parse_spec spec
+			matched = PAT.match(spec)
+			raise EFormatSpec, spec if not matched
+			matched = matched.to_hash
+
+			# merge @o and matched
+			@o.each do |k,v|
+				@o[k] = matched[k] ? matched[k] : v
+			end
+
+			# handle keys 
+			@o = @o.each.with_object({}) do |(k,v),o|
+				case k 
+				when :width, :precision
+					o[k] = v.to_i if v
+				when :zero_padding
+					if v
+						o[:fill] = "0"
+					end
+				when :precision
+					o[:precision] = 1 if v<1
+				else
+					o[k] = v
+				end
+			end
+
+			if @o[:align] == "="
+				@o[:fill] = "0"
+				@o[:sign] = "+"
+			end
+
+		end
+
+		# format a <#Field> by @o
+		#
+		# @param [Object] arg
+		# @return [String]
+		def format arg
+			# arg is int str ..
+			# ret is str.
+		
+			case arg
+			when Integer	
+				@o[:type] ||= 'd'
+			else  # default is s
+				@o[:type] ||= 's'
+			end
+			
+			ret = case @o[:type] 
+			when 's'
+				arg = arg.to_s
+				@o[:precision] ? arg[0...@o[:precision]] : arg
+			when 'c'
+				arg.chr
+
+			when 'b','o','d','x','X'
+				arg = arg.to_i
+
+				case @o[:type]
+				when 'b'
+					ret1 = arg.to_s 2
+					ret1 = do_comma ret1
+					@o[:alternate] ? '0b'+ret1 : ret1
+				when 'o'
+					ret1 = arg.to_s 8
+					ret1 = do_comma ret1
+					@o[:alternate] ? '0'+ret1 : ret1
+				when 'd'
+					ret1 = arg.to_s 10
+					do_comma ret1
+				when 'x', 'X'
+					ret1 = arg.to_s 16
+					ret1.upcase! if @o[:type]=='X'
+					ret1 = do_comma ret1
+					@o[:alternate] ? "0#{@o[:type]}"+ret1 : ret1
+				end
+
+			# for float, need handle 'precision'
+			when 'f','F','g','G','e','E', '%'
+				type = @o[:type]
+
+				num = arg.to_f
+
+				if type=='%'
+					num = num*100 
+					type = 'g'
+				elsif type=='F'
+					type = 'f'
+				end
+
+				# remove 0 1.00000
+				if type=='f'
+					sa, sb = num.to_s.split('.')
+					prec = sb.length
+					@o[:precision] = prec if not @o[:precision]
+				elsif type=='e'
+					# not implement yet
+				end
+
+				spec = "%"
+				spec += '.' + @o[:precision].to_s if @o[:precision]
+				spec += type
+
+				ret1 = spec % num
+
+				# '%g' % 1.0 => 1
+
+				# 'comma_sep'
+				if not %w(g G).include? type
+					a, b = ret1.split('.') 
+					a = do_comma a
+					ret1 = b==nil ? a : a+'.'+b
+				end
+
+				ret1 += '%' if @o[:type]=='%'
+				ret1
+
+			end # case
+
+			## sign
+			if @o[:sign] != '-'
+				sign = arg.to_f>=0 ? @o[:sign] : '-'
+				ret = sign+ret
+			end
+
+
+			## width
+			n = @o[:width] - ret.length
+			if n > 0
+				fill = ''
+				@o[:fill].chars.cycle do |c|
+					fill << c
+					break if fill.length == n
+				end
+
+				ret = case @o[:align]
+				when '>' then fill + ret
+				when '<' then ret + fill
+				when '^' then fill[0...fill.length/2] + ret + fill[fill.length/2..-1]
+				when '=' then ret[0] + fill + ret[1..-1]
+				end
+
+			end
+			
+
+			ret
+		end # def format
+
+	private
+		# convert '1234' -> ['1', '234'] -> '1,234'
+		#
+		# loop
+		#   [l:h]
+		#   break if h==length 
+		#   l = h ; h += 3
+		def do_comma src
+			# [l:h]
+			l = 0
+			h = (src.length % 3)
+			srcs = []
+
+			loop do
+				pice = src[l...h]
+				srcs << pice  if not pice==""
+				break if h == src.length 
+				l = h ; h += 3
+			end
+
+			srcs.join ','
+		end
+	end # class Field
+end # class PyFormat
+
+class String
+	def format(*args) PyFormat.new(self).format *args end
+end
+
+# vim:foldnestmax=4