tagen 0.1.0

data/lib/tagen/core.rb

@@ -0,0 +1,34 @@
+# from ActiveSupport
+%w(
+	object/blank object/try 
+	module/attribute_accessors
+	class/attribute_accessors
+	string/strip string/access
+	numeric/bytes
+	enumerable
+	array/access array/wrap
+	hash/deep_merge
+).each {|n| require "active_support/core_ext/#{n}"}
+
+# from core
+%w(
+	core/kernel
+	core/object
+	core/module
+
+	core/numeric
+	core/string
+	core/array
+	core/hash
+	core/re
+
+	core/time
+	core/io
+	core/process
+
+	core/pa
+).each {|n| require_relative n }
+
+# from stdlib
+require "time"
+require "date"

data/lib/tagen/core/array.rb

@@ -0,0 +1,41 @@
+require_relative "array/extract_options"
+=begin
+Additional method list
+----------------------
+
+* `#append` _alias from push_
+
+=end
+class Array  
+	alias append push
+
+	alias original_delete delete
+
+	# support delete more than one values.
+	#
+	# 	original: delete(v)
+	# 	currrent: delete(*v)
+	#
+	# @return [Array]
+	def delete *values, &blk
+		indexs = values.each.with_object [] do |v,m|
+			m << original_delete(v, &blk)
+		end
+		values.length==1 ? indexs[0] : indexs
+	end
+
+	alias original_delete_at delete_at
+
+	# support delate_at more than one index.
+	#
+	# 	original: delete_at(i)
+	# 	current: delte_at(*i)
+	#
+	# @return [Array] 
+	def delete_at *indexs, &blk
+		values = indexs.each.with_object [] do |i,m|
+			m << original_delete_at(i, &blk)
+		end
+		indexs.length==1 ? values[0] : values
+	end
+end # class Array

data/lib/tagen/core/array/extract_options.rb

@@ -0,0 +1,40 @@
+class Array
+	# Extracts options from a set of arguments. Removes and returns the last
+	# element in the array if it's a hash, otherwise returns a blank hash.
+	# you can also pass a default option.
+	#
+	# @example
+	#   def options(*args)
+	#     o = args.extract_options!(:a=>1)
+	#   end
+	#
+	#   options(1, 2)           # => {:a=>1}
+	#   options(1, 2, :a => :b) # => {:a=>:b}
+	#
+	# @param [Hash] default default options
+	# @return [Hash]
+	def extract_options! default={}
+		if self.last.is_a?(Hash) && self.last.instance_of?(Hash)
+			self.pop.merge default
+		else
+			default
+		end
+	end
+
+	# extract options
+	# @see extract_options!
+	# @example
+	#   def mkdir(*args)
+	#     paths, o = args.extract_options
+	#   end
+	#
+	# @return [Array<Array,Hash>] 
+	def extract_options default={}
+		if self.last.is_a?(Hash) && self.last.instance_of?(Hash)
+			[self[0...-1], self[-1].merge(default)]
+		else
+			[self, default]
+		end
+	end
+
+end

data/lib/tagen/core/hash.rb

@@ -0,0 +1,17 @@
+class Hash  
+	alias :original_delete :delete
+
+	# support delete more than one keys
+	#
+	#   original: delete(key)
+	#   current:  delete(*keys)
+	#
+	# return [Hash]
+	def delete *keys, &blk
+		values = keys.each.with_object [] do |k,m|
+			m << original_delete(k, &blk)
+		end
+		keys.length==1 ? values[0] : values
+	end
+
+end # class Hash

data/lib/tagen/core/io.rb

@@ -0,0 +1,29 @@
+=begin
+Additional Method list
+----------------------
+
+* `#fd` _alias from fileno_
+
+=end
+class IO 
+
+	# a convient function to write text.
+	#
+	#   use open(path, "w"){|f| f.write(text)}
+	#
+	# @param [String] path
+	# @param [String] text
+	# @return [String]
+	def self.write(path, text) open(path, "w"){|f| f.write(text)} end
+
+	# a convient function to append text.
+	#
+	#   use open(path, "a"){|f| f.write(text)}
+	#
+	# @param [String] path
+	# @param [String] text
+	# @return [String]
+	def self.append(path, text) open(path, "a"){|f| f.write(text)} end
+
+	alias fd fileno
+end # class IO

data/lib/tagen/core/kernel.rb

@@ -0,0 +1,73 @@
+module Kernel 
+private
+
+	# same as `` `` ``, but add some options
+	#
+	# @param [String] cmd a shell command
+	# @param [Symbol, Hash] *o
+	# @option o [Boolean] :verbose puts(cmd) to STDOUT
+	def sh cmd, *o
+		o = o.to_o
+		puts cmd if o[:verbose]
+		`#{cmd}`
+	end
+
+	# convert block to method.
+	#
+	#   you can call a block with arguments
+	#
+	# @example USAGE
+	#   instance_eval(&blk)
+	#   blk2method(&blk).call *args
+	#
+	def blk2method &blk
+		self.class.class_eval do
+			define_method(:__blk2method, &blk)
+		end
+		method(:__blk2method)
+	end
+
+
+	# detect Platform information.
+	#
+	#   RUBY_PLATFORM is "i686-linux" "i386-migw32"
+	#
+	# @return [Boolean]
+	def linux?; RUBY_PLATFORM=~/linux/ end  
+
+	# detect PLatform information.
+	#
+	# @return [Boolean]
+	# @see {#linux?}
+	def win32?; RUBY_PLATFORM=~/mingw32|mswin/ end 
+
+		
+	# *for debug* pd(print debug), search 'pd' is much easier than 'p' in a text-editor.
+	#
+	# like p, but use " " in each argument instead of "\n".
+	#
+	# @example
+	#   p 1,2
+	#    =>
+	#     1
+	#     2
+	#   pd 1,2
+	#    =>
+	#     1 2
+	#
+	# @param [Object] *args
+	# @return nil
+	def pd *args
+		args.each do |arg| print arg.inspect," " end
+		print "\n"
+	end
+
+	# *for debug* print hr. puts '='*14 + " #{name}"
+	#
+	# sometime, we just need a horizonal line to separate message for debug.
+	# @param [String] name
+	def phr name=nil
+		puts '='*14 + " #{name}"
+	end
+
+end # module Kernel

data/lib/tagen/core/marshal.rb

@@ -0,0 +1,34 @@
+module Marshal 
+class <<self
+
+	alias :original_load :load
+
+	# add support with Pa
+	#
+	#   Marshal.load(Pa(path))
+	#
+	# @param [IO,String,Pa] obj
+	# @return [String]
+	def load(obj) original_load Pa===obj ? File.read(obj.p) : obj end
+
+	alias :original_dump :dump
+
+	# add support with Pa
+	#
+	#   Marshal.dump(obj, Pa(path))
+	#   dump(con, [obj], limit=-1)
+	#
+	# @param [String,Pa] obj
+	# @return [String]
+	def dump(obj, *args)
+		case args[0]
+		when String, Pa
+			path = String===args[0] ? args[0] : args[0].p
+			open(path, "wb"){|f| f.write(original_dump(con))}
+		else
+			original_dump con, *args
+		end
+	end
+
+end
+end

data/lib/tagen/core/module.rb

@@ -0,0 +1,25 @@
+class Module 
+
+	alias :original_append_features :append_features
+
+	# after include module, convert methods in  ClassMethods to class methods.
+	# @see ruby-core Module#append_features
+	#
+	# @example
+	#   module Guten
+	#   	module ClassMethods
+	#   		def foo; end     # after include Guten, method 'foo' becomes a class method.
+	#   	end
+	#	  end
+	#  
+	#   class Tag
+	#   	include Guten
+	#	  end
+	#	  Tag.foo
+	#
+	def append_features base
+		original_append_features base
+		base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+	end
+
+end #class Module

data/lib/tagen/core/numeric.rb

@@ -0,0 +1,10 @@
+class Numeric 
+	# equivalent to a.fdiv(b).ceil. +1
+	#
+	# @param [Numeric] num
+	# @return [Numeric]
+	def div2 num
+		d, m = divmod(num)
+		d + (m==0 ? 0 : 1)
+	end
+end

data/lib/tagen/core/object.rb

@@ -0,0 +1,21 @@
+class Object
+	# default \#dup is shallow. 
+	#
+	# @example
+	# 	# dup
+	# 	a={a: { b: 1 }}
+	# 	a2 = a.dup
+	# 	a2[:a][:b] = 2
+	# 	p a  #=> {a: {b: 2} }
+	#
+	# 	# use deepdup
+	# 	a= {a: {b: 1 }}
+	# 	a2 = a.deepdup
+	# 	a2[:a][:b] = 2
+	# 	p a #=> {a: {b: 1}}
+	#
+	# @return [Object]
+	def deepdup
+		Marshal.load(Marshal.dump(self))
+	end
+end

data/lib/tagen/core/pa.rb

@@ -0,0 +1,187 @@
+=begin
+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"
+=end
+
+class Pa 
+	Error = Class.new Exception
+	EUnkonwType = Class.new Error
+
+	attr_accessor :path
+	attr_reader :absolute, :dir, :base, :name, :ext, :fext
+	alias p path
+	alias a absolute
+	alias d dir
+	alias	b base
+	alias n name
+	alias e ext
+	alias fe fext
+
+	# @param [String,Pa,Pathname] path
+	# @api also used by replace
+	def initialize path
+		@path = case path.class.to_s
+			when "Pathname"
+				path.to_s
+			when "Pa"
+				path.path
+			when "String"
+				path
+			else
+				raise ArgumentError, path.inspect
+			end
+		@absolute = Pa.absolute(@path) 
+		@dir = Pa.dirname(@path)
+		@base = Pa.basename(@path) 
+		@name, @ext = Pa.basename(@path, ext: true)
+		@fext = @ext.empty? ? "" : "."+@ext
+	end
+
+	# @param [String,Pa,Pathname]
+	# @return [Pa] the same Pa object
+	def replace path
+		initialize 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 @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
+
+	# join path
+	#
+	# param [String] *names
+	# return [Pa]
+	def join(*names)
+		Pa(Pa.join(@path, *names))
+	end
+
+	# get parent path
+	# 
+	# return [Pa] 
+	def parent
+		Pa(Pa.join(@path, '..'))
+	end
+
+
+	# missing method goes to Pa.class-method 
+	# return@ [Pa,..] return Pa for some methods.
+	def method_missing(name, *args, &blk)
+		ret = self.class.__send__(name, *args, @path, &blk)
+		[ :readlink ]
+			.include?(name) ? Pa(ret) : ret
+	end
+end
+
+
+require_relative "pa/path"
+require_relative "pa/cmd"
+require_relative "pa/dir"
+require_relative "pa/state"
+class Pa
+class << self
+
+	# missing method goes to File class method
+	def method_missing name, *args, &blk
+		return if args.size>1
+		File.__send__ name, get(args[0]), &blk
+	end
+
+end
+end
+
+class Pa
+	extend Path
+	extend Directory
+	extend State
+	extend Cmd
+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
+