pa 1.0.0

data/lib/pa.rb

@@ -0,0 +1,175 @@
+require_relative "pa/core"
+
+require "bundler/setup"
+Bundler.require
+
+=begin rdoc
+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
+	fname     fn     alias of base
+  name      n      filename of a path
+  ext       e      extname of a path,  return "" or "ogg"  
+  fext      fe     return "" or ".ogg"
+
+== used with rspec
+
+	File.exists?(path).should be_true
+	Pa(path).should be_exists
+
+=end
+class Pa 
+	Error = Class.new Exception
+	EUnkonwType = Class.new Error
+
+	attr_reader :path
+
+	# @param [String,#path] path
+	def initialize path
+		@path = path.respond_to?(:path) ? path.path : path
+		initialize_variables
+	end
+
+	def ok
+		initialize_variables
+	end
+
+	chainable = Module.new do
+		def initialize_variables; end
+	end
+	include chainable
+
+	alias p path
+
+	# @param [String,#path]
+	# @return [Pa] the same Pa object
+	def replace path
+		@path = path.respond_to?(:path) ? path.path : path
+		initialize_variables
+	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
+
+	# missing method goes to Pa.class-method 
+	def method_missing(name, *args, &blk)
+		ret = self.class.__send__(name, path, *args, &blk)
+
+		case ret	
+
+		# e.g. readlink ..
+		when String
+			Pa(ret)
+
+		# e.g. directory? 
+		else
+			ret
+		end
+
+	end
+
+
+end
+
+class Pa
+module ClassMethods
+	UNDEFS = [:open, :fstat]
+
+	# missing method goes to File class method
+	def method_missing name, *args, &blk
+		raise NoMethodError, name.inspect if UNDEFS.include?(name)
+		return if args.size>1 
+		File.__send__ name, get(args[0]), &blk
+	end
+end
+end
+
+require_relative "pa/path"
+require_relative "pa/cmd"
+require_relative "pa/dir"
+require_relative "pa/state"
+class Pa
+  extend ClassMethods
+  extend ClassMethods::Path
+  extend ClassMethods::Dir
+  extend ClassMethods::State
+  extend ClassMethods::Cmd
+
+  include Path
+  include State
+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
+

data/pa.gemspec

@@ -0,0 +1,22 @@
+$: << "."
+require "version"
+require "bundler"
+
+Gem::Specification.new do |s|
+	s.name = "pa"
+	s.version = Pa::VERSION::IS
+	s.summary = "a good lib"
+	s.description = <<-EOF
+a good lib
+	EOF
+
+	s.author = "Guten"
+	s.email = "ywzhaifei@Gmail.com"
+	s.homepage = "http://github.com/GutenLinux/pa"
+	s.rubyforge_project = "xx"
+
+	s.files = `git ls-files`.split("\n")
+
+	s.add_bundler_dependencies
+	#s.add_dependency "x"
+end

data/pa.watchr

@@ -0,0 +1,22 @@
+# lib/**/*.rb
+watch %r~lib/(.*)\.rb~ do |m|
+	test "spec/#{m[1]}_spec.rb"
+end
+
+# spec/**/*_spec.rb
+watch %r~spec/.*_spec\.rb~ do |m|
+	test m[0]
+end
+
+# Ctrl-\
+Signal.trap('QUIT') do
+  puts "--- Running all tests ---\n\n"
+	test "spec"
+end
+
+def test path
+	cmd = "rspec #{path}"
+	puts cmd
+	system cmd
+end
+

data/spec/pa/cmd_spec.rb

@@ -0,0 +1,278 @@
+require "spec_helper"
+require "fileutils"
+require "tmpdir"
+
+describe Pa do
+	it "a" do
+		Pa._copy 'a','b'
+	end
+end
+
+
+=begin
+describe Pa do
+	before :all do
+		@curdir = Dir.pwd
+		@tmpdir = Dir.mktmpdir
+		Dir.chdir(@tmpdir)
+	end
+
+	after(:all) do
+		Dir.chdir(@curdir)
+		FileUtils.rm_r @tmpdir
+	end
+
+	describe "#_rmdir" do
+		# dir/
+		#   a
+		#  dira/
+		#    aa
+		before(:all) do	
+			@_rmdir = Pa.method(:_rmdir)
+			FileUtils.mkdir_p(%w(dir/dira))
+			FileUtils.touch(%w(dir/a dir/dira/aa))
+		end
+
+		it "remove directory" do
+			@_rmdir.call Pa("dir")
+			File.exists?("dir").should be_false
+		end
+	end
+
+	# rm family
+	describe "" do
+		# a
+		# dir/ 
+		#   dira/
+		#   a 
+		before :each do
+			FileUtils.mkdir_p(%w(dir/dira))
+			FileUtils.touch(%w(a dir/a))
+		end
+
+		describe "#rm" do
+			it "remove file" do
+				Pa.rm "a"
+				File.exists?("a").should be_false
+				lambda{Pa.rm("dir")}.should raise_error(Errno::EISDIR)
+			end
+		end
+
+		describe "#rm_f" do
+			it "remove file force" do
+				lambda{Pa.rm_f("dir")}.should_not raise_error(Errno::EISDIR)
+			end
+		end
+
+		describe "#rmdir" do
+			it "remove directory" do
+				Pa.rmdir "dir"
+				File.exists?("dir").should be_false
+				lambda{Pa.rmdir("a")}.should raise_error(Errno::ENOTDIR)
+			end
+		end
+
+		describe "#rmdir_f" do
+			it "remove directory force" do
+				lambda{Pa.rmdir_r("a")}.should_not raise_error(Errno::ENOTDIR) 
+			end
+		end
+
+		describe "#rm_r" do
+			it "remove both file and directory" do
+				Pa.rm "a"
+				File.exists?("a").should be_false
+				Pa.rm_r "dir"
+				File.exists?("dir").should be_false
+			end
+		end
+
+
+
+		describe "#rm_if" do
+			it "remove if condition" do
+				Pa.rm_if "." do |pa|
+					next if pa.p=="a"
+					yield if pa.b=="a"
+				end
+
+			File.exists?("a").should be_true 
+			File.exists?("dir/dira/a").should be_false
+		end
+	end
+
+	end
+
+	describe "#mkdir" do
+		after :each do
+			FileUtils.rm_r Dir["*"]-%w(. ..)
+		end
+
+		it "mkdir" do
+			Pa.mkdir("guten/tag")
+			File.exists?("guten/tag").should be_true
+		end
+	end
+
+	describe "#_copy" do
+		# a symfile
+		# ab
+		# ac
+		# dir/ 
+		#   b   # guten
+		#   dira/
+		#     c
+		# destdir/
+		#   b  # tag
+		#   dir/ 
+		before :all do
+			FileUtils.mkdir_p(%w(dir/dira destdir/dir))
+			FileUtils.touch(%w(a ab ac dir/b dir/dira/c destdir/dir/b))
+			File.symlink("a", "symfile")
+			open("dir/b", "w"){|f|f.write "guten"}
+			open("destdir/dir/b", "w"){|f|f.write "tag"}
+		end
+
+		it "_copy file" do
+			Pa._copy 'a', 'b', verbose: true
+			File.exists?('b').should be_true
+		end
+
+		it "_copy directory" do
+			Pa._copy 'dir', 'dirc'
+			Dir.entries('dirc').should == Dir.entries('dir')
+		end
+
+		context "with :symlink" do
+
+			it "_copy" do
+				Pa._copy 'symfile', 'symfilea'
+				File.symlink?('symfilea').should be_true
+			end
+
+			it "_copy with :folsymlink" do
+				Pa._copy 'symfile', 'folsymlink', folsymlink:true
+				File.symlink?('folsymlink').should be_false
+				File.file?('folsymlink').should be_true
+			end
+
+		end
+
+		context "with :mkdir" do
+			it "_copy" do
+				lambda{Pa.cp "a", "destdir/mkdir/dir"}.should raise_error(Errno::ENOENT)
+			end
+
+			it "_copy with :mkdir" do
+				lambda{Pa.cp "a", "destdir/mkdir/dir", mkdir:true}.should_not raise_error(Errno::ENOENT)
+				File.exists?("destdir/mkdir/dir/a").should be_true
+			end
+
+			it "_copy with :mkdir" do
+				lambda{Pa.cp "a", "destdir/mkdira", mkdir:true}.should_not raise_error(Errno::ENOENT)
+				File.exists?("destdir/mkdira/a").should be_true
+			end
+		end
+
+		context "with :force" do
+			it "_copy" do
+				File.open("destdir/overwrite","w"){|f|f.write("")}
+				lambda{Pa.cp "a", "destdir/overwrite"}.should raise_error(Errno::EEXIST)
+			end
+
+			it "_copy with :force" do
+				lambda{Pa.cp "a", "destdir/overwrite", force:true}.should_not raise_error(Errno::EEXIST)
+			end
+		end
+
+		it "_copy with :normal" do
+			Pa._copy 'dir', 'dir_normal', special: true
+			Dir.empty?('dir_normal').should be_true
+		end
+
+	end
+
+	describe "#cp" do
+		it "cp file destdir/file" do
+			Pa.cp "a", "destdir/aa" 
+			File.exists?("destdir/aa").should be_true
+		end
+
+		it "cp file destdir/" do
+			Pa.cp "a", "destdir"
+			File.exists?("destdir/a").should be_true
+		end
+
+		it "cp file1 file2 .. dest_file" do
+			lambda{Pa.cp(%w(a ab), "ac")}.should raise_error(Errno::ENOTDIR)
+		end
+
+		it "cp file1 file2 .. dird/" do
+			Dir.mkdir 'dird'
+			Pa.cp %w(a ab), "dird"
+			File.exists?("dird/a").should be_true
+			File.exists?("dird/ab").should be_true
+		end
+	end
+	
+	describe "#_move" do
+		# a
+		# dir/ b  
+		before :each do
+			FileUtils.mkdir_p(%w(dir))
+			FileUtils.touch(%w(a dir/b))
+		end
+		after :each do
+			FileUtils.rm_r Dir["*"]-%w(. ..)
+		end
+
+		it "mv a dir/a" do
+			ino = File.stat('a').ino
+			Pa._move "a", "dir/a", {}
+			File.stat('dir/a').ino.should == ino
+			File.exists?("a").should be_false
+		end
+		
+		context "with :force" do
+			it "mv a dir/b" do
+				lambda{Pa._move "a", "dir/b", {}}.should raise_error Errno::EEXIST
+			end
+
+			it "mv a dir/b :force" do
+				ino = File.stat('a').ino
+				Pa._move "a", "dir/b", force:true
+				File.stat("dir/b").ino.should == ino
+			end
+		end
+
+	end
+
+	describe "#mv" do
+		# a b c
+		# dir/ aa  
+		before :each do
+			FileUtils.mkdir_p(%w(dir))
+			FileUtils.touch(%w(a b c dir/aa))
+		end
+		after :each do
+			FileUtils.rm_r Dir["*"]-%w(. ..)
+		end
+
+		it "mv a dir/" do
+			Pa.mv "a", "dir"
+			File.exists?("dir/a").should be_true
+		end
+
+		it "mv a b .. file" do
+			lambda{Pa.mv(%w(a b), "c")}.should raise_error(Errno::ENOTDIR)
+		end
+
+		it "mv file1 file2 .. dir/" do
+			Pa.mv %w(a b), "dir"
+			File.exists?("dir/a").should be_true
+			File.exists?("dir/b").should be_true
+		end
+	end
+
+end
+=end

data/spec/pa/dir_spec.rb

@@ -0,0 +1,137 @@
+require "spec_helper"
+require "fileutils"
+require "tmpdir"
+
+class Pa
+	class << self
+	public :_copy, :_move, :_rmdir, :_mktmpname, :_mkdir, :_touch
+	end
+end
+
+describe Pa do
+	before :all do
+		@curdir = Dir.pwd
+		@tmpdir = Dir.mktmpdir
+		Dir.chdir(@tmpdir)
+	end
+
+	after(:all) do
+		Dir.chdir(@curdir)
+		FileUtils.rm_r @tmpdir
+	end
+
+	describe "#glob" do
+		before(:each) do 
+			@files = %w(fa .fa)
+			FileUtils.touch(@files)
+		end
+		after(:each) do 
+			FileUtils.rm @files
+		end
+
+		context "call without any option" do
+			it "returns 1 items" do
+				Pa.glob("*").should have(1).items
+			end
+		end
+
+		context "call with :dotmatch option" do
+			it "returns 2 items" do
+				Pa.glob("*", dotmatch: true).should have(2).items
+			end
+		end
+	end
+
+	describe "#each" do
+		# fa .fa fa~ 
+		# dira/
+		#   dirb/
+		#     b
+		before(:each) do 
+			@dirs = %w(dira/dirb)
+			@files = %w(fa .fa fa~ dira/dirb/b)
+			FileUtils.mkdir_p(@dirs)
+			FileUtils.touch(@files)
+		end
+		after(:each) do 
+			FileUtils.rm @files
+			FileUtils.rm_r @dirs
+		end
+
+		it "runs on" do
+			ret = []
+			Pa.each{|pa| ret << pa.fname}
+			ret.sort.should == %w(.fa dira fa fa~)
+		end
+
+		it "return a Enumerator when call without block" do
+			Pa.each.should be_an_instance_of Enumerator
+		end
+
+		it "raise Errno::ENOENT if path doesn't exists" do
+			lambda { Pa.each("path_doesn't_exits"){} }.should raise_error(Errno::ENOENT)
+		end
+
+		it "raise Errno::ENOTDIDR if path isn't a directory" do
+			lambda { Pa.each("fa"){} }.should raise_error(Errno::ENOTDIR)
+		end
+
+		it "each(.) return 'foo' not '.foo'" do 
+			Pa.each.with_object([]){|pa,m| m<<pa.p}.sort.should == %w(.fa dira fa fa~)
+		end
+
+		it "each(nodot: true) -> list all files except dot file" do
+			Pa.each(nodot: true).with_object([]){|pa,m|m<<pa.b}.sort.should == %w(dira fa fa~)
+		end
+
+	end
+
+	describe "#each_r" do
+		# fa .fa fa~ 
+		# dira/
+		#   dirb/
+		#     b
+		before(:each) do 
+			@dirs = %w(dira/dirb)
+			@files = %w(fa .fa fa~ dira/dirb/b)
+			FileUtils.mkdir_p(@dirs)
+			FileUtils.touch(@files)
+		end
+		after(:each) do 
+			FileUtils.rm @files
+			FileUtils.rm_r @dirs
+		end
+
+		it "each_r -> Enumerator" do
+			Pa.each_r.should be_an_instance_of Enumerator
+		 	Pa.each_r.with_object([]){|(pa,r),m|m<<r}.sort.should == %w(.fa dira dira/dirb dira/dirb/b fa fa~)
+		end
+	end
+
+
+	describe "#ls" do
+		# filea 
+		# dira/
+		# 	fileb
+		before(:each) do 
+			@dirs = %w(dira)
+			@files = %w(filea dira/fileb)
+			FileUtils.mkdir_p(@dirs)
+			FileUtils.touch(@files)
+		end
+		after(:each) do 
+			FileUtils.rm @files
+			FileUtils.rm_r @dirs
+		end
+
+		it "runs ok -> Array" do
+			Pa.ls.should == ["filea", "dira"]
+		end
+
+		it "call a block" do
+			Pa.ls { |pa, fname| pa.directory?  }.should == ["dira"]
+		end
+	end
+
+
+end