virtfs 0.0.1

data/lib/virtfs/context_switch_class_methods.rb

@@ -0,0 +1,96 @@
+module VirtFS
+  module ContextSwitchClassMethods
+    def context_manager
+      ContextManager
+    end
+
+    def context
+      context_manager.current.current_context
+    end
+
+    def context!
+      context_manager.current!.current_context
+    end
+
+    def mount(fs_instance, mount_point)
+      context.mount(fs_instance, mount_point)
+    end
+
+    def umount(mount_point)
+      context.umount(mount_point)
+    end
+
+    def mounted?(mount_point)
+      context.mounted?(mount_point)
+    end
+
+    def cwd=(dir)
+      context.restore_cwd_root(dir, nil)
+    end
+
+    def root
+      _cwd, root = context.cwd_root
+      root
+    end
+
+    def dir_chroot(dir)
+      context.chroot(dir)
+    end
+
+    def dir_chdir(dir)
+      context.chdir(dir)
+    end
+
+    def dir_getwd
+      context.getwd
+    end
+
+    #
+    # Expand symbolic links and perform mount indirection look up.
+    #
+    def path_lookup(path, raise_full_path = false, include_last = true)
+      context.path_lookup(path, raise_full_path, include_last)
+    end
+
+    #
+    # Expand symbolic links in the path.
+    # This must be done here, because a symlink in one file system
+    # can point to a file in another filesystem.
+    #
+    def expand_links(p, include_last = true)
+      context.expand_links(p, include_last)
+    end
+
+    def normalize_path(p, relative_to = nil)
+      # When running on windows, File.expand_path will add a drive letter.
+      # Remove it if it's there.
+      VfsRealFile.expand_path(p, relative_to || context.getwd).sub(/^[a-zA-Z]:/, "") # XXX
+    end
+
+    # Invoke block withing the given filesystem context
+    #
+    # @api private
+    # @param fs [VirtFS::FS] filesystem intstance through which to invoke block
+    # @param path [String] path to specify to block
+    #
+    # @raise [VirtFS::NotImplementedError] if filesystem method does not exist
+    #
+    def fs_call(fs, path = nil, &block)
+      block.arity < 1 ? fs.instance_eval(&block) : fs.instance_exec(path, &block)
+    rescue NoMethodError => err
+      STDOUT.puts err.to_s
+      STDOUT.puts err.backtrace.join("\n")
+      raise VirtFS::NotImplementedError.new(fs, err.name)
+    end
+
+  # Invoke block using fully resolved filesystem path
+  #
+  # @api private
+  # @see .fs_call
+  # @see Context#path_lookup
+    def fs_lookup_call(path, raise_full_path = false, include_last = true, &block)
+      fs, p = path_lookup(path, raise_full_path, include_last)
+      fs_call(fs, p, &block)
+    end
+  end
+end

data/lib/virtfs/delegate_module.rb

@@ -0,0 +1,40 @@
+require "delegate"
+
+module VirtFS
+  module DelegateModule
+    def delegate_module(superclass)
+      mod = Module.new
+      methods = superclass.instance_methods
+      methods -= ::Delegator.public_api
+      methods -= [:to_s, :inspect, :=~, :!~, :===]
+
+      mod.module_eval do
+        def __getobj__  # :nodoc:
+          unless defined?(@delegate_dc_obj)
+            return yield if block_given?
+            __raise__ ::ArgumentError, "not delegated"
+          end
+          @delegate_dc_obj
+        end
+
+        def __setobj__(obj)  # :nodoc:
+          __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
+          @delegate_dc_obj = obj
+        end
+
+        methods.each do |method|
+          define_method(method, Delegator.delegating_block(method))
+        end
+      end
+
+      mod.define_singleton_method :public_instance_methods do |all = true|
+        super(all) - superclass.protected_instance_methods
+      end
+
+      mod.define_singleton_method :protected_instance_methods do |all = true|
+        super(all) | superclass.protected_instance_methods
+      end
+      mod
+    end
+  end
+end

data/lib/virtfs/dir_instance_delegate.rb

@@ -0,0 +1,3 @@
+module VirtFS
+  DirInstanceDelegate = delegate_module(VfsRealDir)
+end

data/lib/virtfs/exception.rb

@@ -0,0 +1,13 @@
+module VirtFS
+  class NotImplementedError < StandardError
+    def initialize(fs, method)
+      super "Feature: #{method} - not implemented in #{fs.name} filesystem"
+    end
+  end
+
+  class NoContextError < StandardError
+    def initialize
+      super "No filesystem context defined for thread group: #{Thread.current.group.inspect}"
+    end
+  end
+end

data/lib/virtfs/file_instance_delegate.rb

@@ -0,0 +1,3 @@
+module VirtFS
+  FileInstanceDelegate = delegate_module(VfsRealFile)
+end

data/lib/virtfs/file_modes_and_options.rb

@@ -0,0 +1,293 @@
+module VirtFS
+
+  # Utilty class to convert String File Modes and Options to their
+  # corresponding Ruby Constants.
+  #
+  # *args --> mode="r" <,permission> <,options>
+  #           mode       --> String or Integer
+  #           permission --> Integer
+  #           options    --> Hash
+  #
+  # 1 arg:  <mode | options>
+  # 2 args: mode, <permissions | options>
+  # 3 args: mode, permissions, options
+  #
+  # mode string --> file-mode[:external-encoding[:internal-encoding]]
+  #
+  # file-mode mapped to binary:
+  #     "r"  --> File::RDONLY
+  #     "r+" --> File::RDWR
+  #     "w"  --> File::WRONLY | File::TRUNC  | File::CREAT
+  #     "w+" --> File::RDWR   | File::TRUNC  | File::CREAT
+  #     "a"  --> File::WRONLY | File::APPEND | File::CREAT
+  #     "a+" --> File::RDWR   | File::APPEND | File::CREAT
+  #
+  # Options:
+  #     :autoclose          => If false, the underlying file will not be closed
+  #                            when this I/O object is finalized.
+  #
+  #     :binmode            => Opens the IO object in binary mode if true (same as mode: "b").
+  #
+  #     :encoding           => Specifies both external and internal encodings
+  #                            as "external:internal" (same format used in mode parameter).
+  #
+  #     :external_encoding  => Specifies the external encoding.
+  #
+  #     :internal_encoding  => Specifies the internal encoding.
+  #
+  #     :mode               => Specifies what would have been the mode parameter.
+  #
+  #     :textmode           => Open the file in text mode (the default).
+  #
+  class FileModesAndOptions # rubocop:disable ClassLength
+    attr_reader :external_encoding, :external_encoding_str
+    attr_reader :internal_encoding, :internal_encoding_str
+    attr_reader :permissions, :mode_bits, :options
+    attr_reader :args
+
+    BINARY_ENCODING = "ASCII-8BIT"
+
+    def initialize(*args) # rubocop:disable AbcSize, PerceivedComplexity
+      @args      = args
+      @options   = {}
+      @mode_bits = 0
+      @external_encoding_str = ""
+      @internal_encoding_str = ""
+      @binmode     = false
+      @autoclose   = true
+      @permissions = nil
+      @closed      = false
+
+      process_args(args)
+
+      @mode_bits = VFile::RDONLY if @mode_bits == 0
+
+      if @external_encoding_str.empty? || @external_encoding_str.empty? == "-"
+        @external_encoding = Encoding.default_external
+      else
+        @external_encoding = Encoding.find(@external_encoding_str)
+      end
+
+      if @internal_encoding_str.empty? || @internal_encoding_str == "-"
+        @internal_encoding = Encoding.default_internal
+      else
+        @internal_encoding = Encoding.find(@internal_encoding_str)
+      end
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    def append?
+      @mode_bits & VFile::APPEND != 0
+    end
+
+    def autoclose?
+      @autoclose
+    end
+
+    def binmode?
+      @binmode
+    end
+
+    def binmode
+      set_encoding(BINARY_ENCODING, nil)
+      @binmode = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    def create?
+      @mode_bits & VFile::CREAT != 0
+    end
+
+    def excl?
+      @mode_bits & VFile::EXCL != 0
+    end
+
+    def noctty?
+      @mode_bits & VFile::NOCTTY != 0
+    end
+
+    def nonblock?
+      @mode_bits & VFile::NONBLOCK != 0
+    end
+
+    def rdonly?
+      @mode_bits == VFile::RDONLY # VFile::RDONLY = 0
+    end
+
+    def rdwr?
+      @mode_bits & VFile::RDWR != 0
+    end
+
+    def trunc?
+      @mode_bits & VFile::TRUNC != 0
+    end
+
+    def wronly?
+      @mode_bits & VFile::WRONLY != 0
+    end
+
+    def read?
+      rdonly? || rdwr?
+    end
+
+    def write?
+      wronly? || rdwr?
+    end
+
+    def close_read
+      return unless rdonly?
+      close
+    end
+
+    def close_write
+      return unless wronly?
+      close
+    end
+
+    def close
+      @closed = true
+    end
+
+    def set_encoding(*args) # rubocop:disable AccessorMethodName, AbcSize, PerceivedComplexity, CyclomaticComplexity, MethodLength, LineLength
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 1..2)" if args.length < 1 || args.length > 2
+      unless args[0].is_a?(Encoding) || args[0].respond_to?(:to_str)
+        raise TypeError, "no implicit conversion of #{args[0].class.name} into String"
+      end
+
+      if args.length == 2
+        unless args[1].is_a?(Encoding) || args[1].respond_to?(:to_str) || args[1].nil?
+          raise TypeError, "no implicit conversion of #{args[1].class.name} into String"
+        end
+        @external_encoding     = args[0].is_a?(Encoding) ? args[0] : Encoding.find(args[0].to_str)
+        @internal_encoding     = args[1].nil? || args[1].is_a?(Encoding) ? args[1] : Encoding.find(args[1].to_str)
+        return nil
+      end
+
+      if args[0].is_a?(Encoding)
+        @external_encoding = args[0]
+        return nil
+      end
+
+      if args[0].to_str.include?(":")
+        @external_encoding_str, @internal_encoding_str = args[0].split(":")
+        @external_encoding_str = @external_encoding_str.to_str
+        @internal_encoding_str = @internal_encoding_str.to_str
+      else
+        @external_encoding_str = @internal_encoding_str = args[0].to_str
+      end
+
+      @external_encoding = Encoding.find(@external_encoding_str) unless @external_encoding_str.empty?
+      @internal_encoding = Encoding.find(@internal_encoding_str) unless @internal_encoding_str.empty?
+      nil
+    end
+
+    private
+
+    def process_args(args) # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity
+      case args.length
+      when 0
+        # mode = "r"
+      when 1
+        # <mode | options>
+        if args[0].is_a?(Hash)
+          @options = args[0]
+        else
+          mode_arg(args[0])
+        end
+      when 2
+        # mode, <permissions | options>
+        mode_arg(args[0])
+        if args[1].is_a?(Hash)
+          @options = args[1]
+        else
+          @permissions = args[1].to_int
+        end
+      when 3
+        # mode, permissions, options
+        mode_arg(args[0])
+        @permissions = args[1].to_int
+        @options = args[2]
+        raise ArgumentError, "wrong number of arguments (4 for 1..3)" unless @options.is_a?(Hash)
+      end
+      process_options(@options)
+    end
+
+    def mode_arg(mode) # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity
+      if mode.respond_to?(:to_int)
+        @mode_bits = mode.to_int
+      else
+        @mode_string = mode.to_str
+        @file_mode, external_encoding_str, internal_encoding_str = @mode_string.split(":")
+
+        unless external_encoding_str.nil? || external_encoding_str.empty?
+          raise ArgumentError, "encoding specified twice" unless @external_encoding_str.empty?
+          @external_encoding_str = external_encoding_str.to_s
+        end
+        unless internal_encoding_str.nil? || internal_encoding_str.empty?
+          raise ArgumentError, "encoding specified twice" unless @internal_encoding_str.empty?
+          @internal_encoding_str = internal_encoding_str.to_s
+        end
+
+        mode_str_to_bits(@file_mode)
+      end
+      @mode_provided = true
+    end
+
+    def mode_str_to_bits(mode_str) # rubocop:disable AbcSize, CyclomaticComplexity
+      if mode_str[-1] == "b"
+        binmode
+        mode_str[-1] = ""
+        return if mode_str.empty?
+      end
+
+      @mode_bits = case mode_str
+                   when "r"  then VFile::RDONLY
+                   when "r+" then VFile::RDWR
+                   when "w"  then VFile::WRONLY | VFile::TRUNC | VFile::CREAT
+                   when "w+" then VFile::RDWR | VFile::TRUNC | VFile::CREAT
+                   when "a"  then VFile::WRONLY | VFile::APPEND | VFile::CREAT
+                   when "a+" then VFile::RDWR | VFile::APPEND | VFile::CREAT
+                   else
+                     raise ArgumentError, "invalid access mode #{mode_str}"
+                   end
+    end
+
+    def process_options(opts) # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity, MethodLength
+      return if opts.empty?
+
+      @autoclose = opts[:autoclose] if opts.key?(:autoclose)
+      if opts.key?(:binmode)
+        raise ArgumentError, "binmode specified twice" if binmode?
+        binmode
+      end
+      if opts[:encoding]
+        raise ArgumentError, "encoding specified twice" unless @external_encoding_str.empty? && @internal_encoding_str.empty? # rubocop:disable LineLength
+        @external_encoding_str, @internal_encoding_str = opts[:encoding].split(":")
+        @external_encoding_str = @external_encoding_str.to_s
+        @internal_encoding_str = @internal_encoding_str.to_s
+      end
+      if opts[:external_encoding]
+        raise ArgumentError, "encoding specified twice" unless @external_encoding_str.empty?
+        @external_encoding_str = opts[:external_encoding].dup
+      end
+      if opts[:internal_encoding]
+        raise ArgumentError, "encoding specified twice" unless @internal_encoding_str.empty?
+        @internal_encoding_str = opts[:internal_encoding]
+      end
+      if opts[:mode]
+        # raise ArgumentError, "mode specified twice" if @mode_provided
+        mode_arg(opts[:mode])
+      end
+      if opts.key?(:textmode)
+        raise ArgumentError, "binmode and textmode are mutually exclusive" if binmode?
+      end
+      nil
+    end
+  end
+end