io 0.0.1

data/lib/vfs/entries/entry.rb

@@ -0,0 +1,147 @@
+module Vfs
+  class Entry
+    attr_reader :driver, :path, :path_cache
+
+    def initialize *args
+      if args.size == 1 and args.first.is_a? Entry
+        entry = args.first
+        @path_cache = entry.path_cache
+        @driver, @path = entry.driver, entry.path
+      else
+        driver, path = *args
+        @path_cache = Path.new path
+        @driver, @path = driver, path_cache.to_s
+      end
+      raise "driver not defined!" unless self.driver
+    end
+
+    #
+    # Navigation
+    #
+    def parent
+      Dir.new(driver, path_cache + '..')
+    end
+
+
+    #
+    # Transformations
+    #
+    def dir path = nil
+      if path
+        new_path = path_cache + path
+        Dir.new driver, 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 driver, 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
+        klass.new driver, new_path
+      else
+        UniversalEntry.new self
+      end
+      EntryProxy.new entry
+    end
+    alias_method :to_entry, :entry
+
+
+    #
+    # Attributes
+    #
+    def get attr_name = nil
+      attrs = driver.open{driver.attributes(path)}
+      (attr_name and attrs) ? attrs[attr_name] : attrs
+    end
+
+    def set options
+      # TODO2 set attributes
+      not_implemented
+    end
+
+    def dir?; !!get(:dir) end
+    def file?; !!get(:file) end
+    def created_at; get :created_at end
+    def updated_at; get :updated_at end
+
+
+    #
+    # Miscellaneous
+    #
+    def name
+      path_cache.name
+    end
+
+    def tmp &block
+      driver.open do
+        if block
+          driver.tmp do |path|
+            block.call Dir.new(driver, path)
+          end
+        else
+          Dir.new driver, driver.tmp
+        end
+      end
+    end
+
+    def local?
+      driver.local?
+    end
+
+
+    #
+    # Utils
+    #
+    def inspect
+      "#{driver}#{':' unless driver.to_s.empty?}#{path}"
+    end
+    alias_method :to_s, :inspect
+
+    def == other
+      return false unless other.is_a? Entry
+      driver == other.driver and path == other.path
+    end
+
+    def hash
+      driver.hash + path.hash
+    end
+
+    def eql? other
+      return false unless other.class == self.class
+      driver.eql?(other.driver) and path.eql?(other.path)
+    end
+
+    protected
+      def destroy_entry first = :file, second = :dir
+        driver.open do
+          begin
+            driver.send :"delete_#{first}", path
+          rescue StandardError => e
+            attrs = get
+            if attrs and attrs[first]
+              # some unknown error
+              raise e
+            elsif attrs and attrs[second]
+              driver.send :"delete_#{second}", path
+            else
+              # do nothing, entry already not exist
+            end
+          end
+        end
+        self
+      end
+  end
+end

data/lib/vfs/entries/file.rb

@@ -0,0 +1,154 @@
+module Vfs
+  class File < Entry
+    #
+    # Attributes
+    #
+    alias_method :exist?, :file?
+
+
+    #
+    # CRUD
+    #
+    def read options = {}, &block
+      options[:bang] = true unless options.include? :bang
+      driver.open do
+        begin
+          if block
+            driver.read_file path, &block
+          else
+            data = ""
+            driver.read_file(path){|buff| data << buff}
+            data
+          end
+        rescue StandardError => e
+          raise Vfs::Error, "can't read Dir #{self}!" if dir.exist?
+          attrs = get
+          if attrs and attrs[:file]
+            # unknown internal error
+            raise e
+          elsif attrs and 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 write *args, &block
+      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]
+
+      driver.open do
+        try = 0
+        begin
+          try += 1
+          if block
+            driver.write_file(path, options[:append], &block)
+          else
+            driver.write_file(path, options[:append]){|writer| writer.write data}
+          end
+        rescue StandardError => error
+          parent = self.parent
+          if entry.exist?
+            entry.destroy
+          elsif !parent.exist?
+            parent.create(options)
+          else
+            # unknown error
+            raise error
+          end
+
+          try < 2 ? retry : raise(error)
+        end
+      end
+      self
+    end
+
+    def append *args, &block
+      options = (args.last.is_a?(Hash) && args.pop) || {}
+      options[:append] = true
+      write(*(args << options), &block)
+    end
+
+    def update options = {}, &block
+      data = read options
+      write block.call(data), options
+    end
+
+    def destroy
+      destroy_entry
+    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.write buff}
+      end
+
+      target
+    end
+
+    def move_to to
+      copy_to to
+      destroy
+      to
+    end
+
+
+    #
+    # Extra Stuff
+    #
+    def render *args
+      require 'tilt'
+
+      args.unshift Object.new if args.size == 1 and args.first.is_a?(Hash)
+
+      template = Tilt.new(path){read}
+      template.render *args
+    end
+
+    def size; get :size end
+
+    def basename
+      ::File.basename(name, File.extname(name))
+    end
+
+    def extension
+      ::File.extname(name).sub(/^\./, '')
+    end
+  end
+end

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,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