pa 1.0.0

data/.gitignore

@@ -0,0 +1 @@
+*~

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+group :development do
+	gem 'rspec'
+	gem 'watchr'
+end
+
+#gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    watchr (0.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec
+  watchr

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Guten
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+Pa, a path libraray for Ruby
+========================
+
+**Homepage**: [https://github.com/GutenLinux/pa](https://github.com/GutenLinux/pa) <br/>
+**Author**:	Guten <br/>
+**License**: MIT-LICENSE <br/>
+**Documentation**: [http://rubydoc.info/gems/pa/frames](http://rubydoc.info/gems/pa/frames) <br/>
+**Issue Tracker**: [https://github.com/GutenLinux/pa/issues](https://github.com/GutenLinux/pa/issues) <br/>
+
+Overview
+--------
+
+An Introduction to Pa 
+---------------------
+
+	require "tagen/core"
+	pa = Pa('/home/foo')
+	pa.exists? #=> false
+	pa.dir #=> '/home'
+	pa.base #=> 'foo'
+	pa.join('a.ogg') #=> '/home/a.ogg'
+	pa.join(a.ogg).exists? #=> true.
+
+	Pa.exists?('/home/foo') # alternate way
+
+which rspec
+
+	Pa('/home/foo').should be_exists
+
+more see API doc
+
+Usage
+-----
+
+
+Contributing
+-------------
+
+* join the project.
+* report bugs/featues to issue tracker.
+* fork it and pull a request.
+* improve documentation.
+* feel free to post any ideas. 
+
+Install
+----------
+
+	gem install pa
+
+Resources
+---------
+
+	some related resources to help each other.
+
+Copyright
+---------
+Copyright &copy; 2011 by Guten. this library released under MIT-LICENSE, See {file:LICENSE} for futher details.

data/Ragfile

@@ -0,0 +1,5 @@
+# add your own task in Ragfile or in tasks/*.rag
+class Rag < Thor
+end
+
+# vim: filetype=ruby

data/lib/pa/cmd.rb

@@ -0,0 +1,410 @@
+=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/pa/core.rb

@@ -0,0 +1,106 @@
+class Array
+ 
+=begin
+	# extend options are symbols and hash, symbol as a boolean option.
+	#
+	#   :a #=> { a: true }
+	#   :_a #=> { a: false}
+	#
+	# @example
+	#   def foo(*args)
+	#     paths, o = args.extract_extend_options
+	#   end
+	#
+	#   foo(1, :a, :_b, :c => 2) 
+	#     #=> paths is [1]
+	#     #=> o is {a: true, b: false, c: 2}
+	#
+	# @param [Symbol, Hash] *defaults
+	# @return [Array<Object>, Hash] \[args, options]
+	def extract_extend_options *defaults
+		args, o = _parse_o(defaults)
+		args1, o1 = _parse_o(self)
+		[args+args1, o.merge(o1)]
+	end
+
+	# modify args IN PLACE.
+	# @ see extract_extend_options
+	#
+	# @example
+	#   def foo(*args)
+	#     options = args.extract_extend_options!
+	#   end
+	#
+	#   foo(1, :a, :_b, c: 2)
+	#     #=> args is [1]
+	#     #=> o is {a: true, b: false, c:2}
+	#   
+	# @param [Symbol, Hash] *defaults
+	# @return [Hash] options
+	def extract_extend_options! *defaults
+		args, o = extract_extend_options *defaults
+		self.replace args
+		o
+	end
+
+	# @param [Array,Hash] args
+	def _parse_o args
+		args = args.dup
+		# name:1
+		o1 = Hash === args.last ? args.pop : {}
+		# :force :_force
+		rst = args.select{|v| Symbol===v}
+		args.delete_if{|v| Symbol===v}
+		o2={}
+		rst.each do |k|
+			v = true
+			if k=~/^_/
+				k = k[1..-1].to_sym
+				v = false
+			end
+			o2[k] = v
+		end
+		[args, o1.merge(o2)]
+	end
+	private :_parse_o
+=end
+
+	# 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