eventifier 0.0.2 → 0.0.3

data/lib/eventifier.rb

@@ -4,14 +4,10 @@
 # Consider implementing with http://www.ruby-doc.org/stdlib-1.9.3/libdoc/observer/rdoc/Observable.html
 
 
-
 # init.rb
 # require 'eventifer'
 
 
-
-
-
 # Todo
 # - Notifications
 
@@ -28,15 +24,17 @@
 #   end
 # 
 # end
-
-require 'active_record'
 require 'action_mailer'
 
-require 'eventifier/event'
+if defined? Mongoid
+  require 'eventifier/mongoid_support'
+elsif defined? ActiveRecord
+  require 'eventifier/active_record_support'
+end
+
 require 'eventifier/helper_methods'
-require 'eventifier/notification'
 require 'eventifier/notification_mailer'
 require 'eventifier/notification_helper'
 require 'eventifier/event_helper'
-require 'eventifier/event_observer'
-require 'eventifier/event_tracking'
+require 'eventifier/event_tracking'
+

data/lib/generators/eventifier/install/install_generator.rb

@@ -17,7 +17,7 @@ module Eventifier
       end
 
       def generate_migration
-        migration_template "migration.rb", "db/migrate/eventifier_setup.rb"
+        migration_template "migration.rb", "db/migrate/eventifier_setup.rb" if defined?(ActiveRecord)
       end
 
     end

data/spec/event_helper_spec.rb

@@ -3,55 +3,65 @@ require 'spec_helper'
 describe Eventifier::EventHelper do
 
   class TestClass
-    def self.helper_method(*args); end
+    def self.helper_method(*args)
+    end
+
     include Eventifier::EventHelper
   end
 
+  let(:verb) { "update" }
+  let(:change_data) { { } }
+  let(:event) { double("Event", :verb => verb, :eventable_type => "Object", :change_data => change_data, :user => double("user", :name => "Willy")) }
   let!(:helper) { TestClass.new }
 
   before do
-    @event_strings = {
-      :post => {
-        :create => "{{user.name}} just created a new post - you should check it out",
-        :destroy => "{{user.name}} just deleted a post",
-        :update => {
-          :single => "{{user.name}} made a change to their post",
-          :multiple => "{{user.name}} made some changes to their post"
-        }
-      }
-    }
-    I18n.backend.store_translations :en, :events => @event_strings
+    helper.stub :replace_vars => double("String", :html_safe => true)
   end
 
   describe ".event_message" do
-    it "should return the I18n message for that event" do
-      event = Eventifier::Event.make! :eventable => Post.make!, :verb => :create
-      helper.event_message(event).should == "<strong>#{event.user.name}</strong> just created a new post - you should check it out"
-    end
+    subject { helper.event_message event }
 
-    it "should return a message specific to a single change if only 1 change has been made" do
-      event = Eventifier::Event.make! :eventable => Post.make!, :verb => :update, :change_data => { :name => ["Fred", "Mike"] }
-      helper.event_message(event).should == "<strong>#{event.user.name}</strong> made a change to their post"
-    end
+    context "with event verb create" do
+      let(:verb) { "create" }
+
+      it "should hit the I18n verb definition for create & destroy" do
+        I18n.should_receive(:translate).with("events.object.create", :default => :"events.default.create", "user.name" => "Willy", :"event.type" => "Object")
 
-    it "should return a message specific to multiple changes if more than 1 change has been made" do
-      event = Eventifier::Event.make! :eventable => Post.make!, :verb => :update, :change_data => { :name => ["Fred", "Mike"], :age => [55, 65] }
-      helper.event_message(event).should == "<strong>#{event.user.name}</strong> made some changes to their post"
+        subject
+      end
+
+      it "should pass the I18n translation to the replace_vars method" do
+        I18n.should_receive(:translate).with("events.object.create", :default => :"events.default.create", "user.name" => "Willy", :"event.type" => "Object").and_return("A message")
+        helper.should_receive(:replace_vars).with "A message", event
+
+        subject
+      end
     end
 
-    it "should return the default I18n message if one doesn't exist" do
-      I18n.backend.reload!
-      @event_strings = {
-        :default => {
-          :create => "{{user.name}} created a {{eventable_type}}",
-          :update => "{{user.name}} updated a {{eventable_type}}"
-        }
-      }
-      I18n.backend.store_translations :test, :events => @event_strings
-      I18n.with_locale("test") do
-        event = Eventifier::Event.make! :eventable => Post.make!, :verb => :create
-        helper.event_message(event).should == "<strong>#{event.user.name}</strong> created a <strong>Post</strong>"
+    context "with event verb update" do
+      let(:verb) { "update" }
+
+      context "multiple updates" do
+        let(:change_data) { { :name => ["Lol", "Omg Lol"] } }
+
+        it "should specify single on the verb for the I18n definition on update when there are just a single change" do
+          I18n.should_receive(:translate).with("events.object.update.single", :default => :"events.default.update", "user.name" => "Willy", :"event.type" => "Object")
+
+          subject
+        end
+      end
+
+      context "multiple updates" do
+        let(:change_data) { { :name => ["Lol", "Omg Lol"], :address => ["old", "new"] } }
+
+        it "should specify single on the verb for the I18n definition on update when there are just a single change" do
+          I18n.should_receive(:translate).with("events.object.update.multiple", :default => :"events.default.update", "user.name" => "Willy", :"event.type" => "Object")
+
+          subject
+        end
+
       end
     end
+
   end
 end

data/spec/event_observer_spec.rb

@@ -1,14 +1,9 @@
 require 'spec_helper'
 
 describe Eventifier::EventObserver do
-
-  describe "#add_notification" do
-    pending
-  end
+  subject { Eventifier::EventObserver.instance }
 
   describe "#method_from_relation" do
-    subject { Eventifier::EventObserver.instance }
-
     it "should call the string as a method when passed a string" do
       object = double('object', :mouse => 5)
 

data/spec/event_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Eventifier::Event do
-  let(:event) { Eventifier::Event.make! }
+  let(:event) { Fabricate(:event) }
 
   describe "#valid?" do
     pending
@@ -10,14 +10,25 @@ describe Eventifier::Event do
     #it_requires_a   :verb
   end
 
-  describe ".find_all_by_eventable" do
+  describe '.add_url' do
+    it "should send add_url to each of it's observers with params" do
+      url_proc = -> activity { [activity.group, activity] }
+      observer = double('Observer')
+      Eventifier::Event.stub :observer_instances => [observer]
+
+      observer.should_receive(:add_url).with(Object, url_proc)
+
+      Eventifier::Event.add_url Object, url_proc
+    end
+  end
 
-    let!(:eventable) {Post.make!}
-    let(:event) {Eventifier::Event.make! :eventable => eventable}
+  describe ".find_all_by_eventable" do
+    let!(:eventable)  { Fabricate(:post) }
+    let(:event)       { Fabricate(:event, :eventable => eventable) }
 
     it "should find the associated polymorphic eventable object" do
       lambda do
-        Eventifier::Event.make! :eventable => Post.make!
+        Fabricate(:event, :eventable => Fabricate(:post))
         event
       end.should change(Eventifier::Event, :count).by(2)
 

data/spec/event_tracking_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+class Activity; end
+
+describe Eventifier::EventTracking do
+  let(:event_tracker) { Object.new.extend(Eventifier::EventTracking) }
+
+  describe ".url" do
+    it "should at the url form to a hash" do
+      url_proc = -> activity { [activity.group, activity] }
+      event_tracker.instance_variable_set(:@klasses, [Activity])
+
+      event_tracker.url url_proc
+
+      Eventifier::EventTracking.url_mappings[:activity].should == url_proc
+    end
+
+  end
+
+end

data/spec/eventifier_spec.rb

@@ -1,16 +1,11 @@
 require 'spec_helper'
-
 describe Eventifier::EventTracking do
 
-  let(:user) { User.make }
+  let(:user) { Fabricate(:user) }
   let(:test_class) { Post }
-  let(:object) { test_class.make }
+  let(:object) { Fabricate.build(:post) }
   let(:event_tracker) { Object.new.extend(Eventifier::EventTracking) }
 
-  after :all do
-    Post.observers.disable :all
-  end
-
   describe ".initialize" do
 
     it "should start" do
@@ -48,7 +43,7 @@ describe Eventifier::EventTracking do
 
 
       it "should create an event with the relevant info" do
-        changes = {:foo => 'bar', :bar => 'baz'}
+        changes = { :foo => 'bar', :bar => 'baz' }
         object.stub(:changes).and_return(changes)
 
         Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes)
@@ -61,28 +56,28 @@ describe Eventifier::EventTracking do
 
   describe '#create_event' do
     let(:object) { double('object', :changes => changes, :user => double(User)) }
-    let(:changes) { {:foo => 'bar', :bar => 'baz', :bob => 'blah'} }
-    let(:options) { {} }
+    let(:changes) { { :foo => 'bar', :bar => 'baz', :bob => 'blah' } }
+    let(:options) { { } }
 
     subject { Eventifier::Event.create_event(:create, object, options) }
 
     describe "exclude" do
-      let(:options) { {:except => ['foo']} }
+      let(:options) { { :except => ['foo'] } }
 
       it 'should exclude the right attrs' do
         Eventifier::Event.should_receive(:create) do |attrs|
-          attrs[:change_data].should == {:bar => 'baz', :bob => 'blah'}
+          attrs[:change_data].should == { :bar => 'baz', :bob => 'blah' }
         end
         subject
       end
 
     end
     describe "only" do
-      let(:options) { {:only => ['foo']} }
+      let(:options) { { :only => ['foo'] } }
 
       it 'should exclude the right attrs' do
         Eventifier::Event.should_receive(:create) do |attrs|
-          attrs[:change_data].should == {:foo => 'bar'}
+          attrs[:change_data].should == { :foo => 'bar' }
         end
         subject
       end
@@ -104,11 +99,11 @@ describe Eventifier::EventTracking do
       end
 
       it "should create an event with the relevant info" do
-        changes = {:foo => 'bar', :bar => 'baz'}
+        changes = { :foo => 'bar', :bar => 'baz' }
         object.stub(:changes).and_return(changes)
         event_tracker.events_for test_class do
-          track_on [:create, :destroy], :attributes => {:except => %w(updated_at)}
-          track_on :update, :attributes => {:except => %w(updated_at)}
+          track_on [:create, :destroy], :attributes => { :except => %w(updated_at) }
+          track_on :update, :attributes => { :except => %w(updated_at) }
         end
 
         Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes)
@@ -120,60 +115,61 @@ describe Eventifier::EventTracking do
         event_tracker.should_receive(:track_on).exactly(2).times
 
         event_tracker.events_for test_class do
-          track_on [:create, :destroy], :attributes => {:except => %w(updated_at)}
-          track_on :update, :attributes => {:except => %w(updated_at)}
+          track_on [:create, :destroy], :attributes => { :except => %w(updated_at) }
+          track_on :update, :attributes => { :except => %w(updated_at) }
         end
       end
-    end
 
-    context "notifying" do
-      before do
-        @event_observer_instance = Eventifier::EventObserver.instance
-      end
+      context "notifying" do
+        before do
+          @event_observer_instance = Eventifier::EventObserver.instance
+          Eventifier::EventObserver.any_instance.stub post_path: '/post'
+        end
 
-      describe "#add_notification" do
+        describe "#add_notification" do
 
-        it "should add the notification to the notification hash" do
-          @event_observer_instance.should_receive(:add_notification).with(test_class, :user, :create)
+          it "should add the notification to the notification hash" do
+            @event_observer_instance.should_receive(:add_notification).with(test_class, :user, :create)
 
-          event_tracker.events_for test_class do
-            track_on :create, :attributes => {:except => %w(updated_at)}
-            notify :user, :on => :create
+            event_tracker.events_for test_class do
+              track_on :create, :attributes => { :except => %w(updated_at) }
+              notify :user, :on => :create
+            end
           end
         end
-      end
 
-      it "should notify users when passed a hash" do
-        subscriber = double('user')
+        it "should notify users when passed a hash" do
+          subscriber = double('user')
 
-        object.stub :category => double('category', :subscribers => [subscriber])
+          object.stub :category => double('category', :subscribers => [subscriber])
 
-        Eventifier::Notification.should_receive(:create) do |args|
-          args[:user].should == subscriber
-          args[:event].eventable.should == object
-        end
+          Eventifier::Notification.should_receive(:create) do |args|
+            args[:user].should == subscriber
+            args[:event].eventable.should == object
+          end
 
-        event_tracker.events_for test_class do
-          track_on :create, :attributes => {:except => %w(updated_at)}
-          notify :category => :subscribers, :on => :create
+          event_tracker.events_for test_class do
+            track_on :create, :attributes => { :except => %w(updated_at) }
+            notify :category => :subscribers, :on => :create
+          end
+
+          object.save
         end
 
-        object.save
-      end
 
+        it "should create a notification" do
+          Eventifier::Notification.should_receive(:create)
+          object.stub(:readers => [Fabricate.build(:user)])
+          event_tracker.events_for test_class do
+            track_on :create, :attributes => { :except => %w(updated_at) }
+            notify :readers, :on => :create
+          end
 
-      it "should create a notification" do
-        Eventifier::Notification.should_receive(:create)
-        object.stub(:users => [User.make])
-        event_tracker.events_for test_class do
-          track_on :create, :attributes => {:except => %w(updated_at)}
-          notify :readers, :on => :create
+          object.save
         end
 
-        object.save
       end
-
     end
-  end
 
+  end
 end

data/spec/fabricators/fabricator.rb

@@ -0,0 +1,31 @@
+require 'eventifier'
+
+
+Fabricator(:event, :class_name => Eventifier::Event) do
+  user!
+  eventable!(:fabricator => :post)
+  verb :update
+  change_data { { :date => [5.days.ago, 3.days.ago] } }
+end
+
+Fabricator(:ghost, :class_name => Eventifier::Ghost) do
+  ghost_class { "Post" }
+  ghost_id    { 123 }
+  data_hash   { Fabricate.attributes_for(:post) }
+end
+
+Fabricator(:notification, :class_name => Eventifier::Notification) do
+  event! { Fabricate(:event) }
+  user!
+end
+
+Fabricator(:post, :class_name => Post) do
+  title   { "My amazing blog post" }
+  body    { "A deep and profound analysis of life" }
+  author! { Fabricate(:user) }
+end
+
+Fabricator(:user, :class_name => User) do
+  name { "Billy #{sequence(:name, 1)}" }
+  email{ "billy#{sequence(:email, 1)}@email.com" }
+end

data/spec/ghost_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Eventifier::Ghost do
+
+  it_requires_a :ghost_class
+  it_requires_a :ghost_id
+  it_requires_a :data_hash
+
+  describe ".create_from_object" do
+    subject     { Eventifier::Ghost }
+    let(:post)  { Fabricate(:post) }
+
+    it "should create a ghost when passed an object" do
+      subject.should_receive(:create).with(:ghost_class => "Post", :ghost_id => post.id, :data_hash => post.serializable_hash)
+
+      subject.create_from_object(post)
+    end
+  end
+
+  describe "#ghost" do
+    let(:post)  { Fabricate.build(:post, :id => 123) }
+    subject     { Fabricate.build(:ghost, :data_hash => post.serializable_hash) }
+
+    it "should be an object with the attributes of the undeleted object" do
+      subject.ghost.class.should == Post
+      subject.ghost.attributes.except("_type").should == post.serializable_hash
+    end
+  end
+
+end

data/spec/helper_methods_spec.rb

@@ -10,7 +10,7 @@ describe Eventifier::EventHelper do
   let!(:helper) { TestClass.new }
 
   describe ".replace_vars" do
-    let(:event) { Eventifier::Event.make }
+    let(:event) { Fabricate.build(:event)}
 
     it "should replace {{stuff}} with awesome" do
       message = "I'm really loving {{eventable.title}}"
@@ -26,7 +26,7 @@ describe Eventifier::EventHelper do
   describe ".load_event_for_template" do
 
     it "should add some handy methods to an event instance" do
-      event = Eventifier::Event.make!
+      event = Fabricate(:event)
       event = helper.load_event_for_template event
       event.object.should == event.eventable
       event.object_type.should == event.eventable_type

data/spec/integration/eventifier_spec.rb

@@ -1,67 +1,108 @@
+require 'spec_helper'
 
 describe Eventifier do
-  let(:post) { mock_model('Post', :group => group) }
-  let(:group)    { double('group', :user => owner,
-    :members => [owner, member]) }
-  let(:owner)    { User.make! }
-  let(:member)   { double('member') }
-
-  before :each do
-    Eventifier::Notification.stub :create => true
-  end
+  let(:post) { Fabricate(:post, :author => owner) }
+  let(:owner) { Fabricate(:user) }
+  let(:reader1) { Fabricate(:user) }
+  let(:reader2) { Fabricate(:user) }
 
-  context 'a new post' do
-    let(:event) { Eventifier::Event.new :eventable => post, :verb => :create,
-      :user => owner }
-
-    it "notifies the members of the group" do
-      Eventifier::Notification.should_receive(:create).
-        with(:user => member, :event => event)
-      ActiveRecord::Observer.with_observers(Eventifier::EventObserver) do
-        event.save
-      end
+
+  let(:event_tracker) { Object.new.extend(Eventifier::EventTracking) }
+
+
+  before do
+    Eventifier::NotificationMailer.any_instance.stub main_app: double('app', url_for: true)
+    post.stub(:readers => [owner, reader1, reader2])
+
+    event_tracker.events_for Post do
+      track_on [:create, :update], :attributes => { :except => %w(updated_at) }
+      notify :readers, :on => [:create, :update]
     end
+  end
 
-    it "does not notify the person initiating the event" do
-      Eventifier::Notification.should_not_receive(:create).
-        with(:user => owner, :event => event)
+  context 'a new post' do
+    let(:post) { Fabricate.build(:post, :author => owner) }
 
-      event.save
+    it "notifies only the readers of the post" do
+      Eventifier::Notification.should_receive(:create).twice do |args|
+        args[:event].verb.should == :create
+        [reader1, reader2].should include(args[:user])
+      end
+      post.save
     end
   end
 
   context 'an existing post' do
+    let(:post) { Fabricate(:post, :author => owner) }
     let(:event) { Eventifier::Event.new :eventable => post, :verb => :update,
-      :user => owner }
-    let(:guest) { double('guest') }
+                                        :user => owner }
 
-    before :each do
-      post.group.stub :members => [owner, guest]
+    it "notifies the readers of the post" do
+      Eventifier::Notification.should_receive(:create).twice do |args|
+        args[:event].verb.should == :update
+        [reader1, reader2].should include(args[:user])
+      end
+      post.update_attribute(:title, 'something else')
     end
 
-    it "notifies the members of the post" do
-      Eventifier::Notification.should_receive(:create).
-        with(:user => guest, :event => event)
-      ActiveRecord::Observer.with_observers(Eventifier::EventObserver) do
-        event.save
-      end
+    it "should create a notification for readers of a post when it's changed" do
+      lambda { post.update_attribute(:title, 'somethang') }.should change(reader1.notifications, :count).by(1)
     end
+  end
 
-    it "does not notify the person initiating the event" do
-      Eventifier::Notification.should_not_receive(:create).
-        with(:user => owner, :event => event)
+  context "helper method" do
 
-      ActiveRecord::Observer.with_observers(Eventifier::EventObserver) do
-        event.save
+    class TestClass
+      def self.helper_method(*args)
       end
+
+      include Eventifier::EventHelper
+    end
+
+    let!(:helper) { TestClass.new }
+    before do
+      @event_strings = {
+        :post => {
+          :create => "{{user.name}} just created a new post - you should check it out",
+          :destroy => "{{user.name}} just deleted a post",
+          :update => {
+            :single => "{{user.name}} made a change to their post",
+            :multiple => "{{user.name}} made some changes to their post"
+          }
+        }
+      }
+      I18n.backend.store_translations :en, :events => @event_strings
+    end
+
+    it "should return the I18n message for that event" do
+      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
+      helper.event_message(event).should == "<strong>#{event.user.name}</strong> just created a new post - you should check it out"
     end
-  end
-  
-  it "should create a notification for users of a post when it's changed" do
-    post = event.eventable
-    user = User.make!
 
-    lambda { post.update_attribute :date, 5.days.from_now }.should change(user.notifications, :count).by(1)
+    it "should return a message specific to a single change if only 1 change has been made" do
+      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"] })
+      helper.event_message(event).should == "<strong>#{event.user.name}</strong> made a change to their post"
+    end
+
+    it "should return a message specific to multiple changes if more than 1 change has been made" do
+      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"], :age => [55, 65] })
+      helper.event_message(event).should == "<strong>#{event.user.name}</strong> made some changes to their post"
+    end
+
+    it "should return the default I18n message if one doesn't exist" do
+      I18n.backend.reload!
+      @event_strings = {
+        :default => {
+          :create => "{{user.name}} created a {{eventable_type}}",
+          :update => "{{user.name}} updated a {{eventable_type}}"
+        }
+      }
+      I18n.backend.store_translations :test, :events => @event_strings
+      I18n.with_locale("test") do
+        event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
+        helper.event_message(event).should == "<strong>#{event.user.name}</strong> created a <strong>Post</strong>"
+      end
+    end
   end
 
 end