Refactor Common#prepare_settings.

lib/public_activity/common.rb

@@ -269,60 +269,75 @@ def create_activity(*args)
     # @overload prepare_settings(options = {})
     #   @see #create_activity
     def prepare_settings(*args)
-      # key
-      all_options = args.extract_options!
-      options = {
-        key: all_options.delete(:key),
-        action: all_options.delete(:action),
-        parameters: all_options.delete(:parameters) || all_options.delete(:params)
-      }
-      action = (args.first || options[:action]).try(:to_s)
-
-      options[:key] = extract_key(action, options)
+      raw_options = args.extract_options!
+      action      = [args.first, raw_options.delete(:action)].compact.first
+      key         = prepare_key(action, raw_options)
 
-      raise NoKeyProvided, "No key provided for #{self.class.name}" unless options[:key]
+      raise NoKeyProvided, "No key provided for #{self.class.name}" unless key
 
-      options.delete(:action)
-
-      # user responsible for the activity
-      options[:owner] = PublicActivity.resolve_value(self,
-        (all_options.has_key?(:owner) ? all_options[:owner] : (
-          self.activity_owner || self.class.activity_owner_global
-          )
-        )
+      prepare_custom_fields(raw_options.except(:params)).merge(
+        {
+          key:        key,
+          owner:      prepare_relation(:owner,     raw_options),
+          recipient:  prepare_relation(:recipient, raw_options),
+          parameters: prepare_parameters(raw_options),
+        }
       )
+    end
 
-      # recipient of the activity
-      options[:recipient] = PublicActivity.resolve_value(self,
-        (all_options.has_key?(:recipient) ? all_options[:recipient] : (
-          self.activity_recipient || self.class.activity_recipient_global
-          )
-        )
-      )
+    # Prepares absolutely required options for activity
+    # @private
+    def prepare_options(raw)
+      {
+        key:        raw.delete(:key),
+        action:     raw.delete(:action),
+        parameters: raw.delete(:parameters) || raw.delete(:params)
+      }
+    end
+
+    # Prepares and resolves custom fields
+    # users can pass to `tracked` method
+    # @private
+    def prepare_custom_fields(options)
+      customs = self.class.activity_custom_fields_global.clone
+      customs.merge!(self.activity_custom_fields) if self.activity_custom_fields
+      customs.merge!(options)
+      customs.each do  |k, v|
+        customs[k] = PublicActivity.resolve_value(self, v)
+      end
+    end
 
-      #customizable parameters
+    # Prepares i18n parameters that will
+    # be serialized into the Activity#parameters column
+    # @private
+    def prepare_parameters(options)
       params = {}
       params.merge!(self.class.activity_params_global)
       params.merge!(self.activity_params) if self.activity_params
-      params.merge!(options[:params] || options[:parameters] || {})
+      params.merge!([options.delete(:parameters), options.delete(:params), {}].compact.first)
       params.each { |k, v| params[k] = PublicActivity.resolve_value(self, v) }
-      options[:parameters] = params
-      options.delete(:params)
+    end
 
-      customs = self.class.activity_custom_fields_global.clone
-      customs.merge!(self.activity_custom_fields) if self.activity_custom_fields
-      customs.merge!(all_options)
-      customs.each do  |k, v|
-        customs[k] = PublicActivity.resolve_value(self, v)
-      end.merge options
+    # Prepares relation to be saved
+    # to Activity. Can be :recipient or :owner
+    # @private
+    def prepare_relation(name, options)
+      PublicActivity.resolve_value(self,
+        (options.has_key?(name) ? options[name] : (
+          self.send("activity_#{name}") || self.class.send("activity_#{name}_global")
+          )
+        )
+      )
     end
 
     # Helper method to serialize class name into relevant key
     # @return [String] the resulted key
     # @param [Symbol] or [String] the name of the operation to be done on class
     # @param [Hash] options to be used on key generation, defaults to {}
-    def extract_key(action, options = {})
-      (options[:key] || self.activity_key ||
+    def prepare_key(action, options = {})
+      (
+        options[:key] ||
+        self.activity_key ||
         ((self.class.name.underscore.gsub('/', '_') + "." + action.to_s) if action)
       ).try(:to_s)
     end

lib/public_activity/roles/tracked.rb

@@ -29,10 +29,10 @@ module Tracked
     # @return [nil]
     def activity(options = {})
       rest = options.clone
-      self.activity_key = rest.delete(:key) if rest[:key]
-      self.activity_owner = rest.delete(:owner) if rest[:owner]
-      self.activity_params = rest.delete(:params) if rest[:params]
-      self.activity_recipient = rest.delete(:recipient) if rest[:recipient]
+      self.activity_key           = rest.delete(:key) if rest[:key]
+      self.activity_owner         = rest.delete(:owner) if rest[:owner]
+      self.activity_params        = rest.delete(:params) if rest[:params]
+      self.activity_recipient     = rest.delete(:recipient) if rest[:recipient]
       self.activity_custom_fields = rest if rest.count > 0
       nil
     end

public_activity.gemspec

@@ -43,4 +43,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'minitest', '< 5.0.0'
   s.add_development_dependency 'redcarpet'
   s.add_development_dependency 'yard', '~> 0.8'
+  s.add_development_dependency 'pry'
 end

test/test_common.rb

@@ -94,7 +94,7 @@
     activity.owner.must_equal @owner
   end
 
-  describe '#extract_key' do
+  describe '#prepare_key' do
     describe 'for class#activity_key method' do
       before do
         @article = article(:owner => :user).new(:user => @owner)
@@ -103,17 +103,17 @@
       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"
+        @article.prepare_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"
+        @article.prepare_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"
+        @article.prepare_key(:create, :key => :my_custom_key).must_equal "my_custom_key"
       end
     end
 
@@ -126,7 +126,7 @@ def self.name; 'CamelCase' end
       end
 
       it 'assigns generates key from class name' do
-        @camel_case.extract_key(:create, {}).must_equal "camel_case.create"
+        @camel_case.prepare_key(:create, {}).must_equal "camel_case.create"
       end
     end
 
@@ -141,7 +141,7 @@ def self.name; 'MyNamespace::CamelCase' end
       end
 
       it 'assigns key value from options hash' do
-        @namespaced_camel_case.extract_key(:create, {}).must_equal "my_namespace_camel_case.create"
+        @namespaced_camel_case.prepare_key(:create, {}).must_equal "my_namespace_camel_case.create"
       end
     end
   end

test/test_helper.rb

@@ -12,7 +12,7 @@
 require 'active_support/testing/setup_and_teardown'
 require 'public_activity'
 require 'public_activity/testing'
-
+require 'pry'
 require 'minitest/autorun'
 
 PublicActivity::Config.orm = (ENV['PA_ORM'] || :active_record)