vfs 0.3.10 → 0.3.11

data/lib/vfs.rb

@@ -12,7 +12,6 @@
   
   entry_proxy
   
-  storages/hash_fs
   storages/local
   
   integration/string

data/lib/vfs/entries/dir.rb

@@ -177,7 +177,8 @@ module Vfs
         raise "can't copy to unknown Entry!"
       end
       
-      efficient_dir_copy(target, options) || unefficient_dir_copy(target, options)      
+      # efficient_dir_copy(target, options) || unefficient_dir_copy(target, options)
+      unefficient_dir_copy(target, options)      
       
       target
     end
@@ -196,8 +197,12 @@ module Vfs
       move_to to, options
     end
     
+    # class << self
+    #   attr_accessor :dont_use_efficient_dir_copy
+    # end
+    
     protected
-      def unefficient_dir_copy to, options       
+      def unefficient_dir_copy to, options   
         to.create options
         entries options do |e|        
           if e.is_a? Dir
@@ -210,64 +215,67 @@ module Vfs
         end
       end
       
-      def efficient_dir_copy to, options
-        storage.open_fs do |fs|
-          try = 0
-          begin                                
-            try += 1                    
-            self.class.efficient_dir_copy(self, to, options[:override])
-          rescue StandardError => error          
-            unknown_errors = 0
-          
-            attrs = get
-            if attrs[:file]
-              raise Error, "can't copy File as a Dir ('#{self}')!"
-            elsif attrs[:dir]
-              # some unknown error (but it also maybe caused by to be fixed error in 'to')
-              unknown_errors += 1   
-            else
-              raise Error, "'#{self}' not exist!" if options[:bang]
-              return true
-            end
-            
-            attrs = to.get
-            if attrs[:file]
-              if options[:override]
-                to.destroy
-              else
-                raise Vfs::Error, "entry #{to} already exist!"
-              end
-            elsif attrs[:dir]
-              unknown_errors += 1
-              # if options[:override]
-              #   to.destroy
-              # else
-              #   dir_already_exist = true              
-              #   # raise Vfs::Error, "entry #{to} already exist!"
-              # end
-            else # parent not exist
-              parent = to.parent
-              if parent.exist?
-                # some unknown error (but it also maybe caused by already fixed error in 'from')
-                unknown_errors += 1
-              else
-                parent.create(options)        
-              end        
-            end
-
-            raise error if unknown_errors > 1
-            try < 2 ? retry : raise(error)
-          end
-        end
-      end
       
-      def self.efficient_dir_copy from, to, override
-        from.storage.open_fs{|fs|
-          fs.respond_to?(:efficient_dir_copy) and fs.efficient_dir_copy(from, to, override)
-        } or
-        to.storage.open_fs{|fs|
-          fs.respond_to?(:efficient_dir_copy) and fs.efficient_dir_copy(from, to, override)
-        }
-      end
+      # def efficient_dir_copy to, options
+      #   return false if self.class.dont_use_efficient_dir_copy
+      #   
+      #   storage.open_fs do |fs|
+      #     try = 0
+      #     begin                                
+      #       try += 1                    
+      #       self.class.efficient_dir_copy(self, to, options[:override])
+      #     rescue StandardError => error          
+      #       unknown_errors = 0
+      #     
+      #       attrs = get
+      #       if attrs[:file]
+      #         raise Error, "can't copy File as a Dir ('#{self}')!"
+      #       elsif attrs[:dir]
+      #         # some unknown error (but it also maybe caused by to be fixed error in 'to')
+      #         unknown_errors += 1   
+      #       else
+      #         raise Error, "'#{self}' not exist!" if options[:bang]
+      #         return true
+      #       end
+      #       
+      #       attrs = to.get
+      #       if attrs[:file]
+      #         if options[:override]
+      #           to.destroy
+      #         else
+      #           raise Vfs::Error, "entry #{to} already exist!"
+      #         end
+      #       elsif attrs[:dir]
+      #         unknown_errors += 1
+      #         # if options[:override]
+      #         #   to.destroy
+      #         # else
+      #         #   dir_already_exist = true              
+      #         #   # raise Vfs::Error, "entry #{to} already exist!"
+      #         # end
+      #       else # parent not exist
+      #         parent = to.parent
+      #         if parent.exist?
+      #           # some unknown error (but it also maybe caused by already fixed error in 'from')
+      #           unknown_errors += 1
+      #         else
+      #           parent.create(options)        
+      #         end        
+      #       end
+      # 
+      #       raise error if unknown_errors > 1
+      #       try < 2 ? retry : raise(error)
+      #     end
+      #   end
+      # end
+      # 
+      # def self.efficient_dir_copy from, to, override
+      #   from.storage.open_fs{|fs|
+      #     fs.respond_to?(:efficient_dir_copy) and fs.efficient_dir_copy(from, to, override)
+      #   } or
+      #   to.storage.open_fs{|fs|
+      #     fs.respond_to?(:efficient_dir_copy) and fs.efficient_dir_copy(from, to, override)
+      #   }
+      # end
   end
 end

data/lib/vfs/entries/file.rb

@@ -69,7 +69,7 @@ module Vfs
           else
             fs.write_file(path, options[:append]){|writer| writer.call data}
           end
-        rescue StandardError => error      
+        rescue StandardError => error
           entry = self.entry
           if entry.exist?
             if options[:override]
@@ -86,7 +86,7 @@ module Vfs
               parent.create(options)        
             end
           end
-      
+
           retry if try < 2
         end
       end
@@ -159,7 +159,7 @@ module Vfs
         to.file      
       else
         raise "can't copy to unknown Entry!"
-      end      
+      end
       
       target.write options do |writer|
         read(options){|buff| writer.call buff}
@@ -191,7 +191,7 @@ module Vfs
       
       args.unshift Object.new if args.size == 1 and args.first.is_a?(Hash)
       
-      template = Tilt.new path
+      template = Tilt.new(path){read}
       template.render *args
     end
     

data/lib/vfs/storages/local.rb

@@ -1,10 +1,11 @@
+warn 'remove trailing spaces'
 require 'tempfile'
 
 module Vfs
   module Storages
     class Local
       module LocalVfsHelper
-        DEFAULT_BUFFER = 1024*128
+        DEFAULT_BUFFER = 1000 * 1024
         
         attr_writer :buffer
         def buffer
@@ -23,7 +24,7 @@ module Vfs
           # attributes special for file system
           attrs[:created_at] = stat.ctime
           attrs[:updated_at] = stat.mtime
-          attrs[:size] = stat.size
+          attrs[:size] = stat.size if stat.file?
           attrs
         rescue Errno::ENOENT
           {}
@@ -45,15 +46,18 @@ module Vfs
           end
         end
 
-        def write_file path, append, &block        
-          option = append ? 'a' : 'w'
+        def write_file path, append, &block
+          # TODO2 Performance lost, extra call to check file existence
+          raise "can't write, entry #{path} already exist!" if !append and ::File.exist?(path)
+          
+          option = append ? 'a' : 'w'          
           ::File.open path, option do |os|
             writer = -> buff {os.write buff}
             block.call writer
           end
         end
 
-        def delete_file path
+        def delete_file path          
           ::File.delete path
         end
 
@@ -70,6 +74,9 @@ module Vfs
         end
 
         def delete_dir path
+          # TODO2 Performance lost, extra call to check file existence
+          raise "can't delete file (#{path})!" if ::File.file?(path)
+          
           FileUtils.rm_r path
         end      
 
@@ -96,33 +103,20 @@ module Vfs
           end
         end
         
-        def efficient_dir_copy from, to, override          
-          return false if override # FileUtils.cp_r doesn't support this behaviour
-            
-          from.storage.open_fs do |from_fs|          
-            to.storage.open_fs do |to_fs|
-              if from_fs.local? and to_fs.local?
-                FileUtils.cp_r from.path, to.path
-                true
-              else
-                false
-              end
-            end
-          end
-        end
-
-        # def move_dir path
-        #   raise 'not supported'
-        # end
-
-        # def upload_directory from_local_path, to_remote_path
-        #   FileUtils.cp_r from_local_path, to_remote_path
+        # def efficient_dir_copy from, to, override          
+        #   return false if override # FileUtils.cp_r doesn't support this behaviour
+        #     
+        #   from.storage.open_fs do |from_fs|          
+        #     to.storage.open_fs do |to_fs|
+        #       if from_fs.local? and to_fs.local?
+        #         FileUtils.cp_r from.path, to.path
+        #         true
+        #       else
+        #         false
+        #       end
+        #     end
+        #   end
         # end
-        # 
-        # def download_directory from_remote_path, to_local_path
-        #   FileUtils.cp_r from_remote_path, to_local_path
-        # end
-
 
         # 
         # Other

data/spec/container_spec.rb

@@ -1,30 +1,29 @@
 require 'spec_helper'
 
 describe 'Container' do
-  before do
-    @fs = '/'.to_entry_on(Vfs::Storages::HashFs.new)
-  end
+  with_test_fs
   
   it "should threat paths as UniversalEntry except it ends with '/'" do
-    @fs.should_receive(:entry).with('/a/b')
-    @fs['/a/b']
+    test_fs.should_receive(:entry).with('tmp/a/b')
+    test_fs['tmp/a/b']
     
-    @fs.should_receive(:dir).with('/a/b')
-    @fs['/a/b/']
+    test_fs.should_receive(:dir).with('tmp/a/b')
+    test_fs['tmp/a/b/']
   end
   
   it '/' do
-    @fs[:some_path].should == @fs / :some_path
+    test_fs[:some_path].should == test_fs / :some_path
+    test_fs[:some_path][:another_path].should == test_fs / :some_path / :another_path
   end
   
   it "UniversalEntry should be wrapped inside of proxy, Dir and File should not" do
-    -> {@fs.dir.proxy?}.should raise_error(NoMethodError)
-    -> {@fs.file.proxy?}.should raise_error(NoMethodError)
-    @fs.entry.proxy?.should be_true
+    -> {test_fs.dir.proxy?}.should raise_error(NoMethodError)
+    -> {test_fs.file.proxy?}.should raise_error(NoMethodError)
+    test_fs.entry.proxy?.should be_true
   end
   
   it "sometimes it also should inexplicitly guess that path is a Dir instead of UniversalEntry (but still wrap it inside of Proxy)" do
-    dir = @fs['/a/..']
+    dir = test_fs['tmp/a/..']
     dir.proxy?.should be_true
     dir.should be_a(Vfs::Dir)
   end

data/spec/dir_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Dir' do
+  with_test_fs
+  
   before do
-    @fs = '/'.to_entry_on(Vfs::Storages::HashFs.new)
-    @path = @fs['/a/b/c']
+    @path = test_fs['a/b/c']
   end
   
   describe 'existence' do
@@ -195,28 +196,28 @@ describe 'Dir' do
         @to.file('other_file').read.should == 'other'
       end
     end
-    
+
     describe 'general copy' do   
       it_should_behave_like 'copy_to behavior'
       
       before do
-        # we using here another HashFs storage, to prevent :effective_dir_copy to be used
-        @to = '/'.to_entry_on(Vfs::Storages::HashFs.new)['to']
-        
-        @from.storage.should_not_receive(:for_spec_helper_effective_copy_used)
-      end            
+        # prevenging usage of :efficient_dir_copy
+        # Vfs::Dir.dont_use_efficient_dir_copy = true
+
+        @to = test_fs['to']
+      end
+      # after do
+      #   Vfs::Dir.dont_use_efficient_dir_copy = false
+      # end
     end    
     
-    describe 'effective copy' do
-      it_should_behave_like 'copy_to behavior'
-      
-      before do
-        # we using the same HashFs storage, so :effective_dir_copy will be used
-        @to = @fs['to']
-        
-        # @from.storage.should_receive(:for_spec_helper_effective_copy_used).at_least(1).times
-      end
-    end
+    # describe 'effective copy' do
+    #   it_should_behave_like 'copy_to behavior'
+    #   
+    #   before do
+    #     @to = test_fs['to']
+    #   end
+    # end
   end
     
   describe 'moving' do

data/spec/entry_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Entry' do
+  with_test_fs
+  
   before do
-    @fs = '/'.to_entry_on(Vfs::Storages::HashFs.new)
-    @path = @fs['/a/b/c']
+    @path = test_fs['a/b/c']
   end
   
   it "name" do
@@ -11,11 +12,11 @@ describe 'Entry' do
   end
   
   it 'tmp' do
-    tmp = @fs.tmp
+    tmp = test_fs.tmp
     tmp.should be_dir
     
     tmp = nil
-    @fs.tmp do |path|
+    test_fs.tmp do |path|
       tmp = path
       tmp.should be_dir
     end

data/spec/file_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'File' do
+  with_test_fs
+  
   before do
-    @fs = '/'.to_entry_on(Vfs::Storages::HashFs.new)
-    @path = @fs['/a/b/c']
+    @path = test_fs['a/b/c']
   end
   
   describe 'existence' do
@@ -67,15 +68,16 @@ describe 'File' do
       @path.read.should == 'something'
     end
     
-    it 'should override existing file if override specified' do
+    it 'should not override existing file, only if :override specified' do
       @path.write 'something'
       @path.should be_file
       -> {@path.write 'another'}.should raise_error(Vfs::Error, /exist/)
-      @path.write! 'another'
-      @path.read.should == 'another'
+      
+      @path.write! 'other'
+      @path.read.should == 'other'
     end
     
-    it 'should override existing dir if override specified' do
+    it 'should override existing dir if :override specified' do
       @path.dir.create
       @path.should be_dir
       -> {@path.write 'another'}.should raise_error(Vfs::Error, /exist/)
@@ -132,22 +134,28 @@ describe 'File' do
     end
     
     it 'should copy to file (and overwrite if forced)' do
-      check_copy_for @fs.file('to')
+      check_copy_for test_fs.file('to')
     end
     
     it 'should copy to dir (and overwrite if forced)' do
-      check_copy_for @fs.dir("to")
+      check_copy_for test_fs.dir("to")
     end
     
     it 'should copy to UniversalEntry (and overwrite if forced)' do
-      check_copy_for @fs.entry('to')
+      check_copy_for test_fs.entry('to')
     end
     
     it 'should be chainable' do
-      to = @fs['to']
+      to = test_fs['to']
       @from.copy_to(to).should == to
       @from.copy_to!(to).should == to
     end
+    
+    it "should autocreate parent's path if not exist (from error)" do
+      to = test_fs['parent_path/to']
+      @from.copy_to(to)
+      to.read.should == 'something'
+    end
   end
   
   describe 'moving' do
@@ -188,7 +196,23 @@ describe 'File' do
   end
   
   describe "extra stuff" do
-    it 'render'
+    it 'render' do
+      template = test_fs / 'letter.erb'
+      template.write "Hello dear <%= name %>"
+      template.render(name: 'Mary').should == "Hello dear Mary"
+    end
+    
+    begin
+      require 'haml'
+      
+      it 'render using other template engines' do      
+        template = test_fs / 'letter.haml'
+        template.write "Hello dear \#{name}"
+        template.render(name: 'Mary').should =~ /Hello dear Mary/
+      end
+    rescue LoadError
+      warn "no :haml template engine, skipping rendering with haml specs"
+    end
     
     it 'size'
   end

data/spec/spec_helper.rb

@@ -1,4 +1,50 @@
 require 'rspec_ext'
 require 'ruby_ext'
 
-require 'vfs'
+require 'tilt'
+require 'vfs'
+
+rspec do
+  def self.with_test_fs        
+    before do
+      @test_fs = "/tmp/test_fs".to_dir
+      
+      FileUtils.rm_r test_fs.path if File.exist? test_fs.path
+      FileUtils.mkdir_p test_fs.path
+    end
+    
+    after do      
+      FileUtils.rm_r test_fs.path if File.exist? test_fs.path
+      @test_fs = nil
+    end
+  end
+  
+  def test_fs
+    @test_fs
+  end
+end
+
+# require 'fakefs/spec_helpers'
+# 
+# include FakeFS::SpecHelpers
+# use_fakefs self
+# 
+# 
+# # 
+# # FakeFS fixes
+# # 
+# FakeFS::File::Stat.class_eval do
+#   # there's also file? method defined on File::Stat
+#   def file?; !directory? end
+# end
+# 
+# FakeFS::File.class_eval do
+#   class << self
+#     # File.delete should raise error if it's directory
+#     alias_method :delete_without_bang, :delete
+#     def delete path
+#       raise Errno::EPERM, "Operation not permitted - #{path}" if directory?(path)
+#       delete_without_bang path
+#     end
+#   end
+# end

data/spec/universal_entry_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'UniversalEntry' do
+  with_test_fs
+  
   before do
-    @fs = '/'.to_entry_on(Vfs::Storages::HashFs.new)
-    @path = @fs['/a/b/c']
+    @path = test_fs['a/b/c']
   end
   
   describe 'existence' do

metadata

@@ -1,28 +1,22 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: vfs
-version: !ruby/object:Gem::Version 
-  version: 0.3.10
+version: !ruby/object:Gem::Version
+  version: 0.3.11
   prerelease: 
 platform: ruby
-authors: 
+authors:
 - Alexey Petrushin
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-08 00:00:00 +04:00
-default_executable: 
+date: 2011-08-10 00:00:00.000000000Z
 dependencies: []
-
 description: 
 email: 
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - Rakefile
 - readme.md
 - lib/vfs/entries/dir.rb
@@ -34,7 +28,6 @@ files:
 - lib/vfs/error.rb
 - lib/vfs/integration/string.rb
 - lib/vfs/path.rb
-- lib/vfs/storages/hash_fs.rb
 - lib/vfs/storages/local.rb
 - lib/vfs/storages/specification.rb
 - lib/vfs/support.rb
@@ -46,36 +39,30 @@ files:
 - spec/file_spec.rb
 - spec/path_spec.rb
 - spec/spec_helper.rb
-- spec/storages/hash_fs_spec.rb
 - spec/storages/local_spec.rb
 - spec/universal_entry_spec.rb
-has_rdoc: true
 homepage: http://github.com/alexeypetrushin/vfs
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.1
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Virtual File System
 test_files: []
-

data/lib/vfs/storages/hash_fs.rb

@@ -1,216 +0,0 @@
-# 
-# Very dirty and inefficient In Memory File System, mainly for tests.
-# 
-module Vfs
-  module Storages
-    class HashFs < Hash
-      def initialize
-        super
-        self['/'] = {dir: true}
-      end
-      
-      
-      def open_fs &block
-        block.call self
-      end
-      
-      # 
-      # Attributes
-      # 
-      def attributes path
-        base, name = split_path path
-      
-        # if path == '/'
-        #   return {dir: true, file: false}
-        # end
-        # 
-        stat = cd(base)[name]
-        attrs = {}
-        attrs[:file] = !!stat[:file]
-        attrs[:dir] = !!stat[:dir]
-        attrs
-      rescue Exception
-        {}
-      end
-      
-      def set_attributes path, attrs      
-        raise 'not supported'
-      end
-      
-      
-      # 
-      # File
-      #       
-      def read_file path, &block
-        base, name = split_path path
-        assert cd(base)[name], :include?, :file
-        block.call cd(base)[name][:content]
-      end
-      
-      def write_file path, append, &block
-        base, name = split_path path
-                    
-        os = if append
-          file = cd(base)[name]
-          file ? file[:content] : ''
-        else
-          assert_not cd(base), :include?, name
-          ''
-        end
-        writer = -> buff {os << buff}       
-        block.call writer
-
-        cd(base)[name] = {file: true, content: os}
-      end
-      
-      def delete_file path
-        base, name = split_path path
-        assert cd(base)[name], :include?, :file
-        cd(base).delete name
-      end
-      
-      # def move_file path
-      #   raise 'not supported'
-      # end
-    
-      
-      # 
-      # Dir
-      #
-      def create_dir path
-        base, name = split_path path
-        assert_not cd(base), :include?, name
-        cd(base)[name] = {dir: true}
-      end
-    
-      def delete_dir path
-        base, name = split_path path        
-        assert cd(base)[name], :include?, :dir
-        # empty = true
-        # cd(base)[name].each do |key, value|
-        #   empty = false if key.is_a? String
-        # end
-        # raise 'you are trying to delete not empty dir!' unless empty
-        cd(base).delete name
-      end      
-      
-      # def move_dir path
-      #   raise 'not supported'
-      # end
-      
-      def each_entry path, query, &block
-        raise "hash_fs not support :each_entry with query!" if query
-        
-        base, name = split_path path
-        assert cd(base)[name], :include?, :dir
-        cd(base)[name].each do |relative_name, content|
-          next if relative_name.is_a? Symbol
-          if content[:dir]
-            block.call relative_name, :dir
-          else
-            block.call relative_name, :file
-          end
-        end
-      end
-      
-      def efficient_dir_copy from, to, override        
-        from.storage.open_fs do |from_fs|          
-          to.storage.open_fs do |to_fs|
-            if from_fs == to_fs
-              for_spec_helper_effective_copy_used
-
-              _efficient_dir_copy from.path, to.path, override
-              true
-            else
-              false
-            end
-          end
-        end
-      end  
-      
-      def _efficient_dir_copy from_path, to_path, override
-        from_base, from_name = split_path from_path
-        assert cd(from_base)[from_name], :include?, :dir
-
-        to_base, to_name = split_path to_path
-        # assert_not cd(to_base), :include?, to_name
-        
-        if cd(to_base).include? to_name
-          if cd(to_base)[to_name][:dir]
-            each_entry from_path, nil do |name, type|
-              if type == :dir
-                _efficient_dir_copy "#{from_path}/#{name}", "#{to_path}/#{name}", override
-              else
-                raise "file #{to_path}/#{name} already exist!" if cd(to_base)[to_name].include?(name) and !override                  
-                cd(to_base)[to_name][name] = cd(from_base)[from_name][name].clone
-              end
-            end
-          else
-            raise "can't copy dir #{from_path} to file #{to_path}!"
-          end                
-        else
-          cd(to_base)[to_name] = {dir: true}
-          _efficient_dir_copy from_path, to_path, override
-        end
-      end
-      protected :_efficient_dir_copy
-      def for_spec_helper_effective_copy_used; end
-      
-      # def upload_directory from_local_path, to_remote_path
-      #   FileUtils.cp_r from_local_path, to_remote_path
-      # end
-      # 
-      # def download_directory from_remote_path, to_local_path
-      #   FileUtils.cp_r from_remote_path, to_local_path
-      # end
-      
-      
-      # 
-      # Other
-      # 
-      def local?; true end
-      
-      def to_s; 'hash_fs' end
-      
-      def tmp &block
-        tmp_dir = "/tmp_#{rand(10**6)}"
-        create_dir tmp_dir
-        if block
-          begin
-            block.call tmp_dir
-          ensure
-            delete_dir tmp_dir
-          end
-        else          
-          tmp_dir
-        end
-      end
-      
-      protected
-        def assert obj, method, arg          
-          raise "#{obj} should #{method} #{arg}" unless obj.send method, arg
-        end
-        
-        def assert_not obj, method, arg
-          raise "#{obj} should not #{method} #{arg}" if obj.send method, arg
-        end
-      
-        def split_path path
-          parts = path[1..-1].split('/')
-          parts.unshift '/'
-          name = parts.pop          
-          return parts, name
-        end
-      
-        def cd parts
-          current = self
-          iterator = parts.clone
-          while iterator.first
-            current = current[iterator.first]
-            iterator.shift
-          end    
-          current
-        end
-    end
-  end
-end

data/spec/storages/hash_fs_spec.rb

@@ -1,10 +0,0 @@
-require 'vfs/storages/hash_fs'
-require 'vfs/storages/specification'
-
-describe Vfs::Storages::HashFs do
-  it_should_behave_like "vfs storage"    
-    
-  before do
-    @storage = Vfs::Storages::HashFs.new
-  end
-end