virtfs 0.0.1

data/test/bench.rb

@@ -0,0 +1,18 @@
+big_string = "0123456789" * 1000
+big_string.force_encoding("ASCII-8BIT")
+
+t0 = Time.now
+(0...2_000_000).each do
+  s = big_string.dup
+  s[-1] = ""
+end
+t1 = Time.now
+puts "Index: #{t1 - t0} seconds"
+
+t0 = Time.now
+(0...2_000_000).each do
+  s = big_string.dup
+  s.chop!
+end
+t1 = Time.now
+puts "chop!: #{t1 - t0} seconds"

data/test/bio_internal_test.rb

@@ -0,0 +1,45 @@
+require "../lib/virtfs"
+require "tempfile"
+
+begin
+  @start_marker = "START OF FILE:\n"
+  @end_marker   = ":END OF FILE"
+  @data1        = "0123456789"
+  @data2        = "abcdefghijklmnopqrstuvwxyz\n"
+
+  @temp_file    = Tempfile.new("VirtFS-IO")
+  @temp_file.write(@start_marker)
+  (0..9).each do
+    @temp_file.write(@data1)
+    @temp_file.write(@data2)
+  end
+  @temp_file.write(@end_marker)
+  @temp_file.close
+
+  @full_path  = @temp_file.path
+  @rel_path   = File.basename(@full_path)
+  @parent_dir = File.dirname(@full_path)
+  @file_size  = VfsRealFile.size(@full_path)
+
+  @utf_8_filename  = VfsRealFile.join(__dir__, "UTF-8-demo.txt")
+
+  require "../lib/nativefs"
+  @root      = File::SEPARATOR
+  @native_fs = NativeFS.new
+  VirtFS.mount(@native_fs, @root)
+
+  @vfile_read_obj = VirtFS::VFile.new(@full_path, "r:UTF-8")
+  @vfile_read_obj.send(:min_read_buf_sz=, 1)
+  range = @vfile_read_obj.read_buffer.range
+
+  puts "pos = #{@vfile_read_obj.pos}, Range(#{range.first}, #{range.end})"
+
+  char = "X"
+  @vfile_read_obj.ungetc(char)
+  puts "pos = #{@vfile_read_obj.pos}, Range(#{range.first}, #{range.end})"
+  @vfile_read_obj.getc
+
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/test/delegate_io.rb

@@ -0,0 +1,31 @@
+require "delegate"
+
+begin
+
+  class MyFile < DelegateClass(::File)
+    SUPER_CLASSES = [File, IO]
+
+    def initialize(*args)
+      fobj = ::File.new(*args)
+      super(fobj)
+    end
+
+    def is_a?(klass)
+      super(klass) || SUPER_CLASSES.include?(klass)
+    end
+    alias_method :kind_of?, :is_a?
+  end
+
+  f = MyFile.new(__FILE__, "r")
+
+  puts "f.is_a?(File)   = #{f.is_a?(File)}"
+  puts "f.is_a?(IO)     = #{f.is_a?(IO)}"
+  puts "f.is_a?(MyFile) = #{f.is_a?(MyFile)}"
+  puts "f.is_a?(String) = #{f.is_a?(String)}"
+
+  f.close
+
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/test/delegate_module.rb

@@ -0,0 +1,62 @@
+require "delegate"
+
+begin
+
+  def DelegateModule(superclass)
+    klass = Module.new
+    methods = superclass.instance_methods
+    methods -= ::Delegator.public_api
+    methods -= [:to_s,:inspect,:=~,:!~,:===]
+    klass.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
+    klass.define_singleton_method :public_instance_methods do |all=true|
+      super(all) - superclass.protected_instance_methods
+    end
+    klass.define_singleton_method :protected_instance_methods do |all=true|
+      super(all) | superclass.protected_instance_methods
+    end
+    return klass
+  end
+
+  FileDelegate = DelegateModule(File)
+
+  class MyIO
+  end
+
+  class MyFile < MyIO
+    include FileDelegate
+
+    def initialize(dobj)
+      __setobj__(dobj)
+    end
+  end
+
+  fobj = File.new(__FILE__, "r")
+
+  mf = MyFile.new(fobj)
+
+  puts "mf.is_a?(MyFile) = #{mf.is_a?(MyFile)}"
+  puts "mf.is_a?(MyIO)   = #{mf.is_a?(MyIO)}"
+
+  puts
+  mf.each { |l| puts l }
+  mf.close
+
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/test/encode_test.rb

@@ -0,0 +1,42 @@
+begin
+  #
+  # Find the offset within the file of the first multi-byte character.
+  #
+  binary_string = ""
+  File.open("UTF-16-demo.txt", "rb") do |io|
+    binary_string = io.read
+  end
+  puts "\tbinary_string.encoding.name   = #{binary_string.encoding.name} (valid: #{binary_string.valid_encoding?})"
+  puts "\tbinary_string.length          = #{binary_string.length}"
+  puts "\tbinary_string.bytesize        = #{binary_string.bytesize}"
+  puts
+
+  utf8_string = ""
+  ec = Encoding::Converter.new("UTF-16le", "UTF-8")
+  rv = ec.primitive_convert(binary_string, utf8_string)
+  puts "primitive_convert --> #{rv}"
+  puts "\tutf8_string.encoding.name   = #{utf8_string.encoding.name} (valid: #{utf8_string.valid_encoding?})"
+  puts "\tutf8_string.length          = #{utf8_string.length}"
+  puts "\tutf8_string.bytesize        = #{utf8_string.bytesize}"
+  puts
+
+  nchunk = 0
+  utf8_string = ""
+  ec = Encoding::Converter.new("UTF-16le", "UTF-8")
+  File.open("UTF-16-demo.txt", "rb") do |io|
+    while (binary_string = io.read(99))
+      rv = ec.primitive_convert(binary_string, utf8_string, nil, nil, :partial_input => true)
+      puts "Chunk: #{nchunk}, rv = #{rv}"
+      nchunk += 1
+    end
+  end
+
+  puts "nchunk = #{nchunk}"
+  puts "\tutf8_string.encoding.name   = #{utf8_string.encoding.name} (valid: #{utf8_string.valid_encoding?})"
+  puts "\tutf8_string.length          = #{utf8_string.length}"
+  puts "\tutf8_string.bytesize        = #{utf8_string.bytesize}"
+  puts
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/test/enoent_test.rb

@@ -0,0 +1,30 @@
+require "yaml"
+
+begin
+  begin
+    Dir.new("/not/a/dir")
+  rescue => err
+    puts " err => #{err.class.name}"
+    puts " err => #{err.inspect}"
+    puts " err.errno = #{err.errno}"
+    puts " err.class::Errno = #{err.class::Errno}"
+    err = YAML.load(YAML.dump(err))
+    nerr = SystemCallError.new("dir", err.class::Errno)
+    # nerr.message = err.message
+    raise nerr
+  end
+rescue Errno::ENOENT => oerr
+  puts "**** Got Errno::ENOENT"
+  puts "oerr => #{oerr.class.name}"
+  puts "oerr => #{oerr.inspect}"
+  puts "oerr.errno = #{oerr.errno}"
+  puts "oerr.class::Errno = #{oerr.class::Errno}"
+rescue SystemCallError => oerr
+  puts "**** Got SystemCallError"
+rescue => oerr
+  puts "**** Not Errno::ENOENT"
+  puts "oerr => #{oerr.class.name}"
+  puts "oerr => #{oerr.inspect}"
+  puts "oerr.errno = #{oerr.errno}"
+  puts "oerr.class::Errno = #{oerr.class::Errno}"
+end

data/test/namespace_test.rb

@@ -0,0 +1,42 @@
+class MyFile
+  def self.name
+    "MyFile"
+  end
+end
+
+class Vfs
+  def self.nest(ext)
+    ext.const_set(:File, MyFile)
+  end
+end
+
+begin
+
+  Module.new do
+    class << self
+      puts self.class.name
+      puts constants.inspect
+      puts File.name
+
+      Vfs.nest(self)
+      puts constants.inspect
+      puts File.name
+    end
+  end
+
+  puts
+
+  Module.new do
+    class << self
+      puts self.class.name
+      puts constants.inspect
+      puts File.name
+    end
+  end
+
+  puts File.name
+
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/test/read_block_valid_encoding.rb

@@ -0,0 +1,44 @@
+require "tempfile"
+
+begin
+  input_file_name   = "UTF-8-demo.txt"
+  external_encoding = Encoding.find("UTF-8")
+  binary_encoding   = Encoding.find("ASCII-8BIT")
+  buffer_size       = 95
+
+  temp_file  = Tempfile.new("rbve")
+
+  File.open(input_file_name, "rb") do |io|
+    block = 0
+    while (binary_string = io.read(buffer_size))
+      binary_string.force_encoding(external_encoding)
+      puts "Block: #{block}, valid: #{binary_string.valid_encoding?}"
+      push_back = 0
+      (0...8).each do
+        break if binary_string.valid_encoding?
+        binary_string.force_encoding(binary_encoding)
+        binary_string[-1] = ""
+        binary_string.force_encoding(external_encoding)
+        push_back += 1
+      end
+      raise "Invalid byte sequence" unless binary_string.valid_encoding?
+      puts "Block: #{block}, valid: #{binary_string.valid_encoding?}, push_back: #{push_back}"
+      temp_file.write(binary_string)
+      io.seek(-push_back, IO::SEEK_CUR) unless push_back == 0
+      block += 1
+    end
+  end
+
+  temp_file.close
+
+  input  = File.read(input_file_name)
+  output = File.read(temp_file.path)
+
+  puts
+  puts "Input size:  #{input.bytesize}"
+  puts "Output size: #{output.bytesize}"
+  puts "Data check pass: #{input == output}"
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/test/read_test.rb

@@ -0,0 +1,78 @@
+begin
+  #
+  # Find the offset within the file of the first multi-byte character.
+  #
+  first_mb_char_pos = 0
+  File.open("UTF-8-demo.txt", "r:utf-8:utf-8") do |io|
+    io.each_char do |c|
+      if c.length != c.bytesize
+        puts "first_mb_char_pos = #{first_mb_char_pos}, char = '#{c}' #{c.bytes.to_a.inspect}"
+        puts
+        break
+      end
+      first_mb_char_pos += 1
+    end
+  end
+
+  puts "Read whole file as binary:"
+  binary_string = ""
+  File.open("UTF-8-demo.txt", "rb") do |io|
+    binary_string = io.read
+  end
+  puts "\tbinary_string.encoding.name   = #{binary_string.encoding.name} (valid: #{binary_string.valid_encoding?})"
+  puts "\tbinary_string.length          = #{binary_string.length}"
+  puts "\tbinary_string.bytesize        = #{binary_string.bytesize}"
+  puts
+
+  puts "Read whole file as utf-8:"
+  utf8_string = ""
+  File.open("UTF-8-demo.txt", "r:utf-8:utf-8") do |io|
+    utf8_string = io.read
+  end
+  puts "\tutf8_string.encoding.name   = #{utf8_string.encoding.name} (valid: #{utf8_string.valid_encoding?})"
+  puts "\tutf8_string.length          = #{utf8_string.length}"
+  puts "\tutf8_string.bytesize        = #{utf8_string.bytesize}"
+  puts
+
+  puts "Partial read (100 bytes) as utf-8:"
+  File.open("UTF-8-demo.txt", "r:utf-8:utf-8") do |io|
+    utf8_string = io.read(100)
+  end
+  puts "\tutf8_string.encoding.name   = #{utf8_string.encoding.name} (valid: #{utf8_string.valid_encoding?})"
+  puts "\tutf8_string.length          = #{utf8_string.length}"
+  puts "\tutf8_string.bytesize        = #{utf8_string.bytesize}"
+  puts
+
+  puts "Offset read (on char boundary) as utf-8:"
+  File.open("UTF-8-demo.txt", "r:utf-8:utf-8") do |io|
+    io.seek(first_mb_char_pos, IO::SEEK_SET)
+    utf8_string = io.read
+  end
+  puts "\tutf8_string.encoding.name   = #{utf8_string.encoding.name} (valid: #{utf8_string.valid_encoding?})"
+  puts "\tutf8_string.length          = #{utf8_string.length}"
+  puts "\tutf8_string.bytesize        = #{utf8_string.bytesize}"
+  puts
+
+  puts "Offset read (not on char boundary) as utf-8:"
+  File.open("UTF-8-demo.txt", "r:utf-8:utf-8") do |io|
+    io.seek(first_mb_char_pos+1, IO::SEEK_SET)
+    utf8_string = io.read
+  end
+  puts "\tutf8_string.encoding.name   = #{utf8_string.encoding.name} (valid: #{utf8_string.valid_encoding?})"
+  puts "\tutf8_string.length          = #{utf8_string.length}"
+  puts "\tutf8_string.bytesize        = #{utf8_string.bytesize}"
+  puts
+
+  # File.open("UTF-8-demo.txt", "r:utf-8:utf-8") do |io|
+  #   while utf8_string = io.gets
+  #     puts utf8_string
+  #     puts "\tutf8_string.encoding.name   = #{utf8_string.encoding.name} (valid: #{utf8_string.valid_encoding?})"
+  #     puts "\tutf8_string.length          = #{utf8_string.length}"
+  #     puts "\tutf8_string.bytesize        = #{utf8_string.bytesize}"
+  #     puts
+  #   end
+  # end
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/test/stream_readers.rb

@@ -0,0 +1,46 @@
+begin
+  first_mb_char_pos = 0
+  File.open("UTF-8-demo.txt", "r:utf-8:utf-8") do |io|
+    io.each_char do |c|
+      if c.length != c.bytesize
+        puts "first_mb_char_pos = #{first_mb_char_pos}, char = '#{c}' #{c.bytes.to_a.inspect}"
+        puts
+        break
+      end
+      first_mb_char_pos += 1
+    end
+  end
+
+  File.open("UTF-8-demo.txt", "r:utf-8:utf-8") do |io|
+    puts "File opened"
+    puts "\tio.pos = #{io.pos}"
+    puts
+
+    puts "Reading 10 bytes."
+    barray = io.each_byte.first(10)
+    puts "\tio.pos = #{io.pos}"
+    puts
+
+    puts "Reading 10 bytes."
+    barray = io.each_char.first(10)
+    puts "\tio.pos = #{io.pos}"
+    puts
+
+    puts "Reading 10 lines."
+    ln = 0
+    io.each_line do |line|
+      break if ln >= 10
+      puts "Line: #{ln}"
+      puts "\tline.length            = #{line.length}"
+      puts "\tline.bytesize          = #{line.bytesize}"
+      puts "\tline.codepoints.length = #{line.codepoints.length}"
+      puts "\tio.pos                 = #{io.pos}"
+      puts "\tio.lineno              = #{io.lineno}"
+      puts
+      ln += 1
+    end
+  end
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end