user_notification 0.0.1

data/lib/user_notification/utility/store_controller.rb

@@ -0,0 +1,37 @@
+module UserNotification
+  # @private
+  @@controllers = Hash.new
+  # Lambda called after the thread is destroyed.
+  Finalizer = lambda { |id|
+    @@controllers.delete id
+  }
+
+  class << self
+    # Setter for remembering controller instance
+    def set_controller(controller)
+      unless @@controllers.has_key?(Thread.current.object_id)
+        ObjectSpace.define_finalizer Thread.current, Finalizer
+      end if RUBY_VERSION != "1.9.3"
+      @@controllers[Thread.current.object_id] = controller
+    end
+
+    # Getter for accessing the controller instance
+    def get_controller
+      @@controllers[Thread.current.object_id]
+    end
+  end
+
+  # Module included in controllers to allow p_a access to controller instance
+  module StoreController
+    extend ActiveSupport::Concern
+
+    included do
+      before_filter :store_controller_for_user_notification
+    end
+
+    # Before filter executed to remember current controller
+    def store_controller_for_user_notification
+      UserNotification.set_controller(self)
+    end
+  end
+end

data/lib/user_notification/utility/view_helpers.rb

@@ -0,0 +1,26 @@
+# Provides a shortcut from views to the rendering method.
+module UserNotification
+  # Module extending ActionView::Base and adding `render_notification` helper.
+  module ViewHelpers
+    # View helper for rendering an notification, calls {UserNotification::Notification#render} internally.
+    def render_notification notifications, options = {}
+      if notifications.is_a? UserNotification::Notification
+        notifications.render self, options
+      elsif notifications.respond_to?(:map)
+        # depend on ORMs to fetch as needed
+        # maybe we can support Postgres streaming with this?
+        notifications.map {|notification| notification.render self, options.dup }.join.html_safe
+      end
+    end
+    alias_method :render_notifications, :render_notification
+
+    # Helper for setting content_for in notification partial, needed to
+    # flush remains in between partial renders.
+    def single_content_for(name, content = nil, &block)
+      @view_flow.set(name, ActiveSupport::SafeBuffer.new)
+      content_for(name, content, &block)
+    end
+  end
+
+  ActionView::Base.class_eval { include ViewHelpers }
+end

data/lib/user_notification/version.rb

@@ -0,0 +1,4 @@
+module UserNotification
+  # A constant with gem's version
+  VERSION = '0.0.1'
+end

data/lib/user_notification.rb

@@ -0,0 +1,68 @@
+require 'active_support'
+require 'action_view'
+# +user_notification+ keeps track of changes made to models
+# and allows you to display them to the users.
+#
+# Check {UserNotification::Tracked::ClassMethods#tracked} for more details about customizing and specifying
+# ownership to users.
+module UserNotification
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+
+  autoload :Notification,     'user_notification/models/notification'
+  autoload :Activist,     'user_notification/models/activist'
+  autoload :Adapter,      'user_notification/models/adapter'
+  autoload :Trackable,    'user_notification/models/trackable'
+  autoload :Common
+  autoload :Config
+  autoload :Creation,     'user_notification/actions/creation.rb'
+  autoload :Deactivatable,'user_notification/roles/deactivatable.rb'
+  autoload :Destruction,  'user_notification/actions/destruction.rb'
+  autoload :Renderable
+  autoload :Tracked,      'user_notification/roles/tracked.rb'
+  autoload :Update,       'user_notification/actions/update.rb'
+  autoload :VERSION
+
+  # Switches UserNotification on or off.
+  # @param value [Boolean]
+  # @since 0.5.0
+  def self.enabled=(value)
+    UserNotification.config.enabled = value
+  end
+
+  # Returns `true` if UserNotification is on, `false` otherwise.
+  # Enabled by default.
+  # @return [Boolean]
+  # @since 0.5.0
+  def self.enabled?
+    !!UserNotification.config.enabled
+  end
+
+  # Returns UserNotification's configuration object.
+  # @since 0.5.0
+  def self.config
+    @@config ||= UserNotification::Config.instance
+  end
+
+  # Method used to choose which ORM to load
+  # when UserNotification::Notification class is being autoloaded
+  def self.inherit_orm(model="Notification")
+    orm = UserNotification.config.orm
+    require "user_notification/orm/#{orm.to_s}"
+    "UserNotification::ORM::#{orm.to_s.classify}::#{model}".constantize
+  end
+
+  # Module to be included in ActiveRecord models. Adds required functionality.
+  module Model
+    extend ActiveSupport::Concern
+    included do
+      include Common
+      include Deactivatable
+      include Tracked
+      include Activist  # optional associations by recipient|owner
+    end
+  end
+end
+
+require 'user_notification/utility/store_controller'
+require 'user_notification/utility/view_helpers'

data/test/migrations/001_create_notifications.rb

@@ -0,0 +1,24 @@
+# Migration responsible for creating a table with notifications
+class CreateNotifications < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :notifications do |t|
+      t.belongs_to :trackable, :polymorphic => true
+      t.belongs_to :owner, :polymorphic => true
+      t.string  :key
+      t.text    :parameters
+      t.belongs_to :recipient, :polymorphic => true
+      t.boolwan :read, default: false
+
+      t.timestamps
+    end
+
+    add_index :notifications, [:trackable_id, :trackable_type]
+    add_index :notifications, [:owner_id, :owner_type]
+    add_index :notifications, [:recipient_id, :recipient_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :notifications
+  end
+end

data/test/migrations/002_create_articles.rb

@@ -0,0 +1,11 @@
+class CreateArticles < ActiveRecord::Migration
+  def self.up
+    puts "creating"
+    create_table :articles do |t|
+      t.string :name
+      t.boolean :published
+      t.belongs_to :user
+      t.timestamps
+    end
+  end
+end

data/test/migrations/003_create_users.rb

@@ -0,0 +1,8 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end

data/test/migrations/004_add_nonstandard_to_notifications.rb

@@ -0,0 +1,7 @@
+class AddNonstandardToNotifications < ActiveRecord::Migration
+  def change
+    change_table :notifications do |t|
+      t.string :nonstandard
+    end
+  end
+end

data/test/mongo_mapper.yml

@@ -0,0 +1,4 @@
+test:
+  host: 127.0.0.1
+  port: 27017
+  database: user_notification_test

data/test/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      hosts:
+        - 127.0.0.1:27017
+      database: user_notification_test

data/test/test_activist.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+describe UserNotification::Activist do
+  it 'adds owner association' do
+    klass = article
+    klass.must_respond_to :activist
+    klass.activist
+    klass.new.must_respond_to :notifications
+    case ENV["PA_ORM"]
+      when "active_record"
+        klass.reflect_on_association(:notifications_as_owner).options[:as].must_equal :owner
+      when "mongoid"
+        klass.reflect_on_association(:notifications_as_owner).options[:inverse_of].must_equal :owner
+      when "mongo_mapper"
+        klass.associations[:notifications_as_owner].options[:as].must_equal :owner
+    end
+
+    if ENV["PA_ORM"] == "mongo_mapper"
+      klass.associations[:notifications_as_owner].options[:class_name].must_equal "::UserNotification::Notification"
+    else
+      klass.reflect_on_association(:notifications_as_owner).options[:class_name].must_equal "::UserNotification::Notification"
+    end
+  end
+
+  it 'returns notifications from association' do
+    case UserNotification::Config.orm
+      when :active_record
+        class ActivistUser < ActiveRecord::Base
+          include UserNotification::Model
+          self.table_name = 'users'
+          activist
+        end
+      when :mongoid
+        class ActivistUser
+          include Mongoid::Document
+          include UserNotification::Model
+          activist
+
+          field :name, type: String
+        end
+      when :mongo_mapper
+        class ActivistUser
+          include MongoMapper::Document
+          include UserNotification::Model
+          activist
+
+          key :name, String
+        end
+    end
+    owner = ActivistUser.create(:name => "Peter Pan")
+    a = article(owner: owner).new
+    a.save
+
+    owner.notifications_as_owner.length.must_equal 1
+  end
+end

data/test/test_common.rb

@@ -0,0 +1,168 @@
+require 'test_helper'
+
+describe UserNotification::Common do
+  before do
+    @owner     = User.create(:name => "Peter Pan")
+    @recipient = User.create(:name => "Bruce Wayne")
+    @options   = {:params => {:author_name => "Peter",
+                  :summary => "Default summary goes here..."},
+                  :owner => @owner, :recipient => @recipient}
+  end
+  subject { article(@options).new }
+
+  it 'prioritizes parameters passed to #create_notification' do
+    subject.save
+    subject.create_notification(:test, params: {author_name: 'Pan'}).parameters[:author_name].must_equal 'Pan'
+    subject.create_notification(:test, parameters: {author_name: 'Pan'}).parameters[:author_name].must_equal 'Pan'
+    subject.create_notification(:test, params: {author_name: nil}).parameters[:author_name].must_be_nil
+    subject.create_notification(:test, parameters: {author_name: nil}).parameters[:author_name].must_be_nil
+  end
+
+  it 'prioritizes owner passed to #create_notification' do
+    subject.save
+    subject.create_notification(:test, owner: @recipient).owner.must_equal @recipient
+    subject.create_notification(:test, owner: nil).owner.must_be_nil
+  end
+
+  it 'prioritizes recipient passed to #create_notification' do
+    subject.save
+    subject.create_notification(:test, recipient: @owner).recipient.must_equal @owner
+    subject.create_notification(:test, recipient: nil).recipient.must_be_nil
+  end
+
+  it 'uses global fields' do
+    subject.save
+    notification = subject.notifications.last
+    notification.parameters.must_equal @options[:params]
+    notification.owner.must_equal @owner
+  end
+
+  it 'allows custom fields' do
+    subject.save
+    subject.create_notification :with_custom_fields, nonstandard: "Custom allowed"
+    subject.notifications.last.nonstandard.must_equal "Custom allowed"
+  end
+
+  it '#create_notification returns a new notification object' do
+    subject.save
+    subject.create_notification("some.key").wont_be_nil
+  end
+
+  it 'allows passing owner through #create_notification' do
+    article = article().new
+    article.save
+    notification = article.create_notification("some.key", :owner => @owner)
+    notification.owner.must_equal @owner
+  end
+
+  it 'allows resolving custom fields' do
+    subject.name      = "Resolving is great"
+    subject.published = true
+    subject.save
+    subject.create_notification :with_custom_fields, nonstandard: :name
+    subject.notifications.last.nonstandard.must_equal "Resolving is great"
+    subject.create_notification :with_custom_fields_2, nonstandard: proc {|_, model| model.published.to_s}
+    subject.notifications.last.nonstandard.must_equal "true"
+  end
+
+  it 'inherits instance parameters' do
+    subject.notification :params => {:author_name => "Michael"}
+    subject.save
+    notification = subject.notifications.last
+
+    notification.parameters[:author_name].must_equal "Michael"
+  end
+
+  it 'accepts instance recipient' do
+    subject.notification :recipient => @recipient
+    subject.save
+    subject.notifications.last.recipient.must_equal @recipient
+  end
+
+  it 'accepts instance owner' do
+    subject.notification :owner => @owner
+    subject.save
+    subject.notifications.last.owner.must_equal @owner
+  end
+
+  it 'accepts owner as a symbol' do
+    klass = article(:owner => :user)
+    @article = klass.new(:user => @owner)
+    @article.save
+    notification = @article.notifications.last
+
+    notification.owner.must_equal @owner
+  end
+
+  describe '#extract_key' do
+    describe 'for class#notification_key method' do
+      before do
+        @article = article(:owner => :user).new(:user => @owner)
+      end
+
+      it 'assigns key to value of notification_key if set' do
+        def @article.notification_key; "my_custom_key" end
+
+        @article.extract_key(:create, {}).must_equal "my_custom_key"
+      end
+
+      it 'assigns key based on class name as fallback' do
+        def @article.notification_key; nil end
+
+        @article.extract_key(:create).must_equal "article.create"
+      end
+
+      it 'assigns key value from options hash' do
+        @article.extract_key(:create, :key => :my_custom_key).must_equal "my_custom_key"
+      end
+    end
+
+    describe 'for camel cased classes' do
+      before do
+        class CamelCase < article(:owner => :user)
+          def self.name; 'CamelCase' end
+        end
+        @camel_case = CamelCase.new
+      end
+
+      it 'assigns generates key from class name' do
+        @camel_case.extract_key(:create, {}).must_equal "camel_case.create"
+      end
+    end
+
+    describe 'for namespaced classes' do
+      before do
+        module ::MyNamespace;
+          class CamelCase < article(:owner => :user)
+            def self.name; 'MyNamespace::CamelCase' end
+          end
+        end
+        @namespaced_camel_case = MyNamespace::CamelCase.new
+      end
+
+      it 'assigns key value from options hash' do
+        @namespaced_camel_case.extract_key(:create, {}).must_equal "my_namespace_camel_case.create"
+      end
+    end
+  end
+
+  # no key implicated or given
+  specify { ->{subject.prepare_settings}.must_raise UserNotification::NoKeyProvided }
+
+  describe 'resolving values' do
+    it 'allows procs with models and controllers' do
+      context = mock('context')
+      context.expects(:accessor).times(2).returns(5)
+      controller = mock('controller')
+      controller.expects(:current_user).returns(:cu)
+      UserNotification.set_controller(controller)
+      p = proc {|controller, model|
+        assert_equal :cu, controller.current_user
+        assert_equal 5, model.accessor
+      }
+      UserNotification.resolve_value(context, p)
+      UserNotification.resolve_value(context, :accessor)
+    end
+  end
+
+end

data/test/test_controller_integration.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class StoringController < ActionView::TestCase::TestController
+  include UserNotification::StoreController
+  include ActionController::Testing::ClassMethods
+end
+
+describe UserNotification::StoreController do
+  it 'stores controller' do
+    controller = StoringController.new
+    UserNotification.set_controller(controller)
+    controller.must_be_same_as UserNotification.instance_eval { class_variable_get(:@@controllers)[Thread.current.object_id] }
+    controller.must_be_same_as UserNotification.get_controller
+  end
+
+  it 'stores controller with a filter in controller' do
+    controller = StoringController.new
+    controller._process_action_callbacks.select {|c| c.kind == :before}.map(&:filter).must_include :store_controller_for_user_notification
+    controller.instance_eval { store_controller_for_user_notification }
+    controller.must_be_same_as UserNotification.class_eval { class_variable_get(:@@controllers)[Thread.current.object_id] }
+  end
+
+  it 'stores controller in a threadsafe way' do
+    reset_controllers
+    UserNotification.set_controller(1)
+    UserNotification.get_controller.must_equal 1
+
+    a = Thread.new {
+      UserNotification.set_controller(2)
+      UserNotification.get_controller.must_equal 2
+    }
+
+    UserNotification.get_controller.must_equal 1
+    # cant really test finalizers though
+  end
+
+  private
+  def reset_controllers
+    UserNotification.class_eval { class_variable_set(:@@controllers, {}) }
+  end
+end

data/test/test_generators.rb

@@ -0,0 +1,30 @@
+if ENV["PA_ORM"] == "active_record"
+
+  require 'test_helper'
+  require 'rails/generators/test_case'
+  require 'generators/user_notification/notification/notification_generator'
+  require 'generators/user_notification/migration/migration_generator'
+
+  class TestNotificationGenerator < Rails::Generators::TestCase
+    tests UserNotification::Generators::NotificationGenerator
+    destination File.expand_path("../tmp", File.dirname(__FILE__))
+    setup :prepare_destination
+
+    def test_generating_notification_model
+      run_generator
+      assert_file "app/models/notification.rb"
+    end
+  end
+
+  class TestMigrationGenerator < Rails::Generators::TestCase
+    tests UserNotification::Generators::MigrationGenerator
+    destination File.expand_path("../tmp", File.dirname(__FILE__))
+    setup :prepare_destination
+
+    def test_generating_notification_model
+      run_generator
+      assert_migration "db/migrate/create_notifications.rb"
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,124 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+unless ENV['NOCOV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/test/"
+  end
+end
+$:.unshift File.expand_path('../../lib/', __FILE__)
+require 'active_support/testing/setup_and_teardown'
+require 'user_notification'
+require 'minitest/autorun'
+require 'minitest/pride' if ENV['WITH_PRIDE'] or ENV['PRIDE']
+
+UserNotification::Config.orm = (ENV['PA_ORM'] || :active_record)
+
+case UserNotification::Config.orm
+when :active_record
+  require 'active_record'
+  require 'active_record/connection_adapters/sqlite3_adapter'
+  require 'stringio'        # silence the output
+  $stdout = StringIO.new    # from migrator
+  ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+  ActiveRecord::Migrator.migrate(File.expand_path('../migrations', __FILE__))
+  $stdout = STDOUT
+
+  def article(options = {})
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'articles'
+      include UserNotification::Model
+      tracked options
+      belongs_to :user
+
+      def self.name
+        "Article"
+      end
+
+      if ::ActiveRecord::VERSION::MAJOR < 4
+        attr_accessible :name, :published, :user
+      end
+    end
+    klass
+  end
+  class User < ActiveRecord::Base; end
+
+  if ::ActiveRecord::VERSION::MAJOR < 4
+    UserNotification::Notification.class_eval do
+      attr_accessible :nonstandard
+    end
+  end
+when :mongoid
+  require 'mongoid'
+
+  Mongoid.load!(File.expand_path("test/mongoid.yml"), :test)
+
+  class User
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    has_many :articles
+
+    field :name, type: String
+  end
+
+  class Article
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include UserNotification::Model
+
+    belongs_to :user
+
+    field :name, type: String
+    field :published, type: Boolean
+  end
+
+  def article(options = {})
+    Article.class_eval do
+      set_user_notification_class_defaults
+      tracked options
+    end
+    Article
+  end
+
+when :mongo_mapper
+  require 'mongo_mapper'
+
+  config = YAML.load(File.read("test/mongo_mapper.yml"))
+  MongoMapper.setup(config, :test)
+
+  class User
+    include MongoMapper::Document
+
+    has_many :articles
+
+    key :name, String
+    timestamps!
+  end
+
+  class Article
+    include MongoMapper::Document
+    include UserNotification::Model
+
+    belongs_to :user
+
+    key :name, String
+    key :published, Boolean
+  end
+
+  def article(options = {})
+    Article.class_eval do
+      set_user_notification_class_defaults
+      tracked options
+    end
+    Article
+  end
+end
+
+class ViewSpec < MiniTest::Spec
+  include ActiveSupport::Testing::SetupAndTeardown
+  include ActionView::TestCase::Behavior
+end
+MiniTest::Spec.register_spec_type(/Rendering$/, ViewSpec)