thespian 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+doc
+vendor/bundle
+doc
+.rbenv-version
+.DS_Store

data/CHANGELOG

@@ -0,0 +1,2 @@
+0.0.1
+	* Initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in thesp.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,178 @@
+== Thespian
+
+Implementation of the actor pattern built on threads.
+
+== Quickstart
+
+Dive in...
+
+  actor1 = Thespian::Actor.new do |message|
+    sleep(message) # Simulate work
+    puts "Actor1 worked for #{message} seconds"
+  end
+
+  actor2 = Thespian::Actor.new do |message|
+    sleep(message) # Simulate work
+    puts "Actor2 worked for #{message} seconds"
+  end
+
+  actor1.start
+  actor2.start
+
+  10.times{ actor1 << rand }
+  10.times{ actor2 << rand }
+
+  actor1.stop
+  actor2.stop
+
+Unlike other actor APIs, Thespian assumes you want your actor to loop forever, processing messages
+until it's told to stop.  Thus when you create an actor, all you have to do is specify how 
+to processes messages.
+
+  actor = Thespian::Actor.new do |message|
+    # ... handle message ...
+  end
+
+An actor won't start processing messages until the Thespian::Actor#start method is called.
+
+  actor.start
+
+Also, you cannot put messages into an actor's mailbox unless it is currently running.
+
+  actor << some_message # Will raise an exception if the actor isn't running
+
+You can change this behavior by changing the actor's strict option.
+
+  actor.options(:strict => false)
+
+Now you can add messages to the actor's mailbox, even if it's not running.
+
+== States
+
+An actor can be in one of three states:  +:initialized+, +:running+ or +:finished+
+
++:initialized+ is when the actor has been created, but Thespian::Actor#start hasn't been called (it's not
+in the message processing loop yet).
+
++:running+ is when #start has been called and it's processing (or waiting on) messaegs.
+
++:finished+ is when the actor is no longer processing messages (it was either instructed to stop or
+an error occurred).
+
+  actor = Thespian::Actor.new{ ... }
+  actor.state # => :initialized
+
+== Error handling
+
+What happens if an actor causes an unhandled exception while processing a message?  The actor's
+state will be set to +:finished+, Thespian::Actor#error? will return true and subsequent calls to
+various methods will cause the exception to be raised in the calling thread.
+
+  actor = Thespian::Actor.new do |message|
+    raise "oops"
+  end
+
+  actor.start
+  actor << 1
+  sleep(0.01)
+  actor.error?    # => true
+  actor.exception # #<RuntimeError: oops>
+  actor << 2      # raises #<RuntimeError: oops>
+
+== Linking
+
+You can link actors together so that if an error occurs in one, it will trickle up to all that
+are linked to it.
+
+
+  actor1 = Thespian::Actor.new do |message|
+    puts message.inspect
+  end
+
+  actor2 = Thespian::Actor.new do |message|
+    raise "oops"
+  end
+
+  actor1.link(actor2)
+  actor1.start
+  actor2.start
+
+  actor2 << "blah"
+  sleep(0.01)
+
+  actor1.error?    # => true
+  actor1.exception # => #<Thespian::DeadActorError: oops>
+
+Thespian::DeadActorError contains information about which actor died and the exception that caused it.
+
+== Trapping linked errors
+
+If you specify the +:trap_exit+ option, then instead of raising a Thespian::DeadActorError in the linked
+actor, it will be put in the actor's mailbox instead.
+
+  actor1 = Thespian::Actor.new do |message|
+    puts message.inspect
+  end
+
+  actor2 = Thespian::Actor.new do |message|
+    raise "oops"
+  end
+
+  actor1.options(:trap_exit => true)
+  actor1.link(actor2)
+  actor1.start
+  actor2.start
+
+  actor2 << "blah"
+  sleep(0.01)
+
+  actor1.error?    # => false
+  actor1.exception # => nil
+
+This will print <tt>#<Thespian::DeadActorError: oops></tt> to stdout.
+
+== Classes
+
+You can use Thespian with classes by including the Thespian module into them.
+
+  class ArnoldSchwarzenegger
+    include Thespian
+
+    actor.receive do |message|
+      handle_message(message)
+    end
+
+    def handle_message(message)
+      puts message
+    end
+  end
+
+  arnold = ArnoldSchwarzenegger.new
+  arnold.actor.start
+  arnold.actor << "I'm a cop, you idiot!"
+  arnold.actor.stop
+
+The block given to +actor.receive+ on the class is exactly the same as the block given to
+Thespian::Actor.new except that it is run in the context of an instance of the class (meaning it
+can call instance methods).
+
++actor+ on the instance returns a special instance of Thespian::Actor, that is aware of its relationship
+to it's parent object.
+
+What does that mean?  Nothing really.  The only difference is that Thespian::DeadActorError#actor
+will return an instance of ArnoldSchwarzenegger instead of an instance of Thespian::Actor.
+
+== RDoc
+
+{\http://doc.stochasticbytes.com/thespian/index.html}[http://doc.stochasticbytes.com/thespian/index.html]
+
+== Examples
+
+A simple producer/consumer example.
+{\https://github.com/cjbottaro/thespian/blob/master/examples/producer_consumer.rb}[https://github.com/cjbottaro/thespian/blob/master/examples/producer_consumer.rb]
+
+An example where one actor links to another.
+{\https://github.com/cjbottaro/thespian/blob/master/examples/linked.rb}[https://github.com/cjbottaro/thespian/blob/master/examples/linked.rb]
+
+A complex example showing how a background job/task processor could be architected.
+{\https://github.com/cjbottaro/thespian/blob/master/examples/task_processor.rb}[https://github.com/cjbottaro/thespian/blob/master/examples/task_processor.rb]

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/linked.rb

@@ -0,0 +1,39 @@
+require "thespian"
+
+producer = nil
+consumer = nil
+n = 0
+
+producer = Thespian::Actor.new do |message|
+  case message
+  when :need_item
+    if (n += 1) < 10
+      consumer << rand
+    else
+      consumer << "bad message"
+    end
+  else
+    raise "unexpected message: #{message}"
+  end
+end
+
+consumer = Thespian::Actor.new do |message|
+  case message
+  when Float
+    puts "consumer got #{message}"
+    producer << :need_item
+  else
+    raise "I can only work with numbers!"
+  end
+end
+
+producer.link(consumer)
+producer.start
+consumer.start
+producer << :need_item
+Thread.pass while consumer.running?
+puts consumer.finished?  # True
+puts consumer.error?     # True
+puts producer.finished?  # True because it's linked to the consumer
+puts producer.error?     # True because it's linked to the consumer
+puts producer.exception

data/examples/producer_consumer.rb

@@ -0,0 +1,24 @@
+require "thespian"
+
+producer = nil
+consumer = nil
+
+producer = Thespian::Actor.new do |message|
+  case message
+  when :need_item
+    consumer << rand
+  else
+    raise "unexpected message: #{message}"
+  end
+end
+
+consumer = Thespian::Actor.new do |message|
+  sleep(message)
+  puts "consumer got #{message}"
+  producer << :need_item
+end
+
+producer.start
+consumer.start
+producer << :need_item
+sleep

data/examples/task_processor.rb

@@ -0,0 +1,170 @@
+require "thespian"
+
+# The actors are Supervisor, Logger, Poller, Worker(s).  There is one of each except for multiple
+# workers.  The basic idea is that the supervisor can send messages to any other actor, but all
+# other actors can only send messages to the supervisor.  In other words the non-supervisor actors
+# cannot directly communicate with each other; they have to go through the supervisor.
+
+# This actor just sits and waits for log messages to print out.  It has a 10% chance of erroring
+# on each message it processes.
+class Logger
+  include Thespian
+
+  def initialize
+    actor.options(:strict => false)
+  end
+
+  actor.receive do |message|
+    if rand > 0.90
+      raise "logger oops"
+    else
+      puts message
+    end
+  end
+
+end
+
+# This actor is sent "work" messages.  When it's done with the work, it will send a message
+# with its id back to the supervisor saying that it's ready for more work.
+# It has a 10% chance of dying while processing a message.
+class Worker
+  include Thespian
+  attr_reader :id
+
+  def initialize(id, supervisor)
+    @id = id
+    @supervisor = supervisor
+    actor.start
+  end
+  
+  actor.receive do |message|
+    raise "oops worker" if rand > 0.90
+
+    cmd, *args = message
+
+    case cmd
+    when :work
+      time, = *args
+      sleep(time)
+      @supervisor.actor << [:log, "worker ##{id} worked for #{time.round(2)} seconds"]
+      @supervisor.actor << [:ready, @id]
+    end
+  end
+
+end
+
+# This actor is responsible for getting "work" for a worker to do.  The supervisor will
+# send it a "get work" message, once it's retreived the work (maybe from a queue if this
+# was in the real world), it will send it back to the supervisor as "task ready" message.
+class Poller
+  include Thespian
+
+  def initialize(supervisor)
+    actor.options :strict => false
+    @supervisor = supervisor
+  end
+
+  actor.receive do |cmd, *args|
+    raise "oops poller" if rand > 0.90
+    sleep(0.2)
+    case cmd
+    when :get
+      @supervisor.actor << [:task, rand]
+    end
+  end
+
+end
+
+# The supervisor is responsible for coordinating all the actors.  It's also responsible for
+# restarting any other actors that die (hence it needs to link to all of them).
+#
+# The basic idea is that the supervisor starts up each actor, then keeps a list of idle workers.
+# For each idle worker, it asks the poller for a task.  When the poller responds with a task,
+# it sends the task to the worker and removes the worker from the idle list.  When the worker
+# reports that it is finished, the worker is placed back in the idle list and the supervisor
+# asks the poller for another task.
+class Supervisor
+  include Thespian
+
+  def initialize(count)
+    @ready = []
+    actor.options(:trap_exit => true)
+    actor.start
+    initialize_logger
+    initialize_poller
+    count.times{ |id| initialize_worker(id) }
+  end
+
+  actor.receive do |message|
+    case message
+    when Thespian::DeadActorError
+      handle_dead_actor(message.actor)
+    when Array
+      cmd, *args = message
+      send("do_#{cmd}", *args)
+    end
+  end
+
+  def handle_dead_actor(actor)
+    case actor
+    when Logger
+      do_log("logger died, restarting")
+      initialize_logger
+    when Worker
+      do_log("worker(#{actor.id}) died, restarting")
+      initialize_worker(actor.id)
+    when Poller
+      do_log("poller died (#{@ready.length}, #{@poller.actor.instance_eval{ @mailbox }.length}), restarting")
+      initialize_poller
+    end
+  end
+
+  def do_log(message)
+    @logger.actor << message
+  end
+
+  def do_ready(id)
+    @ready << id
+    @poller.actor << [:get]
+  end
+
+  def do_task(arg)
+    id = @ready.shift
+    @workers[id].actor << [:work, arg]
+  end
+
+  def initialize_logger
+    if @logger
+      old_mailbox = @logger.actor.salvage_mailbox
+    end
+    @logger = Logger.new
+    actor.link(@logger)
+    if old_mailbox
+      old_mailbox.each{ |message| @logger.actor << message }
+    end
+    @logger.actor.start
+  end
+
+  def initialize_poller
+    @poller = Poller.new(self)
+    @ready.each{ @poller.actor << [:get] }
+    actor.link(@poller)
+    @poller.actor.start
+  end
+
+  def initialize_worker(id)
+    @workers ||= []
+    @workers[id] = Worker.new(id, self).tap do |worker|
+      @ready << id
+      actor.link(worker)
+      @poller.actor << [:get]
+    end
+  end
+
+end
+
+s = Supervisor.new(5)
+while true
+  raise s.actor.exception unless s.actor.running?
+  sleep(1)
+end

data/lib/thespian/actor.rb

@@ -0,0 +1,245 @@
+require "thread"
+require "monitor"
+require "set"
+
+require "thespian/errors"
+
+module Thespian
+  class Actor
+
+    # If an actor died due to an exception, it is stored here.
+    attr_reader :exception
+
+    # Returns the actor's state.
+    attr_reader :state
+
+    # The state an actor is in after it has been created, but before it enters the message processing loop.
+    STATE_INITIALIZED = :initialized
+
+    # The state for when an actor is in the message processing loop.
+    STATE_RUNNING = :running
+
+    # The state for when an actor has exited the message processing loop (either by error or intentially).
+    STATE_FINISHED = :finished
+
+    DEFAULT_OPTIONS = {
+      :strict    => true,
+      :trap_exit => false,
+      :object    => nil
+    } #:nodoc:
+
+    # call-seq:
+    #   new(options = {}){ |message| ... }
+    #
+    # Create a new actor using the given block to handles messages.  The actor will be in the +:initialized+
+    # state, meaning the message processing loop hasn't started yet (see #start).
+    #
+    # +options+ are the same as specified by #options.
+    def initialize(options = {}, &block)
+      self.options(DEFAULT_OPTIONS.merge(options))
+
+      @state         = :initialized
+      @receive_block = block
+      @linked_actors = Set.new
+
+      @mailbox = []
+      @mailbox_lock = Monitor.new
+      @mailbox_cond = @mailbox_lock.new_cond
+
+    end
+
+    # call-seq:
+    #   options -> Hash
+    #   options(hash) -> Hash
+    #   options(symbol) -> value
+    #
+    # Get or set options.  Valid options are:
+    # [:strict (default true)]
+    #   Require an actor to be running in order to put messages into its mailbox.
+    # [:trap_exit (default false)]
+    #   If true, the actor will get a DeadActorError message in its mailbox when a linked actor raises an unhandled exception.
+    #
+    # If given no arguments, returns a hash of options.
+    #
+    # If given a hash, sets the options specified in the hash.
+    #
+    # If given a symbol, returns that option's value.
+    def options(arg = nil)
+      @options ||= {}
+
+      case arg
+      when Hash
+        @options.merge!(arg)
+      when Symbol
+        @options[arg]
+      when nil
+        @options
+      end
+    end
+
+    # call-seq:
+    #   link(actor)
+    #
+    # Exceptions in actors will be propogated to actors that are linked to them.  How they are propogated is
+    # determined by the +:trap_exit+ option (see #options).
+    #
+    # +actor+ can either be an Actor instance or an instance of a class that included Thespian.
+    def link(object)
+      actor = object.kind_of?(Actor) ? object : object.actor
+      actor.send(:_link, self)
+      object
+    end
+
+    # Start the actor's message processing loop.
+    # The thread that the loop is run on is guaranteed to have started by the time this method returns.
+    def start
+
+      # Don't let them start an already started actor.
+      raise "already running" if running?
+
+      # Can't raise an actor from the dead.
+      raise @exception if @exception
+
+      # IMPORTANT - Race condition!
+      # This method and the thread both set @state. We don't want this method to
+      # possibly overwrite how the thread sets @state, so we set the @state
+      # before staring the thread.
+      @state = :running
+
+      # Declare local synchronization vars.
+      lock = Monitor.new
+      cond = lock.new_cond
+      wait = true
+
+       # Start the thread and have it signal when it's running.
+      @thread = Thread.new do
+        Thread.current[:actor] = options(:object).to_s
+        lock.synchronize do
+          wait = false
+          cond.signal
+        end
+        run
+      end
+
+      # Block until the thread has signaled that it's running.
+      lock.synchronize do
+        cond.wait_while{ wait }
+      end
+    end
+
+    # Add a message to the actor's mailbox.
+    # May raise an exception according to #check_alive!
+    def <<(message)
+      check_alive! if options(:strict)
+      message = message.new if message == Stop
+      @mailbox_lock.synchronize do
+        @mailbox << message
+        @mailbox_cond.signal
+      end
+      self
+    end
+
+    # Stop the actor.
+    # All pending messages will be processed before stopping the actor.
+    # Raises an exception if the actor is not #running? and +:strict+ (see #options) is true.
+    def stop
+      check_alive! if options(:strict)
+      self << Stop.new
+      @thread.join
+      raise @exception if @exception
+    end
+
+    # #state == :initialized
+    def initialized?
+      state == :initialized
+    end
+
+    # #state == :running
+    def running?
+      state == :running
+    end
+
+    # #state == :finished
+    def finished?
+      state == :finished
+    end
+
+    # Returns true if an error occurred that caused the actor to enter the :finished state.
+    def error?
+      !!@exception
+    end
+
+    # Salvage mailbox contents from a dead actor (including the message it died on).
+    # Useful for restarting a dead actor while preserving its mailbox.
+    def salvage_mailbox
+      raise "cannot salvage mailbox from an actor that isn't finished" unless state == :finished
+      @mailbox.dup.tap do |mailbox|
+        mailbox.unshift(@last_message) if @last_message
+      end
+    end
+
+  private
+    
+    # This wraps the user's #act method.
+    # It traps exceptions and notifies any linked actors.
+    def run
+      if options(:object)
+        loop{ options(:object).instance_exec(receive, &@receive_block) }
+      elsif @receive_block
+        loop{ @receive_block.call(receive) }
+      else
+        loop{ receive }
+      end
+    rescue Stop
+      nil
+    rescue Exception => e
+      @exception    = e
+      @last_message = @message
+    ensure
+      @state = :finished
+      notify_linked_of(@exception) if @exception
+    end
+
+    # Receive a message from the actor's mailbox.
+    def receive
+      message = @mailbox_lock.synchronize do
+        @mailbox_cond.wait_while{ @mailbox.empty? }
+        @message = @mailbox.shift
+      end
+
+      # Communicate with #run by possibly raising exceptions here.
+      case message
+      when DeadActorError
+        raise message unless options(:trap_exit)
+      when Stop
+        raise message
+      end
+
+      message # Return the message
+    end
+
+    # The other side of #link.
+    def _link(actor)
+      @linked_actors << actor
+    end
+
+    # Notifies all linked actors of the given exception, by adding it to their mailboxes.
+    def notify_linked_of(exception)
+      @linked_actors.each do |actor|
+        actor << DeadActorError.new(options(:object) || self, exception)
+      end
+    end
+
+    # An exception will be raised if the actor is not alive (is not running).
+    # It will be a DeadActorError if died due to a linked actor, otherwise it will be a RuntimeError.
+    def check_alive!
+      return if running?
+      if @exception
+        raise @exception
+      else
+        raise RuntimeError, "actor is not running"
+      end
+    end
+
+  end
+end

data/lib/thespian/dsl.rb

@@ -0,0 +1,10 @@
+module Thespian
+  class Dsl #:nodoc:
+    attr_reader :receive_block
+
+    def receive(&block)
+      @receive_block = block
+    end
+
+  end
+end

data/lib/thespian/errors.rb

@@ -0,0 +1,20 @@
+module Thespian
+  class DeadActorError < RuntimeError
+
+    # The actor or host object that died.
+    attr_reader :actor
+
+    # The exact exception that caused the actor to die.
+    attr_reader :reason
+
+    def initialize(actor, exception) #:nodoc:
+      super(exception)
+      @actor = actor
+      @reason = exception
+    end
+  end
+
+  # This is used as the stop message.
+  class Stop < StandardError #:nodoc:
+  end
+end

data/lib/thespian/version.rb

@@ -0,0 +1,3 @@
+module Thespian
+  VERSION = "0.0.1"
+end

data/lib/thespian.rb

@@ -0,0 +1,46 @@
+require "thespian/actor"
+require "thespian/dsl"
+require "thespian/version"
+
+# Include this module into classes to give them acting abilities.
+#   class ArnoldSchwarzenegger
+#     include Thespian
+# 
+#     actor.receive do |message|
+#       handle_message(message)
+#     end
+#
+#     def handle_message(message)
+#       puts message
+#     end
+#   end
+#
+#   arnold = ArnoldSchwarzenegger.new
+#   arnold.actor.start
+#   arnold.actor << "I'm a cop, you idiot!"
+#   arnold.actor.stop
+#
+# For a general overview of this gem, see the README.rdoc.
+module Thespian
+
+  def self.included(mod) #:nodoc:
+    mod.send(:extend,  ClassMethods)
+    mod.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods #:nodoc:
+    
+    def actor
+      @actor ||= Dsl.new
+    end
+
+  end
+
+  module InstanceMethods #:nodoc:
+
+    def actor
+      @actor ||= Actor.new(:object => self, &self.class.actor.receive_block)
+    end
+
+  end
+end

data/spec/actor_spec.rb

@@ -0,0 +1,144 @@
+require "spec_helper"
+
+module Thespian
+  describe Actor do
+
+    context "#new" do
+      let(:actor){ Actor.new }
+
+      it "returns a new Actor" do
+        actor.should be_a(Actor)
+      end
+
+      it "that is initialized" do
+        actor.should be_initialized
+      end
+    end
+
+    context "#link" do
+      let(:actor1){ Actor.new.extend(ActorHelper) }
+      let(:actor2){ Actor.new.extend(ActorHelper) }
+
+      it "adds self to the other actor's linked list" do
+        actor1.link(actor2)
+        actor2.linked_actors.should include(actor1)
+        actor1.linked_actors.should_not include(actor2)
+      end
+
+      it "can take host objects as argument" do
+        host = Class.new{ include Thespian }.new
+        host.actor.extend(ActorHelper)
+
+        actor1.link(host)
+        host.actor.linked_actors.should include(actor1)
+        actor1.linked_actors.should_not include(host.actor)
+      end
+    end
+
+    context "#start" do
+      let(:actor){ Actor.new.extend(ActorHelper) }
+
+      before(:all) do
+        actor.start
+      end
+
+      it "marks the actor as alive" do
+        actor.should be_running
+      end
+
+      it "starts a thread" do
+        actor.thread.should be_alive
+      end
+    end
+
+    context "#receive" do
+      let(:actor){ Actor.new.extend(ActorHelper) }
+
+      it "returns the next message from the actor's mailbox" do
+        actor.mailbox << "hello"
+        actor.receive.should == "hello"
+      end
+
+      it "raises a DeadActorError if that's what's in the mailbox" do
+        actor.mailbox << DeadActorError.new(actor, "blah")
+        expect{ actor.receive }.to raise_error(DeadActorError)
+      end
+
+      it "raises a Stop exception if that's what's in the mailbox" do
+        actor.mailbox << Stop.new
+        expect{ actor.receive }.to raise_error(Stop)
+      end
+
+      it "returns DeadActorError if trap_exit is true and that's what's in the mailbox" do
+        actor.mailbox << DeadActorError.new(actor, "blah")
+        actor.options(:trap_exit => true)
+        actor.receive.should be_a(DeadActorError)
+      end
+    end
+
+    context "#<<" do
+      let(:actor){ Actor.new.extend(ActorHelper) }
+
+      it "puts an item into the mailbox" do
+        stub(actor).running?{ true }
+        actor << "hello"
+        actor.mailbox.should include("hello")
+      end
+
+      it "raises a RuntimeError if the actor isn't alive" do
+        actor.should_not be_running
+        expect{ actor << "hello" }.to raise_error(RuntimeError, /not running/i)
+      end
+
+      it "works on a dead actor if strict is false" do
+        actor.should_not be_running
+        actor.options :strict => false
+        actor << "blah"
+        actor.mailbox.should include("blah")
+      end
+    end
+
+    context "#stop" do
+      let(:actor){ Actor.new.extend(ActorHelper) }
+
+      it "raises an exception if the actor isn't alive" do
+        expect{ actor.stop }.to raise_error(RuntimeError, /not running/i)
+      end
+
+      it "puts a Stop message in the actor's mailbox" do
+        mock(actor).running?{ true }.times(2)
+        mock(actor.thread).join
+        actor.stop
+        actor.mailbox[0].should be_a(Stop)
+      end
+    end
+
+    context "#salvage_mailbox" do
+
+      it "raises an error if the actor isn't done" do
+        actor = Actor.new
+        expect{ actor.salvage_mailbox }.to raise_error(/isn't finished/i)
+      end
+
+      it "doesn't include the last message if the actor stopped properly" do
+        actor = Actor.new.extend(ActorHelper)
+        actor.mailbox.replace([1, 2, 3, Stop.new, 4, 5])
+        actor.start
+        Thread.pass while actor.running?
+        actor.salvage_mailbox.should == [4, 5]
+      end
+
+      it "includes the last message if the actor error'ed" do
+        actor = Actor.new do |message|
+          raise "oops" if message == 3
+        end.extend(ActorHelper)
+        actor.mailbox.replace([1, 2, 3, 4, 5])
+        actor.start
+        Thread.pass while actor.running?
+        actor.salvage_mailbox.should == [3, 4, 5]
+      end
+
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+require "thespian"
+
+module ActorHelper
+
+  def linked_actors
+    @linked_actors
+  end
+
+  def thread
+    @thread
+  end
+
+  def mailbox
+    @mailbox
+  end
+
+  def mailbox_cond
+    @mailbox_cond
+  end
+
+  # To get around receive being private
+  def receive
+    super
+  end
+
+end
+
+require 'rr'
+
+module RR
+  module Adapters
+    module RSpec2
+
+      include RRMethods
+
+      def setup_mocks_for_rspec
+        RR.reset
+      end
+      def verify_mocks_for_rspec
+        RR.verify
+      end
+      def teardown_mocks_for_rspec
+        RR.reset
+      end
+
+      def have_received(method = nil)
+        RR::Adapters::Rspec::InvocationMatcher.new(method)
+      end
+    end
+  end
+end
+
+RSpec.configuration.backtrace_clean_patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
+
+module RSpec
+  module Core
+    module MockFrameworkAdapter
+      include RR::Adapters::RSpec2
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end
+

data/thespian.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "thespian/version"
+
+Gem::Specification.new do |s|
+  s.name        = "thespian"
+  s.version     = Thespian::VERSION
+  s.authors     = ["Christopher J. Bottaro"]
+  s.email       = ["cjbottaro@alumni.cs.utexas.edu"]
+  s.homepage    = "https://github.com/cjbottaro/thespian"
+  s.summary     = %q{Implementation of actor pattern using threads}
+  s.description = %q{Ruby implementation of actor pattern built on threads}
+
+  s.rubyforge_project = "thespian"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rr"
+  s.add_development_dependency "rdoc"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: thespian
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Christopher J. Bottaro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70140461192260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70140461192260
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &70140461191780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70140461191780
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70140461191300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70140461191300
+description: Ruby implementation of actor pattern built on threads
+email:
+- cjbottaro@alumni.cs.utexas.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG
+- Gemfile
+- README.rdoc
+- Rakefile
+- examples/linked.rb
+- examples/producer_consumer.rb
+- examples/task_processor.rb
+- lib/thespian.rb
+- lib/thespian/actor.rb
+- lib/thespian/dsl.rb
+- lib/thespian/errors.rb
+- lib/thespian/version.rb
+- spec/actor_spec.rb
+- spec/spec_helper.rb
+- thespian.gemspec
+homepage: https://github.com/cjbottaro/thespian
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: thespian
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Implementation of actor pattern using threads
+test_files:
+- spec/actor_spec.rb
+- spec/spec_helper.rb