scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/rspec/example_actor_class.rb

@@ -0,0 +1,109 @@
+module ExampleActorClass
+  def self.create(included_module, task_klass)
+    Class.new do
+      include included_module
+      task_class task_klass
+      attr_reader :name
+      finalizer :my_finalizer
+      execute_block_on_receiver :run_on_receiver
+
+      def initialize(name)
+        @name = name
+        @delegate = [:bar]
+      end
+
+      def sleepy(duration)
+        sleep duration
+      end
+
+      def change_name(new_name)
+        @name = new_name
+      end
+
+      def change_name_async(new_name)
+        async.change_name new_name
+      end
+
+      def greet
+        "Hi, I'm #{@name}"
+      end
+
+      def actor?
+        Celluloid.actor?
+      end
+
+      def run(*args)
+        yield(*args)
+      end
+
+      def run_on_receiver(*args)
+        yield(*args)
+      end
+
+      def crash
+        raise ExampleCrash, "the spec purposely crashed me :("
+      end
+
+      def crash_with_abort(reason, foo = nil)
+        example_crash = ExampleCrash.new(reason)
+        example_crash.foo = foo
+        abort example_crash
+      end
+
+      def crash_with_abort_raw(reason)
+        abort reason
+      end
+
+      def internal_hello
+        external_hello
+      end
+
+      def external_hello
+        "Hello"
+      end
+
+      def inspect_thunk
+        inspect
+      end
+
+      def send(string)
+        string.reverse
+      end
+
+      def shutdown
+        terminate
+      end
+
+      def method_missing(method_name, *args, &block)
+        if delegates?(method_name)
+          @delegate.send method_name, *args, &block
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_name, include_private = false)
+        super || delegates?(method_name)
+      end
+
+      def call_private
+        async.zomg_private
+      end
+
+      def zomg_private
+        @private_called = true
+      end
+      private :zomg_private
+      attr_reader :private_called
+
+      def my_finalizer
+      end
+
+      private
+
+      def delegates?(method_name)
+        @delegate.respond_to?(method_name)
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/rspec/mailbox_examples.rb

@@ -0,0 +1,84 @@
+shared_context "a Celluloid Mailbox" do
+  after do
+    Celluloid.logger.stub(:debug)
+    subject.shutdown if subject.alive?
+  end
+
+  it "receives messages" do
+    message = :ohai
+
+    subject << message
+    subject.receive.should == message
+  end
+
+  it "prioritizes system events over other messages" do
+    subject << :dummy1
+    subject << :dummy2
+
+    subject << Celluloid::SystemEvent.new
+    subject.receive.should be_a(Celluloid::SystemEvent)
+  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 eq(foo)
+    subject.receive { |msg| msg.is_a? Bar }.should eq(bar)
+    subject.receive.should eq(baz)
+  end
+
+  it "waits for a given timeout interval" do
+    interval = 0.1
+    started_at = Time.now
+
+    expect do
+      subject.receive(interval) { false }
+    end.to raise_exception(Celluloid::TimeoutError)
+
+    (Time.now - started_at).should be_within(Celluloid::TIMER_QUANTUM).of interval
+  end
+
+  it "has a size" do
+    subject.should respond_to(:size)
+    subject.size.should be_zero
+    subject << :foo
+    subject << :foo
+    subject.should have(2).entries
+  end
+
+  it "discards messages received when when full" do
+    subject.max_size = 2
+    subject << :first
+    subject << :second
+    subject << :third
+    subject.to_a.should =~ [:first, :second]
+  end
+
+  it "logs discarded messages" do
+    Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): third")
+
+    subject.max_size = 2
+    subject << :first
+    subject << :second
+    subject << :third
+  end
+
+  it "discard messages when dead" do
+    Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): first")
+    Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): second")
+    Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): third")
+
+    subject << :first
+    subject << :second
+    subject.shutdown
+    subject << :third
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/rspec/task_examples.rb

@@ -0,0 +1,49 @@
+class MockActor
+  attr_reader :tasks
+
+  def initialize
+    @tasks = []
+  end
+
+  def setup_thread
+  end
+end
+
+shared_context "a Celluloid Task" do |task_class|
+  let(:task_type)     { :foobar }
+  let(:suspend_state) { :doing_something }
+  let(:actor)         { MockActor.new }
+
+  subject { task_class.new(task_type, {}) { Celluloid::Task.suspend(suspend_state) } }
+
+  before :each do
+    Thread.current[:celluloid_actor_system] = Celluloid.actor_system
+    Thread.current[:celluloid_actor] = actor
+  end
+
+  after :each do
+    Thread.current[:celluloid_actor] = nil
+    Thread.current[:celluloid_actor_system] = nil
+  end
+
+  it "begins with status :new" do
+    subject.status.should be :new
+  end
+
+  it "resumes" do
+    subject.should be_running
+    subject.resume
+    subject.status.should eq(suspend_state)
+    subject.resume
+    subject.should_not be_running
+  end
+
+  it "raises exceptions outside" do
+    task = task_class.new(task_type, {}) do
+      raise "failure"
+    end
+    expect do
+      task.resume
+    end.to raise_exception("failure")
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/rspec.rb

@@ -0,0 +1,13 @@
+require 'celluloid/rspec/example_actor_class'
+require 'celluloid/rspec/actor_examples'
+require 'celluloid/rspec/mailbox_examples'
+require 'celluloid/rspec/task_examples'
+
+module Celluloid
+  # Timer accuracy enforced by the tests (50ms)
+  TIMER_QUANTUM = 0.05
+end
+
+$CELLULOID_DEBUG = true
+
+require 'celluloid/test'

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/signals.rb

@@ -0,0 +1,23 @@
+module Celluloid
+  # Event signaling between methods of the same object
+  class Signals
+    def initialize
+      @conditions = {}
+    end
+
+    # Wait for the given signal and return the associated value
+    def wait(name)
+      raise "cannot wait for signals while exclusive" if Celluloid.exclusive?
+
+      @conditions[name] ||= Condition.new
+      @conditions[name].wait
+    end
+
+    # Send a signal to all method calls waiting for the given name
+    def broadcast(name, value = nil)
+      if condition = @conditions.delete(name)
+        condition.broadcast(value)
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/stack_dump.rb

@@ -0,0 +1,133 @@
+module Celluloid
+  class StackDump
+    module DisplayBacktrace
+      def display_backtrace(backtrace, output, indent = nil)
+        backtrace ||= ["EMPTY BACKTRACE"]
+        backtrace.each do |line|
+          output << indent if indent
+          output << "\t" << line << "\n"
+        end
+        output << "\n\n"
+      end
+    end
+
+    class TaskState < Struct.new(:task_class, :type, :meta, :status, :backtrace)
+    end
+
+    class ActorState
+      include DisplayBacktrace
+      attr_accessor :name, :id, :cell
+      attr_accessor :status, :tasks
+      attr_accessor :backtrace
+
+      def dump
+        string = ""
+        string << "Celluloid::Actor 0x#{id.to_s(16)}"
+        string << " [#{name}]" if name
+        string << "\n"
+
+        if cell
+          string << cell.dump
+          string << "\n"
+        end
+
+        if status == :idle
+          string << "State: Idle (waiting for messages)\n"
+          display_backtrace backtrace, string
+        else
+          string << "State: Running (executing tasks)\n"
+          display_backtrace backtrace, string
+          string << "\tTasks:\n"
+
+          tasks.each_with_index do |task, i|
+            string << "\t  #{i+1}) #{task.task_class}[#{task.type}]: #{task.status}\n"
+            string << "\t      #{task.meta.inspect}\n"
+            display_backtrace task.backtrace, string, "\t"
+          end
+        end
+
+        string
+      end
+    end
+
+    class CellState < Struct.new(:subject_id, :subject_class)
+      def dump
+        "Celluloid::Cell 0x#{subject_id.to_s(16)}: #{subject_class}"
+      end
+    end
+
+    class ThreadState < Struct.new(:thread_id, :backtrace, :role)
+      include DisplayBacktrace
+
+      def dump
+        string = ""
+        string << "Thread 0x#{thread_id.to_s(16)} (#{role}):\n"
+        display_backtrace backtrace, string
+        string
+      end
+    end
+
+    attr_accessor :actors, :threads
+
+    def initialize(internal_pool)
+      @internal_pool = internal_pool
+
+      @actors  = []
+      @threads = []
+
+      snapshot
+    end
+
+    def snapshot
+      @internal_pool.each do |thread|
+        if thread.role == :actor
+          @actors << snapshot_actor(thread.actor) if thread.actor
+        else
+          @threads << snapshot_thread(thread)
+        end
+      end
+    end
+
+    def snapshot_actor(actor)
+      state = ActorState.new
+      state.id = actor.object_id
+
+      # TODO: delegate to the behavior
+      if actor.behavior.is_a?(Cell)
+        state.cell = snapshot_cell(actor.behavior)
+      end
+
+      tasks = actor.tasks
+      if tasks.empty?
+        state.status = :idle
+      else
+        state.status = :running
+        state.tasks = tasks.to_a.map { |t| TaskState.new(t.class, t.type, t.meta, t.status, t.backtrace) }
+      end
+
+      state.backtrace = actor.thread.backtrace if actor.thread
+      state
+    end
+
+    def snapshot_cell(behavior)
+      state = CellState.new
+      state.subject_id = behavior.subject.object_id
+      state.subject_class = behavior.subject.class
+      state
+    end
+
+    def snapshot_thread(thread)
+      ThreadState.new(thread.object_id, thread.backtrace, thread.role)
+    end
+
+    def print(output = STDERR)
+      @actors.each do |actor|
+        output.print actor.dump
+      end
+
+      @threads.each do |thread|
+        output.print thread.dump
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/supervision_group.rb

@@ -0,0 +1,169 @@
+module Celluloid
+  # Supervise collections of actors as a group
+  class SupervisionGroup
+    include Celluloid
+    trap_exit :restart_actor
+
+    class << self
+
+      # Actors or sub-applications to be supervised
+      def blocks
+        @blocks ||= []
+      end
+
+      # Start this application (and watch it with a supervisor)
+      def run!(registry = nil)
+        group = new(registry) do |_group|
+          blocks.each do |block|
+            block.call(_group)
+          end
+        end
+        group
+      end
+
+      # Run the application in the foreground with a simple watchdog
+      def run(registry = nil)
+        loop do
+          supervisor = run!(registry)
+
+          # Take five, toplevel supervisor
+          sleep 5 while supervisor.alive?
+
+          Logger.error "!!! Celluloid::SupervisionGroup #{self} crashed. Restarting..."
+        end
+      end
+
+      # Register an actor class or a sub-group to be launched and supervised
+      # Available options are:
+      #
+      # * as: register this application in the Celluloid::Actor[] directory
+      # * args: start the actor with the given arguments
+      def supervise(klass, options = {})
+        blocks << lambda do |group|
+          group.add klass, options
+        end
+      end
+
+      # Register a pool of actors to be launched on group startup
+      # Available options are:
+      #
+      # * as: register this application in the Celluloid::Actor[] directory
+      # * args: start the actor pool with the given arguments
+      def pool(klass, options = {})
+        blocks << lambda do |group|
+          group.pool klass, options
+        end
+      end
+    end
+
+    finalizer :finalize
+
+    # Start the group
+    def initialize(registry = nil)
+      @members = []
+      @registry = registry || Celluloid.actor_system.registry
+
+      yield current_actor if block_given?
+    end
+
+    execute_block_on_receiver :initialize, :supervise, :supervise_as
+
+    def supervise(klass, *args, &block)
+      add(klass, :args => args, :block => block)
+    end
+
+    def supervise_as(name, klass, *args, &block)
+      add(klass, :args => args, :block => block, :as => name)
+    end
+
+    def pool(klass, options = {})
+      options[:method] = 'pool_link'
+      add(klass, options)
+    end
+
+    def add(klass, options)
+      member = Member.new(@registry, klass, options)
+      @members << member
+      member.actor
+    end
+
+    def actors
+      @members.map(&:actor)
+    end
+
+    def [](actor_name)
+      @registry[actor_name]
+    end
+
+    # Restart a crashed actor
+    def restart_actor(actor, reason)
+      member = @members.find do |_member|
+        _member.actor == actor
+      end
+      raise "a group member went missing. This shouldn't be!" unless member
+
+      if reason
+        member.restart
+      else
+        member.cleanup
+        @members.delete(member)
+      end
+    end
+
+    # A member of the group
+    class Member
+      def initialize(registry, klass, options = {})
+        @registry = registry
+        @klass = klass
+
+        # Stringify keys :/
+        options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+
+        @name = options['as']
+        @block = options['block']
+        @args = options['args'] ? Array(options['args']) : []
+        @method = options['method'] || 'new_link'
+        @pool = @method == 'pool_link'
+        @pool_size = options['size'] if @pool
+
+        start
+      end
+      attr_reader :name, :actor
+
+      def start
+        # when it is a pool, then we don't splat the args
+        # and we need to extract the pool size if set
+        if @pool
+          options = {:args => @args}
+          options[:size] = @pool_size if @pool_size
+          @args = [options]
+        end
+        @actor = @klass.send(@method, *@args, &@block)
+        @registry[@name] = @actor if @name
+      end
+
+      def restart
+        @actor = nil
+        cleanup
+
+        start
+      end
+
+      def terminate
+        cleanup
+        @actor.terminate if @actor
+      rescue DeadActorError
+      end
+
+      def cleanup
+        @registry.delete(@name) if @name
+      end
+    end
+
+    private
+
+    def finalize
+      @members.reverse_each(&:terminate) if @members
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/supervisor.rb

@@ -0,0 +1,22 @@
+module Celluloid
+  # Supervisors are actors that watch over other actors and restart them if
+  # they crash
+  class Supervisor
+    class << self
+      # Define the root of the supervision tree
+      attr_accessor :root
+
+      def supervise(klass, *args, &block)
+        SupervisionGroup.new do |group|
+          group.supervise klass, *args, &block
+        end
+      end
+
+      def supervise_as(name, klass, *args, &block)
+        SupervisionGroup.new do |group|
+          group.supervise_as name, klass, *args, &block
+        end
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/lib/celluloid/system_events.rb

@@ -0,0 +1,66 @@
+module Celluloid
+  # High-priority internal system events
+  class SystemEvent; end
+
+  # Request to link with another actor
+  class LinkingRequest < SystemEvent
+    attr_reader :actor, :type
+
+    def initialize(actor, type)
+      @actor, @type = actor, type.to_sym
+      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+    end
+
+    def process(links)
+      case type
+      when :link   then links << actor
+      when :unlink then links.delete actor
+      end
+
+      actor.mailbox << LinkingResponse.new(Actor.current, type)
+    end
+  end
+
+  # Response to a link request
+  class LinkingResponse
+    attr_reader :actor, :type
+
+    def initialize(actor, type)
+      @actor, @type = actor, type.to_sym
+      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+    end
+  end
+
+  # An actor has exited for the given reason
+  class ExitEvent < SystemEvent
+    attr_reader :actor, :reason
+
+    def initialize(actor, reason = nil)
+      @actor, @reason = actor, reason
+    end
+  end
+
+  # Name an actor at the time it's registered
+  class NamingRequest < SystemEvent
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  # Request for an actor to terminate
+  class TerminationRequest < SystemEvent; end
+
+  # Signal a condition
+  class SignalConditionRequest < SystemEvent
+    def initialize(task, value)
+      @task, @value = task, value
+    end
+    attr_reader :task, :value
+
+    def call
+      @task.resume(@value)
+    end
+  end
+end