state_machines-audit_trail 1.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b8a0bfd2dd9a83185bc24c1c55d3804b2fba5a8e
-  data.tar.gz: 03e55491819582dbf56a32b494756564d0da7ffd
+SHA256:
+  metadata.gz: fa9c1aad624d9dad005c50ab44eb5522908b1790490f6e8b1eacc1b05261a7e3
+  data.tar.gz: 9bcb723941ab88d56534181ad6be0c147de7262ee408c2a5607a77bd146b94e2
 SHA512:
-  metadata.gz: d1c764d8ed988ecb2a766939127e76ce902241320bd53fdce5641830bb3eb52c666179dae873d23fc2f989a5fd65013722af497716a59d65e06c5d5d5a659e6b
-  data.tar.gz: 60d5d11f419b337f253141fb36a17a51dcb2852cb549e89b64a59f4c8f06ed8a30fe7785038138a7a11884212ca1cd0b52cbac094cd9133699eb3165a5dd39f4
+  metadata.gz: ffaacbb29036d844d7a25d72da512906bee8d7a646e63b42b68f3f99bfcd7ff572e33177b84cf85ef079cb284dc2667611ce22b40835d524f065fdfb76f7926f
+  data.tar.gz: 15cf000aea32b80c3f0cf675fe9cad34574ce127d4328c3faea9f70b62e7d35550b67ef62ed9209000bf46c84e949ccec27821ba2d90861cfb075c43ae616a76

data/.gitignore

@@ -1,6 +1,7 @@
 *.gem
-/.bundle
+.bundle
 Gemfile.lock
+*.gemfile.lock
 pkg/*
 .DS_Store
 *.rbc

data/.ruby-gemset

@@ -0,0 +1 @@
+state_machines-audit_trail

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.travis.yml

@@ -1,17 +1,43 @@
 language: ruby
-sudo: false
 cache: bundler
 
 script: "bundle exec rake"
 
 services: mongodb
 rvm:
-  - 2.1
-  - 2.0.0
   - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - ruby-head
+  - jruby-head
   - jruby
   - rbx-2
+gemfile:
+  - gemfiles/rails_5.0.gemfile
+  - gemfiles/rails_5.1.gemfile
+  - gemfiles/rails_5.2.gemfile
+  - gemfiles/rails_6.0.gemfile
+  - gemfiles/rails_edge.gemfile
 matrix:
+  exclude:
+    - rvm: 2.2
+      gemfile: gemfiles/rails_6.0.gemfile
+    - rvm: 2.3
+      gemfile: gemfiles/rails_6.0.gemfile
+    - rvm: 2.4
+      gemfile: gemfiles/rails_6.0.gemfile
+    - rvm: 2.2
+      gemfile: gemfiles/rails_edge.gemfile
+    - rvm: 2.3
+      gemfile: gemfiles/rails_edge.gemfile
+    - rvm: 2.4
+      gemfile: gemfiles/rails_edge.gemfile
   allow_failures:
     - rvm: rbx-2
-    - rvm: jruby
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - gemfile: gemfiles/rails_edge.gemfile
+

data/Appraisals

@@ -0,0 +1,16 @@
+appraise 'rails_5.0' do
+  gem 'activerecord', '~> 5.0'
+  gem 'activemodel', '~> 5.0'
+end
+
+appraise 'rails_5.1' do
+  gem 'activerecord', '~> 5.1'
+  gem 'activemodel', '~> 5.1'
+end
+
+appraise 'rails_edge' do
+  gem 'rails', github: 'rails/rails', branch: 'master'
+  gem 'activerecord', github: 'rails/rails', branch: 'master'
+  gem 'activemodel', github: 'rails/rails', branch: 'master'
+  gem 'arel', github: 'rails/arel', branch: 'master'
+end

data/README.md

@@ -1,5 +1,5 @@
 [![Build Status](https://travis-ci.org/state-machines/state_machines-audit_trail.svg?branch=master)](https://travis-ci.org/state-machines/state_machines-audit_trail)
-[![Code Climate](https://codeclimate.com/github/state-machines/state_machines-audit_trail.png)](https://codeclimate.com/github/state-machines/state_machines-audit_trail)
+[![Code Climate](https://codeclimate.com/github/state-machines/state_machines-audit_trail.svg)](https://codeclimate.com/github/state-machines/state_machines-audit_trail)
 
 # state_machines-audit_trail
 Log transitions on a [state_machines gem](https://github.com/state-machines/state_machines) to support auditing and business process analytics.
@@ -12,7 +12,7 @@ for any state machine. Having an audit trail gives you a complete history of the
 to investigate incidents or perform analytics, like: _"How long does it take on average to go from state a to state b?"_,
 or _"What percentage of cases goes from state a to b via state c?"_
 
-For more information read [Why developers should be force-fed state machines](http://www.shopify.com/technology/3383012-why-developers-should-be-force-fed-state-machines).
+For more information read [Why developers should be force-fed state machines](https://engineering.shopify.com/blogs/engineering/17488160-why-developers-should-be-force-fed-state-machines).
 
 ## ORM support
 
@@ -56,7 +56,7 @@ will generate the `SubscriptionStateTransition` model and an accompanying migrat
 
 ```ruby
 class Subscription < ActiveRecord::Base
-  state_machines :state, initial: :start do
+  state_machine :state, initial: :start do
     audit_trail
     ...
 ```
@@ -64,6 +64,10 @@ class Subscription < ActiveRecord::Base
 ### That's it!
 `audit_trail` will register an `after_transition` callback that is used to log all transitions including the initial state if there is one.
 
+## Upgrading from state_machine-audit_trail
+
+See the wiki, https://github.com/state-machines/state_machines-audit_trail/wiki/Converting-from-former-state_machine-audit_trail-to-state_machines-audit_trail
+
 ## Configuration options
 
 ### `:initial` - turn off initial state logging
@@ -97,7 +101,7 @@ In order to utilize this feature, you need to:
 #### Example 1 - Store a single attribute value
 Store `Subscription` `field1` in `Transition` field `field1`:
 ```ruby
-audit_trail :context: :field1
+audit_trail context: :field1
 ```
 
 #### Example 2 - Store multiple attribute values
@@ -106,7 +110,25 @@ Store `Subscription` `field1` and `field2` in `Transition` fields `field1` and `
 audit_trail context: [:field1, :field2]
 ```
 
-#### Example 3 - Store simple method results
+#### Example 3 - Store multiple values from a single context object
+Store `Subscription` `user` in `Transition` fields `user_id` and `user_name`:
+```ruby
+class Subscription < ActiveRecord::Base
+  state_machine :state, initial: :start do
+    audit_trail context: :user
+    ...
+  end
+end
+
+class SubscriptionStateTransition < ActiveRecord::Base
+  def user=(u)
+    self.user_id = u.id
+    self.user_name = u.name
+  end
+end
+```
+
+#### Example 4 - Store simple method results
 Store simple method results.
 
 Sometimes it can be useful to store dynamically computed information, such as those from a `Subscription`  method `#plan_time_remaining`
@@ -114,7 +136,7 @@ Sometimes it can be useful to store dynamically computed information, such as th
 
 ```ruby
 class Subscription < ActiveRecord::Base
-  state_machines :state, initial: :start do
+  state_machine :state, initial: :start do
     audit_trail :context: :plan_time_remaining
     ...
 
@@ -123,12 +145,12 @@ class Subscription < ActiveRecord::Base
     ...
 ```
 
-#### Example 4 - Store advanced method results
+#### Example 5 - Store advanced method results
 Store method results that interrogate the transition for information such as `event` arguments:
 
 ```ruby
 class Subscription < ActiveRecord::Base
-  state_machines :state, initial: :start do
+  state_machine :state, initial: :start do
     audit_trail :context: :user_name
     ...
 

data/Rakefile

@@ -6,4 +6,10 @@ RSpec::Core::RakeTask.new(:spec) do |task|
   task.rspec_opts = ['--color']
 end
 
-task :default => [:spec]
+if ENV['APPRAISAL_INITIALIZED'] || ENV['TRAVIS']
+  task :default => :spec
+else
+  require 'appraisal'
+  Appraisal::Task.new
+  task :default => :appraisal
+end

data/gemfiles/rails_5.0.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.0.0"
+gem "activemodel", "~> 5.0.0"
+gem "sqlite3", "~> 1.3.6"
+
+gemspec path: "../"

data/gemfiles/rails_5.1.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.1.0"
+gem "activemodel", "~> 5.1.0"
+
+gemspec path: "../"

data/gemfiles/rails_5.2.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.2.0"
+gem "activemodel", "~> 5.2.0"
+
+gemspec path: "../"

data/gemfiles/rails_6.0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 6.0.0"
+gem "activemodel", "~> 6.0.0"
+
+gemspec path: "../"

data/gemfiles/rails_edge.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", github: "rails/rails", branch: "master"
+gem "activerecord", github: "rails/rails", branch: "master"
+gem "activemodel", github: "rails/rails", branch: "master"
+gem "arel", github: "rails/arel", branch: "master"
+
+gemspec path: "../"

data/lib/state_machines-audit_trail.rb

@@ -1,2 +1,3 @@
+# Comment here to test travis build on gem PR with no meaningful changes
 # To keep Rails happy
 require 'state_machines/audit_trail'

data/lib/state_machines/audit_trail/backend.rb

@@ -1,4 +1,4 @@
-class StateMachines::AuditTrail::Backend < Struct.new(:transition_class, :owner_class, :context)
+class StateMachines::AuditTrail::Backend < Struct.new(:transition_class, :owner_class, :options)
 
   autoload :Mongoid, 'state_machines/audit_trail/backend/mongoid'
   autoload :ActiveRecord, 'state_machines/audit_trail/backend/active_record'
@@ -9,10 +9,18 @@ class StateMachines::AuditTrail::Backend < Struct.new(:transition_class, :owner_
   #   - transition: state machine transition object that state machine passes to after/before transition callbacks
   #
   def log(object, transition)
-    fields = {event: transition.event ? transition.event.to_s : nil, from: transition.from, to: transition.to}
-    [context].flatten(1).each { |field|
+
+    if transition.machine.presence
+      # full transition object
+      namespace = transition.machine.namespace
+    else
+      # initial state open struct
+      namespace = transition.namespace
+    end
+    fields = {namespace: namespace, event: transition.event ? transition.event.to_s : nil, from: transition.from, to: transition.to}
+    [*options[:context]].each { |field|
       fields[field] = resolve_context(object, field, transition)
-    } unless self.context.nil?
+    }
 
     # begin
     persist(object, fields)
@@ -30,16 +38,21 @@ class StateMachines::AuditTrail::Backend < Struct.new(:transition_class, :owner_
   # To add a new ORM, implement something similar to lib/state_machines/audit_trail/backend/active_record.rb
   # and return from here the appropriate object based on which ORM the transition_class is using
   #
-  def self.create_for(transition_class, owner_class, context = nil)
+  def self.create_for(transition_class, owner_class, options = {})
     if Object.const_defined?('ActiveRecord') && transition_class.ancestors.include?(::ActiveRecord::Base)
-      return StateMachines::AuditTrail::Backend::ActiveRecord.new(transition_class, owner_class, context)
+      return StateMachines::AuditTrail::Backend::ActiveRecord.new(transition_class, owner_class, options)
     elsif Object.const_defined?('Mongoid') && transition_class.ancestors.include?(::Mongoid::Document)
-      return StateMachines::AuditTrail::Backend::Mongoid.new(transition_class, owner_class, context)
+      return StateMachines::AuditTrail::Backend::Mongoid.new(transition_class, owner_class, options)
     else
       raise 'Not implemented. Only support for ActiveRecord and Mongoid is implemented. Pull requests welcome.'
     end
   end
 
+  # Exists in case ORM layer has a different way of answering this question, but works for most.
+  def new_record?(object)
+    object.new_record?
+  end
+
   protected
 
   def persist(object, fields)
@@ -47,7 +60,15 @@ class StateMachines::AuditTrail::Backend < Struct.new(:transition_class, :owner_
   end
 
   def resolve_context(object, context, transition)
-    if object.method(context).arity != 0
+    # ---------------
+    # TODO: remove this check after we set a minimum version of Rails/ActiveRecord to 5.1+. At that time, the argument will be removed and the arity check will be enough. - rosskevin
+    # Don't send params to Rails 5+ associations because it triggers a ton of deprecation messages.
+    # @see https://github.com/state-machines/state_machines-audit_trail/issues/6
+    #  check if activerecord && the context is an association
+    skip_args = object.is_a?(::ActiveRecord::Base) && object.class.reflections.keys.include?(context.to_s)
+    # ---------------
+
+    if object.method(context).arity != 0 && !skip_args
       object.send(context, transition)
     else
       object.send(context)

data/lib/state_machines/audit_trail/backend/active_record.rb

@@ -1,13 +1,11 @@
 require 'state_machines-activerecord'
 
 class StateMachines::AuditTrail::Backend::ActiveRecord < StateMachines::AuditTrail::Backend
-  attr_accessor :context
-
-  def initialize(transition_class, owner_class, context = nil)
+  def initialize(transition_class, owner_class, options = {})
+    super
     @association = transition_class.to_s.tableize.split('/').last.to_sym
-    super transition_class, owner_class
-    self.context = context # FIXME: actually not sure why we need to do this, but tests fail otherwise. Something with super's Struct?
-    owner_class.has_many(@association, class_name: transition_class.to_s) unless owner_class.reflect_on_association(@association)
+    assoc_options = {class_name: transition_class.to_s}.merge(options.slice(:as))
+    owner_class.has_many(@association, **assoc_options) unless owner_class.reflect_on_association(@association)
   end
 
   def persist(object, fields)

data/lib/state_machines/audit_trail/transition_auditing.rb

@@ -12,6 +12,7 @@ module StateMachines::AuditTrail::TransitionAuditing
   #
   # options:
   #   - :class - custom state transition class
+  #   - :owner_class - the class which is to own the persisted transition objects
   #   - :context - methods to call/store in field of same name in the state transition class
   #   - :initial - if false, won't log null => initial state transition upon instantiation
   #
@@ -21,18 +22,21 @@ module StateMachines::AuditTrail::TransitionAuditing
       raise ":class option[#{options[:class]}] must be a class (not a string)." unless options[:class].is_a? Class
     end
     transition_class = options[:class] || default_transition_class
+    owner_class = options[:owner_class] || self.owner_class
 
     # backend implements #log to store transition information
-    @backend = StateMachines::AuditTrail::Backend.create_for(transition_class, self.owner_class, options[:context])
+    @backend = StateMachines::AuditTrail::Backend.create_for(transition_class, owner_class, options.slice(:context, :as))
 
     # Initial state logging can be turned off. Very useful for a model with multiple state_machines using a single TransitionState object for logging
     unless options[:initial] == false
       unless state_machine.action == nil
         # Log the initial transition from null => initial (upon object instantiation)
         state_machine.owner_class.after_initialize do |object|
-          current_state = object.send(state_machine.attribute)
-          if !current_state.nil?
-            state_machine.backend.log(object, OpenStruct.new(to: current_state))
+          if state_machine.backend.new_record? object
+            current_state = object.send(state_machine.attribute)
+            if !current_state.nil?
+              state_machine.backend.log(object, OpenStruct.new(namespace: state_machine.namespace, to: current_state))
+            end
           end
         end
       end

data/lib/state_machines/audit_trail/version.rb

@@ -1,5 +1,5 @@
 module StateMachines
   module AuditTrail
-    VERSION = '1.0.0'
+    VERSION = '2.0.2'
   end
 end

data/lib/state_machines/audit_trail_generator.rb

@@ -12,6 +12,7 @@ class StateMachines::AuditTrailGenerator < ::Rails::Generators::Base
   def create_model
     args = [transition_class_name,
             "#{source_model.demodulize.tableize.singularize}:references",
+            'namespace:string',
             'event:string',
             'from:string',
             'to:string',

data/spec/helpers/active_record.rb

@@ -6,6 +6,11 @@ ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':me
 class ARModelStateTransition < ActiveRecord::Base
   belongs_to :ar_model
 end
+
+class ARModelWithNamespaceFooStateTransition < ActiveRecord::Base
+  belongs_to :ar_model_with_namespace
+end
+
 class ARModelNoInitialStateTransition < ActiveRecord::Base
   belongs_to :ar_model_no_initial
 end
@@ -32,7 +37,7 @@ end
 
 class ARModel < ActiveRecord::Base
 
-  state_machine :state, initial: :waiting do # log initial state?
+  state_machine :state, initial: :waiting do
     audit_trail
 
     event :start do
@@ -47,7 +52,7 @@ end
 
 class ARModelNoInitial < ActiveRecord::Base
 
-  state_machine :state, initial: :waiting do # log initial state?
+  state_machine :state, initial: :waiting do
     audit_trail initial: false
 
     event :start do
@@ -59,9 +64,25 @@ class ARModelNoInitial < ActiveRecord::Base
     end
   end
 end
+
+class ARModelWithNamespace < ActiveRecord::Base
+
+  state_machine :foo_state, initial: :waiting, namespace: :foo do
+    audit_trail
+
+    event :start do
+      transition [:waiting, :stopped] => :started
+    end
+
+    event :stop do
+      transition :started => :stopped
+    end
+  end
+end
+
 #
 class ARModelWithContext < ActiveRecord::Base
-  state_machine :state, initial: :waiting do # log initial state?
+  state_machine :state, initial: :waiting do
     audit_trail context: :context
 
     event :start do
@@ -79,7 +100,7 @@ class ARModelWithContext < ActiveRecord::Base
 end
 
 class ARModelWithMultipleContext < ActiveRecord::Base
-  state_machine :state, initial: :waiting do # log initial state?
+  state_machine :state, initial: :waiting do
     audit_trail context: [:context, :second_context, :context_with_args]
 
     event :start do
@@ -150,14 +171,46 @@ class ARModelWithMultipleStateMachines < ActiveRecord::Base
   end
 end
 
-module SomeNamespace
+class ARResourceStateTransition < ActiveRecord::Base
+  belongs_to :resource, polymorphic: true
+end
+
+class ARFirstModelWithPolymorphicStateTransition < ActiveRecord::Base
+  state_machine :state, :initial => :pending do
+    audit_trail class: ARResourceStateTransition, as: :ar_resource
+
+    event :start do
+      transition :pending => :in_progress
+    end
+
+    event :finish do
+      transition :in_progress => :complete
+    end
+  end
+end
+
+class ARSecondModelWithPolymorphicStateTransition < ActiveRecord::Base
+  state_machine :state, :initial => :pending do
+    audit_trail class: ARResourceStateTransition, as: :ar_resource
+
+    event :start do
+      transition :pending => :in_progress
+    end
+
+    event :finish do
+      transition :in_progress => :complete
+    end
+  end
+end
+
+module SomeModule
   class ARModelStateTransition < ActiveRecord::Base
-    belongs_to :test_model
+    belongs_to :ar_model
   end
 
   class ARModel < ActiveRecord::Base
 
-    state_machine :state, initial: :waiting do # log initial state?
+    state_machine :state, initial: :waiting do
       audit_trail
 
       event :start do
@@ -174,9 +227,13 @@ end
 #
 # Generate tables
 #
-def create_model_table(owner_class, multiple_state_machines = false)
+def create_model_table(owner_class, multiple_state_machines = false, state_column = nil)
   ActiveRecord::Base.connection.create_table(owner_class.name.tableize) do |t|
-    t.string :state unless multiple_state_machines
+    if state_column.presence
+      t.string state_column
+    else
+      t.string :state unless multiple_state_machines
+    end
     t.string :type
 
     if multiple_state_machines
@@ -189,19 +246,21 @@ def create_model_table(owner_class, multiple_state_machines = false)
   end
 end
 
-create_model_table(ARModel)
-create_model_table(ARModelNoInitial)
-create_model_table(ARModelWithContext)
-create_model_table(ARModelWithMultipleContext)
-create_model_table(ARModelWithMultipleStateMachines, true)
 
+%w(ARModel ARModelNoInitial ARModelWithContext ARModelWithMultipleContext ARFirstModelWithPolymorphicStateTransition ARSecondModelWithPolymorphicStateTransition).each do |name|
+  create_model_table(name.constantize)
+end
+
+create_model_table(ARModelWithNamespace, false, :foo_state)
+create_model_table(ARModelWithMultipleStateMachines, true)
 
-def create_transition_table(owner_class, state, add_context = false)
-  class_name = "#{owner_class.name}#{state.to_s.camelize}Transition"
+def create_transition_table(owner_class_name, state, add_context: false, polymorphic: false)
+  class_name = "#{owner_class_name}#{state.to_s.camelize}Transition"
   ActiveRecord::Base.connection.create_table(class_name.tableize) do |t|
 
-    # t.references :"#{owner_class.name.pluralize.demodulize.tableize}"
-    t.integer owner_class.name.foreign_key
+    t.references "#{owner_class_name.demodulize.underscore}", index: false, polymorphic: polymorphic
+    # t.integer owner_class_name.foreign_key
+    t.string :namespace
     t.string :event
     t.string :from
     t.string :to
@@ -213,10 +272,14 @@ def create_transition_table(owner_class, state, add_context = false)
   end
 end
 
-create_transition_table(ARModel, :state)
-create_transition_table(ARModelNoInitial, :state)
-create_transition_table(ARModelWithContext, :state, true)
-create_transition_table(ARModelWithMultipleContext, :state, true)
-create_transition_table(ARModelWithMultipleStateMachines, :first)
-create_transition_table(ARModelWithMultipleStateMachines, :second)
-create_transition_table(ARModelWithMultipleStateMachines, :third)
+%w(ARModel ARModelNoInitial).each do |name|
+  create_transition_table(name, :state)
+end
+
+create_transition_table("ARModelWithNamespace", :foo_state, add_context: false)
+create_transition_table("ARModelWithContext", :state, add_context: true)
+create_transition_table("ARModelWithMultipleContext", :state, add_context: true)
+create_transition_table("ARModelWithMultipleStateMachines", :first)
+create_transition_table("ARModelWithMultipleStateMachines", :second)
+create_transition_table("ARModelWithMultipleStateMachines", :third)
+create_transition_table("ARResource", :state, polymorphic: true)

data/spec/helpers/mongoid.rb

@@ -9,6 +9,7 @@ class MongoidTestModelStateTransition
   include Mongoid::Timestamps
   belongs_to :mongoid_test_model
 
+  field :namespace, type: String
   field :event, type: String
   field :from,  type: String
   field :to,    type: String
@@ -19,6 +20,7 @@ class MongoidTestModelWithMultipleStateMachinesFirstTransition
   include Mongoid::Timestamps
   belongs_to :mongoid_test_model
 
+  field :namespace, type: String
   field :event, type: String
   field :from,  type: String
   field :to,    type: String
@@ -29,6 +31,7 @@ class MongoidTestModelWithMultipleStateMachinesSecondTransition
   include Mongoid::Timestamps
   belongs_to :mongoid_test_model
 
+  field :namespace, type: String
   field :event, type: String
   field :from,  type: String
   field :to,    type: String

data/spec/helpers/mongoid.yml

@@ -1,5 +1,5 @@
 test:
-  sessions:
+  clients:
     default:
       database: sm_audit_trail
       hosts:

data/spec/lib/state_machines/audit_trail/backend/active_record_spec.rb

@@ -9,20 +9,35 @@ require 'helpers/active_record'
 describe StateMachines::AuditTrail::Backend::ActiveRecord do
 
   context ':initial option' do
-    it 'default logs' do
-      target = ARModel.new
-      # initial transition is built but not saved
-      expect(target.new_record?).to be_truthy
-      expect(target.ar_model_state_transitions.count).to eq 0
-      target.save!
+    context 'default' do
+      it 'new object' do
+        target = ARModel.new
+        # initial transition is built but not saved
+        expect(target.new_record?).to be_truthy
+        expect(target.ar_model_state_transitions.count).to eq 0
+        target.save!
+
+        # initial transition is saved and should be present
+        expect(target.new_record?).to be_falsey
+        expect(target.ar_model_state_transitions.count).to eq 1
+        state_transition = target.ar_model_state_transitions.first
+        assert_transition state_transition, nil, nil, 'waiting'
+      end
 
-      # initial transition is saved and should be present
-      expect(target.new_record?).to be_falsey
-      expect(target.ar_model_state_transitions.count).to eq 1
-      state_transition = target.ar_model_state_transitions.first
-      expect(state_transition.from).to be_nil
-      expect(state_transition.to).to eq 'waiting'
-      expect(state_transition.event).to be_nil
+      it 'create object' do
+        target = ARModel.create!
+        # initial transition is saved and should be present
+        expect(target.new_record?).to be_falsey
+        expect(target.ar_model_state_transitions.count).to eq 1
+        state_transition = target.ar_model_state_transitions.first
+        assert_transition state_transition, nil, nil, 'waiting'
+
+        # ensure we don't have a second initial state transition logged (issue #4)
+        target = target.reload()
+        expect(target.ar_model_state_transitions.count).to eq 1
+        state_transition = target.ar_model_state_transitions.first
+        assert_transition state_transition, nil, nil, 'waiting'
+      end
     end
 
     it 'false skips log' do
@@ -38,6 +53,32 @@ describe StateMachines::AuditTrail::Backend::ActiveRecord do
     end
   end
 
+  context 'namespaced state_machine' do
+    it 'should log namespace' do
+      target = ARModelWithNamespace.create!
+
+      # initial transition is saved and should be present
+      expect(target.new_record?).to be_falsey
+      expect(target.ar_model_with_namespace_foo_state_transitions.count).to eq 1
+      state_transition = target.ar_model_with_namespace_foo_state_transitions.first
+      expect(state_transition.namespace).to eq 'foo'
+      expect(state_transition.from).to be_nil
+      expect(state_transition.to).to eq 'waiting'
+      expect(state_transition.event).to be_nil
+    end
+
+    it 'should not log namespace' do
+      target = ARModel.create!
+      expect(target.new_record?).to be_falsey
+      expect(target.ar_model_state_transitions.count).to eq 1
+      state_transition = target.ar_model_state_transitions.first
+      expect(state_transition.namespace).to be_nil
+      expect(state_transition.from).to be_nil
+      expect(state_transition.to).to eq 'waiting'
+      expect(state_transition.event).to be_nil
+    end
+  end
+
   context '#create_for' do
     it 'should be Backend::ActiveRecord' do
       backend = StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, ARModel)
@@ -49,13 +90,13 @@ describe StateMachines::AuditTrail::Backend::ActiveRecord do
       expect(ARModel.reflect_on_association(:ar_model_state_transitions).collection?).to be_truthy
     end
 
-    it 'should handle namespaced models' do
-      StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, SomeNamespace::ARModel)
-      expect(SomeNamespace::ARModel.reflect_on_association(:ar_model_state_transitions).collection?).to be_truthy
+    it 'should handle models within modules' do
+      StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, SomeModule::ARModel)
+      expect(SomeModule::ARModel.reflect_on_association(:ar_model_state_transitions).collection?).to be_truthy
     end
 
-    it 'should handle namespaced state transition model' do
-      StateMachines::AuditTrail::Backend.create_for(SomeNamespace::ARModelStateTransition, ARModel)
+    it 'should handle state transition models within modules' do
+      StateMachines::AuditTrail::Backend.create_for(SomeModule::ARModelStateTransition, ARModel)
       expect(ARModel.reflect_on_association(:ar_model_state_transitions).collection?).to be_truthy
     end
   end
@@ -106,7 +147,7 @@ describe StateMachines::AuditTrail::Backend::ActiveRecord do
 
     context 'wants to log a single context' do
       before(:each) do
-        StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, ARModelWithContext, :context)
+        StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, ARModelWithContext, context: :context)
       end
 
       let!(:target) { ARModelWithContext.create! }
@@ -120,7 +161,7 @@ describe StateMachines::AuditTrail::Backend::ActiveRecord do
 
     context 'wants to log multiple context fields' do
       before(:each) do
-        StateMachines::AuditTrail::Backend.create_for(ARModelWithMultipleContextStateTransition, ARModelWithMultipleContext, [:context, :second_context, :context_with_args])
+        StateMachines::AuditTrail::Backend.create_for(ARModelWithMultipleContextStateTransition, ARModelWithMultipleContext, context: [:context, :second_context, :context_with_args])
       end
 
       let!(:target) { ARModelWithMultipleContext.create! }
@@ -222,4 +263,26 @@ describe StateMachines::AuditTrail::Backend::ActiveRecord do
       expect { m.complete! }.not_to raise_error
     end
   end
+
+  context 'polymorphic' do
+    it 'creates polymorphic state transitions' do
+      m1 = ARFirstModelWithPolymorphicStateTransition.create!
+      m2 = ARSecondModelWithPolymorphicStateTransition.create!
+      m2.start!
+      m2.finish!
+
+      expect(m1.ar_resource_state_transitions.count).to eq(1)
+      expect(m2.ar_resource_state_transitions.count).to eq(3)
+      expect(ARResourceStateTransition.count).to eq(4)
+    end
+  end
+
+  private
+
+  def assert_transition(state_transition, event, from, to)
+    # expect(state_transition.namespace).to eq namespace
+    expect(state_transition.event).to eq event
+    expect(state_transition.from).to eq from
+    expect(state_transition.to).to eq to
+  end
 end

data/spec/lib/state_machines/audit_trail/backend/mongoid_spec.rb

@@ -1,98 +1,98 @@
-# reset integrations so that something like ActiveRecord is not loaded and conflicting
-require 'state_machines'
-StateMachines::Integrations.reset
-
-require 'spec_helper'
-require 'state_machines-mongoid'
-require 'helpers/mongoid'
-
-describe StateMachines::AuditTrail::Backend::Mongoid do
-
-  context '#create_for' do
-    it 'should create a Mongoid backend' do
-      backend = StateMachines::AuditTrail::Backend.create_for(MongoidTestModelStateTransition, MongoidTestModel)
-      expect(backend).to be_instance_of(StateMachines::AuditTrail::Backend::Mongoid)
-    end
-  end
-
-  context 'single state machine' do
-    let!(:target) { MongoidTestModel.create! }
-
-    it 'should populate all fields' do
-      target.start!
-      last_transition = MongoidTestModelStateTransition.where(:mongoid_test_model_id => target.id).last
-
-      expect(last_transition.event).to eq 'start'
-      expect(last_transition.from).to eq 'waiting'
-      expect(last_transition.to).to eq 'started'
-      expect(last_transition.created_at).to be_within(10.seconds).of(DateTime.now)
-    end
-
-    it 'should log multiple events' do
-      expect { target.start && target.stop && target.start }.to change(MongoidTestModelStateTransition, :count).by(3)
-    end
-
-    it 'do nothing on failed transition' do
-      expect { target.stop }.not_to change(MongoidTestModelStateTransition, :count)
-    end
-  end
-
-  context 'multiple state machines' do
-    let!(:target) { MongoidTestModelWithMultipleStateMachines.create! }
-
-    it 'should log a state transition for the affected state machine' do
-      expect { target.begin_first! }.to change(MongoidTestModelWithMultipleStateMachinesFirstTransition, :count).by(1)
-    end
-
-    it 'should not log a state transition for the unaffected state machine' do
-      expect { target.begin_first! }.not_to change(MongoidTestModelWithMultipleStateMachinesSecondTransition, :count)
-    end
-  end
-
-  context 'on an object with a state machine having an initial state' do
-    let(:target_class) { MongoidTestModelWithMultipleStateMachines }
-    let(:state_transition_class) { MongoidTestModelWithMultipleStateMachinesFirstTransition }
-
-    it 'should log a state transition for the inital state' do
-      expect { target_class.create! }.to change(state_transition_class, :count).by(1)
-    end
-
-    it 'should only set the :to state for the initial transition' do
-      target_class.create!
-      initial_transition = state_transition_class.last
-      expect(initial_transition.event).to be_nil
-      expect(initial_transition.from).to be_nil
-      expect(initial_transition.to).to eq 'beginning'
-      expect(initial_transition.created_at).to be_within(10.seconds).of(DateTime.now)
-    end
-  end
-
-  context 'on an object with a state machine not having an initial state' do
-    let(:target_class) { MongoidTestModelWithMultipleStateMachines }
-    let(:state_transition_class) { MongoidTestModelWithMultipleStateMachinesSecondTransition }
-
-    it 'should not log a transition when the object is created' do
-      expect { target_class.create! }.not_to change(state_transition_class, :count)
-    end
-
-    it 'should log a transition for the first event' do
-      expect { target_class.create.begin_second! }.to change(state_transition_class, :count).by(1)
-    end
-
-    it 'should not set a value for the :from state on the first transition' do
-      target_class.create.begin_second!
-      first_transition = state_transition_class.last
-      expect(first_transition.event).to eq 'begin_second'
-      expect(first_transition.from).to be_nil
-      expect(first_transition.to).to eq 'beginning_second'
-      expect(first_transition.created_at).to be_within(10.seconds).of(DateTime.now)
-    end
-  end
-
-  context 'on a class using STI' do
-    it 'should properly grab the class name from STI models' do
-      m = MongoidTestModelDescendant.create!
-      expect { m.start! }.not_to raise_error
-    end
-  end
-end
+# # reset integrations so that something like ActiveRecord is not loaded and conflicting
+# require 'state_machines'
+# StateMachines::Integrations.reset
+#
+# require 'spec_helper'
+# require 'state_machines-mongoid'
+# require 'helpers/mongoid'
+#
+# describe StateMachines::AuditTrail::Backend::Mongoid do
+#
+#   context '#create_for' do
+#     it 'should create a Mongoid backend' do
+#       backend = StateMachines::AuditTrail::Backend.create_for(MongoidTestModelStateTransition, MongoidTestModel)
+#       expect(backend).to be_instance_of(StateMachines::AuditTrail::Backend::Mongoid)
+#     end
+#   end
+#
+#   context 'single state machine' do
+#     let!(:target) { MongoidTestModel.create! }
+#
+#     it 'should populate all fields' do
+#       target.start!
+#       last_transition = MongoidTestModelStateTransition.where(:mongoid_test_model_id => target.id).last
+#
+#       expect(last_transition.event).to eq 'start'
+#       expect(last_transition.from).to eq 'waiting'
+#       expect(last_transition.to).to eq 'started'
+#       expect(last_transition.created_at).to be_within(10.seconds).of(DateTime.now)
+#     end
+#
+#     it 'should log multiple events' do
+#       expect { target.start && target.stop && target.start }.to change(MongoidTestModelStateTransition, :count).by(3)
+#     end
+#
+#     it 'do nothing on failed transition' do
+#       expect { target.stop }.not_to change(MongoidTestModelStateTransition, :count)
+#     end
+#   end
+#
+#   context 'multiple state machines' do
+#     let!(:target) { MongoidTestModelWithMultipleStateMachines.create! }
+#
+#     it 'should log a state transition for the affected state machine' do
+#       expect { target.begin_first! }.to change(MongoidTestModelWithMultipleStateMachinesFirstTransition, :count).by(1)
+#     end
+#
+#     it 'should not log a state transition for the unaffected state machine' do
+#       expect { target.begin_first! }.not_to change(MongoidTestModelWithMultipleStateMachinesSecondTransition, :count)
+#     end
+#   end
+#
+#   context 'on an object with a state machine having an initial state' do
+#     let(:target_class) { MongoidTestModelWithMultipleStateMachines }
+#     let(:state_transition_class) { MongoidTestModelWithMultipleStateMachinesFirstTransition }
+#
+#     it 'should log a state transition for the inital state' do
+#       expect { target_class.create! }.to change(state_transition_class, :count).by(1)
+#     end
+#
+#     it 'should only set the :to state for the initial transition' do
+#       target_class.create!
+#       initial_transition = state_transition_class.last
+#       expect(initial_transition.event).to be_nil
+#       expect(initial_transition.from).to be_nil
+#       expect(initial_transition.to).to eq 'beginning'
+#       expect(initial_transition.created_at).to be_within(10.seconds).of(DateTime.now)
+#     end
+#   end
+#
+#   context 'on an object with a state machine not having an initial state' do
+#     let(:target_class) { MongoidTestModelWithMultipleStateMachines }
+#     let(:state_transition_class) { MongoidTestModelWithMultipleStateMachinesSecondTransition }
+#
+#     it 'should not log a transition when the object is created' do
+#       expect { target_class.create! }.not_to change(state_transition_class, :count)
+#     end
+#
+#     it 'should log a transition for the first event' do
+#       expect { target_class.create.begin_second! }.to change(state_transition_class, :count).by(1)
+#     end
+#
+#     it 'should not set a value for the :from state on the first transition' do
+#       target_class.create.begin_second!
+#       first_transition = state_transition_class.last
+#       expect(first_transition.event).to eq 'begin_second'
+#       expect(first_transition.from).to be_nil
+#       expect(first_transition.to).to eq 'beginning_second'
+#       expect(first_transition.created_at).to be_within(10.seconds).of(DateTime.now)
+#     end
+#   end
+#
+#   context 'on a class using STI' do
+#     it 'should properly grab the class name from STI models' do
+#       m = MongoidTestModelDescendant.create!
+#       expect { m.start! }.not_to raise_error
+#     end
+#   end
+# end

data/spec/lib/state_machines/audit_trail_generator_spec.rb

@@ -10,7 +10,7 @@
 # describe StateMachines::AuditTrailGenerator, type: :generator do
 #
 #   destination File.expand_path('../../../../tmp', __FILE__)
-#   arguments %w(SomeNamespace::Subscription state)
+#   arguments %w(SomeModule::Subscription state)
 #
 #   before(:all) do
 #     prepare_destination
@@ -36,7 +36,7 @@
 #                                       end
 #                                       directory 'some_namespace' do
 #                                         file 'subscription_state_transition.rb' do
-#                                           contains 'class SomeNamespace::SubscriptionStateTransition'
+#                                           contains 'class SomeModule::SubscriptionStateTransition'
 #                                         end
 #                                       end
 #                                     end

data/state_machines-audit_trail.gemspec

@@ -22,12 +22,17 @@ Gem::Specification.new do |s|
   s.add_development_dependency('state_machines-mongoid')
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec', '>= 3.0.0')
-  s.add_development_dependency('activerecord', '>= 4.0.0')
-  s.add_development_dependency('sqlite3')
-  s.add_development_dependency('mongoid', '>= 4.0.0')
-  s.add_development_dependency('bson_ext')
+  s.add_development_dependency('activerecord', '>= 5.0.0')
+  if(defined?(JRUBY_VERSION))
+    s.add_development_dependency('activerecord-jdbcsqlite3-adapter')
+  else
+    s.add_development_dependency('sqlite3')
+  end
+  s.add_development_dependency('mongoid', '>= 6.0.0.beta')
+  s.add_development_dependency('bson')
   s.add_development_dependency('generator_spec')
-  s.add_development_dependency('rails', '>= 4.0.0')
+  s.add_development_dependency('rails', '>= 5.0.0')
+  s.add_development_dependency('appraisal', '~> 2.2.0')
 
   s.files = `git ls-files`.split($/).reject { |f| f =~ /^samples\// }
   s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: state_machines-audit_trail
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Kevin Ross
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-30 00:00:00.000000000 Z
+date: 2020-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: state_machines
@@ -88,14 +88,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -116,16 +116,16 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 6.0.0.beta
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 6.0.0.beta
 - !ruby/object:Gem::Dependency
-  name: bson_ext
+  name: bson
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -158,14 +158,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
 description: Log transitions on a state_machines to support auditing and business
   process analytics.
 email:
@@ -178,11 +192,19 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
 - ".travis.yml"
+- Appraisals
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- gemfiles/rails_5.0.gemfile
+- gemfiles/rails_5.1.gemfile
+- gemfiles/rails_5.2.gemfile
+- gemfiles/rails_6.0.gemfile
+- gemfiles/rails_edge.gemfile
 - lib/state_machines-audit_trail.rb
 - lib/state_machines/audit_trail.rb
 - lib/state_machines/audit_trail/backend.rb
@@ -220,8 +242,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Log transitions on a state_machines to support auditing and business process