eventifier 0.0.1

data/lib/eventifier/matchers.rb

@@ -0,0 +1,34 @@
+module Eventifier
+  module Matchers
+    class Notifications
+      def initialize(target)
+        @target = target
+      end
+
+      def matches?(block_to_test)
+        #before = incidents_count
+        existing_notifications = @target.inject({}) do |memo, record|
+          memo[record] = record.notifications
+        end
+        block_to_test.call
+        @target.none? do |record|
+          (existing_notifications[record] - record.notifications).empty?
+        end
+      end
+
+      def failure_message_for_should
+        'should have worked'
+        #"the block should have chronicled the '#{ @event_name }' incident for the #{ @target.class.name }##{ @target.object_id }, but it didn't"
+      end
+
+      def failure_message_for_should_not
+        'should not have worked'
+        #"the block should not have chronicled the '#{ @event_name }' incident for the #{ @target.class.name }##{ @target.object_id }, but it did"
+      end
+    end
+
+    def create_notifications_for(target)
+      Matchers::Notifications.new(target)
+    end
+  end
+end

data/lib/eventifier/notification.rb

@@ -0,0 +1,40 @@
+module Eventifier
+  class Notification < ActiveRecord::Base
+    belongs_to :event
+    belongs_to :user
+
+    default_scope order("created_at DESC")
+    scope :for_events,  lambda { |ids| where(:event_id => ids) }
+    scope :for_user,    lambda { |id| where(:user_id => id) }
+    scope :latest,      order('notifications.created_at DESC').limit(5)
+
+    validates :event,     :presence => true
+    validates :user,      :presence => true
+    validates :event_id,  :uniqueness => { :scope => :user_id }
+
+    after_create :send_email
+
+    def self.expire_for_past_events!(time_limit = 1.day.ago)
+      self.for_events(Event.expired_ids(time_limit)).each &:expire!
+    end
+
+    def self.unread_for(user)
+      if user.notifications_last_read_at
+        for_user(user).
+          where("notifications.created_at > ?", user.notifications_last_read_at)
+      else
+        for_user(user)
+      end
+    end
+
+    def unread_for?(user)
+      return true if user.notifications_last_read_at.nil?
+      created_at > user.notifications_last_read_at
+    end
+
+    def send_email
+      # TODO: Are we okay to have notifier sit on the gem? How is this going to be handled?
+      Eventifier::NotificationMailer.notification_email(self).deliver
+    end
+  end
+end

data/lib/eventifier/notification_helper.rb

@@ -0,0 +1,51 @@
+module Eventifier
+  module NotificationHelper
+    include Eventifier::HelperMethods
+
+    # A helper for outputting a notification message.
+    #
+    # Uses I18n messages from config/locales/events.en.yml to generate these messages, or defaults to a standard.
+    #
+    # Example:
+    #
+    # %ul#recent_notifications
+    #   - current_user.notifications.each do |notification|
+    #     %li= notification_message notification.event
+
+    def notification_message event
+      if event.verb.to_sym == :update
+        if event.change_data.keys.count == 1
+          key = "notifications.#{event.eventable_type.downcase}.#{event.verb}.single"
+        else
+          key = "notifications.#{event.eventable_type.downcase}.#{event.verb}.multiple"
+        end
+      else
+        key = "notifications.#{event.eventable_type.downcase}.#{event.verb}"
+      end
+      message = I18n.translate key, :default => :"notifications.default.#{event.verb}", "user.name" => event.user.name, :"event.type" => event.eventable_type
+
+      replace_vars(message, event).html_safe
+    end
+
+    # Generating where the notification should lead when clicked
+
+    def notification_url eventable
+      case eventable.class.name.downcase.to_sym
+      when :activity
+        url_for([eventable.group, eventable])
+      when :announcement
+        url_for([eventable.group, eventable.activity])
+      end
+    end
+
+    def self.included(base)
+      base.helper_method :notification_message, :notification_url
+    end
+  end
+end
+
+if defined? ActionController::Base
+  ActionController::Base.class_eval do
+    include Eventifier::NotificationHelper
+  end
+end

data/lib/eventifier/notification_mailer.rb

@@ -0,0 +1,20 @@
+require 'eventifier/notification_helper'
+
+module Eventifier
+  class NotificationMailer < ActionMailer::Base
+    include Eventifier::NotificationHelper
+    layout 'email'
+
+    default :from => "\"Funways\" <noreply@funways.me>"
+
+    def notification_email(notification)
+      @notification = notification
+      @notification_url = notification_url(notification.event.eventable)
+      @notification_message = notification_message(notification.event).gsub("class='target'", "style='color: #ff0c50'").html_safe
+
+      mail :to => notification.user.email,
+           :subject => "You have new notifications"
+
+    end
+  end
+end

data/lib/eventifier/version.rb

@@ -0,0 +1,3 @@
+module Eventifier
+  VERSION = "0.0.1"
+end

data/lib/generators/active_record/eventifier_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class EventifierGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+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
+        copy_file "event_tracking.rb", "app/models/event_tracking.rb"
+      end
+
+      def copy_language
+        copy_file "events.en.yaml", "config/locales/events.en.yaml"
+      end
+
+      def generate_migration
+        migration_template "migration.rb", "db/migrate/eventifier_setup.rb"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+class EventTracking
+  include Eventifier::EventTracking
+
+  def initialize
+    # events_for Group do
+    #   track_on [:create, :update, :destroy], :attributes => { :except => %w(updated_at) }
+    #   notify :group => :members, :on => [:create, :update]
+    # end
+  end
+end
+
+EventTracking.new

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

@@ -0,0 +1,13 @@
+en:
+  events:
+    default:
+      create: "{{user.name}} created a <strong>{{object_type}}</strong>"
+      update:
+        single: "{{user.name}} updated a {{object_type}}"
+        multiple: "{{user.name}} made some changes to a {{object_type}}"
+  notifications:
+    default:
+      create: "{{user.name}} created a <strong>{{object_type}}</strong>"
+      update:
+        single: "{{user.name}} updated a {{object_type}}"
+        multiple: "{{user.name}} made some changes to a {{object_type}}"

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

@@ -0,0 +1,30 @@
+class EventifierSetup < ActiveRecord::Migration
+  def change
+    create_table :events do |t|
+      t.integer :user_id
+      t.string  :eventable_type
+      t.integer :eventable_id
+      t.string  :verb
+      t.text    :change_data
+
+      t.timestamps
+    end
+    
+    add_index :events, :user_id
+    add_index :events, [:eventable_id, :eventable_type]
+
+    create_table :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_column :users, :notifications_last_read_at, :datetime
+  end
+
+end

data/spec/event_helper_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Eventifier::EventHelper do
+
+  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
+
+  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
+
+    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
+
+    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"
+    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>"
+      end
+    end
+  end
+end

data/spec/event_observer_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Eventifier::EventObserver do
+
+  describe "#add_notification" do
+    pending
+  end
+
+  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)
+
+      subject.method_from_relation(object, :mouse).should == [5]
+    end
+
+    it "should string the methods when passed a hash" do
+      object = double('object', :cat => (cat = double('cat', :mouse => 5)))
+
+      subject.method_from_relation(object, :cat => :mouse).should == [5]
+    end
+  end
+
+end

data/spec/event_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Eventifier::Event do
+  let(:event) { Eventifier::Event.make! }
+
+  describe "#valid?" do
+    pending
+    #it_requires_a   :user
+    #it_requires_an  :eventable
+    #it_requires_a   :verb
+  end
+
+  describe ".find_all_by_eventable" do
+
+    let!(:eventable) {Post.make!}
+    let(:event) {Eventifier::Event.make! :eventable => eventable}
+
+    it "should find the associated polymorphic eventable object" do
+      lambda do
+        Eventifier::Event.make! :eventable => Post.make!
+        event
+      end.should change(Eventifier::Event, :count).by(2)
+
+      Eventifier::Event.find_all_by_eventable(eventable).length.should == 1
+    end
+  end
+
+end

data/spec/eventifier_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe Eventifier::EventTracking do
+
+  let(:user) { User.make }
+  let(:test_class) { Post }
+  let(:object) { test_class.make }
+  let(:event_tracker) { Object.new.extend(Eventifier::EventTracking) }
+
+  after :all do
+    Post.observers.disable :all
+  end
+
+  describe ".initialize" do
+
+    it "should start" do
+      event_tracker
+    end
+
+  end
+
+  describe ".events_for" do
+
+    it "should create the relation notifications for Users" do
+      event_tracker.events_for test_class,
+                               :track_on => [:create, :update, :destroy],
+                               :attributes => { :except => %w(updated_at) }
+
+      user.should respond_to(:notifications)
+    end
+
+  end
+
+  describe "hash syntax" do
+
+    describe "creating events" do
+
+      let(:subject) do
+        object.save
+      end
+
+      before do
+        object.stub(:user).and_return(user)
+        event_tracker.events_for test_class,
+                                 :track_on => [:create, :update, :destroy],
+                                 :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)
+
+        subject
+      end
+    end
+
+  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
+      let(:subject) do
+        object.save
+      end
+
+      before do
+        object.stub(:user).and_return(user)
+      end
+
+      it "should create an event with the relevant info" do
+        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)}
+        end
+
+        Eventifier::Event.should_receive(:create).with(:user => user, :eventable => object, :verb => :create, :change_data => changes)
+
+        subject
+      end
+
+      it "should hit the track event twice" 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)}
+        end
+      end
+    end
+
+    context "notifying" do
+      before do
+        @event_observer_instance = Eventifier::EventObserver.instance
+      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
+        subscriber = double('user')
+
+        object.stub :category => double('category', :subscribers => [subscriber])
+
+        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
+        end
+
+        object.save
+      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
+        end
+
+        object.save
+      end
+
+    end
+  end
+
+end