eventifier 0.0.14 → 0.1.0

data/lib/eventifier/preferences.rb

@@ -13,10 +13,24 @@ class Eventifier::Preferences
     end
   end
 
+  def update(preferences)
+    settings.preferences['email'] ||= {}
+    to_hashes.each do |hash|
+      settings.preferences['email'][hash[:key]] = boolean(
+        preferences[hash[:key]]
+      )
+    end
+    settings.save
+  end
+
   private
 
   attr_reader :user
 
+  def boolean(value)
+    !(value.nil? || value == '0')
+  end
+
   def keys
     @keys ||= begin
       hash = Eventifier::NotificationMapping.notification_mappings

data/lib/eventifier/tracker.rb

@@ -8,6 +8,13 @@ module Eventifier
       User.class_eval {
         has_many :notifications, class_name: 'Eventifier::Notification'
       } unless User.respond_to?(:notifications)
+      User.class_eval {
+        has_one :notification_setting,
+                class_name: 'Eventifier::NotificationSetting',
+                dependent: :destroy
+      } unless User.respond_to?(:notification_setting)
+
+
 
       # set up each class with an observer and relationships
       @klasses.each do |target_klass|

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

@@ -10,7 +10,7 @@ module Eventifier
       end
 
       def copy_language
-        copy_file "events.en.yaml", "config/locales/events.en.yaml"
+        copy_file "events.en.yaml", "config/locales/events.en.yml"
       end
 
       def add_routes

data/lib/generators/eventifier/install/templates/{events.en.yaml → events.en.yml}

@@ -1,5 +1,8 @@
 en:
   events:
+    labels:
+      preferences:
+        default: "All notifications"
     default:
       create: "{{user.name}} created a <strong>{{object_type}}</strong>"
       update:

data/spec/controllers/eventifier/notifications_controller_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Eventifier::NotificationsController do
+  routes     { Eventifier::Engine.routes }
+
   describe '#touch' do
     let(:user) { double 'User', :update_attribute => true }
 
@@ -18,7 +20,7 @@ describe Eventifier::NotificationsController do
     it "responds with JSON OK status" do
       post :touch
 
-      response.body.should == {'status' => 'OK'}.to_json
+      expect(response.body).to eq ({'status' => 'OK'}.to_json)
     end
   end
 end

data/spec/controllers/eventifier/preferences_controller_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Eventifier::PreferencesController do
+  routes     { Eventifier::Engine.routes }
   let(:user) { double 'User' }
 
   before :each do
@@ -15,34 +16,15 @@ describe Eventifier::PreferencesController do
     it "returns the settings hashes" do
       get :show
 
-      response.body.should == [{'foo' => 'bar'}].to_json
+      expect(response.body).to eq ([{'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
+    let(:preferences) { double update: true }
 
     it 'saves the settings changes' do
-      settings.should_receive(:save)
+      preferences.should_receive(:update).with('foo' => '')
 
       put :update, :preferences => {'foo' => ''}
     end
@@ -50,7 +32,7 @@ describe Eventifier::PreferencesController do
     it "renders a JSON OK status" do
       put :update, :preferences => {'foo' => ''}
 
-      response.body.should == {'status' => 'OK'}.to_json
+      expect(response.body).to eq ({'status' => 'OK'}.to_json)
     end
   end
 end

data/spec/event_tracking_spec.rb

@@ -12,9 +12,9 @@ describe Eventifier::EventTracking do
 
       event_tracker.url url_proc
 
-      Eventifier::EventTracking.url_mappings[:activity].should == url_proc
+      expect(Eventifier::EventTracking.url_mappings[:activity]).to eq url_proc
     end
 
   end
 
-end
+end

data/spec/eventifier/notification_translator_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe Eventifier::NotificationTranslator do
+  let(:translator) {
+    Eventifier::NotificationTranslator.new 'foo', options, :bar
+  }
+  let(:options)    { {} }
+  let(:object)     { double 'EventableObject'}
+  let(:event)      { double 'Event', user: double, eventable: object }
+  let(:user_a)     { double 'User' }
+  let(:user_b)     { double 'User' }
+
+  before :each do
+    stub_const 'ActiveSupport::Notifications::Event',
+      double(new: double(payload: {event: event}))
+    stub_const 'Eventifier::NotificationMapping', double
+    stub_const 'Eventifier::Notification', double(create: double)
+    stub_const 'Eventifier::Delivery', double(deliver_for: true)
+
+    Eventifier::NotificationMapping.stub(:users_and_relations).
+      and_yield(user_a, [:a]).and_yield(user_b, [:b])
+  end
+
+  describe '#translate' do
+    it "creates a notification for each affected user" do
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_a, relations: [:a])
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_b, relations: [:b])
+
+      translator.translate
+    end
+
+    it "does not create an event for the originator's user" do
+      event.stub user: user_a
+
+      Eventifier::Notification.should_not_receive(:create).
+        with(event: event, user: user_a, relations: [:a])
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_b, relations: [:b])
+
+      translator.translate
+    end
+
+    it "creates a notification for the originating user if allowed" do
+      options[:notify_self] = true
+
+      event.stub user: user_a
+
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_a, relations: [:a])
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_b, relations: [:b])
+
+      translator.translate
+    end
+
+    it "creates an event when :if is set and returns true" do
+      options[:if] = Proc.new { |event, user| true }
+
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_a, relations: [:a])
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_b, relations: [:b])
+
+      translator.translate
+    end
+
+    it "does not create an event when :if is set and returns false" do
+      options[:if] = Proc.new { |event, user| false }
+
+      Eventifier::Notification.should_not_receive(:create).
+        with(event: event, user: user_a, relations: [:a])
+      Eventifier::Notification.should_not_receive(:create).
+        with(event: event, user: user_b, relations: [:b])
+
+      translator.translate
+    end
+
+    it "creates an event when :unless is set and returns false" do
+      options[:unless] = Proc.new { |event, user| false }
+
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_a, relations: [:a])
+      Eventifier::Notification.should_receive(:create).
+        with(event: event, user: user_b, relations: [:b])
+
+      translator.translate
+    end
+
+    it "does not create an event when :unless is set and returns true" do
+      options[:unless] = Proc.new { |event, user| true }
+
+      Eventifier::Notification.should_not_receive(:create).
+        with(event: event, user: user_a, relations: [:a])
+      Eventifier::Notification.should_not_receive(:create).
+        with(event: event, user: user_b, relations: [:b])
+
+      translator.translate
+    end
+
+    it "does not deliver an email by default" do
+      Eventifier::Delivery.should_not_receive(:deliver_for).with(user_a)
+      Eventifier::Delivery.should_not_receive(:deliver_for).with(user_b)
+
+      translator.translate
+    end
+
+    it "delivers email when :email is set to :immediate" do
+      options[:email] = :immediate
+
+      Eventifier::Delivery.should_receive(:deliver_for).with(user_a)
+      Eventifier::Delivery.should_receive(:deliver_for).with(user_b)
+
+      translator.translate
+    end
+  end
+end

data/spec/eventifier/preferences_spec.rb

@@ -14,7 +14,7 @@ describe Eventifier::Preferences do
 
   describe '#to_hashes' do
     it "interprets each key" do
-      preferences.to_hashes.collect { |hash| hash[:key] }.should == [
+      expect(preferences.to_hashes.collect { |hash| hash[:key] }).to eq [
         'default',
         'create_posts_notify_readers',
         'create_comments_notify_post_readers'
@@ -22,28 +22,28 @@ describe Eventifier::Preferences do
     end
 
     it "sets values to true if unknown" do
-      preferences.to_hashes.collect { |hash| hash[:value] }.
-        should == [true, true, true]
+      expect(preferences.to_hashes.collect { |hash| hash[:value] }).
+        to eq [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]
+      expect(preferences.to_hashes.collect { |hash| hash[:value] }).
+        to eq [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]
+      expect(preferences.to_hashes.collect { |hash| hash[:value] }).
+        to eq [true, false, true]
     end
 
     it "returns keys if no translations available for labels" do
-      preferences.to_hashes.collect { |hash| hash[:label] }.should == [
+      expect(preferences.to_hashes.collect { |hash| hash[:label] }).to eq [
         'default',
         'create_posts_notify_readers',
         'create_comments_notify_post_readers'
@@ -62,8 +62,45 @@ describe Eventifier::Preferences do
         }
       }
 
-      preferences.to_hashes.collect { |hash| hash[:label] }.
-        should == ['All Events', 'New Posts', 'New Comments']
+      expect(preferences.to_hashes.collect { |hash| hash[:label] }).
+        to eq ['All Events', 'New Posts', 'New Comments']
+    end
+  end
+
+  describe '#update' do
+    before :each do
+      settings.stub save: true
+    end
+
+    it "updates the user's email preferences" do
+      preferences.update(
+        'create_posts_notify_readers'         => '',
+        'create_comments_notify_post_readers' => '0'
+      )
+
+      expect(
+        settings.preferences['email']['create_posts_notify_readers']
+      ).to be_truthy
+      expect(
+        settings.preferences['email']['create_comments_notify_post_readers']
+      ).to be_falsey
+    end
+
+    it "sets everything to false if no preferences are supplied" do
+      preferences.update({})
+
+      expect(
+        settings.preferences['email']['create_posts_notify_readers']
+      ).to be_falsey
+      expect(
+        settings.preferences['email']['create_comments_notify_post_readers']
+      ).to be_falsey
+    end
+
+    it 'saves the settings changes' do
+      settings.should_receive(:save)
+
+      preferences.update('create_posts_notify_readers' => '')
     end
   end
 end

data/spec/eventifier/relationship_spec.rb

@@ -3,17 +3,17 @@ 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'
+      expect(Eventifier::Relationship.new(double, :mouse).key).to eq 'mouse'
     end
 
     it "translates hash relations to period-separated strings" do
-      Eventifier::Relationship.new(double, :cat => :mouse).key.
-        should == 'cat_mouse'
+      expect(Eventifier::Relationship.new(double, :cat => :mouse).key).
+        to eq 'cat_mouse'
     end
 
     it "translates array relations to hyphen-separated strings" do
-      Eventifier::Relationship.new(double, [:cat, :mouse]).key.
-        should == 'cat-mouse'
+      expect(Eventifier::Relationship.new(double, [:cat, :mouse]).key).
+        to eq 'cat-mouse'
     end
   end
 
@@ -21,13 +21,13 @@ describe Eventifier::Relationship 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]
+      expect(Eventifier::Relationship.new(object, :mouse).users).to eq [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]
+      expect(Eventifier::Relationship.new(object, :cat => :mouse).users).to eq [5]
     end
   end
-end
+end

data/spec/eventifier_spec.rb

@@ -13,7 +13,7 @@ describe Eventifier::EventTracking do
                                :track_on => [:create, :update, :destroy],
                                :attributes => { :except => %w(updated_at) }
 
-      user.should respond_to(:notifications)
+      expect(user).to respond_to(:notifications)
     end
   end
 
@@ -32,7 +32,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, :groupable => object).and_return(event)
+        Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes, :groupable => object, :system => nil).and_return(event)
 
         subject
       end
@@ -55,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).and_return(event)
+        Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes, :groupable => object, :system => nil).and_return(event)
 
         subject
       end
@@ -84,16 +84,20 @@ describe Eventifier::EventTracking do
           object.stub :category => double('category', :subscribers => [subscriber])
 
           Eventifier::Notification.should_receive(:create) do |args|
-            args[:user].should == subscriber
-            args[:event].eventable.should == object
-          end
+            expect(args[:user]).to == subscriber
+            expect(args[:event].eventable).to == object
+          end.and_return(nil)
 
-          event_tracker.events_for test_class do
-            track_on :create, :attributes => { :except => %w(updated_at) }
-            notify :category => :subscribers, :on => :create
-          end
+          # event_tracker.events_for test_class do
+          #   track_on :create, :attributes => { :except => %w(updated_at) }
+          #   notify :category => :subscribers, :on => :create
+          # end
 
           object.save
+
+          ActiveSupport::Notifications.notifier.listeners_for('create.posts.notification.eventifier').each do |listener|
+            ActiveSupport::Notifications.unsubscribe(listener)
+          end
         end