win32-nio 0.0.2 → 0.0.3

data/CHANGES

@@ -1,7 +1,13 @@
+== 0.0.3 - 24-Apr-2010
+* Removed inline gem building from the gemspec. That's now handled by a
+  Rakefile task.
+* Rafactored the Rakefile, removed an old install task and added new
+  gem tasks.
+
 == 0.0.2 - 6-Aug-2009
 * License changed to Artistic 2.0.
 * Some gemspec updates, including adding win32-event as a dependency and
   test-unit as a development dependency.
 
 == 0.0.1 - 28-Nov-2008
-* Initial release
+* Initial release

data/README

@@ -2,69 +2,72 @@
    Native IO for Windows. This class matches and extends the current Ruby
    IO class API, using native Windows functions underneath the hood.
 
+= Installation
+  gem install win32-nio
+
 = Synopsis
-   require 'win32/nio'
-   include Win32
+  require 'win32/nio'
+  include Win32
    
-   p NIO.read('some_file.text')
+  p NIO.read('some_file.text')
    
-   p NIO.readlines('some_file.txt')
+  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.
+  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 win32-api), which means
-   it isn't optimized for speed.
+  In addition, it is currently using pure Ruby (via win32-api), which means
+  it isn't optimized for speed.
 
 = 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 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:
                          
                           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)
+  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.
+  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 http://www.rubyforge.net/projects/win32utils
+  None that I know of. Please log any other bug reports on the RubyForge
+  project page at http://www.rubyforge.net/projects/win32utils
 
 = 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.
+  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
+  Artistic 2.0
     
 = Copyright
-   (C) 2008-2009 Daniel J. Berger, All Rights Reserved
+  (C) 2008-2010 Daniel J. Berger, All Rights Reserved
     
 = Warranty
-   This package is provided "as is" and without any express or
-   implied warranties, including, without limitation, the implied
-   warranties of merchantability and fitness for a particular purpose.
+  This package is provided "as is" and without any express or
+  implied warranties, including, without limitation, the implied
+  warranties of merchantability and fitness for a particular purpose.
 
 = Author(s)
-   Daniel Berger
-   Park Heesob
+  Daniel Berger
+  Park Heesob
    

data/Rakefile

@@ -3,21 +3,31 @@ require 'rake/testtask'
 require 'rbconfig'
 include Config
 
-desc 'Install the win32-nio library (non-gem)'
-task :install do
-   sitelibdir = CONFIG['sitelibdir']
-   installdir = File.join(sitelibdir, 'win32')
-   file = 'lib\win32\nio.rb'
+namespace 'gem' do
+  desc 'Remove any .gem files from the project.'
+  task :clean do
+    Dir['*.gem'].each{ |f| File.delete(f) }
+  end
 
-   Dir.mkdir(installdir) unless File.exists?(installdir)
-   FileUtils.cp(file, installdir, :verbose => true)
+  desc 'Create the win32-nio gem'
+  task :create => [:clean] do
+    spec = eval(IO.read('win32-nio.gemspec'))
+    Gem::Builder.new(spec).build
+  end
+
+  desc 'Install the win32-nio gem'
+  task :install => [:create] do
+    file = Dir['*.gem'].first
+    sh "gem install #{file}"
+  end
 end
 
 desc 'Run the benchmark suite'
 task :bench do
-   sh "ruby -Ilib benchmarks/win32_nio_benchmarks.rb"
+  sh "ruby -Ilib benchmarks/win32_nio_benchmarks.rb"
+end
 
 Rake::TestTask.new do |t|
-   t.verbose = true
-   t.warning = true
+  t.verbose = true
+  t.warning = true
 end

data/lib/win32/nio.rb

@@ -13,206 +13,225 @@ require 'win32/event'
 # 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::File
-      include Windows::Handle
-      include Windows::Error
-      include Windows::Synchronize
-      include Windows::MSVCRT::IO
-      include Windows::MSVCRT::Buffer
-      include Windows::SystemInfo
-      include Windows::Memory      
-      include Windows::NIO
-      include Windows::Thread
-
-      extend Windows::File
-      extend Windows::Handle
-      extend Windows::Error
-      extend Windows::Synchronize
-      extend Windows::MSVCRT::IO
-      extend Windows::MSVCRT::Buffer
-      extend Windows::SystemInfo
-      extend Windows::Memory      
-      extend Windows::NIO
-      extend Windows::Thread
+  # The NIO class encapsulates the native IO methods for MS Windows.
+  class NIO
+    include Windows::File
+    include Windows::Handle
+    include Windows::Error
+    include Windows::Synchronize
+    include Windows::MSVCRT::IO
+    include Windows::MSVCRT::Buffer
+    include Windows::SystemInfo
+    include Windows::Memory      
+    include Windows::NIO
+    include Windows::Thread
+
+    extend Windows::File
+    extend Windows::Handle
+    extend Windows::Error
+    extend Windows::Synchronize
+    extend Windows::MSVCRT::IO
+    extend Windows::MSVCRT::Buffer
+    extend Windows::SystemInfo
+    extend Windows::Memory      
+    extend Windows::NIO
+    extend Windows::Thread
       
-      # The version of the win32-nio library
-      VERSION = '0.0.2'
-
-      # Error typically raised if any of the native functions fail.
-      class Error < StandardError; end
-
-      # This method is similar to Ruby's IO.read method except that, in
-      # addition to using native function calls, accepts an optional +event+
-      # argument for the fourth argument, which must be an instance of
-      # Win32::Event (if provided). The event is automatically set to a
-      # signaled state when the read operation completes.
-      #   
-      # If a block is provided, then it is treated as a callback that fires
-      # when the read operation is complete.
-      #
-      def self.read(port_name, length=nil, offset=0, event=nil, &block)
-         if length
-            raise TypeError unless length.is_a?(Fixnum)
-            raise ArgumentError if length < 0
-         end
-
-         if offset
-            raise TypeError unless offset.is_a?(Fixnum)
-            raise ArgumentError if offset < 0
-         end
-
-         if event
-            raise TypeError unless event.is_a?(Win32::Event)
-         end
-
-         flags = FILE_FLAG_SEQUENTIAL_SCAN 
-
-         overlapped = 0.chr * 20  # sizeof(OVERLAPPED)
-         overlapped[8,4] = [offset].pack('L') # OVERLAPPED.Offset
-
-         if offset > 0 || event
-            flags |= FILE_FLAG_OVERLAPPED
-            overlapped[16,4] = [event.handle].pack('L') if event
-         end
-
-         handle = CreateFile(
-            port_name,
-            FILE_READ_DATA,
-            FILE_SHARE_READ,
-            0,
-            OPEN_EXISTING,
-            flags,
-            0
-         )
-
-         if handle == INVALID_HANDLE_VALUE
-            raise Error, get_last_error
-         end
+    # The version of the win32-nio library
+    VERSION = '0.0.2'
+
+    # Error typically raised if any of the native functions fail.
+    class Error < StandardError; end
+
+    # This method is similar to Ruby's IO.read method except that, in
+    # addition to using native function calls, it accepts an optional +event+
+    # argument for the fourth argument, which must be an instance of
+    # Win32::Event (if provided). The event is automatically set to a
+    # signaled state when the read operation completes.
+    #   
+    # If a block is provided, then it is treated as a callback that fires
+    # when the read operation is complete.
+    #
+    # 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)
+    #
+    # # Read 25 bytes, starting at offset 5, and print "Done!" when finished.
+    # Win32::NIO.read(file, 25, 5){ puts "Done!" }
+    #
+    # # Attach an event that fires when finished.
+    # require 'win32/event'
+    # event = Win32::Event.new{ puts "Finished!" }
+    # Win32::NIO.read(file, nil, nil, event)
+    #
+    def self.read(port_name, length=nil, offset=0, event=nil, &block)
+      if length
+        raise TypeError unless length.is_a?(Fixnum)
+        raise ArgumentError if length < 0
+      end
+
+      if offset
+        raise TypeError unless offset.is_a?(Fixnum)
+        raise ArgumentError if offset < 0
+      end
+
+      if event
+        raise TypeError unless event.is_a?(Win32::Event)
+      end
+
+      flags = FILE_FLAG_SEQUENTIAL_SCAN 
+
+      overlapped = 0.chr * 20  # sizeof(OVERLAPPED)
+      overlapped[8,4] = [offset].pack('L') # OVERLAPPED.Offset
+
+      if offset > 0 || event
+        flags |= FILE_FLAG_OVERLAPPED
+        overlapped[16,4] = [event.handle].pack('L') if event
+      end
+
+      handle = CreateFile(
+        port_name,
+        FILE_READ_DATA,
+        FILE_SHARE_READ,
+        0,
+        OPEN_EXISTING,
+        flags,
+        0
+      )
+
+      if handle == INVALID_HANDLE_VALUE
+        raise Error, get_last_error
+      end
          
-         # Ruby's File.size is broken, so we implement it here. Also, if an
-         # offset is provided, we can reduce the size to only what we need.
-         if length.nil?
-            size = [0].pack('Q')
-            GetFileSizeEx(handle, size)
-            length = size.unpack('Q').first
-            length -= offset if offset
-         end
-
-         buf = 0.chr * length
-
-         begin
-            if block_given?
-               callback = Win32::API::Callback.new('LLP', 'V'){ block.call }
-               bool = ReadFileEx(handle, buf, length, overlapped, callback)
-            else
-               bytes = [0].pack('L')
-               bool = ReadFile(handle, buf, length, bytes, overlapped)
-            end
+      # Ruby's File.size is broken, so we implement it here. Also, if an
+      # offset is provided, we can reduce the size to only what we need.
+      if length.nil?
+        size = [0].pack('Q')
+        GetFileSizeEx(handle, size)
+        length = size.unpack('Q').first
+        length -= offset if offset
+      end
+
+      buf = 0.chr * length
+
+      begin
+        if block_given?
+          callback = Win32::API::Callback.new('LLP', 'V'){ block.call }
+          bool = ReadFileEx(handle, buf, length, overlapped, callback)
+        else
+          bytes = [0].pack('L')
+          bool = ReadFile(handle, buf, length, bytes, overlapped)
+        end
             
-            errno = GetLastError()
+        errno = GetLastError()
 
-            SleepEx(1, true) # Must be in alertable wait state
+        SleepEx(1, true) # Must be in alertable wait state
          
-            unless bool
-               if errno = ERROR_IO_PENDING
-                  unless GetOverlappedResult(handle, overlapped, bytes, true)
-                     raise Error, get_last_error
-                  end
-               else
-                  raise Error, errno
-               end
+        unless bool
+          if errno = ERROR_IO_PENDING
+            unless GetOverlappedResult(handle, overlapped, bytes, true)
+              raise Error, get_last_error
             end
+          else
+            raise Error, errno
+          end
+        end
             
-            event.wait if event
-         ensure
-            CloseHandle(handle)
-         end
-         
-         buf[0, length]
+        event.wait if event
+      ensure
+        CloseHandle(handle)
       end
-
-      # 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")
-         handle = CreateFile(
-            file,
-            GENERIC_READ,
-            FILE_SHARE_READ,
-            nil,
-            OPEN_EXISTING,
-            FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
-            nil
-         )
          
-         if handle == INVALID_HANDLE_VALUE
-            raise Error, get_last_error
-         end
+      buf[0, length]
+    end
+
+    # 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")
+      handle = CreateFile(
+        file,
+        GENERIC_READ,
+        FILE_SHARE_READ,
+        nil,
+        OPEN_EXISTING,
+        FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
+        nil
+      )
          
-         sysbuf = 0.chr * 40
-         GetSystemInfo(sysbuf)
+      if handle == INVALID_HANDLE_VALUE
+        raise Error, get_last_error
+      end
+         
+      sysbuf = 0.chr * 40
+      GetSystemInfo(sysbuf)
 
-         file_size = [0].pack('Q')
-         GetFileSizeEx(handle, file_size)
-         file_size = file_size.unpack('Q')[0]
+      file_size = [0].pack('Q')
+      GetFileSizeEx(handle, file_size)
+      file_size = file_size.unpack('Q')[0]
 
-         page_size = sysbuf[4,4].unpack('L')[0] # dwPageSize
-         page_num  = (file_size.to_f / page_size).ceil
+      page_size = sysbuf[4,4].unpack('L')[0] # dwPageSize
+      page_num  = (file_size.to_f / page_size).ceil
          
-         begin
-            base_address = VirtualAlloc(
-               nil,
-               page_size * page_num,
-               MEM_COMMIT,
-               PAGE_READWRITE
-            )
+      begin
+        base_address = VirtualAlloc(
+          nil,
+          page_size * page_num,
+          MEM_COMMIT,
+          PAGE_READWRITE
+        )
                
-            buf_list = []
+        buf_list = []
             
-            for i in 0...page_num
-               buf_list.push(base_address + page_size * i)
-            end
+        for i in 0...page_num
+          buf_list.push(base_address + page_size * i)
+        end
                   
-            seg_array  = buf_list.pack('Q*') + 0.chr * 8
-            overlapped = 0.chr * 20
+        seg_array  = buf_list.pack('Q*') + 0.chr * 8
+        overlapped = 0.chr * 20
                   
-            bool = ReadFileScatter(
-               handle,
-               seg_array,
-               page_size * page_num, 
-               nil,
-               overlapped
-            )
-
-            unless bool
-               error = GetLastError()
-               if error != ERROR_IO_PENDING
-                  raise Error, get_last_error(error)
-               end
-            end
-
-            SleepEx(1, true) unless HasOverlappedIoCompleted(overlapped)
-
-            buffer = 0.chr * file_size
-            memcpy(buffer, buf_list[0], file_size)
-         ensure
-            CloseHandle(handle)
-            VirtualFree(base_address, 0, MEM_RELEASE)
-         end
-
-         if sep == ""
-            buffer = buffer.split(/(\r\n){2,}/)
-            buffer.delete("\r\n")
-         else
-            buffer = buffer.split(sep)
-         end
+        bool = ReadFileScatter(
+          handle,
+          seg_array,
+          page_size * page_num, 
+          nil,
+          overlapped
+        )
+
+        unless bool
+          error = GetLastError()
+          if error != ERROR_IO_PENDING
+            raise Error, get_last_error(error)
+          end
+        end
+
+        SleepEx(1, true) unless HasOverlappedIoCompleted(overlapped)
+
+        buffer = 0.chr * file_size
+        memcpy(buffer, buf_list[0], file_size)
+      ensure
+        CloseHandle(handle)
+        VirtualFree(base_address, 0, MEM_RELEASE)
+      end
 
-         buffer
+      if sep == ""
+        buffer = buffer.split(/(\r\n){2,}/)
+        buffer.delete("\r\n")
+      else
+        buffer = buffer.split(sep)
       end
-   end
+
+      buffer
+    end
+  end
 end

data/win32-nio.gemspec

@@ -1,30 +1,28 @@
 require 'rubygems'
 
-spec = Gem::Specification.new do |gem|
-   gem.name     = 'win32-nio'
-   gem.version  = '0.0.2'
-   gem.author   = 'Daniel J. Berger'
-   gem.license  = 'Artistic 2.0'
-   gem.email    = 'djberg96@gmail.com'
-   gem.homepage = 'http://www.rubyforge.org/projects/win32utils'
-   gem.platform = Gem::Platform::RUBY
-   gem.summary  = 'Native IO for MS Windows'
-   gem.has_rdoc = true
-   gem.files    = Dir['**/*'].reject{ |f| f.include?('CVS') }
+Gem::Specification.new do |spec|
+  spec.name     = 'win32-nio'
+  spec.version  = '0.0.3'
+  spec.author   = 'Daniel J. Berger'
+  spec.license  = 'Artistic 2.0'
+  spec.email    = 'djberg96@gmail.com'
+  spec.homepage = 'http://www.rubyforge.org/projects/win32utils'
+  spec.platform = Gem::Platform::RUBY
+  spec.summary  = 'Native IO for MS Windows'
+  spec.has_rdoc = true
+  spec.files    = Dir['**/*'].reject{ |f| f.include?('git') }
 
-   gem.rubyforge_project = 'Win32Utils'
-   gem.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
+  spec.rubyforge_project = 'Win32Utils'
+  spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
 
-   gem.description = <<-EOF
-      The win32-nio library implements certain IO methods using native
-      Windows function calls rather than using the POSIX compatibility
-      layer that MRI typically uses. In addition, some methods provide
-      additional event handling capability.
-   EOF
+  spec.description = <<-EOF
+    The win32-nio library implements certain IO methods using native
+    Windows function calls rather than using the POSIX compatibility
+    layer that MRI typically uses. In addition, some methods provide
+    additional event handling capability.
+  EOF
 
-   gem.add_dependency('windows-pr', '>= 0.9.5')
-   gem.add_dependency('win32-event', '>= 0.5.0')
-   gem.add_development_dependency('test-unit', '>= 2.0.3')
+  spec.add_dependency('windows-pr', '>= 0.9.5')
+  spec.add_dependency('win32-event', '>= 0.5.0')
+  spec.add_development_dependency('test-unit', '>= 2.0.3')
 end
-
-Gem::Builder.new(spec).build

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: win32-nio
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Daniel J. Berger
@@ -9,40 +14,52 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-06 00:00:00 -06:00
+date: 2010-04-24 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: windows-pr
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 5
         version: 0.9.5
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: win32-event
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 0
         version: 0.5.0
-    version: 
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: test-unit
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 3
         version: 2.0.3
-    version: 
-description: "      The win32-nio library implements certain IO methods using native\n      Windows function calls rather than using the POSIX compatibility\n      layer that MRI typically uses. In addition, some methods provide\n      additional event handling capability.\n"
+  type: :development
+  version_requirements: *id003
+description: "    The win32-nio library implements certain IO methods using native\n    Windows function calls rather than using the POSIX compatibility\n    layer that MRI typically uses. In addition, some methods provide\n    additional event handling capability.\n"
 email: djberg96@gmail.com
 executables: []
 
@@ -75,18 +92,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: Win32Utils
-rubygems_version: 1.3.4
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Native IO for MS Windows