vfs 0.1.0 → 0.1.1

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake_ext'
 
 project(
   name: "vfs",
-  version: "0.1.0",
+  version: "0.1.1",
   summary: "Virtual File System",
 
   author: "Alexey Petrushin",

data/lib/vfs.rb

@@ -4,6 +4,7 @@
   path
   error
   
+  entries/entry/special_attributes
   entries/entry
   entries/file
   entries/dir
@@ -15,4 +16,6 @@
   storages/local
   
   integration/string
+  
+  vfs
 ).each{|f| require "vfs/#{f}"}

data/lib/vfs/entries/dir.rb

@@ -97,7 +97,7 @@ module Vfs
       storage.open_fs do |fs| 
         begin
           list = []
-          fs.each path do |name, type|
+          fs.each_entry path do |name, type|
             next if options[:filter] and options[:filter] != type
             entry = if type == :dir
               dir(name)
@@ -140,6 +140,10 @@ module Vfs
     end
     alias_method :has?, :include?
     
+    def empty?
+      entries.empty?
+    end
+    
     
     # 
     # Transfers
@@ -162,53 +166,7 @@ module Vfs
         raise "can't copy to unknown Entry!"
       end
       
-      storage.open_fs do |fs|
-        try = 0
-        begin
-          try += 1          
-          self.class.efficient_dir_copy(self, target) || self.class.unefficient_dir_copy(self, target)       
-        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 'target')
-            unknown_errors += 1            
-          else
-            raise Error, "'#{self}' not exist!" if options[:bang]            
-            return target
-          end
-          
-          attrs = target.get          
-          if attrs[:file]
-            if options[:override]
-              to.destroy
-            else
-              raise Vfs::Error, "entry #{target} already exist!"
-            end
-          elsif attrs[:dir]
-            if options[:override]
-              to.destroy
-            else
-              raise Vfs::Error, "entry #{target} already exist!"
-            end
-          else
-            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
-                
-          retry if try < 2
-        end
-      end
+      efficient_dir_copy(target, options) || unefficient_dir_copy(target, options)      
       
       target
     end
@@ -228,44 +186,76 @@ module Vfs
     end
     
     protected
-      def self.unefficient_dir_copy from, to        
-        from.storage.open_fs do |from_fs|
-          to.storage.open_fs do |to_fs|
-            to_fs.create_dir to.path            
-            from_fs.each from.path do |name, type|
-              if type == :dir
-                unefficient_dir_copy from.dir(name), to.dir(name)
-              elsif type == :file
-                to_fs.write_file to.file(name).path, false do |writer|
-                  from_fs.read_file from.file(name).path do |buff|
-                    writer.call buff
-                  end
-                end
+      def unefficient_dir_copy to, options       
+        to.create options
+        entries options do |e|        
+          if e.is_a? Dir
+            e.copy_to to.dir(e.name), options
+          elsif e.is_a? File
+            e.copy_to to.file(e.name), options
+          else
+            raise 'internal error'
+          end        
+        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 'invalid entry type!'
+                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
-        
-          # target.create options
-          # entries do |e|
-          #   if e.is_a? Dir
-          #     e.copy_to target.dir(e.name), options
-          #   elsif e.is_a? File
-          #     e.copy_to target.file(e.name), options
-          #   else
-          #     raise 'internal error'
-          #   end        
-          # end
       end
       
-      def self.efficient_dir_copy from, to
+      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)
+          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)
+          fs.respond_to?(:efficient_dir_copy) and fs.efficient_dir_copy(from, to, override)
         }
       end
   end

data/lib/vfs/entries/entry.rb

@@ -73,14 +73,11 @@ module Vfs
       not_implemented
     end
     
-    def dir?
-      !!get(:dir)
-    end
+    def dir?; !!get(:dir) end
+    def file?; !!get(:file) end        
+    
+    include SpecialAttributes
     
-    def file?
-      !!get(:file)
-    end
-      
     
     # 
     # Micelaneous
@@ -101,6 +98,10 @@ module Vfs
       end
     end
     
+    def local?
+      storage.local?
+    end
+    
     
     # 
     # Utils

data/lib/vfs/entries/entry/special_attributes.rb

@@ -0,0 +1,26 @@
+module Vfs
+  class Entry
+    module SpecialAttributes
+      def created_at
+        safe_get :created_at
+      end
+      
+      def updated_at
+        safe_get :updated_at
+      end
+      
+      protected
+        def safe_get name
+          if value = get[name]
+            value
+          else
+            if get[:dir] or get[:file]
+              raise "attribute :#{name} not supported for #{storage.class}!"
+            else
+              raise "entry #{path} not exist!"
+            end
+          end
+        end
+    end
+  end
+end

data/lib/vfs/entries/file.rb

@@ -21,7 +21,7 @@ module Vfs
             data
           end
         rescue StandardError => e
-          raise Vrs::Error, "can't read Dir #{self}!" if dir.exist?
+          raise Vfs::Error, "can't read Dir #{self}!" if dir.exist?
           attrs = get
           if attrs[:file]
             # unknown internal error

data/lib/vfs/storages/hash_fs.rb

@@ -1,5 +1,5 @@
 # 
-# Dirty and uneficient In Memory FS, mainly for tests.
+# Very dirty and uneficient In Memory FS, mainly for tests.
 # 
 module Vfs
   module Storages
@@ -98,7 +98,7 @@ module Vfs
       #   raise 'not supported'
       # end
       
-      def each path, &block
+      def each_entry path, &block
         base, name = split_path path
         assert cd(base)[name], :include?, :dir
         cd(base)[name].each do |relative_name, content|
@@ -111,27 +111,47 @@ module Vfs
         end
       end
       
-      def efficient_dir_copy from, to
+      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
 
-              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
-
-              cd(to_base)[to_name] = cd(from_base)[from_name]
-
+              _efficient_dir_copy from.path, to.path, override
               true
             else
               false
             end
           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 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

data/lib/vfs/storages/local.rb

@@ -19,6 +19,10 @@ module Vfs
           attrs = {}
           attrs[:file] = stat.file?
           attrs[:dir] = stat.directory?
+          
+          # attributes special for file system
+          attrs[:created_at] = stat.ctime
+          attrs[:updated_at] = stat.mtime
           attrs
         rescue Errno::ENOENT
           {}
@@ -68,7 +72,7 @@ module Vfs
           FileUtils.rm_r path
         end      
 
-        def each path, &block
+        def each_entry path, &block
           ::Dir.foreach path do |relative_name|
             next if relative_name == '.' or relative_name == '..'
             if ::File.directory? "#{path}/#{relative_name}"
@@ -79,7 +83,9 @@ module Vfs
           end
         end
         
-        def efficient_dir_copy from, to
+        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?

data/lib/vfs/storages/specification.rb

@@ -20,6 +20,8 @@ shared_examples_for 'vfs storage' do
     @storage.open_fs{|fs| fs.should respond_to(:local?)}
   end
   
+  it 'should respond to :host'
+  
   it 'should have root dir' do
     @storage.open_fs do |fs|
       fs.attributes('/').subset(:file, :dir).should == {file: false, dir: true}
@@ -99,7 +101,7 @@ shared_examples_for 'vfs storage' do
     it 'each' do
       @storage.open_fs do |fs|
         list = {}
-        fs.each(@tmp_dir){|path, type| list[path] = type}
+        fs.each_entry(@tmp_dir){|path, type| list[path] = type}
         list.should be_empty
       
         dir, file = "#{@tmp_dir}/dir", "#{@tmp_dir}/file"
@@ -107,7 +109,7 @@ shared_examples_for 'vfs storage' do
         fs.write_file(file, false){|w| w.call 'something'}
       
         list = {}
-        fs.each(@tmp_dir){|path, type| list[path] = type}
+        fs.each_entry(@tmp_dir){|path, type| list[path] = type}
         list.should == {'dir' => :dir, 'file' => :file}
       end
     end

data/lib/vfs/vfs.rb

@@ -0,0 +1,34 @@
+module Vfs
+  class << self
+    def to_entry
+      '/'.to_entry
+    end
+    
+    def to_file
+      to_entry.file
+    end
+    
+    def to_dir
+      to_entry.dir
+    end
+    
+    # def [] path
+    #   to_entry[path]
+    # end
+    # alias_method :/, :[]
+          
+    %w(
+      entry dir file 
+      entries dirs files
+      [] / 
+      tmp
+    ).each do |m|
+      script = <<-RUBY
+        def #{m} *a, &b
+          to_entry.#{m} *a, &b
+        end
+      RUBY
+      eval script, binding, __FILE__, __LINE__
+    end
+  end
+end

data/readme.md

@@ -1,7 +1,7 @@
 # Vfs - Virtual File System
 
 Handy and simple abstraction over any storage that can represent concept of File and Directory (or at least part of it). 
-The Vfs for File System Storages is the same as ActiveRecord is for Relational Databases.
+The Vfs for File System is the same as ActiveRecord is for Relational Databases.
 
 Currently, there are following implementations available:
 
@@ -20,69 +20,76 @@ Currently, there are following implementations available:
 ** all methods should have the same performance as native system calls, except for :move and :rename. Right now they are implemented 
 ASAP by using copy+destroy approach, will be fixed as soon as I'll have free time to do it.
 
+## Installation
+
+    $ gem install vfs
+    $ gem install vos
+
 ## Code samples:
-      gem 'vfs'                                    # Virtual File System
-      require 'vfs'                              
+    gem 'vfs'                                    # Virtual File System
+    require 'vfs'                              
 
-      gem 'vos'                                    # Virtual Operating System
-      require 'vos'
+    gem 'vos'                                    # Virtual Operating System
+    require 'vos'
 
 
-      # Connections, let's deploy our 'cool_app' project from our local box to remote server
-      server = Vfs::Box.new(host: 'cool_app.com', ssh: {user: 'me', password: 'secret'})
-      me = '~'.to_dir
+    # Connections, let's deploy our 'cool_app' project from our local box to remote server
+    server = Box.new('cool_app.com')             # it will use id_rsa, or You can add {user: 'me', password: 'secret'}                                                  
+    me = '~'.to_dir                              # handy shortcut for local FS
 
-      cool_app = server['apps/cool_app']
-      projects = me['projects']
+    deploy_dir = server['apps/cool_app']
+    projects = me['projects']
 
 
-      # Working with dirs, copying dir from any source to any destination (local/remote/custom_storage_type)
-      projects['cool_app'].copy_to cool_app        
+    # Working with dirs, copying dir from any source to any destination (local/remote/custom_storage_type)
+    projects['cool_app'].copy_to deploy_dir        
 
 
-      # Working with files
-      dbc = cool_app.file('config/database.yml')   # <= the 'config' dir not exist yet
-      dbc.write("user: root\npassword: secret")    # <= now the 'database.yml' and parent 'config' has been created
-      dbc.content =~ /database/                    # => false, we forgot to add the database
-      dbc.append("\ndatabase: mysql")              # let's do it
+    # Working with files
+    dbc = deploy_dir.file('config/database.yml') # <= the 'config' dir not exist yet
+    dbc.write("user: root\npassword: secret")    # <= now the 'database.yml' and parent 'config' has been created
+    dbc.content =~ /database/                    # => false, we forgot to add the database
+    dbc.append("\ndatabase: mysql")              # let's do it
 
-      dbc.update do |content|                      # and add host info
-        content + "\nhost: cool_app.com "
-      end                                       
+    dbc.update do |content|                      # and add host info
+      content + "\nhost: cool_app.com "
+    end                                       
 
-      projects['cool_app/config/database.yml'].    # or just overwrite it with our local dev version
-        copy_to! dbc
-        
-      # there are also streaming support (read/write/append), please go to specs for docs
+    projects['cool_app/config/database.yml'].    # or just overwrite it with our local dev version
+      copy_to! dbc
+      
+    # there are also streaming support (read/write/append) with &block, please go to specs for details
 
 
-      # Checks
-      cool_app['config'].exist?                    # => true
-      cool_app.dir('config').exist?                # => true
-      cool_app.file('config').exist?               # => false
+    # Checks
+    deploy_dir['config'].exist?                  # => true
+    deploy_dir.dir('config').exist?              # => true
+    deploy_dir.file('config').exist?             # => false
 
-      cool_app['config'].dir?                      # => true
-      cool_app['config'].file?                     # => false
+    deploy_dir['config'].dir?                    # => true
+    deploy_dir['config'].file?                   # => false
 
 
-      # Navigation
-      config = cool_app['config']
-      config.parent                                # => </apps/cool_app>
-      config['../..']                              # => </>
-      config['../..'].dir?                         # => true
+    # Navigation
+    config = deploy_dir['config']
+    config.parent                                # => </apps/cool_app>
+    config['../..']                              # => </>
+    config['../..'].dir?                         # => true
 
-      cool_app.entries                             # => list of dirs and files, also support &block
-      cool_app.files                               # => list of files, also support &block
-      cool_app.dirs                                # => list of dirs, also support &block
+    deploy_dir.entries                           # => list of dirs and files, also support &block
+    deploy_dir.files                             # => list of files, also support &block
+    deploy_dir.dirs                              # => list of dirs, also support &block
 
 
-      # For more please go to specs (create/update/move/copy/destroy/...)
+    # For more please go to specs (create/update/move/copy/destroy/...)
       
 ## Integration with [Vos][vos] (Virtual Operating System)
     
-      server['apps/cool_app'].bash 'rails production'
+    server['apps/cool_app'].bash 'rails production'
 
-For more details please go to [Vos][vos] project page.
+For more details please go to [Vos][vos] project page. 
+Or checkout configuration I use to control my production servers [My Cluster][my_cluster] in conjunction with small 
+configuration tool [Cluster Management][cluster_management].
 
 # Why?
 
@@ -103,7 +110,7 @@ different API than local FS, and you has to remember all thouse little quirks).
 - list of entries/files/dirs
 - support for efficient copy for Local and SSH storages
 
-### v 0.2 (not started)
+### v 0.2
 
 - efficient (not copy/destroy) versions of move_to, rename
 - glob search for directories: Dir['**/*.yml']
@@ -114,4 +121,6 @@ different API than local FS, and you has to remember all thouse little quirks).
 
 - add storages: Hadoop DFS, MongoDB, Amazon S3
 
-[vos]: http://github.com/alexeypetrushin/vos
+[vos]: http://github.com/alexeypetrushin/vos
+[cluster_management]: http://github.com/alexeypetrushin/cluster_management
+[my_cluster]: http://github.com/alexeypetrushin/my_cluster

data/spec/dir_spec.rb

@@ -121,6 +121,8 @@ describe 'Dir' do
       @path.include?('file').should be_true
       @path.include?('non_existing').should be_false
     end
+    
+    it 'empty?'
   end
   
   describe 'copying' do
@@ -137,69 +139,81 @@ describe 'Dir' do
       -> {@from.copy_to @from}.should raise_error(Vfs::Error, /itself/)
     end
     
-    def check_copy_for to, error_re1, error_re2 
-      begin
-        target = @from.copy_to to                  
-        target['file'].read.should == 'something'
-        target['dir/file2'].read.should == 'something2'
-        target.should == to
-      rescue Exception => e
-        raise e unless e.message =~ error_re1
+    shared_examples_for 'copy_to behavior' do
+      it 'should not copy to file (and overwrite if forced)' do
+        -> {@from.copy_to @to.file}.should raise_error(/can't copy Dir to File/)
+        
+        @from.copy_to! @to.file
+        @to['file'].read.should == 'something'
+      end
+      
+      it 'should not override files (and override if forced)' do
+        @from.copy_to @to
+        -> {@from.copy_to @to}.should raise_error(/already exist/)
+        
+        @from['dir/file2'].write! 'another'
+        @from.copy_to! @to
+        @to['dir/file2'].read.should == 'another'
+      end
+    
+      it 'should copy to UniversalEntry (and overwrite if forced)' do
+        @from.copy_to @to.entry
+        -> {@from.copy_to @to.entry}.should raise_error(/already exist/)
+        
+        @from.copy_to! @to.entry
+        @to['file'].read.should == 'something'        
+      end
+      
+      it "shouldn't delete existing content of directory" do
+        @to.dir.create!
+        @to.file('existing_file').write 'existing_content'
+        @to.dir('existing_dir').create
+        @to.file('dir/existing_file2').write 'existing_content2'
+
+        @from.copy_to @to
+        # copied files
+        @to['file'].read.should == 'something'
+        @to['dir/file2'].read.should == 'something2'
+        # shouldn't delete already existing files
+        @to.file('existing_file').read.should == 'existing_content'
+        @to.dir('existing_dir').should exist
+        @to.file('dir/existing_file2').read.should == 'existing_content2'
       end      
       
-      @from['dir/file2'].write! 'another'      
-      -> {@from.copy_to to}.should raise_error(Vfs::Error, error_re2)
-      target = @from.copy_to! to
-      target['file'].read.should == 'something'
-      target['dir/file2'].read.should == 'another'            
+      it 'should be chainable' do
+        @from.copy_to(@to).should == @to
+        @from.copy_to!(@to).should == @to
+      end
+      
+      it "should override without deleting other files" do
+        @from.copy_to(@to).should == @to 
+        @to.file('other_file').write 'other'
+                       
+        @from.copy_to!(@to).should == @to
+        @to.file('other_file').read.should == 'other'
+      end
     end
     
     describe 'general copy' do   
+      it_should_behave_like 'copy_to behavior'
+      
       before :each 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      
-    
-      it 'should copy to file (and overwrite if forced)' do
-        check_copy_for @to.file, /can't copy Dir to File/, /can't copy Dir to File/
-      end
-    
-      it 'should copy to dir (and overwrite if forced)' do
-        check_copy_for @to.dir, nil, /exist/
-      end
-    
-      it 'should copy to UniversalEntry (and overwrite if forced)' do
-        check_copy_for @to.entry, nil, /exist/
-      end
-    end
+      end            
+    end    
     
     describe 'effective copy' do
+      it_should_behave_like 'copy_to behavior'
+      
       before :each 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
-      
-      it 'should copy to file (and overwrite if forced)' do
-        check_copy_for @to.file, /can't copy Dir to File/, /can't copy Dir to File/
-      end
-    
-      it 'should copy to dir (and overwrite if forced)' do
-        check_copy_for @to.dir, nil, /exist/
+        # @from.storage.should_receive(:for_spec_helper_effective_copy_used).at_least(1).times
       end
-    
-      it 'should copy to UniversalEntry (and overwrite if forced)' do
-        check_copy_for @to.entry, nil, /exist/
-      end
-    end
-    
-    it 'should be chainable' do
-      to = @fs['to']
-      @from.copy_to(to).should == to
-      @from.copy_to!(to).should == to
     end
   end
     

data/spec/entry_spec.rb

@@ -21,4 +21,14 @@ describe 'Entry' do
     end
     tmp.should_not exist
   end
+  
+  it 'should respond to local?'
+  
+  it 'should respond to host'
+  
+  describe 'attributes' do
+    it 'created_at'
+    
+    it 'updated_at'
+  end
 end

data/spec/storages/local_spec.rb

@@ -7,4 +7,10 @@ describe Vfs::Storages::Local do
   before :each do
     @storage = Vfs::Storages::Local.new
   end
+  
+  describe 'attributes' do
+    it 'created_at'
+    
+    it 'updated_at'
+  end
 end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: vfs
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+  prerelease: 
+  version: 0.1.1
 platform: ruby
 authors: 
 - Alexey Petrushin
@@ -14,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-08 00:00:00 +03:00
+date: 2011-02-16 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -30,6 +26,7 @@ files:
 - Rakefile
 - readme.md
 - lib/vfs/entries/dir.rb
+- lib/vfs/entries/entry/special_attributes.rb
 - lib/vfs/entries/entry.rb
 - lib/vfs/entries/file.rb
 - lib/vfs/entries/universal_entry.rb
@@ -41,6 +38,7 @@ files:
 - lib/vfs/storages/local.rb
 - lib/vfs/storages/specification.rb
 - lib/vfs/support.rb
+- lib/vfs/vfs.rb
 - lib/vfs.rb
 - spec/container_spec.rb
 - spec/dir_spec.rb
@@ -65,21 +63,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.1
 signing_key: 
 specification_version: 3
 summary: Virtual File System