scoot 0.0.4

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

@@ -0,0 +1,65 @@
+module Celluloid
+  class RingBuffer
+    def initialize(size)
+      @size = size
+      @start = 0
+      @count = 0
+      @buffer = Array.new(size)
+      @mutex = Mutex.new
+    end
+
+    def full?
+      @count == @size
+    end
+
+    def empty?
+      @count == 0
+    end
+
+    def push(value)
+      @mutex.synchronize do
+        stop = (@start + @count) % @size
+        @buffer[stop] = value
+        if full?
+          @start = (@start + 1) % @size
+        else
+          @count += 1
+        end
+        value
+      end
+    end
+    alias :<< :push
+
+    def shift
+      @mutex.synchronize do
+        remove_element
+      end
+    end
+
+    def flush
+      values = []
+      @mutex.synchronize do
+        while !empty?
+          values << remove_element
+        end
+      end
+      values
+    end
+
+    def clear
+      @buffer = Array.new(@size)
+      @start = 0
+      @count = 0
+    end
+
+    private
+
+    def remove_element
+      return nil if empty?
+      value, @buffer[@start] = @buffer[@start], nil
+      @start = (@start + 1) % @size
+      @count -= 1
+      value
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'celluloid/logging/log_event'
+require 'celluloid/logging/incident'
+require 'celluloid/logging/ring_buffer'
+require 'celluloid/logging/incident_logger'
+require 'celluloid/logging/incident_reporter'

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

@@ -0,0 +1,156 @@
+require 'thread'
+
+module Celluloid
+  class MailboxDead < Celluloid::Error; end # you can't receive from the dead
+  class MailboxShutdown < Celluloid::Error; end # raised if the mailbox can no longer be used
+
+  # Actors communicate with asynchronous messages. Messages are buffered in
+  # Mailboxes until Actors can act upon them.
+  class Mailbox
+    include Enumerable
+
+    # A unique address at which this mailbox can be found
+    attr_reader :address
+    attr_accessor :max_size
+
+    def initialize
+      @address   = Celluloid.uuid
+      @messages  = []
+      @mutex     = Mutex.new
+      @dead      = false
+      @condition = ConditionVariable.new
+      @max_size  = nil
+    end
+
+    # Add a message to the Mailbox
+    def <<(message)
+      @mutex.lock
+      begin
+        if mailbox_full || @dead
+          dead_letter(message)
+          return
+        end
+        if message.is_a?(SystemEvent)
+          # SystemEvents are high priority messages so they get added to the
+          # head of our message queue instead of the end
+          @messages.unshift message
+        else
+          @messages << message
+        end
+
+        @condition.signal
+        nil
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
+    # Receive a message from the Mailbox. May return nil and may return before
+    # the specified timeout.
+    def check(timeout = nil, &block)
+      message = nil
+
+      @mutex.lock
+      begin
+        raise MailboxDead, "attempted to receive from a dead mailbox" if @dead
+
+        Timers::Wait.for(timeout) do |remaining|
+          message = next_message(&block)
+
+          break message if message
+
+          @condition.wait(@mutex, remaining)
+        end
+      ensure
+        @mutex.unlock rescue nil
+      end
+      
+      return message
+    end
+
+    # Receive a letter from the mailbox. Guaranteed to return a message. If
+    # timeout is exceeded, raise a TimeoutError.
+    def receive(timeout = nil, &block)
+      Timers::Wait.for(timeout) do |remaining|
+        if message = check(timeout, &block)
+          return message
+        end
+      end
+      
+      raise TimeoutError.new("receive timeout exceeded")
+    end
+
+    # Shut down this mailbox and clean up its contents
+    def shutdown
+      raise MailboxDead, "mailbox already shutdown" if @dead
+
+      @mutex.lock
+      begin
+        yield if block_given?
+        messages = @messages
+        @messages = []
+        @dead = true
+      ensure
+        @mutex.unlock rescue nil
+      end
+
+      messages.each do |msg|
+        dead_letter msg
+        msg.cleanup if msg.respond_to? :cleanup
+      end
+      true
+    end
+
+    # Is the mailbox alive?
+    def alive?
+      !@dead
+    end
+
+    # Cast to an array
+    def to_a
+      @mutex.synchronize { @messages.dup }
+    end
+
+    # Iterate through the mailbox
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    # Inspect the contents of the Mailbox
+    def inspect
+      "#<#{self.class}:#{object_id.to_s(16)} @messages=[#{map { |m| m.inspect }.join(', ')}]>"
+    end
+
+    # Number of messages in the Mailbox
+    def size
+      @mutex.synchronize { @messages.size }
+    end
+
+    private
+
+    # Retrieve the next message in the mailbox
+    def next_message
+      message = nil
+
+      if block_given?
+        index = @messages.index do |msg|
+          yield(msg) || msg.is_a?(SystemEvent)
+        end
+
+        message = @messages.slice!(index, 1).first if index
+      else
+        message = @messages.shift
+      end
+
+      message
+    end
+
+    def dead_letter(message)
+      Logger.debug "Discarded message (mailbox is dead): #{message}" if $CELLULOID_DEBUG
+    end
+
+    def mailbox_full
+      @max_size && @messages.size >= @max_size
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Celluloid
+  # Method handles that route through an actor proxy
+  class Method
+
+    def initialize(proxy, name)
+      raise NameError, "undefined method `#{name}'" unless proxy.respond_to? name
+
+      @proxy, @name = proxy, name
+      @klass = @proxy.class
+    end
+
+    def arity
+      @proxy.method_missing(:method, @name).arity
+    end
+
+    def name
+      @proxy.method_missing(:method, @name).name
+    end
+
+    def parameters
+      @proxy.method_missing(:method, @name).parameters
+    end
+
+    def call(*args, &block)
+      @proxy.__send__(@name, *args, &block)
+    end
+
+    def inspect
+      "#<Celluloid::Method #{@klass}##{@name}>"
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Celluloid
+  module Notifications
+    def self.notifier
+      Actor[:notifications_fanout] or raise DeadActorError, "notifications fanout actor not running"
+    end
+
+    def publish(pattern, *args)
+      Celluloid::Notifications.notifier.publish(pattern, *args)
+    end
+
+    def subscribe(pattern, method)
+      Celluloid::Notifications.notifier.subscribe(Actor.current, pattern, method)
+    end
+
+    def unsubscribe(*args)
+      Celluloid::Notifications.notifier.unsubscribe(*args)
+    end
+
+    class Fanout
+      include Celluloid
+      trap_exit :prune
+
+      def initialize
+        @subscribers = []
+        @listeners_for = {}
+      end
+
+      def subscribe(actor, pattern, method)
+        subscriber = Subscriber.new(actor, pattern, method).tap do |s|
+          @subscribers << s
+        end
+        link actor
+        @listeners_for.clear
+        subscriber
+      end
+
+      def unsubscribe(subscriber)
+        @subscribers.reject! { |s| s.matches?(subscriber) }
+        @listeners_for.clear
+      end
+
+      def publish(pattern, *args)
+        listeners_for(pattern).each { |s| s.publish(pattern, *args) }
+      end
+
+      def listeners_for(pattern)
+        @listeners_for[pattern] ||= @subscribers.select { |s| s.subscribed_to?(pattern) }
+      end
+
+      def listening?(pattern)
+        listeners_for(pattern).any?
+      end
+
+      def prune(actor, reason=nil)
+        @subscribers.reject! { |s| s.actor == actor }
+        @listeners_for.clear
+      end
+    end
+
+    class Subscriber
+      attr_accessor :actor, :pattern, :method
+
+      def initialize(actor, pattern, method)
+        @actor = actor
+        @pattern = pattern
+        @method = method
+      end
+
+      def publish(pattern, *args)
+        actor.async method, pattern, *args
+      end
+
+      def subscribed_to?(pattern)
+        !pattern || @pattern === pattern.to_s
+      end
+
+      def matches?(subscriber_or_pattern)
+        self === subscriber_or_pattern ||
+          @pattern && @pattern === subscriber_or_pattern
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+require 'set'
+
+module Celluloid
+  # Manages a fixed-size pool of workers
+  # Delegates work (i.e. methods) and supervises workers
+  # Don't use this class directly. Instead use MyKlass.pool
+  class PoolManager
+    include Celluloid
+    trap_exit :__crash_handler__
+    finalizer :__shutdown__
+
+    def initialize(worker_class, options = {})
+      @size = options[:size] || [Celluloid.cores || 2, 2].max
+      raise ArgumentError, "minimum pool size is 2" if @size < 2
+
+      @worker_class = worker_class
+      @args = options[:args] ? Array(options[:args]) : []
+
+      @idle = @size.times.map { worker_class.new_link(*@args) }
+
+      # FIXME: Another data structure (e.g. Set) would be more appropriate
+      # here except it causes MRI to crash :o
+      @busy = []
+    end
+
+    def __shutdown__
+      terminators = (@idle + @busy).map do |actor|
+        begin
+          actor.future(:terminate)
+        rescue DeadActorError
+        end
+      end
+
+      terminators.compact.each { |terminator| terminator.value rescue nil }
+    end
+
+    def _send_(method, *args, &block)
+      worker = __provision_worker__
+
+      begin
+        worker._send_ method, *args, &block
+      rescue DeadActorError # if we get a dead actor out of the pool
+        wait :respawn_complete
+        worker = __provision_worker__
+        retry
+      rescue Exception => ex
+        abort ex
+      ensure
+        if worker.alive?
+          @idle << worker
+          @busy.delete worker
+        end
+      end
+    end
+
+    def name
+      _send_ @mailbox, :name
+    end
+
+    def is_a?(klass)
+      _send_ :is_a?, klass
+    end
+
+    def kind_of?(klass)
+      _send_ :kind_of?, klass
+    end
+
+    def methods(include_ancestors = true)
+      _send_ :methods, include_ancestors
+    end
+
+    def to_s
+      _send_ :to_s
+    end
+
+    def inspect
+      _send_ :inspect
+    end
+
+    def size
+      @size
+    end
+
+    def size=(new_size)
+      new_size = [0, new_size].max
+
+      if new_size > size
+        delta = new_size - size
+        delta.times { @idle << @worker_class.new_link(*@args) }
+      else
+        (size - new_size).times do
+          worker = __provision_worker__
+          unlink worker
+          @busy.delete worker
+          worker.terminate
+        end
+      end
+      @size = new_size
+    end
+
+    def busy_size
+      @busy.length
+    end
+
+    def idle_size
+      @idle.length
+    end
+
+    # Provision a new worker
+    def __provision_worker__
+      Task.current.guard_warnings = true
+      while @idle.empty?
+        # Wait for responses from one of the busy workers
+        response = exclusive { receive { |msg| msg.is_a?(Response) } }
+        Thread.current[:celluloid_actor].handle_message(response)
+      end
+
+      worker = @idle.shift
+      @busy << worker
+
+      worker
+    end
+
+    # Spawn a new worker for every crashed one
+    def __crash_handler__(actor, reason)
+      @busy.delete actor
+      @idle.delete actor
+      return unless reason
+
+      @idle << @worker_class.new_link(*@args)
+      signal :respawn_complete
+    end
+
+    def respond_to?(method, include_private = false)
+      super || @worker_class.instance_methods.include?(method.to_sym)
+    end
+
+    def method_missing(method, *args, &block)
+      if respond_to?(method)
+        _send_ method, *args, &block
+      else
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'celluloid'
+
+$CELLULOID_MONITORING = true
+
+module Celluloid
+  class Probe
+    include Celluloid
+    include Celluloid::Notifications
+
+    NOTIFICATIONS_TOPIC_BASE = 'celluloid.events.%s'
+    INITIAL_EVENTS = Queue.new
+
+    class << self
+      def run
+        # spawn the actor if not found
+        supervise_as(:probe_actor) unless Actor[:probe_actor] && Actor[:probe_actor].alive?
+      end
+
+      def actor_created(actor)
+        trigger_event(:actor_created, actor)
+      end
+
+      def actor_named(actor)
+        trigger_event(:actor_named, actor)
+      end
+
+      def actor_died(actor)
+        trigger_event(:actor_died, actor)
+      end
+
+      def actors_linked(a, b)
+        a = find_actor(a)
+        b = find_actor(b)
+        trigger_event(:actors_linked, a, b)
+      end
+
+      private
+
+      def trigger_event(name, *args)
+        return unless $CELLULOID_MONITORING
+        probe_actor = Actor[:probe_actor]
+        if probe_actor
+          probe_actor.async.dispatch_event(name, args)
+        else
+          INITIAL_EVENTS << [name, args]
+        end
+      end
+
+      def find_actor(obj)
+        if obj.__send__(:class) == Actor
+          obj
+        elsif owner = obj.instance_variable_get(OWNER_IVAR)
+          owner
+        end
+      end
+    end
+
+    def initialize
+      async.first_run
+    end
+
+    def first_run
+      until INITIAL_EVENTS.size == 0
+        event = INITIAL_EVENTS.pop
+        dispatch_event(*event)
+      end
+    end
+
+    def dispatch_event(cmd, args)
+      publish(NOTIFICATIONS_TOPIC_BASE % cmd, args)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Celluloid
+  # Properties define inheritable attributes of classes, somewhat similar to
+  # Rails cattr_*/mattr_* or class_attribute
+  module Properties
+    def property(name, opts = {})
+      default   = opts.fetch(:default, nil)
+      multi     = opts.fetch(:multi, false)
+      ivar_name = "@#{name}".to_sym
+
+      ancestors.first.send(:define_singleton_method, name) do |value = nil, *extra|
+        if value
+          value = value ? [value, *send(name), *extra].uniq : [] if multi
+          instance_variable_set(ivar_name, value)
+        elsif instance_variables.include?(ivar_name)
+          instance_variable_get(ivar_name)
+        elsif superclass.respond_to? name
+          superclass.send(name)
+        else
+          default
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Celluloid
+  # Base class of all Celluloid proxies
+  class AbstractProxy < BasicObject
+    # Used for reflecting on proxy objects themselves
+    def __class__; AbstractProxy; end
+
+    # Needed for storing proxies in data structures
+    needed = [:object_id, :__id__, :hash] - instance_methods
+    if needed.any?
+      include ::Kernel.dup.module_eval {
+        undef_method(*(instance_methods - needed))
+        self
+      }
+
+      # rubinius bug?  These methods disappear when we include hacked kernel
+      define_method :==, ::BasicObject.instance_method(:==) unless instance_methods.include?(:==)
+      alias_method(:equal?, :==) unless instance_methods.include?(:equal?)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Celluloid
+  # A proxy which controls the Actor lifecycle
+  class ActorProxy < AbstractProxy
+    attr_reader :thread, :mailbox
+
+    # Used for reflecting on proxy objects themselves
+    def __class__; ActorProxy; end
+
+    def initialize(thread, mailbox)
+      @thread = thread
+      @mailbox = mailbox
+    end
+
+    def inspect
+      # TODO: use a system event to fetch actor state: tasks?
+      "#<Celluloid::ActorProxy(#{@mailbox.address}) alive>"
+    rescue DeadActorError
+      "#<Celluloid::ActorProxy(#{@mailbox.address}) dead>"
+    end
+
+    def alive?
+      @mailbox.alive?
+    end
+
+    # Terminate the associated actor
+    def terminate
+      terminate!
+      Actor.join(self)
+      nil
+    end
+
+    # Terminate the associated actor asynchronously
+    def terminate!
+      ::Kernel.raise DeadActorError, "actor already terminated" unless alive?
+      @mailbox << TerminationRequest.new
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Celluloid
+  # A proxy which sends asynchronous calls to an actor
+  class AsyncProxy < AbstractProxy
+    attr_reader :mailbox
+
+    # Used for reflecting on proxy objects themselves
+    def __class__; AsyncProxy; end
+
+    def initialize(mailbox, klass)
+      @mailbox, @klass = mailbox, klass
+    end
+
+    def inspect
+      "#<Celluloid::AsyncProxy(#{@klass})>"
+    end
+
+    def method_missing(meth, *args, &block)
+      if @mailbox == ::Thread.current[:celluloid_mailbox]
+        args.unshift meth
+        meth = :__send__
+      end
+
+      if block_given?
+        # FIXME: nicer exception
+        raise "Cannot use blocks with async yet"
+      end
+
+      @mailbox << AsyncCall.new(meth, args, block)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Celluloid
+  class BlockProxy
+    def initialize(call, mailbox, block)
+      @call = call
+      @mailbox = mailbox
+      @block = block
+      @execution = :sender
+    end
+    attr_writer :execution
+    attr_reader :call, :block
+
+    def to_proc
+      if @execution == :sender
+        lambda do |*values|
+          if task = Thread.current[:celluloid_task]
+            @mailbox << BlockCall.new(self, Actor.current.mailbox, values)
+            # TODO: if respond fails, the Task will never be resumed
+            task.suspend(:invokeblock)
+          else
+            # FIXME: better exception
+            raise "No task to suspend"
+          end
+        end
+      else
+        @block
+      end
+    end
+  end
+end