win32-event 0.5.1 → 0.5.2

data/CHANGES

@@ -1,3 +1,9 @@
+== 0.5.2 - 21-Apr-2010
+* Updated the gemspec, adding some gem building tasks, and removed the
+  inline gem building code from the gemspec itself.
+* Added test-unit 2 as a development dependency and made some minor
+  updates to the test suite.
+
 == 0.5.1 - 6-Aug-2009
 * License changed to Artistic 2.0.
 * Some gemspec updates, including the addition of a license and an update

data/README

@@ -1,52 +1,51 @@
 == Description
-   Interface to MS Windows Event objects.
+  Interface to MS Windows Event objects.
 
 == Prerequsites
-   Requires the win32-ipc package.
+  Requires the win32-ipc library.
    
 == Installation
-   rake test (optional)
-   rake install
+  gem install win32-event
 
 == Synopsis
-   Win32::Event.new("Foo") do |event|
-      event.set
-      # Do stuff
-      event.reset
-   end
+  Win32::Event.new("Foo") do |event|
+    event.set
+    # Do stuff
+    event.reset
+  end
 
-   e2 = Win32::Event.open("Bar")
-   # Do stuff
-   e2.close
+  e2 = Win32::Event.open("Bar")
+  # Do stuff
+  e2.close
 
 == Documentation
-   The event.rb file contains inline RDoc documentation. If you installed
-   this file as a gem, then you have the docs.
+  The event.rb file contains inline RDoc documentation. If you installed
+  this file as a gem, then you have the docs.
 
 == Notes
-   The Event class is a subclass of Win32::Ipc (win32-ipc). This package
-   require's the win32-ipc package internally (you don't need to explicitly
-   call it).
+  The Event class is a subclass of Win32::Ipc (win32-ipc). This library
+  require's the win32-ipc library internally (you don't need to explicitly
+  call it).
 
-   A PulseEvent() wrapper is intentionally omitted.  From the MSDN web site:
-   "This function is unreliable and should not be used. It exists mainly for
-   backward compatibility."
+  A PulseEvent() wrapper is intentionally omitted. From the MSDN web site:
+  "This function is unreliable and should not be used. It exists mainly for
+  backward compatibility."
 
 == Acknowledgements
-   The Win32::Event Perl module by Chris Madsen was used as a general
-   guideline for developing the API.
+  The Win32::Event Perl module by Chris Madsen was used as a general
+  guideline for developing the API.
     
 == Known Bugs
-   None that I'm aware of. Please submit any bug reports to the project page
-   at http://www.rubyforge.org/projects/win32utils.
+  None that I'm aware of. Please submit any bug reports to the project page
+  at http://www.rubyforge.org/projects/win32utils.
 
 == Copyright
-   (C) 2003-2007 Daniel J. Berger
-   All Rights Reserved
+  (C) 2003-2010 Daniel J. Berger
+  All Rights Reserved
 
 == License
-   Ruby's
+  Artistic 2.0
 
 == Author
-   Park Heesob
-   Daniel J. Berger
+  Park Heesob
+  Daniel J. Berger

data/Rakefile

@@ -3,17 +3,26 @@ require 'rake/testtask'
 require 'rbconfig'
 include Config
 
-desc 'Install the win32-event package (non-gem)'
-task :install do
-   sitelibdir = CONFIG['sitelibdir']
-   installdir = File.join(sitelibdir, 'win32')
-   file = 'lib\win32\event.rb'
+namespace 'gem' do
+  desc 'Remove existing .gem file from the current directory'
+  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-event gem'
+  task :create do
+    spec = eval(IO.read('win32-event.gemspec'))
+    Gem::Builder.new(spec).build
+  end
+
+  desc 'Install the win32-event gem'
+  task :install => [:clean, :create] do
+    file = Dir['*.gem'].first
+    sh "gem install #{file}"
+  end
 end
 
 Rake::TestTask.new do |t|
-   t.verbose = true
-   t.warning = true
+  t.verbose = true
+  t.warning = true
 end

data/lib/win32/event.rb

@@ -3,163 +3,163 @@ require 'win32/ipc'
 # The Win32 module serves as a namespace only.
 module Win32
 
-   # The Event class encapsulates Windows event objects.
-   class Event < Ipc
+  # The Event class encapsulates Windows event objects.
+  class Event < Ipc
    
-      # This is the error raised if any of the Event methods fail.
-      class Error < StandardError; end
+    # This is the error raised if any of the Event methods fail.
+    class Error < StandardError; end
       
-      extend Windows::Synchronize
-      extend Windows::Error
-      extend Windows::Handle
+    extend Windows::Synchronize
+    extend Windows::Error
+    extend Windows::Handle
       
-      # The version of the win32-event library
-      VERSION = '0.5.1'
+    # The version of the win32-event library
+    VERSION = '0.5.2'
    
-      # The name of the Event object.
-      #
-      attr_reader :name
+    # The name of the Event object.
+    #
+    attr_reader :name
       
-      # Indicates whether or not the Event requires use of the ResetEvent()
-      # function set the state to nonsignaled.
-      #
-      attr_reader :manual_reset
+    # Indicates whether or not the Event requires use of the ResetEvent()
+    # function set the state to nonsignaled.
+    #
+    attr_reader :manual_reset
       
-      # The initial state of the Event object. If true, the initial state
-      # is signaled. Otherwise, it is non-signaled.
-      #
-      attr_reader :initial_state
+    # The initial state of the Event object. If true, the initial state
+    # is signaled. Otherwise, it is non-signaled.
+    #
+    attr_reader :initial_state
       
-      # Creates and returns new Event object.  If +name+ is omitted, the
-      # Event object is created without a name, i.e. it's anonymous.
-      #
-      # If +name+ is provided and it already exists, then it is opened
-      # instead and the +manual_reset+ and +initial_state+ parameters are
-      # ignored.
-      #
-      # If the +man_reset+ parameter is set to +true+, then it creates an Event
-      # object which requires use of the Event#reset method in order to set the
-      # state to non-signaled. If this parameter is false (the default) then
-      # the system automatically resets the state to non-signaled after a
-      # single waiting thread has been released.
-      #
-      # If the +init_state+ parameter is +true+, the initial state of the
-      # Event object is signaled; otherwise, it is nonsignaled (the default).
-      #
-      # If the +inherit+ parameter is true, then processes created by this
-      # process will inherit the handle. Otherwise they will not.
-      # 
-      # In block form this will automatically close the Event object at the
-      # end of the block.
-      # 
-      def initialize(name=nil, man_reset=false, init_state=false, inherit=true)
-         @name          = name
-         @manual_reset  = man_reset
-         @initial_state = init_state
-         @inherit       = inherit
+    # Creates and returns new Event object.  If +name+ is omitted, the
+    # Event object is created without a name, i.e. it's anonymous.
+    #
+    # If +name+ is provided and it already exists, then it is opened
+    # instead and the +manual_reset+ and +initial_state+ parameters are
+    # ignored.
+    #
+    # If the +man_reset+ parameter is set to +true+, then it creates an Event
+    # object which requires use of the Event#reset method in order to set the
+    # state to non-signaled. If this parameter is false (the default) then
+    # the system automatically resets the state to non-signaled after a
+    # single waiting thread has been released.
+    #
+    # If the +init_state+ parameter is +true+, the initial state of the
+    # Event object is signaled; otherwise, it is nonsignaled (the default).
+    #
+    # If the +inherit+ parameter is true, then processes created by this
+    # process will inherit the handle. Otherwise they will not.
+    # 
+    # In block form this will automatically close the Event object at the
+    # end of the block.
+    # 
+    def initialize(name=nil, man_reset=false, init_state=false, inherit=true)
+      @name          = name
+      @manual_reset  = man_reset
+      @initial_state = init_state
+      @inherit       = inherit
          
-         manual_reset  = man_reset ? 1 : 0
-         initial_state = init_state ? 1 : 0
+      manual_reset  = man_reset ? 1 : 0
+      initial_state = init_state ? 1 : 0
          
-         # Used to prevent potential segfaults.
-         if name && !name.is_a?(String)
-            raise TypeError, 'name must be a string'
-         end
+      # Used to prevent potential segfaults.
+      if name && !name.is_a?(String)
+        raise TypeError, 'name must be a string'
+      end
 
-         if inherit
-            sec = 0.chr * 12 # sizeof(SECURITY_ATTRIBUTES)
-            sec[0,4] = [12].pack('L')
-            sec[8,4] = [1].pack('L') # 1 == TRUE
-         else
-            sec = 0
-         end
+      if inherit
+        sec = 0.chr * 12 # sizeof(SECURITY_ATTRIBUTES)
+        sec[0,4] = [12].pack('L')
+        sec[8,4] = [1].pack('L') # 1 == TRUE
+      else
+        sec = 0
+      end
          
-         handle = CreateEvent(sec, manual_reset, initial_state, name)
+      handle = CreateEvent(sec, manual_reset, initial_state, name)
          
-         if handle == 0 || handle == INVALID_HANDLE_VALUE
-            raise Error, get_last_error
-         end
+      if handle == 0 || handle == INVALID_HANDLE_VALUE
+        raise Error, get_last_error
+      end
  
-         super(handle)
+      super(handle)
          
-         if block_given?
-            begin
-               yield self
-            ensure
-               close
-            end
-         end
+      if block_given?
+        begin
+          yield self
+        ensure
+          close
+        end
       end
+    end
       
-      # Open an existing Event by +name+. The +inherit+ argument sets whether
-      # or not the object was opened such that a process created by the
-      # CreateProcess() function (a Windows API function) can inherit the
-      # handle. The default is true.
-      #
-      # This method is essentially identical to Event.new, except that the
-      # options for manual_reset and initial_state cannot be set (since they
-      # are already set). Also, this method will raise an Event::Error if the
-      # event doesn't already exist.
-      #
-      # If you want "open or create" semantics, then use Event.new.
-      #
-      def self.open(name, inherit=true, &block)
-         if name && !name.is_a?(String)
-            raise TypeError, 'name must be a string'
-         end
+    # Open an existing Event by +name+. The +inherit+ argument sets whether
+    # or not the object was opened such that a process created by the
+    # CreateProcess() function (a Windows API function) can inherit the
+    # handle. The default is true.
+    #
+    # This method is essentially identical to Event.new, except that the
+    # options for manual_reset and initial_state cannot be set (since they
+    # are already set). Also, this method will raise an Event::Error if the
+    # event doesn't already exist.
+    #
+    # If you want "open or create" semantics, then use Event.new.
+    #
+    def self.open(name, inherit=true, &block)
+      if name && !name.is_a?(String)
+        raise TypeError, 'name must be a string'
+      end
          
-         bool = inherit ? 1 : 0
+      bool = inherit ? 1 : 0
 
-         # This block of code is here strictly to force an error if the user
-         # tries to open an event that doesn't already exist.
-         begin
-            handle = OpenEvent(EVENT_ALL_ACCESS, bool, name)
+      # This block of code is here strictly to force an error if the user
+      # tries to open an event that doesn't already exist.
+      begin
+        handle = OpenEvent(EVENT_ALL_ACCESS, bool, name)
 
-            if handle == 0 || handle == INVALID_HANDLE_VALUE
-               raise Error, get_last_error
-            end
-         ensure
-            CloseHandle(handle) if handle > 0
-         end
-
-         self.new(name, false, false, inherit, &block)
+        if handle == 0 || handle == INVALID_HANDLE_VALUE
+          raise Error, get_last_error
+        end
+      ensure
+        CloseHandle(handle) if handle > 0
       end
+
+      self.new(name, false, false, inherit, &block)
+    end
       
-      # Returns whether or not the object was opened such that a process
-      # created by the CreateProcess() function (a Windows API function) can
-      # inherit the handle. The default is true.
-      #
-      def inheritable?
-         @inherit
-      end
+    # Returns whether or not the object was opened such that a process
+    # created by the CreateProcess() function (a Windows API function) can
+    # inherit the handle. The default is true.
+    #
+    def inheritable?
+      @inherit
+    end
       
-      # Sets the Event object to a non-signaled state.
-      # 
-      def reset
-         unless ResetEvent(@handle)
-            raise Error, get_last_error
-         end
-         @signaled = false
+    # Sets the Event object to a non-signaled state.
+    # 
+    def reset
+      unless ResetEvent(@handle)
+        raise Error, get_last_error
       end
+      @signaled = false
+    end
       
-      # Sets the Event object to a signaled state.
-      # 
-      def set
-         unless SetEvent(@handle)
-            raise Error, get_last_error
-         end
-         @signaled = true
+    # Sets the Event object to a signaled state.
+    # 
+    def set
+      unless SetEvent(@handle)
+        raise Error, get_last_error
       end
+      @signaled = true
+    end
       
-      # Synonym for Event#reset if +bool+ is false, or Event#set
-      # if +bool+ is true.
-      # 
-      def signaled=(bool)
-         if bool
-            set
-         else
-            reset
-         end
-      end 
-   end
+    # Synonym for Event#reset if +bool+ is false, or Event#set
+    # if +bool+ is true.
+    # 
+    def signaled=(bool)
+      if bool
+        set
+      else
+        reset
+      end
+    end 
+  end
 end

data/test/test_win32_event.rb

@@ -4,118 +4,121 @@
 # Test suite for the win32-event library. This test should be run
 # via the 'rake test' task.
 #####################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'win32/event'
 include Win32
 
 class TC_Win32Event < Test::Unit::TestCase
-   def setup
-      @event1 = Event.new
-      @event2 = Event.new("Foo")
-      @event3 = Event.new("Bar", true)
-      @event4 = Event.new("Baz", true, true)
-      @uni_event = Event.new("Ηελλας")
-   end
+  def setup
+    @event1 = Event.new
+    @event2 = Event.new("Foo")
+    @event3 = Event.new("Bar", true)
+    @event4 = Event.new("Baz", true, true)
+    @uni_event = Event.new("Ηελλας")
+  end
    
-   def test_version
-      assert_equal('0.5.1', Event::VERSION)
-   end
+  def test_version
+    assert_equal('0.5.2', Event::VERSION)
+  end
   
-   def test_constructor_errors
-      assert_raises(ArgumentError){ Event.new("Foo", true, false, true, 1) }
-      assert_raises(TypeError){ Event.new(1) }
-   end
+  def test_constructor_errors
+    assert_raises(ArgumentError){ Event.new("Foo", true, false, true, 1) }
+    assert_raises(TypeError){ Event.new(1) }
+  end
    
-   def test_open
-      assert_respond_to(Event, :open)
-      assert_nothing_raised{ Event.open("Bar"){} }
-      assert_nothing_raised{ Event.open("Ηελλας"){} }
-      assert_nothing_raised{ Event.open("Bar", false) }
+  def test_open
+    assert_respond_to(Event, :open)
+    assert_nothing_raised{ Event.open("Bar"){} }
+    assert_nothing_raised{ Event.open("Ηελλας"){} }
+    assert_nothing_raised{ Event.open("Bar", false) }
+  end
       
-      assert_raises(ArgumentError){ Event.open("Bar", true, false){} }
-      assert_raises(Event::Error){ Event.open("Blah"){} }
-      assert_raises(TypeError){ Event.open(1){} }
-   end
+  def test_open_expected_errors
+    assert_raises(ArgumentError){ Event.open("Bar", true, false){} }
+    assert_raises(Event::Error){ Event.open("Blah"){} }
+    assert_raises(TypeError){ Event.open(1){} }
+  end
    
-   def test_inheritable
-      @event1 = Event.open("Foo")
-      @event2 = Event.open("Baz", false)
-      
-      assert_respond_to(@event1, :inheritable?)
-      assert_nothing_raised{ @event1.inheritable? }
+  def test_inheritable
+    @event1 = Event.open("Foo")
+    @event2 = Event.open("Baz", false)
       
-      assert_equal(true, @event1.inheritable?)
-      assert_equal(false, @event2.inheritable?)
-   end
+    assert_respond_to(@event1, :inheritable?)
+    assert_nothing_raised{ @event1.inheritable? }
+    assert_true(@event1.inheritable?)
+    assert_false(@event2.inheritable?)
+  end
    
-   def test_name
-      assert_respond_to(@event1, :name)
-      assert_nothing_raised{ @event1.name }
-      assert_nothing_raised{ @uni_event.name }
-      
-      assert_nil(@event1.name)
-      assert_kind_of(String, @event2.name)
-   end
+  def test_name
+    assert_respond_to(@event1, :name)
+    assert_nothing_raised{ @event1.name }
+    assert_nothing_raised{ @uni_event.name }
+    assert_nil(@event1.name)
+    assert_kind_of(String, @event2.name)
+  end
    
-   def test_initial_state
-      assert_respond_to(@event1, :initial_state)
-      assert_nothing_raised{ @event1.initial_state }
+  def test_initial_state
+    assert_respond_to(@event1, :initial_state)
+    assert_nothing_raised{ @event1.initial_state }
       
-      assert_equal(false, @event1.initial_state)
-      assert_equal(false, @event2.initial_state)
-      assert_equal(false, @event3.initial_state)
-      assert_equal(true, @event4.initial_state)
-   end
+    assert_false(@event1.initial_state)
+    assert_false(@event2.initial_state)
+    assert_false(@event3.initial_state)
+    assert_true(@event4.initial_state)
+  end
    
-   def test_manual_reset
-      assert_respond_to(@event1, :manual_reset)
-      assert_nothing_raised{ @event1.manual_reset }
+  def test_manual_reset
+    assert_respond_to(@event1, :manual_reset)
+    assert_nothing_raised{ @event1.manual_reset }
       
-      assert_equal(false, @event1.manual_reset)
-      assert_equal(false, @event2.manual_reset)
-      assert_equal(true, @event3.manual_reset)
-      assert_equal(true, @event4.manual_reset)
-   end
+    assert_false(@event1.manual_reset)
+    assert_false(@event2.manual_reset)
+    assert_true(@event3.manual_reset)
+    assert_true(@event4.manual_reset)
+  end
    
-   def test_set
-      assert_respond_to(@event1, :set)
-      assert_nothing_raised{ @event1.set }
-   end
+  def test_set
+    assert_respond_to(@event1, :set)
+    assert_nothing_raised{ @event1.set }
+  end
    
-   def test_is_signaled
-      event = Event.new
-      assert_respond_to(event, :signaled?)
-      assert_nothing_raised{ event.signaled? }
-      
-      assert_equal(false, event.signaled?)
-      event.set
-      assert_equal(true, event.signaled?)
-      event.reset
-      assert_equal(false, event.signaled?)
-   end
+  def test_is_signaled
+    event = Event.new
+    assert_respond_to(event, :signaled?)
+    assert_nothing_raised{ event.signaled? }
+     
+    assert_false(event.signaled?)
+    event.set
+    assert_true(event.signaled?)
+    event.reset
+    assert_false(event.signaled?)
+  end
    
-   def test_reset
-      assert_respond_to(@event1, :reset)
-      assert_nothing_raised{ @event1.reset }
-   end
+  def test_reset
+    assert_respond_to(@event1, :reset)
+    assert_nothing_raised{ @event1.reset }
+  end
    
-   def test_close
-      event = Event.new
-      assert_respond_to(event, :close)
-      assert_nothing_raised{ event.close }
-   end
+  def test_close
+    event = Event.new
+    assert_respond_to(event, :close)
+    assert_nothing_raised{ event.close }
+  end
    
-   def teardown
-      @event1.close
-      @event2.close
-      @event3.close
-      @event4.close
-      @uni_event.close
+  def teardown
+    @event1.close
+    @event2.close
+    @event3.close
+    @event4.close
+    @uni_event.close
       
-      @event1 = nil
-      @event2 = nil
-      @event3 = nil
-      @event4 = nil
-      @uni_event = nil
-   end
+    @event1 = nil
+    @event2 = nil
+    @event3 = nil
+    @event4 = nil
+    @uni_event = nil
+  end
 end

data/win32-event.gemspec

@@ -1,29 +1,28 @@
 require 'rubygems'
 
-spec = Gem::Specification.new do |gem|
-   gem.name        = 'win32-event'
-   gem.version     = '0.5.1'
-   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     = 'Interface to MS Windows Event objects.'
-   gem.test_file   = 'test/test_win32_event.rb'
-   gem.has_rdoc    = true
-   gem.files       = Dir['**/*'].reject{ |f| f.include?('CVS') }
+Gem::Specification.new do |spec|
+  spec.name      = 'win32-event'
+  spec.version   = '0.5.2'
+  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   = 'Interface to MS Windows Event objects.'
+  spec.test_file = 'test/test_win32_event.rb'
+  spec.has_rdoc  = true
+  spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
 
-   gem.extra_rdoc_files = ['README', 'CHANGES', 'MANIFEST']
-   gem.rubyforge_project = 'win32utils'
+  spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
+  spec.rubyforge_project = 'win32utils'
 
-   gem.add_dependency('win32-ipc', '>= 0.5.0')
+  spec.add_dependency('win32-ipc', '>= 0.5.0')
+  spec.add_development_dependency('test-unit', '>= 2.0.7')
 
-   gem.description = <<-EOF
-      The win32-event library provides an interface to Windows event objects.
-      An event object is a synchronization object whose state can be explicitly
-      set to a signaled state. Event objects are useful in sending a signal to
-      a thread indicating that a particular event has occurred.
-   EOF
+  spec.description = <<-EOF
+    The win32-event library provides an interface to Windows event objects.
+    An event object is a synchronization object whose state can be explicitly
+    set to a signaled state. Event objects are useful in sending a signal to
+    a thread indicating that a particular event has occurred.
+  EOF
 end
-
-Gem::Builder.new(spec).build

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: win32-event
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 2
+  version: 0.5.2
 platform: ruby
 authors: 
 - Daniel J. Berger
@@ -9,20 +14,38 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-06 00:00:00 -06:00
+date: 2010-04-21 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: win32-ipc
-  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
+        - 5
+        - 0
         version: 0.5.0
-    version: 
-description: "      The win32-event library provides an interface to Windows event objects.\n      An event object is a synchronization object whose state can be explicitly\n      set to a signaled state. Event objects are useful in sending a signal to\n      a thread indicating that a particular event has occurred.\n"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 7
+        version: 2.0.7
+  type: :development
+  version_requirements: *id002
+description: "    The win32-event library provides an interface to Windows event objects.\n    An event object is a synchronization object whose state can be explicitly\n    set to a signaled state. Event objects are useful in sending a signal to\n    a thread indicating that a particular event has occurred.\n"
 email: djberg96@gmail.com
 executables: []
 
@@ -53,18 +76,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: Interface to MS Windows Event objects.