scoot 0.0.4

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

@@ -0,0 +1,108 @@
+require 'thread'
+
+module Celluloid
+  # Celluloid::Future objects allow methods and blocks to run in the
+  # background, their values requested later
+  class Future
+    def self.new(*args, &block)
+      return super unless block
+
+      future = new
+      Celluloid::ThreadHandle.new(Celluloid.actor_system, :future) do
+        begin
+          call = SyncCall.new(future, :call, args)
+          call.dispatch(block)
+        rescue
+          # Exceptions in blocks will get raised when the value is retrieved
+        end
+      end
+      future
+    end
+
+    attr_reader :address
+
+    def initialize
+      @address = Celluloid.uuid
+      @mutex = Mutex.new
+      @ready = false
+      @result = nil
+      @forwards = nil
+    end
+
+    # Check if this future has a value yet
+    def ready?
+      @ready
+    end
+
+    # Obtain the value for this Future
+    def value(timeout = nil)
+      ready = result = nil
+
+      begin
+        @mutex.lock
+
+        if @ready
+          ready = true
+          result = @result
+        else
+          case @forwards
+          when Array
+            @forwards << Celluloid.mailbox
+          when NilClass
+            @forwards = Celluloid.mailbox
+          else
+            @forwards = [@forwards, Celluloid.mailbox]
+          end
+        end
+      ensure
+        @mutex.unlock
+      end
+
+      unless ready
+        result = Celluloid.receive(timeout) do |msg|
+          msg.is_a?(Future::Result) && msg.future == self
+        end
+      end
+
+      if result
+        result.value
+      else
+        raise TimeoutError, "Timed out"
+      end
+    end
+    alias_method :call, :value
+
+    # Signal this future with the given result value
+    def signal(value)
+      result = Result.new(value, self)
+
+      @mutex.synchronize do
+        raise "the future has already happened!" if @ready
+
+        if @forwards
+          @forwards.is_a?(Array) ? @forwards.each { |f| f << result } : @forwards << result
+        end
+
+        @result = result
+        @ready = true
+      end
+    end
+    alias_method :<<, :signal
+
+    # Inspect this Celluloid::Future
+    alias_method :inspect, :to_s
+
+    # Wrapper for result values to distinguish them in mailboxes
+    class Result
+      attr_reader :future
+
+      def initialize(result, future)
+        @result, @future = result, future
+      end
+
+      def value
+        @result.value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'set'
+
+module Celluloid
+  class Handlers
+    def initialize
+      @handlers = Set.new
+    end
+
+    def handle(*patterns, &block)
+      patterns.each do |pattern|
+        handler = Handler.new pattern, block
+        @handlers << handler
+      end
+    end
+
+    # Handle incoming messages
+    def handle_message(message)
+      if handler = @handlers.find { |h| h.match(message) }
+        handler.call message
+        handler
+      end
+    end
+  end
+
+  # Methods blocking on a call to receive
+  class Handler
+    def initialize(pattern, block)
+      @pattern = pattern
+      @block = block
+    end
+
+    # Match a message with this receiver's block
+    def match(message)
+      @pattern === message
+    end
+
+    def call(message)
+      @block.call message
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+require 'thread'
+
+module Celluloid
+  # Maintain a thread pool FOR SPEED!!
+  class InternalPool
+    attr_accessor :max_idle
+
+    def initialize
+      @mutex = Mutex.new
+      @idle_threads = []
+      @all_threads  = []
+      @busy_size = 0
+      @idle_size = 0
+
+      # TODO: should really adjust this based on usage
+      @max_idle = 16
+      @running = true
+    end
+
+    def busy_size
+      @busy_size
+    end
+
+    def idle_size
+      @idle_size
+    end
+
+    def assert_running
+      raise Error, "Thread pool is not running" unless running?
+    end
+
+    def assert_inactive
+      if active?
+        message = "Thread pool is still active"
+        if defined?(JRUBY_VERSION)
+          Celluloid.logger.warn message
+        else
+          raise Error, message
+        end
+      end
+    end
+
+    def running?
+      @running
+    end
+
+    def active?
+      busy_size + idle_size > 0
+    end
+
+    def each
+      to_a.each {|thread| yield thread }
+    end
+
+    def to_a
+      @mutex.synchronize { @all_threads.dup }
+    end
+
+    # Get a thread from the pool, running the given block
+    def get(&block)
+      @mutex.synchronize do
+        assert_running
+
+        begin
+          if @idle_threads.empty?
+            thread = create
+          else
+            thread = @idle_threads.pop
+            @idle_size = @idle_threads.length
+          end
+        end until thread.status # handle crashed threads
+
+        thread.busy = true
+        @busy_size += 1
+        thread[:celluloid_queue] << block
+        thread
+      end
+    end
+
+    # Return a thread to the pool
+    def put(thread)
+      @mutex.synchronize do
+        thread.busy = false
+        if idle_size + 1 >= @max_idle
+          thread[:celluloid_queue] << nil
+          @busy_size -= 1
+          @all_threads.delete(thread)
+        else
+          @idle_threads.push thread
+          @busy_size -= 1
+          @idle_size = @idle_threads.length
+          clean_thread_locals(thread)
+        end
+      end
+    end
+
+    def shutdown
+      @mutex.synchronize do
+        finalize
+        @all_threads.each do |thread|
+          thread[:celluloid_queue] << nil
+        end
+        @all_threads.clear
+        @idle_threads.clear
+        @busy_size = 0
+        @idle_size = 0
+      end
+    end
+
+    def kill
+      @mutex.synchronize do
+        finalize
+        @running = false
+
+        @all_threads.shift.kill until @all_threads.empty?
+        @idle_threads.clear
+        @busy_size = 0
+        @idle_size = 0
+      end
+    end
+
+    private
+
+    # Create a new thread with an associated queue of procs to run
+    def create
+      queue = Queue.new
+      thread = Thread.new do
+        while proc = queue.pop
+          begin
+            proc.call
+          rescue => ex
+            Logger.crash("thread crashed", ex)
+          end
+
+          put thread
+        end
+      end
+
+      thread[:celluloid_queue] = queue
+      # @idle_threads << thread
+      @all_threads << thread
+      thread
+    end
+
+    # Clean the thread locals of an incoming thread
+    def clean_thread_locals(thread)
+      thread.keys.each do |key|
+        next if key == :celluloid_queue
+
+        # Ruby seems to lack an API for deleting thread locals. WTF, Ruby?
+        thread[key] = nil
+      end
+    end
+
+    def finalize
+      @max_idle = 0
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+class Thread
+  def self.mailbox
+    Celluloid.mailbox
+  end
+
+  def self.receive(timeout = nil, &block)
+    Celluloid.receive(timeout, &block)
+  end
+end

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

@@ -0,0 +1,36 @@
+module Celluloid
+  # Linked actors send each other system events
+  class Links
+    include Enumerable
+
+    def initialize
+      @links = {}
+    end
+
+    # Add an actor to the current links
+    def <<(actor)
+      @links[actor.mailbox.address] = actor
+    end
+
+    # Do links include the given actor?
+    def include?(actor)
+      @links.has_key? actor.mailbox.address
+    end
+
+    # Remove an actor from the links
+    def delete(actor)
+      @links.delete actor.mailbox.address
+    end
+
+    # Iterate through all links
+    def each
+      @links.each { |_, actor| yield(actor) }
+    end
+
+    # Generate a string representation
+    def inspect
+      links = self.map(&:inspect).join(',')
+      "#<#{self.class}[#{links}]>"
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module Celluloid
+  module Logger
+    class WithBacktrace
+      def initialize(backtrace)
+        @backtrace = backtrace
+      end
+
+      def debug(string)
+        Celluloid.logger.debug(decorate(string))
+      end
+
+      def info(string)
+        Celluloid.logger.info(decorate(string))
+      end
+
+      def warn(string)
+        Celluloid.logger.warn(decorate(string))
+      end
+
+      def error(string)
+        Celluloid.logger.error(decorate(string))
+      end
+
+      def decorate(string)
+        [string, @backtrace].join("\n\t")
+      end
+    end
+
+    @exception_handlers = []
+    module_function
+
+    def with_backtrace(backtrace)
+      yield WithBacktrace.new(backtrace) if Celluloid.logger
+    end
+
+    # Send a debug message
+    def debug(string)
+      Celluloid.logger.debug(string) if Celluloid.logger
+    end
+
+    # Send a info message
+    def info(string)
+      Celluloid.logger.info(string) if Celluloid.logger
+    end
+
+    # Send a warning message
+    def warn(string)
+      Celluloid.logger.warn(string) if Celluloid.logger
+    end
+
+    # Send an error message
+    def error(string)
+      Celluloid.logger.error(string) if Celluloid.logger
+    end
+
+    # Handle a crash
+    def crash(string, exception)
+      string << "\n" << format_exception(exception)
+      error string
+
+      @exception_handlers.each do |handler|
+        begin
+          handler.call(exception)
+        rescue => ex
+          error "EXCEPTION HANDLER CRASHED:\n" << format_exception(ex)
+        end
+      end
+    end
+
+    # Note a deprecation
+    def deprecate(message)
+      trace = caller.join("\n\t")
+      warn "DEPRECATION WARNING: #{message}\n\t#{trace}"
+    end
+
+    # Define an exception handler
+    # NOTE: These should be defined at application start time
+    def exception_handler(&block)
+      @exception_handlers << block
+      nil
+    end
+
+    # Format an exception message
+    def format_exception(exception)
+      str = "#{exception.class}: #{exception.to_s}\n\t"
+      if exception.backtrace
+        str << exception.backtrace.join("\n\t")
+      else
+        str << "EMPTY BACKTRACE\n\t"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Celluloid
+  # Wraps all events and context for a single incident.
+  class Incident
+    attr_accessor :pid
+    attr_accessor :events, :triggering_event
+
+    def initialize(events, triggering_event=nil)
+      @events = events
+      @triggering_event = triggering_event
+      @pid = $$
+    end
+
+    # Merge two incidents together. This may be useful if two incidents occur at the same time.
+    def merge(*other_incidents)
+      merged_events = other_incidents.flatten.inject(events) do |events, incident|
+        events += incident.events
+      end
+      Incident.new(merged_events.sort, triggering_event)
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+require 'logger'
+module Celluloid
+  # A logger that holds all messages in circular buffers, then flushes the buffers
+  # when an event occurs at a configurable severity threshold.
+  #
+  # Unlike ruby's Logger, this class only supports a single progname.
+  class IncidentLogger
+    module Severity
+      include ::Logger::Severity
+
+      TRACE = -1
+
+      def severity_to_string(severity)
+        case severity
+        when TRACE   then 'TRACE'
+        when DEBUG   then 'DEBUG'
+        when INFO    then 'INFO'
+        when WARN    then 'WARN'
+        when ERROR   then 'ERROR'
+        when FATAL   then 'FATAL'
+        when UNKNOWN then 'UNKNOWN'
+        end
+      end
+
+    end
+    include Severity
+
+    # The progname (facility) for this instance.
+    attr_accessor :progname
+
+    # The logging level. Messages below this severity will not be logged at all.
+    attr_accessor :level
+
+    # The incident threshold. Messages at or above this severity will generate an
+    # incident and be published to incident reporters.
+    attr_accessor :threshold
+
+    # The buffer size limit. Each log level will retain this number of messages
+    # at maximum.
+    attr_accessor :sizelimit
+
+    attr_accessor :buffers
+
+    # Create a new IncidentLogger.
+    def initialize(progname=nil, options={})
+      @progname = progname || "default"
+      @level = options[:level] || DEBUG
+      @threshold = options[:threshold] || ERROR
+      @sizelimit = options[:sizelimit] || 100
+
+      @buffer_mutex = Mutex.new
+      @buffers = Hash.new do |progname_hash, _progname|
+        @buffer_mutex.synchronize do
+          progname_hash[_progname] = Hash.new do |severity_hash, severity|
+            severity_hash[severity] = RingBuffer.new(@sizelimit)
+          end
+        end
+      end
+
+      # When the IncidentLogger itself encounters an error, it falls back to logging to stderr
+      @fallback_logger = ::Logger.new(STDERR)
+      @fallback_logger.progname = "FALLBACK"
+    end
+
+    # add an event.
+    def add(severity, message=nil, progname=nil, &block)
+      progname ||= @progname
+      severity ||= UNKNOWN
+
+      if severity < @level
+        return event.id
+      end
+
+      if message.nil? && !block_given?
+        message = progname
+        progname = @progname
+      end
+
+      event = LogEvent.new(severity, message, progname, &block)
+
+      @buffers[progname][severity] << event
+
+      if severity >= @threshold
+        begin
+          Celluloid::Notifications.notifier.async.publish(incident_topic, create_incident(event))
+        rescue => ex
+          @fallback_logger.error(ex)
+        end
+      end
+      event.id
+    end
+    alias :log :add
+
+    # See docs for Logger#info
+    def trace   (progname=nil, &block); add(TRACE,   nil, progname, &block); end
+    def debug   (progname=nil, &block); add(DEBUG,   nil, progname, &block); end
+    def info    (progname=nil, &block); add(INFO,    nil, progname, &block); end
+    def warn    (progname=nil, &block); add(WARN,    nil, progname, &block); end
+    def error   (progname=nil, &block); add(ERROR,   nil, progname, &block); end
+    def fatal   (progname=nil, &block); add(FATAL,   nil, progname, &block); end
+    def unknown (progname=nil, &block); add(UNKNOWN, nil, progname, &block); end
+
+    def flush
+      messages = []
+      @buffer_mutex.synchronize do
+        @buffers.each do |progname, severities|
+          severities.each do |severity, buffer|
+            messages += buffer.flush
+          end
+        end
+      end
+      messages.sort
+    end
+
+    def clear
+      @buffer_mutex.synchronize do
+        @buffers.each { |buffer| buffer.clear }
+      end
+    end
+
+    def create_incident(event=nil)
+      Incident.new(flush, event)
+    end
+
+    def incident_topic
+      "log.incident.#{@progname}"
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'logger'
+module Celluloid
+  # Subscribes to log incident topics to report on them.
+  class IncidentReporter
+    include Celluloid
+    include Celluloid::Notifications
+
+    # get the time from the event
+    class Formatter < ::Logger::Formatter
+      def call(severity, time, progname, msg)
+        super(severity, msg.time, progname, msg.message)
+      end
+    end
+
+    def initialize(*args)
+      subscribe(/log\.incident/, :report)
+      @logger = ::Logger.new(*args)
+      @logger.formatter = Formatter.new
+      @silenced = false
+    end
+
+    def report(topic, incident)
+      return if @silenced
+
+      header = "INCIDENT"
+      header << " AT #{incident.triggering_event.time}" if incident.triggering_event
+      @logger << header
+      @logger << "\n"
+      @logger << "====================\n"
+      incident.events.each do |event|
+        @logger.add(event.severity, event, event.progname)
+      end
+      @logger << "====================\n"
+    end
+
+    def silence
+      @silenced = true
+    end
+
+    def unsilence
+      @silenced = false
+    end
+
+    def silenced?
+      @silenced
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Celluloid
+  # Wraps a single log event.
+  class LogEvent
+    attr_accessor :id, :severity, :message, :progname, :time
+
+    def initialize(severity, message, progname, time=Time.now, &block)
+      # This id should be ordered. For now relies on Celluloid::UUID to be ordered.
+      # May want to use a generation/counter strategy for independence of uuid.
+      @id = Celluloid::UUID.generate
+      @severity = severity
+      @message = block_given? ? yield : message
+      @progname = progname
+      @time = time
+    end
+
+    def <=>(other)
+      @id <=> other.id
+    end
+  end
+end