win32-mutex 0.3.2 → 0.4.0

data/CHANGES

@@ -1,3 +1,9 @@
+== 0.4.0 - 10-Jul-2012
+* Converted to FFI.
+* Now requires Ruby 1.9 or later.
+* Removed the Error class. If a Windows function fails it raises the
+  appropriate SystemCallError (Errno::).
+
 == 0.3.2 - 18-Mar-2011
 * Updates to the Rakefile and gemspec.
 * One test file change for Ruby 1.9.

data/MANIFEST

@@ -5,4 +5,4 @@
 * win32-mutex.gemspec
 * examples/mutex_test.rb
 * lib/win32/mutex.rb
-* test/tc_mutex.rb
+* test/test_win32_mutex.rb

data/README

@@ -2,7 +2,7 @@
    Interface for Mutexes on MS Windows.
 
 == Prerequisites
-   win32-ipc 0.5.0 or later
+   win32-ipc 0.6.0 or later
 
 == Installation
    gem install win32-mutex

data/lib/win32/mutex.rb

@@ -3,129 +3,141 @@ require 'win32/ipc'
 # The Win32 module serves as a namespace only.
 module Win32
 
-   # The Mutex class encapsulates Windows mutex objects.
-   class Mutex < Ipc
-
-      # This is the error raised if any of the Mutex methods fail.
-      class Error < StandardError; end
-
-      extend Windows::Synchronize
-      extend Windows::Error
-      extend Windows::Handle
-
-      # The version of the win32-mutex library
-      VERSION = '0.3.2'
-
-      # The name of the mutex object.
-      attr_reader :name
-
-      # Creates and returns new Mutex object. If +name+ is omitted, the
-      # Mutex object is created without a name, i.e. it's anonymous.
-      #
-      # If the +initial_owner+ value is true and the caller created the mutex,
-      # the calling thread obtains initial ownership of the mutex object.
-      # Otherwise, the calling thread does not obtain ownership of the mutex.
-      # This value is false by default.
-      #
-      # If +name+ is provided and it already exists, then it is opened
-      # instead, and the +initial_count+ and +max_count+ parameters are
-      # ignored.
-      #
-      # The +inherit+ attribute determines whether or not the mutex can
-      # be inherited by child processes.
-      #
-      def initialize(initial_owner=false, name=nil, inherit=true)
-         @initial_owner = initial_owner
-         @name          = name
-         @inherit       = inherit
-
-         # 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
-
-         initial = initial_owner ? 1 : 0
-
-         handle = CreateMutex(sec, initial, name)
-
-         if handle == 0 || handle == INVALID_HANDLE_VALUE
-            raise Error, get_last_error
-         end
-
-         super(handle)
-
-         if block_given?
-            begin
-               yield self
-            ensure
-               close # From superclass
-            end
-         end
+  # The Mutex class encapsulates Windows mutex objects.
+  class Mutex < Ipc
+    ffi_lib :kernel32
+
+    private
+
+    class SecurityAttributes < FFI::Struct
+      layout(
+        :nLength, :ulong,
+        :lpSecurityDescriptor, :pointer,
+        :bInheritHandle, :bool
+      )
+    end
+
+    attach_function :CreateMutexW, [:pointer, :bool, :buffer_in], :ulong
+    attach_function :OpenMutexW, [:ulong, :bool, :buffer_in], :ulong
+    attach_function :ReleaseMutex, [:ulong], :bool
+
+    private_class_method :CreateMutexW, :OpenMutexW, :ReleaseMutex
+
+    INVALID_HANDLE_VALUE = 0xFFFFFFFF
+    MUTEX_ALL_ACCESS     = 0x1F0001
+
+    public
+
+    # The version of the win32-mutex library
+    VERSION = '0.4.0'
+
+    # The name of the mutex object.
+    attr_reader :name
+
+    # Creates and returns new Mutex object. If +name+ is omitted, the
+    # Mutex object is created without a name, i.e. it's anonymous.
+    #
+    # If the +initial_owner+ value is true and the caller created the mutex,
+    # the calling thread obtains initial ownership of the mutex object.
+    # Otherwise, the calling thread does not obtain ownership of the mutex.
+    # This value is false by default.
+    #
+    # If +name+ is provided and it already exists, then it is opened
+    # instead, and the +initial_count+ and +max_count+ parameters are
+    # ignored.
+    #
+    # The +inherit+ attribute determines whether or not the mutex can
+    # be inherited by child processes.
+    #
+    def initialize(initial_owner=false, name=nil, inherit=true)
+      @initial_owner = initial_owner
+      @name          = name
+      @inherit       = inherit
+
+      if inherit
+        sec = SecurityAttributes.new
+        sec[:nLength] = SecurityAttributes.size
+        sec[:bInheritHandle] = true
+      else
+        sec = nil
       end
 
-      # Open an existing Mutex 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 Mutex.new, except that the
-      # option for +initial_owner+ cannot be set (since it is already set).
-      # Also, this method will raise a Mutex::Error if the mutex doesn't
-      # already exist.
-      #
-      # If you want "open or create" semantics, then use Mutex.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
-
-         # The OpenMutex() call here is strictly to force an error if the user
-         # tries to open a mutex that doesn't already exist.
-         begin
-            handle = OpenMutex(MUTEX_ALL_ACCESS, bool, name)
-
-            if handle == 0 || handle == INVALID_HANDLE_VALUE
-               raise Error, get_last_error
-            end
-         ensure
-            CloseHandle(handle) if handle && handle > 0
-         end
-
-         self.new(false, name, inherit, &block)
+      if name && name.encoding.to_s != 'UTF-16LE'
+        name = name + 0.chr
+        name.encode!('UTF-16LE')
       end
 
-      # Releases ownership of the mutex.
-      #
-      def release
-         unless ReleaseMutex(@handle)
-            raise Error, get_last_error
-         end
+      handle = CreateMutexW(sec, initial_owner, name)
+
+      if handle == 0 || handle == INVALID_HANDLE_VALUE
+        raise SystemCallError.new("CreateMutex", FFI.errno)
       end
 
-      # Returns whether or not the calling thread has initial ownership of
-      # the mutex object.
-      #
-      def initial_owner?
-         @initial_owner
+      super(handle)
+
+      if block_given?
+        begin
+          yield self
+        ensure
+          close # From superclass
+        end
       end
+    end
+
+    # Open an existing Mutex 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 Mutex.new, except that the
+    # option for +initial_owner+ cannot be set (since it is already set).
+    # Also, this method will raise a Mutex::Error if the mutex doesn't
+    # already exist.
+    #
+    # If you want "open or create" semantics, then use Mutex.new.
+    #
+    def self.open(name, inherit=true, &block)
+      if name.encoding.to_s != 'UTF-16LE'
+        name = name + 0.chr
+        name.encode!('UTF-16LE')
+      end
+
+      begin
+        # The OpenMutex() call here is strictly to force an error if the user
+        # tries to open a mutex that doesn't already exist.
+        handle = OpenMutexW(MUTEX_ALL_ACCESS, inherit, name)
+
+        if handle == 0 || handle == INVALID_HANDLE_VALUE
+          raise SystemCallError.new("OpenMutex", FFI.errno)
+        end
+      ensure
+        CloseHandle(handle) if handle && handle > 0
+      end
+
+      self.new(false, name, 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
+    # Releases ownership of the mutex.
+    #
+    def release
+      unless ReleaseMutex(@handle)
+        raise SystemCallError.new("ReleaseMutex", FFI.errno)
       end
-   end
+    end
+
+    # Returns whether or not the calling thread has initial ownership of
+    # the mutex object.
+    #
+    def initial_owner?
+      @initial_owner
+    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
+  end
 end

data/test/test_win32_mutex.rb

@@ -1,14 +1,11 @@
 # encoding: utf-8
 #######################################################################
-# test_Win32::Mutex.rb
+# test_win32_mutex.rb
 #
-# Test suite for the win32-Win32::Mutex package. This test suite
-# should be run via the 'rake test' task.
+# Test suite for the win32-mutex library. This test suite should be
+# run via the 'rake test' task.
 #######################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
+require 'test-unit'
 require 'win32/mutex'
 
 class TC_Win32_Mutex < Test::Unit::TestCase
@@ -18,47 +15,67 @@ class TC_Win32_Mutex < Test::Unit::TestCase
   end
 
   def test_version
-    assert_equal('0.3.2', Win32::Mutex::VERSION)
+    assert_equal('0.4.0', Win32::Mutex::VERSION)
+  end
+
+  test "constructor with no arguments works as expected" do
+    mutex = nil
+    assert_nothing_raised{ mutex = Win32::Mutex.new }
+    mutex.close
   end
 
-  def test_open
+  test "default attributes are set to expected values" do
+    mutex = Win32::Mutex.new
+    assert_false(mutex.initial_owner?)
+    assert_true(mutex.inheritable?)
+    assert_nil(mutex.name)
+    mutex.close
+  end
+
+  test "open method works as expected" do
     assert_respond_to(Win32::Mutex, :open)
     assert_nothing_raised{ Win32::Mutex.open('test'){} }
     assert_nothing_raised{ Win32::Mutex.open('Ηελλας'){} }
   end
 
-  def test_open_expected_errors
-    assert_raise(Win32::Mutex::Error){ Win32::Mutex.open('bogus'){} }
+  test "attempting to open an unknown mutex raises an error" do
+    assert_raise(Errno::ENOENT){ Win32::Mutex.open('bogus'){} }
   end
 
-  def test_release
+  test "release method works as expected" do
     assert_respond_to(@mutex, :release)
     assert_nothing_raised{ @mutex.release }
   end
 
-  def test_initial_owner
+  test "initial_owner? works as expected and returns expected value" do
     assert_respond_to(@mutex, :initial_owner?)
     assert_true(@mutex.initial_owner?)
     assert_false(@umutex.initial_owner?)
   end
 
-  def test_inheritable
+  test "inheritable? works as expected and returns expected value" do
     assert_respond_to(@mutex, :inheritable?)
     assert_true(@mutex.inheritable?)
   end
 
-  def test_wait
+  test "wait method was inherited" do
     assert_respond_to(@mutex, :wait)
   end
 
-  def test_wait_any
+  test "wait_any method was inherited" do
     assert_respond_to(@mutex, :wait_any)
   end
 
-  def test_wait_all
+  test "wait_all method was inherited" do
     assert_respond_to(@mutex, :wait_all)
   end
 
+  test "ffi functions are private" do
+    assert_not_respond_to(Win32::Mutex, :CreateMutexW)
+    assert_not_respond_to(Win32::Mutex, :OpenMutexW)
+    assert_not_respond_to(Win32::Mutex, :ReleaseMutex)
+  end
+
   def teardown
     @mutex.close
     @umutex.close

data/win32-mutex.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'win32-mutex'
-  spec.version   = '0.3.2'
+  spec.version   = '0.4.0'
   spec.author    = 'Daniel J. Berger'
   spec.license   = 'Artistic 2.0'
   spec.email     = 'djberg96@gmail.com'
@@ -13,12 +13,10 @@ Gem::Specification.new do |spec|
 
   spec.rubyforge_project = 'win32utils'
   spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
+  spec.required_ruby_version = '> 1.9.0'
 
-  spec.add_dependency('win32-ipc', '>= 0.5.0')
-   
-  spec.add_development_dependency('test-unit', '>= 2.0.3')
-  spec.add_development_dependency('win32-process', '>= 0.6.1')
-  spec.add_development_dependency('win32-mmap', '>= 0.2.2')
+  spec.add_dependency('win32-ipc', '>= 0.6.0')
+  spec.add_development_dependency('test-unit')
 
   spec.description = <<-EOF
     The win32-mutex library provides an interface for creating mutex objects

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: win32-mutex
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,52 +9,40 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-18 00:00:00.000000000 Z
+date: 2012-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: win32-ipc
-  requirement: &5842660 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
-  version_requirements: *5842660
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: &5841950 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.0.3
-  type: :development
-  prerelease: false
-  version_requirements: *5841950
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
-  name: win32-process
-  requirement: &5841220 !ruby/object:Gem::Requirement
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *5841220
-- !ruby/object:Gem::Dependency
-  name: win32-mmap
-  requirement: &5840660 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.2.2
-  type: :development
-  prerelease: false
-  version_requirements: *5840660
+        version: '0'
 description: ! "    The win32-mutex library provides an interface for creating mutex
   objects\n    on MS Windows. A mutex object is a synchronization object whose state\n
   \   is set to signaled when it is not owned by any thread, and non-signaled\n    when
@@ -85,9 +73,9 @@ require_paths:
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -96,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: win32utils
-rubygems_version: 1.8.11
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Interface to MS Windows Mutex objects.