vfs 0.0.4 → 0.1.0

data/Rakefile

@@ -2,8 +2,8 @@ require 'rake_ext'
 
 project(
   name: "vfs",
-  version: "0.0.4",
-  summary: "Tiny wrapper over Net::SSH/SFTP + small rake addon for cluster configuration management",
+  version: "0.1.0",
+  summary: "Virtual File System",
 
   author: "Alexey Petrushin",
   homepage: "http://github.com/alexeypetrushin/vfs"

data/lib/vfs.rb

@@ -0,0 +1,18 @@
+%w(
+  support
+
+  path
+  error
+  
+  entries/entry
+  entries/file
+  entries/dir
+  entries/universal_entry
+  
+  entry_proxy
+  
+  storages/hash_fs
+  storages/local
+  
+  integration/string
+).each{|f| require "vfs/#{f}"}

data/lib/vfs/entries/dir.rb

@@ -0,0 +1,272 @@
+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 = {}
+      storage.open_fs do |fs|
+        try = 0
+        begin
+          try += 1
+          fs.create_dir path
+        rescue StandardError => error          
+          entry = self.entry
+          attrs = entry.get          
+          if attrs[:file] #entry.exist?
+            if options[:override]
+              entry.destroy
+            else
+              raise Error, "entry #{self} already exist!"
+            end
+          elsif attrs[:dir]
+            # do nothing
+          else
+            parent = self.parent
+            if parent.exist?
+              # some unknown error
+              raise error          
+            else
+              parent.create(options)        
+            end        
+          end
+      
+          retry if try < 2
+        end
+      end
+      self
+    end    
+    def create! options = {}
+      options[:override] = true
+      create options
+    end
+            
+    def destroy options = {}
+      storage.open_fs do |fs|
+        begin
+          fs.delete_dir path    
+        rescue StandardError => e
+          attrs = get
+          if 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[: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
+    end
+    
+    
+    # 
+    # Content
+    # 
+    def entries options = {}, &block
+      options[:bang] = true unless options.include? :bang      
+      storage.open_fs do |fs| 
+        begin
+          list = []
+          fs.each path do |name, type|
+            next if options[:filter] and options[:filter] != type
+            entry = if type == :dir
+              dir(name)
+            elsif type == :file
+              file(name)
+            else
+              raise 'invalid entry type!'
+            end
+            block ? block.call(entry) : (list << entry)
+          end
+          block ? nil : list
+        rescue StandardError => error
+          attrs = get
+          if attrs[:file]
+            raise Error, "can't query entries on File ('#{self}')!"
+          elsif attrs[:dir]
+            # unknown error
+            raise error
+          else
+            raise Error, "'#{self}' not exist!" if options[:bang]
+            []            
+          end
+        end
+      end
+    end
+    alias_method :each, :entries
+    
+    def files options = {}, &block
+      options[:filter] = :file
+      entries options, &block
+    end
+    
+    def dirs options = {}, &block
+      options[:filter] = :dir
+      entries options, &block
+    end    
+    
+    def include? name
+      entry[name].exist?
+    end
+    alias_method :has?, :include?
+    
+    
+    # 
+    # Transfers
+    # 
+    def copy_to to, options = {}
+      options[:bang] = true unless options.include? :bang
+      
+      raise Error, 'invalid argument' unless to.is_a? Entry
+      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)
+      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
+      
+      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
+      
+      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
+    
+    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
+              else
+                raise 'invalid entry type!'
+              end
+            end
+          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
+        from.storage.open_fs{|fs|
+          fs.respond_to?(:efficient_dir_copy) and fs.efficient_dir_copy(from, to)
+        } or
+        to.storage.open_fs{|fs|
+          fs.respond_to?(:efficient_dir_copy) and fs.efficient_dir_copy(from, to)
+        }
+      end
+  end
+end

data/lib/vfs/entries/entry.rb

@@ -0,0 +1,127 @@
+module Vfs
+  class Entry
+    attr_reader :storage, :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
+      else
+        storage, path = *args
+        @path_cache = Path.new path
+        @storage, @path = storage, path_cache.to_s
+      end
+      raise "storage not defined!" unless self.storage
+    end      
+        
+    
+    # 
+    # Navigation
+    # 
+    def parent
+      Dir.new(storage, path_cache + '..')
+    end
+    
+    
+    #     
+    # Transformations
+    #     
+    def dir path = nil
+      if path
+        new_path = path_cache + path
+        Dir.new storage, new_path
+      else
+        Dir.new self
+      end
+    end
+    alias_method :to_dir, :dir
+    
+    def file path = nil
+      if path
+        new_path = path_cache + path
+        File.new storage, new_path
+      else
+        File.new self
+      end
+    end
+    alias_method :to_file, :file
+    
+    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        
+      else
+        UniversalEntry.new self
+      end
+      EntryProxy.new entry
+    end
+    alias_method :to_entry, :entry
+                
+                
+    # 
+    # Attributes
+    #         
+    def get attr_name = nil
+      attrs = storage.open_fs{|fs| fs.attributes(path)}
+      attr_name ? attrs[attr_name] : attrs
+    end
+    
+    def set options
+      not_implemented
+    end
+    
+    def dir?
+      !!get(:dir)
+    end
+    
+    def file?
+      !!get(:file)
+    end
+      
+    
+    # 
+    # Micelaneous
+    # 
+    def name
+      path_cache.name
+    end
+    
+    def tmp &block
+      storage.open_fs do |fs|
+        if block
+          fs.tmp do |path|
+            block.call Dir.new(storage, path)
+          end
+        else
+          Dir.new storage, fs.tmp
+        end
+      end
+    end
+    
+    
+    # 
+    # Utils
+    #             
+    def inspect
+      "#{storage}#{':' unless storage.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
+    end
+    
+    def hash      
+      storage.hash + path.hash
+    end
+    
+    def eql? other
+      return false unless other.class == self.class
+      storage.eql?(other.storage) and path.eql?(other.path)
+    end
+  end
+end

data/lib/vfs/entries/file.rb

@@ -0,0 +1,185 @@
+module Vfs
+  class File < Entry
+    # 
+    # Attributes
+    # 
+    alias_method :exist?, :file?
+    
+    
+    #
+    # CRUD
+    #
+    def read options = {}, &block
+      options[:bang] = true unless options.include? :bang
+      storage.open_fs do |fs|
+        begin
+          if block
+            fs.read_file path, &block
+          else
+            data = ""
+            fs.read_file(path){|buff| data << buff}
+            data
+          end
+        rescue StandardError => e
+          raise Vrs::Error, "can't read Dir #{self}!" if dir.exist?
+          attrs = get
+          if attrs[:file]
+            # unknown internal error
+            raise e
+          elsif attrs[:dir]
+            raise Error, "You are trying to read Dir '#{self}' as if it's a File!"
+          else
+            if options[:bang]
+              raise Error, "file #{self} not exist!"
+            else
+              block ? block.call('') : ''
+            end        
+          end
+        end
+      end      
+    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    
+      storage.open_fs do |fs|        
+        try = 0
+        begin
+          try += 1
+          if block
+            options = args.first || {}        
+          else
+            data, options = *args
+            options ||= {}        
+          end
+          raise "can't do :override and :append at the same time!" if options[:override] and options[:append]      
+          if block        
+            fs.write_file(path, options[:append], &block)
+          else
+            fs.write_file(path, options[:append]){|writer| writer.call data}
+          end
+        rescue StandardError => error      
+          entry = self.entry
+          if entry.exist?
+            if options[:override]
+              entry.destroy
+            else
+              raise Error, "entry #{self} already exist!"
+            end
+          else
+            parent = self.parent
+            if parent.exist?
+              # some unknown error
+              raise error          
+            else
+              parent.create(options)        
+            end
+          end
+      
+          retry if try < 2
+        end
+      end
+      self
+    end    
+    def write! *args, &block
+      args << {} unless args.last.is_a? Hash
+      args.last[:override] = true
+      write *args, &block
+    end
+    
+    def destroy options = {}
+      storage.open_fs do |fs| 
+        begin
+          fs.delete_file path          
+          self
+        rescue StandardError => e
+          attrs = get
+          if 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[: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
+    end
+    
+    def append *args, &block
+      if block
+        options = args.first || {}        
+      else
+        data, options = *args
+        options ||= {}        
+      end
+      
+      options[:append] = true
+      write data, options, &block
+    end
+    
+    def update options = {}, &block
+      options[:override] = true
+      data = read options
+      write block.call(data), options
+    end
+    
+    
+    #
+    # Transfers
+    #      
+    def copy_to to, options = {}
+      raise Error, "you can't copy to itself" if self == to
+     
+      target = if to.is_a? File
+        to
+      elsif to.is_a? Dir
+        to.file #(name)  
+      elsif to.is_a? UniversalEntry
+        to.file      
+      else
+        raise "can't copy to unknown Entry!"
+      end      
+      
+      target.write options do |writer|
+        read(options){|buff| writer.call buff}
+      end
+      
+      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
+  end
+end