vfs 0.0.4 → 0.1.0

data/lib/vfs/entries/universal_entry.rb

@@ -0,0 +1,24 @@
+module Vfs
+  class UniversalEntry < Entry
+    # 
+    # Attributes
+    # 
+    def exist?
+      attrs = get
+      !!(attrs[:dir] or attrs[:file])
+    end
+    
+    
+    #
+    # CRUD
+    #
+    def destroy
+      storage.open_fs do |fs|
+        attrs = get 
+        fs.delete_dir path if attrs[:dir]
+        fs.delete_file path if attrs[:file]
+      end
+      self
+    end
+  end
+end

data/lib/vfs/entry_proxy.rb

@@ -0,0 +1,38 @@
+# 
+# It allows you dynamically (magically) switch between UniversalEntry/Dir/File
+# 
+module Vfs
+  class EntryProxy < BasicObject    
+    attr_reader :_target
+    # WRAP = [:[], :entry, :dir, :file].to_set
+    
+    def initialize entry
+      raise 'something wrong happening here!' if entry.respond_to?(:proxy?) and entry.proxy?
+      self._target = entry
+    end
+    
+    def proxy?
+      true
+    end
+    
+    protected :==, :equal?, :!, :!=
+    protected    
+      attr_writer :_target
+      
+      def method_missing m, *a, &b
+        unless _target.respond_to? m
+          if ::Vfs::UniversalEntry.method_defined? m
+            self.target = _target.entry
+          elsif ::Vfs::Dir.method_defined? m
+            self._target = _target.dir
+          elsif ::Vfs::File.method_defined? m
+            self._target = _target.file
+          end
+        end
+        
+        _target.send m, *a, &b
+        
+        # return WRAP.include?(m) ? EntryProxy.new(result) : result
+      end
+  end
+end

data/lib/vfs/error.rb

@@ -0,0 +1,4 @@
+module Vfs
+  class Error < StandardError
+  end
+end

data/lib/vfs/integration/string.rb

@@ -0,0 +1,19 @@
+class String
+  def to_entry_on storage = nil
+    path = self
+    storage ||= Vfs::Storages::Local.new    
+    
+    Vfs::Dir.new(storage, '/')[path]
+  end
+  alias_method :to_entry, :to_entry_on  
+  
+  def to_file_on storage = nil
+    to_entry_on(storage).file
+  end
+  alias_method :to_file, :to_file_on
+  
+  def to_dir_on storage = nil
+    to_entry_on(storage).dir
+  end
+  alias_method :to_dir, :to_dir_on
+end

data/lib/vfs/path.rb

@@ -0,0 +1,125 @@
+module Vfs
+  class Path < String
+    def initialize path = '/', options = {}
+      if options[:skip_normalization]
+        super path
+        @probably_dir = options[:probably_dir]
+      else
+        Path.validate! path
+        path, probably_dir = Path.normalize_to_string path
+        raise "invalid path '#{path}' (you are outside of the root)!" unless path
+        super path
+        @probably_dir = probably_dir
+      end      
+    end
+    
+    def + path = ''
+      path = path.to_s
+      Path.validate! path, false
+      
+      if Path.absolute?(path)
+        Path.normalize path
+      elsif path.empty?
+        self
+      else
+        Path.normalize "#{self}#{'/' unless self == '/'}#{path}"
+      end
+    end
+    
+    def parent
+      self + '..'
+    end
+    
+    def probably_dir?
+      !!@probably_dir
+    end
+    
+    def name
+      unless @name
+        root = self[0..0]
+        @name ||= split('/').last || root
+      end
+      @name
+    end
+    
+    class << self
+      def absolute? path
+        path =~ /^[\/~]|^\.$|^\.\//
+      end
+      
+      def valid? path, forbid_relative = true, &block
+        result, err = if forbid_relative and !absolute?(path)
+          [false, "path must be started with '/', '~', or '.'"]
+        elsif path =~ /.+[\/~]$|\/\.$/
+          [false, "path can't be ended with '/', '~', or '/.'"]
+        elsif path =~ /\/[\/~]|\/\.\//
+          [false, "path can't include '/./', '/~/', '//' combinations!"]
+        elsif path =~ /.+[~]|\/\.\//
+          [false, "'~', or '.' can be present only at the begining of string"]
+        else
+          [true, nil]
+        end
+    
+        block.call err if block and !result and err
+        result
+      end
+    
+      def normalize path
+        path, probably_dir = normalize_to_string path
+        unless path        
+          nil
+        else
+          Path.new(path, skip_normalization: true, probably_dir: probably_dir)
+        end
+      end
+    
+      def validate! path, forbid_relative = true
+        valid?(path, forbid_relative){|error| raise "invalid path '#{path}' (#{error})!"}
+      end
+      
+      def normalize_to_string path
+        root = path[0..0]        
+        result, probably_dir = [], false
+        
+        parts = path.split('/')[1..-1]
+        if parts
+          parts.each do |part|
+            if part == '..' and root != '.'
+              return nil, false unless result.size > 0
+              result.pop
+              probably_dir ||= true
+            # elsif part == '.'
+            #   # do nothing
+            else
+              result << part
+              probably_dir &&= false
+            end
+          end
+        end      
+        normalized_path = result.join('/')        
+          
+        probably_dir ||= true if normalized_path.empty?
+
+        return "#{root}#{'/' unless root == '/' or normalized_path.empty?}#{normalized_path}", probably_dir
+      end
+    end    
+    
+    # protected    
+    #   def delete_dir_mark
+    #     path = path.to_s.sub(%r{/$}, '')
+    #   end
+    # 
+    # 
+    #   def root_path? path
+    #     path =~ /^[#{ROOT_SYMBOLS}]$/
+    #   end
+    # 
+    #   def split_path path
+    #     path.split(/#{ROOT_SYMBOLS}/)
+    #   end
+    # 
+    #   def dir_mark? path
+    #     path =~ %r{/$}
+    #   end
+  end
+end

data/lib/vfs/storages/hash_fs.rb

@@ -0,0 +1,194 @@
+# 
+# Dirty and uneficient In Memory FS, mainly for tests.
+# 
+module Vfs
+  module Storages
+    class HashFs < Hash
+      def initialize
+        super
+        self['/'] = {dir: true}
+      end
+      
+      
+      def open_fs &block
+        block.call self
+      end
+      
+      # 
+      # Attributes
+      # 
+      def attributes path
+        base, name = split_path path
+      
+        # if path == '/'
+        #   return {dir: true, file: false}
+        # end
+        # 
+        stat = cd(base)[name]
+        attrs = {}
+        attrs[:file] = !!stat[:file]
+        attrs[:dir] = !!stat[:dir]
+        attrs
+      rescue Exception
+        {}
+      end
+      
+      def set_attributes path, attrs      
+        raise 'not supported'
+      end
+      
+      
+      # 
+      # File
+      #       
+      def read_file path, &block
+        base, name = split_path path
+        assert cd(base)[name], :include?, :file
+        block.call cd(base)[name][:content]
+      end
+      
+      def write_file path, append, &block
+        base, name = split_path path
+                    
+        os = if append
+          file = cd(base)[name]
+          file ? file[:content] : ''
+        else
+          assert_not cd(base), :include?, name
+          ''
+        end
+        writer = -> buff {os << buff}       
+        block.call writer
+
+        cd(base)[name] = {file: true, content: os}
+      end
+      
+      def delete_file path
+        base, name = split_path path
+        assert cd(base)[name], :include?, :file
+        cd(base).delete name
+      end
+      
+      # def move_file path
+      #   raise 'not supported'
+      # end
+    
+      
+      # 
+      # Dir
+      #
+      def create_dir path
+        base, name = split_path path
+        assert_not cd(base), :include?, name
+        cd(base)[name] = {dir: true}
+      end
+    
+      def delete_dir path
+        base, name = split_path path        
+        assert cd(base)[name], :include?, :dir
+        # empty = true
+        # cd(base)[name].each do |key, value|
+        #   empty = false if key.is_a? String
+        # end
+        # raise 'you are trying to delete not empty dir!' unless empty
+        cd(base).delete name
+      end      
+      
+      # def move_dir path
+      #   raise 'not supported'
+      # end
+      
+      def each path, &block
+        base, name = split_path path
+        assert cd(base)[name], :include?, :dir
+        cd(base)[name].each do |relative_name, content|
+          next if relative_name.is_a? Symbol
+          if content[:dir]
+            block.call relative_name, :dir
+          else
+            block.call relative_name, :file
+          end
+        end
+      end
+      
+      def efficient_dir_copy from, to
+        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]
+
+              true
+            else
+              false
+            end
+          end
+        end
+      end      
+      def for_spec_helper_effective_copy_used; end
+      
+      # def upload_directory from_local_path, to_remote_path
+      #   FileUtils.cp_r from_local_path, to_remote_path
+      # end
+      # 
+      # def download_directory from_remote_path, to_local_path
+      #   FileUtils.cp_r from_remote_path, to_local_path
+      # end
+      
+      
+      # 
+      # Other
+      # 
+      def local?; true end
+      
+      def to_s; 'hash_fs' end
+      
+      def tmp &block
+        tmp_dir = "/tmp_#{rand(10**6)}"
+        create_dir tmp_dir
+        if block
+          begin
+            block.call tmp_dir
+          ensure
+            delete_dir tmp_dir
+          end
+        else          
+          tmp_dir
+        end
+      end
+      
+      protected
+        def assert obj, method, arg          
+          raise "#{obj} should #{method} #{arg}" unless obj.send method, arg
+        end
+        
+        def assert_not obj, method, arg
+          raise "#{obj} should not #{method} #{arg}" if obj.send method, arg
+        end
+      
+        def split_path path
+          parts = path[1..-1].split('/')
+          parts.unshift '/'
+          name = parts.pop          
+          return parts, name
+        end
+      
+        def cd parts
+          current = self
+          iterator = parts.clone
+          while iterator.first
+            current = current[iterator.first]
+            iterator.shift
+          end    
+          current
+        end
+    end
+  end
+end

data/lib/vfs/storages/local.rb

@@ -0,0 +1,138 @@
+require 'tempfile'
+
+module Vfs
+  module Storages
+    class Local
+      module LocalVfsHelper
+        DEFAULT_BUFFER = 1024*128
+        
+        attr_writer :buffer
+        def buffer
+          @buffer || DEFAULT_BUFFER
+        end        
+        
+        # 
+        # Attributes
+        # 
+        def attributes path
+          stat = ::File.stat path
+          attrs = {}
+          attrs[:file] = stat.file?
+          attrs[:dir] = stat.directory?
+          attrs
+        rescue Errno::ENOENT
+          {}
+        end
+
+        def set_attributes path, attrs      
+          raise 'not supported'
+        end
+
+
+        # 
+        # File
+        #       
+        def read_file path, &block
+          ::File.open path, 'r' do |is|
+            while buff = is.gets(self.buffer || DEFAULT_BUFFER)            
+              block.call buff
+            end
+          end
+        end
+
+        def write_file path, append, &block        
+          option = append ? 'a' : 'w'
+          ::File.open path, option do |os|
+            writer = -> buff {os.write buff}
+            block.call writer
+          end
+        end
+
+        def delete_file path
+          ::File.delete path
+        end
+
+        # def move_file from, to
+        #   FileUtils.mv from, to
+        # end
+
+
+        # 
+        # Dir
+        #
+        def create_dir path
+          ::Dir.mkdir path
+        end
+
+        def delete_dir path
+          FileUtils.rm_r path
+        end      
+
+        def each path, &block
+          ::Dir.foreach path do |relative_name|
+            next if relative_name == '.' or relative_name == '..'
+            if ::File.directory? "#{path}/#{relative_name}"
+              block.call relative_name, :dir
+            else
+              block.call relative_name, :file
+            end
+          end
+        end
+        
+        def efficient_dir_copy from, to
+          from.storage.open_fs do |from_fs|          
+            to.storage.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
+
+        # def move_dir path
+        #   raise 'not supported'
+        # end
+
+        # def upload_directory from_local_path, to_remote_path
+        #   FileUtils.cp_r from_local_path, to_remote_path
+        # end
+        # 
+        # def download_directory from_remote_path, to_local_path
+        #   FileUtils.cp_r from_remote_path, to_local_path
+        # end
+
+
+        # 
+        # Other
+        # 
+        def local?; true end
+        
+        def tmp &block
+          tmp_dir = "#{::Dir.tmpdir}/#{rand(10**3)}"        
+          if block
+            begin
+              create_dir tmp_dir
+              block.call tmp_dir
+            ensure
+              delete_dir tmp_dir
+            end
+          else
+            create_dir tmp_dir
+            tmp_dir
+          end
+        end
+        
+        def to_s; '' end
+      end
+      
+      include LocalVfsHelper
+      
+      def open_fs &block
+        block.call self
+      end
+    end
+  end
+end