untied-publisher 0.0.3 → 0.0.4

data/lib/untied-publisher/doorkeeper.rb

@@ -12,7 +12,7 @@ module Untied
       # The following publisher watches the User after_create event:
       #
       #   class MyDoorkeeper
-      #     include Untied::Doorkeeper
+      #     include Untied::Publisher::Doorkeeper
       #
       #     def initialize
       #       watch User, :after_create
@@ -27,14 +27,15 @@ module Untied
       # Watches ActiveRecord lifecycle callbacks for some Class
       #
       #   class Doorkeeper
-      #     include Untied::Doorkeeper
+      #     include Untied::Publisher::Doorkeeper
       #   end
       #
       #   pub.new.watch(User, :after_create)
       #   User.create # sends the user into the wire
       def watch(*args)
         entity = args.shift
-        observed << [entity, args]
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        observed << [entity, args, options]
       end
 
       # Returns the list of classes watched
@@ -46,7 +47,7 @@ module Untied
       # For example, if the publisher is defined as follows:
       #
       #   class MyDoorkeeper
-      #     include Untided::Doorkeeper
+      #     include Untided::Publisher::Doorkeeper
       #
       #     def initialize
       #       watch User, :after_create
@@ -57,20 +58,37 @@ module Untied
       # _notify_untied__publisher_observer_for_after_create is created on User's
       # model. This method is called when the after_create callback is fired.
       def define_callbacks
+        observed.each do |(klass, callbacks, options)|
+          ActiveRecord::Callbacks::CALLBACKS.each do |callback|
+            next unless callbacks.include?(callback)
+            setup_observer(klass, callback, options)
+          end
+        end
+      end
+
+      protected
+
+      def setup_observer(klass, callback, options={})
         observer = Untied::Publisher::Observer
         observer_name = observer.name.underscore.gsub('/', '__')
+        notifier_meth = :"_notify_#{observer_name}_for_#{callback}"
 
-        observed.each do |(klass, callbacks)|
-          ActiveRecord::Callbacks::CALLBACKS.each do |callback|
-          next unless callbacks.include?(callback)
-          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
-          unless klass.respond_to?(callback_meth)
-            klass.send(:define_method, callback_meth) do
-              observer.instance.send(callback, self)
-            end
-            klass.send(callback, callback_meth)
-          end
+        if define_notifier_method(klass, observer, callback, notifier_meth, options)
+          klass.send(callback, notifier_meth)
         end
+
+        klass
+      end
+
+      def define_method_on(klass, method_name, &block)
+        unless klass.respond_to?(method_name)
+          klass.send(:define_method, method_name, &block)
+        end
+      end
+
+      def define_notifier_method(klass, observer, callback, method_name, options={})
+        define_method_on(klass, method_name) do
+          observer.instance.send(callback, self, options)
         end
       end
     end

data/lib/untied-publisher/event.rb

@@ -1,9 +1,9 @@
 # -*- encoding : utf-8 -*-
-require 'active_model'
+
+require 'representable/json'
 
 module Untied
   class Event
-    include ActiveModel::Serializers::JSON
     attr_accessor :name, :payload, :origin
 
     def initialize(attrs)
@@ -19,9 +19,15 @@ module Untied
       @payload = @config.delete(:payload)
       @origin = @config.delete(:origin)
     end
+  end
 
-    def attributes
-      { "name" => @name, "origin" => @origin, "payload" => @payload }
-    end
+  module EventRepresenter
+    include Representable::JSON
+
+    self.representation_wrap = true
+
+    property :name
+    property :payload
+    property :origin
   end
 end

data/lib/untied-publisher/observer.rb

@@ -18,7 +18,8 @@ module Untied
 
       def method_missing(name, model, *args, &block)
         if ActiveRecord::Callbacks::CALLBACKS.include?(name)
-          produce_event(name, model)
+          options = args.first.is_a?(Hash) ? args.first : {}
+          produce_event(name, model, options)
         else
           super
         end
@@ -26,9 +27,13 @@ module Untied
 
       protected
 
-      def produce_event(callback, model)
-        e = Event.new(:name => callback, :payload => model,
-                      :origin => Publisher.config.service_name)
+      def produce_event(callback, model, options={})
+        if representer = options[:with_representer]
+          model = model.extend(representer)
+        end
+        e = Event.new(:name => callback,
+                      :payload => model, :origin => Publisher.config.service_name)
+        e.extend(EventRepresenter)
         producer.publish(e)
       end
 

data/lib/untied-publisher/version.rb

@@ -1,5 +1,5 @@
 module Untied
   module Publisher
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

data/spec/doorkeeper_spec.rb

@@ -8,13 +8,21 @@ module Untied
         class ::Doorkeeper
           include Untied::Publisher::Doorkeeper
         end
+
+        module SomeRepresenter; end
       end
       let(:doorkeeper) { ::Doorkeeper.new }
 
       context "#watch" do
         it "should add observed classes to observed list" do
           doorkeeper.watch(User, :after_create)
-          doorkeeper.observed.should == [[User, [:after_create]]]
+          doorkeeper.observed.should == [[User, [:after_create], {}]]
+        end
+
+        it "should accept a constant" do
+          opts = { :represent_with => SomeRepresenter }
+          doorkeeper.watch(User, :after_create, opts)
+          doorkeeper.observed.should == [[User, [:after_create], opts]]
         end
       end
 
@@ -48,6 +56,43 @@ module Untied
           Post.new.should \
             respond_to(:_notify_untied__publisher__observer_for_after_create)
         end
+
+        context "with :represent_with option" do
+          let(:observer) do
+            observer = double('Untied::Publisher::Observer')
+            observer.stub(:name).and_return("Untied::Publisher::Observer")
+            observer.stub(:after_create)
+            observer
+          end
+          before do
+            Observer.stub(:instance).and_return(observer)
+            doorkeeper.watch(Post, :after_create, :represent_with => SomeRepresenter)
+            doorkeeper.define_callbacks
+          end
+
+          it "should extend the entity with the constant" do
+            observer.should_receive(:after_create).
+              with(an_instance_of(Post), { :represent_with => SomeRepresenter })
+            Post.create
+          end
+        end
+      end
+
+      context "Observed#_notify_untied__publisher__observer_for_[callback]" do
+        let(:observer) do
+          observer = double('Untied::Publisher::Observer')
+          observer.stub(:name).and_return("Untied::Publisher::Observer")
+        end
+        before do
+          doorkeeper.watch(User, :after_create)
+          Observer.stub(:instance).and_return(observer)
+        end
+
+        it "should invoke observer method" do
+          observer.should_receive(:after_create)
+          doorkeeper.define_callbacks
+          User.new.send(:_notify_untied__publisher__observer_for_after_create)
+        end
       end
 
       context "#observed_classes" do

data/spec/event_spec.rb

@@ -28,8 +28,9 @@ module Untied
         end
 
         it "should include the origin service name" do
-          Event.new(:name => :after_create, :payload => person, :origin => "core").
-            origin.should == "core"
+         e = Event.new(:name => :after_create,
+                       :payload => person, :origin => "core")
+         e.origin.should == "core"
         end
       end
 

data/spec/producer_spec.rb

@@ -33,7 +33,8 @@ module Untied
       context "#publish" do
         it "should call Channel#publish" do
           mock_reactor_and_amqp do |channel|
-            e = Event.new(:name => "create", :payload => { :foo => 'bar' }, :origin => :core)
+            e = Event.new(:name => "create",
+                          :payload => { :foo => 'bar' }, :origin => :core)
             channel.topic.should_receive(:publish)
             producer = Producer.new(:channel => channel, :deliver_messages => true)
             producer.publish(e)

data/spec/publisher_observer_spec.rb

@@ -3,18 +3,16 @@ require 'spec_helper'
 
 module Untied
   module Publisher
-    describe Publisher do
+    describe Observer do
       before do
-        class MyDoorkeeper
+        class ::FooDoorkeeper
           include Untied::Publisher::Doorkeeper
-          def initialize
-            watch(User, :after_create)
-            watch(User, :after_update)
-          end
         end
-        Untied::Publisher.config.doorkeeper = MyDoorkeeper
+        Untied::Publisher.config.doorkeeper = ::FooDoorkeeper
+        module UserRepresenter
+        end
       end
-      after { Untied::Publisher.config.doorkeeper = MyDoorkeeper }
+      let(:doorkeeper) { ::FooDoorkeeper.new }
 
       context ".instance" do
         it "should raise a friendly error when no doorkeeper is defined" do
@@ -27,17 +25,19 @@ module Untied
       end
 
       context "ActiveRecord::Callbacks" do
-        it "should call the observer when the callback is fired" do
-          Observer.instance.should_receive(:after_create)
-          User.create
-        end
+        let(:user) { User.create(:name => "Guila") }
 
-        it "should accept multiple callbacks even in different #watch" do
-          Observer.instance.should_receive(:after_create)
-          Observer.instance.should_receive(:after_update)
+        it "should proxy #produce_event" do
+          Observer.instance.should_receive(:produce_event)
+          Observer.instance.send(:after_create, user)
+        end
 
-          user = User.create(:name => "yo")
-          user.update_attributes({:name => "Ops!"})
+        context "passing :with_representer" do
+          it "should call user.extend(UserRepresenter)" do
+            user.should_receive(:extend).with(UserRepresenter)
+            Observer.instance.
+              send(:after_create, user, :with_representer => UserRepresenter)
+          end
         end
       end
 

data/spec/spec_helper.rb

@@ -19,6 +19,13 @@ RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
+  config.before do
+    # Redefining models for each it
+    %w(User Post).each do |klass|
+      Object.send(:remove_const, :"#{klass}")
+      Object.const_set(klass, Class.new(ActiveRecord::Base))
+    end
+  end
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing

data/untied-publisher.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "amqp"
   gem.add_runtime_dependency "configurable"
   gem.add_runtime_dependency "json"
+  gem.add_runtime_dependency "representable"
 
   if RUBY_VERSION < "1.9"
     gem.add_development_dependency "ruby-debug"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: untied-publisher
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Guilherme Cavalcanti
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-23 00:00:00 Z
+date: 2012-11-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -126,9 +126,23 @@ dependencies:
         - 0
         version: "0"
   prerelease: false
+  type: :runtime
+  name: representable
+  requirement: *id008
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
   type: :development
   name: ruby-debug
-  requirement: *id008
+  requirement: *id009
 description: Provides the Publisher part of the Untied gem.
 email: 
 - guiocavalcanti@gmail.com