pa 1.2.1 → 1.2.2

data/lib/pa.rb

@@ -207,13 +207,21 @@ class Pa
   DELEGATE_METHODS = [ :dir, :build, :join ]
 
 	attr_reader :path2
-  attr_reader :absolute2, :dir2, :dir_strict2, :base2, :fname2, :name2, :short2, :ext2, :fext2
+  attr_reader :absolute2, :dir2, :dir_strict2, :base2, :fname2, :name2, :short2, :ext2, :fext2, :rel, :rea
+  attr_reader :options
 
+  # @param [Hash] o option
+  # @option o [String] rel relative path
+  # @option o [String] base_dir
 	# @param [String, #path] path
-	def initialize(path)
-    # convert ~ to ENV["HOME"]
+	def initialize(path, o={})
 		@path2 = Pa.get(path)
+    # convert ~ to ENV["HOME"]
     @path2.sub!(/^~/, ENV["HOME"]) if @path2 # nil
+    @options = o
+
+    @rel = o[:rel] || ""
+    @base_dir = o[:base_dir]
 
 		initialize_variables
   end
@@ -223,8 +231,34 @@ class Pa
 	end
 	include chainable
 
+  def rel
+    raise Error, "don't have a :rel option" unless rel?
+
+    @rel ||= options[:rel]
+  end
+
+  def base_dir
+    raise Error, "don't have a :base_dir option" unless base_dir?
+
+    @base_dir ||= options[:base_dir]
+  end
+
+  def rea
+    raise Error, "don't have a :base_dir option" unless base_dir?
+
+    @rea ||= File.join(options[:base_dir], path)
+  end
+
+  def rel?
+    options.has_key?(:rel)
+  end
+
+  def base_dir?
+    options.has_key?(:base_dir)
+  end
+
   def absolute2
-    @absolute2 ||= File.absolute_path(path)
+    @absolute2 ||= File.absolute_path(options[:base_dir] ? rea : path)
   end
 
   # => ".", "..", "/", "c:"

data/lib/pa/cmd.rb

@@ -93,7 +93,7 @@ class Pa
       # @overload touch(*paths, o={})
       #   @param [String] *paths
       #   @param [Hash] o option
-      #   @option o [Fixnum,String] :mode
+      #   @option o [Fixnum,String] :mode (0664)
       #   @option o [Boolean] :mkdir auto mkdir if path contained directory not exists.
       #   @option o [Boolean] :force 
       #   @option o [Boolean] :verbose 
@@ -119,7 +119,7 @@ class Pa
       # @overload mkdir(*paths, o={})
       #   @param [String, Pa] *paths
       #   @param [Hash] o option
-      #   @option o [Fixnum] :mode
+      #   @option o [Fixnum] :mode (0775)
       #   @option o [Boolean] :force
       #   @option o [Boolean] :verbose
       #   @return [nil]
@@ -308,6 +308,8 @@ class Pa
       #    yield  # use yield to do the actuactal cp work
       #  end
       #
+      # default: preverse mode, not owner.
+      #
       # @overload cp(src_s, dest, o)
       #   @param [Array<String>, String] src_s support globbing
       #   @param [String,Pa] dest
@@ -460,7 +462,7 @@ class Pa
       end
 
       def _mkdir(paths, o)
-        o[:mode] ||= 0744
+        o[:mode] ||= 0775
         paths.map!{|v|get(v)}
         paths.each {|p|
           puts "mkdir #{p}" if o[:verbose]

data/lib/pa/directory.rb

@@ -106,50 +106,60 @@ class Pa
       #   @prarm [Hash] o
       #   @option o [Boolean] :dot (true) include dot file
       #   @option o [Boolean] :backup (true) include backup file
-      #   @option o [Boolean] :absolute (false) return absolute path
       #   @option o [Boolean] :error (false) yield(pa, err) instead of raise Errno::EPERM when Dir.open(dir)
+      #   @option o [Boolean] :file (false) return path and not raise Errno:ENOTDIR if path is a file.
+      #   @option o [String,Pa] :base_dir (nil) base directory.
       #   @return [Enumerator<String>]
-      # @overload each(path=".", o={})
+      # @overload each(path=".", o={}){|path, abs, fname, err, [rea]|}
       #   @yieldparam [String] path
+      #   @yieldparam [String] abs absolute path
+      #   @yieldparam [String] fname a basename
+      #   @yieldparam [String] err error
+      #   @yieldparam [String] rea real relative path with o[:base_dir]
       #   @return [nil]
       def each2(*args, &blk) 
         return Pa.to_enum(:each2, *args) unless blk
 
-        (path,), o = Util.extract_options(args)
+        (dir,), o = Util.extract_options(args)
+        dir = dir ? get(dir) : "."
         o = {dot: true, backup: true}.merge(o)
 
-        path = path ? get(path) : "."
-        raise Errno::ENOENT, "`#{path}' doesn't exists."  unless File.exists?(path)
-        raise Errno::ENOTDIR, "`#{path}' not a directoy."  unless File.directory?(path)
+        rea_dir = o[:base_dir] ? File.join(get(o[:base_dir]), dir) : dir
+        raise Errno::ENOENT, "`#{rea_dir}' doesn't exists."  unless File.exists?(rea_dir)
+
+        if not File.directory?(rea_dir) 
+          if o[:file]
+            rea_path = rea_dir
+            blk.call dir, File.absolute_path(rea_path), File.basename(rea_path), nil, rea_path
+            return
+          else
+            raise Errno::ENOTDIR, "`#{rea_dir}' is not a directoy."
+          end
+        end
 
         begin
-          dir = Dir.open(path)
+          d = Dir.open(rea_dir)
         rescue Errno::EPERM => err
         end
         raise err if err and !o[:error]
 
-        while (entry=dir.read)
+        while (entry=d.read)
           next if %w(. ..).include? entry
           next if not o[:dot] and entry=~/^\./
           next if not o[:backup] and entry=~/~$/
 
-          p = if o[:absolute]
-            File.absolute_path(File.join(path, entry))
-          else
-            # => "foo" not "./foo"
-             path=="." ? entry : File.join(path, entry)
-          end
-
-          blk.call p, err  
-          end
+          path = Util.join(dir, entry)
+          rea_path = Util.join(rea_dir, entry)
+          blk.call path, File.absolute_path(rea_path), File.basename(rea_path), err, rea_path
         end
+      end
 
       def each(*args, &blk)
         return Pa.to_enum(:each, *args) unless blk
 
         args, o = Util.extract_options(args)
-        each2(*args, o) { |path, err|
-          blk.call Pa(path), err
+        each2(*args, o) { |path, abs, fname, err, rea|
+          blk.call Pa(path), abs, fname, err, rea
         }
       end
 
@@ -160,27 +170,29 @@ class Pa
       # * each2_r(){path, relative, err}
       #
       # @overload each2_r(path=".", o={})
+      #   @option o [String, Pa] :base_dir (nil) base directory.
       #   @return [Enumerator<String>]
       # @overload each2_r(path=".", o={})
       #   @yieldparam [String] path
-      #   @yieldparam [String] relative relative path
+      #   @yieldparam [String] abs
+      #   @yieldparam [String] rel/rea relative path
       #   @yieldparam [Errno::ENOENT,Errno::EPERM] err 
       #   @return [nil]
       def each2_r(*args, &blk)
         return Pa.to_enum(:each2_r, *args) if not blk
 
-        (path,), o = Util.extract_options(args)
-        path ||= "."
+        (dir,), o = Util.extract_options(args)
+        dir ||= "."
 
-        _each2_r(path, "", o, &blk)
+        _each2_r(dir, "", o, &blk)
       end
 
       def each_r(*args, &blk)
         return Pa.to_enum(:each_r, *args) if not blk
 
         args, o = Util.extract_options(args)
-        each2_r *args, o do |path, err|
-          blk.call Pa(path), err
+        each2_r *args, o do |path, abs, rel, err, rea|
+          blk.call Pa(path), abs, rel, err, rea
         end
       end
 
@@ -192,81 +204,120 @@ class Pa
       # @Example
       #   Pa.ls2(".") {|path, fname| Pa.directory?(path)} # list only directories
       #
-      # @overload ls2(path=".", o={})
+      # @overload ls2(*dirs, o={})
+      #   @option o [Boolean] :absolute (false) return absolute path instead.
+      #   @option o [Boolean] :include (false) return "<path>/foo"
       # 	@return [Array<String>]
-      # @overload ls2(path=".", o={})
+      # @overload ls2(*dirs, o={}){|path, abs, fname|}
       #   @yieldparam [String] path
+      #   @yieldparam [String] abs
       #   @yieldparam [String] fname
       #   @return [Array<String>]
       def ls2(*args, &blk)
-        (path,), o = Util.extract_options(args)
-        path ||= "."
+        dirs, o = Util.extract_options(args)
+        dirs << "." if dirs.empty?
         blk ||= proc { true }
 
-        each2(path, o).with_object([]) { |(path),m| 
-          base = File.basename(path)
-
-          blk_ret = blk.call(path, base)
-          file = o[:absolute] ? path : base
-          m << file if blk_ret
-        }
-      end
-
-      # @overload ls(path=".", o={})
-      # 	@return [Array<Pa>]
-      # @overload ls(path=".", o={})
-      #   @yieldparam [Pa] path
-      #   @yieldparam [String] fname
-      #   @return [Array<String>]
-      def ls(*args, &blk)
-        (path,), o = Util.extract_options(args)
-        path ||= "."
-        blk ||= proc { true }
+        dirs.each.with_object([]) { |dir, m|
+          each2(dir, o) { |path, abs, fname, err, rea|
 
-        each2(path, o).with_object([]) { |(path), m|
-          base = File.basename(path)
+            view_path = if o[:absolute]
+                     abs
+                   elsif o[:include]
+                     path
+                   else
+                     fname
+                   end
 
-          blk_ret = blk.call(Pa(path), base)
-          file = o[:absolute] ? path : base
-          m << Pa(file) if blk_ret
+            m << view_path if blk.call(path, abs, fname, err, rea)
+          }
         }
       end
 
       # ls2 with recursive
       # @see ls2
       #
-      # @overload ls2_r(path=".", o={})
+      # @overload ls2_r(*dirs, o={})
       # 	@return [Array<String>]
-      # @overload ls2_r(path=".", o={})
-      #   @yieldparam [Pa] pa
+      # @overload ls2_r(*dirs, o={}){|pa, abs, rel, err, [rea]|
+      #   @yieldparam [String] path
+      #   @yieldparam [String] abs
       #   @yieldparam [String] rel
+      #   @yieldparam [Exception] err
+      #   @yieldparam [String] rea
       #   @return [Array<String>]
       def ls2_r(*args, &blk)
-        blk ||= proc {true}
-        each2_r(*args).with_object([]) { |(path,rel),m| 
-          m<<rel if blk.call(path, rel)
+        dirs, o = Util.extract_options(args)
+        dirs << "." if dirs.empty?
+        blk ||= proc { true }
+
+        dirs.each.with_object([]) { |dir, m|
+          each2_r(dir, o) { |path, abs, rel, err, rea|
+            view_path = if o[:absolute]
+                     abs
+                   elsif o[:include]
+                     path
+                   else
+                     rel
+                   end
+
+            m << view_path if blk.call(path, abs, rel, err, rea)
+          }
         }
       end
 
+      # @overload ls(*paths, o={})
+      #   @params [Array] paths (["."])
+      # 	@return [Array<Pa>]
+      # @overload ls(*paths, o={}){|pa, abs, fname, err, [rea]|}
+      #   @yieldparam [Pa] pa
+      #   @yieldparam [String] abs
+      #   @yieldparam [String] fname
+      #   @yieldparam [Exception] err
+      #   @yieldparam [String] rea
+      #   @return [Array<String>]
+      def ls(*args, &blk)
+        dirs, o = Util.extract_options(args)
+        blk ||= proc { true }
+        ret = []
+
+        ls2(*dirs, o) { |path, abs, fname, err, rea|
+          view_path = if o[:absolute]
+                   abs
+                 elsif o[:include]
+                   path
+                 else
+                   fname
+                 end
+
+          ret << Pa(view_path) if blk.call(Pa(path), abs, fname, err, rea)
+        }
+
+        ret
+      end
+
       def ls_r(*args, &blk)
         args, o = Util.extract_options(args)
         ls2_r(*args, o, &blk)
       end
 
     private
+
+      # I'm rescurive.
       # @param [String] path
       def _each2_r(path, relative, o, &blk)
+        relative = relative == "" ? nil : relative
         o.merge!(error: true)
 
-        Pa.each2(path, o) do |path2, err|
+        Pa.each2(path, o) do |path2, abs, fname, err, rea|
           # fix for File.join with empty string
-          joins=[ relative=="" ? nil : relative, File.basename(path2)].compact
-          relative2 = File.join(*joins)
+          rel = File.join(*[relative, File.basename(path2)].compact)
+          rea = o[:base_dir] ? File.join(get(o[:base_dir]), rel) : rel
 
-          blk.call path2, relative2, err
+          blk.call path2, abs, rel, err, rea
 
-          if File.directory?(path2)
-            _each2_r(path2, relative2, o, &blk)
+          if File.directory?(abs)
+            _each2_r(path2, rel, o, &blk)
           end
         end
       end

data/lib/pa/path.rb

@@ -175,4 +175,3 @@ class Pa
     end
   end
 end
-

data/lib/pa/util.rb

@@ -31,6 +31,11 @@ class Pa
       def win32? 
         RUBY_PLATFORM =~ /mingw32|mswin/ 
       end 
+
+      # join(".", "foo") => "foo" not "./foo"
+      def join(dir, *names)
+        dir == "." ? File.join(*names) : File.join(dir, *names)
+      end
     end
   end
 end

data/lib/pa/version.rb

@@ -1,3 +1,3 @@
 class Pa
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

data/pa.gemspec

@@ -1,7 +1,4 @@
-$: << File.expand_path("../lib", __FILE__)
-require "pa/version"
-
-pd Pa::VERSION
+Kernel.load File.expand_path("../lib/pa/version.rb", __FILE__)
 
 Gem::Specification.new do |s|
 	s.name = "pa"

data/spec/pa/directory_spec.rb

@@ -67,10 +67,19 @@ describe Pa do
 			FileUtils.touch %w[filea .filea filea~ dira/dirb/b]
 		end
 
-		it "works" do
-			ret = []
-			Pa.each2{|pa| ret << pa}
-			ret.sort.should == %w(.filea dira filea filea~)
+    it "(:base_dir => x) to build clean path" do
+      Pa.each2("dira").to_a.map{|v|v[0]}.should == %w[dira/dirb]
+      Pa.each2("dirb", :base_dir => "dira").to_a.map{|v|v[0]}.should == %w[dirb/b]
+      Pa.each2("dirb", :base_dir => Pa("dira")).to_a.map{|v|v[0]}.should == %w[dirb/b]
+    end
+
+    it "yields {|path, abs, fname, err, rea|}" do
+      Pa.each2("dira").to_a.sort[0].should == ["dira/dirb", File.join(Dir.pwd, "dira/dirb"), "dirb", nil, "dira/dirb"]
+      Pa.each2("dirb", :base_dir => "dira").to_a.sort[0].should == ["dirb/b", File.join(Dir.pwd, "dira/dirb/b"), "b", nil, "dira/dirb/b"]
+    end
+
+		it "list a directory" do
+			Pa.each2.to_a.map{|v|v[0]}.sort.should == %w[.filea dira filea filea~]
 		end
 
 		it "return a Enumerator when call without block" do
@@ -85,29 +94,29 @@ describe Pa do
 			lambda { Pa.each2("filea"){} }.should raise_error(Errno::ENOTDIR)
 		end
 
-		it "each2(.) return 'foo' not '.foo'" do 
-			Pa.each2.with_object([]){|(pa),m| m<<pa}.sort.should == %w(.filea dira filea filea~)
-		end
+    it "(:file => true) return path if path is a file." do
+      Pa.each2("filea", :file => true).to_a[0][0].should == "filea"
+    end
 
-		it ".each2 with :dot => false -> list all files except dot file" do
-			Pa.each2(:dot => false).with_object([]){|(pa),m|m<<pa}.sort.should == %w[dira filea filea~]
+		it "(.) return 'foo' not '.foo'" do 
+			Pa.each2.to_a.map{|v|v[0]}.sort.should == %w(.filea dira filea filea~)
 		end
 
-    it ".each2 with :backup => false" do
-      Pa.each2(:backup => false).with_object([]){|(pa),m|m<<pa}.sort.should == %w[.filea dira filea]
-    end
+		it "with :dot => false -> list all files except dot file" do
+			Pa.each2(:dot => false).to_a.map{|v|v[0]}.sort.should == %w[dira filea filea~]
+		end
 
-    it ".each2 with :absolute => true" do
-      b = %w[.filea dira filea filea~].map{|v| File.join(Dir.pwd, v)}
-      Pa.each2(:absolute => true).with_object([]){|(pa),m|m<<pa}.sort.should == b
+    it "with :backup => false" do
+      Pa.each2(:backup => false).to_a.map{|v|v[0]}.sort.should == %w[.filea dira filea]
     end
 
-    it "each returns Pa" do
+    it "returns Pa" do
       Pa.each { |pa|
         pa.should be_an_instance_of Pa
         break
       }
     end
+
 	end
 
   describe ".each" do
@@ -141,15 +150,30 @@ describe Pa do
 			FileUtils.touch %w[filea .filea filea~ dira/dirb/b]
 		end
 
-		it "each2_r -> Enumerator" do
+    it "=> Enumerator when call without any arguments" do
 			Pa.each2_r.should be_an_instance_of Enumerator
-		 	Pa.each2_r.with_object([]){|(pa,r),m|m<<r}.sort.should == %w[.filea dira dira/dirb dira/dirb/b filea filea~]
 		end
 
-    it "with :absolute => true" do
-      Pa.each2_r(:absolute => true).to_a[0][0].should == File.join(Dir.pwd, "filea~")
+    it "list directory recursive" do
+		 	Pa.each2_r.map{|v,|v}.sort.should == %w[.filea dira dira/dirb dira/dirb/b filea filea~]
+    end
+
+    it "(:base_dir => x) to build clean path" do
+      Pa.each2_r("dira").to_a.map{|v|v[0]}.should == %w[dira/dirb dira/dirb/b]
+      Pa.each2_r(".", :base_dir => "dira").to_a.map{|v|v[0]}.should == %w[dirb dirb/b]
+      Pa.each2_r(".", :base_dir => Pa("dira")).to_a.map{|v|v[0]}.should == %w[dirb dirb/b]
     end
+	end
 
+	describe ".each_r" do
+		# filea .filea filea~ 
+		# dira/
+		#   dirb/
+		#     b
+		before :each do 
+			FileUtils.mkdir_p %w[dira/dirb]
+			FileUtils.touch %w[filea .filea filea~ dira/dirb/b]
+		end
 
     it "#each_r returns Pa" do
       Pa.each_r { |pa|
@@ -163,22 +187,77 @@ describe Pa do
 		# filea 
 		# dira/
 		# 	fileb
+    # dirb/
+    #   dirb1/
+    #     fileb1
 		before :each do 
-			FileUtils.mkdir_p %w[dira]
-			FileUtils.touch %w[filea dira/fileb]
+			FileUtils.mkdir_p %w[dira dirb/dirb1]
+			FileUtils.touch %w[filea dira/fileb dirb/dirb1/fileb1]
 		end
 
 		it "works" do
-			Pa.ls2.should == %w[filea dira]
-      Pa.ls2(Dir.pwd).should == %w[filea dira]
+			Pa.ls2.should == %w[filea dira dirb]
+      Pa.ls2("dira").should == %w[fileb]
 		end
 
-    it "with :absolute => true" do
-      Pa.ls2(:absolute => true).should == %w[filea dira].map{|v| File.join(Dir.pwd, v)}
+    it "list multi paths" do
+      Pa.ls2("dira", "dirb").should == %w[fileb dirb1]
     end
 
-		it "call a block" do
-			Pa.ls2 { |p, fn| File.directory?(p)  }.should == ["dira"]
+    it "(:absolute => true) returns absolute path" do
+      Pa.ls2("dira", :absolute => true).should == [File.join(Dir.pwd, "dira/fileb")]
+    end
+
+    it %~(:include => true) returns "<path>/foo"~ do
+      Pa.ls2("dira", :include => true).should == %w[dira/fileb]
+    end
+
+    it "(:base_dir => x)" do
+      Pa.ls2("dirb1", :base_dir => "dirb").should == %w[fileb1]
+      Pa.ls2("dirb1", :base_dir => "dirb", :include => true).should == %w[dirb1/fileb1]
+    end
+
+		it "call a block returns filtered result" do
+			Pa.ls2 {|p| File.directory?(p)}.should == %w[dira dirb]
+		end
+  end
+
+	describe ".ls2_r" do
+		# filea 
+		# dira/
+		# 	fileb
+    # dirb/
+    #   dirb1/
+    #     fileb1
+		before :each do 
+			FileUtils.mkdir_p %w[dira dirb/dirb1]
+			FileUtils.touch %w[filea dira/fileb dirb/dirb1/fileb1]
+		end
+
+		it "works" do
+			Pa.ls2_r.should == %w[filea dira dira/fileb dirb dirb/dirb1 dirb/dirb1/fileb1]
+      Pa.ls2_r("dirb").should == %w[dirb1 dirb1/fileb1]
+		end
+
+    it "list multi paths" do
+      Pa.ls2_r("dira", "dirb").should == %w[fileb dirb1 dirb1/fileb1]
+    end
+
+    it "(:absolute => true) returns absolute path" do
+      Pa.ls2_r("dirb", :absolute => true).should == %w[dirb/dirb1 dirb/dirb1/fileb1].map{|v|File.join(Dir.pwd, v)}
+    end
+
+    it %~(:include => true) returns "<path>/foo"~ do
+      Pa.ls2_r("dirb", :include => true).should == %w[dirb/dirb1 dirb/dirb1/fileb1]
+    end
+
+    it "(:base_dir => x)" do
+      Pa.ls2_r("dirb1", :base_dir => "dirb").should == %w[fileb1]
+      Pa.ls2_r("dirb1", :base_dir => "dirb", :include => true).should == %w[dirb1/fileb1]
+    end
+
+		it "call a block returns filtered result" do
+			Pa.ls2_r {|p, fn| File.directory?(p)}.should == %w[dira dirb dirb/dirb1]
 		end
   end
 
@@ -192,16 +271,20 @@ describe Pa do
 		end
 
 		it "works" do
-			Pa.ls.should == %w[filea dira].map{|v| Pa(v)}
-      Pa.ls(Dir.pwd).should == %w[filea dira].map{|v| Pa(v)}
+			Pa.ls.should == %w[filea dira].map{|v|Pa(v)}
+      Pa.ls(Dir.pwd).should == %w[filea dira].map{|v|Pa(v)}
 		end
 
+    it "list multi paths" do
+      Pa.ls(".", "dira").should == %w[filea dira fileb].map{|v|Pa(v)}
+    end
+
     it "with :absolute => true" do
-      Pa.ls(:absolute => true).should == %w[filea dira].map{|v| Pa(File.join(Dir.pwd, v))}
+      Pa.ls(:absolute => true).should == %w[filea dira].map{|v|Pa(File.join(Dir.pwd, v))}
     end
 
 		it "call a block" do
-			Pa.ls{|p, fn| p.directory? }.should == %w[dira].map{|v| Pa(v)}
+			Pa.ls{|p, fn| p.directory? }.should == %w[dira].map{|v|Pa(v)}
 		end
   end
 

data/spec/pa/util_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+Util = Pa::Util
+
+describe Util do
+  describe ".join" do
+    it %~join(".", "foo") to "foo", not "./foo"~ do
+      Util.join(".", "a", "b").should == "a/b"
+      Util.join("a", "b", "c").should == "a/b/c"
+    end
+  end
+end
+

data/spec/pa_spec.rb

@@ -265,5 +265,4 @@ describe Pa do
       Pa.new("foo").build.should == Pa("foo")
     end
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pa
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-02 00:00:00.000000000 Z
+date: 2012-02-21 00:00:00.000000000 Z
 dependencies: []
 description: ! 'a path library for Ruby
 
@@ -39,6 +39,7 @@ files:
 - spec/pa/directory_spec.rb
 - spec/pa/path_spec.rb
 - spec/pa/state_spec.rb
+- spec/pa/util_spec.rb
 - spec/pa_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/GutenYe/pa