public_activity 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83290b8f83bb4db6127ed0b907380946d30a3d8a91b2ea3d1a835d7dfb36327d
-  data.tar.gz: 2a7e5abad8fae61ff03440747938653eb1624e14f62279fddb28b2d10362b75e
+  metadata.gz: f12beefe37e1f8d3c8fbaada9d0318de0838dd8514c1b32c93d47b97d7af6d57
+  data.tar.gz: bf5e00de61c14049488a4fe549a9bc198367eca931e9d73c0d47dd0ba9c173f3
 SHA512:
-  metadata.gz: 502c70c85f62ec2838d592a2eaed2de714e97bbc27dcf0e7677dc27ac21e76e2fa1960c7c8d9fae218ff77ac1b103d0b7228ab4ed9afe2b50e7eb09bd2f6b7fe
-  data.tar.gz: ef18dda98ec4e763311971ec8a3a9382b4ba05a5b00a76c7ee6e3a58a9d4ec80f1c9a11487d9bb2e30c5ca9f0a336136033e2811f9ac52974a9cb8f9c95efa39
+  metadata.gz: a95d53aac261777b5b52a1a35add35acc0d93d742d4cbb3d2f4deea08ec552ade88b61cbd4447146172953b4ecda464b3ea2539ecb82d58d26c7756cdc5c52b7
+  data.tar.gz: 7dc0ddb8a3622c52b856f1b5a1f45124d300892559800cd62b06115bc14854d0ff84bf33b5a88a50f9f6ae7c060f298f171cb7d082f9bae3aa9696dfdcb36d5a

data/Rakefile

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rake'
 require 'yard'
 require 'yard/rake/yardoc_task'
 require 'rake/testtask'
 
-task :default => :test
+task default: :test
 
 desc 'Generate documentation for the public_activity plugin.'
 YARD::Rake::YardocTask.new do |doc|
@@ -14,7 +14,6 @@ YARD::Rake::YardocTask.new do |doc|
 end
 
 Rake::TestTask.new do |t|
-	t.libs << "test"
-	t.test_files = FileList['test/test*.rb']
+  t.libs << 'test'
+  t.test_files = FileList['test/test*.rb']
 end
-

data/lib/generators/public_activity/migration/migration_generator.rb

@@ -9,7 +9,7 @@ module PublicActivity
     class MigrationGenerator < ActiveRecord::Generators::Base
       extend Base
 
-      argument :name, :type => :string, :default => 'create_activities'
+      argument :name, type: :string, default: 'create_activities'
       # Create migration in project's folder
       def generate_files
         migration_template 'migration.rb', "db/migrate/#{name}.rb"

data/lib/generators/public_activity/migration/templates/migration.rb

@@ -1,24 +1,23 @@
 # frozen_string_literal: true
 
-require 'migrations_base'
-
 # Migration responsible for creating a table with activities
-class CreateActivities < MigrationsBase
+class CreateActivities < ActiveRecord::Migration[5.0]
   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.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]
+    add_index :activities, %i[trackable_id trackable_type]
+    add_index :activities, %i[owner_id owner_type]
+    add_index :activities, %i[recipient_id recipient_type]
   end
+
   # Drop table
   def self.down
     drop_table :activities

data/lib/generators/public_activity/migration_upgrade/migration_upgrade_generator.rb

@@ -9,7 +9,8 @@ module PublicActivity
     class MigrationUpgradeGenerator < ActiveRecord::Generators::Base
       extend Base
 
-      argument :name, :type => :string, :default => 'upgrade_activities'
+      argument :name, type: :string, default: 'upgrade_activities'
+
       # Create migration in project's folder
       def generate_files
         migration_template 'upgrade.rb', "db/migrate/#{name}.rb"

data/lib/generators/public_activity/migration_upgrade/templates/upgrade.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 # Migration responsible for creating a table with activities
-class UpgradeActivities < ActiveRecord::Migration
+class UpgradeActivities < ActiveRecord::Migration[5.0]
   # Create table
   def self.change
     change_table :activities do |t|
-      t.belongs_to :recipient, :polymorphic => true
+      t.belongs_to :recipient, polymorphic: true
     end
   end
 end

data/lib/public_activity/orm/active_record/activity.rb

@@ -25,20 +25,22 @@ module PublicActivity
         self.abstract_class = true
 
         # Define polymorphic association to the parent
-        belongs_to :trackable, :polymorphic => true
+        belongs_to :trackable, polymorphic: true
 
         case ::ActiveRecord::VERSION::MAJOR
-        when 3..4
-          # Define ownership to a resource responsible for this activity
-          belongs_to :owner, :polymorphic => true
-          # Define ownership to a resource targeted by this activity
-          belongs_to :recipient, :polymorphic => true
-        when 5..7
-          with_options(:required => false) do
+        when 5
+          with_options(required: false) do
             # Define ownership to a resource responsible for this activity
-            belongs_to :owner, :polymorphic => true
+            belongs_to :owner, polymorphic: true
             # Define ownership to a resource targeted by this activity
-            belongs_to :recipient, :polymorphic => true
+            belongs_to :recipient, polymorphic: true
+          end
+        when 6..7
+          with_options(optional: true) do
+            # Define ownership to a resource responsible for this activity
+            belongs_to :owner, polymorphic: true
+            # Define ownership to a resource targeted by this activity
+            belongs_to :recipient, polymorphic: true
           end
         end
 

data/lib/public_activity/version.rb

@@ -2,5 +2,5 @@
 
 module PublicActivity
   # A constant with gem's version
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

data/test/migrations/002_create_articles.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require 'migrations_base'
-
-class CreateArticles < MigrationsBase
+class CreateArticles < ActiveRecord::Migration[5.0]
   def self.up
-    puts "creating"
     create_table :articles do |t|
       t.string :name
       t.boolean :published

data/test/migrations/003_create_users.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'migrations_base'
-
-class CreateUsers < MigrationsBase
+class CreateUsers < ActiveRecord::Migration[5.0]
   def self.up
     create_table :users do |t|
       t.string :name

data/test/migrations/004_add_nonstandard_to_activities.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'migrations_base.rb'
-
-class AddNonstandardToActivities < MigrationsBase
+class AddNonstandardToActivities < ActiveRecord::Migration[5.0]
   def change
     change_table :activities do |t|
       t.string :nonstandard

data/test/test_activist.rb

@@ -5,54 +5,55 @@ require 'test_helper'
 describe PublicActivity::Activist do
   it 'adds owner association' do
     klass = article
-    klass.must_respond_to :activist
+    assert_respond_to klass, :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
+    assert_respond_to klass.new, :activities
+
+    case ENV['PA_ORM']
+    when 'active_record'
+      assert_equal klass.reflect_on_association(:activities_as_owner).options[:as], :owner
+    when 'mongoid'
+      assert_equal klass.reflect_on_association(:activities_as_owner).options[:inverse_of], :owner
+    when 'mongo_mapper'
+      assert_equal klass.associations[:activities_as_owner].options[:as], :owner
     end
 
-    if ENV["PA_ORM"] == "mongo_mapper"
-      klass.associations[:activities_as_owner].options[:class_name].must_equal "::PublicActivity::Activity"
+    if ENV['PA_ORM'] == 'mongo_mapper'
+      assert_equal klass.associations[:activities_as_owner].options[:class_name], '::PublicActivity::Activity'
     else
-      klass.reflect_on_association(:activities_as_owner).options[:class_name].must_equal "::PublicActivity::Activity"
+      assert_equal klass.reflect_on_association(:activities_as_owner).options[:class_name], '::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
+    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")
+    owner = ActivistUser.create(name: 'Peter Pan')
     a = article(owner: owner).new
     a.save
 
-    owner.activities_as_owner.length.must_equal 1
+    assert_equal owner.activities_as_owner.length, 1
   end
 end

data/test/test_activity.rb

@@ -4,86 +4,85 @@ require 'test_helper'
 
 describe 'PublicActivity::Activity Rendering' do
   describe '#text' do
-    subject { PublicActivity::Activity.new(:key => 'activity.test', :parameters => {:one => 1}) }
+    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})
+      I18n.config.backend.store_translations(:en, activity: { test: '%{one} %{two}' })
+      assert_equal subject.text(two: 2), '1 2'
+      assert_equal subject.parameters, one: 1
     end
   end
 
   describe '#render' do
     subject do
-      s = PublicActivity::Activity.new(:key => 'activity.test', :parameters => {:one => 1})
-      s.save && s
+      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__) }
+    before { @controller.view_paths << File.expand_path('views', __dir__) }
 
     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"
+      subject.render(self, two: 2)
+      assert_equal rendered, "#{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"
+      subject.render(self, two: 2)
+      assert_equal rendered, "#{template_output}\n"
     end
 
     it 'provides local variables' do
       PublicActivity.set_controller(nil)
-      subject.render(self, locals: {two: 2})
-      rendered.chomp.must_equal "2"
+      subject.render(self, locals: { two: 2 })
+      assert_equal rendered.chomp, '2'
     end
 
     it 'uses translations only when requested' do
-      I18n.config.backend.store_translations(:en,
-        {:activity => {:test => '%{one} %{two}'}}
-      )
+      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'
+      assert_equal rendered, '1 2'
     end
 
-    it "pass all params to view context" do
+    it 'pass all params to view context' do
       view_context = mock('ViewContext')
       PublicActivity.set_controller(nil)
-      view_context.expects(:render).with() {|params| params[:formats] == ['json']}
-      subject.render(view_context, :formats => ['json'])
+      view_context.expects(:render).with { |params| params[:formats] == ['json'] }
+      subject.render(view_context, formats: ['json'])
     end
 
-    it "uses specified layout" do
+    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: 'activity')
+      assert_includes rendered, 'Here be the layouts'
 
-      subject.render(self, :layout => "layouts/activity")
-      rendered.must_include "Here be the layouts"
+      subject.render(self, layout: 'layouts/activity')
+      assert_includes rendered, 'Here be the layouts'
 
-      subject.render(self, :layout => :activity)
-      rendered.must_include "Here be the layouts"
+      subject.render(self, layout: :activity)
+      assert_includes rendered, 'Here be the layouts'
     end
 
-    it "accepts a custom layout root" do
-      subject.render(self, :layout => :layout, :layout_root => "custom")
-      rendered.must_include "Here be the custom layouts"
+    it 'accepts a custom layout root' do
+      subject.render(self, layout: :layout, layout_root: 'custom')
+      assert_includes rendered, 'Here be the custom layouts'
     end
-    it "accepts an absolute layout path" do
-      subject.render(self, :layout => '/custom/layout')
-      rendered.must_include "Here be the custom layouts"
+
+    it 'accepts an absolute layout path' do
+      subject.render(self, layout: '/custom/layout')
+      assert_includes rendered, 'Here be the custom layouts'
     end
-    it "accepts a template root" do
-      subject.render(self, :root => "custom")
-      rendered.must_include "Custom Template Root"
+
+    it 'accepts a template root' do
+      subject.render(self, root: 'custom')
+      assert_includes rendered, 'Custom Template Root'
     end
   end
 end

data/test/test_common.rb

@@ -4,55 +4,60 @@ 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}
+    @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
+    assert_equal subject.create_activity(:test, params: { author_name: 'Pan' }).parameters[:author_name], 'Pan'
+    assert_equal subject.create_activity(:test, parameters: { author_name: 'Pan' }).parameters[:author_name], 'Pan'
+    assert_nil subject.create_activity(:test, params: { author_name: nil }).parameters[:author_name]
+    assert_nil subject.create_activity(:test, parameters: { author_name: nil }).parameters[:author_name]
   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
+    assert_equal subject.create_activity(:test, owner: @recipient).owner, @recipient
+    assert_nil subject.create_activity(:test, owner: nil).owner
   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
+    assert_equal subject.create_activity(:test, recipient: @owner).recipient, @owner
+    assert_nil subject.create_activity(:test, recipient: nil).recipient
   end
 
   it 'uses global fields' do
     subject.save
     activity = subject.activities.last
-    activity.parameters.must_equal @options[:params]
-    activity.owner.must_equal @owner
+    assert_equal activity.parameters, @options[:params]
+    assert_equal activity.owner, @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"
+    subject.create_activity :with_custom_fields, nonstandard: 'Custom allowed'
+    assert_equal subject.activities.last.nonstandard, 'Custom allowed'
   end
 
   it '#create_activity returns a new activity object' do
     subject.save
-    subject.create_activity("some.key").wont_be_nil
+    assert subject.create_activity('some.key')
   end
 
   it '#create_activity! returns a new activity object' do
     subject.save
-    activity = subject.create_activity!("some.key")
+    activity = subject.create_activity!('some.key')
     assert activity.persisted?
     assert_equal 'article.some.key', activity.key
   end
@@ -63,103 +68,102 @@ describe PublicActivity::Common do
     subject.save
     subject.save
     after_count = subject.activities.count
-    before_count.must_equal after_count
+    assert_equal before_count, after_count
   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
+    activity = article.create_activity('some.key', owner: @owner)
+    assert_equal activity.owner, @owner
   end
 
   it 'allows resolving custom fields' do
-    subject.name      = "Resolving is great"
+    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"
+    assert_equal subject.activities.last.nonstandard, 'Resolving is great'
+    subject.create_activity :with_custom_fields_2, nonstandard: proc { |_, model| model.published.to_s }
+    assert_equal subject.activities.last.nonstandard, 'true'
   end
 
   it 'inherits instance parameters' do
-    subject.activity :params => {:author_name => "Michael"}
+    subject.activity params: { author_name: 'Michael' }
     subject.save
     activity = subject.activities.last
 
-    activity.parameters[:author_name].must_equal "Michael"
+    assert_equal activity.parameters[:author_name], 'Michael'
   end
 
   it 'accepts instance recipient' do
-    subject.activity :recipient => @recipient
+    subject.activity recipient: @recipient
     subject.save
-    subject.activities.last.recipient.must_equal @recipient
+    assert_equal subject.activities.last.recipient, @recipient
   end
 
   it 'accepts instance owner' do
-    subject.activity :owner => @owner
+    subject.activity owner: @owner
     subject.save
-    subject.activities.last.owner.must_equal @owner
+    assert_equal subject.activities.last.owner, @owner
   end
 
   it 'accepts owner as a symbol' do
-    klass = article(:owner => :user)
-    @article = klass.new(:user => @owner)
+    klass = article(owner: :user)
+    @article = klass.new(user: @owner)
     @article.save
     activity = @article.activities.last
 
-    activity.owner.must_equal @owner
+    assert_equal activity.owner, @owner
   end
 
   it 'reports PublicActivity::Activity as the base class' do
-    if ENV["PA_ORM"] == "active_record" # Only relevant for ActiveRecord
+    if ENV['PA_ORM'] == 'active_record' # Only relevant for ActiveRecord
       subject.save
-      subject.activities.last.class.base_class.must_equal PublicActivity::Activity
+      assert_equal subject.activities.last.class.base_class, PublicActivity::Activity
     end
   end
 
   describe '#prepare_key' do
     describe 'for class#activity_key method' do
       before do
-        @article = article(:owner => :user).new(:user => @owner)
+        @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
+        def @article.activity_key; 'my_custom_key' end
 
-        @article.prepare_key(:create, {}).must_equal "my_custom_key"
+        assert_equal @article.prepare_key(:create, {}), 'my_custom_key'
       end
 
       it 'assigns key based on class name as fallback' do
         def @article.activity_key; nil end
 
-        @article.prepare_key(:create).must_equal "article.create"
+        assert_equal @article.prepare_key(:create), 'article.create'
       end
 
       it 'assigns key value from options hash' do
-        @article.prepare_key(:create, :key => :my_custom_key).must_equal "my_custom_key"
+        assert_equal @article.prepare_key(:create, key: :my_custom_key), 'my_custom_key'
       end
     end
 
     describe 'for camel cased classes' do
       before do
-        class CamelCase < article(:owner => :user)
+        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.prepare_key(:create, {}).must_equal "camel_case.create"
+        assert_equal @camel_case.prepare_key(:create, {}), 'camel_case.create'
       end
     end
 
     describe 'for namespaced classes' do
       before do
         module ::MyNamespace;
-          class CamelCase < article(:owner => :user)
+          class CamelCase < article(owner: :user)
             def self.name; 'MyNamespace::CamelCase' end
           end
         end
@@ -167,13 +171,15 @@ describe PublicActivity::Common do
       end
 
       it 'assigns key value from options hash' do
-        @namespaced_camel_case.prepare_key(:create, {}).must_equal "my_namespace_camel_case.create"
+        assert_equal @namespaced_camel_case.prepare_key(:create, {}), 'my_namespace_camel_case.create'
       end
     end
   end
 
   # no key implicated or given
-  specify { ->{subject.prepare_settings}.must_raise PublicActivity::NoKeyProvided }
+  specify do
+    assert_raises(PublicActivity::NoKeyProvided) { subject.prepare_settings }
+  end
 
   describe 'resolving values' do
     it 'allows procs with models and controllers' do
@@ -182,7 +188,7 @@ describe PublicActivity::Common do
       controller = mock('controller')
       controller.expects(:current_user).returns(:cu)
       PublicActivity.set_controller(controller)
-      p = proc {|c, m|
+      p = proc { |c, m|
         assert_equal :cu, c.current_user
         assert_equal 5, m.accessor
       }
@@ -191,4 +197,7 @@ describe PublicActivity::Common do
     end
   end
 
+  def teardown
+    PublicActivity.set_controller(nil)
+  end
 end