ribbon-event_bus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c83efffe844e2c1892b1e481097a5831aedf70ee
+  data.tar.gz: 186b25081e035b0b0ce0a2eb471fea5aee74b260
+SHA512:
+  metadata.gz: ffd5b13af305094619bfc9b9fd51fa3df095b2fee5b1a037b4f79eebd09ad0848661d78e96d27f44aadf3af882fa709cdd71895f9e253ee5ca94551220ebf54d
+  data.tar.gz: 6c9ef7a77f6b8934edb74e206d7ae785ddf9738fe4f5d72c89602f9d8d668653a1b1030b3d60fb3dc37a71f0f05fbdce6190d138e5cb2cbc736ae9caba5c34d9

data/config/defaults.yml

@@ -0,0 +1,12 @@
+subscriptions:
+  default_priority: medium
+
+publishers:
+  resque:
+    publisher_queue: publisher
+    subscription_queue_format: 'subscriptions_p%{priority}'
+
+  remote_resque:
+    queue: publisher
+    redis_namespace: resque
+    subscription_queue_format: 'subscriptions_p%{priority}'

data/lib/ribbon/event_bus/config.rb

@@ -0,0 +1,134 @@
+require 'yaml'
+
+module Ribbon::EventBus
+  class Config
+    # Putting this here instead of in Errors because I may move this into a
+    # separate gem.
+    class ConfigError < StandardError; end
+    class NotAddableError < ConfigError; end
+
+    class ProcArray < Array
+      def push(*procs)
+        raise ConfigError, "May only add blocks" unless procs.all? { |p| p.is_a?(Proc) }
+        super
+      end
+
+      def call(*args, &block)
+        map { |x| x.call(*args, &block) }
+      end
+    end
+
+    attr_reader :name
+
+    def initialize(name=nil, &block)
+      @name = name
+      define(&block) if block_given?
+    end
+
+    def define(&block)
+      case block.arity
+      when 0 then instance_eval(&block)
+      when 1 then block.call(self)
+      else   raise ConfigError, 'invalid config block arity'
+      end
+    end
+
+    # Deep dup all the values.
+    def dup
+      super.tap do |new_config|
+        new_config.instance_variable_set(
+          :@_nested,
+          Hash[
+            _nested.map { |key, object|
+              [
+                key,
+                object.is_a?(Config) ? object.dup : object
+              ]
+            }
+          ]
+        )
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      meth_str = meth.to_s
+
+      if /^(\w+)\=$/.match(meth_str)
+        _set($1, *args, &block)
+      elsif args.length > 0 || block_given?
+        _add(meth, *args, &block)
+      elsif /^(\w+)\?$/.match(meth_str)
+        !!_get($1)
+      else
+        object = _get(meth)
+        object = _set(meth, Config.new((name ? "#{name}." : '') + meth_str)) unless object
+        object
+      end
+    end
+
+    def nested(name)
+      _nested[name.to_sym]
+    end
+
+    def nest_value(name, value)
+      nested()
+    end
+
+    def nested_values(key)
+      _nested_values[key.to_sym]
+    end
+
+    def nested_configs(namespace)
+      _nested_configs[namespace.to_sym]
+    end
+
+    def merge_hash!(hash)
+      hash.each { |k, v|
+        if v.is_a?(Hash)
+          send(k).merge_hash!(v)
+        else
+          send("#{k}=", v)
+        end
+      }
+
+      self
+    end
+
+    def merge_config_file!(file)
+      merge_hash!(YAML.load_file(file))
+    end
+
+    private
+    def _get(key)
+      _nested[key.to_sym]
+    end
+
+    def _set(key, *args, &block)
+      object = _args_to_object(*args, &block)
+      _nested[key.to_sym] = object
+    end
+
+    def _add(key, *args, &block)
+      raise NotAddableError, self.inspect if @_value && !@_value.is_a?(Array)
+      object = _args_to_object(*args, &block)
+      _set(key, object.is_a?(Proc) ? ProcArray.new : []) unless _get(key)
+      _get(key).push(object)
+    end
+
+    def _args_to_object(*args, &block)
+      if args.length == 1
+        args.first
+      elsif args.length > 1
+        args
+      elsif block_given?
+        block
+      else
+        raise ConfigError, 'must pass value or block'
+      end
+    end
+
+    def _nested
+      @_nested ||= {}
+    end
+  end # Config
+end # Ribbon::EventBus

data/lib/ribbon/event_bus/errors.rb

@@ -0,0 +1,49 @@
+module Ribbon::EventBus
+  module Errors
+    class Error < StandardError; end
+    class DuplicateInstanceNameError < Error; end
+    class NoPublishersDefinedError < Error; end
+
+    ###
+    # Instance Errors
+    ###
+    class InstanceError < Error; end
+
+    ###
+    # Event Errors
+    ###
+    class EventError < Error; end
+    class UnsafeValueError < EventError
+      def initialize(key, value)
+        super("#{key.inspect} => #{value.inspect}")
+      end
+    end # UnsafeValueError
+
+    ###
+    # Subscription Errors
+    ###
+    class SubscriptionError < Error; end
+    class InvalidPriorityError < SubscriptionError; end
+    class UnexpectedEventError < SubscriptionError; end
+
+    ###
+    # Publisher Errors
+    ###
+    class PublisherError < Error; end
+    class InvalidPublisherError < PublisherError; end
+    class InvalidPublisherNameError < PublisherError; end
+
+    # RemoteResquePublisher Errors
+    class RemoteResquePublisherError < PublisherError; end
+
+    # ProcPublisherErrors
+    class ProcPublisherError < PublisherError; end
+    class MissingProcError < ProcPublisherError; end
+    class InvalidArityError < ProcPublisherError; end
+
+    ###
+    # Serializable Errors
+    ###
+    class SerializableError < Error; end
+  end
+end

data/lib/ribbon/event_bus/event.rb

@@ -0,0 +1,85 @@
+module Ribbon::EventBus
+  class Event
+    include Mixins::HasInstance
+    include Mixins::HasConfig
+    include Mixins::Serializable
+
+    config_key :events
+    serialize_with :name, :instance, :params
+
+    attr_reader :name
+    attr_reader :params
+
+    def initialize(name, params={})
+      raise ArgumentError, 'missing event name' unless name.respond_to?(:to_sym)
+      @name = name.to_sym
+      _evaluate_params(params)
+    end
+
+    def self.load_from_serialized(name, instance, params)
+      new(name, params.merge(instance: instance))
+    end
+
+    def [](key)
+      params[key]
+    end
+
+    def publish
+      instance.publishers.each { |p| p.publish(self) }
+    end
+
+    def subscriptions
+      instance.subscriptions_to(self)
+    end
+
+    private
+
+    ############################################################################
+    # Parameter Evaluation Logic
+    #
+    # This evaluates the parameters passed to the initializer.
+    ############################################################################
+
+    ###
+    # Root evaluation method.
+    ###
+    def _evaluate_params(params)
+      unless params.is_a?(Hash)
+        raise ArgumentError, 'event parameters must be a hash'
+      end
+
+      params = params.dup
+      @instance = params.delete(:instance)
+      @params = _sanitize_params(params)
+    end
+
+    ###
+    # Sanitize the event params.
+    # Prevents passing values that could cause errors later in the EventBus.
+    ###
+    def _sanitize_params(params)
+      Hash[params.map { |key, value| [key.to_sym, _sanitize_value(key, value)] }].freeze
+    end
+
+    # Sanitize an array.
+    def _sanitize_array(key, array)
+      array.map { |value| _sanitize_value(key, value) }.freeze
+    end
+
+    # Sanitize an individual value.
+    def _sanitize_value(key, value)
+      case value
+      when String
+        value.dup.freeze
+      when Symbol, Integer, Float, NilClass, TrueClass, FalseClass
+        value
+      when Array
+        _sanitize_array(key, value)
+      when Hash
+        _sanitize_params(value)
+      else
+        raise Errors::UnsafeValueError.new(key, value)
+      end
+    end
+  end # Event
+end # Ribbon::EventBus

data/lib/ribbon/event_bus/instance.rb

@@ -0,0 +1,111 @@
+module Ribbon
+  module EventBus
+    DEFAULT_CONFIG_PATH = File.expand_path('../../../../config/defaults.yml', __FILE__).freeze
+
+    ##############################################################################
+    # Instance
+    #
+    # Represents an instance of the EventBus. Allows multiple Instances to be
+    # created with separate configuration, subscriptions, etc. Primarily intended
+    # to help testing, but there are practical use-cases as well.
+    ##############################################################################
+    class Instance
+      include Mixins::Serializable
+
+      serialize_with :name
+
+      attr_reader :name
+      attr_reader :publishers
+
+      def initialize(name=nil)
+        if name
+          @name = name.to_sym
+          EventBus._register_instance(self) if @name
+        end
+
+        _load_default_config
+      end
+
+      def self.load_from_serialized(name)
+        if name
+          EventBus.instance(name)
+        else
+          raise Errors::InstanceError, "Can't deserialize an unnamed Instance"
+        end
+      end
+
+      def config(&block)
+        (@__config ||= Config.new).tap { |config|
+          if block_given?
+            config.define(&block)
+            _process_config
+          end
+        }
+      end
+
+      def publish(*args)
+        raise Errors::NoPublishersDefinedError unless publishers && !publishers.empty?
+        _args_to_event(*args).publish
+      end
+
+      def subscribe_to(event_name, params={}, &block)
+        Subscription.new(event_name, params.merge(instance: self), &block)
+      end
+
+      def subscriptions_to(event_or_name)
+        event_name = event_or_name.is_a?(Event) ? event_or_name.name : event_or_name.to_sym
+        _registered_subscriptions_to(event_name).dup
+      end
+
+      def find_subscription(locator)
+        _subscriptions_by_locators[locator]
+      end
+
+      def _register_subscription(subscription)
+        if _subscriptions_by_locators[subscription.locator]
+          # This is not expected to occur
+          raise Errors::SubscriptionError, "duplicate locator: #{subscription.locator.inspect}"
+        else
+          _subscriptions_by_locators[subscription.locator] = subscription
+       end
+
+        _registered_subscriptions_to(subscription.event_name)
+          .push(subscription)
+          .sort! { |x, y| x.priority <=> y.priority }
+      end
+
+      private
+      def _registered_subscriptions_to(event_name)
+        (@__registered_subscriptions ||= {})[event_name] ||= []
+      end
+
+      def _subscriptions_by_locators
+        @__registered_subscriptions_by_locator ||= {}
+      end
+
+      def _load_default_config
+        config.merge_config_file!(DEFAULT_CONFIG_PATH)
+      end
+
+      # Attempt to convert *args to an event object.
+      def _args_to_event(name_or_event, params={})
+        raise ArgumentError, 'event parameters must be a hash' unless params.is_a?(Hash)
+
+        case name_or_event
+        when Event
+          name_or_event.tap { |e| e.instance_variable_set(:@instance, self) }
+        else
+          Event.new(name_or_event, params.merge(instance: self))
+        end
+      end # _args_to_event
+
+      def _process_config
+        @publishers = _load_publishers.dup.freeze
+      end
+
+      def _load_publishers
+        Publishers.load_for_instance(self)
+      end
+    end # Instance
+  end # EventBus
+end # Ribbon

data/lib/ribbon/event_bus/mixins/has_config.rb

@@ -0,0 +1,45 @@
+module Ribbon::EventBus
+  module Mixins
+    module HasConfig
+      def self.included(base)
+        raise "HasConfig requires HasInstance" unless base < HasInstance
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def config_key(key)
+          config_keys << key.to_sym
+        end
+
+        def config_keys(*keys)
+          unless keys.empty?
+            _has_config_values[:keys] = keys.map(&:to_sym)
+          else
+            _has_config_values[:keys] ||= _has_config_ancestor_keys
+          end
+        end
+
+        def _has_config_ancestor_keys
+          ancestors[1] < HasConfig ? ancestors[1].config_keys.dup : []
+        end
+
+        def _has_config_values
+          @__has_config_values ||= {}
+        end
+      end
+
+      def config
+        _has_config_config
+      end
+
+      def _has_config_config
+        @__has_config_config ||= _has_config_load_config.dup
+      end
+
+      def _has_config_load_config
+        keys = self.class.config_keys
+        keys.inject(instance.config) { |c, k| c.send(k) }
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/mixins/has_instance.rb

@@ -0,0 +1,9 @@
+module Ribbon
+  module EventBus::Mixins
+    module HasInstance
+      def instance
+        (defined?(@instance) && @instance) || EventBus.instance
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/mixins/serializable.rb

@@ -0,0 +1,183 @@
+require 'base64'
+
+module Ribbon::EventBus
+  module Mixins
+    module Serializable
+      MAGIC = :SRLZ
+      VERSION = 1
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def serialize_with(*args)
+          _serializable_values[:args] = args.map(&:to_sym)
+        end
+
+        def deserialize(encoded)
+          marshalled = _serializable_decode(encoded)
+          package = _serializable_unmarshal(marshalled)
+          _serializable_load_package(package)
+        end
+
+        def _serializable_load_package(package)
+          klass, args = _serializable_unpackage(package)
+          klass._deserialize_args(args)
+        end
+
+        def _deserialize_args(args)
+          args = args.map { |arg| _deserialize_arg(arg) }
+
+          if respond_to?(:load_from_serialized)
+            load_from_serialized(*args)
+          else
+            new(*args)
+          end
+        end
+
+        def _deserialize_arg(arg)
+          if _serializable_valid_package?(arg, false)
+            _serializable_load_package(arg)
+          else
+            arg
+          end
+        end
+
+        ###
+        # Encoding
+        ###
+        def _serializable_encode(marshalled)
+          Base64.strict_encode64(marshalled) # => encoded
+        end
+
+        def _serializable_decode(encoded)
+          begin
+            Base64.strict_decode64(encoded) # => marshalled
+          rescue ArgumentError
+            raise Errors::SerializableError, 'serialized string not encoded properly'
+          end
+        end
+
+        ###
+        # Marshalling
+        ###
+        def _serializable_marshal(package)
+          Marshal.dump(package) # => marshalled
+        end
+
+        def _serializable_unmarshal(marshalled)
+          begin
+            Marshal.load(marshalled) # => package
+          rescue TypeError
+            raise Errors::SerializableError, 'incorrect format'
+          end
+        end
+
+        ###
+        # Class Encoding
+        ###
+
+        def _serializable_encode_class(klass)
+          klass.name.to_s.sub('Ribbon::EventBus::', '').to_sym
+        end
+
+        def _serializable_decode_class(encoded_klass)
+          Ribbon::EventBus.const_get(encoded_klass.to_s)
+        end
+
+        ###
+        # Packaging
+        ###
+        def _serializable_package(klass, args)
+          encoded_klass = _serializable_encode_class(klass)
+          [MAGIC, VERSION, encoded_klass] + args # => package
+        end
+
+        def _serializable_valid_package?(package, noisy=true)
+          unless package.is_a?(Array)
+            if noisy
+              raise Errors::SerializableError, 'not a package'
+            else
+              return false
+            end
+          end
+
+          magic, version, class_name = package
+
+          # Check Magic
+          unless magic == MAGIC
+            if noisy
+              raise Errors::SerializableError, 'invalid serialized package'
+            else
+              return false
+            end
+          end
+
+          # Check Version
+          unless version == VERSION
+            if noisy
+              raise Errors::SerializableError, 'unsupported package version'
+            else
+              return false
+            end
+          end
+
+          # Check Class Name
+          unless class_name.is_a?(Symbol)
+            if noisy
+              raise Errors::SerializableError, 'invalid class name'
+            else
+              return false
+            end
+          end
+
+          return true
+        end
+
+        def _serializable_unpackage(package)
+          _serializable_valid_package?(package)
+          magic, version, encoded_klass, *args = package
+          klass = _serializable_decode_class(encoded_klass)
+          [klass, args]
+        end
+
+        ###
+        # Helpers
+        ###
+        def _serializable_values
+          @__serializable_values ||= {}
+        end
+
+        def _serializable_args
+          _serializable_values[:args] or
+            raise Errors::SerializableError, "Missing serialize_with definition"
+        end
+      end
+
+      def serialize
+        package = _serializable_package
+        marshalled = self.class._serializable_marshal(package)
+        self.class._serializable_encode(marshalled)
+      end
+
+      def _serializable_package
+        args = _serializable_args.map { |arg| _serialize_arg(send(arg)) }
+        self.class._serializable_package(self.class, args)
+      end
+
+      def _serialize_arg(arg)
+        case arg
+        when Serializable
+          arg._serializable_package
+        else
+          arg
+        end
+      end
+
+      def _serializable_args
+        self.class._serializable_args
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/mixins.rb

@@ -0,0 +1,7 @@
+module Ribbon::EventBus
+  module Mixins
+    autoload(:HasInstance, 'ribbon/event_bus/mixins/has_instance')
+    autoload(:HasConfig, 'ribbon/event_bus/mixins/has_config')
+    autoload(:Serializable, 'ribbon/event_bus/mixins/serializable')
+  end
+end

data/lib/ribbon/event_bus/publishers/proc_publisher.rb

@@ -0,0 +1,22 @@
+module Ribbon::EventBus
+  module Publishers
+    class ProcPublisher < Publisher
+      def initialize(instance=nil, &block)
+        super
+
+        raise Errors::MissingProcError unless block_given?
+        raise Errors::InvalidArityError, 'Proc arity must be 1' unless block.arity == 1
+        @_block = block
+      end
+
+      def new(instance=nil)
+        self.class.new(instance, &@_block)
+      end
+
+      def publish(event)
+        super
+        @_block.call(event)
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/publishers/publisher.rb

@@ -0,0 +1,30 @@
+module Ribbon::EventBus
+  module Publishers
+    class Publisher
+      include Mixins::HasInstance
+      include Mixins::HasConfig
+      config_key :publishers
+
+      def initialize(instance=nil, params={})
+        @instance = instance
+        @_params = params
+      end
+
+      def config
+        @__config ||= super.merge_hash!(@_params)
+      end
+
+      ###
+      # #publish(event)
+      #
+      # This method should be overridden by a subclass. Make sure to call "super"
+      # so that proper sanity checks can be performed.
+      ###
+      def publish(event)
+        unless event.instance == instance
+          raise Errors::PublisherError, "Event for different instance"
+        end
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/publishers/remote_resque_publisher.rb

@@ -0,0 +1,82 @@
+require 'uri'
+require 'redis'
+require 'redis/namespace'
+
+module Ribbon::EventBus
+  module Publishers
+    class RemoteResquePublisher < Publisher
+      config_key :remote_resque
+
+      def publish(event)
+        super
+
+        # Based on Resque 1.25.2
+
+        # Resque call stack:
+        # -> Resque.enqueue(klass, *args)
+        # -> Resque.enqueue_to(queue, klass, *args)
+        # -> Job.create(queue, klass, *args)
+        # -> Resque.push(queue, class: klass.to_s, args: args)
+
+        # These should be the same as the args passed to Resque.enqueue in
+        # ResquePublisher#publish(event).
+        args = [
+          config.subscription_queue_format.to_s,
+          event.serialize
+        ]
+
+        enqueue_to(config.queue.to_s, Publishers::ResquePublisher::PublisherJob, *args)
+      end
+
+      def redis
+        @redis ||= _redis
+      end
+
+      private
+
+      ##########################################################################
+      # Methods copied from Resque v1.25.2
+      ##########################################################################
+
+      def enqueue_to(queue, klass, *args)
+        # This is a functionality copy, not a direct code copy.
+        # Here, I'm skipping the call to Job.create(queue, klass, *args) and
+        # calling push directly.
+        push(queue, class: klass.to_s, args: args)
+      end
+
+      # Resque::push(queue, items)
+      def push(queue, item)
+        redis.pipelined do
+          watch_queue(queue)
+          redis.rpush "queue:#{queue}", encode(item)
+        end
+      end
+
+      # Resque::watch_queue
+      def watch_queue(queue)
+        redis.sadd(:queues, queue.to_s)
+      end
+
+      def encode(object)
+        # This one we can call directly.
+        Resque.encode(object)
+      end
+
+      ##########################################################################
+      # Helper Methods
+      ##########################################################################
+
+      def _redis
+        if config.redis?
+          config.redis
+        elsif config.redis_url?
+          redis = Redis.connect(url: config.redis_url, thread_safe: true)
+          Redis::Namespace.new(config.redis_namespace.to_sym, redis: redis)
+        else
+          raise Errors::RemoteResquePublisherError, "missing redis configuration"
+        end
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/publishers/resque_publisher.rb

@@ -0,0 +1,52 @@
+require 'resque'
+
+module Ribbon::EventBus
+  module Publishers
+    class ResquePublisher < Publisher
+      config_key :resque
+
+      def publish(event)
+        super
+
+        unless event.subscriptions.empty?
+          PublisherJob.set_queue(config.publisher_queue.to_sym)
+          sub_queue_format = config.subscription_queue_format.to_s
+          Resque.enqueue(PublisherJob, sub_queue_format, event.serialize)
+        end
+      end
+
+      module PublisherJob
+        def self.set_queue(queue)
+          @queue = queue
+        end
+
+        def self.perform(sub_queue_format, serialized_event)
+          event = Event.deserialize(serialized_event)
+
+          event.subscriptions.each { |s|
+            SubscriptionJob.set_queue(
+              (sub_queue_format % {
+                event: event.name,
+                priority: s.priority
+              }).to_sym
+            )
+
+            Resque.enqueue(SubscriptionJob, s.serialize, event.serialize)
+          }
+        end
+      end
+
+      module SubscriptionJob
+        def self.set_queue(queue)
+          @queue = queue
+        end
+
+        def self.perform(serialized_sub, serialized_event)
+          subscription = Subscription.deserialize(serialized_sub)
+          event = Event.deserialize(serialized_event)
+          subscription.handle(event)
+        end
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/publishers/subscriptions_publisher.rb

@@ -0,0 +1,8 @@
+module Ribbon::EventBus::Publishers
+  class SubscriptionsPublisher < Publisher
+    def publish(event)
+      super
+      event.subscriptions.each { |subscription| subscription.handle(event) }
+    end
+  end
+end

data/lib/ribbon/event_bus/publishers.rb

@@ -0,0 +1,52 @@
+module Ribbon::EventBus
+  module Publishers
+    autoload(:Publisher,
+      'ribbon/event_bus/publishers/publisher')
+    autoload(:ProcPublisher,
+      'ribbon/event_bus/publishers/proc_publisher')
+    autoload(:SubscriptionsPublisher,
+      'ribbon/event_bus/publishers/subscriptions_publisher')
+    autoload(:ResquePublisher,
+      'ribbon/event_bus/publishers/resque_publisher')
+    autoload(:RemoteResquePublisher,
+      'ribbon/event_bus/publishers/remote_resque_publisher')
+
+    module_function
+    def load_for_instance(instance)
+      config = instance.config
+      config.publish_to? ? _load_for_instance(instance, config.publish_to) : []
+    end
+
+    def _load_for_instance(instance, publishers)
+      publishers.map { |publisher| _load_with_args(publisher, instance) }
+    end
+
+    def _load_with_args(publisher, *args)
+      case publisher
+      when Array
+        _load_with_args(publisher[0], *(args + publisher[1..-1]))
+      else
+        load(publisher).new(*args)
+      end
+    end
+
+    def load(publisher)
+      case publisher
+      when String, Symbol then _load_from_string(publisher.to_s)
+      when Proc           then _load_from_proc(publisher)
+      when Publisher      then publisher
+      else raise Errors::InvalidPublisherError, publisher.inspect
+      end
+    end
+
+    def _load_from_string(publisher_name)
+      const_get((publisher_name.split('_').map(&:capitalize) + ['Publisher']).join)
+    rescue NameError
+      raise Errors::InvalidPublisherNameError, publisher_name
+    end
+
+    def _load_from_proc(publisher_proc)
+      ProcPublisher.new(&publisher_proc)
+    end
+  end
+end

data/lib/ribbon/event_bus/subscription.rb

@@ -0,0 +1,118 @@
+require 'digest'
+
+module Ribbon::EventBus
+  class Subscription
+    include Mixins::HasInstance
+    include Mixins::HasConfig
+    include Mixins::Serializable
+
+    config_key :subscriptions
+    serialize_with :instance, :locator
+
+    attr_reader :event_name
+    attr_reader :priority
+    attr_reader :locator
+
+    PRIORITY_SYMBOL_TO_INTEGER_MAP = {
+      highest: 1,
+      high: 3,
+      medium: 5,
+      low: 7,
+      lowest: 10
+    }.freeze
+
+    def initialize(event_name, params={}, &block)
+      @event_name = event_name.to_sym
+      @_block = block
+
+      _evaluate_params(params)
+      _generate_locator
+
+      instance._register_subscription(self)
+    end
+
+    def self.load_from_serialized(instance, locator)
+      instance.find_subscription(locator)
+    end
+
+    def handle(event)
+      raise Errors::UnexpectedEventError, 'wrong name' unless event.name == event_name
+      raise Errors::UnexpectedEventError, 'wrong instance' unless event.instance == instance
+      @_block.call(event)
+    end
+
+    private
+
+    def _generate_locator
+      path = File.expand_path('../..', __FILE__)
+      non_event_bus_caller = caller.find { |c| !c.start_with?(path) }
+
+      unless non_event_bus_caller
+        # This is not expected to occur.
+        raise Errors::SubscriptionError, "Could not find non-EventBus caller"
+      end
+
+      @locator = Digest::MD5.hexdigest(non_event_bus_caller).to_sym
+    end
+
+    ############################################################################
+    # Parameter Evaluation Logic
+    #
+    # This evaluates the parameters passed to the initializer.
+    ############################################################################
+
+    ###
+    # Root evaluation method.
+    ###
+    def _evaluate_params(params)
+      params = params.dup
+      @instance = params.delete(:instance)
+      @priority = _evaluate_priority(params.delete(:priority))
+    end
+
+    ###
+    # Priority evaluation
+    ###
+    def _evaluate_priority(priority)
+      case priority
+      when Integer
+        _evaluate_priority_int(priority)
+      when String, Symbol
+        _evaluate_priority_symbol(priority.to_sym)
+      when NilClass
+        _evaluate_priority_nil
+      else
+        raise Errors::InvalidPriorityError, priority.inspect
+      end
+    end
+
+    # Evaluate an integer as a priority.
+    def _evaluate_priority_int(int)
+      raise Errors::InvalidPriorityError, int unless int > 0 && int <= 10
+      int
+    end
+
+    # Evaluate a symbol as a priority.
+    def _evaluate_priority_symbol(sym)
+      if (priority = PRIORITY_SYMBOL_TO_INTEGER_MAP[sym])
+        _evaluate_priority(priority)
+      else
+        raise Errors::InvalidPriorityError, sym.inspect
+      end
+    end
+
+    # Evaluate nil as a priority.
+    def _evaluate_priority_nil
+      # Need to specify value explicitly here, otherwise in the call to
+      # _evaluate_priority, the case statement won't recognize it as a Symbol.
+      # That's because when calls Symbol::=== to evaluate a match.
+      priority = config.default_priority
+
+      if priority
+        _evaluate_priority(priority)
+      else
+        raise Errors::InvalidPriorityError, priority.inspect
+      end
+    end
+  end # Event
+end # Ribbon::EventBus

data/lib/ribbon/event_bus/version.rb

@@ -0,0 +1,5 @@
+module Ribbon
+  module EventBus
+    VERSION = "0.1.0"
+  end
+end

data/lib/ribbon/event_bus.rb

@@ -0,0 +1,36 @@
+module Ribbon
+  module EventBus
+    autoload(:Instance, 'ribbon/event_bus/instance')
+    autoload(:Errors, 'ribbon/event_bus/errors')
+    autoload(:Config, 'ribbon/event_bus/config')
+    autoload(:Event, 'ribbon/event_bus/event')
+    autoload(:Subscription, 'ribbon/event_bus/subscription')
+    autoload(:Publishers, 'ribbon/event_bus/publishers')
+    autoload(:Mixins, 'ribbon/event_bus/mixins')
+
+    module_function
+
+    def method_missing(meth, *args, &block)
+      instance.send(meth, *args, &block)
+    end
+
+    def instance(name=:primary)
+      _registered_instances[name.to_sym] || Instance.new(name)
+    end
+
+    def _registered_instances
+      @__registered_instances ||= {}
+    end
+
+    def _register_instance(instance)
+      if _registered_instances.key?(instance.name)
+        raise Errors::DuplicateInstanceNameError, instance.name
+      else
+        _registered_instances[instance.name] = instance
+      end
+    end
+  end
+end
+
+# Create a shortcut
+EventBus = Ribbon::EventBus

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: ribbon-event_bus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Honer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.13
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.13
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.2
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An asynchronous event bus for Ruby.
+email:
+- robert@ribbonpayments.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- config/defaults.yml
+- lib/ribbon/event_bus.rb
+- lib/ribbon/event_bus/config.rb
+- lib/ribbon/event_bus/errors.rb
+- lib/ribbon/event_bus/event.rb
+- lib/ribbon/event_bus/instance.rb
+- lib/ribbon/event_bus/mixins.rb
+- lib/ribbon/event_bus/mixins/has_config.rb
+- lib/ribbon/event_bus/mixins/has_instance.rb
+- lib/ribbon/event_bus/mixins/serializable.rb
+- lib/ribbon/event_bus/publishers.rb
+- lib/ribbon/event_bus/publishers/proc_publisher.rb
+- lib/ribbon/event_bus/publishers/publisher.rb
+- lib/ribbon/event_bus/publishers/remote_resque_publisher.rb
+- lib/ribbon/event_bus/publishers/resque_publisher.rb
+- lib/ribbon/event_bus/publishers/subscriptions_publisher.rb
+- lib/ribbon/event_bus/subscription.rb
+- lib/ribbon/event_bus/version.rb
+homepage: http://github.com/ribbon/event_bus
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: An asynchronous event bus for Ruby.
+test_files: []