celluloid 0.7.0 → 0.7.1

data/README.md

@@ -65,37 +65,41 @@ Usage
 
 To use Celluloid, define a normal Ruby class that includes Celluloid:
 
-    require 'celluloid'
+```ruby
+require 'celluloid'
 
-    class Sheen
-      include Celluloid
+class Sheen
+  include Celluloid
 
-      def initialize(name)
-        @name = name
-      end
+  def initialize(name)
+    @name = name
+  end
 
-      def set_status(status)
-        @status = status
-      end
+  def set_status(status)
+    @status = status
+  end
 
-      def report
-        "#{@name} is #{@status}"
-      end
-    end
+  def report
+    "#{@name} is #{@status}"
+  end
+end
+```
 
 Now when you create new instances of this class, they're actually concurrent
 objects, each running in their own thread:
 
-    >> charlie = Sheen.new "Charlie Sheen"
-     => #<Celluloid::Actor(Sheen:0x00000100a312d0) @name="Charlie Sheen">
-    >> charlie.set_status "winning!"
-     => "winning!"
-    >> charlie.report
-     => "Charlie Sheen is winning!"
-    >> charlie.set_status! "asynchronously winning!"
-     => nil
-    >> charlie.report
-     => "Charlie Sheen is asynchronously winning!"
+```ruby
+>> charlie = Sheen.new "Charlie Sheen"
+ => #<Celluloid::Actor(Sheen:0x00000100a312d0) @name="Charlie Sheen">
+>> charlie.set_status "winning!"
+ => "winning!"
+>> charlie.report
+ => "Charlie Sheen is winning!"
+>> charlie.set_status! "asynchronously winning!"
+ => nil
+>> charlie.report
+ => "Charlie Sheen is asynchronously winning!"
+```
 
 You can call methods on this concurrent object just like you would any other
 Ruby object. The Sheen#set_status method works exactly like you'd expect,

data/lib/celluloid/actor.rb

@@ -116,7 +116,7 @@ module Celluloid
         begin
           message = @mailbox.receive(timeout)
         rescue ExitEvent => exit_event
-          Task.new(:exit_handler) { handle_exit_event exit_event; nil }.resume
+          Task.new(:exit_handler) { handle_exit_event exit_event }.resume
           retry
         end
 
@@ -161,11 +161,15 @@ module Celluloid
       # handing them the one we're using internally across threads, a definite
       # thread safety shared state no-no
       tasks = {}
-      current_task = Thread.current[:task]
+      current_task = Task.current rescue nil
       tasks[current_task] = :running if current_task
 
-      @signals.waiting.each do |waitable, task|
-        tasks[task] = waitable
+      @signals.waiting.each do |waitable, waiters|
+        if waiters.is_a? Enumerable
+          waiters.each { |waiter| tasks[waiter] = waitable }
+        else
+          tasks[waiters] = waitable
+        end
       end
 
       tasks
@@ -174,7 +178,7 @@ module Celluloid
     # Schedule a block to run at the given time
     def after(interval)
       @timers.add(interval) do
-        Task.new(:timer) { yield; nil }.resume
+        Task.new(:timer) { yield }.resume
       end
     end
 
@@ -189,7 +193,7 @@ module Celluloid
     def handle_message(message)
       case message
       when Call
-        Task.new(:message_handler) { message.dispatch(@subject); nil }.resume
+        Task.new(:message_handler) { message.dispatch(@subject) }.resume
       when Response
         handled_successfully = signal [:call, message.call_id], message
 
@@ -226,6 +230,7 @@ module Celluloid
     def cleanup(exit_event)
       @mailbox.shutdown
       @links.send_event exit_event
+      tasks.each { |task, _| task.terminate }
 
       begin
         @subject.finalize if @subject.respond_to? :finalize

data/lib/celluloid/core_ext.rb

@@ -1,3 +1,5 @@
+require 'celluloid/fiber'
+
 # Monkeypatch Thread to allow lazy access to its Celluloid::Mailbox
 class Thread
   # Retrieve the mailbox for the current thread or lazily initialize it
@@ -5,3 +7,8 @@ class Thread
     current[:mailbox] ||= Celluloid::Mailbox.new
   end
 end
+
+class Fiber
+  # Celluloid::Task associated with this Fiber
+  attr_accessor :task
+end

data/lib/celluloid/future.rb

@@ -37,6 +37,8 @@ module Celluloid
 
       def initialize(*args, &block)
         @args, @block = args, block
+        @called = nil
+        @error = nil
       end
 
       def run

data/lib/celluloid/signals.rb

@@ -7,10 +7,19 @@ module Celluloid
       @waiting = {}
     end
 
-    # Wait for the given signal name and return the associated value
-    def wait(name)
-      tasks = @waiting[name] ||= []
-      tasks << Task.current
+    # Wait for the given signal and return the associated value
+    def wait(signal)
+      tasks = @waiting[signal]
+
+      case tasks
+      when Array
+        tasks << Task.current
+      when NilClass
+        @waiting[signal] = Task.current
+      else
+        @waiting[signal] = [tasks, Task.current]
+      end
+
       Task.suspend
     end
 
@@ -18,10 +27,24 @@ module Celluloid
     # Returns true if any calls were signaled, or false otherwise
     def send(name, value = nil)
       tasks = @waiting.delete name
-      return unless tasks
 
-      tasks.each { |task| task.resume(value) if task.running? }
+      case tasks
+      when Array
+        tasks.each { |task| run_task task, value }
+      when NilClass
+        Logger.debug("spurious signal: #{name}")
+      else
+        run_task tasks, value
+      end
+
       value
     end
+
+    # Run the given task, reporting errors that occur
+    def run_task(task, value)
+      task.resume(value)
+    rescue => ex
+      Celluloid::Logger.crash("signaling error", ex)
+    end
   end
 end

data/lib/celluloid/task.rb

@@ -4,18 +4,22 @@ module Celluloid
 
   # Tasks are interruptable/resumable execution contexts used to run methods
   class Task
+    class TerminatedError < StandardError; end # kill a running fiber
+
     attr_reader :type # what type of task is this?
 
     # Obtain the current task
     def self.current
-      task = Thread.current[:task]
+      task = Fiber.current.task
       raise "not in task scope" unless task
       task
     end
 
     # Suspend the running task, deferring to the scheduler
     def self.suspend(value = nil)
-      Fiber.yield(value)
+      result = Fiber.yield(value)
+      raise TerminatedError, "task was terminated" if result == TerminatedError
+      result
     end
 
     # Run the given block within a task
@@ -28,9 +32,14 @@ module Celluloid
       @fiber = Fiber.new do
         Thread.current[:actor]   = actor
         Thread.current[:mailbox] = mailbox
-        Thread.current[:task]    = self
 
-        yield
+        Fiber.current.task = self
+
+        begin
+          yield
+        rescue TerminatedError
+          # Task was explicitly terminated
+        end
       end
     end
 
@@ -40,6 +49,17 @@ module Celluloid
       nil
     rescue FiberError
       raise DeadTaskError, "cannot resume a dead task"
+    rescue RuntimeError => ex
+      # These occur spuriously on 1.9.3 if we shut down an actor with running tasks
+      return if ex.message == ""
+      raise
+    end
+
+    # Terminate this task
+    def terminate
+      resume TerminatedError
+    rescue FiberError
+      # If we're getting this the task should already be dead
     end
 
     # Is the current task still running?

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -253,44 +253,62 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @signaler = Class.new do
         include included_module
-        attr_reader :signaled
 
         def initialize
+          @waiting  = false
           @signaled = false
         end
 
         def wait_for_signal
+          raise "already signaled" if @signaled
+
+          @waiting = true
+          signal :future
+
           value = wait :ponycopter
+
+          @waiting = false
           @signaled = true
           value
         end
 
+        def wait_for_future
+          return true if @waiting
+          wait :future
+        end
+
         def send_signal(value)
           signal :ponycopter, value
         end
+
+        def waiting?; @waiting end
+        def signaled?; @signaled end
       end
     end
 
     it "allows methods within the same object to signal each other" do
       obj = @signaler.new
-      obj.signaled.should be_false
+      obj.should_not be_signaled
 
       obj.wait_for_signal!
-      obj.signaled.should be_false
+      obj.should_not be_signaled
 
       obj.send_signal :foobar
-      obj.signaled.should be_true
+      obj.should be_signaled
     end
 
     # FIXME: This is deadlocking on Travis, and may still have issues
-    it "sends values along with signals", :pending => ENV['CI'] do
+    it "sends values along with signals" do
       obj = @signaler.new
-      obj.signaled.should be_false
+      obj.should_not be_signaled
 
-      future = Celluloid::Future.new { obj.wait_for_signal }
-      obj.signaled.should be_false
+      future = obj.future(:wait_for_signal)
 
-      obj.send_signal :foobar
+      obj.wait_for_future
+      obj.should be_waiting
+      obj.should_not be_signaled
+
+      obj.send_signal(:foobar).should be_true
       future.value.should == :foobar
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-29 00:00:00.000000000 Z
+date: 2012-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70176959879340 !ruby/object:Gem::Requirement
+  requirement: &70351782537080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176959879340
+  version_requirements: *70351782537080
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70176959878380 !ruby/object:Gem::Requirement
+  requirement: &70351782536080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: 2.7.0
   type: :development
   prerelease: false
-  version_requirements: *70176959878380
+  version_requirements: *70351782536080
 description: Celluloid is a concurrent object framework inspired by the Actor Model
 email:
 - tony@medioh.com
@@ -93,3 +93,4 @@ signing_key:
 specification_version: 3
 summary: Celluloid is a concurrent object framework inspired by the Actor Model
 test_files: []
+has_rdoc: