win32-nio 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8de13720111c1452f9e5a1f43fb0e2f8fc471ea7
-  data.tar.gz: 134e23c2257adf6c650663fde6bf4fd44a1a1c7f
+  metadata.gz: 31fe6e337f6c93527d80360c231b9fb5766e2399
+  data.tar.gz: bac2e6d821bc01dd2814f8a09b749d476da7d74e
 SHA512:
-  metadata.gz: 121d75dfb3d4fff1abbe238f6e6131e306813a38b92b7a36c5fd0f5634ec0c8a8d393861b34d204cfcd0f5771d161f381473e927338e03985a225e32873b8d21
-  data.tar.gz: a3084ccaa518e24f132760a0e3c235f93b68c7ce077e51b551bd9fa15c846a2360594849be678f180195f99974c53ed34d10a57bee50a31f0d9c2423c97ce52e
+  metadata.gz: 2985ccd28d539b4433ebf2a163fe98567b596b965ef0259eccba7df26cdf670e6cf5a7cb102b58d7a4dfd3f3d04a52973f527248aba7d16687cd70efb7fe34af
+  data.tar.gz: eeae941454d811133a0d6cf7e84093a855fbfb992e633ce4e0a895140a6780ca75780f940dfda54cc5b82d0de2d7cc16a836a22bb1a029b359fe681811bedb33

data/CHANGES

@@ -1,3 +1,10 @@
+== 0.2.0 - 30-Mar-2015
+* Converted to C code for performance.
+* The NIO.readlines method now accepts an optional event object as
+  an argument.
+* A negative offset value will now raise an ArgumentError.
+* Some documentation updates.
+ 
 == 0.1.3 - 21-Oct-2013
 * Fixed INVALID_HANDLE_VALUE for 64-bit versions of Ruby.
 * Added Rake as a development dependency.

data/README

@@ -9,58 +9,71 @@
   require 'win32/nio'
   include Win32
    
+  # Similar to Ruby
   p NIO.read('some_file.text')
-   
+  p NIO.read('some_file.text', 50)
+  p NIO.read('some_file.text', 50, 5)
+
   p NIO.readlines('some_file.txt')
-   
-= Proof of Concept
-  This code is ALPHA!
-  
-  This code is mostly a proof of concept to see how to implement Ruby's
-  IO functions in pure Windows functions. While it does offer a couple of
-  features over and above Ruby's IO interface, such as the ability to supply
-  an event or a block to the NIO.read method, it offers little practical
-  advantage at the moment.
-   
-  In addition, it is currently using pure Ruby (via FFI), which means
-  it isn't optimized for speed.
+  p NIO.readlines('some_file.txt', '')
+
+  # With events
+  event = Win32::Event.new
+
+  NIO.read('some_big_file.txt', nil, nil, event)
+  p event.signaled? # => true
+
+  # With blocks
+  NIO.read('some_big_file.txt'){ puts "Finished" }
+
+= Proof of Concept 
+  This code was originally written to see if using pure Windows functions
+  to implement MRI methods would offer any practical advantage. The answer
+  is a definite maybe.
 
+  Functionally, these library does offer something the MRI methods do not,
+  which is the ability to provide a block or event object that is called
+  when a read is finished.
+
+  In terms of speed, I've found the NIO.read method to be almost twice as
+  fast as Ruby 2.2, while the NIO.readlines method was about the same speed.
+  In most cases the NIO.readlines method offers no practical advantage, but
+  see the documentation for details.
+   
 = Benchmarks
 
-  Using my HP Windows XP Pro laptop, with a 1.66 core duo Pentium T5500 and
-  2gb of RAM, I saw these results, which were typical in repeated runs:
+  Using my current laptop running Windows 7 I saw these results, which were
+  typical in repeated runs:
+
+  IO.read(small)         0.000000   0.016000   0.016000 (  0.020342)
+  NIO.read(small)        0.000000   0.000000   0.000000 (  0.008140)
+  IO.read(medium)        0.187000   0.047000   0.234000 (  0.230579)
+  NIO.read(medium)       0.015000   0.093000   0.108000 (  0.122542)
+  IO.read(large)         1.654000   0.593000   2.247000 (  2.355478)
+  NIO.read(large)        0.343000   0.765000   1.108000 (  1.222567)
+  IO.readlines(small)    0.125000   0.000000   0.125000 (  0.119982)
+  NIO.readlines(small)   0.094000   0.015000   0.109000 (  0.132461)
+  IO.readlines(medium)   1.419000   0.234000   1.653000 (  1.764216)
+  NIO.readlines(medium)  1.092000   0.109000   1.201000 (  1.537593)
+  IO.readlines(large)   12.714000   0.874000  13.588000 ( 13.798494)
+  NIO.readlines(large)   9.719000   0.468000  10.187000 ( 13.437217)
+  
+  Your results may vary.
+
+= JRuby
+  As of version 0.2.0 this code was written as a C extension, and
+  does not support JRuby. However, JRuby users can continue to use
+  the 0.1.x branch.
                          
-                          user     system      total        real
-  IO.read(small)         0.016000   0.047000   0.063000 (  0.063000)
-  NIO.read(small)        0.109000   0.000000   0.109000 (  0.109000)
-  IO.read(medium)        0.422000   0.094000   0.516000 (  0.532000)
-  NIO.read(medium)       0.937000   0.062000   0.999000 (  1.047000)
-  IO.read(large)         3.282000   1.063000   4.345000 (  4.468000)
-  NIO.read(large)        8.187000   1.062000   9.249000 (  9.454000)
-  IO.readlines(small)    0.156000   0.063000   0.219000 (  0.234000)
-  NIO.readlines(small)   0.141000   0.000000   0.141000 (  0.797000)
-  IO.readlines(medium)   2.984000   0.250000   3.234000 (  3.625000)
-  NIO.readlines(medium)  1.172000   0.062000   1.234000 (  3.406000)
-  IO.readlines(large)    18.625000   2.281000  20.906000 ( 21.532000)
-  NIO.readlines(large)   12.406000   0.563000  12.969000 (122.643000)
-   
-  Note that, in most cases, the user and system time has decreased, but
-  the real time has increased.
-   
 = Known Bugs
   None that I know of. Please log any other bug reports on the RubyForge
   project page at https://github.com/djberg96/win32-nio.
 
-= Future Plans
-  The pure Ruby code is really only meant for prototyping. The eventual
-  plan is to convert the Ruby code to equivalent C code in order to improve
-  performance.
-
 = License
   Artistic 2.0
     
 = Copyright
-  (C) 2008-2013 Daniel J. Berger, All Rights Reserved
+  (C) 2008-2015 Daniel J. Berger, All Rights Reserved
     
 = Warranty
   This package is provided "as is" and without any express or

data/Rakefile

@@ -1,19 +1,44 @@
 require 'rake'
 require 'rake/clean'
 require 'rake/testtask'
+include RbConfig
 
-CLEAN.include("**/*.gem", "**/*.txt")
+CLEAN.include(
+  '**/*.gem',               # Gem files
+  '**/*.rbc',               # Rubinius
+  '**/*.o',                 # C object file
+  '**/*.log',               # Ruby extension build log
+  '**/Makefile',            # C Makefile
+  '**/*.def',               # Definition files
+  '**/*.exp',
+  '**/*.lib',
+  '**/*.pdb',
+  '**/*.obj',
+  '**/*.stackdump',         # Junk that can happen on Windows
+  "**/*.#{CONFIG['DLEXT']}" # C shared object
+)
+
+desc "Build the win32-nio library"
+task :build => [:clean] do
+  if RbConfig::CONFIG['host_os'] =~ /mingw|cygwn/i
+    require 'devkit'
+    make_cmd = "make"
+  else
+    make_cmd = "nmake"
+  end
+  Dir.chdir('ext') do
+    ruby "extconf.rb"
+    sh make_cmd
+    cp 'nio.so', 'win32' # For testing
+  end
+end
 
 namespace 'gem' do
   desc 'Create the win32-nio gem'
   task :create => [:clean] do
+    require 'rubygems/package'
     spec = eval(IO.read('win32-nio.gemspec'))
-    if Gem::VERSION < "2.0.0"
-      Gem::Builder.new(spec).build
-    else
-      require 'rubygems/package'
-      Gem::Package.build(spec)
-    end
+    Gem::Package.build(spec)
   end
 
   desc 'Install the win32-nio gem'
@@ -24,24 +49,30 @@ namespace 'gem' do
 end
 
 desc 'Run the benchmark suite'
-task :bench do
-  sh "ruby -Ilib benchmarks/win32_nio_benchmarks.rb"
+task :bench => [:build] do
+  sh "ruby -Iext benchmarks/win32_nio_benchmarks.rb"
 end
 
 namespace :test do
   Rake::TestTask.new(:read) do |t|
+    task :read => [:build]
+    t.libs << 'ext'
     t.verbose = true
     t.warning = true
     t.test_files = FileList['test/test_win32_nio_read.rb']
   end
 
   Rake::TestTask.new(:readlines) do |t|
+    task :readlines => [:build]
+    t.libs << 'ext'
     t.verbose = true
     t.warning = true
     t.test_files = FileList['test/test_win32_nio_readlines.rb']
   end
 
   Rake::TestTask.new(:all) do |t|
+    task :all => [:build]
+    t.libs << 'ext'
     t.verbose = true
     t.warning = true
     t.test_files = FileList['test/test*.rb']

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('win32/nio', 'win32')

data/ext/win32/nio.c

@@ -0,0 +1,347 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <windows.h>
+#include <math.h>
+
+// Callback used when a block is provided to read method. It simply calls the block.
+void CALLBACK read_complete(DWORD dwErrorCode, DWORD dwBytes, LPOVERLAPPED olap){
+  VALUE p = rb_block_proc();
+  rb_funcall(p, rb_intern("call"), 0);
+}
+
+// Helper function to raise system errors the way I would like
+void rb_raise_syserr(const char* msg, int errnum){
+  VALUE v_sys = rb_funcall(rb_eSystemCallError, rb_intern("new"), 2, rb_str_new2(msg), INT2FIX(errnum));
+  rb_funcall(rb_mKernel, rb_intern("raise"), 1, v_sys);
+}
+
+/*
+* This method is similar to Ruby's IO.read method except that it uses
+* native function calls.
+*
+* Examples:
+*
+* # Read everything
+* Win32::NIO.read(file)
+*
+* # Read the first 100 bytes
+* Win32::NIO.read(file, 100)
+*
+* # Read 50 bytes starting at offset 10
+* Win32::NIO.read(file, 50, 10)
+*
+* Note that the + options + that may be passed to this method are limited
+* to :encoding, : mode and : event because we're no longer using the open
+* function internally.In the case of:mode the only thing that is checked
+* for is the presence of the 'b' (binary)mode.
+*
+* The :event option, if present, must be a Win32::Event object.
+*/
+static VALUE rb_nio_read(int argc, VALUE* argv, VALUE self){
+  OVERLAPPED olap;
+  HANDLE h;
+  DWORD bytes_read;
+  LARGE_INTEGER lsize;
+  BOOL b;
+  VALUE v_file, v_length, v_offset, v_options;
+  VALUE v_event, v_mode, v_encoding, v_result;
+  size_t length;
+  int flags, error, size;
+  wchar_t* file = NULL;
+  char* buffer = NULL;
+
+  memset(&olap, 0, sizeof(olap));
+
+  // Paranoid initialization
+  v_length = Qnil;
+  v_offset = Qnil;
+  v_options = Qnil;
+
+  rb_scan_args(argc, argv, "13", &v_file, &v_length, &v_offset, &v_options);
+
+  // Allow path-y objects.
+  if (rb_respond_to(v_file, rb_intern("to_path")))
+    v_file = rb_funcall(v_file, rb_intern("to_path"), 0, NULL);
+
+  SafeStringValue(v_file);
+
+  // If a length is provided it cannot be negative.
+  if (!NIL_P(v_length)){
+    length = NUM2SIZET(v_length);
+    if ((int)length < 0)
+      rb_raise(rb_eArgError, "negative length %i given", (int)length);
+  }
+  else{
+    length = 0; // Mostly to make gcc stfu. We'll set this later.
+  }
+
+  // Unlike MRI, don't wait for an internal C function to fail on an invalid argument.
+  if (!NIL_P(v_offset)){
+    olap.Offset = NUM2ULONG(v_offset);
+    if ((int)olap.Offset < 0)
+      rb_raise(rb_eArgError, "negative offset %i given", (int)olap.Offset);
+  }
+
+  // Gotta do this for wide character function support.
+  size = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, NULL, 0);
+  file = (wchar_t*)ruby_xmalloc(MAX_PATH * sizeof(wchar_t));
+
+  if (!MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, file, size)){
+    ruby_xfree(file);
+    rb_raise_syserr("MultibyteToWideChar", GetLastError());
+  }
+
+  flags = FILE_FLAG_SEQUENTIAL_SCAN;
+
+  // Possible options are :event, :mode and :encoding
+  if (!NIL_P(v_options)){
+    Check_Type(v_options, T_HASH);
+
+    v_event = rb_hash_aref(v_options, ID2SYM(rb_intern("event")));
+    v_encoding = rb_hash_aref(v_options, ID2SYM(rb_intern("encoding")));
+    v_mode = rb_hash_aref(v_options, ID2SYM(rb_intern("mode")));
+
+    if (!NIL_P(v_event)){
+      flags |= FILE_FLAG_OVERLAPPED;
+      olap.hEvent = (HANDLE)NUM2OFFT(rb_funcall(v_event, rb_intern("handle"), 0, 0));
+    }
+  }
+  else{
+    v_event = Qnil;
+    v_encoding = Qnil;
+    v_mode = Qnil;
+  }
+
+  h = CreateFileW(
+    file,
+    GENERIC_READ,
+    FILE_SHARE_READ,
+    NULL,
+    OPEN_EXISTING,
+    flags,
+    NULL
+  );
+
+  if (h == INVALID_HANDLE_VALUE)
+    rb_raise_syserr("CreateFile", GetLastError());
+
+  // Get the file size. We may use this later to limit read length.
+  if (!GetFileSizeEx(h, &lsize)){
+    error = GetLastError();
+    CloseHandle(h);
+    rb_raise_syserr("GetFileSizeEx", error);
+  }
+
+  // If no length is specified, read the entire file
+  if (NIL_P(v_length))
+    length = (size_t)lsize.QuadPart;
+
+  // Don't read past the end of the file
+  if (olap.Offset + length > (size_t)lsize.QuadPart)
+    length = (size_t)lsize.QuadPart - olap.Offset;
+
+  buffer = (char*)ruby_xmalloc(length * sizeof(char));
+
+  // If a block is given then treat it as a callback
+  if (rb_block_given_p()){
+    flags |= FILE_FLAG_OVERLAPPED;
+    b = ReadFileEx(h, buffer, length, &olap, read_complete);
+  }
+  else{
+    b = ReadFile(h, buffer, length, &bytes_read, &olap);
+  }
+
+  error = GetLastError();
+
+  // Put in alertable wait state if overlapped IO
+  if (flags & FILE_FLAG_OVERLAPPED)
+    SleepEx(1, TRUE);
+
+  if (!b){
+    if(error == ERROR_IO_PENDING){
+      DWORD bytes;
+      if (!GetOverlappedResult(h, &olap, &bytes, TRUE)){
+        ruby_xfree(buffer);
+        CloseHandle(h);
+        rb_raise_syserr("GetOverlappedResult", error);
+      }
+    }
+    else{
+      ruby_xfree(buffer);
+      CloseHandle(h);
+      rb_raise_syserr("ReadFile", error);
+    }
+  }
+
+  CloseHandle(h);
+
+  v_result = rb_str_new(buffer, length);
+  ruby_xfree(buffer);
+
+  // Convert CRLF to LF if text mode
+  if (!NIL_P(v_mode) && strstr(RSTRING_PTR(v_mode), "t"))
+    rb_funcall(v_result, rb_intern("gsub!"), 2, rb_str_new2("\r\n"), rb_gv_get("$/"));
+
+  if (!NIL_P(v_encoding))
+    rb_funcall(v_result, rb_intern("encode!"), 1, v_encoding);
+
+  return v_result;
+}
+
+/*
+ * Reads the entire file specified by portname as individual lines, and
+ * returns those lines in an array. Lines are separated by +sep+.
+ *
+ * Examples:
+ *
+ *   # Standard call
+ *   Win32::NIO.readlines('file.txt') # => ['line 1', 'line 2', 'line 3', 'line 4']
+ *
+ *   # Paragraph mode
+ *   Win32::NIO.readlines('file.txt', '') # => ['line 1\r\nline 2', 'line 3\r\nline 4']
+ *
+ *   # With event
+ *   event = Win32::Event.new
+ *   Win32::NIO.readlines('file.txt', nil, event)
+ *   p event.signaled? # => true
+ *
+ * Superficially this method acts the same as the Ruby IO.readlines call, except that
+ * it does not transform line endings and accepts an optional event object. However,
+ * internally this method is using a scattered read to accomplish its goal. In practice
+ * this is only relevant in specific situations. Using it outside of those situations
+ * is unlikely to provide any practical benefit, and may even result in slower performance.
+ *
+ * See information on vectored IO for more details.
+ */
+static VALUE rb_nio_readlines(int argc, VALUE* argv, VALUE self){
+  HANDLE h;
+  SYSTEM_INFO info;
+  LARGE_INTEGER file_size;
+  size_t length, page_size;
+  double size;
+  void* base_address;
+  int error, page_num;
+  wchar_t* file;
+  VALUE v_file, v_sep, v_event, v_result;
+
+  rb_scan_args(argc, argv, "12", &v_file, &v_sep, &v_event);
+
+  SafeStringValue(v_file);
+
+  if (NIL_P(v_sep))
+    v_sep = rb_str_new2("\r\n");
+  else
+    SafeStringValue(v_sep);
+
+  v_result = Qnil;
+
+  length = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, NULL, 0);
+  file = (wchar_t*)ruby_xmalloc(MAX_PATH * sizeof(wchar_t));
+
+  if (!MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, file, length)){
+    ruby_xfree(file);
+    rb_raise_syserr("MultibyteToWideChar", GetLastError());
+  }
+
+  h = CreateFileW(
+    file,
+    GENERIC_READ,
+    FILE_SHARE_READ,
+    NULL,
+    OPEN_EXISTING,
+    FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
+    NULL
+  );
+
+  if (h == INVALID_HANDLE_VALUE)
+    rb_raise_syserr("CreateFile", GetLastError());
+
+  if (!GetFileSizeEx(h, &file_size)){
+    error = GetLastError();
+    CloseHandle(h);
+    rb_raise_syserr("GetFileSizeEx", error);
+  }
+
+  length = (size_t)file_size.QuadPart;
+
+  GetSystemInfo(&info);
+  page_size = info.dwPageSize;
+
+  page_num = (int)ceil((double)length / page_size);
+
+  size = page_num * page_size;
+
+  base_address = VirtualAlloc(NULL, (size_t)size, MEM_COMMIT, PAGE_READWRITE);
+
+  if (!base_address){
+    error = GetLastError();
+    CloseHandle(h);
+    rb_raise_syserr("VirtualAlloc", error);
+  }
+  else{
+    int i;
+    OVERLAPPED olap;
+    BOOL rv;
+    FILE_SEGMENT_ELEMENT* fse;
+
+    olap.Offset = 0;
+    olap.OffsetHigh = 0;
+
+    if (NIL_P(v_event))
+      olap.hEvent = NULL;
+    else
+      olap.hEvent = (HANDLE)NUM2OFFT(rb_funcall(v_event, rb_intern("handle"), 0, 0));
+
+    fse = (FILE_SEGMENT_ELEMENT*)malloc(sizeof(FILE_SEGMENT_ELEMENT) * (page_num + 1));
+    memset(fse, 0, sizeof(FILE_SEGMENT_ELEMENT) * (page_num + 1));
+    v_result = Qnil;
+
+    for (i = 0; i < page_num; i++)
+      fse[i].Alignment = (ULONGLONG)base_address + (page_size * i);
+
+    rv = ReadFileScatter(h, fse, (DWORD)size, NULL, &olap);
+
+    if (!rv){
+      error = GetLastError();
+
+      if (error == ERROR_IO_PENDING){
+        while (!HasOverlappedIoCompleted(&olap))
+          SleepEx(1, TRUE);
+      }
+      else{
+        VirtualFree(base_address, 0, MEM_RELEASE);
+        CloseHandle(h);
+        rb_raise_syserr("ReadFileScatter", error);
+      }
+    }
+
+    // Explicitly handle paragraph mode
+    if (rb_equal(v_sep, rb_str_new2(""))){
+      VALUE v_args[1];
+      v_args[0] = rb_str_new2("(\r\n){2,}");
+      v_sep = rb_class_new_instance(1, v_args, rb_cRegexp);
+      v_result = rb_funcall(rb_str_new2(fse[0].Buffer), rb_intern("split"), 1, v_sep);
+      rb_funcall(v_result, rb_intern("delete"), 1, rb_str_new2("\r\n"));
+    }
+    else{
+      v_result = rb_funcall(rb_str_new2(fse[0].Buffer), rb_intern("split"), 1, v_sep);
+    }
+
+    VirtualFree(base_address, 0, MEM_RELEASE);
+  }
+
+  CloseHandle(h);
+
+  return v_result;
+}
+
+void Init_nio(){
+  VALUE mWin32 = rb_define_module("Win32");
+  VALUE cNio = rb_define_class_under(mWin32, "NIO", rb_cObject);
+
+  rb_define_singleton_method(cNio, "read", rb_nio_read, -1);
+  rb_define_singleton_method(cNio, "readlines", rb_nio_readlines, -1);
+
+  /* 0.2.0: The version of the win32-nio library */
+  rb_define_const(cNio, "VERSION", rb_str_new2("0.2.0"));
+}

data/test/test_win32_nio_read.rb

@@ -24,7 +24,7 @@ class TC_Win32_NIO_Read < Test::Unit::TestCase
   end
 
   test "version number is set to expected value" do
-    assert_equal('0.1.3', Win32::NIO::VERSION)
+    assert_equal('0.2.0', Win32::NIO::VERSION)
   end
 
   test "read method basic functionality" do
@@ -61,7 +61,7 @@ class TC_Win32_NIO_Read < Test::Unit::TestCase
   end
 
   test "offset parameter must be a positive number" do
-    assert_raise(Errno::EINVAL, Errno::ENAMETOOLONG){ NIO.read(@@file, 1, -1) }
+    assert_raise(ArgumentError){ NIO.read(@@file, 1, -1) }
     assert_raise(TypeError){ NIO.read(@@file, 1, 'foo') }
   end
 
@@ -74,7 +74,7 @@ class TC_Win32_NIO_Read < Test::Unit::TestCase
   end
 
   def self.shutdown
-    File.delete(@@file) if File.exists?(@@file)
+    File.delete(@@file) if File.exist?(@@file)
     @@file = nil
     @@text = nil
   end

data/test/test_win32_nio_readlines.rb

@@ -5,6 +5,7 @@
 #######################################################################
 require 'test-unit'
 require 'win32/nio'
+require 'win32/event'
 include Win32
 
 class TC_Win32_NIO_Readlines < Test::Unit::TestCase
@@ -23,6 +24,7 @@ class TC_Win32_NIO_Readlines < Test::Unit::TestCase
 
   def setup
     @array = nil
+    @event = Win32::Event.new
   end
 
   test "readlines method basic functionality" do
@@ -45,20 +47,27 @@ class TC_Win32_NIO_Readlines < Test::Unit::TestCase
     assert_equal(4, NIO.readlines(@@file, '').size)
   end
 
+  test "readlines accepts an event object" do
+    assert_false(@event.signaled?)
+    assert_nothing_raised{ NIO.readlines(@@file, nil, @event) }
+    assert_true(@event.signaled?)
+  end
+
   test "readlines expects at least one argument" do
     assert_raise(ArgumentError){ NIO.readlines }
   end
 
-  test "readlines accepts a maximum of two arguments" do
-    assert_raise(ArgumentError){ NIO.readlines(@@file, '', true) }
+  test "readlines accepts a maximum of three arguments" do
+    assert_raise(ArgumentError){ NIO.readlines(@@file, '', @event, true) }
   end
 
   def teardown
     @array = nil
+    @event = nil
   end
 
   def self.shutdown
-    File.delete(@@file) if File.exists?(@@file)
+    File.delete(@@file) if File.exist?(@@file)
     @@file = nil
     @@size = nil
     @@line = nil

data/win32-nio.gemspec

@@ -1,20 +1,20 @@
 require 'rubygems'
 
 Gem::Specification.new do |spec|
-  spec.name     = 'win32-nio'
-  spec.version  = '0.1.3'
-  spec.author   = 'Daniel J. Berger'
-  spec.license  = 'Artistic 2.0'
-  spec.email    = 'djberg96@gmail.com'
-  spec.homepage = 'https://github.com/djberg96/win32-nio'
-  spec.summary  = 'Native IO for MS Windows'
-  spec.files    = Dir['**/*'].reject{ |f| f.include?('git') }
+  spec.name       = 'win32-nio'
+  spec.version    = '0.2.0'
+  spec.author     = 'Daniel J. Berger'
+  spec.license    = 'Artistic 2.0'
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'https://github.com/djberg96/win32-nio'
+  spec.summary    = 'Native IO for MS Windows'
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+  spec.extensions = ['ext/extconf.rb']
 
   spec.rubyforge_project = 'Win32Utils'
   spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
   spec.required_ruby_version = '> 1.9.0'
 
-  spec.add_dependency('ffi')
   spec.add_dependency('win32-event', '>= 0.6.0')
 
   spec.add_development_dependency('rake')

metadata

@@ -1,69 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: win32-nio
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel J. Berger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-21 00:00:00.000000000 Z
+date: 2015-03-30 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: ffi
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: win32-event
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: |2
@@ -73,22 +59,20 @@ description: |2
       additional event handling capability.
 email: djberg96@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/extconf.rb
 extra_rdoc_files:
 - README
 - CHANGES
 - MANIFEST
 files:
-- benchmarks/win32_nio_benchmarks.rb
 - CHANGES
-- lib/win32/nio.rb
-- lib/win32/windows/constants.rb
-- lib/win32/windows/functions.rb
-- lib/win32/windows/macros.rb
-- lib/win32/windows/structs.rb
 - MANIFEST
-- Rakefile
 - README
+- Rakefile
+- benchmarks/win32_nio_benchmarks.rb
+- ext/extconf.rb
+- ext/win32/nio.c
 - test/test_win32_nio_read.rb
 - test/test_win32_nio_readlines.rb
 - win32-nio.gemspec
@@ -102,17 +86,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - ">"
     - !ruby/object:Gem::Version
       version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: Win32Utils
-rubygems_version: 2.1.9
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Native IO for MS Windows

data/lib/win32/nio.rb

@@ -1,200 +0,0 @@
-require 'ffi'
-require 'win32/event'
-
-require File.join(File.dirname(__FILE__), 'windows/functions')
-require File.join(File.dirname(__FILE__), 'windows/constants')
-require File.join(File.dirname(__FILE__), 'windows/structs')
-require File.join(File.dirname(__FILE__), 'windows/macros')
-
-# The Win32 module serves as a namespace only.
-module Win32
-
-  # The NIO class encapsulates the native IO methods for MS Windows.
-  class NIO
-    include Windows::Constants
-    include Windows::Structs
-    extend  Windows::Functions
-    extend  Windows::Macros
-
-    # The version of the win32-nio library
-    VERSION = '0.1.3'
-
-    # This method is similar to Ruby's IO.read method except that it uses
-    # native function calls.
-    #
-    # Examples:
-    #
-    # # Read everything
-    # Win32::NIO.read(file)
-    #
-    # # Read the first 100 bytes
-    # Win32::NIO.read(file, 100)
-    #
-    # # Read 50 bytes starting at offset 10
-    # Win32::NIO.read(file, 50, 10)
-    #
-    # Note that the +options+ that may be passed to this method are limited
-    # to :encoding, :mode and :event because we're no longer using the open
-    # function internally. In the case of :mode the only thing that is checked
-    # for is the presence of the 'b' (binary) mode.
-    #
-    # The :event option, if present, must be a Win32::Event object.
-    #--
-    # In practice the fact that I ignore open_args: is irrelevant since you
-    # would never want to open in anything other than GENERIC_READ. I suppose
-    # I could change this to as a way to pass flags to CreateFile.
-    #
-    def self.read(name, length=nil, offset=0, options={})
-      begin
-        fname = name + "\0"
-        fname.encode!('UTF-16LE')
-
-        flags = FILE_FLAG_SEQUENTIAL_SCAN
-        olap  = Overlapped.new
-        event = options[:event]
-
-        if event
-          raise TypeError unless event.is_a?(Win32::Event)
-        end
-
-        olap[:Offset] = offset
-
-        if offset > 0 || event
-          flags |= FILE_FLAG_OVERLAPPED
-          olap[:hEvent] = event.handle if event
-        end
-
-        handle = CreateFileW(
-          fname,
-          GENERIC_READ,
-          FILE_SHARE_READ,
-          nil,
-          OPEN_EXISTING,
-          flags,
-          0
-        )
-
-        if handle == INVALID_HANDLE_VALUE
-          raise SystemCallError.new("CreateFile", FFI.errno)
-        end
-
-        length ||= File.size(name)
-        buf  = 0.chr * length
-
-        if block_given?
-          callback = Proc.new{ |e,b,o| block.call }
-          bool = ReadFileEx(handle, buf, buf.size, olap, callback)
-        else
-          bool = ReadFile(handle, buf, buf.size, nil, olap)
-        end
-
-        errno = FFI.errno
-
-        SleepEx(1, true) # Must be in alertable wait state
-
-        unless bool
-          if errno == ERROR_IO_PENDING
-            bytes = FFI::MemoryPointer.new(:ulong)
-            unless GetOverlappedResult(handle, olap, bytes, true)
-              raise SystemCallError.new("GetOverlappedResult", FFI.errno)
-            end
-          else
-            raise SystemCallError.new("ReadFile", errno)
-          end
-        end
-
-        result = buf.delete(0.chr)
-
-        result.encode!(options[:encoding]) if options[:encoding]
-
-        if options[:mode] && options[:mode].include?('t') && ($/ != "\r\n")
-          result.gsub!(/\r\n/, $/)
-        end
-
-        result
-      ensure
-        CloseHandle(handle) if handle && handle != INVALID_HANDLE_VALUE
-      end
-    end # NIO.read
-
-    # Reads the entire file specified by portname as individual lines, and
-    # returns those lines in an array. Lines are separated by +sep+.
-    #--
-    # The semantics are the same as the MRI version but the implementation
-    # is drastically different. We use a scattered IO read.
-    #
-    def self.readlines(file, sep = "\r\n")
-      fname = file + "\0"
-      fname.encode!('UTF-16LE')
-
-      begin
-        handle = CreateFileW(
-          fname,
-          GENERIC_READ,
-          FILE_SHARE_READ,
-          nil,
-          OPEN_EXISTING,
-          FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
-          0
-        )
-
-        if handle == INVALID_HANDLE_VALUE
-          raise SystemCallError.new("CreateFileW", FFI.errno)
-        end
-
-        sysinfo = SystemInfo.new
-        GetSystemInfo(sysinfo)
-
-        file_size = File.size(file)
-        page_size = sysinfo[:dwPageSize]
-        page_num  = (file_size.to_f / page_size).ceil
-
-        begin
-          size = page_size * page_num
-          base_address = VirtualAlloc(nil, size, MEM_COMMIT, PAGE_READWRITE)
-
-          if base_address == 0
-            raise SystemCallError.new("VirtualAlloc", FFI.errno)
-          end
-
-          # Add 1 for null as per the docs
-          array = FFI::MemoryPointer.new(FileSegmentElement, page_num + 1)
-
-          for i in 0...page_num
-            fse = FileSegmentElement.new(array[i])
-            fse[:Alignment] = base_address + page_size * i
-          end
-
-          overlapped = Overlapped.new
-
-          bool = ReadFileScatter(handle, array, size, nil, overlapped)
-
-          unless bool
-            error = FFI.errno
-            if error == ERROR_IO_PENDING
-              SleepEx(1, true) while !HasOverlappedIoCompleted(overlapped)
-            else
-              raise SystemCallError.new("ReadFileScatter", error)
-            end
-          end
-
-          string = array[0].read_pointer.read_string
-
-          if sep == ""
-            array = string.split(/(\r\n){2,}/)
-            array.delete("\r\n")
-          else
-            array = string.split(sep)
-          end
-
-          array
-        ensure
-          VirtualFree(base_address, 0, MEM_RELEASE)
-        end
-      ensure
-        CloseHandle(handle) if handle && handle != INVALID_HANDLE_VALUE
-      end
-    end # NIO.readlines
-
-  end # NIO
-end # Win32

data/lib/win32/windows/constants.rb

@@ -1,77 +0,0 @@
-require 'ffi'
-module Windows
-  module Constants
-    include FFI::Library
-
-    private
-
-    INVALID_HANDLE_VALUE = FFI::Pointer.new(-1).address
-
-    CREATE_NEW        = 1
-    CREATE_ALWAYS     = 2
-    OPEN_EXISTING     = 3
-    OPEN_ALWAYS       = 4
-    TRUNCATE_EXISTING = 5
-
-    GENERIC_READ    = 0x80000000
-    GENERIC_WRITE   = 0x40000000
-    GENERIC_EXECUTE = 0x20000000
-    GENERIC_ALL     = 0x10000000
-
-    FILE_SHARE_READ = 0x00000001
-
-    FILE_FLAG_WRITE_THROUGH       = 0x80000000
-    FILE_FLAG_OVERLAPPED          = 0x40000000
-    FILE_FLAG_NO_BUFFERING        = 0x20000000
-    FILE_FLAG_RANDOM_ACCESS       = 0x10000000
-    FILE_FLAG_SEQUENTIAL_SCAN     = 0x08000000
-    FILE_FLAG_DELETE_ON_CLOSE     = 0x04000000
-    FILE_FLAG_BACKUP_SEMANTICS    = 0x02000000
-    FILE_FLAG_POSIX_SEMANTICS     = 0x01000000
-    FILE_FLAG_OPEN_REPARSE_POINT  = 0x00200000
-    FILE_FLAG_OPEN_NO_RECALL      = 0x00100000
-    FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000
-
-    MEM_COMMIT      = 0x1000
-    MEM_RESERVE     = 0x2000
-    MEM_DECOMMIT    = 0x4000
-    MEM_RELEASE     = 0x8000
-    MEM_FREE        = 0x10000
-    MEM_PRIVATE     = 0x20000
-    MEM_MAPPED      = 0x40000
-    MEM_RESET       = 0x80000
-    MEM_TOP_DOWN    = 0x100000
-    MEM_WRITE_WATCH = 0x200000
-    MEM_PHYSICAL    = 0x400000
-    MEM_LARGE_PAGES = 0x20000000
-    MEM_4MB_PAGES   = 0x80000000
-
-    PAGE_NOACCESS          = 0x01
-    PAGE_READONLY          = 0x02
-    PAGE_READWRITE         = 0x04
-    PAGE_WRITECOPY         = 0x08
-    PAGE_EXECUTE           = 0x10
-    PAGE_EXECUTE_READ      = 0x20
-    PAGE_EXECUTE_READWRITE = 0x40
-    PAGE_EXECUTE_WRITECOPY = 0x80
-    PAGE_GUARD             = 0x100
-    PAGE_NOCACHE           = 0x200
-    PAGE_WRITECOMBINE      = 0x400
-
-    INFINITE         = 0xFFFFFFFF
-    WAIT_OBJECT_0    = 0
-    WAIT_TIMEOUT     = 0x102
-    WAIT_ABANDONED   = 128
-    WAIT_ABANDONED_0 = WAIT_ABANDONED
-    WAIT_FAILED      = 0xFFFFFFFF
-
-    STATUS_WAIT_0           =  0
-    STATUS_ABANDONED_WAIT_0 =  128
-    STATUS_USER_APC         =  192
-    STATUS_TIMEOUT          =  258
-    STATUS_PENDING          =  259
-
-    ERROR_IO_INCOMPLETE     = 996
-    ERROR_IO_PENDING        = 997
-  end
-end

data/lib/win32/windows/functions.rb

@@ -1,27 +0,0 @@
-require 'ffi'
-
-module Windows
-  module Functions
-    extend FFI::Library
-    typedef :ulong, :dword
-    typedef :uintptr_t, :handle
-    typedef :pointer, :ptr
-
-    ffi_lib :kernel32
-    ffi_convention :stdcall
-
-    attach_function :CloseHandle, [:handle], :bool
-    attach_function :CreateFileA, [:string, :dword, :dword, :ptr, :dword, :dword, :handle], :handle
-    attach_function :CreateFileW, [:buffer_in, :dword, :dword, :ptr, :dword, :dword, :handle], :handle
-    attach_function :GetOverlappedResult, [:handle, :ptr, :ptr, :bool], :bool
-    attach_function :GetSystemInfo, [:ptr], :void
-    attach_function :ReadFile, [:handle, :buffer_out, :dword, :ptr, :ptr], :bool
-    attach_function :ReadFileScatter, [:handle, :ptr, :dword, :ptr, :ptr], :bool
-    attach_function :SleepEx, [:dword, :bool], :dword
-    attach_function :VirtualAlloc, [:ptr, :size_t, :dword, :dword], :dword
-    attach_function :VirtualFree, [:dword, :size_t, :dword], :bool
-
-    callback :completion_function, [:dword, :dword, :ptr], :void
-    attach_function :ReadFileEx, [:handle, :buffer_out, :dword, :ptr, :completion_function], :bool
-  end
-end

data/lib/win32/windows/macros.rb

@@ -1,7 +0,0 @@
-module Windows
-  module Macros
-    def HasOverlappedIoCompleted(overlapped)
-      overlapped[:Internal] != 259 # STATUS_PENDING
-    end
-  end
-end

data/lib/win32/windows/structs.rb

@@ -1,39 +0,0 @@
-require 'ffi'
-
-module Windows
-  module Structs
-    extend FFI::Library
-
-    # I'm assuming the anonymous struct for the internal union here.
-    class Overlapped < FFI::Struct
-      layout(
-        :Internal, :uintptr_t,
-        :InternalHigh, :uintptr_t,
-        :Offset, :ulong,
-        :OffsetHigh, :ulong,
-        :hEvent, :uintptr_t
-      )
-    end
-
-    # dwOemId is deprecated. Just assume the nested struct.
-    class SystemInfo < FFI::Struct
-      layout(
-        :wProcessorArchitecture, :ushort,
-        :wReserved, :ushort,
-        :dwPageSize, :ulong,
-        :lpMinimumApplicationAddress, :pointer,
-        :lpMaximumApplicationAddress, :pointer,
-        :dwActiveProcessorMask, :pointer,
-        :dwNumberOfProcessors, :ulong,
-        :dwProcessorType, :ulong,
-        :dwAllocationGranularity, :ulong,
-        :wProcessorLevel, :ushort,
-        :wProcessorRevision, :ushort
-      )
-    end
-
-    class FileSegmentElement < FFI::Union
-      layout(:Buffer, :pointer, :Alignment, :uint64)
-    end
-  end
-end