wiser_trails 1.1.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTVhMjgwMTM0ZGYyYWYzOWI3Y2RjNzU3NTk3OWUzNDdiMzhiOTM5Nw==
+  data.tar.gz: !binary |-
+    ZWI0ZDBhNTY4MGYyYWQyNjdjYTNhNjg0ZWE1NDFhZmQ1Y2FlOGIyYQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MzVhN2ZjZTgyZGIwMGM4MWQzMTFiNmY1MmZhYTc1MjA4NTVjMmMxNmZjYjU1
+    NjM2ZDEyYzg1YzQ3OTdiZjllZGM3ZTY0ZDA5OTliMDQ5ZTQwNDBkY2I1YjAy
+    ZTg4OGVkMTY1NjA1OWU2NGJjMjFlMjI5NjgxMjM4NjJhODQ2MjM=
+  data.tar.gz: !binary |-
+    MGE2Y2Y3ZTE5MWIxNjU5MjcyNTIyOWNiN2E5M2VlYWY4ZTQ4ZmQ5MjkyMjc1
+    M2FmNGJkNTYxNzljYjYwYmZhNGU3NjhlODgyOWQ5NTI4YTBhOWJhMjA5YmM3
+    NTM3ZTI3Yzc5NmU5MGI3OTcwNjU3YzJhNDEyMWM1NmFhMWU3Zjk=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kenneth John Balgos
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,145 @@
+# WiserTrails
+
+Audit Trails in Harmony
+
+## Requirements
+
+_Audit Trails_ only support Rails 3.x and 4.0 with **Active Record**.
+
+## Setup
+
+### Gem Installation
+
+You can do normal gem installation for `wiser_trails`:
+
+    gem install wiser_trails
+
+or in your Gemfile:
+
+```ruby
+gem 'wiser_trails'
+```
+
+### Database
+
+**(ActiveRecord only)** Generate a migration for trails and migrate the database (in your Rails project):
+
+    rails g wiser_trails:migration
+    rake db:migrate
+
+## Usage
+
+### Monitoring CRUD Actions
+
+To record the Create, Update, and Delete actions, include `WiserTrails::Model` and add `trail_it` to the model you want to keep track of:
+
+```ruby
+class Notes < ActiveRecord::Base
+  include WiserTrails::Model
+  trail_it
+end
+```
+
+If you want to automatically send the owner of the trail, include `WiserTrails::StoreController` to your `application_controller.rb`:
+
+```ruby
+class ApplicationController < ActionController::Base
+  include WiserTrails::StoreController
+end
+```
+
+Then you can specify the `owner` of the trail:
+
+```ruby
+class Notes < ActiveRecord::Base
+  include WiserTrails::Model
+  trail_it owner: ->(controller, model) { controller && controller.current_user }
+end
+```
+
+Or even the `account` if you're having a multi-account structure:
+
+```ruby
+class Notes < ActiveRecord::Base
+  include WiserTrails::Model
+  trail_it
+    owner: ->(controller, model) { controller && controller.current\_user },
+    account: ->(controller, model) { controller && controller.current\_account }
+end
+```
+
+### Monitoring Custom Actions
+
+To record custom actions, you can manually trigger the `create_activity` method on the model record:
+
+```ruby
+@note.create_activity(key: 'note.published', owner: current_user)
+```
+
+Or even the `account` if you're having a multi-account structure:
+
+```ruby
+@note.create_activity(key: 'note.published', owner: current_user, account: current_account)
+```
+
+## Fetching Trails
+
+### Query for the WiserTrails::Activity model
+To get the trails them you simply query the `WiserTrails::Activity` model in your controllers:
+
+```ruby
+def index
+  @trails = WiserTrails::Activity.order('id DESC')
+end
+```
+
+Or with account:
+
+```ruby
+def index
+  @trails = WiserTrails::Activity.where(account: current_account)
+end
+```
+
+### Getting the objects
+
+You can get the `owner`, `account`, and the `trackable` objects from the `WiserTrails::Activity`:
+
+```ruby
+def show
+  @trail = WiserTrails::Activity.find(params[:id])
+  # @trail.owner => current_user object
+  # @trail.account => current_account object
+  # @trail.trackable => Note object
+end
+```
+
+You can also get the new trackable value by calling `new_value`:
+
+```ruby
+def show
+  @trail = WiserTrails::Activity.find(params[:id])
+  # @trail.new_value => exact Note attributes after the trail was recorded
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Support
+Open an issue in https://github.com/kennethjohnbalgos/wiser_trails if you need further support or want to report a bug.
+
+## License
+
+The MIT License (MIT) Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+require 'rake'

data/lib/generators/wiser_trails.rb

@@ -0,0 +1,12 @@
+require 'rails/generators/named_base'
+
+module WiserTrails
+  module Generators
+    module Base
+      # Get path for migration template
+      def source_root
+        @_wiser_trails_source_root ||= File.expand_path(File.join('../wiser_trails', generator_name, 'templates'), __FILE__)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'generators/wiser_trails'
+require 'rails/generators/active_record'
+
+module WiserTrails
+  module Generators
+    # Migration generator that creates migration file from template
+    class MigrationGenerator < ActiveRecord::Generators::Base
+      extend Base
+
+      argument :name, :type => :string, :default => 'create_wiser_trails'
+      # Create migration in project's folder
+      def generate_files
+        migration_template 'migration.rb', "db/migrate/#{name}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# Migration responsible for creating a table with trails
+class CreateWiserTrails < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :wiser_trails do |t|
+      t.belongs_to :trackable, :polymorphic => true
+      t.belongs_to :account, :polymorphic => true
+      t.belongs_to :owner, :polymorphic => true
+      t.string :key
+      t.text :new_value
+
+      t.timestamps
+    end
+
+    add_index :wiser_trails, [:trackable_id, :trackable_type]
+    add_index :wiser_trails, [:account_id, :account_type]
+    add_index :wiser_trails, [:owner_id, :owner_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :wiser_trails
+  end
+end

data/lib/generators/wiser_trails/model/model_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/wiser_date'
+require 'rails/generators/active_record'
+
+module WiserTrails
+  module Generators
+    # Activity generator that creates activity model file from template
+    class ActivityGenerator < ActiveRecord::Generators::Base
+      extend Base
+
+      argument :name, :type => :string, :default => 'wiser_trails'
+      # Create model in project's folder
+      def generate_files
+        copy_file 'model.rb', "app/models/#{name}.rb"
+      end
+    end
+  end
+end

data/lib/generators/wiser_trails/model/templates/model.rb

@@ -0,0 +1,3 @@
+# WiserTrails model for customisation & custom methods
+class WiserTrails < WiserTrails::Activity
+end

data/lib/wiser_trails.rb

@@ -0,0 +1,69 @@
+require 'wiser_trails/version'
+require 'active_support'
+require 'action_view'
+
+# +wiser_trails+ keeps track of changes made to models
+# and allows you to display them to the users.
+#
+# Check {WiserTrails::Tracked::ClassMethods#tracked} for more details about customizing and specifying
+# ownership to users.
+
+module WiserTrails
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+
+  autoload :Activity,     'wiser_trails/models/activity'
+  autoload :Activist,     'wiser_trails/models/activist'
+  autoload :Adapter,      'wiser_trails/models/adapter'
+  autoload :Trackable,    'wiser_trails/models/trackable'
+  autoload :Common
+  autoload :Config
+  autoload :Creation,     'wiser_trails/actions/creation.rb'
+  autoload :Deactivatable,'wiser_trails/roles/deactivatable.rb'
+  autoload :Destruction,  'wiser_trails/actions/destruction.rb'
+  autoload :Renderable
+  autoload :TrailIt,      'wiser_trails/roles/trail_it.rb'
+  autoload :Update,       'wiser_trails/actions/update.rb'
+  autoload :VERSION
+
+  # Switches WiserTrails on or off.
+  # @param value [Boolean]
+  # @since 0.5.0
+  def self.enabled=(value)
+    WiserTrails.config.enabled = value
+  end
+
+  # Returns `true` if WiserTrails is on, `false` otherwise.
+  # Enabled by default.
+  # @return [Boolean]
+  # @since 0.5.0
+  def self.enabled?
+    !!WiserTrails.config.enabled
+  end
+
+  def self.config
+    @@config ||= WiserTrails::Config.instance
+  end
+
+  # Method used to choose which ORM to load
+  # when WiserTrails::Activity class is being autoloaded
+  def self.inherit_orm(model="Activity")
+    orm = WiserTrails.config.orm
+    require "wiser_trails/orm/#{orm.to_s}"
+    "WiserTrails::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 TrailIt
+      include Activist  # optional associations by account|owner
+    end
+  end
+end
+
+require 'wiser_trails/utility/store_controller'
+require 'wiser_trails/utility/view_helpers'

data/lib/wiser_trails/actions/creation.rb

@@ -0,0 +1,15 @@
+module WiserTrails
+  # Handles creation of Activities upon destruction and update of tracked model.
+  module Creation
+    extend ActiveSupport::Concern
+
+    included do
+      after_create :activity_on_create
+    end
+    private
+      # Creates activity upon creation of the tracked model
+      def activity_on_create
+        create_activity(:create)
+      end
+  end
+end

data/lib/wiser_trails/actions/destruction.rb

@@ -0,0 +1,15 @@
+module WiserTrails
+  # Handles creation of Activities upon destruction of tracked model.
+  module Destruction
+    extend ActiveSupport::Concern
+
+    included do
+      before_destroy :activity_on_destroy
+    end
+    private
+      # Records an activity upon destruction of the tracked model
+      def activity_on_destroy
+        create_activity(:destroy)
+      end
+  end
+end

data/lib/wiser_trails/actions/update.rb

@@ -0,0 +1,15 @@
+module WiserTrails
+  # Handles creation of Activities upon destruction and update of tracked model.
+  module Update
+    extend ActiveSupport::Concern
+
+    included do
+      after_update :activity_on_update
+    end
+    private
+      # Creates activity upon modification of the tracked model
+      def activity_on_update
+        create_activity(:update)
+      end
+  end
+end

data/lib/wiser_trails/activity.rb

@@ -0,0 +1,6 @@
+module WiserTrails
+  # Main model, stores all information about what happened,
+  # who caused it, when and anything else.
+  class Activity < inherit_orm("Activity")
+  end
+end

data/lib/wiser_trails/common.rb

@@ -0,0 +1,334 @@
+module WiserTrails
+  # Happens when creating custom activities without either action or a key.
+  class NoKeyProvided < Exception; end
+
+  # Used to smartly transform value from metadata to data.
+  # Accepts Symbols, which it will send against context.
+  # Accepts Procs, which it will execute with controller and context.
+  # @since 0.4.0
+  def self.resolve_value(context, thing)
+    case thing
+    when Symbol
+      context.__send__(thing)
+    when Proc
+      thing.call(WiserTrails.get_controller, context)
+    else
+      thing
+    end
+  end
+
+  # Common methods shared across the gem.
+  module Common
+    extend ActiveSupport::Concern
+
+    included do
+      include Trackable
+      class_attribute :activity_owner_global, :activity_account_global,
+                      :activity_new_value_global, :activity_hooks, :activity_custom_fields_global
+      set_wiser_trails_class_defaults
+    end
+
+    # @!group Global options
+
+    # @!attribute activity_owner_global
+    #   Global version of activity owner
+    #   @see #activity_owner
+    #   @return [Model]
+
+    # @!attribute activity_account_global
+    #   Global version of activity recipient
+    #   @see #activity_account
+    #   @return [Model]
+
+    # @!attribute activity_new_value_global
+    #   Global version of activity parameters
+    #   @see #activity_new_value
+    #   @return [Hash<Symbol, Object>]
+
+    # @!attribute activity_hooks
+    #   @return [Hash<Symbol, Proc>]
+    #   Hooks/functions that will be used to decide *if* the activity should get
+    #   created.
+    #
+    #   The supported keys are:
+    #   * :create
+    #   * :update
+    #   * :destroy
+
+    # @!endgroup
+
+    # @!group Instance options
+
+    # Set or get parameters that will be passed to {Activity} when saving
+    #
+    # == Usage:
+    #
+    #   @article.activity_new_value = {:article_title => @article.title}
+    #   @article.save
+    #
+    # This way you can pass strings that should remain constant, even when model attributes
+    # change after creating this {Activity}.
+    # @return [Hash<Symbol, Object>]
+    attr_accessor :activity_new_value
+    @activity_new_value = {}
+    # Set or get owner object responsible for the {Activity}.
+    #
+    # == Usage:
+    #
+    #   # where current_user is an object of logged in user
+    #   @article.activity_owner = current_user
+    #   # OR: take @article.author association
+    #   @article.activity_owner = :author
+    #   # OR: provide a Proc with custom code
+    #   @article.activity_owner = proc {|controller, model| model.author }
+    #   @article.save
+    #   @article.activities.last.owner #=> Returns owner object
+    # @return [Model] Polymorphic model
+    # @see #activity_owner_global
+    attr_accessor :activity_owner
+    @activity_owner = nil
+
+    # Set or get recipient for activity.
+    #
+    # Association is polymorphic, thus allowing assignment of
+    # all types of models. This can be used for example in the case of sending
+    # private notifications for only a single user.
+    # @return (see #activity_owner)
+    attr_accessor :activity_account
+    @activity_account = nil
+    # Set or get custom i18n key passed to {Activity}, later used in {Renderable#text}
+    #
+    # == Usage:
+    #
+    #   @article = Article.new
+    #   @article.activity_key = "my.custom.article.key"
+    #   @article.save
+    #   @article.activities.last.key #=> "my.custom.article.key"
+    #
+    # @return [String]
+    attr_accessor :activity_key
+    @activity_key = nil
+
+    # Set or get custom fields for later processing
+    #
+    # @return [Hash]
+    attr_accessor :activity_custom_fields
+    @activity_custom_fields = {}
+
+    # @!visibility private
+    @@activity_hooks = {}
+
+    # @!endgroup
+
+    # Provides some global methods for every model class.
+    module ClassMethods
+      #
+      # @since 1.0.0
+      # @api private
+      def set_wiser_trails_class_defaults
+        self.activity_owner_global             = nil
+        self.activity_account_global           = nil
+        self.activity_new_value_global         = {}
+        self.activity_hooks                    = {}
+        self.activity_custom_fields_global     = {}
+      end
+
+      # Extracts a hook from the _:on_ option provided in
+      # {Tracked::ClassMethods#tracked}. Returns nil when no hook exists for
+      # given action
+      # {Common#get_hook}
+      #
+      # @see Tracked#get_hook
+      # @param key [String, Symbol] action to retrieve a hook for
+      # @return [Proc, nil] callable hook or nil
+      # @since 0.4.0
+      # @api private
+      def get_hook(key)
+        key = key.to_sym
+        if self.activity_hooks.has_key?(key) and self.activity_hooks[key].is_a? Proc
+          self.activity_hooks[key]
+        else
+          nil
+        end
+      end
+    end
+    #
+    # Returns true if WiserTrails is enabled
+    # globally and for this class.
+    # @return [Boolean]
+    # @api private
+    # @since 0.5.0
+    def wiser_trails_enabled?
+      WiserTrails.enabled?
+    end
+    #
+    # Shortcut for {ClassMethods#get_hook}
+    # @param (see ClassMethods#get_hook)
+    # @return (see ClassMethods#get_hook)
+    # @since (see ClassMethods#get_hook)
+    # @api (see ClassMethods#get_hook)
+    def get_hook(key)
+      self.class.get_hook(key)
+    end
+
+    # Calls hook safely.
+    # If a hook for given action exists, calls it with model (self) and
+    # controller (if available, see {StoreController})
+    # @param key (see #get_hook)
+    # @return [Boolean] if hook exists, it's decision, if there's no hook, true
+    # @since 0.4.0
+    # @api private
+    def call_hook_safe(key)
+      hook = self.get_hook(key)
+      if hook
+        # provides hook with model and controller
+        hook.call(self, WiserTrails.get_controller)
+      else
+        true
+      end
+    end
+
+    # Directly creates activity record in the database, based on supplied options.
+    #
+    # It's meant for creating custom activities while *preserving* *all*
+    # *configuration* defined before. If you fire up the simplest of options:
+    #
+    #   current_user.create_activity(:avatar_changed)
+    #
+    # It will still gather data from any procs or symbols you passed as params
+    # to {Tracked::ClassMethods#tracked}. It will ask the hooks you defined
+    # whether to really save this activity.
+    #
+    # But you can also overwrite instance and global settings with your options:
+    #
+    #   @article.activity :owner => proc {|controller| controller.current_user }
+    #   @article.create_activity(:commented_on, :owner => @user)
+    #
+    # And it's smart! It won't execute your proc, since you've chosen to
+    # overwrite instance parameter _:owner_ with @user.
+    #
+    # [:key]
+    #   The key will be generated from either:
+    #   * the first parameter you pass that is not a hash (*action*)
+    #   * the _:action_ option in the options hash (*action*)
+    #   * the _:key_ option in the options hash (it has to be a full key,
+    #     including model name)
+    #   When you pass an *action* (first two options above), they will be
+    #   added to parameterized model name:
+    #
+    #   Given Article model and instance: @article,
+    #
+    #     @article.create_activity :commented_on
+    #     @article.activities.last.key # => "article.commented_on"
+    #
+    # For other parameters, see {Tracked#activity}, and "Instance options"
+    # accessors at {Tracked}, information on hooks is available at
+    # {Tracked::ClassMethods#tracked}.
+    # @see #prepare_settings
+    # @return [Model, nil] If created successfully, new activity
+    # @since 0.4.0
+    # @api public
+    # @overload create_activity(action, options = {})
+    #   @param [Symbol,String] action Name of the action
+    #   @param [Hash] options Options with quality higher than instance options
+    #     set in {Tracked#activity}
+    #   @option options [Activist] :owner Owner
+    #   @option options [Activist] :recipient Recipient
+    #   @option options [Hash] :params Parameters, see
+    #     {WiserTrails.resolve_value}
+    # @overload create_activity(options = {})
+    #   @param [Hash] options Options with quality higher than instance options
+    #     set in {Tracked#activity}
+    #   @option options [Symbol,String] :action Name of the action
+    #   @option options [String] :key Full key
+    #   @option options [Activist] :owner Owner
+    #   @option options [Activist] :recipient Recipient
+    #   @option options [Hash] :params Parameters, see
+    #     {WiserTrails.resolve_value}
+    def create_activity(*args)
+      return unless self.wiser_trails_enabled?
+      options = prepare_settings(*args)
+
+      if call_hook_safe(options[:key].split('.').last)
+        reset_activity_instance_options
+        return WiserTrails::Adapter.create_activity(self, options)
+      end
+
+      nil
+    end
+
+    # Prepares settings used during creation of Activity record.
+    # params passed directly to tracked model have priority over
+    # settings specified in tracked() method
+    #
+    # @see #create_activity
+    # @return [Hash] Settings with preserved options that were passed
+    # @api private
+    # @overload prepare_settings(action, options = {})
+    #   @see #create_activity
+    # @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)
+      }
+      action = (args.first || options[:action]).try(:to_s)
+
+      options[:key] = extract_key(action, options)
+
+      raise NoKeyProvided, "No key provided for #{self.class.name}" unless options[:key]
+
+      options.delete(:action)
+
+      # user responsible for the activity
+      options[:owner] = WiserTrails.resolve_value(self,
+        (all_options.has_key?(:owner) ? all_options[:owner] : (
+          self.activity_owner || self.class.activity_owner_global
+          )
+        )
+      )
+
+      # recipient of the activity
+      options[:account] = WiserTrails.resolve_value(self,
+        (all_options.has_key?(:account) ? all_options[:account] : (
+          self.activity_account || self.class.activity_account_global
+          )
+        )
+      )
+      options[:new_value] = self.attributes
+      options.delete(:params)
+
+      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] = WiserTrails.resolve_value(self, v)
+      end.merge options
+    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 ||
+        ((self.class.name.underscore.gsub('/', '_') + "." + action.to_s) if action)
+      ).try(:to_s)
+    end
+
+    # Resets all instance options on the object
+    # triggered by a successful #create_activity, should not be
+    # called from any other place, or from application code.
+    # @private
+    def reset_activity_instance_options
+      @activity_new_value = {}
+      @activity_key = nil
+      @activity_owner = nil
+      @activity_account = nil
+      @activity_custom_fields = {}
+    end
+  end
+end