rubinius-actor 0.0.1 → 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,41 @@
1
+ require 'rubinius/actor'
2
+
3
+ Ready = Struct.new(:this)
4
+ Work = Struct.new(:msg)
5
+
6
+ @supervisor = Rubinius::Actor.spawn do
7
+ supervisor = Rubinius::Actor.current
8
+ work_loop = Proc.new do
9
+ loop do
10
+ work = Rubinius::Actor.receive
11
+ puts("Processing: #{work.msg}")
12
+ supervisor << Ready[Rubinius::Actor.current]
13
+ end
14
+ end
15
+
16
+ Rubinius::Actor.trap_exit = true
17
+ ready_workers = []
18
+ 10.times do |x|
19
+ # start 10 worker actors
20
+ ready_workers << Rubinius::Actor.spawn_link(&work_loop)
21
+ end
22
+ loop do
23
+ Rubinius::Actor.receive do |f|
24
+ f.when(Ready) do |who|
25
+ # SNIP
26
+ end
27
+ f.when(Work) do |work|
28
+ ready_workers.pop << work
29
+ end
30
+ f.when(Rubinius::Actor::DeadActorError) do |exit|
31
+ print "Actor exited with message: #{exit.reason}\n"
32
+ ready_workers << Rubinius::Actor.spawn_link(&work_loop)
33
+ end
34
+ end
35
+ end
36
+ end
37
+
38
+ 10.times do |idx|
39
+ @supervisor << Work[idx]
40
+ end
41
+ sleep 1
@@ -31,395 +31,397 @@
31
31
 
32
32
  require 'rubinius/core-api'
33
33
 
34
- class Rubinius::Actor
35
- class DeadActorError < RuntimeError
36
- attr_reader :actor
37
- attr_reader :reason
38
- def initialize(actor, reason)
39
- super(reason)
40
- @actor = actor
41
- @reason = reason
34
+ module Rubinius
35
+ class Actor
36
+ class DeadActorError < RuntimeError
37
+ attr_reader :actor
38
+ attr_reader :reason
39
+ def initialize(actor, reason)
40
+ super(reason)
41
+ @actor = actor
42
+ @reason = reason
43
+ end
42
44
  end
43
- end
44
45
 
45
- ANY = Object.new
46
- def ANY.===(other)
47
- true
48
- end
46
+ ANY = Object.new
47
+ def ANY.===(other)
48
+ true
49
+ end
49
50
 
50
- class << self
51
- alias_method :private_new, :new
52
- private :private_new
51
+ class << self
52
+ alias_method :private_new, :new
53
+ private :private_new
53
54
 
54
- @@registered_lock = Rubinius::Channel.new
55
- @@registered = {}
56
- @@registered_lock << nil
55
+ @@registered_lock = Rubinius::Channel.new
56
+ @@registered = {}
57
+ @@registered_lock << nil
57
58
 
58
- def current
59
- Thread.current[:__current_actor__] ||= private_new
60
- end
59
+ def current
60
+ Thread.current[:__current_actor__] ||= private_new
61
+ end
61
62
 
62
- # Spawn a new Actor that will run in its own thread
63
- def spawn(*args, &block)
64
- raise ArgumentError, "no block given" unless block
65
- spawned = Rubinius::Channel.new
66
- Thread.new do
67
- private_new do |actor|
68
- Thread.current[:__current_actor__] = actor
69
- spawned << actor
70
- block.call *args
63
+ # Spawn a new Actor that will run in its own thread
64
+ def spawn(*args, &block)
65
+ raise ArgumentError, "no block given" unless block
66
+ spawned = Rubinius::Channel.new
67
+ Thread.new do
68
+ private_new do |actor|
69
+ Thread.current[:__current_actor__] = actor
70
+ spawned << actor
71
+ block.call *args
72
+ end
71
73
  end
74
+ spawned.receive
72
75
  end
73
- spawned.receive
74
- end
75
- alias_method :new, :spawn
76
-
77
- # Atomically spawn an actor and link it to the current actor
78
- def spawn_link(*args, &block)
79
- current = self.current
80
- link_complete = Rubinius::Channel.new
81
- spawn do
82
- begin
83
- Actor.link(current)
84
- ensure
85
- link_complete << Actor.current
76
+ alias_method :new, :spawn
77
+
78
+ # Atomically spawn an actor and link it to the current actor
79
+ def spawn_link(*args, &block)
80
+ current = self.current
81
+ link_complete = Rubinius::Channel.new
82
+ spawn do
83
+ begin
84
+ Actor.link(current)
85
+ ensure
86
+ link_complete << Actor.current
87
+ end
88
+ block.call *args
86
89
  end
87
- block.call *args
90
+ link_complete.receive
88
91
  end
89
- link_complete.receive
90
- end
91
92
 
92
- # Polls for exit notifications
93
- def check_for_interrupt
94
- current._check_for_interrupt
95
- self
96
- end
93
+ # Polls for exit notifications
94
+ def check_for_interrupt
95
+ current._check_for_interrupt
96
+ self
97
+ end
97
98
 
98
- # Waits until a matching message is received in the current actor's
99
- # mailbox, and executes the appropriate action. May be interrupted by
100
- # exit notifications.
101
- def receive #:yields: filter
102
- filter = Filter.new
103
- if block_given?
104
- yield filter
105
- else
106
- filter.when(ANY) { |m| m }
99
+ # Waits until a matching message is received in the current actor's
100
+ # mailbox, and executes the appropriate action. May be interrupted by
101
+ # exit notifications.
102
+ def receive #:yields: filter
103
+ filter = Filter.new
104
+ if block_given?
105
+ yield filter
106
+ else
107
+ filter.when(ANY) { |m| m }
108
+ end
109
+ current._receive(filter)
107
110
  end
108
- current._receive(filter)
109
- end
110
111
 
111
- # Send a "fake" exit notification to another actor, as if the current
112
- # actor had exited with +reason+
113
- def send_exit(recipient, reason)
114
- recipient.notify_exited(current, reason)
115
- self
116
- end
112
+ # Send a "fake" exit notification to another actor, as if the current
113
+ # actor had exited with +reason+
114
+ def send_exit(recipient, reason)
115
+ recipient.notify_exited(current, reason)
116
+ self
117
+ end
117
118
 
118
- # Link the current Actor to another one.
119
- def link(actor)
120
- current = self.current
121
- current.notify_link actor
122
- actor.notify_link current
123
- self
124
- end
119
+ # Link the current Actor to another one.
120
+ def link(actor)
121
+ current = self.current
122
+ current.notify_link actor
123
+ actor.notify_link current
124
+ self
125
+ end
125
126
 
126
- # Unlink the current Actor from another one
127
- def unlink(actor)
128
- current = self.current
129
- current.notify_unlink actor
130
- actor.notify_unlink current
131
- self
132
- end
133
-
134
- # Actors trapping exit do not die when an error occurs in an Actor they
135
- # are linked to. Instead the exit message is sent to their regular
136
- # mailbox in the form [:exit, actor, reason]. This allows certain
137
- # Actors to supervise sets of others and restart them in the event
138
- # of an error. Setting the trap flag may be interrupted by pending
139
- # exit notifications.
140
- #
141
- def trap_exit=(value)
142
- current._trap_exit = value
143
- self
144
- end
127
+ # Unlink the current Actor from another one
128
+ def unlink(actor)
129
+ current = self.current
130
+ current.notify_unlink actor
131
+ actor.notify_unlink current
132
+ self
133
+ end
145
134
 
146
- # Is the Actor trapping exit?
147
- def trap_exit
148
- current._trap_exit
149
- end
150
- alias_method :trap_exit?, :trap_exit
135
+ # Actors trapping exit do not die when an error occurs in an Actor they
136
+ # are linked to. Instead the exit message is sent to their regular
137
+ # mailbox in the form [:exit, actor, reason]. This allows certain
138
+ # Actors to supervise sets of others and restart them in the event
139
+ # of an error. Setting the trap flag may be interrupted by pending
140
+ # exit notifications.
141
+ #
142
+ def trap_exit=(value)
143
+ current._trap_exit = value
144
+ self
145
+ end
151
146
 
152
- # Lookup a locally named service
153
- def lookup(name)
154
- raise ArgumentError, "name must be a symbol" unless Symbol === name
155
- @@registered_lock.receive
156
- begin
157
- @@registered[name]
158
- ensure
159
- @@registered_lock << nil
147
+ # Is the Actor trapping exit?
148
+ def trap_exit
149
+ current._trap_exit
160
150
  end
161
- end
162
- alias_method :[], :lookup
151
+ alias_method :trap_exit?, :trap_exit
163
152
 
164
- # Register an Actor locally as a named service
165
- def register(name, actor)
166
- raise ArgumentError, "name must be a symbol" unless Symbol === name
167
- unless actor.nil? or actor.is_a?(Actor)
168
- raise ArgumentError, "only actors may be registered"
153
+ # Lookup a locally named service
154
+ def lookup(name)
155
+ raise ArgumentError, "name must be a symbol" unless Symbol === name
156
+ @@registered_lock.receive
157
+ begin
158
+ @@registered[name]
159
+ ensure
160
+ @@registered_lock << nil
161
+ end
169
162
  end
163
+ alias_method :[], :lookup
170
164
 
171
- @@registered_lock.receive
172
- begin
173
- if actor.nil?
174
- @@registered.delete(name)
175
- else
176
- @@registered[name] = actor
165
+ # Register an Actor locally as a named service
166
+ def register(name, actor)
167
+ raise ArgumentError, "name must be a symbol" unless Symbol === name
168
+ unless actor.nil? or actor.is_a?(Actor)
169
+ raise ArgumentError, "only actors may be registered"
170
+ end
171
+
172
+ @@registered_lock.receive
173
+ begin
174
+ if actor.nil?
175
+ @@registered.delete(name)
176
+ else
177
+ @@registered[name] = actor
178
+ end
179
+ ensure
180
+ @@registered_lock << nil
177
181
  end
178
- ensure
179
- @@registered_lock << nil
180
182
  end
181
- end
182
- alias_method :[]=, :register
183
+ alias_method :[]=, :register
183
184
 
184
- def _unregister(actor) #:nodoc:
185
- @@registered_lock.receive
186
- begin
187
- @@registered.delete_if { |n, a| actor.equal? a }
188
- ensure
189
- @@registered_lock << nil
185
+ def _unregister(actor) #:nodoc:
186
+ @@registered_lock.receive
187
+ begin
188
+ @@registered.delete_if { |n, a| actor.equal? a }
189
+ ensure
190
+ @@registered_lock << nil
191
+ end
190
192
  end
191
193
  end
192
- end
193
194
 
194
- def initialize
195
- @lock = Rubinius::Channel.new
195
+ def initialize
196
+ @lock = Rubinius::Channel.new
196
197
 
197
- @filter = nil
198
- @ready = Rubinius::Channel.new
199
- @action = nil
200
- @message = nil
198
+ @filter = nil
199
+ @ready = Rubinius::Channel.new
200
+ @action = nil
201
+ @message = nil
201
202
 
202
- @mailbox = []
203
- @interrupts = []
204
- @links = []
205
- @alive = true
206
- @exit_reason = nil
207
- @trap_exit = false
208
- @thread = Thread.current
203
+ @mailbox = []
204
+ @interrupts = []
205
+ @links = []
206
+ @alive = true
207
+ @exit_reason = nil
208
+ @trap_exit = false
209
+ @thread = Thread.current
209
210
 
210
- @lock << nil
211
+ @lock << nil
211
212
 
212
- if block_given?
213
- watchdog { yield self }
214
- else
215
- Thread.new { watchdog { @thread.join } }
213
+ if block_given?
214
+ watchdog { yield self }
215
+ else
216
+ Thread.new { watchdog { @thread.join } }
217
+ end
216
218
  end
217
- end
218
219
 
219
- def send(message)
220
- @lock.receive
221
- begin
222
- return self unless @alive
223
- if @filter
224
- @action = @filter.action_for(message)
225
- if @action
226
- @filter = nil
227
- @message = message
228
- @ready << nil
220
+ def send(message)
221
+ @lock.receive
222
+ begin
223
+ return self unless @alive
224
+ if @filter
225
+ @action = @filter.action_for(message)
226
+ if @action
227
+ @filter = nil
228
+ @message = message
229
+ @ready << nil
230
+ else
231
+ @mailbox << message
232
+ end
229
233
  else
230
234
  @mailbox << message
231
235
  end
232
- else
233
- @mailbox << message
236
+ ensure
237
+ @lock << nil
234
238
  end
235
- ensure
236
- @lock << nil
239
+ self
237
240
  end
238
- self
239
- end
240
- alias_method :<<, :send
241
-
242
- def _check_for_interrupt #:nodoc:
243
- check_thread
244
- @lock.receive
245
- begin
246
- raise @interrupts.shift unless @interrupts.empty?
247
- ensure
248
- @lock << nil
241
+ alias_method :<<, :send
242
+
243
+ def _check_for_interrupt #:nodoc:
244
+ check_thread
245
+ @lock.receive
246
+ begin
247
+ raise @interrupts.shift unless @interrupts.empty?
248
+ ensure
249
+ @lock << nil
250
+ end
249
251
  end
250
- end
251
252
 
252
- def _receive(filter) #:nodoc:
253
- check_thread
253
+ def _receive(filter) #:nodoc:
254
+ check_thread
254
255
 
255
- action = nil
256
- message = nil
257
- timed_out = false
256
+ action = nil
257
+ message = nil
258
+ timed_out = false
258
259
 
259
- @lock.receive
260
- begin
261
- raise @interrupts.shift unless @interrupts.empty?
260
+ @lock.receive
261
+ begin
262
+ raise @interrupts.shift unless @interrupts.empty?
262
263
 
263
- for i in 0...(@mailbox.size)
264
- message = @mailbox[i]
265
- action = filter.action_for(message)
266
- if action
267
- @mailbox.delete_at(i)
268
- break
264
+ for i in 0...(@mailbox.size)
265
+ message = @mailbox[i]
266
+ action = filter.action_for(message)
267
+ if action
268
+ @mailbox.delete_at(i)
269
+ break
270
+ end
269
271
  end
270
- end
271
272
 
272
- unless action
273
- @filter = filter
274
- @lock << nil
275
- begin
276
- if filter.timeout?
277
- timed_out = @ready.receive_timeout(filter.timeout) == false
278
- else
279
- @ready.receive
273
+ unless action
274
+ @filter = filter
275
+ @lock << nil
276
+ begin
277
+ if filter.timeout?
278
+ timed_out = @ready.receive_timeout(filter.timeout) == false
279
+ else
280
+ @ready.receive
281
+ end
282
+ ensure
283
+ @lock.receive
280
284
  end
281
- ensure
282
- @lock.receive
283
- end
284
285
 
285
- if !timed_out and @interrupts.empty?
286
- action = @action
287
- message = @message
288
- else
289
- @mailbox << @message if @action
290
- end
286
+ if !timed_out and @interrupts.empty?
287
+ action = @action
288
+ message = @message
289
+ else
290
+ @mailbox << @message if @action
291
+ end
291
292
 
292
- @action = nil
293
- @message = nil
293
+ @action = nil
294
+ @message = nil
294
295
 
295
- raise @interrupts.shift unless @interrupts.empty?
296
+ raise @interrupts.shift unless @interrupts.empty?
297
+ end
298
+ ensure
299
+ @lock << nil
296
300
  end
297
- ensure
298
- @lock << nil
299
- end
300
301
 
301
- if timed_out
302
- filter.timeout_action.call
303
- else
304
- action.call message
302
+ if timed_out
303
+ filter.timeout_action.call
304
+ else
305
+ action.call message
306
+ end
305
307
  end
306
- end
307
308
 
308
- # Notify this actor that it's now linked to the given one; this is not
309
- # intended to be used directly except by actor implementations. Most
310
- # users will want to use Actor.link instead.
311
- #
312
- def notify_link(actor)
313
- @lock.receive
314
- alive = nil
315
- exit_reason = nil
316
- begin
317
- alive = @alive
318
- exit_reason = @exit_reason
319
- @links << actor if alive and not @links.include? actor
320
- ensure
321
- @lock << nil
309
+ # Notify this actor that it's now linked to the given one; this is not
310
+ # intended to be used directly except by actor implementations. Most
311
+ # users will want to use Actor.link instead.
312
+ #
313
+ def notify_link(actor)
314
+ @lock.receive
315
+ alive = nil
316
+ exit_reason = nil
317
+ begin
318
+ alive = @alive
319
+ exit_reason = @exit_reason
320
+ @links << actor if alive and not @links.include? actor
321
+ ensure
322
+ @lock << nil
323
+ end
324
+ actor.notify_exited(self, exit_reason) unless alive
325
+ self
322
326
  end
323
- actor.notify_exited(self, exit_reason) unless alive
324
- self
325
- end
326
327
 
327
- # Notify this actor that it's now unlinked from the given one; this is
328
- # not intended to be used directly except by actor implementations. Most
329
- # users will want to use Actor.unlink instead.
330
- #
331
- def notify_unlink(actor)
332
- @lock.receive
333
- begin
334
- return self unless @alive
335
- @links.delete(actor)
336
- ensure
337
- @lock << nil
328
+ # Notify this actor that it's now unlinked from the given one; this is
329
+ # not intended to be used directly except by actor implementations. Most
330
+ # users will want to use Actor.unlink instead.
331
+ #
332
+ def notify_unlink(actor)
333
+ @lock.receive
334
+ begin
335
+ return self unless @alive
336
+ @links.delete(actor)
337
+ ensure
338
+ @lock << nil
339
+ end
340
+ self
338
341
  end
339
- self
340
- end
341
342
 
342
- # Notify this actor that one of the Actors it's linked to has exited;
343
- # this is not intended to be used directly except by actor implementations.
344
- # Most users will want to use Actor.send_exit instead.
345
- #
346
- def notify_exited(actor, reason)
347
- to_send = nil
348
- @lock.receive
349
- begin
350
- return self unless @alive
351
- @links.delete(actor)
352
- ex = DeadActorError.new(actor, reason)
353
- if @trap_exit
354
- to_send = ex
355
- elsif reason
356
- @interrupts << ex
357
- if @filter
358
- @filter = nil
359
- @ready << nil
343
+ # Notify this actor that one of the Actors it's linked to has exited;
344
+ # this is not intended to be used directly except by actor implementations.
345
+ # Most users will want to use Actor.send_exit instead.
346
+ #
347
+ def notify_exited(actor, reason)
348
+ to_send = nil
349
+ @lock.receive
350
+ begin
351
+ return self unless @alive
352
+ @links.delete(actor)
353
+ ex = DeadActorError.new(actor, reason)
354
+ if @trap_exit
355
+ to_send = ex
356
+ elsif reason
357
+ @interrupts << ex
358
+ if @filter
359
+ @filter = nil
360
+ @ready << nil
361
+ end
360
362
  end
363
+ ensure
364
+ @lock << nil
361
365
  end
362
- ensure
363
- @lock << nil
366
+ send to_send if to_send
367
+ self
364
368
  end
365
- send to_send if to_send
366
- self
367
- end
368
369
 
369
- def watchdog
370
- reason = nil
371
- begin
372
- yield
373
- rescue Exception => reason
374
- ensure
375
- links = nil
376
- Actor._unregister(self)
377
- @lock.receive
370
+ def watchdog
371
+ reason = nil
378
372
  begin
379
- @alive = false
380
- @mailbox = nil
381
- @interrupts = nil
382
- @exit_reason = reason
383
- links = @links
384
- @links = nil
373
+ yield
374
+ rescue Exception => reason
385
375
  ensure
386
- @lock << nil
387
- end
388
- links.each do |actor|
376
+ links = nil
377
+ Actor._unregister(self)
378
+ @lock.receive
389
379
  begin
390
- actor.notify_exited(self, reason)
391
- rescue Exception
380
+ @alive = false
381
+ @mailbox = nil
382
+ @interrupts = nil
383
+ @exit_reason = reason
384
+ links = @links
385
+ @links = nil
386
+ ensure
387
+ @lock << nil
388
+ end
389
+ links.each do |actor|
390
+ begin
391
+ actor.notify_exited(self, reason)
392
+ rescue Exception
393
+ end
392
394
  end
393
395
  end
394
396
  end
395
- end
396
- private :watchdog
397
+ private :watchdog
397
398
 
398
- def check_thread
399
- unless Thread.current == @thread
400
- raise ThreadError, "illegal cross-actor call"
399
+ def check_thread
400
+ unless Thread.current == @thread
401
+ raise ThreadError, "illegal cross-actor call"
402
+ end
401
403
  end
402
- end
403
- private :check_thread
404
+ private :check_thread
404
405
 
405
- def _trap_exit=(value) #:nodoc:
406
- check_thread
407
- @lock.receive
408
- begin
409
- raise @interrupts.shift unless @interrupts.empty?
410
- @trap_exit = !!value
411
- ensure
412
- @lock << nil
406
+ def _trap_exit=(value) #:nodoc:
407
+ check_thread
408
+ @lock.receive
409
+ begin
410
+ raise @interrupts.shift unless @interrupts.empty?
411
+ @trap_exit = !!value
412
+ ensure
413
+ @lock << nil
414
+ end
413
415
  end
414
- end
415
416
 
416
- def _trap_exit #:nodoc:
417
- check_thread
418
- @lock.receive
419
- begin
420
- @trap_exit
421
- ensure
422
- @lock << nil
417
+ def _trap_exit #:nodoc:
418
+ check_thread
419
+ @lock.receive
420
+ begin
421
+ @trap_exit
422
+ ensure
423
+ @lock << nil
424
+ end
423
425
  end
424
426
  end
425
427
  end
@@ -2,12 +2,12 @@
2
2
 
3
3
  Gem::Specification.new do |s|
4
4
  s.name = %q{rubinius-actor}
5
- s.version = "0.0.1"
5
+ s.version = "0.0.2"
6
6
  s.authors = ["Evan Phoenix", "MenTaLguY"]
7
7
  s.date = Time.now
8
8
  s.description = "Rubinius's Actor implementation"
9
9
  s.email = ["evan@fallingsnow.net", "mental@rydia.net"]
10
- s.files = Dir['{lib}/**/*'] + Dir['{*.txt,*.gemspec,Rakefile}']
10
+ s.files = Dir['{lib,examples}/**/*'] + Dir['{*.txt,*.gemspec,Rakefile}']
11
11
  s.homepage = "http://github.com/rubinius/rubinius-actor"
12
12
  s.require_paths = ["lib"]
13
13
  s.summary = "Rubinius's Actor implementation"
metadata CHANGED
@@ -1,41 +1,34 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: rubinius-actor
3
3
  version: !ruby/object:Gem::Version
4
- hash: 29
5
4
  prerelease:
6
- segments:
7
- - 0
8
- - 0
9
- - 1
10
- version: 0.0.1
5
+ version: 0.0.2
11
6
  platform: ruby
12
7
  authors:
13
- - Evan Phoenix
14
- - MenTaLguY
8
+ - Evan Phoenix
9
+ - MenTaLguY
15
10
  autorequire:
16
11
  bindir: bin
17
12
  cert_chain: []
18
13
 
19
- date: 2011-06-16 00:00:00 Z
14
+ date: 2011-06-16 00:00:00 -05:00
15
+ default_executable:
20
16
  dependencies:
21
- - !ruby/object:Gem::Dependency
22
- name: rubinius-core-api
23
- prerelease: false
24
- requirement: &id001 !ruby/object:Gem::Requirement
25
- none: false
26
- requirements:
27
- - - ">="
28
- - !ruby/object:Gem::Version
29
- hash: 3
30
- segments:
31
- - 0
32
- version: "0"
33
- type: :runtime
34
- version_requirements: *id001
17
+ - !ruby/object:Gem::Dependency
18
+ name: rubinius-core-api
19
+ prerelease: false
20
+ requirement: &id001 !ruby/object:Gem::Requirement
21
+ none: false
22
+ requirements:
23
+ - - ">="
24
+ - !ruby/object:Gem::Version
25
+ version: "0"
26
+ type: :runtime
27
+ version_requirements: *id001
35
28
  description: Rubinius's Actor implementation
36
29
  email:
37
- - evan@fallingsnow.net
38
- - mental@rydia.net
30
+ - evan@fallingsnow.net
31
+ - mental@rydia.net
39
32
  executables: []
40
33
 
41
34
  extensions: []
@@ -43,10 +36,12 @@ extensions: []
43
36
  extra_rdoc_files: []
44
37
 
45
38
  files:
46
- - lib/rubinius/actor/filter.rb
47
- - lib/rubinius/actor.rb
48
- - README.txt
49
- - rubinius-actor.gemspec
39
+ - lib/rubinius/actor.rb
40
+ - lib/rubinius/actor/filter.rb
41
+ - examples/ten_workers.rb
42
+ - README.txt
43
+ - rubinius-actor.gemspec
44
+ has_rdoc: true
50
45
  homepage: http://github.com/rubinius/rubinius-actor
51
46
  licenses: []
52
47
 
@@ -54,29 +49,23 @@ post_install_message:
54
49
  rdoc_options: []
55
50
 
56
51
  require_paths:
57
- - lib
52
+ - lib
58
53
  required_ruby_version: !ruby/object:Gem::Requirement
59
54
  none: false
60
55
  requirements:
61
- - - ">="
62
- - !ruby/object:Gem::Version
63
- hash: 3
64
- segments:
65
- - 0
66
- version: "0"
56
+ - - ">="
57
+ - !ruby/object:Gem::Version
58
+ version: "0"
67
59
  required_rubygems_version: !ruby/object:Gem::Requirement
68
60
  none: false
69
61
  requirements:
70
- - - ">="
71
- - !ruby/object:Gem::Version
72
- hash: 3
73
- segments:
74
- - 0
75
- version: "0"
62
+ - - ">="
63
+ - !ruby/object:Gem::Version
64
+ version: "0"
76
65
  requirements: []
77
66
 
78
67
  rubyforge_project:
79
- rubygems_version: 1.8.5
68
+ rubygems_version: 1.5.1
80
69
  signing_key:
81
70
  specification_version: 3
82
71
  summary: Rubinius's Actor implementation