multiple_man 0.5.19 → 0.5.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b3a90c9328cca2f0a95772285f276c1b0522f35
-  data.tar.gz: 01242a1490ee37ad43eb9ce6cee868ea941c6b21
+  metadata.gz: 0591b04188fa134c346891d8797b182f08a42f0d
+  data.tar.gz: 1a077b8c73e84f51203c4c7d2b6da4346278cc07
 SHA512:
-  metadata.gz: bff8708331c6173a5f1d4567900112090bb4fedf523e618940867584575bc9f216875ca320e7b97d68d4d72139ab53b8651bdf12e4f39f54dddd31223cb364ae
-  data.tar.gz: fecd5e32679d718d0787dd178ab95f47dcfc9034d0283f4a4f58d6f1df583e446614e5a45b19ff881031e9c997155fa6d618ab94d8af17d42fe4dbc9765fb91c
+  metadata.gz: 81995d16cc55a54ebffdde454fc01ae64fd02bc353a2acdaf9124e110253ffac287b8b47d7008903e5b28363e4e92622b73239b2d9b44e8eb126b8144cd6b7c0
+  data.tar.gz: 99602120d126845c63a7e8aee2d25c117abdd754e8f0837d0d3f56cffbdc1db779624a9721588cfd1644584bf792ff9ec0d6a54b12ef29188b5b10ad027321db

data/lib/multiple_man.rb

@@ -1,4 +1,5 @@
 require "multiple_man/version"
+require 'active_support'
 
 module MultipleMan
   require 'multiple_man/railtie' if defined?(Rails)
@@ -11,10 +12,11 @@ module MultipleMan
   require 'multiple_man/configuration'
   require 'multiple_man/model_publisher'
   require 'multiple_man/attribute_extractor'
+  require 'multiple_man/payload_generator'
   require 'multiple_man/connection'
   require 'multiple_man/routing_key'
-  require 'multiple_man/listener'
-  require 'multiple_man/seeder_listener'
+  require 'multiple_man/listeners/listener'
+  require 'multiple_man/listeners/seeder_listener'
   require 'multiple_man/model_populator'
   require 'multiple_man/identity'
   require 'multiple_man/publish'

data/lib/multiple_man/attribute_extractor.rb

@@ -3,26 +3,40 @@ require 'json'
 module MultipleMan
   class AttributeExtractor
 
-    def initialize(record, fields)
+    def initialize(record, fields, include_previous = false)
       raise "Fields must be specified" unless fields
       
+      self.include_previous = include_previous
       self.record = record
       self.fields = fields
     end
 
+    def as_json
+      if include_previous
+        data.merge(previous_data)
+      else
+        data
+      end
+    end
+
+  private
+
     def data
       Hash[fields.map do |field|
-        [field, record.send(field)]
+        [field, record.send(field)] 
       end]
     end
 
-    def as_json
-      data
+    def previous_data
+      { previous: Hash[fields.map do |field|
+          previous_data_method = "#{field}_was"
+          [field, record.send(previous_data_method)] if record.respond_to? previous_data_method
+        end.reject(&:nil?)]
+      }
     end
 
-  private
 
-    attr_accessor :record, :fields, :identifier
+    attr_accessor :record, :fields, :identifier, :include_previous
 
   end
 end

data/lib/multiple_man/{listener.rb → listeners/listener.rb}

@@ -1,15 +1,15 @@
 require 'json'
 require 'active_support/core_ext/hash'
 
-module MultipleMan
+module MultipleMan::Listeners
   class Listener
 
     class << self
       def start
         MultipleMan.logger.debug "Starting listeners."
-        MultipleMan.logger.debug Subscribers::Registry.subscriptions.to_json
+        MultipleMan.logger.debug MultipleMan::Subscribers::Registry.subscriptions.to_json
 
-        Subscribers::Registry.subscriptions.each do |subscription|
+        MultipleMan::Subscribers::Registry.subscriptions.each do |subscription|
           new(subscription).listen
         end
       end
@@ -43,7 +43,8 @@ module MultipleMan
     def process_message(delivery_info, payload)
       MultipleMan.logger.info "Processing message for #{delivery_info.routing_key}."
       begin
-        subscription.send(operation(delivery_info), JSON.parse(payload).with_indifferent_access)
+        payload = JSON.parse(payload).with_indifferent_access
+        subscription.send(operation(delivery_info, payload), payload)
       rescue Exception => ex
         handle_error(ex, delivery_info)
       else
@@ -60,8 +61,8 @@ module MultipleMan
       queue.channel.nack(delivery_info.delivery_tag)
     end
 
-    def operation(delivery_info)
-      delivery_info.routing_key.split(".").last
+    def operation(delivery_info, payload)
+      payload['operation'] || delivery_info.routing_key.split(".").last
     end
 
     def queue

data/lib/multiple_man/{seeder_listener.rb → listeners/seeder_listener.rb}

@@ -1,4 +1,4 @@
-module MultipleMan
+module MultipleMan::Listeners
   class SeederListener < Listener
     def routing_key
       subscription.routing_key(:seed)

data/lib/multiple_man/mixins/publisher.rb

@@ -4,21 +4,23 @@ module MultipleMan
   module Publisher
     def Publisher.included(base)
       base.extend(ClassMethods)
-      base.after_commit(on: :create) { |r| r.multiple_man_publish(:create) }
-      base.after_commit(on: :update) { |r| r.multiple_man_publish(:update) }
-      base.after_commit(on: :destroy) { |r| r.multiple_man_publish(:destroy) }
+      if base.respond_to?(:after_commit)
+        base.after_commit(on: :create) { |r| r.multiple_man_publish(:create) }
+        base.after_commit(on: :update) { |r| r.multiple_man_publish(:update) }
+        base.after_commit(on: :destroy) { |r| r.multiple_man_publish(:destroy) }
+      end
 
       base.class_attribute :multiple_man_publisher
     end
 
     def multiple_man_publish(operation=:create)
-      self.class.multiple_man_publisher.publish(self, operation) 
+      self.class.multiple_man_publisher.publish(self, operation)
     end
 
     module ClassMethods
-      
+
       def multiple_man_publish(operation=:create)
-        multiple_man_publisher.publish(self, operation) 
+        multiple_man_publisher.publish(self, operation)
       end
 
       def publish(options = {})

data/lib/multiple_man/model_populator.rb

@@ -24,7 +24,9 @@ module MultipleMan
 
     def populate_field(field, value)
       # Attempt to populate source id if id is specified
-      populate_field('source_id', value) if field == 'id'
+      if field.to_s == 'id' && record.respond_to?('source_id')
+        field = 'source_id'
+      end
 
       setter = "#{field}="
       if record.respond_to?(setter)

data/lib/multiple_man/model_publisher.rb

@@ -22,10 +22,12 @@ module MultipleMan
     attr_accessor :options
 
     def push_record(connection, record, operation)
-      data = record_data(record)
-      routing_key = RoutingKey.new(record_type(record), operation).to_s
+      data = PayloadGenerator.new(record, operation, options)
+      routing_key = RoutingKey.new(data.type, operation).to_s
+
       MultipleMan.logger.debug("  Record Data: #{data} | Routing Key: #{routing_key}")
-      connection.topic.publish(data, routing_key: routing_key)
+
+      connection.topic.publish(data.payload, routing_key: routing_key)
     rescue Exception => ex
       MultipleMan.error(ex)
     end
@@ -40,35 +42,5 @@ module MultipleMan
       end
     end
 
-
-    def record_type(record)
-      options[:as] || record.class.name
-    end
-
-    def record_data(record)
-      {
-        id: Identity.build(record, options).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
-      options[:fields]
-    end
-
-    def identifier
-      options[:identifier]
-    end
-
   end
 end

data/lib/multiple_man/payload_generator.rb

@@ -0,0 +1,42 @@
+module MultipleMan
+  class PayloadGenerator
+    def initialize(record, operation = :create, options = {})
+      self.record = record
+      self.operation = operation.to_s
+      self.options = options
+    end
+
+    def payload
+      {
+        type: type,
+        operation: operation,
+        id: id,
+        data: data
+      }.to_json
+    end
+
+    def type
+      options[:as] || record.class.name
+    end
+
+    def id
+      Identity.build(record, options).value
+    end
+
+    def data
+      if options[:with]
+        options[:with].new(record).as_json
+      else
+        AttributeExtractor.new(record, options[:fields]).as_json
+      end
+    end
+
+    attr_reader :operation
+
+  private
+
+    attr_accessor :record, :options
+    attr_writer :operation
+
+  end
+end

data/lib/multiple_man/tasks/worker.rake

@@ -1,12 +1,12 @@
 namespace :multiple_man do
   desc "Run multiple man listeners"
   task :worker => :environment do
-    run_listener(MultipleMan::Listener)
+    run_listener(MultipleMan::Listeners::Listener)
   end
 
   desc 'Run a seeding listener'
   task seed: :environment do
-    run_listener(MultipleMan::SeederListener)
+    run_listener(MultipleMan::Listeners::SeederListener)
   end
 
   def run_listener(listener)

data/lib/multiple_man/version.rb

@@ -1,3 +1,3 @@
 module MultipleMan
-  VERSION = "0.5.19"
+  VERSION = "0.5.20"
 end

data/multiple_man.gemspec

@@ -19,8 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "pry"
   spec.add_development_dependency "rake", '~> 10.1.0'
   spec.add_development_dependency "rspec", '~> 2.14.1'
+  spec.add_development_dependency 'codeclimate-test-reporter'
   spec.add_runtime_dependency     "bunny", '>= 1.2'
   spec.add_runtime_dependency     "activesupport", '>= 3.0'
   spec.add_runtime_dependency     "connection_pool", ">= 1.2"

data/spec/attribute_extractor_spec.rb

@@ -4,8 +4,9 @@ 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) }
+  subject { described_class.new(object, fields, include_previous) }
   let(:fields) { nil }
+  let(:include_previous) { false }
 
   context "without fields" do
     it "should not be allowed" do
@@ -15,11 +16,17 @@ describe MultipleMan::AttributeExtractor do
 
   context "with fields" do
     let(:fields) { [:a, :c] }
-    its(:data) { should == {a: 1, c: 3}}
     its(:as_json) { should == {
       a: 1,
       c: 3
     } }
   end
+
+  context "including old fields" do
+    let(:object) { Struct.new(:a,:b,:a_was,:b_was).new("new_a", "new_b", "old_a", "old_b") }
+    let(:fields) { [:a, :b] }
+    let(:include_previous) { true }
+    its(:as_json) { should == {a: 'new_a', b: 'new_b', previous: { a: 'old_a', b: 'old_b' }}}
+  end
   
 end

data/spec/integration/ephermal_model_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe "Publishing of ephermal models" do
+  let(:ephermal_class) do
+    Class.new do
+      def self.name
+        'Ephermal'
+      end
+
+      attr_accessor :foo, :bar, :baz, :id
+      def initialize(params)
+        self.id = params[:id]
+        self.foo = params[:foo]
+        self.bar = params[:bar]
+        self.baz = params[:baz]
+      end
+
+      include MultipleMan::Publisher
+      publish fields: [:foo, :bar, :baz]
+    end
+  end
+
+  it "should publish properly" do
+    obj = ephermal_class.new(id: 5, foo: 'foo', bar: 'bar', baz: 'baz')
+
+    payload = {
+      type: 'Ephermal',
+      operation: 'create',
+      id: { id: 5 },
+      data: { foo: 'foo', bar: 'bar', baz: 'baz'}
+    }.to_json
+    expect_any_instance_of(Bunny::Exchange).to receive(:publish)
+                                           .with(payload, routing_key: 'multiple_man.Ephermal.create')
+
+    obj.multiple_man_publish(:create)
+  end
+
+end

data/spec/{listener_spec.rb → listeners/listener_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper' 
 
-describe MultipleMan::Listener do 
+describe MultipleMan::Listeners::Listener do 
   class MockClass1; end
   class MockClass2; end
 
@@ -13,14 +13,14 @@ describe MultipleMan::Listener do
         mock2 = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass2)
       ])
 
-      mock_listener = double(MultipleMan::Listener)
-      MultipleMan::Listener.should_receive(:new).twice.and_return(mock_listener)
+      mock_listener = double(described_class)
+      described_class.should_receive(:new).twice.and_return(mock_listener)
 
       # Would actually be two seperate objects in reality, this is for
       # ease of stubbing.
       mock_listener.should_receive(:listen).twice
 
-      MultipleMan::Listener.start
+      described_class.start
     end
   end
 
@@ -32,7 +32,7 @@ describe MultipleMan::Listener do
     before { MultipleMan::Connection.stub(:new).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::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#", queue_name: "MockClass1"))
+      listener = described_class.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
@@ -42,18 +42,29 @@ describe MultipleMan::Listener do
     connection_stub = double(MultipleMan::Connection).as_null_object
     MultipleMan::Connection.stub(:new).and_return(connection_stub)
     subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#").as_null_object
-    listener = MultipleMan::Listener.new(subscriber)
+    listener = described_class.new(subscriber)
 
     connection_stub.should_receive(:acknowledge)
     subscriber.should_receive(:create).with({"a" => 1, "b" => 2})
     listener.process_message(OpenStruct.new(routing_key: "app.MockClass1.create"), '{"a":1,"b":2}')
   end
 
+  specify "process_message should use the payload to determine the operation if it's available" do
+    connection_stub = double(MultipleMan::Connection).as_null_object
+    MultipleMan::Connection.stub(:new).and_return(connection_stub)
+    subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#").as_null_object
+    listener = described_class.new(subscriber)
+
+    connection_stub.should_receive(:acknowledge)
+    subscriber.should_receive(:create)
+    listener.process_message(OpenStruct.new(routing_key: "some random routing key"), '{"operation":"create","data":{"a":1,"b":2}}')
+  end
+
   it "should nack on failure" do
     connection_stub = double(MultipleMan::Connection).as_null_object
     MultipleMan::Connection.stub(:new).and_return(connection_stub)
     subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#").as_null_object
-    listener = MultipleMan::Listener.new(subscriber)
+    listener = described_class.new(subscriber)
 
     connection_stub.should_receive(:nack)
     MultipleMan.should_receive(:error)

data/spec/{seeder_listener_spec.rb → listeners/seeder_listener_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MultipleMan::SeederListener do
+describe MultipleMan::Listeners::SeederListener do
   class MockClass1; end
 
   before { MultipleMan::Connection.stub(:connection).and_return(double(Bunny).as_null_object)}

data/spec/model_populator_spec.rb

@@ -27,6 +27,23 @@ describe MultipleMan::ModelPopulator do
         end
       end
     end
+    context "record has source id" do
+      let(:model) { Class.new do
+        attr_accessor :source_id, :id
+      end.new }
+      let(:data) { { id: 1 }}
+
+      its(:source_id) { should == 1 }
+      its(:id) { should be_nil }
+    end
+    context "record does not have source id" do
+      let(:model) { Class.new do
+        attr_accessor :id
+      end.new }
+      let(:data) { { id: 1 }}
+
+      its(:id) { should == 1 }
+    end
     context "without fields defined" do
       let(:fields) { nil }
 

data/spec/model_publisher_spec.rb

@@ -30,7 +30,7 @@ describe MultipleMan::ModelPublisher do
   describe "publish" do
     it "should send the jsonified version of the model to the correct routing key" do
       MultipleMan::AttributeExtractor.any_instance.should_receive(:as_json).and_return({foo: "bar"})
-      topic_stub.should_receive(:publish).with('{"id":{"id":10},"data":{"foo":"bar"}}', routing_key: "app.MockObject.create")
+      topic_stub.should_receive(:publish).with('{"type":"MockObject","operation":"create","id":{"id":10},"data":{"foo":"bar"}}', routing_key: "app.MockObject.create")
       described_class.new(fields: [:foo]).publish(MockObject.new)
     end
 
@@ -55,7 +55,7 @@ describe MultipleMan::ModelPublisher do
 
     it "should get its data from the serializer" do
       obj = MockObject.new
-      topic_stub.should_receive(:publish).with('{"id":{"id":10},"data":{"a":"yes"}}', routing_key: "app.MockObject.create")
+      topic_stub.should_receive(:publish).with('{"type":"MockObject","operation":"create","id":{"id":10},"data":{"a":"yes"}}', routing_key: "app.MockObject.create")
       subject.publish(obj)
     end
   end

data/spec/payload_generator_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe MultipleMan::PayloadGenerator do 
+  class PayloadMockClass < Struct.new(:foo, :bar)
+  end
+
+  let(:mock_object) { PayloadMockClass.new(1,2) }
+
+  describe "operation" do
+    it "should be whatever was passed in" do
+      expect(described_class.new(mock_object, :update).operation).to eq('update')
+    end
+    it "should be create by default" do
+      expect(described_class.new(mock_object).operation).to eq('create')
+    end
+  end
+
+  describe "data" do
+    context "with a serializer" do
+      it "should return stuff from the serializer" do
+        serializer = Struct.new(:record) do
+          def as_json
+            {a: 1, b: 2}
+          end
+        end
+
+        described_class.new(mock_object, :create, {with: serializer}).data.should == {a: 1, b: 2}
+      end
+    end
+    context "without a serializer" do
+      it "should call the attribute extractor" do
+        MultipleMan::AttributeExtractor.any_instance.stub(:as_json).and_return({c: 3, d: 4})
+        described_class.new(mock_object, :create, { fields: [:c, :d] }).data.should == {c: 3, d: 4}
+      end
+    end
+  end
+
+  describe "id" do
+    it "should defer to identity" do
+      MultipleMan::Identity::MultipleField.any_instance.stub(:value).and_return("foo_1")
+      described_class.new(mock_object).id.should == "foo_1"
+    end
+  end
+
+  describe "record_type" do
+    it "should use the as option if available" do
+      expect(described_class.new(mock_object).type).to eq("PayloadMockClass")
+    end
+    it "should use the class otherwise" do
+      expect(described_class.new(mock_object, :create, { as: 'FooClass'}).type).to eq("FooClass")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,9 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
 require 'bundler/setup'
 require 'bunny'
 require 'ostruct'
+require 'pry'
 
 require_relative '../lib/multiple_man.rb'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multiple_man
 version: !ruby/object:Gem::Version
-  version: 0.5.19
+  version: 0.5.20
 platform: ruby
 authors:
 - Ryan Brunner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-19 00:00:00.000000000 Z
+date: 2015-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !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: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  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: bunny
   requirement: !ruby/object:Gem::Requirement
@@ -112,15 +140,16 @@ files:
 - lib/multiple_man/configuration.rb
 - lib/multiple_man/connection.rb
 - lib/multiple_man/identity.rb
-- lib/multiple_man/listener.rb
+- lib/multiple_man/listeners/listener.rb
+- lib/multiple_man/listeners/seeder_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/payload_generator.rb
 - lib/multiple_man/publish.rb
 - lib/multiple_man/railtie.rb
 - lib/multiple_man/routing_key.rb
-- lib/multiple_man/seeder_listener.rb
 - lib/multiple_man/subscribers/base.rb
 - lib/multiple_man/subscribers/model_subscriber.rb
 - lib/multiple_man/subscribers/registry.rb
@@ -130,13 +159,15 @@ files:
 - spec/attribute_extractor_spec.rb
 - spec/connection_spec.rb
 - spec/identity_spec.rb
-- spec/listener_spec.rb
+- spec/integration/ephermal_model_spec.rb
+- spec/listeners/listener_spec.rb
+- spec/listeners/seeder_listener_spec.rb
 - spec/logger_spec.rb
 - spec/model_populator_spec.rb
 - spec/model_publisher_spec.rb
+- spec/payload_generator_spec.rb
 - spec/publisher_spec.rb
 - spec/routing_key_spec.rb
-- spec/seeder_listener_spec.rb
 - spec/spec_helper.rb
 - spec/subscriber_spec.rb
 - spec/subscribers/base_spec.rb
@@ -170,13 +201,15 @@ test_files:
 - spec/attribute_extractor_spec.rb
 - spec/connection_spec.rb
 - spec/identity_spec.rb
-- spec/listener_spec.rb
+- spec/integration/ephermal_model_spec.rb
+- spec/listeners/listener_spec.rb
+- spec/listeners/seeder_listener_spec.rb
 - spec/logger_spec.rb
 - spec/model_populator_spec.rb
 - spec/model_publisher_spec.rb
+- spec/payload_generator_spec.rb
 - spec/publisher_spec.rb
 - spec/routing_key_spec.rb
-- spec/seeder_listener_spec.rb
 - spec/spec_helper.rb
 - spec/subscriber_spec.rb
 - spec/subscribers/base_spec.rb