fast 0.0.8 → 0.1.0

data/README.rdoc

@@ -6,11 +6,13 @@ Library is pure Ruby 1.8.7, no FileUtils nor other dependencies (except Metafun
 
 == Installation
 
-Don't install right now, as 13-09-2011 this is pre-alpha, but in intensive development.
+  gem install fast
+
+Cucumber features still to do, but specs are stable (2011-12-11)
 
 == Philosophy
 
-<tt>Fast</tt> embraces the more straightforward view of files as strings of data and directories as arrays of files/directories. Some arguments:
+<tt>Fast</tt> embraces the more straightforward view of files as strings of data and directories as arrays of files/directories. Some reasons:
 
 * It is more realistic in everyday usage
 * It makes them more object-like (and thus, more friendly to OOP)
@@ -20,8 +22,8 @@ Don't install right now, as 13-09-2011 this is pre-alpha, but in intensive devel
 <tt>Fast::Dir</tt> is a subclass of <tt>Array</tt>, usable as a hash, and <tt>Fast::File</tt> if a subclass of String.
 
 == Quick notes
-* Move all Fast code to fast/main.rb. Update Metafun/Delegator so it will inject the #delegate method into every Object instance. Reduce the "fast.rb" to a call to external libraries, fast/main and DSLization via #delegate.
-* Describe the SubSetter pattern for filtering. 
+* Read bytes as binary ASCII-8BIT always and then try to perform an heuristic conversion, if there is any reasonable way to do it. Otherwise, leave it to the user. Google: "ruby string encode utf-8 ascii" for some good readings.
+* Apply the SubSetter pattern for filtering instead of FileFilter and DirFilter ad described in http://xaviervia.com.ar/patterns/sub-setter
 * File lists as returned by Fast::Dir#list and Fast::Dir#dirs will be filtered after the list is retrieved by a set of filtering methods of the returned list, which should be an instance of Fast::Dir. 
 * An instance of Fast::Dir should be possible to be created from a Array.
 * The path can be setted indirectly by any method of Fast::File instances, and the same works for Dir. This is fine because allows for very quick calls, but once an instance gets a path setted it should be fixed and raise an exception in case some other method call is trying to change it.

data/lib/fast/dir.rb

@@ -44,22 +44,37 @@ module Fast
       self
     end
 
-    # Creates the dir, if it doesn't exist. Otherwise remains silent
+    # Creates the dir, if it doesn't exist. Otherwise raises an ArgumentException
     # Returns the last dir path passed as argument
     def create *args
-      raise ArgumentError, "No arguments passed, at least one is required" if args.empty?
       if args.length > 0
         return_me = nil
         args.each do |path|
+          raise ArgumentError, "Dir '#{path}' already exists" if Dir.new.exist? path
           return_me = do_create path
         end
         return return_me
       else
-        do_create
+        raise ArgumentError, "No arguments passed, at least one is required" unless @path
+        raise ArgumentError, "Dir '#{@path}' already exists" if Dir.new.exist? @path
+        do_create @path
+      end
+    end
+
+    # Creates the dir, if it doesn't exist. Otherwise remains silent
+    # Returns the last dir path passed as argument
+    def create! *args
+      if args.length > 0
+        return_me = nil
+        args.each do |path|
+          return_me = do_create path
+        end
+        return return_me
+      else
+        raise ArgumentError, "No arguments passed, at least one is required" unless @path
+        do_create @path
       end
     end
-    
-    alias :create! :create
   
     # Deletes the directory along with all its content. Powerful, simple, risky!
     # Many arguments can be passed
@@ -78,6 +93,7 @@ module Fast
     alias :destroy :delete
     alias :del :delete
     alias :unlink :delete
+    alias :remove :delete
     
     # Like #delete, but raises no error if some directory is missing
     def delete! *args
@@ -100,6 +116,8 @@ module Fast
       end
     end
     
+    alias :remove! :delete!
+    
     # Checks for existence. True if the directory exists, false otherwise
     def exist? path = nil
       @path = normalize path if path
@@ -107,6 +125,45 @@ module Fast
     end
     
     alias :exists? :exist?
+   
+    # Returns true if all passed dirs exist, false otherwise
+    def exist_all? *args
+      unless args.empty?
+        args.each do |path|
+          return false if not Dir.new.exist? path
+        end
+        return true
+      else
+        exist?
+      end
+    end
+    
+    # Returns true if any of passed dirs exists, false otherwise
+    def exist_any? *args
+      unless args.empty?
+        args.each do |path|
+          return true if Dir.new.exist? path
+        end
+        return false
+      else
+        exist?
+      end
+    end
+    
+    # Return a list with the existing dirs path
+    # Note: This should be delegated to the SubSetter::Fast::Dir
+    def exist_which *args
+      if args.empty?
+        raise ArgumentError, "Wrong number of arguments, at least one dir should be passed"
+      end
+      
+      existing_ones = []
+      args.each do |path|
+        existing_ones << path if Dir.new.exist? path
+      end
+
+      return existing_ones
+    end
   
     # Returns a String brief of the dir
     def to_s
@@ -183,6 +240,44 @@ module Fast
       Dir.new.delete target
     end
     
+    def copy *args
+      if args.length > 1
+        current, target = *args
+        @path = normalize current
+        target = Dir.new target
+      else
+        target = Dir.new args.first
+      end
+      
+      target.create
+      list do |entry|
+        if File.new.exist? "#{@path}/#{entry}" # This is a "is file?" check and should be more obvious
+          File.new.copy "#{@path}/#{entry}", "#{target.path}/#{entry}"
+        else # is a Dir then
+          Dir.new.copy "#{@path}/#{entry}", "#{target.path}/#{entry}"
+        end
+      end
+    end
+    
+    alias :copy! :copy
+    
+    def [] name
+      if name.is_a? Integer # I do not wish to disable Array behaviour
+        super
+      else
+        return Dir.new "#{@path}/#{name}" if dirs.include? normalize name
+        return File.new "#{@path}/#{name}" if files.include? normalize name
+      end
+    end
+    
+    def []= name, content
+      if name.is_a? Integer # I do not wish to disable Array behaviour
+        super 
+      else
+        return File.new.write "#{@path}/#{name}", content       
+      end
+    end
+    
     private
       def do_delete path = nil
         @path = normalize path if path

data/lib/fast/file.rb

@@ -22,11 +22,17 @@ module Fast
       else
         content = args.first
       end
-      Fast::Dir.new.create! ::File.dirname @path if ::File.dirname(@path) != "."
-      ::File.open @path, "a" do |handler|
-        handler.write content
-      end
-      self
+      
+      do_append content
+    end
+    
+    # Appends the passed content to the file
+    # Creates the file if it doesn't exist.
+    # Creates all the necesary folders if they don't exist
+    # Fails if file path is not defined
+    def << content
+      raise "No path specified in the file" unless @path
+      do_append content
     end
     
     # Writes data into the file. If is does not exist, creates it
@@ -45,27 +51,53 @@ module Fast
       self
     end
     
-    # Deletes the file (wrapper for `File.unlink <path>`)
-    def delete path = nil
-      @path = normalize path if path
-      ::File.unlink @path
-      @path
+    # Deletes the files (wrapper for `File.unlink <path>`)
+    # Fails if file does not exist
+    def delete *args
+      unless args.empty?
+        return_me = nil
+        args.each do |path|
+          return_me = normalize path
+          ::File.unlink return_me
+        end
+        return return_me
+      else
+        ::File.unlink @path
+        @path
+      end
     end
   
     alias :destroy :delete
     alias :unlink :delete
     alias :del :delete
-    alias :delete! :delete
+    
+    # Deletes the file(s) if it exists, does nothing otherwise
+    def delete! *args
+      unless args.empty?
+        return_me = nil
+        args.each do |path|
+          return_me = normalize path
+          ::File.unlink return_me if File.new.exist? path
+        end
+        return return_me
+      else
+        ::File.unlink @path if exist?
+        @path
+      end
+    end
     
     # Touches the file passed. Like bash `touch`, but creates
     # all required directories if they don't exist
-    def touch path
-      @path = normalize path if path
-      Fast::Dir.new.create ::File.dirname @path if ::File.dirname(@path) != "."
-      ::File.open @path, "a+" do |file|
-        file.gets; file.write ""
+    def touch *args
+      if args.length > 0
+        return_me = nil
+        args.each do |path|
+          return_me = do_create path
+        end
+        return return_me
+      else
+        do_create @path
       end
-      @path
     end
     
     alias :create :touch
@@ -78,14 +110,45 @@ module Fast
     end
 
     # Returns true if file exists, false otherwise
-    def exist? path
+    def exist? path = nil
       @path = normalize path if path
-      ::File.exist? @path
+      do_check_existence @path
     end
     
     alias :exists? :exist?
-    alias :exist_all? :exist?
-    alias :exist_any? :exist?
+    
+    def exist_all? *args
+      unless args.empty?
+        return_me = true
+        args.each do |path|
+          return_me &= do_check_existence path
+        end
+        return return_me
+      else
+        do_check_existence @path
+      end
+    end
+    
+    def exist_any? *args
+      unless args.empty?
+        return_me = false
+        args.each do |path|
+          return_me |= do_check_existence path
+        end
+        return return_me
+      else
+        do_check_existence @path
+      end
+    end
+    
+    def exist_which *args
+      raise ArgumentError, "Wrong number of arguments (at least one is needed)" if args.empty?
+      return_list = []
+      args.each do |path|
+        return_list << path if do_check_existence path
+      end
+      return_list
+    end
     
     # Sends self to a FileFilter filter
     def filter
@@ -137,11 +200,89 @@ module Fast
       @path if @path
     end
     
+    # Appends the contents of the target file into self and erase the target
+    def merge *args
+      if args.length > 1
+        source, target = *args
+        @path = normalize source
+        target = File.new target
+      else
+        target = File.new args.first
+      end
+      
+      raise Errno::ENOENT, "No such file - #{@path}" unless exist?
+      raise Errno::ENOENT, "No such file - #{target.path}" unless target.exist?
+      
+      append target.read
+      target.delete!
+      self
+    end
+    
+    # Returns true if the file is empty or does not exist
+    def empty? path = nil
+      @path = normalize path if path
+      return true if not exist?
+      read.empty?
+    end
+    
+    # Copies current file into target file. Does not rely on OS nor FileUtils
+    def copy *args
+      if args.length > 1
+        current, target = *args
+        @path = normalize current
+        target = File.new target
+      else
+        target = File.new args.first
+      end
+      
+      raise ArgumentError, "Target '#{target.path}' already exists." if target.exist?
+      do_copy target
+    end
+    
+    def copy! *args
+      if args.length > 1
+        current, target = *args
+        @path = normalize current
+        target = File.new target
+      else
+        target = File.new args.first
+      end
+      
+      do_copy target
+    end
+    
     private
       def normalize path
         "#{path}"
       end
+      
+      def do_copy target
+        target.write read
+        target
+      end
+            
+      def do_create path
+        path = normalize path
+        Fast::Dir.new.create! ::File.dirname path if ::File.dirname(path) != "."
+        ::File.open path, "a+" do |file|
+          file.gets; file.write ""
+        end
+        path
+      end
+
     
+      def do_append content
+        touch @path unless exist?
+        ::File.open @path, "a" do |handler|
+          handler.write content
+        end
+        self
+      end
+      
+      def do_check_existence path
+        ::File.exist?(path) && !::File.directory?(path)
+      end
+
     # Deprecated!
     def self.call *args
       if args.empty?

data/lib/fast/version.rb

@@ -1,3 +1,3 @@
 module Fast
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end

data/spec/fast/dir_spec.rb

@@ -8,7 +8,7 @@ describe Fast::Dir do
         ::File.should_not be_directory "demo"
         Fast::File.new.touch "demo/myfile.txt"
         Fast::File.new.touch "demo/otherfile.txt"
-        Fast::Dir.new.create "demo/subdir"
+        Fast::Dir.new.create! "demo/subdir"
         
         iteration = []
         list = Fast::Dir.new.send @method, "demo" do |entry|
@@ -112,6 +112,16 @@ describe Fast::Dir do
       }.to raise_error ArgumentError, "No arguments passed, at least one is required"
     end
     
+    context "from an existing Dir object" do
+      it "should create the dir" do
+        Fast::Dir.new.should_not exist :demo
+        the_dir = Fast::Dir.new :demo
+        the_dir.send @method
+        the_dir.should exist
+        the_dir.remove
+      end
+    end
+    
     context "is a simple path" do
       it "should create the dir" do
         ::File.should_not be_directory "demo"
@@ -176,14 +186,30 @@ describe Fast::Dir do
     before :each do @method = :create end
     it_behaves_like "any dir creation"
     
-    it "should fail if the dir already exists"
+    it "should fail if the dir already exists" do
+      Fast::Dir.new.should_not exist :demo
+      Fast::Dir.new.create :demo
+      expect { Fast::Dir.new.create :demo
+      }.to raise_error ArgumentError, "Dir 'demo' already exists"
+      Fast::Dir.new.delete! :demo
+    end
+    
+    after do
+      Fast::Dir.new.delete! :demo
+    end
   end
   
   describe "#create!" do
     before :each do @method = :create! end
     it_behaves_like "any dir creation"
     
-    it "should do nothing if the dir already exists"
+    it "should do nothing if the dir already exists" do
+      Fast::Dir.new.should_not exist :demo
+      Fast::Dir.new.create :demo
+      expect { Fast::Dir.new.create! :demo
+      }.to_not raise_error ArgumentError, "Dir 'demo' already exists"
+      Fast::Dir.new.delete! :demo
+    end
   end
   
   shared_examples_for "any dir subsetter" do
@@ -313,6 +339,27 @@ describe Fast::Dir do
     end
   end
   
+  describe "#remove" do
+    before :each do @method = :remove end
+    it_behaves_like "any dir deletion" 
+
+    it "should fail if the directory does not exist" do
+      ::File.should_not be_directory "demo"
+      expect { Fast::Dir.new.send @method, "demo"
+      }.to raise_error
+    end
+  end
+  
+  describe "#remove!" do
+    before :each do @method = :remove! end
+    it_behaves_like "any dir deletion"
+    
+    it "should not fail even if the directory does not exist" do
+      Fast::Dir.new.should_not exist :demo
+      Fast::Dir.new.remove! :demo
+    end
+  end
+  
   shared_examples_for "any dir existencialism" do
     it "should return true if the dir exists" do
       ::File.should_not be_directory "demo"
@@ -337,6 +384,77 @@ describe Fast::Dir do
     it_behaves_like "any dir existencialism"
   end
   
+  describe "#exist_all?" do
+    before :each do @method = :exist_all? end
+    it_behaves_like "any dir existencialism"
+    
+    it "should return true if all exist" do
+      Fast::Dir.new.should_not exist :demo
+      Fast::Dir.new.should_not exist :demo2
+      Fast::Dir.new.should_not exist :demo3
+      
+      Fast::Dir.new.create :demo, :demo2, :demo3
+      
+      Fast::Dir.new.exist_all?(:demo, :demo2, :demo3).should be_true
+      
+      Fast::Dir.new.remove :demo, :demo2, :demo3
+    end
+    
+    it "should return false if any does not exist" do
+      Fast::Dir.new.should_not exist :demo
+      Fast::Dir.new.should_not exist :demo2
+      Fast::Dir.new.should_not exist :demo3
+      
+      Fast::Dir.new.create :demo, :demo2
+      
+      Fast::Dir.new.exist_all?(:demo, :demo2, :demo3).should be_false
+      
+      Fast::Dir.new.remove :demo, :demo2
+    end
+  end
+
+  describe "#exist_any?" do
+    it_behaves_like "any dir existencialism"
+    before :each do @method = :exist_any? end
+    
+    it "should return true if at least one exists" do
+      Fast::Dir.new.should_not exist :demo
+      Fast::Dir.new.should_not exist :demo2
+      Fast::Dir.new.should_not exist :demo3
+      
+      Fast::Dir.new.create :demo, :demo2
+      
+      Fast::Dir.new.exist_any?(:demo, :demo2, :demo3).should be_true
+      
+      Fast::Dir.new.remove! :demo, :demo2, :demo3
+    end
+    
+    it "should return false if none exists" do
+      Fast::Dir.new.should_not exist :demo
+      Fast::Dir.new.should_not exist :demo2
+      Fast::Dir.new.should_not exist :demo3
+            
+      Fast::Dir.new.exist_any?(:demo, :demo2, :demo3).should be_false
+    end
+  end
+  
+  describe "#exist_which" do
+    it "should return a list with the dir that exists" do
+      Fast::Dir.new.should_not exist :demo
+      Fast::Dir.new.should_not exist :demo2
+      Fast::Dir.new.should_not exist :demo3
+      
+      Fast::Dir.new.create :demo, :demo2
+      
+      the_list = Fast::Dir.new.exist_which :demo, :demo2, :demo3
+      the_list.should include :demo
+      the_list.should include :demo2
+      the_list.should_not include :demo3
+      
+      Fast::Dir.new.remove! :demo, :demo2, :demo3
+    end
+  end
+  
   describe ".new" do
     it "should accept a string path as argument" do
       Fast::Dir.new "demo"
@@ -468,27 +586,73 @@ describe Fast::Dir do
   end
   
   shared_examples_for "any dir copy" do
+    before :each do 
+      Fast::Dir.new.should_not exist :demo      
+      Fast::Dir.new.should_not exist :target
+    end
+    
     context "target dir do not exist" do
-      it "should create the target dir"
+      it "should create the target dir" do
+        Fast::Dir.new.create :demo
+        
+        Fast::Dir.new.send @method, :demo, :target
+        
+        Fast::Dir.new.should exist :target
+      end
       
-      it "should not erase current dir"
+      it "should not erase current dir" do
+        Fast::Dir.new.create :demo
+        
+        Fast::Dir.new.send @method, :demo, :target
+        
+        Fast::Dir.new.should exist :demo
+      end
     end
     
-    it "should be present all of source data in the target"
+    it "should be present all of source data in the target" do        
+      # Create demo data
+      Fast::File.new.touch "demo/content.txt"
+      Fast::File.new.touch "demo/more/content/in/subdir.txt"
+      Fast::Dir.new.create "demo/empty_dir"
+      
+      # Do the copying
+      Fast::Dir.new.send @method, :demo, :target
+      
+      # Check the copy
+      Fast::File.new.should exist "target/content.txt"
+      Fast::File.new.should exist "target/more/content/in/subdir.txt"
+      Fast::Dir.new.should exist "target/empty_dir"
+    end
     
-    it "should return current dir"
+    it "should return the current dir" do
+      the_dir = Fast::Dir.new.create! :demo
+      # Do the copying
+      the_dir.send(@method, :target).should be the_dir      
+    end
+    
+    after :each do
+      Fast::Dir.new.delete! :demo, :target
+    end
   end
   
   describe "#copy" do
     it_behaves_like "any dir copy"
+    before :all do @method = :copy end
     
-    it "should fail if any conflict appears"
+    context "in case of conflict in any file" do
+      it "should fail"
+    
+      it "should not do any copying"
+    end
   end
   
   describe "#copy!" do
     it_behaves_like "any dir copy"
+    before :all do @method = :copy! end
     
-    it "should overwrite in every conflict"
+    context "in case of conflict" do
+      it "should overwrite"
+    end
   end
   
   describe "#merge" do
@@ -528,7 +692,7 @@ describe Fast::Dir do
       Fast::File.new.should exist "demo/data/nested/is.informative.file"
     end
     
-    context "two fails in the source and target have the same name" do
+    context "two files in the source and target have the same name" do
       it "should fail"
       
       it "should not do any changes in any dir"
@@ -544,7 +708,7 @@ describe Fast::Dir do
     it "should behave like #merge but never fail"
   end
 
-  describe "#mergeable?" do
+  describe "#conflicts?" do
     context "both dirs exist and no file or dir in any has the same name in the other" do
       it "should return true"
     end
@@ -552,26 +716,78 @@ describe Fast::Dir do
     context "some files in target dir have the same name as other in source" do
       it "should return false"
     end
-    
-    it "should fail it the target dir does not exist"
   end
   
   describe "#[]" do
+    before :each do
+      Fast::Dir.new.should_not exist :demo
+    end
+    
     context "a file named like the argument exists" do
-      it "should return it"
+      it "should return it" do
+        Fast::File.new.touch "demo/file.txt"
+        
+        the_file = Fast::Dir.new(:demo)["file.txt"]
+        the_file.path.should == "demo/file.txt"
+      end
     end
     
     context "a dir named like the argument exists" do
-      it "should return it"
+      it "should return it" do
+        Fast::Dir.new.create "demo/other_dir"
+        the_dir = Fast::Dir.new(:demo)[:other_dir]
+        the_dir.path.should == "demo/other_dir"
+      end
+    end
+    
+    context "an integet is sent" do
+      it "should behave like an array" do
+        Fast::File.new.touch "demo/file.txt"
+        
+        Fast::Dir.new.list(:demo)[0].should == "file.txt"
+      end
     end
     
     context "there's nothing there" do
-      it "should return nil"
+      it "should return nil" do
+        Fast::Dir.new.create :demo
+        Fast::Dir.new.list(:demo)[:no].should be_nil
+      end
+    end
+
+    after :each do
+      Fast::Dir.new.delete! :demo
     end
   end
   
   describe "#[]=" do # This is an absolute WIN
-    it "should create the file with the given content"
+    before :each do 
+      Fast::Dir.new.should_not exist :demo
+    end
+    
+    context "the content is a String" do
+      it "should create the file with the given content" do
+        the_dir = Fast::Dir.new :demo # Showoff..
+        the_dir[:Pianofile] = "set :port, 80" # So condensed, so solid
+        Fast::File.new.read("demo/Pianofile").should == "set :port, 80"
+      end
+      
+      it "should create self" do
+        the_dir = Fast::Dir.new :demo # Showoff..
+        the_dir[:Pianofile] = "set :port, 80" # So condensed, so solid
+        Fast::Dir.new.should exist :demo
+      end
+    end
+    
+    context "the content is a hash" do
+      it "should create the subdir"
+      
+      it "should create recursively the tree"
+    end
+    
+    after :each do 
+      Fast::Dir.new.delete! :demo
+    end
   end
 
 end

data/spec/fast/file_spec.rb

@@ -5,35 +5,39 @@ require "zucker/os"
 ::File.unlink "demo.txt" if ::File.exist? "demo.txt"
 
 describe Fast::File do
-  describe "#append" do
+
+  shared_examples_for "any file content appending" do
     it "should create the file if it does not exist" do
       ::File.should_not exist "demo.txt"
-      Fast::File.new.append "demo.txt", "some text"
+      the_file = Fast::File.new "demo.txt"
+      the_file.send @method, "some text"
       ::File.should exist "demo.txt"
       ::File.unlink "demo.txt"
     end
-    
+
     it "should not erase the content of the file if it has some" do
       ::File.open "demo.txt", "w" do |file|
         file.write "some demo content"
       end
       
-      Fast::File.new.append "demo.txt", "\nmore demo content"
+      the_file = Fast::File.new "demo.txt"
+      the_file.send @method, "\nmore demo content"
       
       ::File.read( "demo.txt" ).should match /^some demo content/
       ::File.unlink "demo.txt"
     end
-    
+
     it "should append the new content last in the file" do
       ::File.open "demo.txt", "w" do |file|
         file.write "This comes first: "
       end
-      Fast::File.new.append "demo.txt", "and this comes after."
+      the_file = Fast::File.new "demo.txt"
+      the_file.send @method, "and this comes after."
       
       ::File.read( "demo.txt" ).should match /and this comes after.$/
       ::File.unlink "demo.txt"
     end
-    
+
     it "should update the modification time" do
       ::File.open "demo.txt", "w" do |file|
         file.write "Written earlier"
@@ -41,28 +45,18 @@ describe Fast::File do
       mtime = ::File.mtime "demo.txt"
       
       sleep 1
-      Fast::File.new.append "demo.txt", "\nWritten later"
+      the_file = Fast::File.new "demo.txt"
+      the_file.send @method, "\nWritten later"
       ::File.mtime( "demo.txt" ).should > mtime
       
       ::File.unlink "demo.txt"
     end
-    
-    it "should return the file" do
-      the_file = ::Fast::File.new.append "demo.file", "Some content."
-      the_file.should be_a Fast::File
-      the_file.delete!
-    end
-    
-    it "should work even when a symbol is passed as argument" do
-      Fast::File.new.append :demo_txt, "Hola."
-      ::File.should exist "demo_txt"
-      ::File.unlink "demo_txt"
-    end
 
     context "the file is inside a non existing directory" do
       it "should create the directory aswell as the file" do
         ::File.should_not be_directory "demo"
-        Fast::File.new.append "demo/demo.txt", "Nice content!"
+        the_file = Fast::File.new "demo/demo.txt"
+        the_file.send @method, "Nice content!"
         ::File.should be_directory "demo"
         ::File.unlink "demo/demo.txt"
         ::Dir.unlink "demo"
@@ -71,7 +65,25 @@ describe Fast::File do
   end
   
   describe "#<<" do
-    it "should behave almost like #append"
+    it_should_behave_like "any file content appending"
+    before :all do @method = :"<<" end
+  
+    it "should fail if not path previously defined" do
+      the_file = Fast::File.new
+      expect { the_file << "More content"
+      }.to raise_error "No path specified in the file"
+    end
+  end
+  
+  describe "#append" do
+    it_should_behave_like "any file content appending"
+    before :all do @method = :append end        
+        
+    it "should return the file" do
+      the_file = ::Fast::File.new.append "demo.file", "Some content."
+      the_file.should be_a Fast::File
+      the_file.delete!
+    end
   end
   
   describe "#write" do
@@ -134,6 +146,16 @@ describe Fast::File do
       Fast::File.new.send @method, :demo_txt
       ::File.should_not exist "demo.txt"
     end
+    
+    it "should accept multiple arguments" do
+      Fast::File.new.should_not exist "demo1.txt"
+      Fast::File.new.should_not exist "demo2.txt"
+      Fast::File.new.should_not exist "demo3.txt"
+    
+      Fast::File.new.touch "demo1.txt", "demo2.txt", "demo3.txt"
+      
+      Fast::File.new.send @method, "demo1.txt", "demo2.txt", "demo3.txt"
+    end
   end
   
   describe "#delete" do
@@ -144,6 +166,12 @@ describe Fast::File do
   describe "#delete!" do
     before :each do @method = :delete! end
     it_behaves_like "any file deletion" 
+    
+    it "should not fail if the file does not exist" do
+      Fast::File.new.should_not exist "the_file.txt"
+      expect { Fast::File.new.delete! "the_file.txt"
+      }.to_not raise_error
+    end
   end
   
   describe "#unlink" do
@@ -229,7 +257,21 @@ describe Fast::File do
       ::File.unlink "demo_txt"
     end
     
-    it "should work with multiple arguments"
+    it "should work with multiple arguments" do
+      Fast::File.new.should_not exist "demo1.txt" 
+      Fast::File.new.should_not exist "demo2.txt" 
+      Fast::File.new.should_not exist "demo3.txt"
+      
+      Fast::File.new.send @method, "demo1.txt", "demo2.txt", "demo3.txt"
+      
+      Fast::File.new.should exist "demo1.txt"
+      Fast::File.new.should exist "demo2.txt"
+      Fast::File.new.should exist "demo3.txt"
+      
+      Fast::File.new.delete "demo1.txt"
+      Fast::File.new.delete "demo2.txt"
+      Fast::File.new.delete "demo3.txt" 
+    end
   end
   
   describe "#create" do
@@ -315,7 +357,12 @@ describe Fast::File do
       Fast::File.new.send( @method, "demo.file" ).should be_false
     end
     
-    it "should return false if path represents a directory!"
+    it "should return false if path represents a directory!" do
+      Fast::Dir.new.should_not exist "demo"
+      Fast::Dir.new.create "demo"
+      Fast::File.new.send( @method, "demo" ).should be_false
+      Fast::Dir.new.delete "demo"
+    end
   end
   
   describe "#exist?" do
@@ -332,25 +379,105 @@ describe Fast::File do
     before :each do @method = :exist_all? end
     it_behaves_like "any file existencialism"
     
-    it "should return true if all exist"
+    it "should return true if all exist" do
+      # Create the demo files
+      Fast::File.new.touch "demo1.txt", "demo2.txt", "demo3.txt"
+      
+      # Try it
+      Fast::File.new.exist_all?("demo1.txt", "demo2.txt", "demo3.txt").should be_true
+    end
     
-    it "should return false if any does not exist"
+    it "should return false if any does not exist" do
+      Fast::File.new.touch "demo1.txt", "demo2.txt", "demo3.txt"
+      Fast::File.new.should_not exist "demo4.txt"
+      
+      Fast::File.new.exist_all?("demo2.txt", "demo4.txt", "demo1.txt").should be_false
+    end
+  
+    after :all do
+      # Clean after deeds
+      Fast::File.new.delete! "demo1.txt"
+      Fast::File.new.delete! "demo2.txt"
+      Fast::File.new.delete! "demo3.txt"
+    end
   end
   
   describe "#exist_any?" do
     before :each do @method = :exist_any? end
     it_behaves_like "any file existencialism"
     
-    it "should return true if at least one exists"
+    it "should return true if at least one exists" do
+      Fast::File.new.touch "demo1.txt"
+      Fast::File.new.should_not exist "demo2.txt"
+      
+      Fast::File.new.exist_any?("demo1.txt", "demo2.txt").should be_true
+    end
     
-    it "should return false if none exist"
+    it "should return false if none exist" do
+      Fast::File.new.should_not exist "demo2.txt"
+      Fast::File.new.should_not exist "demo3.txt"
+      
+      Fast::File.new.exist_any?("demo2.txt", "demo3.txt").should be_false
+    end
+    
+    after :all do 
+      Fast::File.new.delete "demo1.txt"
+    end
+  end
+  
+  describe "#exist_which" do
+    it "should return a list with the files that exist" do
+      Fast::File.new.should_not exist "demo1.txt"
+      Fast::File.new.should_not exist "demo2.txt"
+      Fast::File.new.should_not exist "demo3.txt"
+
+      Fast::File.new.touch "demo1.txt", "demo2.txt"
+      the_files = Fast::File.new.exist_which "demo1.txt", "demo2.txt", "demo3.txt"
+      the_files.should include "demo1.txt"
+      the_files.should include "demo2.txt"
+      the_files.should_not include "demo3.txt"      
+    end
+
+    after :all do
+      Fast::File.new.delete "demo1.txt"
+      Fast::File.new.delete "demo2.txt"
+    end
+  end
+  
+  describe "#empty?" do
+    it "should return true if the file has no content" do
+      Fast::File.new.should_not exist "demo.txt"
+      Fast::File.new.touch "demo.txt"
+      
+      Fast::File.new.empty?("demo.txt").should be_true
+    end
+    
+    it "should return true if the file does not exist" do
+      Fast::File.new.should_not exist "demo.txt"
+      
+      Fast::File.new.empty?("demo.txt").should be_true
+    end
+    
+    it "should return false if the file has content" do
+      Fast::File.new.should_not exist "demo.txt"
+      Fast::File.new.write "demo.txt", "Some irrelevant content."
+      
+      Fast::File.new.empty?("demo.txt").should be_false
+    end
+    
+    after :each do 
+      Fast::File.new.delete! "demo.txt"
+    end
   end
   
   shared_examples_for "any file subsetter" do
+    # This should follow more precisely the SubSetter pattern as specified
+    # on http://xaviervia.com.ar/patterns/sub-setter
+    #
     # This is a reminder: along with Serializer, the Subsetter pattern
     # (and later, the Sorting one) should be implemented Fast
-    
-    # I guess filtering in Fast will be done in Fast::FileFilter
+    #
+    # Fast::FileFilter will be deprecated soon
     it "should forward self to a filtering object" do      
       the_demo_file = Fast::File.new :demo
       Fast::FileFilter.should_receive( :new ).with the_demo_file
@@ -474,8 +601,117 @@ describe Fast::File do
   end
   
   describe "#merge" do
-    it "should delete the target file"
+    before :each do
+      Fast::File.new.should_not exist "demo.txt"
+      Fast::File.new.should_not exist "target.txt"
+      
+      Fast::File.new.write "demo.txt", "Basic content"
+      Fast::File.new.write "target.txt", "\nSome extra content"
+    end
+
+    it "should delete the target file" do      
+      Fast::File.new.merge "demo.txt", "target.txt"
+      
+      Fast::File.new.should_not exist "target.txt"
+      Fast::File.new.should exist "demo.txt"
+    end
     
-    it "should append the contents of the target into this"
+    it "should append the contents of the target into this" do
+      Fast::File.new.merge "demo.txt", "target.txt"
+      
+      Fast::File.new.read("demo.txt").should include "Basic content\nSome extra content"
+    end
+    
+    it "should return self" do
+      the_file = Fast::File.new "demo.txt"
+      the_file.merge("target.txt").should be the_file
+    end
+    
+    context "some is missing" do
+      it "should fail if self is missing" do 
+        expect { Fast::File.new.merge "hola.txt", "target.txt"
+        }.to raise_error Errno::ENOENT
+      end
+      
+      it "should fail if target is missing" do
+        expect { Fast::File.new.merge "demo.txt", "hola.txt"
+        }.to raise_error Errno::ENOENT
+      end
+    end
+    
+    after :each do
+      Fast::File.new.delete! "demo.txt"
+      Fast::File.new.delete! "target.txt"
+    end
+  end
+
+  shared_examples_for "any file copying" do
+    before :each do 
+      Fast::File.new.should_not exist "demo.txt"
+      Fast::File.new.write "demo.txt", "Need for content"
+    end
+    
+    it "should exist the target file after the copy" do
+      Fast::File.new.send @method, "demo.txt", "target.txt"
+      
+      Fast::File.new.should exist "target.txt"
+    end
+    
+    it "should exist the source file after the copy" do
+      Fast::File.new.send @method, "demo.txt", "target.txt"
+      
+      Fast::File.new.should exist "demo.txt"      
+    end
+    
+    it "should contain the same content both the source and the target files" do
+      Fast::File.new.send @method, "demo.txt", "target.txt"
+      
+      Fast::File.new.read("demo.txt").should == Fast::File.new.read("target.txt")
+    end
+    
+    after :each do 
+      Fast::File.new.delete! "demo.txt"
+      Fast::File.new.delete! "target.txt"
+    end
+  end
+  
+  describe "#copy" do
+    it_behaves_like "any file copying"
+    before :all do @method = :copy end
+    
+    context "the target file exists" do
+      it "should fail" do
+        Fast::File.new.should_not exist "demo.txt"
+        Fast::File.new.should_not exist "target.txt"
+        Fast::File.new.write "demo.txt", "Once upon a time."
+        Fast::File.new.write "target.txt", "A hobbit there was."
+        
+        expect { Fast::File.new.copy "demo.txt", "target.txt"
+        }.to raise_error ArgumentError, "Target 'target.txt' already exists."
+        
+        Fast::File.new.delete! "demo.txt"
+        Fast::File.new.delete! "target.txt"
+      end
+    end
+  end
+  
+  describe "#copy!" do
+    it_behaves_like "any file copying"
+    before :all do @method = :copy! end
+    
+    context "the target file exists" do
+      it "should overwrite the target file" do
+        Fast::File.new.should_not exist "demo.txt"
+        Fast::File.new.should_not exist "target.txt"
+        Fast::File.new.write "demo.txt", "Once upon a time."
+        Fast::File.new.write "target.txt", "A hobbit there was."
+        
+        Fast::File.new.copy! "demo.txt", "target.txt"
+        Fast::File.new.read("demo.txt").should == Fast::File.new.read("target.txt")
+        
+        Fast::File.new.delete! "demo.txt"
+        Fast::File.new.delete! "target.txt"        
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-17 00:00:00.000000000 Z
+date: 2011-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: metafun
-  requirement: &15528200 !ruby/object:Gem::Requirement
+  requirement: &15252960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *15528200
+  version_requirements: *15252960
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &15527120 !ruby/object:Gem::Requirement
+  requirement: &15252120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *15527120
+  version_requirements: *15252120
 - !ruby/object:Gem::Dependency
   name: zucker
-  requirement: &15526180 !ruby/object:Gem::Requirement
+  requirement: &15251420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *15526180
+  version_requirements: *15251420
 description: DSL for file system interaction
 email:
 - xavierviacanel@gmail.com