virtfs 0.0.1

data/lib/virtfs/v_io.rb

@@ -0,0 +1,243 @@
+module VirtFS
+  # VirtFS IO representation - implements the core Ruby IO methods, dispatching
+  # to underlying mounted VirtFS filesystems
+  #
+  class VIO # rubocop:disable ClassLength
+    include IOInstanceDelegate
+
+    VfsRealIO.constants.each { |cn| const_set(cn, VfsRealIO.const_get(cn)) }
+
+    # VFile initializer
+    #
+    # @param io_obj [VirtFS::FS::IO] handle to filesystem specific io obj
+    #
+    def initialize(io_obj)
+      __setobj__(io_obj)
+    end
+
+    #
+    # Some methods need to return the IO object. Methods in the delegator
+    # object can't do that, so we intercept them and do it here.
+    #
+
+    def <<(obj)
+      super
+      self
+    end
+
+    def binmode
+      super
+      self
+    end
+
+    def reopen(*args)
+      __setobj__(super)
+      self
+    end
+
+    def set_encoding(*args) # rubocop:disable Style/AccessorMethodName
+      super
+      self
+    end
+
+    def to_io
+      self
+    end
+
+    # Class methods
+    class << self
+      # Read specified number of bytes from file
+      #
+      # @param f [String] file to ready
+      # @param length [Integer] number of bytes to read
+      # @param offset [Integer] position to start reading at
+      #
+      # @return [Array<Byte>] bytes read from file (up to length size)
+      def binread(f, length = nil, offset = 0)
+        VFile.open(f, "rb") do |fobj|
+          fobj.pos = offset
+          return fobj.read unless length
+          return fobj.read(length)
+        end
+      end
+
+      # def binwrite()
+
+      # Copy stream from source to destination
+      #
+      # @param from [String] file stream to copy
+      # @param to [String] file stream to copy to
+      # @param max_length [Integer] max number of bytes to copy
+      # @param offset [Integer] position to start coying from
+      def copy_stream(from, to, max_length = nil, offset = 0) # rubocop:disable CyclomaticComplexity
+        from_file = from.is_a?(VIO) ? from : VFile.open(from, "rb")
+        to_file   = to.is_a?(VIO)   ? to   : VFile.open(to, "wb") # rubocop:disable SpaceAroundOperators
+        return copy_from_to(from_file, to_file, max_length, offset)
+      ensure
+        from_file.close unless from_file.nil? || from.is_a?(VIO)
+        to_file.close   unless to_file.nil?   || to.is_a?(VIO)    # rubocop:disable SpaceAroundOperators
+      end
+
+      # Invoke block for each file matching pattern
+      #
+      # IO.foreach( portname, separator=$/ <, options> ) { | line | . . . } -> nil
+      # IO.foreach( portname, limit <, options> ) { | line | . . . } -> nil
+      # IO.foreach( portname, separator, limit <, options> ) { | line | . . . } -> nil
+      #
+      def foreach(portname, *args, &block)
+        return VfsRealIO.foreach(portname, *args) unless filename?(portname)
+        return to_enum(__method__, portname, *args) unless block_given?
+
+        separator, limit, options = parse_args(args)
+
+        VFile.open(portname, "r", options) do |fobj|
+          fobj.each(separator, limit, &block)
+        end
+        nil
+      end
+
+      def pipe(*args, &block)
+        # XXX - should wrap VfsRealIO objects in common delegator class
+        # so is_a? and kind_of? will work with all IO objects.
+        VfsRealIO.pipe(*args, &block) # TODO: wrap returned read and write IO
+      end
+
+      def popen(*args, &block)
+        VfsRealIO.popen(*args, &block) # TODO: wrap returned IO
+      end
+
+      def read(portname, *args)
+        return VfsRealIO.read(portname, *args) unless filename?(portname)
+
+        length, offset, options = length_offset_options(args)
+
+        VFile.open(portname, "r", options) do |fobj|
+          fobj.pos = offset
+          return fobj.read unless length
+          return fobj.read(length)
+        end
+      end
+
+      def readlines(portname, *args)
+        return VfsRealIO.readlines(portname, *args) unless filename?(portname)
+        foreach(portname, *args).to_a
+      end
+
+      def select(*args)
+        VfsRealIO.select(*args)
+      end
+
+      def sysopen(*args)
+        VfsRealIO.sysopen(*args)
+      end
+
+      def try_convert(obj)
+        return nil unless obj.respond_to?(:to_io)
+        obj.to_io # TODO: wrap?
+      end
+
+      # Instantiate IO instance.
+      #
+      # @param integer_fd [Integer] file descriptor
+      # @param mode [String] mode to open IO instance
+      # @param hash_options options to forward to IO initialiezr
+      #
+      def new(integer_fd, mode = "r", hash_options = {})
+        #
+        # Directly instantiating an IO instance (not through File)
+        # will return a standard IO object.
+        #
+        fs_obj = VfsRealIO.new(integer_fd, mode, hash_options)
+        obj = allocate
+        obj.send(:initialize, fs_obj)
+        obj
+      end
+      alias_method :for_fd, :new
+
+      # Open IO Instance and invoke block w/ it before closing
+      #
+      # @see #new
+      def open(*args)
+        io_obj = new(*args) # IO.new or File.new
+        return io_obj unless block_given?
+        begin
+          return yield(io_obj)
+        ensure
+          io_obj.close
+        end
+      end
+
+      private
+
+      def filename?(portname)
+        portname[0] != "|"
+      end
+
+      # separator, limit, options
+      def parse_args(args)
+        separator = $RS
+        limit = nil
+        options = {}
+
+        while (arg = args.shift)
+          if arg.is_a?(String)
+            separator = arg
+          elsif arg.is_a?(Numeric)
+            limit = arg
+          elsif arg.is_a?(Hash)
+            options = arg
+          end
+        end
+        return separator, limit, options
+      end
+
+      def length_offset_options(args) # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity
+        case args.length
+        when 0
+          return nil, 0, {}
+        when 1
+          return args[0].to_int, 0, {} if args[0].respond_to?(:to_int)
+          return nil, 0, args[0].to_hash if args[0].respond_to?(:to_hash)
+          int_type_error(args[0])
+        when 2
+          int_type_error(args[0]) unless args[0].respond_to?(:to_int)
+          return args[0].to_int, args[1].to_int, {} if args[1].respond_to?(:to_int)
+          return args[0].to_int, 0, args[1].to_hash if args[1].respond_to?(:to_hash)
+          int_type_error(args[1])
+        when 3
+          int_type_error(args[0]) unless args[0].respond_to?(:to_int)
+          int_type_error(args[1]) unless args[1].respond_to?(:to_int)
+          return args[0].to_int, args[1].to_int, args[2].to_hash if args[2].respond_to?(:to_hash)
+          hash_type_error(args[2])
+        else
+          raise ArgumentError, "wrong number of arguments (5+ for 1..4)"
+        end
+      end
+
+      def int_type_error(arg)
+        raise TypeError, "no implicit conversion from #{arg.class.name} to integer"
+      end
+
+      def hash_type_error(arg)
+        raise TypeError, "no implicit conversion from #{arg.class.name} to Hash"
+      end
+
+      def copy_from_to(from, to, length, offset)
+        chunk_size    = 1024
+        bytes_written = 0
+
+        from.pos = offset
+        while (rv = from.read(chunk_size))
+          if length && bytes_written + rv.bytesize > length
+            len = length - bytes_written
+            to.write(rv[0, len])
+            break
+          end
+          to.write(rv)
+          bytes_written += rv.bytesize
+        end
+        bytes_written
+      end
+    end # class methods
+  end
+end

data/lib/virtfs/v_pathname.rb

@@ -0,0 +1,128 @@
+module VirtFS
+  class VPathname < VfsRealPathname
+    def self.getwd
+      new(::Dir.getwd)
+    end
+
+    def self.pwd
+      getwd
+    end
+
+    def self.glob(*args)
+      return ::Dir.glob(args).collect { |p| new(p) } unless block_given?
+      ::Dir.glob(*args).each { |p| yield(new(p)) }
+    end
+
+    # absolute?
+    # ascend
+
+    def atime
+      ::File.atime(to_path)
+    end
+
+    # basename
+
+    def binread(*args)
+      ::File.binread(to_path, *args)
+    end
+
+    # binwrite
+    # birthtime
+    # blockdev?
+    # chardev?
+    # children
+    # chmod
+    # chown
+    # cleanpath
+    # ctime
+    # delete
+    # descend
+    # directory?
+    # dirname
+    # each_child
+    # each_entry
+    # each_filename
+    # each_line
+    # empty?
+    # entries
+    # eql?
+    # executable?
+    # executable_real?
+    # exist?
+
+    def expand_path(dirstring = nil)
+      return self if absolute?
+      self.class.new(::File.expand_path(to_path, dirstring))
+    end
+
+    # extname
+
+    def file?
+      ::File.file?(to_path)
+    end
+
+    # find
+    # fnmatch
+    # fnmatch?
+    # freeze
+    # ftype
+    # grpowned?
+    # join
+    # lchmod
+    # lchown
+    # lstat
+    # make_link
+    # make_symlink
+    # mkdir
+    # mkpath
+    # mountpoint?
+    # mtime
+    # open
+    # opendir
+    # owned?
+    # parent
+    # pipe?
+
+    def read(*args)
+      ::File.open(to_path, "r") { |f| return f.read(*args) }
+    end
+
+    # readable?
+    # readable_real?
+    # readlines
+    # readlink
+    # realdirpath
+    # realpath
+    # relative?
+    # relative_path_from
+    # rename
+    # rmdir
+    # rmtree
+    # root?
+    # setgid?
+    # setuid?
+    # size
+    # size?
+    # socket?
+    # split
+    # stat
+    # sticky?
+    # sub
+    # sub_ext
+    # symlink?
+    # sysopen
+    # taint
+    # to_path
+    # to_s
+    # truncate
+    # unlink
+    # untaint
+    # utime
+    # world_readable?
+    # world_writable?
+    # writable?
+    # writable_real?
+    # write
+    # zero?
+  end
+end

data/lib/virtfs/version.rb

@@ -0,0 +1,3 @@
+module VirtFS
+  VERSION = "0.0.1" unless const_defined?(:VERSION)
+end

data/spec/activate_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe VirtFS, " - activation (#{$fs_interface} interface)" do
+  before(:each) do
+    reset_context
+    @root = File::SEPARATOR
+    @native_fs = nativefs_class.new
+    VirtFS.mount(@native_fs, @root)
+  end
+
+  after(:each) do
+    VirtFS.deactivate! if VirtFS.activated?
+    VirtFS.umount(@root) if VirtFS.mounted?(@root)
+  end
+
+  it "should save reference to standard Dir class" do
+    expect(Object.const_defined?(:VfsRealDir)).to be true
+    expect(VfsRealDir).to eq(Dir)
+  end
+
+  it "should save reference to standard File class" do
+    expect(Object.const_defined?(:VfsRealFile)).to be true
+    expect(VfsRealFile).to eq(File)
+  end
+
+  it "should save reference to standard IO class" do
+    expect(Object.const_defined?(:VfsRealIO)).to be true
+    expect(VfsRealIO).to eq(IO)
+  end
+
+  it "should define VirtFS class" do
+    expect(Object.const_defined?(:VirtFS)).to be true
+  end
+
+  it "should define VirtFS::VDir class" do
+    expect(VirtFS.const_defined?(:VDir)).to be true
+  end
+
+  it "should define VirtFS::VFile class" do
+    expect(VirtFS.const_defined?(:File)).to be true
+  end
+
+  it "should define VirtFS::VIO class" do
+    expect(VirtFS.const_defined?(:IO)).to be true
+  end
+
+  describe ".activate!" do
+    it "should cause .activated? to return true" do
+      expect(VirtFS.activated?).to be false
+      VirtFS.activate!
+      expect(VirtFS.activated?).to be true
+    end
+
+    it "should set standard Dir class to VirtFS::Dir" do
+      expect(Dir).to eq(VfsRealDir)
+      VirtFS.activate!
+      expect(Dir).to eq(VirtFS::VDir)
+    end
+
+    it "should set standard File class to VirtFS::File" do
+      expect(File).to eq(VfsRealFile)
+      VirtFS.activate!
+      expect(File).to eq(VirtFS::VFile)
+    end
+
+    it "should set standard IO class to VirtFS::IO" do
+      expect(IO).to eq(VfsRealIO)
+      VirtFS.activate!
+      expect(IO).to eq(VirtFS::VIO)
+    end
+  end
+
+  describe ".deactivate!" do
+    before(:each) do
+      VirtFS.activate!
+    end
+
+    after(:each) do
+      VirtFS.deactivate! if VirtFS.activated?
+    end
+
+    it "should cause .activated? to return false" do
+      expect(VirtFS.activated?).to be true
+      VirtFS.deactivate!
+      expect(VirtFS.activated?).to be false
+    end
+
+    it "should set standard Dir class to VfsRealDir" do
+      expect(Dir).to eq(VirtFS::VDir)
+      VirtFS.deactivate!
+      expect(Dir).to eq(VfsRealDir)
+    end
+
+    it "should set standard File class to VfsRealFile" do
+      expect(File).to eq(VirtFS::VFile)
+      VirtFS.deactivate!
+      expect(File).to eq(VfsRealFile)
+    end
+
+    it "should set standard IO class to VfsRealDir" do
+      expect(IO).to eq(VirtFS::VIO)
+      VirtFS.deactivate!
+      expect(IO).to eq(VfsRealIO)
+    end
+  end
+
+  describe ".with" do
+    after(:each) do
+      VirtFS.deactivate! if VirtFS.activated?
+    end
+
+    it "should only be activated within block - when not activated initially" do
+      expect(VirtFS.activated?).to be false
+      VirtFS.with { expect(VirtFS.activated?).to be true }
+      expect(VirtFS.activated?).to be false
+    end
+
+    it "should remain activated - when activated initially" do
+      VirtFS.activate!
+      expect(VirtFS.activated?).to be true
+      VirtFS.with { expect(VirtFS.activated?).to be true }
+      expect(VirtFS.activated?).to be true
+    end
+  end
+
+  describe ".without" do
+    after(:each) do
+      VirtFS.deactivate! if VirtFS.activated?
+    end
+
+    it "should only be deactivated within block - when activated initially" do
+      VirtFS.activate!
+      expect(VirtFS.activated?).to be true
+      VirtFS.without { expect(VirtFS.activated?).to be false }
+      expect(VirtFS.activated?).to be true
+    end
+
+    it "should remain deactivated - when deactivated initially" do
+      expect(VirtFS.activated?).to be false
+      VirtFS.without { expect(VirtFS.activated?).to be false }
+      expect(VirtFS.activated?).to be false
+    end
+  end
+
+  describe "Dir objects" do
+    it "should identify as standard Dir - when not activated" do
+      Dir.open(__dir__) do |dir|
+        expect(dir).to be_kind_of(Dir)
+        expect(dir).to be_kind_of(VfsRealDir)
+        expect(dir).not_to be_kind_of(VirtFS::VDir)
+      end
+    end
+
+    it "should identify as VirtFS Dir - when activated" do
+      VirtFS.with do
+        Dir.open(__dir__) do |dir|
+          expect(dir).to be_kind_of(Dir)
+          expect(dir).to be_kind_of(VirtFS::VDir)
+          expect(dir).not_to be_kind_of(VfsRealDir)
+        end
+      end
+    end
+  end
+
+  describe "File objects" do
+    it "should identify as standard File - when not activated" do
+      File.open(__FILE__) do |file|
+        expect(file).to be_kind_of(File)
+        expect(file).to be_kind_of(VfsRealFile)
+        expect(file).not_to be_kind_of(VirtFS::VFile)
+      end
+    end
+
+    it "should identify as standard IO - when not activated" do
+      File.open(__FILE__) do |file|
+        expect(file).to be_kind_of(IO)
+        expect(file).to be_kind_of(VfsRealIO)
+        expect(file).not_to be_kind_of(VirtFS::VIO)
+      end
+    end
+
+    it "should identify as VirtFS File - when activated" do
+      VirtFS.with do
+        File.open(__FILE__) do |file|
+          expect(file).to be_kind_of(File)
+          expect(file).to be_kind_of(VirtFS::VFile)
+          expect(file).not_to be_kind_of(VfsRealFile)
+        end
+      end
+    end
+
+    it "should identify as VirtFS IO - when activated" do
+      VirtFS.with do
+        File.open(__FILE__) do |file|
+          expect(file).to be_kind_of(IO)
+          expect(file).to be_kind_of(VirtFS::VIO)
+          expect(file).not_to be_kind_of(VfsRealIO)
+        end
+      end
+    end
+  end
+end