eventifier 0.0.7 → 0.0.8

data/lib/eventifier/active_record/notification.rb

@@ -1,13 +0,0 @@
-require 'eventifier/notification_mixin'
-
-module Eventifier
-  class Notification < ActiveRecord::Base
-    include Eventifier::NotificationMixin
-
-    default_scope order("notifications.created_at DESC")
-    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)
-  end
-end

data/lib/eventifier/active_record_support.rb

@@ -1,5 +0,0 @@
-require 'eventifier/active_record/event_tracking'
-require 'eventifier/active_record/event'
-require 'eventifier/active_record/notification'
-require 'eventifier/active_record/event_observer'
-require 'eventifier/active_record/ghost'

data/lib/eventifier/event_helper.rb

@@ -1,40 +0,0 @@
-module Eventifier
-  module EventHelper
-    include Eventifier::HelperMethods
-
-    # A helper for outputting an event message.
-    #
-    # Uses I18n messages from config/locales/events.en.yml to generate these messages, or defaults to a standard.
-    #
-    # Example:
-    #
-    # %ul#events
-    #   - post.events.each do |event|
-    #     %li= event_message event
-
-    def event_message event
-      if event.verb.to_sym == :update
-        if event.change_data.keys.count == 1
-          key = "events.#{event.eventable_type.downcase}.#{event.verb}.single"
-        else
-          key = "events.#{event.eventable_type.downcase}.#{event.verb}.multiple"
-        end
-      else
-        key = "events.#{event.eventable_type.downcase}.#{event.verb}"
-      end
-      message = I18n.translate key, :default => :"events.default.#{event.verb}", "user.name" => event.user.name, :"event.type" => event.eventable_type
-
-      replace_vars(message, event).html_safe
-    end
-
-    def self.included(base)
-      base.helper_method :event_message
-    end
-  end
-end
-
-if defined? ActionController::Base
-  ActionController::Base.class_eval do
-    include Eventifier::EventHelper
-  end
-end

data/lib/eventifier/event_mixin.rb

@@ -1,45 +0,0 @@
-require 'active_support/concern'
-
-module Eventifier
-  module EventMixin
-
-    extend ActiveSupport::Concern
-
-    included do
-      belongs_to :user
-      belongs_to :eventable, polymorphic: true
-      has_many :notifications, class_name: 'Eventifier::Notification', dependent: :destroy
-
-      validates :user, presence: true
-      validates :eventable, presence: true
-      validates :verb, presence: true
-    end
-
-    module ClassMethods
-
-      def add_notification(*arg)
-        observer_instances.each { |observer| observer.add_notification(*arg) }
-      end
-
-      def add_url(*arg)
-        observer_instances.each { |observer| observer.add_url(*arg) }
-      end
-
-      def create_event(verb, object, options = { })
-        changed_data = object.changes.stringify_keys
-        changed_data = changed_data.reject { |attribute, value| options[:except].include?(attribute) } if options[:except]
-        changed_data = changed_data.select { |attribute, value| options[:only].include?(attribute) } if options[:only]
-        self.create(
-          :user => object.user,
-          :eventable => object,
-          :verb => verb,
-          :change_data => changed_data.symbolize_keys
-        )
-      end
-
-      def find_all_by_eventable object
-        where :eventable_id => object.id, :eventable_type => object.class.name
-      end
-    end
-  end
-end

data/lib/eventifier/event_observer_mixin.rb

@@ -1,44 +0,0 @@
-require 'active_support/concern'
-
-module Eventifier
-  module EventObserverMixin
-    extend ActiveSupport::Concern
-
-    include do
-      observe Eventifier::Event
-    end
-
-    module InstanceMethods
-      def add_notification klass_name, relation, method
-        observed_classes.each do |observed_class|
-          notification_mappings[klass_name.name]         ||= { }
-          notification_mappings[klass_name.name][method] = relation
-        end
-      end
-
-      def after_create event
-        Rails.logger.info "Firing #{event.eventable_type}##{event.verb} - #{notification_mappings[event.eventable_type][event.verb]}" if notification_mappings.has_key?(event.eventable_type) and notification_mappings[event.eventable_type].has_key?(event.verb) and defined?(Rails)
-
-        method_from_relation(event.eventable, notification_mappings[event.eventable_type][event.verb]).each do |user|
-          next if user == event.user
-          Eventifier::Notification.create event: event, user: user
-        end if notification_mappings.has_key?(event.eventable_type) and notification_mappings[event.eventable_type].has_key?(event.verb)
-      end
-
-      def method_from_relation object, relation
-        if relation.kind_of?(Hash)
-          method_from_relation(proc { |object, method| object.send(method) }.call(object, relation.keys.first), relation.values.first)
-        else
-          send_to = proc { |object, method| object.send(method) }.call(object, relation)
-          send_to = send_to.kind_of?(Array) ? send_to : [send_to]
-        end
-      end
-
-      private
-
-      def notification_mappings
-        @notification_mapppings ||= { }
-      end
-    end
-  end
-end

data/lib/eventifier/ghost_mixin.rb

@@ -1,27 +0,0 @@
-module Eventifier
-  module GhostMixin
-
-    extend ActiveSupport::Concern
-
-    included do
-
-      validates :ghost_class, :presence => true
-      validates :ghost_id,    :presence => true
-      validates :data_hash,   :presence => true
-    end
-
-    module ClassMethods
-      def create_from_object object
-        create :ghost_class => object.class.name, :ghost_id => object.id, :data_hash => object.serializable_hash
-      end
-    end
-
-    def ghost
-      klass = Object.const_get(ghost_class)
-      ghost_object = klass.new data_hash
-      ghost_object.id = ghost_id
-
-      ghost_object
-    end
-  end
-end

data/lib/eventifier/helper_methods.rb

@@ -1,36 +0,0 @@
-module Eventifier
-  module HelperMethods
-    # Used to replace {{variables}} in I18n messages
-
-    def replace_vars message, event
-      event = load_event_for_template event
-      message.scan(/{{[^}]*}}/) do |replaceable|
-        method = "event."+replaceable.to_s.gsub(/[{|}]/, '').to_s
-        replace_text = eval(method) rescue ""
-
-        case replaceable.to_s
-          when "{{object.name}}"
-            replace_text = "<strong class='target'>#{replace_text}</strong>"
-          when "{{object.title}}"
-            replace_text = "<strong class='target'>#{replace_text}</strong>"
-          when "{{user.name}}"
-            replace_text = "<strong class='user'>#{replace_text}</strong>"
-          else
-            replace_text = "<strong>#{replace_text}</strong>"
-        end
-
-        message = message.gsub(replaceable.to_s, replace_text.to_s.gsub("_", " "))
-      end
-      message
-    end
-
-    # Make is so you can include object in the I18n descriptions and it refers to the eventable object the event is referring to.
-
-    def load_event_for_template event
-      def event.object; eventable; end
-      def event.object_type; eventable_type; end
-
-      event
-    end
-  end
-end

data/lib/eventifier/mongoid/event.rb

@@ -1,16 +0,0 @@
-require 'eventifier/event_mixin'
-
-module Eventifier
-  class Event
-    include Mongoid::Document
-    include Mongoid::Timestamps
-    include Eventifier::EventMixin
-
-    field :change_data, :type => Hash
-    field :eventable_type, :type => String
-    field :verb, :type => Symbol
-
-    index({ user_id: 1 })
-    index({ eventable_id: 1, eventable_type: 1 })
-  end
-end

data/lib/eventifier/mongoid/event_observer.rb

@@ -1,7 +0,0 @@
-require 'eventifier/event_observer_mixin'
-
-module Eventifier
-  class EventObserver < Mongoid::Observer
-    include Eventifier::EventObserverMixin
-  end
-end

data/lib/eventifier/mongoid/event_tracking.rb

@@ -1,13 +0,0 @@
-module Eventifier
-  module EventTracking
-    OBSERVER_CLASS = Mongoid::Observer
-
-    def add_notification_association target_klass
-      target_klass.class_eval do
-        define_method :notifications do
-          events.map(&:notifications).flatten.compact
-        end
-      end
-    end
-  end
-end

data/lib/eventifier/mongoid/ghost.rb

@@ -1,15 +0,0 @@
-require 'eventifier/ghost_mixin'
-
-module Eventifier
-  class Ghost
-    include Mongoid::Document
-    include Mongoid::Timestamps
-    include Eventifier::GhostMixin
-
-    field :ghost_id, :type => BSON::ObjectId
-    field :ghost_class, :type => String
-    field :data_hash, :type => Hash
-
-    index({ ghost_class: 1, ghost_id: 1 })
-  end
-end

data/lib/eventifier/mongoid/notification.rb

@@ -1,19 +0,0 @@
-require 'eventifier/notification_mixin'
-
-module Eventifier
-  class Notification
-    include Mongoid::Document
-    include Mongoid::Timestamps
-    include Eventifier::NotificationMixin
-
-    default_scope order_by([:created_at, :desc])
-    scope :for_events,  ->(ids) { where(event_id: ids) }
-    scope :for_user,    ->(user) { where(user_id: user.id) }
-    scope :since,       ->(date) { where(:created_at.gt => date) }
-    scope :latest,      order_by([:created_at, :desc]).limit(5)
-
-    index({ user_id: 1 })
-    index({ event_id: 1 })
-    #index({ parent_id: 1})
-  end
-end

data/lib/eventifier/mongoid/user_patch.rb

@@ -1,3 +0,0 @@
-class User
-  field :notifications_last_read_at, :type => DateTime
-end

data/lib/eventifier/mongoid_support.rb

@@ -1,6 +0,0 @@
-require 'eventifier/mongoid/event_tracking'
-require 'eventifier/mongoid/user_patch'
-require 'eventifier/mongoid/event'
-require 'eventifier/mongoid/notification'
-require 'eventifier/mongoid/event_observer'
-require 'eventifier/mongoid/ghost'

data/lib/eventifier/notification_helper.rb

@@ -1,42 +0,0 @@
-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
-      default = "notifications.default.#{event.verb}".to_sym
-      if event.verb.to_sym == :update
-        if event.change_data.keys.count == 1
-          key = "notifications.#{event.eventable_type.downcase}.#{event.verb}.attributes.#{event.change_data.keys.first}"
-          default = ["notifications.#{event.eventable_type.downcase}.#{event.verb}.single".to_sym, default]
-        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 => default, "user.name" => event.user.name, :"event.type" => event.eventable_type
-
-      replace_vars(message, event).html_safe
-    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

@@ -1,18 +0,0 @@
-require 'eventifier/notification_helper'
-
-module Eventifier
-  class NotificationMailer < ActionMailer::Base
-    include Eventifier::NotificationHelper
-    layout 'email'
-
-    def notification_email(notification)
-      @notification = notification
-      @notification_url = main_app.url_for notification.url
-      @notification_message = notification_message(notification.event)
-
-      mail :to => notification.user.email,
-           :subject => "You have new notifications"
-
-    end
-  end
-end

data/lib/eventifier/notification_mixin.rb

@@ -1,50 +0,0 @@
-require 'active_support/concern'
-
-module Eventifier
-
-  module NotificationMixin
-    extend ActiveSupport::Concern
-
-    included do
-      belongs_to :event, :class_name => 'Eventifier::Event'
-      belongs_to :user
-
-      validates :event, :presence => true
-      validates :user, :presence => true
-      validates :event_id, :uniqueness => { :scope => :user_id }
-
-      after_create :send_email
-    end
-
-    module ClassMethods
-      def expire_for_past_events!(time_limit = 1.day.ago)
-        self.for_events(Event.expired_ids(time_limit)).each &:expire!
-      end
-
-      def unread_for(user)
-        if user.notifications_last_read_at
-          for_user(user).since(user.notifications_last_read_at)
-        else
-          for_user(user)
-        end
-      end
-    end
-
-    def url
-      if Eventifier::EventTracking.url_mappings[event.eventable_type.underscore.to_sym]
-        Eventifier::EventTracking.url_mappings[event.eventable_type.underscore.to_sym].call(event.eventable)
-      else
-        event.eventable
-      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
-      Eventifier::NotificationMailer.notification_email(self).deliver
-    end
-  end
-end

data/lib/eventifier/version.rb

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

data/spec/event_helper_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe Eventifier::EventHelper do
-
-  class TestClass
-    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
-    helper.stub :replace_vars => double("String", :html_safe => true)
-  end
-
-  describe ".event_message" do
-    subject { helper.event_message event }
-
-    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")
-
-        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
-
-    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,20 +0,0 @@
-require 'spec_helper'
-
-describe Eventifier::EventObserver do
-  subject { Eventifier::EventObserver.instance }
-
-  describe "#method_from_relation" do
-    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

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Eventifier::Event do
-  let(:event) { Fabricate(:event) }
-
-  describe "#valid?" do
-    pending
-    #it_requires_a   :user
-    #it_requires_an  :eventable
-    #it_requires_a   :verb
-  end
-
-  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
-
-  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
-        Fabricate(:event, :eventable => Fabricate(:post))
-        event
-      end.should change(Eventifier::Event, :count).by(2)
-
-      Eventifier::Event.find_all_by_eventable(eventable).length.should == 1
-    end
-  end
-
-end

data/spec/helper_methods_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Eventifier::EventHelper do
-
-  class TestClass
-    def self.helper_method(*args); end
-    include Eventifier::HelperMethods
-  end
-
-  let!(:helper) { TestClass.new }
-
-  describe ".replace_vars" do
-    let(:event) { Fabricate.build(:event)}
-
-    it "should replace {{stuff}} with awesome" do
-      message = "I'm really loving {{eventable.title}}"
-      helper.replace_vars(message, event).should == "I'm really loving <strong>#{event.eventable.title}</strong>"
-    end
-
-    it "should replace multiple {{stuff}} with multiple awesome" do
-      message = "I'm really loving {{eventable.title}} and all {{eventable.class.name}}s"
-      helper.replace_vars(message, event).should == "I'm really loving <strong>#{event.eventable.title}</strong> and all <strong>Post</strong>s"
-    end
-  end
-
-  describe ".load_event_for_template" do
-
-    it "should add some handy methods to an event instance" do
-      event = Fabricate(:event)
-      event = helper.load_event_for_template event
-      event.object.should == event.eventable
-      event.object_type.should == event.eventable_type
-    end
-
-  end
-end

data/spec/notification_helper_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe Eventifier::NotificationHelper do
-
-  class TestClass
-    def self.helper_method(*args); end
-    include Eventifier::NotificationHelper
-  end
-
-  let!(:helper) {TestClass.new}
-
-  before do
-    @notification_strings = {
-      :post => {
-        :create => "{{user.name}} just created an Post - you should check it out",
-        :destroy => "{{user.name}} just deleted an Post",
-        :update => {
-          :single => "{{user.name}} made a change to their Post",
-          :multiple => "{{user.name}} made some changes to their Post",
-          :attributes => {
-            :deleted_at => "{{user.name}} deleted their Post"
-          }
-        }
-      }
-    }
-    I18n.backend.store_translations :en, :notifications => @notification_strings
-  end
-
-  describe "#notification_message" do
-    it "should return the I18n message for that event" do
-
-      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
-      helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> just created an 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 = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"] })
-      helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> made a change to their Post"
-    end
-    it "should return a message specific to a particular field change if configuration is present" do
-      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :deleted_at => [nil, Time.now] })
-      helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> deleted 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.notification_message(event).should == "<strong class='user'>#{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!
-      @notification_strings = {
-        :default => {
-          :create => "{{user.name}} created a {{eventable_type}}",
-          :update => "{{user.name}} updated a {{eventable_type}}"
-        }
-      }
-      I18n.backend.store_translations :test, :notifications => @notification_strings
-      I18n.with_locale("test") do
-        event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
-        helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> created a <strong>Post</strong>"
-      end
-    end
-  end
-end

data/spec/support/action_mailer.rb

@@ -1,3 +0,0 @@
-require 'action_mailer'
-
-ActionMailer::Base.delivery_method = :test

data/spec/support/database_cleaner.rb

@@ -1,3 +0,0 @@
-require 'database_cleaner'
-DatabaseCleaner.strategy = :truncation
-DatabaseCleaner.clean