win32-event 0.5.2 → 0.6.0

Sign up to get free protection for your applications and to get access to all the features.
data/CHANGES CHANGED
@@ -1,3 +1,8 @@
1
+ == 0.6.0 - 9-Jul-2012
2
+ * Converted code to use FFI.
3
+ * Now requires Ruby 1.9 or later.
4
+ * Updated and refactored tests.
5
+
1
6
  == 0.5.2 - 21-Apr-2010
2
7
  * Updated the gemspec, adding some gem building tasks, and removed the
3
8
  inline gem building code from the gemspec itself.
data/README CHANGED
@@ -37,10 +37,10 @@
37
37
 
38
38
  == Known Bugs
39
39
  None that I'm aware of. Please submit any bug reports to the project page
40
- at http://www.rubyforge.org/projects/win32utils.
40
+ at https://github.com/djberg96/win32-event.
41
41
 
42
42
  == Copyright
43
- (C) 2003-2010 Daniel J. Berger
43
+ (C) 2003-2012 Daniel J. Berger
44
44
  All Rights Reserved
45
45
 
46
46
  == License
data/Rakefile CHANGED
@@ -1,16 +1,12 @@
1
1
  require 'rake'
2
2
  require 'rake/testtask'
3
- require 'rbconfig'
4
- include Config
3
+ require 'rake/clean'
5
4
 
6
- namespace 'gem' do
7
- desc 'Remove existing .gem file from the current directory'
8
- task :clean do
9
- Dir['*.gem'].each{ |f| File.delete(f) }
10
- end
5
+ CLEAN.include("**/*.gem", "**/*.rbc")
11
6
 
7
+ namespace 'gem' do
12
8
  desc 'Create the win32-event gem'
13
- task :create do
9
+ task :create => [:clean] do
14
10
  spec = eval(IO.read('win32-event.gemspec'))
15
11
  Gem::Builder.new(spec).build
16
12
  end
@@ -26,3 +22,5 @@ Rake::TestTask.new do |t|
26
22
  t.verbose = true
27
23
  t.warning = true
28
24
  end
25
+
26
+ task :default => :test
data/lib/win32/event.rb CHANGED
@@ -5,31 +5,46 @@ module Win32
5
5
 
6
6
  # The Event class encapsulates Windows event objects.
7
7
  class Event < Ipc
8
-
8
+ ffi_lib :kernel32
9
+
10
+ class SecurityAttributes < FFI::Struct
11
+ layout(
12
+ :nLength, :ulong,
13
+ :lpSecurityDescriptor, :pointer,
14
+ :bInheritHandle, :bool
15
+ )
16
+ end
17
+
18
+ attach_function :CreateEvent, :CreateEventW, [:pointer, :bool, :bool, :buffer_in], :ulong
19
+ attach_function :OpenEvent, :OpenEventW, [:ulong, :bool, :buffer_in], :ulong
20
+ attach_function :SetEvent, [:ulong], :bool
21
+ attach_function :ResetEvent, [:ulong], :bool
22
+
23
+ private_class_method :CreateEvent, :OpenEvent, :SetEvent, :ResetEvent
24
+
25
+ INVALID_HANDLE_VALUE = 0xFFFFFFFF
26
+ EVENT_ALL_ACCESS = 0x1F0003
27
+
9
28
  # This is the error raised if any of the Event methods fail.
10
29
  class Error < StandardError; end
11
-
12
- extend Windows::Synchronize
13
- extend Windows::Error
14
- extend Windows::Handle
15
-
30
+
16
31
  # The version of the win32-event library
17
- VERSION = '0.5.2'
18
-
19
- # The name of the Event object.
32
+ VERSION = '0.6.0'
33
+
34
+ # The name of the Event object. The default is nil
20
35
  #
21
36
  attr_reader :name
22
-
37
+
23
38
  # Indicates whether or not the Event requires use of the ResetEvent()
24
- # function set the state to nonsignaled.
39
+ # function set the state to nonsignaled. The default is false
25
40
  #
26
41
  attr_reader :manual_reset
27
-
42
+
28
43
  # The initial state of the Event object. If true, the initial state
29
- # is signaled. Otherwise, it is non-signaled.
44
+ # is signaled. Otherwise, it is non-signaled. The default is false.
30
45
  #
31
46
  attr_reader :initial_state
32
-
47
+
33
48
  # Creates and returns new Event object. If +name+ is omitted, the
34
49
  # Event object is created without a name, i.e. it's anonymous.
35
50
  #
@@ -48,49 +63,42 @@ module Win32
48
63
  #
49
64
  # If the +inherit+ parameter is true, then processes created by this
50
65
  # process will inherit the handle. Otherwise they will not.
51
- #
66
+ #
52
67
  # In block form this will automatically close the Event object at the
53
68
  # end of the block.
54
- #
69
+ #
55
70
  def initialize(name=nil, man_reset=false, init_state=false, inherit=true)
56
71
  @name = name
57
72
  @manual_reset = man_reset
58
73
  @initial_state = init_state
59
74
  @inherit = inherit
60
-
61
- manual_reset = man_reset ? 1 : 0
62
- initial_state = init_state ? 1 : 0
63
-
64
- # Used to prevent potential segfaults.
65
- if name && !name.is_a?(String)
66
- raise TypeError, 'name must be a string'
75
+
76
+ if name.is_a?(String)
77
+ if name.encoding.to_s != 'UTF-16LE'
78
+ name = name + 0.chr
79
+ name.encode!('UTF-16LE')
80
+ end
81
+ else
82
+ raise TypeError if name
67
83
  end
68
84
 
69
85
  if inherit
70
- sec = 0.chr * 12 # sizeof(SECURITY_ATTRIBUTES)
71
- sec[0,4] = [12].pack('L')
72
- sec[8,4] = [1].pack('L') # 1 == TRUE
86
+ sec = SecurityAttributes.new
87
+ sec[:nLength] = SecurityAttributes.size
88
+ sec[:bInheritHandle] = inherit
73
89
  else
74
- sec = 0
90
+ sec = nil
75
91
  end
76
-
92
+
77
93
  handle = CreateEvent(sec, manual_reset, initial_state, name)
78
-
94
+
79
95
  if handle == 0 || handle == INVALID_HANDLE_VALUE
80
- raise Error, get_last_error
96
+ raise SystemCallError.new("CreateEvent", FFI.errno)
81
97
  end
82
-
98
+
83
99
  super(handle)
84
-
85
- if block_given?
86
- begin
87
- yield self
88
- ensure
89
- close
90
- end
91
- end
92
100
  end
93
-
101
+
94
102
  # Open an existing Event by +name+. The +inherit+ argument sets whether
95
103
  # or not the object was opened such that a process created by the
96
104
  # CreateProcess() function (a Windows API function) can inherit the
@@ -104,27 +112,30 @@ module Win32
104
112
  # If you want "open or create" semantics, then use Event.new.
105
113
  #
106
114
  def self.open(name, inherit=true, &block)
107
- if name && !name.is_a?(String)
108
- raise TypeError, 'name must be a string'
115
+ raise TypeError unless name.is_a?(String)
116
+
117
+ if name.encoding.to_s != 'UTF-16LE'
118
+ oname = name + 0.chr
119
+ oname.encode!('UTF-16LE')
120
+ else
121
+ oname = name.dup
109
122
  end
110
-
111
- bool = inherit ? 1 : 0
112
123
 
113
124
  # This block of code is here strictly to force an error if the user
114
125
  # tries to open an event that doesn't already exist.
115
126
  begin
116
- handle = OpenEvent(EVENT_ALL_ACCESS, bool, name)
127
+ h = OpenEvent(EVENT_ALL_ACCESS, inherit, oname)
117
128
 
118
- if handle == 0 || handle == INVALID_HANDLE_VALUE
119
- raise Error, get_last_error
129
+ if h == 0 || h == INVALID_HANDLE_VALUE
130
+ raise SystemCallError.new("OpenEvent", FFI.errno)
120
131
  end
121
132
  ensure
122
- CloseHandle(handle) if handle > 0
133
+ CloseHandle(h) if h
123
134
  end
124
135
 
125
136
  self.new(name, false, false, inherit, &block)
126
137
  end
127
-
138
+
128
139
  # Returns whether or not the object was opened such that a process
129
140
  # created by the CreateProcess() function (a Windows API function) can
130
141
  # inherit the handle. The default is true.
@@ -132,34 +143,34 @@ module Win32
132
143
  def inheritable?
133
144
  @inherit
134
145
  end
135
-
146
+
136
147
  # Sets the Event object to a non-signaled state.
137
- #
148
+ #
138
149
  def reset
139
150
  unless ResetEvent(@handle)
140
- raise Error, get_last_error
151
+ raise SystemCallError.new("ResetEvent", FFI.errno)
141
152
  end
142
153
  @signaled = false
143
154
  end
144
-
155
+
145
156
  # Sets the Event object to a signaled state.
146
- #
157
+ #
147
158
  def set
148
159
  unless SetEvent(@handle)
149
- raise Error, get_last_error
160
+ raise SystemCallError.new("SetEvent", FFI.errno)
150
161
  end
151
162
  @signaled = true
152
163
  end
153
-
164
+
154
165
  # Synonym for Event#reset if +bool+ is false, or Event#set
155
166
  # if +bool+ is true.
156
- #
167
+ #
157
168
  def signaled=(bool)
158
169
  if bool
159
170
  set
160
171
  else
161
172
  reset
162
173
  end
163
- end
174
+ end
164
175
  end
165
176
  end
@@ -1,124 +1,200 @@
1
+ # encoding: UTF-8
1
2
  #####################################################################
2
3
  # test_win32_event.rb
3
4
  #
4
5
  # Test suite for the win32-event library. This test should be run
5
6
  # via the 'rake test' task.
6
7
  #####################################################################
7
- require 'rubygems'
8
- gem 'test-unit'
9
-
8
+ require 'test-unit'
10
9
  require 'test/unit'
11
10
  require 'win32/event'
12
11
  include Win32
13
12
 
14
13
  class TC_Win32Event < Test::Unit::TestCase
15
14
  def setup
16
- @event1 = Event.new
17
- @event2 = Event.new("Foo")
18
- @event3 = Event.new("Bar", true)
19
- @event4 = Event.new("Baz", true, true)
20
- @uni_event = Event.new("Ηελλας")
21
- end
22
-
23
- def test_version
24
- assert_equal('0.5.2', Event::VERSION)
25
- end
26
-
27
- def test_constructor_errors
28
- assert_raises(ArgumentError){ Event.new("Foo", true, false, true, 1) }
29
- assert_raises(TypeError){ Event.new(1) }
30
- end
31
-
32
- def test_open
15
+ @event = Event.new
16
+ @unicode = "Ηελλας"
17
+ @ascii = "foo"
18
+ end
19
+
20
+ test "version is set to expected value" do
21
+ assert_equal('0.6.0', Event::VERSION)
22
+ end
23
+
24
+ test "constructor works with no arguments" do
25
+ assert_nothing_raised{ @event = Event.new }
26
+ assert_nil(@event.name)
27
+ end
28
+
29
+ test "constructor accepts an event name" do
30
+ assert_nothing_raised{ @event = Event.new(@ascii) }
31
+ end
32
+
33
+ test "constructor accepts a unicode event name" do
34
+ assert_nothing_raised{ @event = Event.new(@unicode) }
35
+ end
36
+
37
+ test "constructor accepts a maximum of four arguments" do
38
+ assert_raises(ArgumentError){ Event.new('Foo', true, false, true, 1) }
39
+ end
40
+
41
+ test "first argument to constructor must be a string" do
42
+ assert_raise(TypeError){ Event.new(1) }
43
+ end
44
+
45
+ test "open method basic functionality" do
46
+ event = Event.new(@ascii)
33
47
  assert_respond_to(Event, :open)
34
- assert_nothing_raised{ Event.open("Bar"){} }
35
- assert_nothing_raised{ Event.open("Ηελλας"){} }
36
- assert_nothing_raised{ Event.open("Bar", false) }
37
- end
38
-
39
- def test_open_expected_errors
40
- assert_raises(ArgumentError){ Event.open("Bar", true, false){} }
41
- assert_raises(Event::Error){ Event.open("Blah"){} }
48
+ assert_nothing_raised{ @event = Event.open(@ascii) }
49
+ assert_equal(@ascii, @event.name)
50
+ event.close
51
+ end
52
+
53
+ test "open method accepts an inherit argument" do
54
+ event = Event.new(@ascii)
55
+ assert_nothing_raised{ @event = Event.open(@ascii, false) }
56
+ assert_false(@event.inheritable?)
57
+ event.close
58
+ end
59
+
60
+ test "open method works with unicode names" do
61
+ event = Event.new(@unicode)
62
+ assert_nothing_raised{ @event = Event.open(@unicode) }
63
+ assert_equal(@unicode, @event.name)
64
+ event.close
65
+ end
66
+
67
+ test "open method requires a name" do
68
+ assert_raise(ArgumentError){ Event.open }
69
+ end
70
+
71
+ test "open method requires a string argument as the first argument" do
42
72
  assert_raises(TypeError){ Event.open(1){} }
43
73
  end
44
-
45
- def test_inheritable
46
- @event1 = Event.open("Foo")
47
- @event2 = Event.open("Baz", false)
48
-
49
- assert_respond_to(@event1, :inheritable?)
50
- assert_nothing_raised{ @event1.inheritable? }
51
- assert_true(@event1.inheritable?)
52
- assert_false(@event2.inheritable?)
53
- end
54
-
55
- def test_name
56
- assert_respond_to(@event1, :name)
57
- assert_nothing_raised{ @event1.name }
58
- assert_nothing_raised{ @uni_event.name }
59
- assert_nil(@event1.name)
60
- assert_kind_of(String, @event2.name)
61
- end
62
-
63
- def test_initial_state
64
- assert_respond_to(@event1, :initial_state)
65
- assert_nothing_raised{ @event1.initial_state }
66
-
67
- assert_false(@event1.initial_state)
68
- assert_false(@event2.initial_state)
69
- assert_false(@event3.initial_state)
70
- assert_true(@event4.initial_state)
71
- end
72
-
73
- def test_manual_reset
74
- assert_respond_to(@event1, :manual_reset)
75
- assert_nothing_raised{ @event1.manual_reset }
76
-
77
- assert_false(@event1.manual_reset)
78
- assert_false(@event2.manual_reset)
79
- assert_true(@event3.manual_reset)
80
- assert_true(@event4.manual_reset)
81
- end
82
-
83
- def test_set
84
- assert_respond_to(@event1, :set)
85
- assert_nothing_raised{ @event1.set }
86
- end
87
-
88
- def test_is_signaled
89
- event = Event.new
90
- assert_respond_to(event, :signaled?)
91
- assert_nothing_raised{ event.signaled? }
92
-
93
- assert_false(event.signaled?)
94
- event.set
95
- assert_true(event.signaled?)
96
- event.reset
97
- assert_false(event.signaled?)
98
- end
99
-
100
- def test_reset
101
- assert_respond_to(@event1, :reset)
102
- assert_nothing_raised{ @event1.reset }
103
- end
104
-
105
- def test_close
106
- event = Event.new
107
- assert_respond_to(event, :close)
108
- assert_nothing_raised{ event.close }
109
- end
110
-
74
+
75
+ test "open accepts a maximum of two arguments" do
76
+ assert_raise(ArgumentError){ Event.open('bogus', true, false) }
77
+ end
78
+
79
+ test "open method fails if name cannot be found" do
80
+ assert_raise(Errno::ENOENT){ Event.open('bogus') }
81
+ end
82
+
83
+ test "inheritable basic functionality" do
84
+ assert_respond_to(@event, :inheritable?)
85
+ assert_nothing_raised{ @event.inheritable? }
86
+ end
87
+
88
+ test "inheritable is true by default" do
89
+ assert_true(@event.inheritable?)
90
+ end
91
+
92
+ test "inheritable matches value passed to constructor" do
93
+ @event = Event.new(nil, false, false, false)
94
+ assert_false(@event.inheritable?)
95
+ end
96
+
97
+ test "name attribute basic functionality" do
98
+ assert_respond_to(@event, :name)
99
+ assert_nothing_raised{ @event.name }
100
+ end
101
+
102
+ test "name is nil by default" do
103
+ assert_nil(@event.name)
104
+ end
105
+
106
+ test "name is set to value specified in constructor" do
107
+ @event = Event.new(@ascii)
108
+ assert_equal(@ascii, @event.name)
109
+ end
110
+
111
+ test "name is set to unicode value specified in constructor" do
112
+ @event = Event.new(@unicode)
113
+ assert_equal(@unicode, @event.name)
114
+ end
115
+
116
+ test "initial_state basic functionality" do
117
+ assert_respond_to(@event, :initial_state)
118
+ assert_nothing_raised{ @event.initial_state }
119
+ assert_boolean(@event.initial_state)
120
+ end
121
+
122
+ test "initial_state is false by default" do
123
+ assert_false(@event.initial_state)
124
+ end
125
+
126
+ test "initial state matches value set in constructor" do
127
+ @event = Event.new(nil, false, true)
128
+ assert_true(@event.initial_state)
129
+ end
130
+
131
+ test "manual_reset basic functionality" do
132
+ assert_respond_to(@event, :manual_reset)
133
+ assert_nothing_raised{ @event.manual_reset }
134
+ assert_boolean(@event.manual_reset)
135
+ end
136
+
137
+ test "manual_reset is false by default" do
138
+ assert_false(@event.manual_reset)
139
+ end
140
+
141
+ test "manual reset matches value passed to constructor" do
142
+ event = Event.new(nil, true)
143
+ assert_true(event.manual_reset)
144
+ event.close
145
+ end
146
+
147
+ test "signaled? basic functionality" do
148
+ assert_respond_to(@event, :signaled?)
149
+ assert_nothing_raised{ @event.signaled? }
150
+ end
151
+
152
+ test "signaled? returns a boolean" do
153
+ assert_boolean(@event.signaled?)
154
+ end
155
+
156
+ test "set basic functionality" do
157
+ @event = Event.new
158
+ assert_respond_to(@event, :set)
159
+ assert_nothing_raised{ @event.set }
160
+ end
161
+
162
+ test "set puts event in signaled state" do
163
+ assert_false(@event.signaled?)
164
+ @event.set
165
+ assert_true(@event.signaled?)
166
+ end
167
+
168
+ test "reset basic functionality" do
169
+ assert_respond_to(@event, :reset)
170
+ assert_nothing_raised{ @event.reset }
171
+ end
172
+
173
+ test "reset sets signaled state to false" do
174
+ @event.set
175
+ assert_true(@event.signaled?)
176
+ @event.reset
177
+ assert_false(@event.signaled?)
178
+ end
179
+
180
+ test "close method basic functionality" do
181
+ assert_respond_to(@event, :close)
182
+ assert_nothing_raised{ @event.close }
183
+ end
184
+
185
+ test "calling close multiple times has no effect" do
186
+ assert_nothing_raised{ 5.times{ @event.close } }
187
+ end
188
+
189
+ test "ffi functions are private" do
190
+ assert_not_respond_to(Event, :CreateEvent)
191
+ assert_not_respond_to(Event, :OpenEvent)
192
+ assert_not_respond_to(Event, :SetEvent)
193
+ assert_not_respond_to(Event, :ResetEvent)
194
+ end
195
+
111
196
  def teardown
112
- @event1.close
113
- @event2.close
114
- @event3.close
115
- @event4.close
116
- @uni_event.close
117
-
118
- @event1 = nil
119
- @event2 = nil
120
- @event3 = nil
121
- @event4 = nil
122
- @uni_event = nil
197
+ @event.close if @event
198
+ @event = nil
123
199
  end
124
200
  end
data/win32-event.gemspec CHANGED
@@ -2,22 +2,21 @@ require 'rubygems'
2
2
 
3
3
  Gem::Specification.new do |spec|
4
4
  spec.name = 'win32-event'
5
- spec.version = '0.5.2'
5
+ spec.version = '0.6.0'
6
6
  spec.author = 'Daniel J. Berger'
7
7
  spec.license = 'Artistic 2.0'
8
8
  spec.email = 'djberg96@gmail.com'
9
9
  spec.homepage = 'http://www.rubyforge.org/projects/win32utils'
10
- spec.platform = Gem::Platform::RUBY
11
10
  spec.summary = 'Interface to MS Windows Event objects.'
12
11
  spec.test_file = 'test/test_win32_event.rb'
13
- spec.has_rdoc = true
14
12
  spec.files = Dir['**/*'].reject{ |f| f.include?('git') }
15
13
 
16
14
  spec.extra_rdoc_files = ['README', 'CHANGES', 'MANIFEST']
17
15
  spec.rubyforge_project = 'win32utils'
16
+ spec.required_ruby_version = '> 1.9.0'
18
17
 
19
- spec.add_dependency('win32-ipc', '>= 0.5.0')
20
- spec.add_development_dependency('test-unit', '>= 2.0.7')
18
+ spec.add_dependency('win32-ipc', '>= 0.6.0')
19
+ spec.add_development_dependency('test-unit')
21
20
 
22
21
  spec.description = <<-EOF
23
22
  The win32-event library provides an interface to Windows event objects.
metadata CHANGED
@@ -1,61 +1,60 @@
1
- --- !ruby/object:Gem::Specification
1
+ --- !ruby/object:Gem::Specification
2
2
  name: win32-event
3
- version: !ruby/object:Gem::Version
4
- prerelease: false
5
- segments:
6
- - 0
7
- - 5
8
- - 2
9
- version: 0.5.2
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.6.0
5
+ prerelease:
10
6
  platform: ruby
11
- authors:
7
+ authors:
12
8
  - Daniel J. Berger
13
9
  autorequire:
14
10
  bindir: bin
15
11
  cert_chain: []
16
-
17
- date: 2010-04-21 00:00:00 -06:00
18
- default_executable:
19
- dependencies:
20
- - !ruby/object:Gem::Dependency
12
+ date: 2012-07-09 00:00:00.000000000 Z
13
+ dependencies:
14
+ - !ruby/object:Gem::Dependency
21
15
  name: win32-ipc
22
- prerelease: false
23
- requirement: &id001 !ruby/object:Gem::Requirement
24
- requirements:
25
- - - ">="
26
- - !ruby/object:Gem::Version
27
- segments:
28
- - 0
29
- - 5
30
- - 0
31
- version: 0.5.0
16
+ requirement: !ruby/object:Gem::Requirement
17
+ none: false
18
+ requirements:
19
+ - - ! '>='
20
+ - !ruby/object:Gem::Version
21
+ version: 0.6.0
32
22
  type: :runtime
33
- version_requirements: *id001
34
- - !ruby/object:Gem::Dependency
35
- name: test-unit
36
23
  prerelease: false
37
- requirement: &id002 !ruby/object:Gem::Requirement
38
- requirements:
39
- - - ">="
40
- - !ruby/object:Gem::Version
41
- segments:
42
- - 2
43
- - 0
44
- - 7
45
- version: 2.0.7
24
+ version_requirements: !ruby/object:Gem::Requirement
25
+ none: false
26
+ requirements:
27
+ - - ! '>='
28
+ - !ruby/object:Gem::Version
29
+ version: 0.6.0
30
+ - !ruby/object:Gem::Dependency
31
+ name: test-unit
32
+ requirement: !ruby/object:Gem::Requirement
33
+ none: false
34
+ requirements:
35
+ - - ! '>='
36
+ - !ruby/object:Gem::Version
37
+ version: '0'
46
38
  type: :development
47
- version_requirements: *id002
48
- 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"
39
+ prerelease: false
40
+ version_requirements: !ruby/object:Gem::Requirement
41
+ none: false
42
+ requirements:
43
+ - - ! '>='
44
+ - !ruby/object:Gem::Version
45
+ version: '0'
46
+ description: ! " The win32-event library provides an interface to Windows event
47
+ objects.\n An event object is a synchronization object whose state can be explicitly\n
48
+ \ set to a signaled state. Event objects are useful in sending a signal to\n a
49
+ thread indicating that a particular event has occurred.\n"
49
50
  email: djberg96@gmail.com
50
51
  executables: []
51
-
52
52
  extensions: []
53
-
54
- extra_rdoc_files:
53
+ extra_rdoc_files:
55
54
  - README
56
55
  - CHANGES
57
56
  - MANIFEST
58
- files:
57
+ files:
59
58
  - CHANGES
60
59
  - lib/win32/event.rb
61
60
  - MANIFEST
@@ -63,35 +62,30 @@ files:
63
62
  - README
64
63
  - test/test_win32_event.rb
65
64
  - win32-event.gemspec
66
- has_rdoc: true
67
65
  homepage: http://www.rubyforge.org/projects/win32utils
68
- licenses:
66
+ licenses:
69
67
  - Artistic 2.0
70
68
  post_install_message:
71
69
  rdoc_options: []
72
-
73
- require_paths:
70
+ require_paths:
74
71
  - lib
75
- required_ruby_version: !ruby/object:Gem::Requirement
76
- requirements:
77
- - - ">="
78
- - !ruby/object:Gem::Version
79
- segments:
80
- - 0
81
- version: "0"
82
- required_rubygems_version: !ruby/object:Gem::Requirement
83
- requirements:
84
- - - ">="
85
- - !ruby/object:Gem::Version
86
- segments:
87
- - 0
88
- version: "0"
72
+ required_ruby_version: !ruby/object:Gem::Requirement
73
+ none: false
74
+ requirements:
75
+ - - ! '>'
76
+ - !ruby/object:Gem::Version
77
+ version: 1.9.0
78
+ required_rubygems_version: !ruby/object:Gem::Requirement
79
+ none: false
80
+ requirements:
81
+ - - ! '>='
82
+ - !ruby/object:Gem::Version
83
+ version: '0'
89
84
  requirements: []
90
-
91
85
  rubyforge_project: win32utils
92
- rubygems_version: 1.3.6
86
+ rubygems_version: 1.8.24
93
87
  signing_key:
94
88
  specification_version: 3
95
89
  summary: Interface to MS Windows Event objects.
96
- test_files:
90
+ test_files:
97
91
  - test/test_win32_event.rb