eventifier 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b08774be55e6345a5cbeb06b9a29435a07d6d88
-  data.tar.gz: 29dd02c4708fcf7502dac329955b1faa9b5ee669
+  metadata.gz: 3ddc5253dc949cf041ed9ff68c7225b234750fd4
+  data.tar.gz: 81a0e4e9121a62a2de35453c7a301450e28d1ce7
 SHA512:
-  metadata.gz: e07d54444749d8d82ea73fd960919e1bbdc66f1a19cbf19a02e15c8431613d801e21c702b77cdb5c24a19b7dad1cdfeb34406420258302a823c283573ba8b168
-  data.tar.gz: cb591b9e8aaafed382e403ba63971346ed0b439e4ccabc2b3a5a5c75af397ddba3c2aa6c0335fdce6f1f174c083dca7150d00b11f0dde007184f19ab643615c0
+  metadata.gz: 6bf60d92b16aed0434bcfec3b9ab981eeec35b1b1c8c9d16595025f44124f41dc7c32ff061ac454fe768761fa5dfe27c31a5547199d80edcd3c017760c0a10e9
+  data.tar.gz: a025c89c3fb8f3f07a8d778de602d030bda0cb3d7f86f13261dbf06bc281418528bea49d4f6d7c4ecd1538bdbf6afd6e34c2275c9d9a395b3572dd216a78c5dd

data/app/controllers/eventifier/notifications_controller.rb

@@ -12,11 +12,11 @@ class Eventifier::NotificationsController < Eventifier::ApplicationController
   private
 
   def notifications
-    scope = current_user.notifications.order("notifications.created_at DESC").limit(per_page)
-    scope = scope.where("notifications.created_at < ?", after) if params[:after]
-    scope = scope.where("notifications.created_at > ?", since) if params[:since]
+    scope = current_user.notifications.order("eventifier_notifications.created_at DESC").limit(per_page)
+    scope = scope.where("eventifier_notifications.created_at < ?", after) if params[:after]
+    scope = scope.where("eventifier_notifications.created_at > ?", since) if params[:since]
     scope = scope.where(
-      "notifications.created_at > ?", current_user.notifications_last_read_at
+      "eventifier_notifications.created_at > ?", current_user.notifications_last_read_at
     ) if params[:recent]
 
     scope

data/app/models/eventifier/event.rb

@@ -1,8 +1,10 @@
 module Eventifier
   class Event < ActiveRecord::Base
+    self.table_name = 'eventifier_events'
+
     attr_accessible :user, :eventable, :verb, :change_data, :groupable
 
-    belongs_to  :user
+    belongs_to  :user,          class_name: Eventifier.user_model_name
     belongs_to  :eventable,     polymorphic: true
     belongs_to  :groupable,     polymorphic: true
     has_many    :notifications, class_name: 'Eventifier::Notification',
@@ -19,4 +21,4 @@ module Eventifier
       where :eventable_id => object.id, :eventable_type => object.class.name
     end
   end
-end
+end

data/app/models/eventifier/notification.rb

@@ -1,5 +1,7 @@
 module Eventifier
   class Notification < ActiveRecord::Base
+    self.table_name = 'eventifier_notifications'
+
     attr_accessible :event, :user, :relations, :event_id, :user_id
 
     belongs_to :event, :class_name => 'Eventifier::Event'
@@ -14,7 +16,9 @@ module Eventifier
     scope :for_events,  -> ids { where(event_id: ids) }
     scope :for_user,    -> user { where(user_id: user.id) }
     scope :since,       -> date { where("created_at > ?", date) }
-    scope :latest,      order('notifications.created_at DESC').limit(5)
+    scope :latest,      -> {
+      order('eventifier_notifications.created_at DESC').limit(5)
+    }
     scope :unsent,      -> { where(sent: false) }
 
     def self.expire_for_past_events!(time_limit = 1.day.ago)

data/app/models/eventifier/notification_setting.rb

@@ -1,4 +1,6 @@
 class Eventifier::NotificationSetting < ActiveRecord::Base
+  self.table_name = 'eventifier_notification_settings'
+
   belongs_to :user
 
   serialize :preferences, MultiJson

data/db/migrate/1_eventifier_setup.rb

@@ -1,6 +1,6 @@
 class EventifierSetup < ActiveRecord::Migration
   def change
-    create_table :events do |t|
+    create_table :eventifier_events do |t|
       t.integer :user_id
       t.string  :eventable_type
       t.integer :eventable_id
@@ -10,19 +10,19 @@ class EventifierSetup < ActiveRecord::Migration
       t.timestamps
     end
 
-    add_index :events, :user_id
-    add_index :events, [:eventable_id, :eventable_type]
+    add_index :eventifier_events, :user_id
+    add_index :eventifier_events, [:eventable_id, :eventable_type]
 
-    create_table :notifications do |t|
+    create_table :eventifier_notifications do |t|
       t.integer :event_id
       t.integer :user_id
       t.integer :parent_id
 
       t.timestamps
     end
-    add_index :notifications, :event_id
-    add_index :notifications, :user_id
-    add_index :notifications, :parent_id
+    add_index :eventifier_notifications, :event_id
+    add_index :eventifier_notifications, :user_id
+    add_index :eventifier_notifications, :parent_id
 
     add_column :users, :notifications_last_read_at, :datetime
   end

data/db/migrate/2_eventifier_notification_settings.rb

@@ -1,11 +1,11 @@
 class EventifierNotificationSettings < ActiveRecord::Migration
   def change
-    create_table :notification_settings do |t|
+    create_table :eventifier_notification_settings do |t|
       t.integer :user_id,     :null => false
       t.text    :preferences, :null => false, :default => '{}'
       t.timestamps
     end
 
-    add_index :notification_settings, :user_id, :unique => true
+    add_index :eventifier_notification_settings, :user_id, :unique => true
   end
 end

data/db/migrate/3_notification_sent_status.rb

@@ -1,15 +1,15 @@
 class NotificationSentStatus < ActiveRecord::Migration
   def up
-    add_column :notifications, :sent,      :boolean, :default => false
-    add_column :notifications, :relations, :text,    :default => '[]'
-    add_index  :notifications, :sent
+    add_column :eventifier_notifications, :sent,      :boolean, default: false
+    add_column :eventifier_notifications, :relations, :text,    default: '[]'
+    add_index  :eventifier_notifications, :sent
 
     Eventifier::Notification.reset_column_information
     Eventifier::Notification.update_all :sent => true
   end
 
   def down
-    remove_column :notifications, :sent
-    remove_column :notifications, :relations
+    remove_column :eventifier_notifications, :sent
+    remove_column :eventifier_notifications, :relations
   end
 end

data/db/migrate/4_event_groupable.rb

@@ -1,19 +1,19 @@
 class EventGroupable < ActiveRecord::Migration
   def up
-    add_column :events, :groupable_id,   :integer
-    add_column :events, :groupable_type, :string
+    add_column :eventifier_events, :groupable_id,   :integer
+    add_column :eventifier_events, :groupable_type, :string
 
     Eventifier::Event.reset_column_information
     Eventifier::Event.update_all(
       'groupable_id = eventable_id, groupable_type = eventable_type'
     )
 
-    change_column :events, :groupable_id,   :integer, :null => false
-    change_column :events, :groupable_type, :string,  :null => false
+    change_column :eventifier_events, :groupable_id,   :integer, :null => false
+    change_column :eventifier_events, :groupable_type, :string,  :null => false
   end
 
   def down
-    remove_column :events, :groupable_id
-    remove_column :events, :groupable_type
+    remove_column :eventifier_events, :groupable_id
+    remove_column :eventifier_events, :groupable_type
   end
 end

data/eventifier.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name        = "eventifier"
-  s.version     = '0.0.13'
+  s.version     = '0.0.14'
   s.authors     = ["Nathan Sampimon", "Peter Murray", "Pat Allan"]
   s.email       = ["nathan@inspire9.com"]
   s.homepage    = "http://github.com/inspire9/eventifier"

data/lib/eventifier.rb

@@ -24,6 +24,9 @@ module Eventifier
   mattr_accessor :mailer_name
   self.mailer_name = "::Eventifier::Mailer"
 
+  mattr_accessor :user_model_name
+  self.user_model_name = 'User'
+
   def self.setup
     yield self
   end
@@ -56,13 +59,16 @@ module Eventifier
 end
 
 
-require 'eventifier/tracker'
 require 'eventifier/delivery'
 require 'eventifier/event_tracking'
-require 'eventifier/trackable_class'
+require 'eventifier/event_builder'
+require 'eventifier/event_translator'
 require 'eventifier/event_subscriber'
+require 'eventifier/notification_translator'
 require 'eventifier/preferences'
 require 'eventifier/relationship'
+require 'eventifier/trackable_class'
+require 'eventifier/tracker'
 
 require 'eventifier/notifier/notification_mapping'
 require 'eventifier/notifier/notification_subscriber'

data/lib/eventifier/delivery.rb

@@ -6,6 +6,10 @@ class Eventifier::Delivery
     end
   end
 
+  def self.deliver_for(user)
+    new(user, user.notifications.unsent).deliver
+  end
+
   def initialize(user, notifications)
     @user, @notifications = user, notifications
   end

data/lib/eventifier/event_builder.rb

@@ -0,0 +1,33 @@
+class Eventifier::EventBuilder
+  def self.store(object, user, verb, groupable = nil, options = {})
+    new(object, user, verb, groupable || object, options).store
+  end
+
+  def initialize(object, user, verb, groupable, options)
+    @object, @user, @verb, @groupable, @options = object, user, verb,
+      groupable, options
+  end
+
+  def store
+    Eventifier::Event.create user: user, eventable: object,
+      groupable: groupable, verb: verb, change_data: change_data
+  end
+
+  private
+
+  attr_reader :object, :user, :verb, :groupable, :options
+
+  def change_data
+    changes = object.changes.stringify_keys
+
+    changes.reject! { |attribute, value|
+      options[:except].include?(attribute)
+    } if options[:except]
+
+    changes.select! { |attribute, value|
+      options[:only].include?(attribute)
+    } if options[:only]
+
+    changes.symbolize_keys
+  end
+end

data/lib/eventifier/event_subscriber.rb

@@ -1,44 +1,38 @@
 class Eventifier::EventSubscriber
-  def self.subscribe_to_all klass, names
+  def self.subscribe_to_all(klass, names)
     names.each do |method_name|
-      new.subscribe_to_method klass, method_name
+      new(klass, method_name).subscribe_to_method
     end
   end
 
-  def subscribe_to_method klass, method_name
-    name = "#{method_name}.#{klass.name.tableize}.event.eventifier"
-
-    return if ActiveSupport::Notifications.notifier.listening?(name)
-
-    ActiveSupport::Notifications.subscribe name do |*args|
-      event = ActiveSupport::Notifications::Event.new(*args)
-      event_user = if event.payload[:user]
-        Eventifier::Relationship.new(event.payload[:object], event.payload[:user]).users.first
-      else
-        event.payload[:object].user
-      end
-      groupable = event.payload[:object]
-      groupable = Eventifier::Relationship.new(groupable, event.payload[:group_by]).users.first if event.payload[:group_by]
-
-      eventifier_event = Eventifier::Event.create(
-        user:         event_user,
-        eventable:    event.payload[:object],
-        groupable:    groupable,
-        verb:         event.payload[:event],
-        change_data:  change_data(event.payload[:object], event.payload[:options])
-      )
-
-      ActiveSupport::Notifications.instrument("#{method_name}.#{klass.name.tableize}.notification.eventifier", verb: :create, event: eventifier_event, object: event.payload[:object])
+  def initialize(klass, method_name)
+    @klass, @method_name = klass, method_name
+  end
+
+  def subscribe_to_method
+    return if notifications.notifier.listening?(name)
+
+    notifications.subscribe(name) do |*args|
+      event = EventTranslator.new(*args).translate
+
+      notifications.instrument "#{prefix}.notification.eventifier",
+        verb: :create, event: event, object: event.eventable
     end
   end
 
   private
-  def change_data object, options
-    change_data = object.changes.stringify_keys
 
-    change_data = change_data.reject { |attribute, value| options[:except].include?(attribute) } if options[:except]
-    change_data = change_data.select { |attribute, value| options[:only].include?(attribute) } if options[:only]
+  attr_reader :klass, :method_name
+
+  def name
+    "#{prefix}.event.eventifier"
+  end
+
+  def notifications
+    ActiveSupport::Notifications
+  end
 
-    change_data.symbolize_keys
+  def prefix
+    "#{method_name}.#{klass.name.tableize}"
   end
-end
+end

data/lib/eventifier/event_translator.rb

@@ -0,0 +1,28 @@
+class EventTranslator
+  def initialize(*args)
+    @event = ActiveSupport::Notifications::Event.new *args
+  end
+
+  def translate
+    Eventifier::EventBuilder.store payload[:object], user, payload[:event],
+      groupable, payload[:options]
+  end
+
+  private
+
+  attr_reader :event
+
+  delegate :payload, to: :event
+
+  def groupable
+    payload[:group_by] ? relationship(payload[:group_by]) : payload[:object]
+  end
+
+  def relationship(key)
+    Eventifier::Relationship.new(payload[:object], key).users.first
+  end
+
+  def user
+    payload[:user] ? relationship(payload[:user]) : payload[:object].user
+  end
+end

data/lib/eventifier/notification_translator.rb

@@ -0,0 +1,25 @@
+class Eventifier::NotificationTranslator
+  def initialize(prefix, delivery, *args)
+    @prefix, @delivery = prefix, delivery
+    @event  = ActiveSupport::Notifications::Event.new(*args).payload[:event]
+  end
+
+  def translate
+    users_and_relations do |user, relations|
+      next if user == event.user
+
+      Eventifier::Notification.create event: event, user: user,
+        relations: relations
+
+      Eventifier::Delivery.deliver_for user if delivery == :immediate
+    end
+  end
+
+  private
+
+  attr_reader :event, :prefix, :delivery
+
+  def users_and_relations(&block)
+    Eventifier::NotificationMapping.users_and_relations event, prefix, &block
+  end
+end

data/lib/eventifier/notifier/notification_subscriber.rb

@@ -1,23 +1,33 @@
 class Eventifier::NotificationSubscriber
-  def self.subscribe_to_method klass, method_name
-    key = "#{method_name}.#{klass.name.tableize}"
-    name = "#{key}.notification.eventifier"
-
-    return if ActiveSupport::Notifications.notifier.listening?(name)
+  def self.subscribe_to_method(klass, method_name, delivery)
+    new(klass, method_name, delivery).subscribe_to_method
+  end
 
-    ActiveSupport::Notifications.subscribe name do |*args|
-      event = ActiveSupport::Notifications::Event.new(*args)
-      eventifier_event = event.payload[:event]
+  def initialize(klass, method_name, delivery)
+    @klass, @method_name, @delivery = klass, method_name, delivery
+  end
 
-      Eventifier::NotificationMapping.users_and_relations(eventifier_event, key) do |user, relations|
-        next if user == eventifier_event.user
+  def subscribe_to_method
+    return if notifications.notifier.listening?(name)
 
-        Eventifier::Notification.create(
-          event:     eventifier_event,
-          user:      user,
-          relations: relations
-        )
-      end
+    notifications.subscribe(name) do |*args|
+      Eventifier::NotificationTranslator.new(prefix, delivery, *args).translate
     end
   end
+
+  private
+
+  attr_reader :klass, :method_name, :delivery
+
+  def name
+    "#{prefix}.notification.eventifier"
+  end
+
+  def notifications
+    ActiveSupport::Notifications
+  end
+
+  def prefix
+    "#{method_name}.#{klass.name.tableize}"
+  end
 end

data/lib/eventifier/notifier/notifier.rb

@@ -1,21 +1,22 @@
 class Eventifier::Notifier
-  def initialize klasses, *args
-    # args will either be [:relation, {:on => :create}] or [{:relation => :second_relation, :on => :create}]
-    # if its the first one, relation is the first in the array, otherwise treat the whole thing like a hash
+  # arguments will either be [:relation, {:on => :create}] or
+  # [{:relation => :second_relation, :on => :create}]
+  # If it's the first one, relation is the first in the array, otherwise treat
+  # the whole thing like a hash
+  def initialize(klasses, *arguments)
+    relation   = arguments.shift if arguments.length == 2
+    arguments  = arguments.first || {}
 
-    @klasses = klasses
-    relation = args.delete_at(0) if args.length == 2
-    args = args.first || {}
+    methods    = Array arguments.delete(:on)
+    delivery   = arguments.delete(:email) || :delayed
 
-    methods  = args.delete(:on)
-    methods  = methods.kind_of?(Array) ? methods : [methods]
-    relation ||= args
+    relation ||= arguments
 
-    @klasses.each do |target_klass|
+    klasses.each do |target_klass|
       methods.each do |method_name|
         Eventifier::NotificationMapping.add "#{method_name}.#{target_klass.name.tableize}", relation
-        Eventifier::NotificationSubscriber.subscribe_to_method target_klass, method_name
+        Eventifier::NotificationSubscriber.subscribe_to_method target_klass, method_name, delivery
       end
     end
   end
-end
+end

data/lib/generators/eventifier/install/templates/event_tracking.rb

@@ -7,6 +7,4 @@ class EventTracking
     #   notify :group => :members, :on => [:create, :update]
     # end
   end
-end
-
-EventTracking.new
+end

data/spec/eventifier_spec.rb

@@ -1,21 +1,13 @@
 require 'spec_helper'
-describe Eventifier::EventTracking do
 
-  let(:user) { Fabricate(:user) }
-  let(:test_class) { Post }
-  let(:object) { Fabricate.build(:post) }
+describe Eventifier::EventTracking do
+  let(:user)          { Fabricate(:user) }
+  let(:test_class)    { Post }
+  let(:object)        { Fabricate.build(:post) }
   let(:event_tracker) { Object.new.extend(Eventifier::EventTracking) }
-
-  describe ".initialize" do
-
-    it "should start" do
-      event_tracker
-    end
-
-  end
+  let(:event)         { double eventable: double }
 
   describe ".events_for" do
-
     it "should create the relation notifications for Users" do
       event_tracker.events_for test_class,
                                :track_on => [:create, :update, :destroy],
@@ -23,16 +15,11 @@ describe Eventifier::EventTracking do
 
       user.should respond_to(:notifications)
     end
-
   end
 
   describe "hash syntax" do
-
     describe "creating events" do
-
-      let(:subject) do
-        object.save
-      end
+      let(:subject) { object.save }
 
       before do
         object.stub(:user).and_return(user)
@@ -41,25 +28,20 @@ describe Eventifier::EventTracking do
           :attributes => { :except => %w(updated_at) }
       end
 
-
       it "should create an event with the relevant info" do
         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, :groupable => object)
+        Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes, :groupable => object).and_return(event)
 
         subject
       end
     end
-
   end
 
   context "block syntax" do
-
     context "tracking" do
-      let(:subject) do
-        object.save
-      end
+      let(:subject) { object.save }
 
       before do
         object.stub(:user).and_return(user)
@@ -73,7 +55,7 @@ describe Eventifier::EventTracking do
           track_on :update, :attributes => { :except => %w(updated_at) }
         end
 
-        Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes, :groupable => object)
+        Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes, :groupable => object).and_return(event)
 
         subject
       end
@@ -130,4 +112,4 @@ describe Eventifier::EventTracking do
     end
 
   end
-end
+end

data/spec/integration/eventifier_spec.rb

@@ -149,3 +149,26 @@ describe 'event tracking' do
     end
   end
 end
+
+describe 'immediate email delivery' do
+  let(:author) { Fabricate :user }
+  let(:post)   { Fabricate :post, author: author }
+
+  before do
+    ActionMailer::Base.deliveries.clear
+
+    Object.new.extend(Eventifier::EventTracking).events_for Like do
+      track_on [:create]
+      notify likeable: :user, on: [:create], email: :immediate
+    end
+  end
+
+  it "emails the readers with a notification automatically" do
+    Like.create! user: Fabricate(:user), likeable: post
+
+    ActionMailer::Base.deliveries.detect { |email|
+      email.to      == [author.email] &&
+      email.subject == 'You have received notifications'
+    }.should be_present
+  end
+end

data/spec/internal/app/models/like.rb

@@ -0,0 +1,4 @@
+class Like < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :likeable, polymorphic: true
+end

data/spec/internal/db/schema.rb

@@ -12,9 +12,10 @@ ActiveRecord::Schema.define do
     t.timestamps
   end
 
-  create_table :users, :force => true do |t|
-    t.column :name, :string
-    t.column :email, :string
+  create_table :likes, :force => true do |t|
+    t.integer :user_id
+    t.string  :likeable_type
+    t.integer :likeable_id
   end
 
   create_table :posts, :force => true do |t|
@@ -28,4 +29,9 @@ ActiveRecord::Schema.define do
     t.column :user_id, :integer
     t.column :post_id, :integer
   end
+
+  create_table :users, :force => true do |t|
+    t.column :name, :string
+    t.column :email, :string
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventifier
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Nathan Sampimon
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-21 00:00:00.000000000 Z
+date: 2013-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -225,10 +225,13 @@ files:
 - lib/eventifier.rb
 - lib/eventifier/delivery.rb
 - lib/eventifier/engine.rb
+- lib/eventifier/event_builder.rb
 - lib/eventifier/event_subscriber.rb
 - lib/eventifier/event_tracking.rb
+- lib/eventifier/event_translator.rb
 - lib/eventifier/mailers/helpers.rb
 - lib/eventifier/matchers.rb
+- lib/eventifier/notification_translator.rb
 - lib/eventifier/notifier/notification_mapping.rb
 - lib/eventifier/notifier/notification_subscriber.rb
 - lib/eventifier/notifier/notifier.rb
@@ -255,6 +258,7 @@ files:
 - spec/internal/app/controllers/application_controller.rb
 - spec/internal/app/lib/event_tracking.rb
 - spec/internal/app/models/category.rb
+- spec/internal/app/models/like.rb
 - spec/internal/app/models/post.rb
 - spec/internal/app/models/subscription.rb
 - spec/internal/app/models/user.rb
@@ -313,6 +317,7 @@ test_files:
 - spec/internal/app/controllers/application_controller.rb
 - spec/internal/app/lib/event_tracking.rb
 - spec/internal/app/models/category.rb
+- spec/internal/app/models/like.rb
 - spec/internal/app/models/post.rb
 - spec/internal/app/models/subscription.rb
 - spec/internal/app/models/user.rb