win32-event 0.5.2 → 0.6.0

data/CHANGES

@@ -1,3 +1,8 @@
+== 0.6.0 - 9-Jul-2012
+* Converted code to use FFI.
+* Now requires Ruby 1.9 or later.
+* Updated and refactored tests.
+
 == 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.

data/README

@@ -37,10 +37,10 @@
     
 == Known Bugs
   None that I'm aware of. Please submit any bug reports to the project page
-  at http://www.rubyforge.org/projects/win32utils.
+  at https://github.com/djberg96/win32-event.
 
 == Copyright
-  (C) 2003-2010 Daniel J. Berger
+  (C) 2003-2012 Daniel J. Berger
   All Rights Reserved
 
 == License

data/Rakefile

@@ -1,16 +1,12 @@
 require 'rake'
 require 'rake/testtask'
-require 'rbconfig'
-include Config
+require 'rake/clean'
 
-namespace 'gem' do
-  desc 'Remove existing .gem file from the current directory'
-  task :clean do
-    Dir['*.gem'].each{ |f| File.delete(f) }
-  end
+CLEAN.include("**/*.gem", "**/*.rbc")
 
+namespace 'gem' do
   desc 'Create the win32-event gem'
-  task :create do
+  task :create => [:clean] do
     spec = eval(IO.read('win32-event.gemspec'))
     Gem::Builder.new(spec).build
   end
@@ -26,3 +22,5 @@ Rake::TestTask.new do |t|
   t.verbose = true
   t.warning = true
 end
+
+task :default => :test

data/lib/win32/event.rb

@@ -5,31 +5,46 @@ module Win32
 
   # The Event class encapsulates Windows event objects.
   class Event < Ipc
-   
+    ffi_lib :kernel32
+
+    class SecurityAttributes < FFI::Struct
+      layout(
+        :nLength, :ulong,
+        :lpSecurityDescriptor, :pointer,
+        :bInheritHandle, :bool
+      )
+    end
+
+    attach_function :CreateEvent, :CreateEventW, [:pointer, :bool, :bool, :buffer_in], :ulong
+    attach_function :OpenEvent, :OpenEventW, [:ulong, :bool, :buffer_in], :ulong
+    attach_function :SetEvent, [:ulong], :bool
+    attach_function :ResetEvent, [:ulong], :bool
+
+    private_class_method :CreateEvent, :OpenEvent, :SetEvent, :ResetEvent
+
+    INVALID_HANDLE_VALUE = 0xFFFFFFFF
+    EVENT_ALL_ACCESS     = 0x1F0003
+
     # 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
-      
+
     # The version of the win32-event library
-    VERSION = '0.5.2'
-   
-    # The name of the Event object.
+    VERSION = '0.6.0'
+
+    # The name of the Event object. The default is nil
     #
     attr_reader :name
-      
+
     # Indicates whether or not the Event requires use of the ResetEvent()
-    # function set the state to nonsignaled.
+    # function set the state to nonsignaled. The default is false
     #
     attr_reader :manual_reset
-      
+
     # The initial state of the Event object. If true, the initial state
-    # is signaled. Otherwise, it is non-signaled.
+    # is signaled. Otherwise, it is non-signaled. The default is false.
     #
     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.
     #
@@ -48,49 +63,42 @@ module Win32
     #
     # 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
-         
-      # Used to prevent potential segfaults.
-      if name && !name.is_a?(String)
-        raise TypeError, 'name must be a string'
+
+      if name.is_a?(String)
+        if name.encoding.to_s != 'UTF-16LE'
+          name = name + 0.chr
+          name.encode!('UTF-16LE')
+        end
+      else
+        raise TypeError if name
       end
 
       if inherit
-        sec = 0.chr * 12 # sizeof(SECURITY_ATTRIBUTES)
-        sec[0,4] = [12].pack('L')
-        sec[8,4] = [1].pack('L') # 1 == TRUE
+        sec = SecurityAttributes.new
+        sec[:nLength] = SecurityAttributes.size
+        sec[:bInheritHandle] = inherit
       else
-        sec = 0
+        sec = nil
       end
-         
+
       handle = CreateEvent(sec, manual_reset, initial_state, name)
-         
+
       if handle == 0 || handle == INVALID_HANDLE_VALUE
-        raise Error, get_last_error
+        raise SystemCallError.new("CreateEvent", FFI.errno)
       end
- 
+
       super(handle)
-         
-      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
@@ -104,27 +112,30 @@ module Win32
     # 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'
+      raise TypeError unless name.is_a?(String)
+
+      if name.encoding.to_s != 'UTF-16LE'
+        oname = name + 0.chr
+        oname.encode!('UTF-16LE')
+      else
+        oname = name.dup
       end
-         
-      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)
+        h = OpenEvent(EVENT_ALL_ACCESS, inherit, oname)
 
-        if handle == 0 || handle == INVALID_HANDLE_VALUE
-          raise Error, get_last_error
+        if h == 0 || h == INVALID_HANDLE_VALUE
+          raise SystemCallError.new("OpenEvent", FFI.errno)
         end
       ensure
-        CloseHandle(handle) if handle > 0
+        CloseHandle(h) if h
       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.
@@ -132,34 +143,34 @@ module Win32
     def inheritable?
       @inherit
     end
-      
+
     # Sets the Event object to a non-signaled state.
-    # 
+    #
     def reset
       unless ResetEvent(@handle)
-        raise Error, get_last_error
+        raise SystemCallError.new("ResetEvent", FFI.errno)
       end
       @signaled = false
     end
-      
+
     # Sets the Event object to a signaled state.
-    # 
+    #
     def set
       unless SetEvent(@handle)
-        raise Error, get_last_error
+        raise SystemCallError.new("SetEvent", FFI.errno)
       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
   end
 end

data/test/test_win32_event.rb

@@ -1,124 +1,200 @@
+# encoding: UTF-8
 #####################################################################
 # test_win32_event.rb
 #
 # 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 '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 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_open
+    @event   = Event.new
+    @unicode = "Ηελλας"
+    @ascii   = "foo"
+  end
+
+  test "version is set to expected value" do
+    assert_equal('0.6.0', Event::VERSION)
+  end
+
+  test "constructor works with no arguments" do
+    assert_nothing_raised{ @event = Event.new }
+    assert_nil(@event.name)
+  end
+
+  test "constructor accepts an event name" do
+    assert_nothing_raised{ @event = Event.new(@ascii) }
+  end
+
+  test "constructor accepts a unicode event name" do
+    assert_nothing_raised{ @event = Event.new(@unicode) }
+  end
+
+  test "constructor accepts a maximum of four arguments" do
+    assert_raises(ArgumentError){ Event.new('Foo', true, false, true, 1) }
+  end
+
+  test "first argument to constructor must be a string" do
+    assert_raise(TypeError){ Event.new(1) }
+  end
+
+  test "open method basic functionality" do
+    event = Event.new(@ascii)
     assert_respond_to(Event, :open)
-    assert_nothing_raised{ Event.open("Bar"){} }
-    assert_nothing_raised{ Event.open("Ηελλας"){} }
-    assert_nothing_raised{ Event.open("Bar", false) }
-  end
-      
-  def test_open_expected_errors
-    assert_raises(ArgumentError){ Event.open("Bar", true, false){} }
-    assert_raises(Event::Error){ Event.open("Blah"){} }
+    assert_nothing_raised{ @event = Event.open(@ascii) }
+    assert_equal(@ascii, @event.name)
+    event.close
+  end
+
+  test "open method accepts an inherit argument" do
+    event = Event.new(@ascii)
+    assert_nothing_raised{ @event = Event.open(@ascii, false) }
+    assert_false(@event.inheritable?)
+    event.close
+  end
+
+  test "open method works with unicode names" do
+    event = Event.new(@unicode)
+    assert_nothing_raised{ @event = Event.open(@unicode) }
+    assert_equal(@unicode, @event.name)
+    event.close
+  end
+
+  test "open method requires a name" do
+    assert_raise(ArgumentError){ Event.open }
+  end
+
+  test "open method requires a string argument as the first argument" do
     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? }
-    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_initial_state
-    assert_respond_to(@event1, :initial_state)
-    assert_nothing_raised{ @event1.initial_state }
-      
-    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 }
-      
-    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_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_close
-    event = Event.new
-    assert_respond_to(event, :close)
-    assert_nothing_raised{ event.close }
-  end
-   
+
+  test "open accepts a maximum of two arguments" do
+    assert_raise(ArgumentError){ Event.open('bogus', true, false) }
+  end
+
+  test "open method fails if name cannot be found" do
+    assert_raise(Errno::ENOENT){ Event.open('bogus') }
+  end
+
+  test "inheritable basic functionality" do
+    assert_respond_to(@event, :inheritable?)
+    assert_nothing_raised{ @event.inheritable? }
+  end
+
+  test "inheritable is true by default" do
+    assert_true(@event.inheritable?)
+  end
+
+  test "inheritable matches value passed to constructor" do
+    @event = Event.new(nil, false, false, false)
+    assert_false(@event.inheritable?)
+  end
+
+  test "name attribute basic functionality" do
+    assert_respond_to(@event, :name)
+    assert_nothing_raised{ @event.name }
+  end
+
+  test "name is nil by default" do
+    assert_nil(@event.name)
+  end
+
+  test "name is set to value specified in constructor" do
+    @event = Event.new(@ascii)
+    assert_equal(@ascii, @event.name)
+  end
+
+  test "name is set to unicode value specified in constructor" do
+    @event = Event.new(@unicode)
+    assert_equal(@unicode, @event.name)
+  end
+
+  test "initial_state basic functionality" do
+    assert_respond_to(@event, :initial_state)
+    assert_nothing_raised{ @event.initial_state }
+    assert_boolean(@event.initial_state)
+  end
+
+  test "initial_state is false by default" do
+    assert_false(@event.initial_state)
+  end
+
+  test "initial state matches value set in constructor" do
+    @event = Event.new(nil, false, true)
+    assert_true(@event.initial_state)
+  end
+
+  test "manual_reset basic functionality" do
+    assert_respond_to(@event, :manual_reset)
+    assert_nothing_raised{ @event.manual_reset }
+    assert_boolean(@event.manual_reset)
+  end
+
+  test "manual_reset is false by default" do
+    assert_false(@event.manual_reset)
+  end
+
+  test "manual reset matches value passed to constructor" do
+    event = Event.new(nil, true)
+    assert_true(event.manual_reset)
+    event.close
+  end
+
+  test "signaled? basic functionality" do
+    assert_respond_to(@event, :signaled?)
+    assert_nothing_raised{ @event.signaled? }
+  end
+
+  test "signaled? returns a boolean" do
+    assert_boolean(@event.signaled?)
+  end
+
+  test "set basic functionality" do
+    @event = Event.new
+    assert_respond_to(@event, :set)
+    assert_nothing_raised{ @event.set }
+  end
+
+  test "set puts event in signaled state" do
+    assert_false(@event.signaled?)
+    @event.set
+    assert_true(@event.signaled?)
+  end
+
+  test "reset basic functionality" do
+    assert_respond_to(@event, :reset)
+    assert_nothing_raised{ @event.reset }
+  end
+
+  test "reset sets signaled state to false" do
+    @event.set
+    assert_true(@event.signaled?)
+    @event.reset
+    assert_false(@event.signaled?)
+  end
+
+  test "close method basic functionality" do
+    assert_respond_to(@event, :close)
+    assert_nothing_raised{ @event.close }
+  end
+
+  test "calling close multiple times has no effect" do
+    assert_nothing_raised{ 5.times{ @event.close } }
+  end
+
+  test "ffi functions are private" do
+    assert_not_respond_to(Event, :CreateEvent)
+    assert_not_respond_to(Event, :OpenEvent)
+    assert_not_respond_to(Event, :SetEvent)
+    assert_not_respond_to(Event, :ResetEvent)
+  end
+
   def teardown
-    @event1.close
-    @event2.close
-    @event3.close
-    @event4.close
-    @uni_event.close
-      
-    @event1 = nil
-    @event2 = nil
-    @event3 = nil
-    @event4 = nil
-    @uni_event = nil
+    @event.close if @event
+    @event = nil
   end
 end

data/win32-event.gemspec

@@ -2,22 +2,21 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'win32-event'
-  spec.version   = '0.5.2'
+  spec.version   = '0.6.0'
   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') }
 
   spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
   spec.rubyforge_project = 'win32utils'
+  spec.required_ruby_version = '> 1.9.0'
 
-  spec.add_dependency('win32-ipc', '>= 0.5.0')
-  spec.add_development_dependency('test-unit', '>= 2.0.7')
+  spec.add_dependency('win32-ipc', '>= 0.6.0')
+  spec.add_development_dependency('test-unit')
 
   spec.description = <<-EOF
     The win32-event library provides an interface to Windows event objects.

metadata

@@ -1,61 +1,60 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: win32-event
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 5
-  - 2
-  version: 0.5.2
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Daniel J. Berger
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-04-21 00:00:00 -06:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: win32-ipc
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 5
-        - 0
-        version: 0.5.0
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
   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
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   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"
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+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: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README
 - CHANGES
 - MANIFEST
-files: 
+files:
 - CHANGES
 - lib/win32/event.rb
 - MANIFEST
@@ -63,35 +62,30 @@ files:
 - README
 - test/test_win32_event.rb
 - win32-event.gemspec
-has_rdoc: true
 homepage: http://www.rubyforge.org/projects/win32utils
-licenses: 
+licenses:
 - Artistic 2.0
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: win32utils
-rubygems_version: 1.3.6
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Interface to MS Windows Event objects.
-test_files: 
+test_files:
 - test/test_win32_event.rb