vfs-momolog 0.0.1

data/lib/vfs/entries/universal_entry.rb

@@ -0,0 +1,24 @@
+module Vfs
+  class UniversalEntry < Entry
+    #
+    # Attributes
+    #
+    def exist?
+      !!get
+    end
+
+
+    def copy_to to, options = {}
+      from = file? ? to_file : to_dir
+      from.copy_to to, options
+    end
+
+
+    #
+    # CRUD
+    #
+    def destroy
+      destroy_entry
+    end
+  end
+end

data/lib/vfs/entry_proxy.rb

@@ -0,0 +1,42 @@
+#
+# It allows dynamically (magically) switching between UniversalEntry/Dir/File
+#
+module Vfs
+  class EntryProxy < BasicObject
+    attr_reader :_target
+
+    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 respond_to? m
+        super or
+        ::Vfs::UniversalEntry.method_defined?(m) or
+        ::Vfs::Dir.method_defined?(m) or
+        ::Vfs::File.method_defined?(m)
+      end
+
+      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
+      end
+  end
+end

data/lib/vfs/error.rb

@@ -0,0 +1,4 @@
+module Vfs
+  class Error < StandardError
+  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/path.rb

@@ -0,0 +1,123 @@
+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 != '.' or (root == '.' and result.size > 0))
+              return nil, false unless result.size > 0
+              result.pop
+              probably_dir ||= true
+            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/version.rb

@@ -0,0 +1,3 @@
+module Vfs
+  VERSION = "0.0.1"
+end

data/lib/vfs/vfs.rb

@@ -0,0 +1,38 @@
+module Vfs
+  class << self
+    def default_driver
+      ::Vfs::Drivers::Local.new
+    end
+
+    def to_entry
+      '/'.to_entry
+    end
+
+    def to_file
+      to_entry.file
+    end
+
+    def to_dir
+      to_entry.dir
+    end
+
+    # def [] path
+    #   to_entry[path]
+    # end
+    # alias_method :/, :[]
+
+    %w(
+      entry dir file
+      entries dirs files
+      [] /
+      tmp
+    ).each do |m|
+      script = <<-RUBY
+        def #{m} *a, &b
+          to_entry.#{m} *a, &b
+        end
+      RUBY
+      eval script, binding, __FILE__, __LINE__
+    end
+  end
+end

data/old/hash_fs.rb

@@ -0,0 +1,216 @@
+#
+# Very dirty and inefficient In Memory File System, mainly for tests.
+#
+module Vfs
+  module Drivers
+    class HashFs < Hash
+      def initialize
+        super
+        self['/'] = {dir: true}
+      end
+
+
+      def open &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_entry path, query, &block
+        raise "hash_fs not support :each_entry with query!" if query
+
+        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, override
+        from.driver.open do |from_fs|
+          to.driver.open do |to_fs|
+            if from_fs == to_fs
+              for_spec_helper_effective_copy_used
+
+              _efficient_dir_copy from.path, to.path, override
+              true
+            else
+              false
+            end
+          end
+        end
+      end
+
+      def _efficient_dir_copy from_path, to_path, override
+        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
+
+        if cd(to_base).include? to_name
+          if cd(to_base)[to_name][:dir]
+            each_entry from_path, nil do |name, type|
+              if type == :dir
+                _efficient_dir_copy "#{from_path}/#{name}", "#{to_path}/#{name}", override
+              else
+                raise "file #{to_path}/#{name} already exist!" if cd(to_base)[to_name].include?(name) and !override
+                cd(to_base)[to_name][name] = cd(from_base)[from_name][name].clone
+              end
+            end
+          else
+            raise "can't copy dir #{from_path} to file #{to_path}!"
+          end
+        else
+          cd(to_base)[to_name] = {dir: true}
+          _efficient_dir_copy from_path, to_path, override
+        end
+      end
+      protected :_efficient_dir_copy
+      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