public_activity 1.1.0 → 1.4.0

data/lib/public_activity/utility/view_helpers.rb

@@ -3,10 +3,18 @@ module PublicActivity
   # Module extending ActionView::Base and adding `render_activity` helper.
   module ViewHelpers
     # View helper for rendering an activity, calls {PublicActivity::Activity#render} internally.
-    def render_activity activity, options = {}
-      activity.render self, options
+    def render_activity activities, options = {}
+      if activities.is_a? PublicActivity::Activity
+        activities.render self, options
+      elsif activities.respond_to?(:map)
+        # depend on ORMs to fetch as needed
+        # maybe we can support Postgres streaming with this?
+        activities.map {|activity| activity.render self, options.dup }.join.html_safe
+      end
     end
-    # Helper for setting content_for in activity partial, needed to 
+    alias_method :render_activities, :render_activity
+
+    # Helper for setting content_for in activity partial, needed to
     # flush remains in between partial renders.
     def single_content_for(name, content = nil, &block)
       @view_flow.set(name, ActiveSupport::SafeBuffer.new)

data/lib/public_activity/version.rb

@@ -1,4 +1,4 @@
 module PublicActivity
   # A constant with gem's version
-  VERSION = '1.1.0'
+  VERSION = '1.4.0'
 end

data/test/migrations/001_create_activities.rb

@@ -0,0 +1,23 @@
+# Migration responsible for creating a table with activities
+class CreateActivities < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :activities 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.timestamps
+    end
+
+    add_index :activities, [:trackable_id, :trackable_type]
+    add_index :activities, [:owner_id, :owner_type]
+    add_index :activities, [:recipient_id, :recipient_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :activities
+  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_activities.rb

@@ -0,0 +1,7 @@
+class AddNonstandardToActivities < ActiveRecord::Migration
+  def change
+    change_table :activities 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: public_activity_test

data/test/mongoid.yml

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

data/test/test_activist.rb

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

data/test/test_activity.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+describe 'PublicActivity::Activity Rendering' do
+  describe '#text' do
+    subject { PublicActivity::Activity.new(:key => 'activity.test', :parameters => {:one => 1}) }
+
+    specify '#text uses translations' do
+      subject.save
+      I18n.config.backend.store_translations(:en,
+        {:activity => {:test => '%{one} %{two}'}}
+      )
+      subject.text(:two => 2).must_equal('1 2')
+      subject.parameters.must_equal({:one => 1})
+    end
+  end
+
+  describe '#render' do
+    subject do
+      s = PublicActivity::Activity.new(:key => 'activity.test', :parameters => {:one => 1})
+      s.save && s
+    end
+
+    let(:template_output) { "<strong>1, 2</strong>\n<em>activity.test, #{subject.id}</em>\n" }
+    before { @controller.view_paths << File.expand_path('../views', __FILE__) }
+
+    it 'uses view partials when available' do
+      PublicActivity.set_controller(Struct.new(:current_user).new('fake'))
+      subject.render(self, :two => 2)
+      rendered.must_equal template_output + "fake\n"
+    end
+
+    it 'uses requested partial'
+
+    it 'uses view partials without controller' do
+      PublicActivity.set_controller(nil)
+      subject.render(self, :two => 2)
+      rendered.must_equal template_output + "\n"
+    end
+
+    it 'provides local variables' do
+      PublicActivity.set_controller(nil)
+      subject.render(self, locals: {two: 2})
+      rendered.chomp.must_equal "2"
+    end
+
+    it 'uses translations only when requested' do
+      I18n.config.backend.store_translations(:en,
+        {:activity => {:test => '%{one} %{two}'}}
+      )
+      @controller.view_paths.paths.clear
+      subject.render(self, two: 2, display: :i18n)
+      rendered.must_equal '1 2'
+    end
+
+    it "uses specified layout" do
+      PublicActivity.set_controller(nil)
+      subject.render(self, :layout => "activity")
+      rendered.must_include "Here be the layouts"
+
+      subject.render(self, :layout => "layouts/activity")
+      rendered.must_include "Here be the layouts"
+
+      subject.render(self, :layout => :activity)
+      rendered.must_include "Here be the layouts"
+    end
+  end
+end

data/test/test_common.rb

@@ -0,0 +1,168 @@
+require 'test_helper'
+
+describe PublicActivity::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_activity' do
+    subject.save
+    subject.create_activity(:test, params: {author_name: 'Pan'}).parameters[:author_name].must_equal 'Pan'
+    subject.create_activity(:test, parameters: {author_name: 'Pan'}).parameters[:author_name].must_equal 'Pan'
+    subject.create_activity(:test, params: {author_name: nil}).parameters[:author_name].must_be_nil
+    subject.create_activity(:test, parameters: {author_name: nil}).parameters[:author_name].must_be_nil
+  end
+
+  it 'prioritizes owner passed to #create_activity' do
+    subject.save
+    subject.create_activity(:test, owner: @recipient).owner.must_equal @recipient
+    subject.create_activity(:test, owner: nil).owner.must_be_nil
+  end
+
+  it 'prioritizes recipient passed to #create_activity' do
+    subject.save
+    subject.create_activity(:test, recipient: @owner).recipient.must_equal @owner
+    subject.create_activity(:test, recipient: nil).recipient.must_be_nil
+  end
+
+  it 'uses global fields' do
+    subject.save
+    activity = subject.activities.last
+    activity.parameters.must_equal @options[:params]
+    activity.owner.must_equal @owner
+  end
+
+  it 'allows custom fields' do
+    subject.save
+    subject.create_activity :with_custom_fields, nonstandard: "Custom allowed"
+    subject.activities.last.nonstandard.must_equal "Custom allowed"
+  end
+
+  it '#create_activity returns a new activity object' do
+    subject.save
+    subject.create_activity("some.key").wont_be_nil
+  end
+
+  it 'allows passing owner through #create_activity' do
+    article = article().new
+    article.save
+    activity = article.create_activity("some.key", :owner => @owner)
+    activity.owner.must_equal @owner
+  end
+
+  it 'allows resolving custom fields' do
+    subject.name      = "Resolving is great"
+    subject.published = true
+    subject.save
+    subject.create_activity :with_custom_fields, nonstandard: :name
+    subject.activities.last.nonstandard.must_equal "Resolving is great"
+    subject.create_activity :with_custom_fields_2, nonstandard: proc {|_, model| model.published.to_s}
+    subject.activities.last.nonstandard.must_equal "true"
+  end
+
+  it 'inherits instance parameters' do
+    subject.activity :params => {:author_name => "Michael"}
+    subject.save
+    activity = subject.activities.last
+
+    activity.parameters[:author_name].must_equal "Michael"
+  end
+
+  it 'accepts instance recipient' do
+    subject.activity :recipient => @recipient
+    subject.save
+    subject.activities.last.recipient.must_equal @recipient
+  end
+
+  it 'accepts instance owner' do
+    subject.activity :owner => @owner
+    subject.save
+    subject.activities.last.owner.must_equal @owner
+  end
+
+  it 'accepts owner as a symbol' do
+    klass = article(:owner => :user)
+    @article = klass.new(:user => @owner)
+    @article.save
+    activity = @article.activities.last
+
+    activity.owner.must_equal @owner
+  end
+
+  describe '#extract_key' do
+    describe 'for class#activity_key method' do
+      before do
+        @article = article(:owner => :user).new(:user => @owner)
+      end
+
+      it 'assigns key to value of activity_key if set' do
+        def @article.activity_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.activity_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 PublicActivity::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)
+      PublicActivity.set_controller(controller)
+      p = proc {|controller, model|
+        assert_equal :cu, controller.current_user
+        assert_equal 5, model.accessor
+      }
+      PublicActivity.resolve_value(context, p)
+      PublicActivity.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 PublicActivity::StoreController
+  include ActionController::Testing::ClassMethods
+end
+
+describe PublicActivity::StoreController do
+  it 'stores controller' do
+    controller = StoringController.new
+    PublicActivity.set_controller(controller)
+    controller.must_be_same_as PublicActivity.instance_eval { class_variable_get(:@@controllers)[Thread.current.object_id] }
+    controller.must_be_same_as PublicActivity.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_public_activity
+    controller.instance_eval { store_controller_for_public_activity }
+    controller.must_be_same_as PublicActivity.class_eval { class_variable_get(:@@controllers)[Thread.current.object_id] }
+  end
+
+  it 'stores controller in a threadsafe way' do
+    reset_controllers
+    PublicActivity.set_controller(1)
+    PublicActivity.get_controller.must_equal 1
+
+    a = Thread.new {
+      PublicActivity.set_controller(2)
+      PublicActivity.get_controller.must_equal 2
+    }
+
+    PublicActivity.get_controller.must_equal 1
+    # cant really test finalizers though
+  end
+
+  private
+  def reset_controllers
+    PublicActivity.class_eval { class_variable_set(:@@controllers, {}) }
+  end
+end

data/test/test_generators.rb

@@ -0,0 +1,41 @@
+if ENV["PA_ORM"] == "active_record"
+
+  require 'test_helper'
+  require 'rails/generators/test_case'
+  require 'generators/public_activity/activity/activity_generator'
+  require 'generators/public_activity/migration/migration_generator'
+  require 'generators/public_activity/migration_upgrade/migration_upgrade_generator'
+
+  class TestActivityGenerator < Rails::Generators::TestCase
+    tests PublicActivity::Generators::ActivityGenerator
+    destination File.expand_path("../tmp", File.dirname(__FILE__))
+    setup :prepare_destination
+
+    def test_generating_activity_model
+      run_generator
+      assert_file "app/models/activity.rb"
+    end
+  end
+
+  class TestMigrationGenerator < Rails::Generators::TestCase
+    tests PublicActivity::Generators::MigrationGenerator
+    destination File.expand_path("../tmp", File.dirname(__FILE__))
+    setup :prepare_destination
+
+    def test_generating_activity_model
+      run_generator
+      assert_migration "db/migrate/create_activities.rb"
+    end
+  end
+
+  class TestMigrationUpgradeGenerator < Rails::Generators::TestCase
+    tests PublicActivity::Generators::MigrationUpgradeGenerator
+    destination File.expand_path("../tmp", File.dirname(__FILE__))
+    setup :prepare_destination
+
+    def test_generating_activity_model
+      run_generator
+      assert_migration "db/migrate/upgrade_activities.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 'public_activity'
+require 'minitest/autorun'
+require 'minitest/pride' if ENV['WITH_PRIDE'] or ENV['PRIDE']
+
+PublicActivity::Config.orm = (ENV['PA_ORM'] || :active_record)
+
+case PublicActivity::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 PublicActivity::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
+    PublicActivity::Activity.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 PublicActivity::Model
+
+    belongs_to :user
+
+    field :name, type: String
+    field :published, type: Boolean
+  end
+
+  def article(options = {})
+    Article.class_eval do
+      set_public_activity_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 PublicActivity::Model
+
+    belongs_to :user
+
+    key :name, String
+    key :published, Boolean
+  end
+
+  def article(options = {})
+    Article.class_eval do
+      set_public_activity_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)