eventifier 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in eventifier.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,83 @@
+PATH
+  remote: .
+  specs:
+    eventifier (0.0.1)
+      actionmailer
+      actionmailer
+      activerecord
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.5)
+      actionpack (= 3.2.5)
+      mail (~> 2.4.4)
+    actionpack (3.2.5)
+      activemodel (= 3.2.5)
+      activesupport (= 3.2.5)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.5)
+      activesupport (= 3.2.5)
+      builder (~> 3.0.0)
+    activerecord (3.2.5)
+      activemodel (= 3.2.5)
+      activesupport (= 3.2.5)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.5)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    journey (1.0.3)
+    machinist (2.0)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.18)
+    multi_json (1.3.6)
+    pg (0.13.2)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  eventifier!
+  machinist
+  pg
+  rspec

data/README.textile

@@ -0,0 +1,43 @@
+h1. Eventifier
+
+Event tracking and notifying for active record models
+
+h2. Features
+
+Tracks and logs events on active record objects
+Send notifications of events
+
+h2. Example
+
+class EventTracking
+  include Eventifier::EventTracking
+
+  def initialize
+    events_for Post do
+      track_on [:create, :update, :destroy], :attributes => { :except => %w(updated_at) }
+      notify :group => :members, :on => [:create, :update]
+    end
+
+    events_for Announcement do
+      track_on :create, :attributes => { :except => %w(updated_at) }
+      notify :group => :members, :on => :create
+    end
+  end
+end
+
+That's it!
+
+h2. Requirements
+
+* ActiveRecord
+
+
+h2. Testing
+
+Creating the database:
+* createdb eventifier
+
+Spec
+``
+  rspec spec
+``

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require 'rake'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+
+
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.rcov = true
+  spec.rcov_opts = ['--exclude', 'spec', '--exclude', '.rvm']
+end

data/eventifier.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "eventifier/version"
+
+Gem::Specification.new do |s|
+  s.name        = "eventifier"
+  s.version     = Eventifier::VERSION
+  s.authors     = ["Nathan Sampimon"]
+  s.email       = ["nathan@inspire9.com"]
+  s.homepage    = "http://github.com/inspire9/eventifier"
+  s.summary     = "Event tracking and notifying for active record models"
+  s.description = "Tracks and logs events and sends notifications of events on Active Record models."
+
+  s.rubyforge_project = "eventifier"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency  "activerecord"
+  s.add_runtime_dependency      "actionmailer"
+  s.add_development_dependency  "machinist"
+  s.add_development_dependency  "pg"
+  s.add_development_dependency  "rspec"
+
+  s.add_runtime_dependency "activerecord"
+  s.add_runtime_dependency "actionmailer"
+end

data/lib/eventifier.rb

@@ -0,0 +1,42 @@
+# Step 1. Use rails hooks for create and update and destroy
+# Step 2. Use modules to overwrite methods, and be rails independent
+# Consider implementing with http://stackoverflow.com/questions/3689736/rails-3-alias-method-chain-still-used
+# Consider implementing with http://www.ruby-doc.org/stdlib-1.9.3/libdoc/observer/rdoc/Observable.html
+
+
+
+# init.rb
+# require 'eventifer'
+
+
+
+
+
+# Todo
+# - Notifications
+
+# Ideas for implementation:
+
+
+# class EventTracking
+#   include Eventable::EventTracking
+# 
+#   def initialize
+#     events_for Activity,
+#                :on => [:create, :update, :destroy],
+#                :attributes => { :except => %w(updated_at) }
+#   end
+# 
+# end
+
+require 'active_record'
+require 'action_mailer'
+
+require 'eventifier/event'
+require 'eventifier/helper_methods'
+require 'eventifier/notification'
+require 'eventifier/notification_mailer'
+require 'eventifier/notification_helper'
+require 'eventifier/event_helper'
+require 'eventifier/event_observer'
+require 'eventifier/event_tracking'

data/lib/eventifier/event.rb

@@ -0,0 +1,35 @@
+module Eventifier
+  class Event < ::ActiveRecord::Base
+
+    belongs_to :user
+    belongs_to :eventable, :polymorphic => true
+    has_many :notifications
+
+    serialize :change_data
+
+    validates :user, :presence => true
+    validates :eventable, :presence => true
+    validates :verb, :presence => true
+
+    def self.add_notification(*arg)
+      observer_instances.each { |observer| observer.add_notification(*arg) }
+    end
+
+
+    def self.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 self.find_all_by_eventable object
+      where :eventable_id => object.id, :eventable_type => object.class.name
+    end
+  end
+end

data/lib/eventifier/event_helper.rb

@@ -0,0 +1,40 @@
+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_observer.rb

@@ -0,0 +1,35 @@
+module Eventifier
+  class EventObserver < ActiveRecord::Observer
+    observe Eventifier::Event
+
+    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

data/lib/eventifier/event_tracking.rb

@@ -0,0 +1,81 @@
+module Eventifier
+  module EventTracking
+    def events_for(klass, *args, &block)
+        @klasses = klass.kind_of?(Array) ? klass : [klass]
+
+        options = args[0] || {}
+
+        methods     = options.delete(:track_on)
+        attributes  = options.delete(:attributes)
+
+        create_observers
+
+        if block.nil?
+          track_on methods, :attributes => attributes
+        else
+          instance_eval(&block)
+        end
+    end
+
+    def create_observers
+      # Create all the observer classes
+      @klasses.each do |target_klass|
+
+        # If the observer doesn't exist, create the class
+        unless self.class.const_defined?("#{target_klass}Observer")
+          constant_name = "#{target_klass}Observer"
+          klass = Class.new(ActiveRecord::Observer)
+          self.class.qualified_const_set(constant_name, klass)
+        end
+      end
+    end
+
+    def track_on methods, options = {}
+      methods = methods.kind_of?(Array) ? methods : [methods]
+      attributes = options.delete(:attributes)
+      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)
+      Eventifier::EventObserver.instance
+
+      # set up each class with an observer and relationships
+      @klasses.each do |target_klass|
+        # Add relations to class
+        target_klass.class_eval { has_many :events, :as => :eventable, :class_name => Eventifier::Event, :dependent => :destroy }
+        target_klass.class_eval { has_many :notifications, :through => :events, :class_name => Eventifier::Notification, :dependent => :destroy }
+
+        # create an observer and have it observe the class
+        klass = self.class.const_get("#{target_klass}Observer")
+        klass.observe target_klass
+
+        # create a callback for the methods we want to track
+        klass.class_eval do
+          methods.each do |event|
+            define_method "after_#{event}" do |object|
+              # create an event when the callback is fired
+              Eventifier::Event.create_event(event.to_sym, object, attributes) if object.changed?
+            end
+          end
+        end
+        # instantiate the observer
+        klass.instance
+      end
+    end
+
+    def notify *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
+      relation = args.delete_at(0) if args.length == 2
+      args = args.first
+
+      methods = args.delete(:on)
+      methods = methods.kind_of?(Array) ? methods : [methods]
+      relation ||= args
+
+      @klasses.each do |target_klass|
+        methods.each do |method|
+          Eventifier::Event.add_notification target_klass, relation, method
+        end
+      end
+    end
+  end
+end

data/lib/eventifier/helper_methods.rb

@@ -0,0 +1,34 @@
+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>"
+          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