multiple_man 0.2.8 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4aca370dc2ba93f3a1703694822843229713bb8
-  data.tar.gz: ebd87ecb2c839afb85303aa5d2fb3f7d60c05c40
+  metadata.gz: e9fe7925c120cc5b704a13b62378b3b459da3b31
+  data.tar.gz: 21d3d6b079125195a0e85b398b5f106e21836a65
 SHA512:
-  metadata.gz: 2a49c5c3d3a4ad069fa15be3873d495068284fdd50f13b3e57c4b6ddeef9b77095d78679195b297442b9ab268fcd4285442794eab9b1f97696698b09f1211689
-  data.tar.gz: 5048241efb03470580873823d5b16d62b7a9790d1ba6fdc0c76b0a9f488529af1fb064164ca7e7921e1464bf895a9eb2c9cea4a497302105a94c31c3108444fa
+  metadata.gz: 0bfec446ad1b8f131216f4493a2a63b61febbcefd1a5974ae7d8a1a9e91f22401f4bd20ab080a560e48e728afdfc0bee8b094fa696e8c7b6636eab856c644d48
+  data.tar.gz: adf476aed9b285617450d42cb823febeda32864bc1ebe9e844abd15dd21c30c22abc5b5d661ca87cc601bff75f8c01f35492b24f9fb1d855081da61b1f0c9fd8

data/lib/multiple_man/attribute_extractor.rb

@@ -3,33 +3,21 @@ require 'json'
 module MultipleMan
   class AttributeExtractor
 
-    def initialize(record, fields, identifier)
+    def initialize(record, fields)
       raise "Fields must be specified" unless fields
       
       self.record = record
-      self.fields = fields 
-      self.identifier = identifier || :id
+      self.fields = fields
     end
 
     def data
-      {
-        id: identifier_for_record,
-        data: Hash[fields.map do |field|
-          [field, record.send(field)]
-        end]
-      }
+      Hash[fields.map do |field|
+        [field, record.send(field)]
+      end]
     end
 
-    def identifier_for_record
-      if identifier.class == Proc
-        identifier.call(record)
-      else
-        record.send(identifier)
-      end
-    end
-
-    def to_json
-      data.to_json
+    def as_json
+      data
     end
 
   private

data/lib/multiple_man/connection.rb

@@ -1,12 +1,13 @@
 require 'bunny'
 require 'connection_pool'
+require 'active_support/core_ext/module'
 
 module MultipleMan
   class Connection
     def self.connection
       @connection ||= begin
         connection = Bunny.new(MultipleMan.configuration.connection)
-        MultipleMan.logger.info "Connecting to #{MultipleMan.configuration.connection}"
+        MultipleMan.logger.debug "Connecting to #{MultipleMan.configuration.connection}"
         connection.start
         connection
       end

data/lib/multiple_man/identity.rb

@@ -0,0 +1,18 @@
+module MultipleMan
+  class Identity
+    def initialize(record, identifier = :id)
+      self.record = record
+      self.identifier = identifier || :id
+    end
+
+    def value
+      if identifier.class == Proc
+        identifier.call(record).to_s
+      else
+        record.send(identifier).to_s
+      end
+    end
+
+    attr_accessor :record, :identifier
+  end
+end

data/lib/multiple_man/listener.rb

@@ -6,9 +6,11 @@ module MultipleMan
 
     class << self
       def start(connection)
-        MultipleMan.logger.info "Starting listeners."
+        MultipleMan.logger.debug "Starting listeners."
         self.connection = connection
-        ModelSubscriber.subscriptions.each do |subscription|
+        MultipleMan.logger.debug Subscribers::Registry.subscriptions.to_json
+
+        Subscribers::Registry.subscriptions.each do |subscription|
           new(subscription).listen
         end
       end
@@ -35,10 +37,10 @@ module MultipleMan
         operation = delivery_info.routing_key.split(".").last
         subscription.send(operation, JSON.parse(payload).with_indifferent_access)
       rescue Exception => ex
-        MultipleMan.logger.error "   Error - #{ex.message}"
+        MultipleMan.logger.error "   Error - #{ex.message}\n\n#{ex.backtrace}"
         MultipleMan.error(ex)
       else
-        MultipleMan.logger.info "   Successfully processed!"
+        MultipleMan.logger.debug "   Successfully processed!"
       end
     end
 

data/lib/multiple_man/mixins/subscriber.rb

@@ -1,7 +1,13 @@
 module MultipleMan
   module Subscriber
     def Subscriber.included(base)
-      MultipleMan::ModelSubscriber.register(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def subscribe(options = {})
+        Subscribers::Registry.register(Subscribers::ModelSubscriber.new(self, options))
+      end
     end
   end
 end

data/lib/multiple_man/model_populator.rb

@@ -0,0 +1,37 @@
+module MultipleMan
+  class ModelPopulator
+
+    def initialize(record, fields)
+      self.record = record
+      self.fields = fields
+    end
+
+    def populate(data)
+      fields_for(data).each do |field|
+        populate_field(field, data[field])
+      end
+      record
+    end
+
+  private 
+    attr_accessor :record, :fields
+
+    # Raise an exception if explicit fields were provided.
+    def should_raise?
+      fields.present?
+    end
+
+    def populate_field(field, value)
+      setter = "#{field}="
+      if record.respond_to?(setter)
+        record.send(setter, value)
+      elsif should_raise?
+        raise "Record #{record} does not respond to #{setter}"
+      end
+    end
+
+    def fields_for(data)
+      fields || data.keys
+    end
+  end
+end

data/lib/multiple_man/model_publisher.rb

@@ -22,7 +22,7 @@ module MultipleMan
     def push_record(connection, record)
       data = record_data(record)
       routing_key = RoutingKey.new(record_type(record), operation).to_s
-      MultipleMan.logger.info("  Record Data: #{data} | Routing Key: #{routing_key}")
+      MultipleMan.logger.debug("  Record Data: #{data} | Routing Key: #{routing_key}")
       connection.topic.publish(data, routing_key: routing_key)
     rescue Exception => ex
       MultipleMan.error(ex)
@@ -33,7 +33,20 @@ module MultipleMan
     end
 
     def record_data(record)
-      AttributeExtractor.new(record, fields, identifier).to_json
+      { 
+        id: Identity.new(record, identifier).value,
+        data: serializer(record).as_json
+      }.to_json
+    end
+
+    # Todo - can we unify the constructor for serializers
+    # and attribute extractors and simplify this?
+    def serializer(record)
+      if options[:with]
+        options[:with].new(record)
+      else
+        AttributeExtractor.new(record, fields)
+      end
     end
 
     def fields

data/lib/multiple_man/subscribers/base.rb

@@ -0,0 +1,34 @@
+module MultipleMan::Subscribers
+  class Base
+
+    def initialize(klass)
+      self.klass = klass
+    end
+
+    attr_reader :klass
+
+    def create
+      # noop
+    end
+
+    def update
+      # noop
+    end
+
+    def destroy
+      # noop
+    end
+
+    def routing_key
+      MultipleMan::RoutingKey.new(klass).to_s
+    end
+
+    def queue_name
+      "#{MultipleMan.configuration.topic_name}.#{MultipleMan.configuration.app_name}.#{klass.name}"
+    end
+
+  private
+
+    attr_writer :klass
+  end
+end

data/lib/multiple_man/subscribers/model_subscriber.rb

@@ -0,0 +1,33 @@
+module MultipleMan::Subscribers 
+  class ModelSubscriber < Base
+
+    def initialize(klass, options)
+      super(klass)
+      self.options = options
+    end
+
+    attr_accessor :options
+
+    def create(payload)
+      model = find_model(payload[:id])
+      MultipleMan::ModelPopulator.new(model, options[:fields]).populate(payload[:data])
+      model.save!
+    end
+
+    alias_method :update, :create
+
+    def destroy(payload)
+      model = find_model(payload[:id])
+      model.destroy!
+    end
+
+  private
+
+    def find_model(id)
+      klass.find_or_initialize_by(multiple_man_identifier: id)
+    end
+
+    attr_writer :klass
+
+  end
+end

data/lib/multiple_man/subscribers/registry.rb

@@ -0,0 +1,12 @@
+module MultipleMan::Subscribers
+  class Registry
+    @subscriptions = []
+    class << self
+      attr_accessor :subscriptions
+
+      def register(subscription)
+        self.subscriptions << subscription
+      end
+    end
+  end
+end

data/lib/multiple_man/version.rb

@@ -1,3 +1,3 @@
 module MultipleMan
-  VERSION = "0.2.8"
+  VERSION = "0.3.2"
 end

data/lib/multiple_man.rb

@@ -5,13 +5,17 @@ module MultipleMan
 
   require 'multiple_man/mixins/publisher'
   require 'multiple_man/mixins/subscriber'
+  require 'multiple_man/subscribers/base'
+  require 'multiple_man/subscribers/model_subscriber'
+  require 'multiple_man/subscribers/registry'
   require 'multiple_man/configuration'
-  require 'multiple_man/model_subscriber'
   require 'multiple_man/model_publisher'
   require 'multiple_man/attribute_extractor'
   require 'multiple_man/connection'
   require 'multiple_man/routing_key'
   require 'multiple_man/listener'
+  require 'multiple_man/model_populator'
+  require 'multiple_man/identity'
 
   def self.logger
     configuration.logger

data/spec/attribute_extractor_spec.rb

@@ -4,9 +4,8 @@ describe MultipleMan::AttributeExtractor do
 
   MockClass = Struct.new(:a, :b, :c, :id)
   let(:object) { MockClass.new(1,2,3,10) }
-  subject { described_class.new(object, fields, identifier) }
+  subject { described_class.new(object, fields) }
   let(:fields) { nil }
-  let(:identifier) { nil }
 
   context "without fields" do
     it "should not be allowed" do
@@ -16,22 +15,11 @@ describe MultipleMan::AttributeExtractor do
 
   context "with fields" do
     let(:fields) { [:a, :c] }
-    its(:data) { should == {id:10, data:{a: 1, c: 3}}}
-    its(:to_json) { should == '{"id":10,"data":{"a":1,"c":3}}'}
-  end
-
-  context "with an identifier" do
-    let(:fields) { [:a] }
-    context "symbol" do
-      let(:identifier) { :a }
-      its(:data) { should == {id:1, data:{a: 1}}}
-      its(:to_json) { should == '{"id":1,"data":{"a":1}}'}
-    end
-    context "proc" do
-      let(:identifier) { lambda{|record| record.b } }
-      its(:data) { should == {id:2, data:{a: 1}}}
-      its(:to_json) { should == '{"id":2,"data":{"a":1}}'}
-    end
+    its(:data) { should == {a: 1, c: 3}}
+    its(:as_json) { should == {
+      a: 1,
+      c: 3
+    } }
   end
   
 end

data/spec/identity_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe MultipleMan::Identity do 
+  let(:record) { double(:model, id: 1, foo: 'foo', bar: 'bar' )}
+  subject { described_class.new(record, identifier).value }
+
+  context "proc identifier" do
+    let(:identifier) { lambda{|record| "#{record.foo}-#{record.id}" } }
+    it { should == "foo-1" }
+  end
+  context "symbol identifier" do
+    let(:identifier) { :foo }
+    it { should == "foo" }
+  end
+  context "no identifier" do
+    let(:identifier) { :id }
+    it { should == "1" }
+  end
+end

data/spec/listener_spec.rb

@@ -6,9 +6,9 @@ describe MultipleMan::Listener do
 
   describe "start" do
     it "should listen to each subscription" do
-      MultipleMan::ModelSubscriber.stub(:subscriptions).and_return([
-        mock1 = double(MultipleMan::ModelSubscriber, klass: MockClass1),
-        mock2 = double(MultipleMan::ModelSubscriber, klass: MockClass2)
+      MultipleMan::Subscribers::Registry.stub(:subscriptions).and_return([
+        mock1 = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1),
+        mock2 = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass2)
       ])
 
       mock_listener = double(MultipleMan::Listener)
@@ -23,22 +23,21 @@ describe MultipleMan::Listener do
   end
 
   describe "listen" do
-    let(:connection_stub) { double(Bunny, channel: channel_stub, topic: 'app') }
-    let(:channel_stub) { double(Bunny::Channel, queue: queue_stub) }
+    let(:connection_stub) { double(MultipleMan::Connection, queue: queue_stub, topic: 'app') }
     let(:queue_stub) { double(Bunny::Queue, bind: bind_stub) }
     let(:bind_stub) { double(:bind, subscribe: nil)}
 
     before { MultipleMan::Listener.stub(:connection).and_return(connection_stub) }
 
     it "should listen to the right topic, and for all updates to a model" do
-      listener = MultipleMan::Listener.new(double(MultipleMan::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#", queue_name: "MockClass1"))
+      listener = MultipleMan::Listener.new(double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#", queue_name: "MockClass1"))
       queue_stub.should_receive(:bind).with('app', routing_key: "MockClass1.#")
       listener.listen
     end
   end
 
   specify "process_message should send the correct data" do
-    subscriber = double(MultipleMan::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#")
+    subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#")
     listener = MultipleMan::Listener.new(subscriber)
     subscriber.should_receive(:create).with({"a" => 1, "b" => 2})
     listener.process_message(OpenStruct.new(routing_key: "app.MockClass1.create"), '{"a":1,"b":2}')

data/spec/model_populator_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe MultipleMan::ModelPopulator do 
+  class MockModel
+    attr_accessor :a, :b
+  end
+
+  describe "populate" do
+    let(:model) { MockModel.new }
+    let(:data) { { a: 1, b: 2 } }
+    subject { described_class.new(model, fields).populate(data) }
+
+    context "with fields defined" do
+      let(:fields) { [:a] }
+
+      its(:b) { should == nil }
+      its(:a) { should == 1 }
+
+      context "when a property doesn't exist" do
+        before { model.stub(:respond_to?) { false } }
+        it "should raise an error" do
+          expect { subject }.to raise_error
+        end
+      end
+    end
+    context "without fields defined" do
+      let(:fields) { nil }
+
+      its(:b) { should == 2 }
+      its(:a) { should == 1 }
+
+      context "when a property doesn't exist" do
+        it "should go on it's merry way" do
+          expect { subject }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/model_publisher_spec.rb

@@ -29,8 +29,8 @@ describe MultipleMan::ModelPublisher do
 
   describe "after_commit" do
     it "should send the jsonified version of the model to the correct routing key" do
-      MultipleMan::AttributeExtractor.any_instance.should_receive(:to_json).and_return('{"id":10,"data":{"foo": "bar"}}')
-      topic_stub.should_receive(:publish).with('{"id":10,"data":{"foo": "bar"}}', routing_key: "app.MockObject.create")
+      MultipleMan::AttributeExtractor.any_instance.should_receive(:as_json).and_return({foo: "bar"})
+      topic_stub.should_receive(:publish).with('{"id":"10","data":{"foo":"bar"}}', routing_key: "app.MockObject.create")
       described_class.new(:create, fields: [:foo]).after_commit(MockObject.new)
     end
 
@@ -42,4 +42,22 @@ describe MultipleMan::ModelPublisher do
     end
   end
 
+  describe "with a serializer" do
+    class MySerializer
+      def initialize(record)
+      end
+      def as_json
+        {a: "yes"}
+      end
+    end
+
+    subject { described_class.new(:create, with: MySerializer) }
+
+    it "should get its data from the serializer" do
+      obj = MockObject.new
+      topic_stub.should_receive(:publish).with('{"id":"10","data":{"a":"yes"}}', routing_key: "app.MockObject.create")
+      subject.after_commit(obj)
+    end
+  end
+
 end

data/spec/subscriber_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe MultipleMan::Subscriber do 
   class MockClass
-
+    include MultipleMan::Subscriber
   end
 
-  describe "inclusion" do
+  describe "subscribe" do
     it "should register itself" do
-      MultipleMan::ModelSubscriber.should_receive(:register).with(MockClass)
-      MockClass.send(:include, MultipleMan::Subscriber)
+      MultipleMan::Subscribers::Registry.should_receive(:register).with(instance_of(MultipleMan::Subscribers::ModelSubscriber))
+      MockClass.subscribe fields: [:foo, :bar]
     end 
   end
 end

data/spec/subscribers/base_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe MultipleMan::Subscribers::Base do
+  class MockClass
+  end
+
+  specify "routing_key should be the model name and a wildcard" do
+    described_class.new(MockClass).routing_key.should == "app.MockClass.#"
+  end
+
+  specify "queue name should be the app name + class" do
+    MultipleMan.configure do |config|
+      config.app_name = "test"
+    end
+    described_class.new(MockClass).queue_name.should == "app.test.MockClass"
+  end
+end

data/spec/subscribers/model_subscriber_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe MultipleMan::Subscribers::ModelSubscriber do
+  class MockClass
+
+  end
+
+  describe "create" do
+    it "should create a new model" do
+      mock_object = MockClass.new
+      MockClass.stub(:find_or_initialize_by).with(multiple_man_identifier: 5).and_return(mock_object)
+      mock_populator = double(MultipleMan::ModelPopulator)
+      MultipleMan::ModelPopulator.should_receive(:new).and_return(mock_populator)
+      mock_populator.should_receive(:populate).with({a: 1, b: 2})
+      mock_object.should_receive(:save!)
+
+      described_class.new(MockClass, {}).create({id: 5, data:{a: 1, b: 2}})
+    end
+  end
+
+  describe "destroy" do
+    it "should destroy the model" do
+      mock_object = MockClass.new
+      MockClass.should_receive(:find_or_initialize_by).and_return(mock_object)
+      mock_object.should_receive(:destroy!)
+
+      described_class.new(MockClass, {}).destroy({id: 1})
+    end
+  end
+end

data/spec/subscribers/registry_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe MultipleMan::Subscribers::Registry do 
+  describe "register" do 
+    it "should add a subscriber" do
+      subscription = double(:subscriber)
+      described_class.register(subscription)
+      described_class.subscriptions[0].should == subscription
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multiple_man
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.2
 platform: ruby
 authors:
 - Ryan Brunner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-09 00:00:00.000000000 Z
+date: 2014-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -111,26 +111,34 @@ files:
 - lib/multiple_man/attribute_extractor.rb
 - lib/multiple_man/configuration.rb
 - lib/multiple_man/connection.rb
+- lib/multiple_man/identity.rb
 - lib/multiple_man/listener.rb
 - lib/multiple_man/mixins/publisher.rb
 - lib/multiple_man/mixins/subscriber.rb
+- lib/multiple_man/model_populator.rb
 - lib/multiple_man/model_publisher.rb
-- lib/multiple_man/model_subscriber.rb
 - lib/multiple_man/railtie.rb
 - lib/multiple_man/routing_key.rb
+- lib/multiple_man/subscribers/base.rb
+- lib/multiple_man/subscribers/model_subscriber.rb
+- lib/multiple_man/subscribers/registry.rb
 - lib/multiple_man/tasks/worker.rake
 - lib/multiple_man/version.rb
 - multiple_man.gemspec
 - spec/attribute_extractor_spec.rb
 - spec/connection_spec.rb
+- spec/identity_spec.rb
 - spec/listener_spec.rb
 - spec/logger_spec.rb
+- spec/model_populator_spec.rb
 - spec/model_publisher_spec.rb
-- spec/model_subscriber_spec.rb
 - spec/publisher_spec.rb
 - spec/routing_key_spec.rb
 - spec/spec_helper.rb
 - spec/subscriber_spec.rb
+- spec/subscribers/base_spec.rb
+- spec/subscribers/model_subscriber_spec.rb
+- spec/subscribers/registry_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -158,11 +166,15 @@ summary: MultipleMan syncs changes to ActiveRecord models via AMQP
 test_files:
 - spec/attribute_extractor_spec.rb
 - spec/connection_spec.rb
+- spec/identity_spec.rb
 - spec/listener_spec.rb
 - spec/logger_spec.rb
+- spec/model_populator_spec.rb
 - spec/model_publisher_spec.rb
-- spec/model_subscriber_spec.rb
 - spec/publisher_spec.rb
 - spec/routing_key_spec.rb
 - spec/spec_helper.rb
 - spec/subscriber_spec.rb
+- spec/subscribers/base_spec.rb
+- spec/subscribers/model_subscriber_spec.rb
+- spec/subscribers/registry_spec.rb

data/lib/multiple_man/model_subscriber.rb

@@ -1,49 +0,0 @@
-module MultipleMan
-  class ModelSubscriber
-
-    @subscriptions = []
-    class << self
-      attr_accessor :subscriptions
-
-      def register(klass)
-        self.subscriptions << new(klass)
-      end
-    end
-
-    def initialize(klass)
-      self.klass = klass
-    end
-
-    attr_reader :klass    
-
-    def create(payload)
-      model = find_model(payload[:id])
-      model.attributes = payload[:data]
-      model.save!
-    end
-
-    alias_method :update, :create
-
-    def destroy(payload)
-      model = find_model(payload[:id])
-      model.destroy!
-    end
-
-    def routing_key
-      RoutingKey.new(klass).to_s
-    end
-
-    def queue_name
-      "#{MultipleMan.configuration.topic_name}.#{MultipleMan.configuration.app_name}.#{klass.name}"
-    end
-
-  private
-
-    def find_model(id)
-      klass.find_or_initialize_by(multiple_man_identifier: id)
-    end
-
-    attr_writer :klass
-
-  end
-end

data/spec/model_subscriber_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe MultipleMan::ModelSubscriber do
-  class MockClass
-
-  end
-
-  describe "register" do 
-    it "should add a subscriber" do
-      MultipleMan::ModelSubscriber.register(MockClass)
-      MultipleMan::ModelSubscriber.subscriptions[0].klass.should == MockClass
-    end
-  end
-
-  describe "create" do
-    it "should create a new model" do
-      mock_object = MockClass.new
-      MockClass.stub(:find_or_initialize_by).with(multiple_man_identifier: 5).and_return(mock_object)
-      mock_object.should_receive(:attributes=)
-      mock_object.should_receive(:save!)
-
-      MultipleMan::ModelSubscriber.new(MockClass).create({id: 5, data:{a: 1, b: 2}})
-    end
-  end
-
-  describe "destroy" do
-    it "should destroy the model" do
-      mock_object = MockClass.new
-      MockClass.should_receive(:find_or_initialize_by).and_return(mock_object)
-      mock_object.should_receive(:destroy!)
-
-      MultipleMan::ModelSubscriber.new(MockClass).destroy({id: 1})
-    end
-  end
-
-  specify "routing_key should be the model name and a wildcard" do
-    MultipleMan::ModelSubscriber.new(MockClass).routing_key.should == "app.MockClass.#"
-  end
-
-  specify "queue name should be the app name + class" do
-    MultipleMan.configure do |config|
-      config.app_name = "test"
-    end
-    MultipleMan::ModelSubscriber.new(MockClass).queue_name.should == "app.test.MockClass"
-  end
-end