celluloid 0.6.2 → 0.7.0

data/spec/support/mailbox_examples.rb

@@ -0,0 +1,52 @@
+shared_context "a Celluloid Mailbox" do
+  class TestEvent < Celluloid::SystemEvent; end
+
+  it "receives messages" do
+    message = :ohai
+
+    subject << message
+    subject.receive.should == message
+  end
+
+  it "raises system events when received" do
+    subject.system_event TestEvent.new("example")
+
+    expect do
+      subject.receive
+    end.to raise_exception(TestEvent)
+  end
+
+  it "prioritizes system events over other messages" do
+    subject << :dummy1
+    subject << :dummy2
+    subject.system_event TestEvent.new("example")
+
+    expect do
+      subject.receive
+    end.to raise_exception(TestEvent)
+  end
+
+  it "selectively receives messages with a block" do
+    class Foo; end
+    class Bar; end
+    class Baz; end
+
+    foo, bar, baz = Foo.new, Bar.new, Baz.new
+
+    subject << baz
+    subject << foo
+    subject << bar
+
+    subject.receive { |msg| msg.is_a? Foo }.should == foo
+    subject.receive { |msg| msg.is_a? Bar }.should == bar
+    subject.receive.should == baz
+  end
+
+  it "waits for a given timeout interval" do
+    interval = 0.1
+    started_at = Time.now
+
+    subject.receive(interval) { false }
+    (Time.now - started_at).should be_within(Celluloid::Timer::QUANTUM).of interval
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-30 00:00:00.000000000 Z
+date: 2011-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70122472224600 !ruby/object:Gem::Requirement
+  requirement: &70176959879340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70122472224600
+  version_requirements: *70176959879340
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70122472224020 !ruby/object:Gem::Requirement
+  requirement: &70176959878380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: 2.7.0
   type: :development
   prerelease: false
-  version_requirements: *70122472224020
+  version_requirements: *70176959878380
 description: Celluloid is a concurrent object framework inspired by the Actor Model
 email:
 - tony@medioh.com
@@ -49,11 +49,8 @@ files:
 - lib/celluloid/core_ext.rb
 - lib/celluloid/events.rb
 - lib/celluloid/fiber.rb
+- lib/celluloid/fsm.rb
 - lib/celluloid/future.rb
-- lib/celluloid/io/mailbox.rb
-- lib/celluloid/io/reactor.rb
-- lib/celluloid/io/waker.rb
-- lib/celluloid/io.rb
 - lib/celluloid/links.rb
 - lib/celluloid/logger.rb
 - lib/celluloid/mailbox.rb
@@ -63,9 +60,13 @@ files:
 - lib/celluloid/rspec.rb
 - lib/celluloid/signals.rb
 - lib/celluloid/supervisor.rb
+- lib/celluloid/task.rb
 - lib/celluloid/tcp_server.rb
+- lib/celluloid/timers.rb
 - lib/celluloid/version.rb
 - lib/celluloid.rb
+- spec/support/actor_examples.rb
+- spec/support/mailbox_examples.rb
 homepage: https://github.com/tarcieri/celluloid
 licenses:
 - MIT
@@ -92,4 +93,3 @@ signing_key:
 specification_version: 3
 summary: Celluloid is a concurrent object framework inspired by the Actor Model
 test_files: []
-has_rdoc: 

data/lib/celluloid/io.rb

@@ -1,24 +0,0 @@
-require 'celluloid/io/waker'
-require 'celluloid/io/reactor'
-require 'celluloid/io/mailbox'
-
-module Celluloid
-  # Actors which can run alongside other I/O operations
-  module IO
-    def self.included(klass)
-      klass.send :include, ::Celluloid
-      klass.use_mailbox Celluloid::IO::Mailbox
-    end
-
-    # Wait for the given IO object to become readable
-    def wait_readable(io, &block)
-      # Law of demeter be damned!
-      current_actor.mailbox.reactor.wait_readable(io, &block)
-    end
-
-    # Wait for the given IO object to become writeable
-    def wait_writeable(io, &block)
-      current_actor.mailbox.reactor.wait_writeable(io, &block)
-    end
-  end
-end

data/lib/celluloid/io/mailbox.rb

@@ -1,65 +0,0 @@
-require 'thread'
-
-module Celluloid
-  module IO
-    # An alternative implementation of Celluloid::Mailbox using Wakers
-    class Mailbox < Celluloid::Mailbox
-      attr_reader :reactor, :waker
-
-      def initialize
-        @messages = []
-        @lock  = Mutex.new
-        @waker = Waker.new
-        @reactor = Reactor.new(@waker)
-      end
-
-      # Add a message to the Mailbox
-      def <<(message)
-        @lock.synchronize do
-          @messages << message
-          @waker.signal
-        end
-        nil
-      rescue DeadWakerError
-        raise MailboxError, "dead recipient"
-      end
-
-      # Add a high-priority system event to the Mailbox
-      def system_event(event)
-        @lock.synchronize do
-          @messages.unshift event
-
-          begin
-            @waker.signal
-          rescue DeadWakerError
-            # Silently fail if messages are sent to dead actors
-          end
-        end
-        nil
-      end
-
-      # Receive a message from the Mailbox
-      def receive(&block)
-        message = nil
-
-        begin
-          @reactor.run_once do
-            @waker.wait
-            message = next_message(&block)
-          end
-        end until message
-
-        message
-      rescue IOError, DeadWakerError
-        shutdown # force shutdown of the mailbox
-        raise MailboxShutdown, "mailbox shutdown called during receive"
-      end
-
-      # Cleanup any IO objects this Mailbox may be using
-      def shutdown
-        @waker.cleanup
-        super
-      end
-    end
-  end
-end

data/lib/celluloid/io/reactor.rb

@@ -1,63 +0,0 @@
-module Celluloid
-  module IO
-    # React to external I/O events. This is kinda sorta supposed to resemble the
-    # Reactor design pattern.
-    class Reactor
-      def initialize(waker)
-        @waker = waker
-        @readers = {}
-        @writers = {}
-      end
-
-      # Wait for the given IO object to become readable
-      def wait_readable(io)
-        monitor_io io, @readers
-        Fiber.yield
-        block_given? ? yield(io) : io
-      end
-
-      # Wait for the given IO object to become writeable
-      def wait_writeable(io)
-        monitor_io io, @writers
-        Fiber.yield
-        block_given? ? yield(io) : io
-      end
-
-      # Run the reactor, waiting for events, and calling the given block if
-      # the reactor is awoken by the waker
-      def run_once
-        readers, writers = select @readers.keys << @waker.io, @writers.keys
-        yield if readers.include? @waker.io
-
-        [[readers, @readers], [writers, @writers]].each do |ios, registered|
-          ios.each do |io|
-            fiber = registered.delete io
-            fiber.resume if fiber
-          end
-        end
-      end
-
-      #######
-      private
-      #######
-
-      def monitor_io(io, set)
-        # zomg ugly type conversion :(
-        unless io.is_a?(IO)
-          if IO.respond_to? :try_convert
-            io = IO.try_convert(io)
-          elsif io.respond_to? :to_io
-            io = io.to_io
-          else raise TypeError, "can't convert #{io.class} into IO"
-          end
-        end
-
-        if set.has_key? io
-          raise ArgumentError, "another method is already waiting on #{io.inspect}"
-        else
-          set[io] = Fiber.current
-        end
-      end
-    end
-  end
-end

data/lib/celluloid/io/waker.rb

@@ -1,43 +0,0 @@
-module Celluloid
-  module IO
-    class DeadWakerError < StandardError; end # You can't wake the dead
-
-    # Wakes up sleepy threads so that they can check their mailbox
-    # Works like a ConditionVariable, except it's implemented as an IO object so
-    # that it can be multiplexed alongside other IO objects.
-    class Waker
-      PAYLOAD = "\0" # the payload doesn't matter. each byte is a signal
-      def initialize
-        @receiver, @sender = ::IO.pipe
-      end
-
-      # Wakes up the thread that is waiting for this Waker
-      def signal
-        @sender << PAYLOAD
-        nil
-      rescue IOError, Errno::EPIPE, Errno::EBADF
-        raise DeadWakerError, "waker is already dead"
-      end
-
-      # Wait for another thread to signal this Waker
-      def wait
-          byte = @receiver.read(1)
-          raise DeadWakerError, "can't wait on a dead waker" unless byte == PAYLOAD
-      rescue IOError, RuntimeError
-          raise DeadWakerError, "can't wait on a dead waker"
-      end
-
-      # Return the IO object which will be readable when this Waker is signaled
-      def io
-        @receiver
-      end
-
-      # Clean up the IO objects associated with this waker
-      def cleanup
-        @receiver.close rescue nil
-        @sender.close rescue nil
-        nil
-      end
-    end
-  end
-end