vfs 0.3.15 → 0.4.0

data/Rakefile

@@ -4,6 +4,7 @@ project(
   name: "vfs",
   gem: true,
   summary: "Virtual File System",
+  version: '0.4.0',
 
   author: "Alexey Petrushin",
   homepage: "http://github.com/alexeypetrushin/vfs"

data/lib/vfs.rb

@@ -1,6 +1,7 @@
-%w(
-  support
+require 'fileutils'
+require 'set'
 
+%w(
   path
   error
 
@@ -11,9 +12,9 @@
 
   entry_proxy
 
-  storages/local
+  drivers/local
 
-  integration/string
+  integration
 
   vfs
 ).each{|f| require "vfs/#{f}"}

data/lib/vfs/drivers/local.rb

@@ -0,0 +1,179 @@
+require 'tempfile'
+
+module Vfs
+  module Drivers
+    class Local
+      class Writer
+        def initialize out; @out = out end
+
+        def write data
+          @out.write data
+        end
+      end
+
+      DEFAULT_BUFFER = 1000 * 1024
+
+      def initialize options = {}
+        options = options.clone
+        @root = options.delete(:root) || ''
+        raise "invalid options #{options}" unless options.empty?
+      end
+
+      def open &block
+        block.call self if block
+      end
+      def close; end
+
+      attr_writer :buffer
+      def buffer
+        @buffer || DEFAULT_BUFFER
+      end
+
+      #
+      # Attributes
+      #
+      def attributes path
+        path = with_root path
+
+        stat = ::File.stat path
+        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[:size]       = stat.size if attrs[:file]
+        attrs
+      rescue Errno::ENOTDIR
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def set_attributes path, attrs
+        # TODO2 set attributes
+        not_implemented
+      end
+
+
+      #
+      # File
+      #
+      def read_file path, &block
+        path = with_root path
+        ::File.open path, 'r' do |is|
+          while buff = is.gets(self.buffer || DEFAULT_BUFFER)
+            block.call buff
+          end
+        end
+      end
+
+      def write_file original_path, append, &block
+        path = with_root original_path
+
+        option = append ? 'a' : 'w'
+        ::File.open path, "#{option}b" do |out|
+          block.call Writer.new(out)
+        end
+      end
+
+      def delete_file path
+        path = with_root path
+        ::File.delete path
+      end
+
+      # def move_file from, to
+      #   FileUtils.mv from, to
+      # end
+
+
+      #
+      # Dir
+      #
+      def create_dir path
+        path = with_root path
+        ::Dir.mkdir path
+      end
+
+      def delete_dir original_path
+        path = with_root original_path
+        ::FileUtils.rm_r path
+      end
+
+      def each_entry path, query, &block
+        path = with_root path
+
+        if query
+          path_with_trailing_slash = path == '/' ? path : "#{path}/"
+          ::Dir["#{path_with_trailing_slash}#{query}"].each do |absolute_path|
+            name = absolute_path.sub path_with_trailing_slash, ''
+            block.call name, ->{::File.directory?(absolute_path) ? :dir : :file}
+            # if ::File.directory? absolute_path
+            #   block.call relative_path, :dir
+            # else
+            #   block.call relative_path, :file
+            # end
+          end
+        else
+          ::Dir.foreach path do |name|
+            next if name == '.' or name == '..'
+            block.call name, ->{::File.directory?("#{path}/#{name}") ? :dir : :file}
+            # if ::File.directory? "#{path}/#{relative_name}"
+            #   block.call relative_name, :dir
+            # else
+            #   block.call relative_name, :file
+            # end
+          end
+        end
+      end
+
+      # def efficient_dir_copy from, to, override
+      #   return false if override # FileUtils.cp_r doesn't support this behaviour
+      #
+      #   from.driver.open_fs do |from_fs|
+      #     to.driver.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
+
+      #
+      # Other
+      #
+      def local?; true end
+
+      def tmp &block
+        path = "/tmp/#{rand(10**6)}"
+        # tmp_dir = "#{::Dir.tmpdir}/#{rand(10**6)}"
+        if block
+          begin
+            ::FileUtils.mkdir_p with_root(path)
+            block.call path
+          ensure
+            ::FileUtils.rm_r with_root(path) if ::File.exist? with_root(path)
+          end
+        else
+          ::FileUtils.mkdir_p with_root(path)
+          path
+        end
+      end
+
+      def to_s; '' end
+
+      protected
+        def root
+          @root || raise('root not defined!')
+        end
+
+        def with_root path
+          path == '/' ? root : root + path
+        end
+    end
+  end
+end

data/lib/vfs/drivers/specification.rb

@@ -0,0 +1,169 @@
+require 'rspec_ext'
+require 'ruby_ext'
+
+shared_examples_for 'vfs driver basic' do
+  it 'should respond to :local?' do
+    @driver.should respond_to(:local?)
+  end
+
+  it "should provide open method" do
+    @driver.open
+    @driver.open{'result'}.should == 'result'
+  end
+end
+
+shared_examples_for 'vfs driver attributes basic' do
+  it 'should have root dir' do
+    attrs = @driver.attributes('/')
+    attrs[:dir].should  be_true
+    attrs[:file].should be_false
+  end
+
+  it "attributes should return nil if there's no entry" do
+    @driver.attributes('/non_existing_entry').should be_nil
+  end
+end
+
+shared_examples_for 'vfs driver files' do
+  it "file attributes" do
+    @driver.attributes('/file').should be_nil
+
+    @driver.write_file('/file', false){|w| w.write 'something'}
+    attrs = @driver.attributes('/file')
+    attrs[:file].should be_true
+    attrs[:dir].should  be_false
+  end
+
+  it "read, write, append" do
+    # write
+    @driver.write_file('/file', false){|w| w.write 'something'}
+    @driver.attributes('/file')[:file].should == true
+
+    # read
+    data = ""
+    @driver.read_file('/file'){|buff| data << buff}
+    data.should == 'something'
+
+    # append
+    @driver.write_file('/file', true){|w| w.write ' another'}
+    data = ""
+    @driver.read_file('/file'){|buff| data << buff}
+    data.should == 'something another'
+  end
+
+  it "delete_file" do
+    @driver.write_file('/file', false){|w| w.write 'something'}
+    @driver.attributes('/file')[:file].should be_true
+    @driver.delete_file('/file')
+    @driver.attributes('/file').should be_nil
+  end
+end
+
+shared_examples_for 'vfs driver full attributes for files' do
+  it "attributes for files" do
+    @driver.write_file('/file', false){|w| w.write 'something'}
+    attrs = @driver.attributes('/file')
+    attrs[:file].should be_true
+    attrs[:dir].should  be_false
+    attrs[:created_at].class.should == Time
+    attrs[:updated_at].class.should == Time
+    attrs[:size].should == 9
+  end
+end
+
+shared_examples_for 'vfs driver dirs' do
+  it "directory crud" do
+    @driver.attributes('/dir').should be_nil
+
+    @driver.create_dir('/dir')
+    attrs = @driver.attributes('/dir')
+    attrs[:file].should be_false
+    attrs[:dir].should  be_true
+
+    @driver.delete_dir('/dir')
+    @driver.attributes('/dir').should be_nil
+  end
+
+  it 'should delete not-empty directories' do
+    @driver.create_dir('/dir')
+    @driver.create_dir('/dir/dir2')
+    @driver.write_file('/dir/dir2/file', false){|w| w.write 'something'}
+    @driver.attributes('/dir').should_not be_nil
+
+    @driver.delete_dir('/dir')
+    @driver.attributes('/dir').should be_nil
+  end
+
+  it 'each' do
+    -> {@driver.each_entry('/not_existing_dir', nil){|path, type| list[path] = type}}.should raise_error
+
+    @driver.create_dir '/dir'
+    @driver.create_dir('/dir/dir2')
+    @driver.write_file('/dir/file', false){|w| w.write 'something'}
+
+    list = {}
+    @driver.each_entry '/dir', nil do |path, type|
+      type = type.call if type.is_a? Proc
+      list[path] = type
+    end
+
+    list.should == {'dir2' => :dir, 'file' => :file}
+  end
+
+  # it "upload_directory & download_directory" do
+  #   upload_path_check = "#{@remote_path}/dir2/file"
+  #   check_attributes upload_path_check, nil
+  #   @driver.upload_directory(@from_local, @remote_path)
+  #   check_attributes upload_path_check, file: true, dir: false
+  #
+  #   download_path_check = "#{@to_local}/dir2/file"
+  #   File.exist?(download_path_check).should be_false
+  #   @driver.download_directory(@remote_path, @to_local)
+  #   File.exist?(download_path_check).should be_true
+  # end
+end
+
+shared_examples_for 'vfs driver query' do
+  it 'each with query' do
+    @driver.create_dir '/dir'
+    @driver.create_dir('/dir/dir_a')
+    @driver.create_dir('/dir/dir_b')
+    @driver.write_file('/dir/file_a', false){|w| w.write 'something'}
+
+    list = {}
+    @driver.each_entry '/dir', '*_a' do |path, type|
+      type = type.call if type.is_a? Proc
+      list[path] = type
+    end
+
+    list.should == {'dir_a' => :dir, 'file_a' => :file}
+  end
+end
+
+shared_examples_for 'vfs driver full attributes for dirs' do
+  it "attributes for dirs" do
+    @driver.create_dir('/dir')
+    attrs = @driver.attributes('/dir')
+    attrs[:file].should be_false
+    attrs[:dir].should  be_true
+    attrs[:created_at].class.should == Time
+    attrs[:updated_at].class.should == Time
+    attrs.should_not include(:size)
+  end
+end
+
+shared_examples_for 'vfs driver tmp dir' do
+  it "tmp dir" do
+    dir = @driver.tmp
+    @driver.attributes(dir).should_not be_nil
+    @driver.delete_dir dir
+    @driver.attributes(dir).should be_nil
+
+    dir = nil
+    @driver.tmp do |tmp_dir|
+      dir = tmp_dir
+      @driver.attributes(dir).should_not be_nil
+    end
+    @driver.attributes(dir).should be_nil
+  end
+end

data/lib/vfs/entries/dir.rb

@@ -25,20 +25,16 @@ module Vfs
     # CRUD
     #
     def create options = {}
-      storage.open do |fs|
+      driver.open do
         try = 0
         begin
           try += 1
-          fs.create_dir path
+          driver.create_dir path
         rescue StandardError => error
           entry = self.entry
           attrs = entry.get
           if attrs and attrs[:file] #entry.exist?
-            if options[:override]
-              entry.destroy
-            else
-              raise Error, "entry #{self} already exist!"
-            end
+            entry.destroy
           elsif attrs and attrs[:dir]
             # dir already exist, no need to recreate it
             return self
@@ -57,36 +53,9 @@ module Vfs
       end
       self
     end
-    def create! options = {}
-      options[:override] = true
-      create options
-    end
 
     def destroy options = {}
-      storage.open do |fs|
-        begin
-          fs.delete_dir path
-        rescue StandardError => e
-          attrs = get
-          if attrs and attrs[:file]
-            if options[:force]
-              file.destroy
-            else
-              raise Error, "can't destroy File #{dir} (You are trying to destroy it as if it's a Dir)"
-            end
-          elsif attrs and attrs[:dir]
-            # 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
+      destroy_entry :dir, :file
     end
 
 
@@ -98,19 +67,26 @@ module Vfs
       options = args.last.is_a?(Hash) ? args.pop : {}
       query = args.first
       options[:bang] = true unless options.include? :bang
+      filter = options[:filter]
+      type_required = options[:type]
 
-      storage.open do |fs|
+      driver.open do
         begin
           list = []
-          # query option is optional and supported only for some storages (local fs for example)
-          fs.each_entry path, query do |name, type|
-            next if options[:filter] and options[:filter] != type
+          # query option is optional and supported only for some drivers (local driver for example)
+          driver.each_entry path, query do |name, type|
+            # for performance reasons some drivers may return the type of entry as
+            # optionally evaluated callback.
+            type = type.call if (filter or type_required) and type.is_a?(Proc)
+
+            next if filter and (filter != type)
+
             entry = if type == :dir
               dir(name)
             elsif type == :file
               file(name)
             else
-              raise 'invalid entry type!'
+              entry(name)
             end
             block ? block.call(entry) : (list << entry)
           end
@@ -120,9 +96,10 @@ module Vfs
           if attrs and attrs[:file]
             raise Error, "can't query entries on File ('#{self}')!"
           elsif attrs and attrs[:dir]
-            # unknown error
+            # some unknown error
             raise error
           else
+            # TODO2 remove :bang
             raise Error, "'#{self}' not exist!" if options[:bang]
             []
           end
@@ -153,7 +130,10 @@ module Vfs
     alias_method :has?, :include?
 
     def empty?
-      entries.empty?
+      catch :break do
+        entries{|e| throw :break, false}
+        true
+      end
     end
 
 
@@ -167,7 +147,6 @@ module Vfs
       raise Error, "you can't copy to itself" if self == to
 
       target = if to.is_a? File
-        raise Error, "can't copy Dir to File ('#{self}')!" unless options[:override]
         to.dir
       elsif to.is_a? Dir
         to.dir #(name)
@@ -183,20 +162,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
       to
     end
-    def move_to! to, options = {}
-      options[:override] = true
-      move_to to, options
-    end
 
     # class << self
     #   attr_accessor :dont_use_efficient_dir_copy
@@ -205,7 +176,7 @@ module Vfs
     protected
       def unefficient_dir_copy to, options
         to.create options
-        entries options do |e|
+        entries options.merge(type: true) do |e|
           if e.is_a? Dir
             e.copy_to to.dir(e.name), options
           elsif e.is_a? File
@@ -220,7 +191,7 @@ module Vfs
       # def efficient_dir_copy to, options
       #   return false if self.class.dont_use_efficient_dir_copy
       #
-      #   storage.open_fs do |fs|
+      #   driver.open do
       #     try = 0
       #     begin
       #       try += 1
@@ -271,11 +242,11 @@ module Vfs
       # 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)
+      #   from.driver.open{
+      #     driver.respond_to?(:efficient_dir_copy) and driver.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)
+      #   to.driver.open{
+      #     driver.respond_to?(:efficient_dir_copy) and driver.efficient_dir_copy(from, to, override)
       #   }
       # end
   end