eventifier 0.0.7 → 0.0.8

data/lib/eventifier/relationship.rb

@@ -0,0 +1,36 @@
+class Eventifier::Relationship
+  def initialize(source, relation)
+    @source, @relation = source, relation
+  end
+
+  def key
+    key_from relation
+  end
+
+  def users
+    Array object.send(method)
+  end
+
+  private
+
+  attr_reader :relation, :source
+
+  def object
+    relation.is_a?(Hash) ? source.send(relation.keys.first) : source
+  end
+
+  def method
+    relation.is_a?(Hash) ? relation.values.first : relation
+  end
+
+  def key_from(object)
+    case object
+    when Hash
+      "#{object.keys.first}_#{key_from object.values.first}"
+    when Array
+      object.join('-')
+    else
+      object.to_s
+    end
+  end
+end

data/lib/eventifier/trackable_class.rb

@@ -0,0 +1,74 @@
+class Eventifier::TrackableClass
+  Eventifier::OBSERVER_CLASS = ActiveRecord::Observer
+
+  def self.track(klass, klass_methods, attributes)
+    self.new(klass, klass_methods, attributes).track
+  end
+
+  def initialize(klass, klass_methods, options)
+    @klass, @klass_methods = klass, klass_methods
+
+    @attributes = options.delete(:attributes) || {}
+    @owner      = options.delete :owner
+    @group_by   = options.delete :group_by
+  end
+
+  def track
+    add_relations
+    generate_observer_callbacks
+
+    observer.instance
+
+    Eventifier::EventSubscriber.subscribe_to_all @klass, @klass_methods
+  end
+
+  private
+
+  def add_relations
+    @klass.class_eval do
+      has_many :events, as: :eventable, class_name: 'Eventifier::Event',
+        dependent: :destroy
+      has_many :notifications, through: :events,
+        class_name: 'Eventifier::Notification'
+    end
+  end
+
+  def generate_observer_callbacks
+    methods, attributes, klass, owner, group_by =
+      @klass_methods, @attributes, @klass, @owner, @group_by
+
+    observer.class_eval do
+      methods.each do |method|
+        define_method "after_#{method}" do |object|
+          Rails.logger.debug "||ASN|| Instrument #{method}.#{klass.name.tableize}" if defined?(Rails)
+          ActiveSupport::Notifications.instrument(
+            "#{method}.#{klass.name.tableize}.event.eventifier",
+            event: method.to_sym,
+            object: object,
+            options: attributes,
+            user: owner,
+            group_by: group_by
+          ) if object.changed?
+        end
+      end
+    end
+  end
+
+  def observer
+    @observer ||= begin
+      observer_klass.observe @klass
+
+      observer_klass
+    end
+  end
+
+  def observer_klass
+    @observer_klass ||= if self.class.const_defined?("#{@klass}Observer")
+      self.class.const_get("#{@klass}Observer")
+    else
+      constant_name = "#{@klass}Observer"
+      klass         = Class.new(Eventifier::OBSERVER_CLASS)
+      self.class.qualified_const_set(constant_name, klass)
+    end
+  end
+end

data/lib/eventifier/tracker.rb

@@ -0,0 +1,18 @@
+module Eventifier
+  class Tracker
+    def initialize klasses, methods, options
+      @klasses   = klasses
+      methods    = methods.kind_of?(Array) ? methods : [methods]
+      raise 'No events defined to track' if methods.compact.empty?
+
+      User.class_eval {
+        has_many :notifications, class_name: 'Eventifier::Notification'
+      } unless User.respond_to?(:notifications)
+
+      # set up each class with an observer and relationships
+      @klasses.each do |target_klass|
+        Eventifier::TrackableClass.track target_klass, methods, options
+      end
+    end
+  end
+end

data/lib/eventifier.rb

@@ -16,27 +16,51 @@
 
 # class EventTracking
 #   include Eventable::EventTracking
-# 
+#
 #   def initialize
 #     events_for Activity,
 #                :on => [:create, :update, :destroy],
 #                :attributes => { :except => %w(updated_at) }
 #   end
-# 
+#
 # end
+
+require 'multi_json'
 require 'action_mailer'
+require 'haml-rails'
+
+module Eventifier
+  mattr_accessor :mailer_sender
+  self.mailer_sender = nil
+
+  mattr_accessor :mailer_name
+  self.mailer_name = "::Eventifier::Mailer"
 
-if defined? Mongoid
-  require 'eventifier/mongoid_support'
-elsif defined? ActiveRecord
-  require 'eventifier/active_record_support'
+  def self.setup
+    yield self
+  end
+
+  def self.mailer
+    ActiveSupport::Dependencies.constantize(@@mailer_name)
+  end
+
+  def self.tracked_classes
+    @tracked_classes ||= []
+  end
 end
 
-require 'eventifier/helper_methods'
-require 'eventifier/notification_mailer'
-require 'eventifier/notification_helper'
-require 'eventifier/event_helper'
+require 'eventifier/tracker'
+require 'eventifier/delivery'
 require 'eventifier/event_tracking'
+require 'eventifier/trackable_class'
+require 'eventifier/event_subscriber'
+require 'eventifier/preferences'
+require 'eventifier/relationship'
+
+require 'eventifier/notifier/notification_mapping'
+require 'eventifier/notifier/notification_subscriber'
+require 'eventifier/notifier/notifier'
 
-require 'eventifier/railtie' if defined?(Rails)
+require 'eventifier/mailers/helpers'
 
+require 'eventifier/engine' if defined?(Rails)

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

@@ -3,9 +3,6 @@ require 'rails/generators/active_record'
 module Eventifier
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      include Rails::Generators::Migration
-      extend ActiveRecord::Generators::Migration
-
       source_root File.expand_path('../templates', __FILE__)
 
       def copy_event_tracking
@@ -16,8 +13,8 @@ module Eventifier
         copy_file "events.en.yaml", "config/locales/events.en.yaml"
       end
 
-      def generate_migration
-        migration_template "migration.rb", "db/migrate/eventifier_setup.rb" if defined?(ActiveRecord)
+      def add_routes
+        route %Q{mount Eventifier::Engine => '/'}
       end
 
     end

data/lib/generators/eventifier/install/templates/events.en.yaml

@@ -6,6 +6,7 @@ en:
         single: "{{user.name}} updated a {{object_type}}"
         multiple: "{{user.name}} made some changes to a {{object_type}}"
   notifications:
+    email_subject: "You have received a notification"
     default:
       create: "{{user.name}} created a <strong>{{object_type}}</strong>"
       update:

data/lib/tasks/email.rake

@@ -0,0 +1,8 @@
+namespace :eventifier do
+  namespace :email do
+    desc 'Send Eventifier notification emails'
+    task :deliver => :environment do
+      Eventifier::Delivery.deliver
+    end
+  end
+end

data/spec/controllers/eventifier/notifications_controller_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Eventifier::NotificationsController do
+  describe '#touch' do
+    let(:user) { double 'User', :update_attribute => true }
+
+    before :each do
+      sign_in user
+    end
+
+    it "updates the current user's notifications last read at" do
+      user.should_receive(:update_attribute).
+        with(:notifications_last_read_at, anything)
+
+      post :touch
+    end
+
+    it "responds with JSON OK status" do
+      post :touch
+
+      response.body.should == {'status' => 'OK'}.to_json
+    end
+  end
+end

data/spec/controllers/eventifier/preferences_controller_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Eventifier::PreferencesController do
+  let(:user) { double 'User' }
+
+  before :each do
+    sign_in user
+
+    Eventifier::Preferences.stub :new => preferences
+  end
+
+  describe '#show' do
+    let(:preferences) { double :to_hashes => [{'foo' => 'bar'}] }
+
+    it "returns the settings hashes" do
+      get :show
+
+      response.body.should == [{'foo' => 'bar'}].to_json
+    end
+  end
+
+  describe '#update' do
+    let(:preferences) { double to_hashes: [{:key => 'foo'}, {:key => 'bar'}] }
+    let(:settings)    { double 'Settings', :preferences => {}, :save => true }
+
+    before :each do
+      Eventifier::NotificationSetting.stub :for_user => settings
+    end
+
+    it "updates the user's email preferences" do
+      put :update, :preferences => {'foo' => ''}
+
+      settings.preferences['email']['foo'].should be_true
+      settings.preferences['email']['bar'].should be_false
+    end
+
+    it "sets everything to false if no preferences are supplied" do
+      put :update
+
+      settings.preferences['email']['foo'].should be_false
+      settings.preferences['email']['bar'].should be_false
+    end
+
+    it 'saves the settings changes' do
+      settings.should_receive(:save)
+
+      put :update, :preferences => {'foo' => ''}
+    end
+
+    it "renders a JSON OK status" do
+      put :update, :preferences => {'foo' => ''}
+
+      response.body.should == {'status' => 'OK'}.to_json
+    end
+  end
+end

data/spec/eventifier/delivery_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Eventifier::Delivery do
+  describe '#deliver' do
+    let(:delivery)     { Eventifier::Delivery.new double, [notification] }
+    let(:notification) { double 'Notification', relations: [:subscribers], event: event, update_attribute: true }
+    let(:event)        { double 'Event', verb: 'create',
+      eventable_type: 'Post' }
+    let(:email)        { double 'Email', deliver: true }
+    let(:settings)     { double 'Settings', preferences: {} }
+    let(:mailer)       { double 'Mailer', notifications: email }
+
+    before :each do
+      Eventifier.stub mailer: mailer
+      Eventifier::NotificationSetting.stub for_user: settings
+    end
+
+    shared_examples_for 'a delivered email' do
+      it "sends the email" do
+        email.should_receive(:deliver)
+
+        delivery.deliver
+      end
+
+      it "updates the sent status of the notification" do
+        notification.should_receive(:update_attribute).with(:sent, true)
+
+        delivery.deliver
+      end
+    end
+
+    shared_examples_for 'a blocked email' do
+      it "does not send the email" do
+        email.should_not_receive(:deliver)
+
+        delivery.deliver
+      end
+
+      it "updates the sent status of the notification" do
+        notification.should_receive(:update_attribute).with(:sent, true)
+
+        delivery.deliver
+      end
+    end
+
+    context 'no settings' do
+      before :each do
+        settings.preferences['email'] = {}
+      end
+
+      it_should_behave_like 'a delivered email'
+    end
+
+    context "default is set to true" do
+      before :each do
+        settings.preferences['email'] = {'default' => true}
+      end
+
+      it_should_behave_like 'a delivered email'
+    end
+
+    context "default is set to false" do
+      before :each do
+        settings.preferences['email'] = {'default' => false}
+      end
+
+      it_should_behave_like 'a blocked email'
+    end
+
+    context "default and post are set to true" do
+      before :each do
+        settings.preferences['email'] = {
+          'default' => true, 'create_posts_notify_subscribers' => true
+        }
+      end
+
+      it_should_behave_like 'a delivered email'
+    end
+
+    context "default is set to false but post is set to true" do
+      before :each do
+        settings.preferences['email'] = {
+          'default' => false, 'create_posts_notify_subscribers' => true
+        }
+      end
+
+      it_should_behave_like 'a delivered email'
+    end
+
+    context "default is set to true but post is set to false" do
+      before :each do
+        settings.preferences['email'] = {
+          'default' => true, 'create_posts_notify_subscribers' => false
+        }
+      end
+
+      it_should_behave_like 'a blocked email'
+    end
+
+    context "default and post are both set to false" do
+      before :each do
+        settings.preferences['email'] = {
+          'default' => false, 'create_posts_notify_subscribers' => false
+        }
+      end
+
+      it_should_behave_like 'a blocked email'
+    end
+  end
+end

data/spec/eventifier/preferences_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Eventifier::Preferences do
+  let(:preferences) { Eventifier::Preferences.new double('User') }
+  let(:settings)    { double 'Settings', :preferences => {} }
+
+  before :each do
+    Eventifier::NotificationMapping.stub :notification_mappings => {
+      'create.posts'    => [:readers],
+      'create.comments' => [{:post => :readers}]
+    }
+    Eventifier::NotificationSetting.stub :for_user => settings
+  end
+
+  describe '#to_hashes' do
+    it "interprets each key" do
+      preferences.to_hashes.collect { |hash| hash[:key] }.should == [
+        'default',
+        'create_posts_notify_readers',
+        'create_comments_notify_post_readers'
+      ]
+    end
+
+    it "sets values to true if unknown" do
+      preferences.to_hashes.collect { |hash| hash[:value] }.
+        should == [true, true, true]
+    end
+
+    it "sets values to true if known and true" do
+      settings.preferences['email'] = {}
+      settings.preferences['email']['create_posts_notify_readers'] = true
+
+      preferences.to_hashes.collect { |hash| hash[:value] }.
+        should == [true, true, true]
+    end
+
+    it "sets values to false if known and false" do
+      settings.preferences['email'] = {}
+      settings.preferences['email']['create_posts_notify_readers'] = false
+
+      preferences.to_hashes.collect { |hash| hash[:value] }.
+        should == [true, false, true]
+    end
+
+    it "returns keys if no translations available for labels" do
+      preferences.to_hashes.collect { |hash| hash[:label] }.should == [
+        'default',
+        'create_posts_notify_readers',
+        'create_comments_notify_post_readers'
+      ]
+    end
+
+    it "matches translations for labels" do
+      I18n.backend.reload!
+      I18n.backend.store_translations :en, :events => {
+        :labels => {
+          :preferences => {
+            'default'                             => 'All Events',
+            'create_posts_notify_readers'         => 'New Posts',
+            'create_comments_notify_post_readers' => 'New Comments'
+          }
+        }
+      }
+
+      preferences.to_hashes.collect { |hash| hash[:label] }.
+        should == ['All Events', 'New Posts', 'New Comments']
+    end
+  end
+end

data/spec/eventifier/relationship_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Eventifier::Relationship do
+  describe '#key' do
+    it "translates symbol relations to strings" do
+      Eventifier::Relationship.new(double, :mouse).key.should == 'mouse'
+    end
+
+    it "translates hash relations to period-separated strings" do
+      Eventifier::Relationship.new(double, :cat => :mouse).key.
+        should == 'cat_mouse'
+    end
+
+    it "translates array relations to hyphen-separated strings" do
+      Eventifier::Relationship.new(double, [:cat, :mouse]).key.
+        should == 'cat-mouse'
+    end
+  end
+
+  describe '#users' do
+    it "should call the string as a method when passed a string" do
+      object = double('object', :mouse => 5)
+
+      Eventifier::Relationship.new(object, :mouse).users.should == [5]
+    end
+
+    it "should string the methods when passed a hash" do
+      object = double('object', :cat => (cat = double('cat', :mouse => 5)))
+
+      Eventifier::Relationship.new(object, :cat => :mouse).users.should == [5]
+    end
+  end
+end

data/spec/eventifier_spec.rb

@@ -37,8 +37,8 @@ describe Eventifier::EventTracking do
       before do
         object.stub(:user).and_return(user)
         event_tracker.events_for test_class,
-                                 :track_on => [:create, :update, :destroy],
-                                 :attributes => { :except => %w(updated_at) }
+          :track_on => [:create, :update, :destroy],
+          :attributes => { :except => %w(updated_at) }
       end
 
 
@@ -46,7 +46,7 @@ describe Eventifier::EventTracking 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)
+        Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes, :groupable => object)
 
         subject
       end
@@ -54,39 +54,6 @@ describe Eventifier::EventTracking do
 
   end
 
-  describe '#create_event' do
-    let(:object) { double('object', :changes => changes, :user => double(User)) }
-    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'] } }
-
-      it 'should exclude the right attrs' do
-        Eventifier::Event.should_receive(:create) do |attrs|
-          attrs[:change_data].should == { :bar => 'baz', :bob => 'blah' }
-        end
-        subject
-      end
-
-    end
-    describe "only" do
-      let(:options) { { :only => ['foo'] } }
-
-      it 'should exclude the right attrs' do
-        Eventifier::Event.should_receive(:create) do |attrs|
-          attrs[:change_data].should == { :foo => 'bar' }
-        end
-        subject
-      end
-
-    end
-
-  end
-
-
   context "block syntax" do
 
     context "tracking" do
@@ -106,7 +73,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)
+        Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes, :groupable => object)
 
         subject
       end
@@ -121,24 +88,15 @@ describe Eventifier::EventTracking do
       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
 
           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
-            end
           end
         end
 
         it "should notify users when passed a hash" do
+          pending
+
           subscriber = double('user')
 
           object.stub :category => double('category', :subscribers => [subscriber])

data/spec/fabricators/fabricator.rb

@@ -1,9 +1,9 @@
 require 'eventifier'
 
-
 Fabricator(:event, :class_name => Eventifier::Event) do
-  user!
-  eventable!(:fabricator => :post)
+  user
+  eventable(:fabricator => :post)
+  groupable(:fabricator => :post)
   verb :update
   change_data { { :date => [5.days.ago, 3.days.ago] } }
 end
@@ -15,17 +15,17 @@ Fabricator(:ghost, :class_name => Eventifier::Ghost) do
 end
 
 Fabricator(:notification, :class_name => Eventifier::Notification) do
-  event! { Fabricate(:event) }
-  user!
+  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) }
+  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
+  name  { "Billy #{sequence(:name, 1)}" }
+  email { "billy#{sequence(:email, 1)}@email.com" }
+end