action_pubsub 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d4a0328f1cb7e3a3a0155c4b0957cd3dc566eaed
+  data.tar.gz: be1336cd5d743520ff2c97f6a6b3034357d197f3
+SHA512:
+  metadata.gz: ff793a319ee02b8d4cb58d14a0ce0cf3b6146e1211e6d3d5f20e73c559ff5b46174cc062dd4b49c7e0835072b23bcb13fa71014e076af0d22c254da5776ca6e9
+  data.tar.gz: b89adff807fb7cb898ad689df79d6dac365623f31f7e838330e56ea617175e2147e0d7117e75a72b75ff8048f8ec5d11bace7a537156379317b7013b4d5afbf7

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.0
+before_install: gem install bundler -v 1.10.3

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# gem "concurrent-ruby", :path => "~/gems/ruby-concurrency"
+# Specify your gem's dependencies in action_pubsub.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jason Ayre
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# ActionPubsub
+
+In process, concurrent observers, loosely modeled after rabbitmq
+
+## Example
+
+Lets say we have a blog app, and our posts have comments enabled on a case by case basis.
+When someone leaves a new comment, we want to blast out an email to everyone who
+has subscribed to recieve new posts
+
+In our comments model:
+
+``` ruby
+module Blogger
+  class Comment < ::ActiveRecord::Base
+    include ::ActionPubsub::ActiveRecord::Publishable
+    publish_as "blogger/comment"
+    publishable_actions :created, :updated
+  end
+end
+```
+
+Our subscriber:
+``` ruby
+module Blogger
+  class CommentSubscriber < ::ActionPubsub::ActiveRecord::Subscriber
+    #this is the "exchange" we want all of the events we are watching for, to be scoped to
+    #i.e. blogger/comment/created will end up being the fully qualified path for on :create
+    subscribe_to "blogger/comment"
+
+    self.concurrency = 5
+
+    on :created, :if => lambda{ |record| record.post.has_comments_enabled? } do
+      #on initialize right now subscriber instance will get a resource instance variable
+      #populated for free pertaining to the record in focus, i.e. a comment record
+      resource.post.commenters.by_new_comment_notifications_enabled.each do |commenter|
+        NewCommentNotificationMailer.deliver(resource, commenter)
+      end
+    end
+  end
+end
+```
+
+### What is the advantage of this pattern?
+
+The advantage is it makes your app incredibly reactive. Rather than have to fatten
+up your controller with logic that does not belong, or have some service object that
+does 20 things in sequence, it allows everything to be decoupled, only subscribe to
+the things that are relevant. It also enforces the single responsibility principle, by
+allowing these subscribers to exist in potentially different engines, or areas of your
+application, and do nothing but react to the events occurring within the system.
+
+### Callbacks
+
+Sure, we could use callbacks, but do we care about any of that if the record has
+not been commited to the database? (No we should not). Unless you use
+after_commit :on => :create, then your callbacks will attempt to run even if record hasn't been committed,
+unless at some point an error or false was returned.
+
+So as a best practice, we only broadcast the creation after it's been commited.
+
+This also allows for complex chains of events to occur, with no knowledge of each other,
+but that do their one job, and do it well. If that subscriber happens to create a new record,
+We can then subscribe to that models creation somewhere else, settings up the building blocks of a pipeline.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'action_pubsub'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install action_pubsub
+
+## Usage
+
+TODO: Work in progress
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/action_pubsub.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/action_pubsub.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'action_pubsub/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "action_pubsub"
+  spec.version       = ActionPubsub::VERSION
+  spec.authors       = ["Jason Ayre"]
+  spec.email         = ["jasonayre@gmail.com"]
+
+  spec.summary       = %q{In process, async, concurrent pubsub}
+  spec.description   = %q{In process, async, concurrent pubsub}
+  spec.homepage      = "http://github.com/jasonayre/action_pubsub"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "active_attr"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "concurrent-ruby"
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency 'guard', '~> 2'
+  spec.add_development_dependency 'guard-rspec', '~> 4'
+  spec.add_development_dependency 'guard-bundler', '~> 2'
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-pride"
+  spec.add_development_dependency 'rspec-its', '~> 1'
+  spec.add_development_dependency 'rspec-collection_matchers', '~> 1'
+  spec.add_development_dependency 'rb-fsevent'
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency 'terminal-notifier-guard'
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-nav"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "action_pubsub"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/action_pubsub.rb

@@ -0,0 +1,81 @@
+require "action_pubsub/version"
+require "active_support/all"
+require "concurrent"
+require "active_attr"
+require "concurrent/lazy_register"
+require "concurrent/actor"
+require "concurrent/agent"
+
+module ActionPubsub
+  extend ::ActiveSupport::Autoload
+
+  autoload :ActiveRecord
+  autoload :Config
+  autoload :Event
+  autoload :Exchange
+  autoload :ExchangeRegistry
+  autoload :Publish
+  autoload :Publishable
+  autoload :Logging
+  autoload :Subscriber
+  autoload :Queue
+
+  @configuration ||= ::ActionPubsub::Config.new
+
+  def self.event_count
+    @event_count ||= ::Concurrent::Agent.new(0)
+  end
+
+  def self.exchange_registry
+    @exchange_registry ||= ::ActionPubsub::ExchangeRegistry.new
+  end
+
+  @some_registry = ::Concurrent::LazyRegister.new
+
+  def self.destination_tuple_from_path(path_string)
+    segs = path_string.split("/")
+    worker_index = segs.pop
+    action = segs.pop
+
+    [segs.join("/"), action, worker_index]
+  end
+
+  def self.destination_tuple_from_sender_path(path_string)
+    segs = path_string.split("/")
+    action = segs.pop
+    [segs.join("/"), action]
+  end
+
+  def self.symbolize_routing_key(routing_key)
+    :"#{routing_key.split('.').join('_')}"
+  end
+
+  def self.publish_event(routing_key, event)
+    #need to loop through exchanges and publish to them
+    #maybe there is a better way to do this?
+    exchange_hash = ::ActionPubsub.exchanges[routing_key].instance_variable_get("@data").value
+    queue_names = exchange_hash.keys
+
+    queue_names.each do |queue_name|
+      exchange_registry[routing_key][queue_name] << serialize_event(event)
+    end
+  end
+
+  def self.serialize_event(event)
+    event
+  end
+
+  def self.deserialize_event(event)
+    event
+  end
+
+  class << self
+    attr_accessor :configuration
+    alias_method :config, :configuration
+    alias_method :exchanges, :exchange_registry
+
+    delegate :register_queue, :to => :exchange_registry
+    delegate :register_channel, :to => :exchange_registry
+    delegate :register_exchange, :to => :exchange_registry
+  end
+end

data/lib/action_pubsub/active_record.rb

@@ -0,0 +1,11 @@
+module ActionPubsub
+  module ActiveRecord
+    extend ::ActiveSupport::Autoload
+
+    autoload :Events
+    autoload :OnChange
+    autoload :Publishable
+    autoload :Subscriber
+    autoload :Subscription
+  end
+end

data/lib/action_pubsub/active_record/events.rb

@@ -0,0 +1,12 @@
+module ActionPubsub
+  module ActiveRecord
+    module Events
+      extend ::ActiveSupport::Autoload
+
+      autoload :Changed
+      autoload :Created
+      autoload :Destroyed
+      autoload :Updated
+    end
+  end
+end

data/lib/action_pubsub/active_record/events/changed.rb

@@ -0,0 +1,29 @@
+module ActionPubsub
+  module ActiveRecord
+    module Events
+      module Changed
+        extend ::ActiveSupport::Concern
+
+        included do
+          after_commit :publish_changed_event, :on => :update
+
+          routing_key = [exchange_prefix, "changed"].join("/")
+          ::ActionPubsub.register_exchange(routing_key)
+        end
+
+        def publish_changed_event
+          routing_key = [self.class.exchange_prefix, "changed"].join("/")
+
+          record_changed_event = ::ActionPubsub::Event.new(
+            :topic => routing_key,
+            :record => self
+          )
+
+          ::ActiveRecord::Base.connection_pool.with_connection do
+            ::ActionPubsub.publish_event(routing_key, record_changed_event)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_pubsub/active_record/events/created.rb

@@ -0,0 +1,29 @@
+module ActionPubsub
+  module ActiveRecord
+    module Events
+      module Created
+        extend ::ActiveSupport::Concern
+
+        included do
+          after_commit :publish_created_event, :on => :create
+
+          routing_key = [exchange_prefix, "created"].join("/")
+          ::ActionPubsub.register_exchange(routing_key)
+        end
+
+        def publish_created_event
+          routing_key = [self.class.exchange_prefix, "created"].join("/")
+
+          record_created_event = ::ActionPubsub::Event.new(
+            :topic => routing_key,
+            :record => self
+          )
+
+          ::ActiveRecord::Base.connection_pool.with_connection do
+            ::ActionPubsub.publish_event(routing_key, record_created_event)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_pubsub/active_record/events/destroyed.rb

@@ -0,0 +1,29 @@
+module ActionPubsub
+  module ActiveRecord
+    module Events
+      module Destroyed
+        extend ::ActiveSupport::Concern
+
+        included do
+          after_commit :publish_destroyed_event, :on => :create
+
+          routing_key = [exchange_prefix, "destroyed"].join("/")
+          ::ActionPubsub.register_exchange(routing_key)
+        end
+
+        def publish_destroyed_event
+          routing_key = [self.class.exchange_prefix, "destroyed"].join("/")
+
+          record_destroyed_event = ::ActionPubsub::Event.new(
+            :topic => routing_key,
+            :record => self
+          )
+
+          ::ActiveRecord::Base.connection_pool.with_connection do
+            ::ActionPubsub.publish_event(routing_key, record_destroyed_event)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_pubsub/active_record/events/updated.rb

@@ -0,0 +1,29 @@
+module ActionPubsub
+  module ActiveRecord
+    module Events
+      module Updated
+        extend ::ActiveSupport::Concern
+
+        included do
+          after_commit :publish_updated_event, :on => :update
+
+          routing_key = [exchange_prefix, "updated"].join("/")
+          ::ActionPubsub.register_exchange(routing_key)
+        end
+
+        def publish_updated_event
+          routing_key = [self.class.exchange_prefix, "updated"].join("/")
+
+          record_updated_event = ::ActionPubsub::Event.new(
+            :topic => routing_key,
+            :record => self
+          )
+
+          ::ActiveRecord::Base.connection_pool.with_connection do
+            ::ActionPubsub.publish_event(routing_key, record_updated_event)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_pubsub/active_record/on_change.rb

@@ -0,0 +1,54 @@
+module ActionPubsub
+  module ActiveRecord
+    module OnChange
+      extend ::ActiveSupport::Concern
+
+      included do
+        class << self
+          attr_accessor :_on_change_watches
+        end
+
+        @_on_change_watches = {}.with_indifferent_access
+      end
+
+      module ClassMethods
+        def on_change(*attribute_names, &block)
+          options = attribute_names.extract_options!
+
+          attribute_names.each do |attribute|
+            @_on_change_watches[attribute] = { :block => block }
+            @_on_change_watches[attribute].merge!(options)
+          end
+
+          on :changed do |record|
+            record.previous_changes.each_pair do |k,vals|
+              if self.class.react_to_changed?(record, k, vals)
+                old_value, new_value = vals
+                self.instance_exec(new_value, old_value, &self.class.watched_attributes[k][:block])
+              end
+            end
+          end
+        end
+
+        def react_to_changed?(resource, attribute_name, value)
+          old_value, new_value = value
+          return false unless watching_attribute?(attribute_name)
+          result = true
+          result &&= old_value == watched_attributes[attribute_name][:from] if watched_attributes[attribute_name].key?(:from)
+          result &&= new_value == watched_attributes[attribute_name][:to] if watched_attributes[attribute_name].key?(:to)
+          result &&= watched_attributes[attribute_name][:if].call(resource) if watched_attributes[attribute_name].key?(:if)
+          result &&= !watched_attributes[attribute_name][:unless].call(resource) if watched_attributes[attribute_name].key?(:unless)
+          return result
+        end
+
+        def watching_attribute?(attribute_name)
+          watched_attributes.key?(attribute_name)
+        end
+
+        def watched_attributes
+          self.instance_variable_get(:@_on_change_watches)
+        end
+      end
+    end
+  end
+end

data/lib/action_pubsub/active_record/publishable.rb

@@ -0,0 +1,47 @@
+module ActionPubsub
+  module ActiveRecord
+    module Publishable
+      extend ActiveSupport::Concern
+
+      PUBLISHABLE_EVENTS = {
+        :changed =>   ::ActionPubsub::ActiveRecord::Events::Changed,
+        :updated =>   ::ActionPubsub::ActiveRecord::Events::Updated,
+        :created =>   ::ActionPubsub::ActiveRecord::Events::Created,
+        :destroyed => ::ActionPubsub::ActiveRecord::Events::Destroyed
+      }
+
+      included do
+        include ::ActiveModel::Dirty unless ancestors.include?(::ActiveModel::Dirty)
+
+        class_attribute :exchange_prefix
+
+        class << self
+          attr_accessor :_publishable_actions
+        end
+      end
+
+      def attributes_hash
+        hash = self.as_json
+        hash.merge!(:changes => previous_changes) if previous_changes && hash
+        hash.symbolize_keys! if hash
+        hash
+      end
+
+      private
+
+      module ClassMethods
+        def publish_as(_exchange_prefix)
+          self.exchange_prefix = _exchange_prefix
+        end
+
+        def publishable_actions(*actions)
+          @_publishable_actions = actions
+
+          actions.each do |action|
+            include PUBLISHABLE_EVENTS[action] unless ancestors.include?(PUBLISHABLE_EVENTS[action])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_pubsub/active_record/subscriber.rb

@@ -0,0 +1,90 @@
+module ActionPubsub
+  module ActiveRecord
+    class Subscriber
+      class_attribute :concurrency,
+                      :event_triggered_count,
+                      :event_processed_count,
+                      :event_failed_count,
+                      :observed_exchanges,
+                      :messages_received_count,
+                      :messages_processed_count,
+                      :queue,
+                      :reactions,
+                      :subscription
+
+      self.concurrency = 1
+
+      attr_accessor :resource, :current_event
+
+      #the indirection here with the "subscription" dynamically created class, is for the sake
+      #of making subscribers immutable and not storing instance state.
+      #i.e. subscription is the actual actor, which just instantiates this subscriber class
+      #and performs the task it needs to
+      def self.inherited(subklass)
+        subklass.subscription = subklass.const_set("Subscription", ::Class.new(::ActionPubsub::ActiveRecord::Subscription))
+        subklass.subscription.subscriber = subklass
+        subklass.reactions = {}
+        subklass.observed_exchanges = ::Set.new
+        subklass.event_triggered_count = ::Concurrent::AtomicFixnum.new(0)
+        subklass.event_failed_count = ::Concurrent::AtomicFixnum.new(0)
+        subklass.event_processed_count = ::Concurrent::AtomicFixnum.new(0)
+      end
+
+      def self.on(event_name, **options, &block)
+        reactions[event_name] = {}.tap do |hash|
+          hash[:block] = block
+          hash[:conditions] = options.extract!(:if, :unless)
+        end
+
+        register_reaction_to_event(event_name)
+      end
+
+      def self.increment_event_failed_count!
+        self.event_failed_count.increment
+      end
+
+      def self.increment_event_processed_count!
+        self.event_processed_count.increment
+      end
+
+      def self.increment_event_triggered_count!
+        self.event_triggered_count.increment
+      end
+
+      def self.subscribe_to(*exchanges)
+        exchanges.each{ |exchange| self.observed_exchanges << exchange }
+      end
+
+      def self.react?(event_name, reaction, record)
+        return false if reaction[:block].blank?
+        return true if reaction[:conditions].blank?
+        result = true
+        result &&= !reaction[:conditions][:unless].call(record) if reaction[:conditions].key?(:unless)
+        result &&= reaction[:conditions][:if].call(record) if reaction[:conditions].key?(:if)
+        return result
+      end
+
+      def self.register_reaction_to_event(event_name)
+        observed_exchanges.each do |exchange_prefix|
+          target_exchange = [exchange_prefix, event_name].join("/")
+          subscriber_key = name.underscore
+          queue_key = [target_exchange, subscriber_key].join("/")
+
+          ::ActionPubsub.register_queue(target_exchange, subscriber_key)
+
+          self.concurrency.times do |i|
+            self.subscription.spawn("#{queue_key}/#{i}") do
+              self.subscription.bind_subscription(target_exchange, subscriber_key)
+            end
+          end
+        end
+      end
+
+      ### Instance Methods ###
+      def initialize(record, event:nil)
+        @resource = record
+        @current_event = event if event
+      end
+    end
+  end
+end

data/lib/action_pubsub/active_record/subscription.rb

@@ -0,0 +1,27 @@
+module ActionPubsub
+  module ActiveRecord
+    class Subscription < ::Concurrent::Actor::Utils::AdHoc
+      class_attribute :subscriber
+
+      def self.bind_subscription(target_exchange, subscriber_key)
+        ::ActionPubsub.exchange_registry[target_exchange][subscriber_key] << :subscribe
+        -> message {
+          ::ActiveRecord::Base.connection_pool.with_connection do
+            message = ::ActionPubsub.deserialize_event(message)
+            reaction = self.class.subscriber.reactions[message["action"]]
+            record = message["record"]
+
+            if self.class.subscriber.react?(message["action"], reaction, record)
+              self.class.subscriber.increment_event_triggered_count!
+
+              subscriber_instance = self.class.subscriber.new(record)
+              subscriber_instance.instance_exec(record, &reaction[:block])
+            end
+
+            self.class.bind_subscription(target_exchange, subscriber_key)
+          end
+        }
+      end
+    end
+  end
+end

data/lib/action_pubsub/config.rb

@@ -0,0 +1,22 @@
+require 'active_support/ordered_options'
+
+module ActionPubsub
+  class Config < ::ActiveSupport::InheritableOptions
+    def initialize(*args)
+      super(*args)
+
+      self[:debug] = false
+      self[:serializer] = nil
+    end
+
+    def debug=(val)
+      ::Concurrent.use_stdlib_logger(Logger::DEBUG) if val
+    end
+
+    def serializer=(val)
+      if val && val.ancestors.include?(::ActiveSupport::Concern)
+        ::ActionPubsub.include(val)
+      end
+    end
+  end
+end

data/lib/action_pubsub/event.rb

@@ -0,0 +1,31 @@
+require 'active_model'
+
+module ActionPubsub
+  class Event
+    include ::ActiveAttr::Model
+    include ::ActiveModel::AttributeMethods
+
+    attribute :id
+    attribute :action
+    attribute :context
+    attribute :meta
+    attribute :name
+    attribute :occured_at
+    attribute :record
+    attribute :subject
+    attribute :topic
+
+    #attributes have to be set for purposes of marshaling
+    def initialize(topic:, record:nil, context: nil, **options)
+      self[:topic] = topic
+      self[:action] = topic.split("/").pop.to_sym
+      self[:meta] = options[:meta] || {}
+      self[:name] = topic
+      self[:record] = record
+      self[:id] = ::SecureRandom.hex
+      self[:subject] = options[:subject] || record.try(:class).try(:name)
+      self[:context] = context if context
+      self[:occured_at] ||= ::Time.now.to_i
+    end
+  end
+end

data/lib/action_pubsub/exchange_registry.rb

@@ -0,0 +1,15 @@
+module ActionPubsub
+  class ExchangeRegistry < ::Concurrent::LazyRegister
+    def register_queue(exchange_name, subscriber_name)
+      register_exchange(exchange_name) unless key?(exchange_name)
+      exchange_hash = self[exchange_name].instance_variable_get("@data").value
+      exchange_keys = exchange_hash.keys
+      queue_name = [exchange_name, subscriber_name].join("/")
+      self[exchange_name].add(subscriber_name) { ::ActionPubsub::Queue.spawn(queue_name) }
+    end
+
+    def register_exchange(exchange_name)
+      add(exchange_name) { ::Concurrent::LazyRegister.new }
+    end
+  end
+end

data/lib/action_pubsub/queue.rb

@@ -0,0 +1,4 @@
+module ActionPubsub
+  class Queue < ::Concurrent::Actor::Utils::Balancer
+  end
+end

data/lib/action_pubsub/serialization.rb

@@ -0,0 +1,7 @@
+module ActionPubsub
+  module Serialization
+    extend ::ActiveSupport::Autoload
+
+    autoload :Marshal
+  end
+end

data/lib/action_pubsub/serialization/marshal.rb

@@ -0,0 +1,17 @@
+module ActionPubsub
+  module Serialization
+    module Marshal
+      extend ActiveSupport::Concern
+
+      module Marshal
+        def self.serialize_event(event)
+          ::Marshal.dump(super(event))
+        end
+
+        def self.deserialize_event(event)
+          ::Marshal.load(super(event))
+        end
+      end
+    end
+  end
+end

data/lib/action_pubsub/subscriber.rb

@@ -0,0 +1,39 @@
+### NOTE: Don't use this. Only the active record subscriber is working ATM.
+module ActionPubsub
+  class Subscriber < ::Concurrent::Actor::Utils::AdHoc
+    class_attribute :concurrency, :queue, :exchange_prefix, :watches
+    self.concurrency = 1
+
+    def self.inherited(subklass)
+      subklass.watches = {}
+    end
+
+    def self.register_event_watcher(event_name)
+      target_exchange = [exchange_prefix, event_name].join("/")
+      subscriber_key = name.underscore
+      queue_key = [target_exchange, subscriber_key].join("/")
+
+      ::ActionPubsub.register_queue(target_exchange, subscriber_key)
+
+      self.concurrency.times do |i|
+        spawn("#{queue_key}/#{i}") do
+          bind_subscription(target_exchange, subscriber_key)
+        end
+      end
+    end
+
+    def self.on(event_name, &block)
+      watches[event_name] = block
+      register_event_watcher(event_name)
+    end
+
+    def self.bind_subscription(target_exchange, subscriber_key)
+      ::ActionPubsub.exchange_registry[target_exchange][subscriber_key] << :subscribe
+      -> message {
+        self.class.watches[message["action"]].call(message["record"])
+
+        self.class.bind_subscription(target_exchange, subscriber_key)
+      }
+    end
+  end
+end

data/lib/action_pubsub/version.rb

@@ -0,0 +1,3 @@
+module ActionPubsub
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,311 @@
+--- !ruby/object:Gem::Specification
+name: action_pubsub
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jason Ayre
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_attr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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-pride
+  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-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  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: simplecov
+  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: terminal-notifier-guard
+  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: pry
+  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: pry-nav
+  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: In process, async, concurrent pubsub
+email:
+- jasonayre@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- action_pubsub.gemspec
+- bin/console
+- bin/setup
+- lib/action_pubsub.rb
+- lib/action_pubsub/active_record.rb
+- lib/action_pubsub/active_record/events.rb
+- lib/action_pubsub/active_record/events/changed.rb
+- lib/action_pubsub/active_record/events/created.rb
+- lib/action_pubsub/active_record/events/destroyed.rb
+- lib/action_pubsub/active_record/events/updated.rb
+- lib/action_pubsub/active_record/on_change.rb
+- lib/action_pubsub/active_record/publishable.rb
+- lib/action_pubsub/active_record/subscriber.rb
+- lib/action_pubsub/active_record/subscription.rb
+- lib/action_pubsub/config.rb
+- lib/action_pubsub/event.rb
+- lib/action_pubsub/exchange_registry.rb
+- lib/action_pubsub/queue.rb
+- lib/action_pubsub/serialization.rb
+- lib/action_pubsub/serialization/marshal.rb
+- lib/action_pubsub/subscriber.rb
+- lib/action_pubsub/version.rb
+homepage: http://github.com/jasonayre/action_pubsub
+licenses:
+- MIT
+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: In process, async, concurrent pubsub
+test_files: []