vfs 0.3.15 → 0.4.0

data/lib/vfs/entries/entry.rb

@@ -1,26 +1,25 @@
 module Vfs
   class Entry
-    attr_reader :storage, :path, :path_cache
+    attr_reader :driver, :path, :path_cache
 
     def initialize *args
       if args.size == 1 and args.first.is_a? Entry
         entry = args.first
         @path_cache = entry.path_cache
-        @storage, @path = entry.storage, entry.path
+        @driver, @path = entry.driver, entry.path
       else
-        storage, path = *args
+        driver, path = *args
         @path_cache = Path.new path
-        @storage, @path = storage, path_cache.to_s
+        @driver, @path = driver, path_cache.to_s
       end
-      raise "storage not defined!" unless self.storage
+      raise "driver not defined!" unless self.driver
     end
 
-
     #
     # Navigation
     #
     def parent
-      Dir.new(storage, path_cache + '..')
+      Dir.new(driver, path_cache + '..')
     end
 
 
@@ -30,7 +29,7 @@ module Vfs
     def dir path = nil
       if path
         new_path = path_cache + path
-        Dir.new storage, new_path
+        Dir.new driver, new_path
       else
         Dir.new self
       end
@@ -40,7 +39,7 @@ module Vfs
     def file path = nil
       if path
         new_path = path_cache + path
-        File.new storage, new_path
+        File.new driver, new_path
       else
         File.new self
       end
@@ -49,10 +48,9 @@ module Vfs
 
     def entry path = nil
       entry = if path
-
         new_path = path_cache + path
         klass = new_path.probably_dir? ? Dir : UniversalEntry
-        entry = klass.new storage, new_path
+        klass.new driver, new_path
       else
         UniversalEntry.new self
       end
@@ -65,7 +63,7 @@ module Vfs
     # Attributes
     #
     def get attr_name = nil
-      attrs = storage.open{|fs| fs.attributes(path)}
+      attrs = driver.open{driver.attributes(path)}
       (attr_name and attrs) ? attrs[attr_name] : attrs
     end
 
@@ -88,19 +86,19 @@ module Vfs
     end
 
     def tmp &block
-      storage.open do |fs|
+      driver.open do
         if block
-          fs.tmp do |path|
-            block.call Dir.new(storage, path)
+          driver.tmp do |path|
+            block.call Dir.new(driver, path)
           end
         else
-          Dir.new storage, fs.tmp
+          Dir.new driver, driver.tmp
         end
       end
     end
 
     def local?
-      storage.local?
+      driver.local?
     end
 
 
@@ -108,22 +106,42 @@ module Vfs
     # Utils
     #
     def inspect
-      "#{storage}#{':' unless storage.to_s.empty?}#{path}"
+      "#{driver}#{':' unless driver.to_s.empty?}#{path}"
     end
     alias_method :to_s, :inspect
 
     def == other
       return false unless other.is_a? Entry
-      storage == other.storage and path == other.path
+      driver == other.driver and path == other.path
     end
 
     def hash
-      storage.hash + path.hash
+      driver.hash + path.hash
     end
 
     def eql? other
       return false unless other.class == self.class
-      storage.eql?(other.storage) and path.eql?(other.path)
+      driver.eql?(other.driver) and path.eql?(other.path)
     end
+
+    protected
+      def destroy_entry first = :file, second = :dir
+        driver.open do
+          begin
+            driver.send :"delete_#{first}", path
+          rescue StandardError => e
+            attrs = get
+            if attrs and attrs[first]
+              # some unknown error
+              raise e
+            elsif attrs and attrs[second]
+              driver.send :"delete_#{second}", path
+            else
+              # do nothing, entry already not exist
+            end
+          end
+        end
+        self
+      end
   end
 end

data/lib/vfs/entries/file.rb

@@ -11,13 +11,13 @@ module Vfs
     #
     def read options = {}, &block
       options[:bang] = true unless options.include? :bang
-      storage.open do |fs|
+      driver.open do
         begin
           if block
-            fs.read_file path, &block
+            driver.read_file path, &block
           else
             data = ""
-            fs.read_file(path){|buff| data << buff}
+            driver.read_file(path){|buff| data << buff}
             data
           end
         rescue StandardError => e
@@ -39,18 +39,14 @@ module Vfs
       end
     end
 
-    def content options = {}
-      read options
-    end
+    # def content options = {}
+    #   read options
+    # end
 
     def create options = {}
       write '', options
       self
     end
-    def create! options = {}
-      options[:override] = true
-      create options
-    end
 
     def write *args, &block
       if block
@@ -61,35 +57,24 @@ module Vfs
       end
       raise "can't do :override and :append at the same time!" if options[:override] and options[:append]
 
-      storage.open do |fs|
-        # TODO2 Performance lost, extra call to check file existence
-        # We need to check if the file exist before writing to it, otherwise it's
-        # impossible to distinguish if the StandardError caused by the 'already exist' error or
-        # some other error.
-        entry = self.entry
-        if entry.exist?
-          if options[:override]
-            entry.destroy
-          else
-            raise Error, "entry #{self} already exist!"
-          end
-        end
-
+      driver.open do
         try = 0
         begin
           try += 1
           if block
-            fs.write_file(path, options[:append], &block)
+            driver.write_file(path, options[:append], &block)
           else
-            fs.write_file(path, options[:append]){|writer| writer.write data}
+            driver.write_file(path, options[:append]){|writer| writer.write data}
           end
         rescue StandardError => error
           parent = self.parent
-          if parent.exist?
-            # some unknown error
-            raise error
-          else
+          if entry.exist?
+            entry.destroy
+          elsif !parent.exist?
             parent.create(options)
+          else
+            # unknown error
+            raise error
           end
 
           try < 2 ? retry : raise(error)
@@ -97,11 +82,6 @@ module Vfs
       end
       self
     end
-    def write! *args, &block
-      args << {} unless args.last.is_a? Hash
-      args.last[:override] = true
-      write *args, &block
-    end
 
     def append *args, &block
       options = (args.last.is_a?(Hash) && args.pop) || {}
@@ -110,37 +90,12 @@ module Vfs
     end
 
     def update options = {}, &block
-      options[:override] = true
       data = read options
       write block.call(data), options
     end
 
-    def destroy options = {}
-      storage.open do |fs|
-        begin
-          fs.delete_file path
-          self
-        rescue StandardError => e
-          attrs = get
-          if attrs and attrs[:dir]
-            if options[:force]
-              dir.destroy
-            else
-              raise Error, "can't destroy Dir #{dir} (you are trying to destroy it as if it's a File)"
-            end
-          elsif attrs and attrs[:file]
-            # unknown internal error
-            raise e
-          else
-            # do nothing, file already not exist
-          end
-        end
-      end
-      self
-    end
-    def destroy! options = {}
-      options[:force] = true
-      destroy options
+    def destroy
+      destroy_entry
     end
 
 
@@ -166,20 +121,12 @@ module Vfs
 
       target
     end
-    def copy_to! to, options = {}
-      options[:override] = true
-      copy_to to, options
-    end
 
-    def move_to to, options = {}
-      copy_to to, options
-      destroy options
+    def move_to to
+      copy_to to
+      destroy
       to
     end
-    def move_to! to, options = {}
-      options[:override] = true
-      move_to to, options
-    end
 
 
     #

data/lib/vfs/entries/universal_entry.rb

@@ -8,17 +8,17 @@ module Vfs
     end
 
 
+    def copy_to to, options = {}
+      from = file? ? to_file : to_dir
+      from.copy_to to, options
+    end
+
+
     #
     # CRUD
     #
-    def destroy options = {}
-      storage.open do |fs|
-        attrs = get
-        fs.delete_dir path if attrs and attrs[:dir]
-        fs.delete_file path if attrs and attrs[:file]
-      end
-      self
+    def destroy
+      destroy_entry
     end
-    alias_method :destroy!, :destroy
   end
 end

data/lib/vfs/integration.rb

@@ -0,0 +1,30 @@
+class String
+  def to_entry_on driver = nil
+    path = self
+    driver ||= Vfs.default_driver
+
+    path = "./#{path}" unless path =~ /^[\/\.\~]/
+    Vfs::Entry.new(driver, path).entry
+  end
+  alias_method :to_entry, :to_entry_on
+
+  def to_file_on driver = nil
+    to_entry_on(driver).file
+  end
+  alias_method :to_file, :to_file_on
+
+  def to_dir_on driver = nil
+    to_entry_on(driver).dir
+  end
+  alias_method :to_dir, :to_dir_on
+end
+
+class File
+  def to_entry
+    path.to_entry
+  end
+
+  def to_file
+    path.to_file
+  end
+end

data/lib/vfs/vfs.rb

@@ -1,7 +1,7 @@
 module Vfs
   class << self
-    def default_storage
-      ::Vfs::Storages::Local.new
+    def default_driver
+      ::Vfs::Drivers::Local.new
     end
 
     def to_entry

data/readme.md

@@ -51,7 +51,7 @@ projects['cool_app'].copy_to deploy_dir
 
 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.read =~ /database/                       # => false, we forgot to add the database
 dbc.append("\ndatabase: mysql")              # let's do it
 
 dbc.update do |content|                      # and add host info

data/spec/container_spec.rb

@@ -1,29 +1,30 @@
 require 'spec_helper'
 
 describe 'Container' do
-  with_test_fs
+  with_test_dir
 
   it "should threat paths as UniversalEntry except it ends with '/'" do
-    test_fs.should_receive(:entry).with('tmp/a/b')
-    test_fs['tmp/a/b']
+    test_dir.should_receive(:entry).with('tmp/a/b')
+    test_dir['tmp/a/b']
 
-    test_fs.should_receive(:dir).with('tmp/a/b')
-    test_fs['tmp/a/b/']
+    test_dir.should_receive(:dir).with('tmp/a/b')
+    test_dir['tmp/a/b/']
   end
 
   it '/' do
-    test_fs[:some_path].should == test_fs / :some_path
-    test_fs[:some_path][:another_path].should == test_fs / :some_path / :another_path
+    test_dir[:some_path].should == test_dir / :some_path
+    test_dir[:some_path][:another_path].should == test_dir / :some_path / :another_path
   end
 
   it "UniversalEntry should be wrapped inside of proxy, Dir and File should not" do
-    -> {test_fs.dir.proxy?}.should raise_error(NoMethodError)
-    -> {test_fs.file.proxy?}.should raise_error(NoMethodError)
-    test_fs.entry.proxy?.should be_true
+    -> {test_dir.dir.proxy?}.should raise_error(NoMethodError)
+    -> {test_dir.file.proxy?}.should raise_error(NoMethodError)
+    test_dir.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 = test_fs['tmp/a/..']
+
+    dir = test_dir['tmp/a/..']
     dir.proxy?.should be_true
     dir.should be_a(Vfs::Dir)
   end

data/spec/dir_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe 'Dir' do
-  with_test_fs
+  with_test_dir
 
   before do
-    @path = test_fs['a/b/c']
+    @path = test_dir['a/b/c']
   end
 
   describe 'existence' do
@@ -13,7 +13,7 @@ describe 'Dir' do
       @path.file.create
       @path.should be_file
       @path.dir.should_not exist
-      @path.dir.create!
+      @path.dir.create
       @path.should be_dir
       @path.dir.should exist
     end
@@ -27,7 +27,6 @@ describe 'Dir' do
   describe 'create' do
     it 'should be chainable' do
       @path.dir.create.should == @path
-      @path.dir.create!.should == @path
     end
 
     it 'should create parent dirs if not exists' do
@@ -41,27 +40,29 @@ describe 'Dir' do
       @path.dir.create
     end
 
-    it 'should override existing file if override specified' do
+    it 'should override existing file' do
       @path.file.create
       @path.should be_file
-      -> {@path.dir.create}.should raise_error(Vfs::Error, /exist/)
-      @path.dir.create!
+      @path.dir.create
       @path.should be_dir
     end
 
-    it 'should override existing dir if override specified' do
-      @path.dir.create
-      @path.should be_dir
-      @path.dir.create!
-      @path.should be_dir
+    it 'should not override existing dir with content' do
+      dir = @path.dir
+      dir.create
+      file = dir.file :file
+      file.create
+      file.should exist
+
+      dir.create
+      file.should exist
     end
   end
 
   describe 'destroying' do
-    it "should raise error if it's trying to destroy a file (unless force specified)" do
+    it "should destroy a file" do
       @path.file.create
-      -> {@path.dir.destroy}.should raise_error(Vfs::Error, /can't destroy File/)
-      @path.dir.destroy!
+      @path.dir.destroy
       @path.entry.should_not exist
     end
 
@@ -72,9 +73,9 @@ describe 'Dir' do
     it 'should destroy recursivelly' do
       dir = @path.dir
       dir.create
-      dir.file('file').write 'something'
-      dir.dir('dir').create.tap do |dir|
-        dir.file('file2').write 'something2'
+      dir.file(:file).write 'something'
+      dir.dir(:dir).create.tap do |dir|
+        dir.file(:file2).write 'something2'
       end
 
       dir.destroy
@@ -83,7 +84,6 @@ describe 'Dir' do
 
     it 'should be chainable' do
       @path.dir.destroy.should == @path
-      @path.dir.destroy!.should == @path
     end
   end
 
@@ -97,10 +97,14 @@ describe 'Dir' do
     it 'entries' do
       -> {@path['non_existing'].entries}.should raise_error(Vfs::Error, /not exist/)
       @path['non_existing'].entries(bang: false).should == []
-      @path.entries.to_set.should be_eql([@path.dir('dir'), @path.file('file')].to_set)
+      @path.entries.to_set.should be_eql([@path.entry('dir'), @path.entry('file')].to_set)
       list = []
       @path.entries{|e| list << e}
-      list.to_set.should be_eql([@path.dir('dir'), @path.file('file')].to_set)
+      list.to_set.should be_eql([@path.entry('dir'), @path.entry('file')].to_set)
+    end
+
+    it 'entries with type' do
+      @path.entries(type: true).to_set.should be_eql([@path.dir('dir'), @path.file('file')].to_set)
     end
 
     it "glob search support" do
@@ -151,32 +155,28 @@ describe 'Dir' do
     end
 
     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
+      it 'should copy to file and overwrite it' do
+        @from.copy_to @to.file
         @to['file'].read.should == 'something'
       end
 
-      it 'should not override files (and override if forced)' do
+      it 'should override files' do
         @from.copy_to @to
-        -> {@from.copy_to @to}.should raise_error(/already exist/)
 
-        @from['dir/file2'].write! 'another'
-        @from.copy_to! @to
+        @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
+      it 'should copy to UniversalEntry (and overwrite)' do
         @from.copy_to @to.entry
-        -> {@from.copy_to @to.entry}.should raise_error(/already exist/)
 
-        @from.copy_to! @to.entry
+        @from.copy_to @to.entry
         @to['file'].read.should == 'something'
       end
 
       it "shouldn't delete existing content of directory" do
-        @to.dir.create!
+        @to.dir.create
         @to.file('existing_file').write 'existing_content'
         @to.dir('existing_dir').create
         @to.file('dir/existing_file2').write 'existing_content2'
@@ -193,16 +193,21 @@ describe 'Dir' do
 
       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
+        @from.copy_to(@to).should == @to
         @to.file('other_file').read.should == 'other'
       end
+
+      it "should raise error if try to copy file as dir" do
+        dir = @from.dir 'file'
+        dir.file?.should be_true
+        -> {dir.copy_to @to}.should raise_error(Vfs::Error)
+      end
     end
 
     describe 'general copy' do
@@ -212,7 +217,7 @@ describe 'Dir' do
         # prevenging usage of :efficient_dir_copy
         # Vfs::Dir.dont_use_efficient_dir_copy = true
 
-        @to = test_fs['to']
+        @to = test_dir['to']
       end
       # after do
       #   Vfs::Dir.dont_use_efficient_dir_copy = false
@@ -223,7 +228,7 @@ describe 'Dir' do
     #   it_should_behave_like 'copy_to behavior'
     #
     #   before do
-    #     @to = test_fs['to']
+    #     @to = test_dir['to']
     #   end
     # end
   end
@@ -231,19 +236,14 @@ describe 'Dir' do
   describe 'moving' do
     it 'move_to' do
       from, to = @path.file('from'), @path.file('to')
-      from.should_receive(:copy_to).with(to, {})
-      from.should_receive(:destroy).with({})
+      from.should_receive(:copy_to).with(to)
+      from.should_receive(:destroy).with()
       from.move_to to
-
-      from.should_receive(:move_to).with(to, override: true)
-      from.move_to! to
     end
 
     it 'should be chainable' do
       from, to = @path.dir('from').create, @path.dir('to')
       from.move_to(to).should == to
-      from.create
-      from.move_to!(to).should == to
     end
   end
 end