fast 0.0.2 → 0.0.3

data/README.rdoc

@@ -0,0 +1,30 @@
+= Fast
+
+DSL for file handling focused in intuitivity and semantics. 
+
+Library is pure Ruby 1.8.7, no FileUtils nor other dependencies (except Metafun for DSL delegation)
+
+== Installation
+
+Don't install right now, as 13-09-2011 this is pre-alpha, but in intensive development.
+
+== Philosophy
+
+<tt>Fast</tt> embraces the more straightforward view of files as strings of data and directories as arrays of files/directories. Some arguments:
+
+* It is more realistic in everyday usage
+* It makes them more object-like (and thus, more friendly to OOP)
+* Is more semantic
+* Files as IOs are still accessible through the harder-to-use native Ruby API
+
+<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
+* 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.
+
+== License
+
+GPL License. Why else?
+
+@ Xavier Via

data/lib/fast/dir-filter.rb

@@ -0,0 +1,9 @@
+module Fast
+  # Specific filter for Dir entries. Should inherit or invoke a Generic Filter
+  # Just a stub for the moment
+  class DirFilter
+    def initialize set
+      @set = set
+    end
+  end
+end

data/lib/fast/dir.rb

@@ -1,16 +1,117 @@
 module Fast
   # Directory handling class
-  class Dir
-    # .call -> like Fast::File.call
+  class Dir < Array
+    # .call -> like Fast::File.call -> NOUP: make delegator pattern Singleton-like
+    def initialize path = nil
+      super()
+      @path = normalize path if path
+    end
     
-    # #list
+    # Returns a Fast::Dir list with all items in the directory, except ".." and "."
+    def list path = nil, &block
+      @path = normalize path if path
+      ::Dir.foreach @path do |entry|
+        unless entry == "." or entry == ".."
+          self << entry 
+          block.call entry if block
+        end
+      end
+      self
+    end
     
-    # #files
+    # Returns a Fast::Dir list of all files in the directory. Non recursive 
+    # (at least yet)
+    def files path = nil, &block
+      @path = normalize path if path
+      ::Dir.foreach @path do |entry|
+        unless ::File.directory? "#{@path}/#{entry}"
+          self << entry 
+          block.call entry if block
+        end
+      end
+      self
+    end
     
-    # #dirs
+    # Returns a Fast::Dir list of all directories in the directory, non-recursive
+    # and excluding points
+    def dirs path = nil, &block
+      @path = normalize path if path
+      ::Dir.foreach @path do |entry|
+        if ::File.directory? "#{@path}/#{entry}" and entry != "." and entry != ".."
+          self << entry 
+          block.call entry if block
+        end
+      end
+      self
+    end
+
+    # Creates the dir, if it doesn't exist. Otherwise remains silent
+    def create path = nil
+      @path = normalize path if path
+      route = []
+      @path.split("/").each do |part|
+        unless part.empty?
+          route << part
+          unless ::File.directory? route.join "/"
+            ::Dir.mkdir route.join "/" 
+          end
+        end
+      end unless ::File.directory? @path
+      self
+    end
     
-    # #create
+    alias :create! :create
   
-    # #exist?
+    # Deletes the directory along with all its content. Powerful, simple, risky!
+    def delete path = nil
+      @path = normalize path if path
+      Dir.new.list @path do |entry|
+        if ::File.directory? "#{@path}/#{entry}"
+          Dir.new.delete "#{@path}/#{entry}" 
+        else
+          ::File.unlink "#{@path}/#{entry}" 
+        end
+      end
+      ::Dir.unlink @path
+      @path
+    end
+  
+    alias :delete! :delete
+    alias :destroy :delete
+    alias :del :delete
+    alias :unlink :delete
+    
+    # Checks for existence. True if the directory exists, false otherwise
+    def exist? path = nil
+      @path = normalize path if path
+      ::File.directory? @path
+    end
+    
+    alias :exists? :exist?
+  
+    # Returns a String brief of the dir
+    def to_s
+      return "#{@path}"
+    end
+    
+    # Sends self to a DirFilter filter
+    def filter
+      DirFilter.new self
+    end
+    
+    alias :by :filter
+
+    # Expands the path to absolute is it is relative
+    def expand path = nil
+      @path = normalize path if path
+      ::File.expand_path @path
+    end
+    
+    alias :absolute :expand
+        
+    private
+      def normalize path
+        @path = "#{path}"
+      end
   end
 end

data/lib/fast/file-filter.rb

@@ -0,0 +1,9 @@
+module Fast
+  # Specific filter for File entries. Should inherit or invoke a Generic Filter
+  # Just a stub for the moment
+  class FileFilter
+    def initialize set
+      @set = set
+    end
+  end
+end

data/lib/fast/file.rb

@@ -1,11 +1,26 @@
 module Fast
   # File handling class.
-  class File
+  class File < String
+  
+    # Initializes the file
+    def initialize source = nil
+      unless source.nil?
+        super( "#{source}" ) 
+      else
+        super()
+      end
+    end
+    
     # Appends the passed content to the file `path`
     # Creates the file if it doesn't exist.
     # Creates all the necesary folders if they don't exist
-    def append path, content
-      @path = normalize path
+    def append *args
+      if args.length > 1
+        path, content = *args 
+        @path = normalize path
+      else
+        content = args.first
+      end
       Fast.dir! ::File.dirname @path if ::File.dirname(@path) != "."
       ::File.open @path, "a" do |handler|
         handler.write content
@@ -14,8 +29,8 @@ module Fast
     end
     
     # Deletes the file (wrapper for `File.unlink <path>`)
-    def delete path
-      @path = normalize path
+    def delete path = nil
+      @path = normalize path if path
       ::File.unlink @path
       @path
     end
@@ -23,18 +38,57 @@ module Fast
     alias :destroy :delete
     alias :unlink :delete
     alias :del :delete
+    alias :delete! :delete
     
     # Touches the file passed. Like bash `touch`, but creates
     # all required directories if they don't exist
     def touch path
-      @path = normalize path
-      Fast.dir! ::File.dirname @path if ::File.dirname(@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 ""
       end
       @path
     end
     
+    alias :create :touch
+    alias :create! :touch
+    
+    # Returns the contents of the file, all at once
+    def read path
+      @path = normalize path if path
+      ::File.read @path
+    end
+
+    # Returns true if file exists, false otherwise
+    def exist? path
+      @path = normalize path if path
+      ::File.exist? @path
+    end
+    
+    alias :exists? :exist?
+    
+    # Sends self to a FileFilter filter
+    def filter
+      FileFilter.new self
+    end
+    
+    alias :by :filter
+    
+    # Expands the path if it's a relative path
+    def expand path = nil
+      @path = normalize path if path
+      ::File.expand_path @path
+    end
+    
+    alias :absolute :expand
+        
+    private
+      def normalize path
+        "#{path}"
+      end
+    
+    # Deprecated!
     def self.call *args
       if args.empty?
         File.new
@@ -42,10 +96,5 @@ module Fast
         ::File.read args.shift
       end
     end
-    
-    private
-      def normalize path
-        "#{path}"
-      end
   end
 end

data/lib/fast/version.rb

@@ -1,3 +1,3 @@
 module Fast
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/fast.rb

@@ -2,6 +2,8 @@ require "metafun/delegator"
 
 require "fast/file"
 require "fast/dir"
+require "fast/dir-filter"
+require "fast/file-filter"
 
 module Fast
   # Returns the list of entries in the directory
@@ -11,10 +13,11 @@ module Fast
   #     `:strip_extension => true`     # If an `:extension` is given, returns the
   #                                    # entries without it
   def self.dir path, options = nil
+    current = Dir.new path
     if options
       if options[:extension]
         filtered = []
-        ::Dir.entries(path).each do |entry|
+        current.list path do |entry|
           if entry.end_with? ".#{options[:extension]}"
             if options[:strip_extension]
               filtered << entry[0..-("#{options[:extension]}".length)-2]
@@ -26,20 +29,25 @@ module Fast
         return filtered
       end
     else
-      ::Dir.entries path
+      current.list path
     end
   end
   
   # Like `dir`, but creates the directory if it does not exist
   def self.dir! path, options = nil
-    mkdir path unless dir? path
+    Dir.new.create! path unless dir? path
     dir path, options
   end
   
   # Returns true if a directory named `path` exists, false otherwise.
   # (wrapper for `File.directory? <path>`)
   def self.dir? path  
-    ::File.directory? path
+    Dir.new.exist? path
+  end
+  
+  # Example. This all will be deprecated when features are done
+  def self.file? path
+    File.new.exist? path
   end
   
   # Returns an instance of Fast::File and passed all methods 
@@ -47,17 +55,8 @@ module Fast
   def self.file *args
     Fast::File.call *args
   end
-  
-  private
-    def self.mkdir path
-      path.split("/").each do |part|
-        route ||= part
-        ::Dir.mkdir route unless route == "" || ::File.directory?( route )
-        route += "/#{path}"
-      end
-    end
 end
 
 include Metafun::Delegator
 
-delegate Fast, :dir, :dir?, :dir!, :file, :from
+delegate Fast, :dir, :dir?, :dir!, :file, :file?

data/spec/fast/dir_spec.rb

@@ -1,35 +1,348 @@
 require "fast"
+require "zucker/os"
 
 describe Fast::Dir do
+  shared_examples_for "any dir list" do 
+    context "a block is passed as an argument" do
+      it "should pass each entry as argument to the block" 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"
+        
+        iteration = []
+        list = Fast::Dir.new.send @method, "demo" do |entry|
+          iteration << entry
+        end 
+                
+        iteration.should == list
+        
+        Fast::Dir.new.delete! "demo"
+      end
+    end
+  end
+
   describe "#list" do 
-    it "should return a list of all items in the directory"
+    before :each do @method = :list end
+    it_behaves_like "any dir list"
+    
+    it "should return a list of all items in the directory, excluding '.' & '..'" do
+      ::File.should_not be_directory "demo"
+      ::Dir.mkdir "demo"
+      Fast::File.new.touch "demo/alice.txt"
+      Fast::File.new.touch "demo/betty.txt"
+      Fast::File.new.touch "demo/chris.txt"
+      ::Dir.mkdir "demo/subdir"
+      
+      Fast::Dir.new.list( "demo" ).should include "alice.txt"
+      Fast::Dir.new.list( "demo" ).should include "betty.txt"
+      Fast::Dir.new.list( "demo" ).should include "chris.txt"
+      Fast::Dir.new.list( "demo" ).should include "subdir"
+      Fast::Dir.new.list( "demo" ).should_not include ".."
+      Fast::Dir.new.list( "demo" ).should_not include "."
+    
+      ::Dir.unlink "demo/subdir"
+      ::File.unlink "demo/chris.txt"
+      ::File.unlink "demo/betty.txt"
+      ::File.unlink "demo/alice.txt"
+      ::Dir.unlink "demo"
+    end
   end
   
   describe "#files" do
-    it "should return a list of all files in the directory"
-    
-    context "args :extension => 'txt'" do
-      it "should return a list of all files with .txt as extension in the directory"
+    before :each do @method = :files end
+    it_behaves_like "any dir list"
+
+    it "should return a list of all files in the directory" do
+      ::File.should_not be_directory "demo"
+      ::Dir.mkdir "demo"
+      Fast::File.new.touch "demo/alice.txt"
+      Fast::File.new.touch "demo/betty.txt"
+      Fast::File.new.touch "demo/chris.txt"
+      ::Dir.mkdir "demo/subdir"
+      
+      Fast::Dir.new.files( "demo" ).should include "alice.txt"
+      Fast::Dir.new.files( "demo" ).should include "betty.txt"
+      Fast::Dir.new.files( "demo" ).should include "chris.txt"
+      Fast::Dir.new.files( "demo" ).should_not include "subdir"
+      Fast::Dir.new.files( "demo" ).should_not include ".."
+      Fast::Dir.new.files( "demo" ).should_not include "."
+        
+      ::Dir.unlink "demo/subdir"
+      ::File.unlink "demo/chris.txt"
+      ::File.unlink "demo/betty.txt"
+      ::File.unlink "demo/alice.txt"
+      ::Dir.unlink "demo"
     end
   end
   
   describe "#dirs" do
-    it "should return a list containing all dirs in the directory"
-    
-    context "args :skip => :dots" do
-      it "should return a list of dirs excluding '.' and '..'"
+    before :each do @method = :dirs end
+    it_behaves_like "any dir list"
+
+    it "should return a list containing all dirs in the directory, excludind dots" do
+      ::File.should_not be_directory "demo"
+      ::Dir.mkdir "demo"
+      Fast::File.new.touch "demo/alice.txt"
+      Fast::File.new.touch "demo/betty.txt"
+      Fast::File.new.touch "demo/chris.txt"
+      ::Dir.mkdir "demo/subdir"
+      ::Dir.mkdir "demo/endodir"
+      
+      Fast::Dir.new.dirs( "demo" ).should_not include "alice.txt"
+      Fast::Dir.new.dirs( "demo" ).should_not include "betty.txt"
+      Fast::Dir.new.dirs( "demo" ).should_not include "chris.txt"
+      Fast::Dir.new.dirs( "demo" ).should include "subdir"
+      Fast::Dir.new.dirs( "demo" ).should include "endodir"
+      Fast::Dir.new.dirs( "demo" ).should_not include ".."
+      Fast::Dir.new.dirs( "demo" ).should_not include "."
+        
+      ::Dir.unlink "demo/subdir"
+      ::Dir.unlink "demo/endodir"
+      ::File.unlink "demo/chris.txt"
+      ::File.unlink "demo/betty.txt"
+      ::File.unlink "demo/alice.txt"
+      ::Dir.unlink "demo"
     end
   end
   
-  describe "#create" do
+  shared_examples_for "any dir creation" do
     context "is a simple path" do
-      it "should create the dir"
+      it "should create the dir" do
+        ::File.should_not be_directory "demo"
+        
+        Fast::Dir.new.send @method, "demo"
+        ::File.should be_directory "demo"
+        ::Dir.unlink "demo"
+      end
   
-      it "should return the directory path"
+      it "should return the directory path" do
+        ::File.should_not be_directory "demo"
+        "#{Fast::Dir.new.create('demo')}".should include "demo"
+        ::Dir.unlink "demo"
+      end
     end
     
     context "it is nested within dirs" do
-      it "should create the directory tree"
+      it "should create the directory tree" do
+        ::File.should_not be_directory "demo"
+        
+        Fast::Dir.new.send @method, "demo/subdir"
+        ::File.should be_directory "demo"
+        ::File.should be_directory "demo/subdir"
+
+        ::Dir.unlink "demo/subdir"
+        ::Dir.unlink "demo"
+      end
+    end
+    
+    context "it is nested within several dirs" do
+      it "should create the directory tree" do
+        ::File.should_not be_directory "demo"
+        
+        Fast::Dir.new.send @method, "demo/in/several/subdirs"
+        ::File.should be_directory "demo/in/several/subdirs"
+
+        ::Dir.unlink "demo/in/several/subdirs"
+        ::Dir.unlink "demo/in/several"
+        ::Dir.unlink "demo/in"
+        ::Dir.unlink "demo"
+      end
     end
   end
+  
+  describe "#create" do
+    before :each do @method = :create end
+    it_behaves_like "any dir creation"
+  end
+  
+  describe "#create!" do
+    before :each do @method = :create! end
+    it_behaves_like "any dir creation"
+  end
+  
+  shared_examples_for "any dir subsetter" do
+    # This is a reminder: along with Serializer, the Subsette pattern
+    # (and later, the Sorting one) should be implemented Fast
+    
+    # I guess filtering in Fast will be done in Fast::DirFilter
+    it "should forward self to a filtering object" do
+      Fast::Dir.new.should_not exist "demo"
+      Fast::File.new.touch "demo/in/subdir.file"
+      
+      the_demo_dir = Fast::Dir.new :demo
+      
+      Fast::DirFilter.should_receive( :new ).with the_demo_dir
+      
+      the_demo_dir.by
+      
+      the_demo_dir.delete!
+    end   
+  end
+
+  describe "#by" do 
+    before :each do @method = :by end
+    it_behaves_like "any dir subsetter"
+  end
+  
+  describe "#filter" do
+    before :each do @method = :filter end
+    it_behaves_like "any dir subsetter"
+  end
+
+  
+  shared_examples_for "any dir deletion" do
+    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
+    
+    it "should delete the directory if it exists" do
+      ::File.should_not be_directory "demo"
+      Fast::Dir.new.create "demo"
+      Fast::Dir.new.send @method, "demo"
+      ::File.should_not be_directory "demo"
+    end
+    
+    context "the dir has content" do
+      it "should delete the content and the dir" do
+        ::File.should_not be_directory "demo"
+        
+        Fast::Dir.new.create "demo"
+        Fast::Dir.new.create "demo/subdir"
+        Fast::File.new.touch "demo/in/subdir.txt"
+        
+        Fast::Dir.new.send @method, "demo"
+        
+        ::File.should_not exist "demo/in/subdir.txt"
+        ::File.should_not be_directory "demo/in"
+        ::File.should_not be_directory "demo/subdir"
+        ::File.should_not be_directory "demo"
+      end
+    end
+    
+    it "should return the deleted dir path" do
+      ::File.should_not be_directory "demo"
+      Fast::Dir.new.create "demo"
+      Fast::Dir.new.send( @method, "demo" ).should == "demo"
+    end
+  end
+
+  describe "#delete" do
+    before :each do @method = :delete end
+    it_behaves_like "any dir deletion" 
+  end
+  
+  describe "#delete!" do
+    before :each do @method = :delete! end
+    it_behaves_like "any dir deletion"
+  end
+  
+  describe "#del" do 
+    before :each do @method = :del end
+    it_behaves_like "any dir deletion" 
+  end
+  
+  describe "#destroy" do 
+    before :each do @method = :destroy end
+    it_behaves_like "any dir deletion" 
+  end
+  
+  describe "#unlink" do 
+    before :each do @method = :unlink end
+    it_behaves_like "any dir deletion" 
+  end
+  
+  shared_examples_for "any dir existencialism" do
+    it "should return true if the dir exists" do
+      ::File.should_not be_directory "demo"
+      Fast::Dir.new.create! "demo"
+      Fast::Dir.new.send( @method, "demo" ).should be_true
+      Fast::Dir.new.delete! "demo"
+    end
+    
+    it "should return false if the dir does not exist" do
+      ::File.should_not be_directory "demo"
+      Fast::Dir.new.send( @method, "demo" ).should be_false
+    end
+  end
+  
+  describe "#exist?" do
+    before :each do @method = :exist? end
+    it_behaves_like "any dir existencialism"
+  end
+  
+  describe "#exists?" do
+    before :each do @method = :exists? end
+    it_behaves_like "any dir existencialism"
+  end
+  
+  describe ".new" do
+    it "should accept a string path as argument" do
+      Fast::Dir.new "demo"
+    end
+    
+    it "should accept a symbol path as argument" do
+      Fast::Dir.new :demo
+    end
+  end
+  
+  describe "#to_s" do
+    it "should include the path to the dir" do
+      Fast::Dir.new.should_not exist "demo"
+      Fast::Dir.new(:demo).to_s.should include "demo"
+    end
+  end
+
+  shared_examples_for "any dir absolutizer" do
+    context "dir path is a relative route" do
+      it "should expand the dir path with the pwd" do
+        Fast::Dir.new.send( @method, :demo ).should == "#{Dir.pwd}/demo"
+      end
+    end
+    
+    context "dir path is an absolute route" do
+      it "should return the same path as given" do
+        unless OS.windows?
+          Fast::Dir.new.send( @method, "/dev/null").should == "/dev/null"
+        else
+          pending "POSIX only!"
+        end
+      end
+    end
+  end
+
+  describe "#expand" do
+    before :each do @method = :expand end
+    it_behaves_like "any dir absolutizer"
+  end
+  
+  describe "#absolute" do
+    before :each do @method = :absolute end
+    it_behaves_like "any dir absolutizer"
+  end
+  
+  describe "#rename" do
+    it "should change the dir's name"
+  end
+
+  describe "#[]" do
+    context "a file named like the argument exists" do
+      it "should return it"
+    end
+    
+    context "a dir named like the argument exists" do
+      it "should return it"
+    end
+    
+    context "there's nothing there" do
+      it "should return nil"
+    end
+  end
+  
+  describe "#[]=" do # This is an absolute WIN
+    it "should create the file with the given content"
+  end
+
 end

data/spec/fast/file_spec.rb

@@ -47,10 +47,7 @@ describe Fast::File do
       ::File.unlink "demo.txt"
     end
     
-    it "should return the path to the file" do
-      Fast::File.new.append( "demo.txt", "Hola." ).should == "demo.txt"
-      ::File.unlink "demo.txt" 
-    end
+    it "should return the file"
     
     it "should work even when a symbol is passed as argument" do
       Fast::File.new.append :demo_txt, "Hola."
@@ -69,14 +66,23 @@ describe Fast::File do
     end
   end
   
+  describe "#write" do
+    it "should create the file if it does not exist"
+    
+    it "should write the given content into the file"
+    
+    it "should overwrite the file if it exists"
+    
+    it "should return the file"
+  end
 
-  shared_examples_for "any deletion" do
+  shared_examples_for "any file deletion" do
     it "should delete the file" do
       ::File.open "demo.txt", "w" do |file|
         file.write "Hola."
       end
       
-      Fast::File.new.delete "demo.txt"
+      Fast::File.new.send @method, "demo.txt"
       ::File.should_not exist "demo.txt"
     end
     
@@ -85,7 +91,7 @@ describe Fast::File do
         file.write "Hola."
       end
       
-      Fast::File.new.delete( "demo.txt" ).should == "demo.txt"
+      Fast::File.new.send( @method, "demo.txt" ).should == "demo.txt"
     end
     
     it "should be possible to use a symbol" do
@@ -93,42 +99,73 @@ describe Fast::File do
         file.write "Hola."
       end
       
-      Fast::File.new.delete :demo_txt
+      Fast::File.new.send @method, :demo_txt
       ::File.should_not exist "demo.txt"
     end
   end
   
-  describe "#delete" do it_behaves_like "any deletion" end
-  describe "#unlink" do it_behaves_like "any deletion" end
-  describe "#del" do it_behaves_like "any deletion" end
-  describe "#destroy" do it_behaves_like "any deletion" end
+  describe "#delete" do
+    before :each do @method = :delete end
+    it_behaves_like "any file deletion" 
+  end
+
+  describe "#delete!" do
+    before :each do @method = :delete! end
+    it_behaves_like "any file deletion" 
+  end
   
-  describe "#touch" do
+  describe "#unlink" do
+    before :each do @method = :unlink end
+    it_behaves_like "any file deletion"
+  end
+  
+  describe "#del" do 
+    before :each do @method = :del end
+    it_behaves_like "any file deletion" 
+  end
+  
+  describe "#destroy" do 
+    before :each do @method = :destroy end
+    it_behaves_like "any file deletion"
+  end
+  
+  shared_examples_for "any file creation" do
     context "in current folder" do
       it "should create the file if it does not exist" do
         ::File.should_not exist "demo.txt"
-        Fast::File.new.touch "demo.txt"
+        Fast::File.new.send @method, "demo.txt"
         ::File.should exist "demo.txt"
         ::File.unlink "demo.txt"
-      end
-      
+      end      
     end
-    
     context "the file is inside a directory" do
       it "should create the file if it does not exist" do
         ::Dir.mkdir "demo" unless ::File.directory? "demo"
         ::File.should_not exist "demo/demo.txt"
-        Fast::File.new.touch "demo/demo.txt"
+        Fast::File.new.send @method, "demo/demo.txt"
         ::File.should exist "demo/demo.txt"
         ::File.unlink "demo/demo.txt"
         ::Dir.unlink "demo"
       end
     end
     
+    context "the file is inside several non existing directories" do
+      it "should create all the required directory tree" do
+        ::File.should_not be_directory "demo"
+        Fast::File.new.send @method, "demo/in/several/subdirs/file.txt"
+        ::File.should exist "demo/in/several/subdirs/file.txt"
+        ::File.unlink "demo/in/several/subdirs/file.txt"
+        ::Dir.unlink "demo/in/several/subdirs"
+        ::Dir.unlink "demo/in/several"
+        ::Dir.unlink "demo/in"
+        ::Dir.unlink "demo"
+      end   
+    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.touch "demo/demo.txt"
+        Fast::File.new.send @method, "demo/demo.txt"
         ::File.should exist "demo/demo.txt"
         ::File.unlink "demo/demo.txt"
         ::Dir.unlink "demo"
@@ -139,10 +176,42 @@ describe Fast::File do
       ::File.open "demo.txt", "w" do |file|
         file.write "something"
       end
-      Fast::File.new.touch "demo.txt"
+      Fast::File.new.send @method, "demo.txt"
+      ::File.unlink "demo.txt"
+    end
+    
+    it "should be empty if it did not exist" do
+      ::File.should_not exist "demo.txt"
+      Fast::File.new.send @method, "demo.txt"
+      ::File.read( "demo.txt" ).should == ""
       ::File.unlink "demo.txt"
     end
     
+    it "should return the path to the file" do
+      Fast::File.new.send( @method, "demo.txt" ).should == "demo.txt"
+      ::File.unlink "demo.txt"
+    end
+    
+    it "should accept a symbol as an argument" do
+      Fast::File.new.send @method, :demo_txt
+      ::File.unlink "demo_txt"
+    end
+  end
+  
+  describe "#create" do
+    before :each do @method = :create end
+    it_behaves_like "any file creation"
+  end
+  
+  describe "#create!" do 
+    before :each do @method = :create! end
+    it_behaves_like "any file creation"
+  end
+  
+  describe "#touch" do
+    before :each do @method = :touch end
+    it_behaves_like "any file creation"
+    
     it "should change its atime if already exists" do
       unless OS.windows?
         ::File.open "demo.txt", "w" do |file|
@@ -157,22 +226,133 @@ describe Fast::File do
         pending "This is for POSIX only."
       end
     end
-
-    it "should be empty if it did not exist" do
-      ::File.should_not exist "demo.txt"
-      Fast::File.new.touch "demo.txt"
-      ::File.read( "demo.txt" ).should == ""
-      ::File.unlink "demo.txt"
+  end  
+  
+  describe "#read" do
+    context "the file exists" do
+      it "should return all the contents of the file" do
+        ::File.should_not exist "demo.txt"
+        Fast::File.new.append "demo.txt", "New content!"
+        Fast::File.new.read( "demo.txt" ).should == "New content!"
+        ::File.unlink "demo.txt"
+      end
+    
+      it "should change the atime of the file" do
+        ::File.should_not exist "demo.txt"
+        Fast::File.new.append "demo.txt", "New content!"
+        atime = ::File.atime "demo.txt"
+        sleep 1
+        Fast::File.new.read "demo.txt"
+        ::File.atime("demo.txt").should > atime
+        ::File.unlink "demo.txt"
+      end
+      
+      it "should accept a symbol as an argument" do
+        ::File.should_not exist "demo_txt"
+        Fast::File.new.append "demo_txt", "New content!"
+        Fast::File.new.read :demo_txt
+        ::File.unlink "demo_txt"
+      end
+      
+      context "a block is passed" do
+        it "should be passed a read-only file as an argument, as in File.open"
+      end
     end
     
-    it "should return the path to the file" do
-      Fast::File.new.touch( "demo.txt" ).should == "demo.txt"
-      ::File.unlink "demo.txt"
+    context "the file doesn't exist" do
+      it "should rise an exception" do
+        ::File.should_not exist "demo.txt"
+        expect { Fast::File.new.read "demo.txt"
+        }.to raise_error
+      end
+    end
+  end
+  
+  shared_examples_for "any file existencialism" do
+    it "should return true if file exists" do
+      ::File.should_not exist "demo.file"
+      Fast::File.new.create! "demo.file"
+      Fast::File.new.send( @method, "demo.file" ).should be_true
+      Fast::File.new.delete "demo.file"
     end
     
-    it "should accept a symbol as an argument" do
-      Fast::File.new.touch :demo_txt
-      ::File.unlink "demo_txt"
+    it "should return false if file does not exist" do
+      ::File.should_not exist "demo.file"
+      Fast::File.new.send( @method, "demo.file" ).should be_false
+    end
+  end
+  
+  describe "#exist?" do
+    before :each do @method = :exist? end
+    it_behaves_like "any file existencialism"
+  end
+  
+  describe "#exists?" do
+    before :each do @method = :exists? end
+    it_behaves_like "any file existencialism"
+  end
+  
+  shared_examples_for "any file subsetter" do
+    # 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
+    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
+      the_demo_file.by
+    end   
+  end
+  
+  describe "#by" do 
+    before :each do @method = :by end
+    it_behaves_like "any file subsetter"
+  end
+  
+  describe "#filter" do
+    before :each do @method = :filter end
+    it_behaves_like "any file subsetter"
+  end
+
+  describe ".new" do
+    it "should accept a string path as argument" do
+      Fast::File.new "demo"
+    end
+    
+    it "should accept a symbol path as argument" do
+      Fast::File.new :demo
     end
   end  
+
+  shared_examples_for "any file absolutizer" do
+    context "file path is a relative route" do
+      it "should expand the file path with pwd" do
+        Fast::File.new.send( @method, "demo.file" ).should == "#{Dir.pwd}/demo.file"
+      end
+    end
+    
+    context "file path is an absolute route" do
+      it "should return the same as given path" do
+        unless OS.windows?
+          Fast::File.new.send( @method, "/dev/null" ).should == "/dev/null"
+        else
+          pending "POSIX only!"
+        end
+      end
+    end
+  end
+  
+  describe "#expand" do
+    before :each do @method = :expand end
+    it_behaves_like "any file absolutizer"
+  end
+  
+  describe "#absolute" do
+    before :each do @method = :absolute end
+    it_behaves_like "any file absolutizer"
+  end
+  
+  describe "#rename" do
+    it "should change the file's name"
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Xavier Via
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-11 00:00:00 +01:00
+date: 2011-11-13 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -65,10 +65,13 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- README.rdoc
 - Rakefile
 - fast.gemspec
 - lib/fast.rb
+- lib/fast/dir-filter.rb
 - lib/fast/dir.rb
+- lib/fast/file-filter.rb
 - lib/fast/file.rb
 - lib/fast/version.rb
 - spec/fast/dir_spec.rb