vfs-momolog 0.0.1

data/lib/vfs/entries/dir.rb

@@ -0,0 +1,256 @@
+module Vfs
+  class Dir < Entry
+    #
+    # Container
+    #
+    def [] path
+      path = path.to_s
+      if path =~ /.+[\/]$/
+        path = path.sub /\/$/, ''
+        dir path
+      elsif path =~ /\*/
+        entries 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 name == ''
+            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

data/lib/vfs/entries/entry.rb

@@ -0,0 +1,152 @@
+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.parent)
+    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
+
+    def delete *args
+      raise "use :destroy!"
+    end
+    alias_method :remove, :delete
+
+    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,155 @@
+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
+        data ||= ""
+        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