io 0.0.1

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake_ext'
+
+project(
+  name: "io",
+  gem: true,
+  summary: "Virtual File System",
+
+  author: "Alexey Petrushin",
+  homepage: "http://github.com/alexeypetrushin/vfs"
+)

data/lib/vfs.rb

@@ -0,0 +1,20 @@
+require 'fileutils'
+require 'set'
+
+%w(
+  path
+  error
+
+  entries/entry
+  entries/file
+  entries/dir
+  entries/universal_entry
+
+  entry_proxy
+
+  drivers/local
+
+  integration
+
+  vfs
+).each{|f| require "vfs/#{f}"}

data/lib/vfs/drivers/local.rb

@@ -0,0 +1,175 @@
+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 root = ''
+        @root = root
+      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 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

@@ -0,0 +1,253 @@
+module Vfs
+  class Dir < Entry
+    #
+    # Container
+    #
+    def [] path
+      path = path.to_s
+      if path =~ /.+[\/]$/
+        path = path.sub /\/$/, ''
+        dir path
+      else
+        entry path
+      end
+    end
+    alias_method :/, :[]
+
+
+    #
+    # Attributes
+    #
+    alias_method :exist?, :dir?
+
+
+    #
+    # CRUD
+    #
+    def create options = {}
+      driver.open do
+        try = 0
+        begin
+          try += 1
+          driver.create_dir path
+        rescue StandardError => error
+          entry = self.entry
+          attrs = entry.get
+          if attrs and attrs[:file] #entry.exist?
+            entry.destroy
+          elsif attrs and attrs[:dir]
+            # dir already exist, no need to recreate it
+            return self
+          else
+            parent = self.parent
+            if parent.exist?
+              # some unknown error
+              raise error
+            else
+              parent.create(options)
+            end
+          end
+
+          try < 2 ? retry : raise(error)
+        end
+      end
+      self
+    end
+
+    def destroy options = {}
+      destroy_entry :dir, :file
+    end
+
+
+    #
+    # Content
+    #
+    def entries *args, &block
+      raise "invalid arguments #{args.inspect}!" if args.size > 2
+      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]
+
+      driver.open do
+        begin
+          list = []
+          # 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
+              entry(name)
+            end
+            block ? block.call(entry) : (list << entry)
+          end
+          block ? nil : list
+        rescue StandardError => error
+          attrs = get
+          if attrs and attrs[:file]
+            raise Error, "can't query entries on File ('#{self}')!"
+          elsif attrs and attrs[:dir]
+            # some unknown error
+            raise error
+          else
+            # TODO2 remove :bang
+            raise Error, "'#{self}' not exist!" if options[:bang]
+            []
+          end
+        end
+      end
+    end
+    alias_method :each, :entries
+
+    def files *args, &block
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      options[:filter] = :file
+      args << options
+      entries *args, &block
+    end
+
+    def dirs *args, &block
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      options[:filter] = :dir
+      args << options
+      entries *args, &block
+    end
+
+    def include? name
+      entry[name].exist?
+    end
+    alias_method :has?, :include?
+
+    def empty?
+      catch :break do
+        entries{|e| throw :break, false}
+        true
+      end
+    end
+
+
+    #
+    # Transfers
+    #
+    def copy_to to, options = {}
+      options[:bang] = true unless options.include? :bang
+
+      raise Error, "invalid argument, destination should be a Entry (#{to})!" unless to.is_a? Entry
+      raise Error, "you can't copy to itself" if self == to
+
+      target = if to.is_a? File
+        to.dir
+      elsif to.is_a? Dir
+        to.dir #(name)
+      elsif to.is_a? UniversalEntry
+        # raise "can't copy Dir to File ('#{self}')!" if to.file? and !options[:override]
+        to.dir #.create
+      else
+        raise "can't copy to unknown Entry!"
+      end
+
+      # efficient_dir_copy(target, options) || unefficient_dir_copy(target, options)
+      unefficient_dir_copy(target, options)
+
+      target
+    end
+
+    def move_to to, options = {}
+      copy_to to, options
+      destroy options
+      to
+    end
+
+    # class << self
+    #   attr_accessor :dont_use_efficient_dir_copy
+    # end
+
+    protected
+      def unefficient_dir_copy to, options
+        to.create options
+        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
+            e.copy_to to.file(e.name), options
+          else
+            raise 'internal error'
+          end
+        end
+      end
+
+
+      # def efficient_dir_copy to, options
+      #   return false if self.class.dont_use_efficient_dir_copy
+      #
+      #   driver.open do
+      #     try = 0
+      #     begin
+      #       try += 1
+      #       self.class.efficient_dir_copy(self, to, options[:override])
+      #     rescue StandardError => error
+      #       unknown_errors = 0
+      #
+      #       attrs = get
+      #       if attrs and attrs[:file]
+      #         raise Error, "can't copy File as a Dir ('#{self}')!"
+      #       elsif attrs and 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 and attrs[:file]
+      #         if options[:override]
+      #           to.destroy
+      #         else
+      #           raise Vfs::Error, "entry #{to} already exist!"
+      #         end
+      #       elsif attrs and 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.driver.open{
+      #     driver.respond_to?(:efficient_dir_copy) and driver.efficient_dir_copy(from, to, override)
+      #   } or
+      #   to.driver.open{
+      #     driver.respond_to?(:efficient_dir_copy) and driver.efficient_dir_copy(from, to, override)
+      #   }
+      # end
+  end
+end