sequel-state-machine 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75e3b94c74a1a1c835374f9e6be8d51c84b62d24cc7fd205f00ee325e1dde15a
-  data.tar.gz: 44fcd2ffd47a5ade52a4c9eda0f6bc86f8b5991f8d9e7cbf7cf9fe0194ba8aa1
+  metadata.gz: 3f0c0bd5c716d726e9e8ba679d545038637a3ed7da8a569918e24725d0558021
+  data.tar.gz: dcba20e8cb5eb3fbcbad3e70e5e5d0662d3515c44ebb6fa033efc5ae4f1e7a02
 SHA512:
-  metadata.gz: 38a3c446b7b00f3a80b1257a37a0705712bc93e397963378709b0bc289aa8e85d372d869e53c94ae439a1ab83c3b507cb07af0ebe5049abd89e9c8c76088e382
-  data.tar.gz: 7a7da89ec5c83001e726c90dd83e52b973754528a71d9a360c78ea2a1bb9a09ae9dc47c965e5962d156c38fd85a052c0ac56d7f29607e8689564f8cd11b0aec0
+  metadata.gz: 78367e0296561bc60d3474dad00650cf1865bd50ee8c96eef1e430c24da24b47ab9f2a70c21f2560a1417ec014b0437e4cbc374c276ab8f18a1f162f4e1dfe5c
+  data.tar.gz: 48c59a255b6d6c4736ceed4e75ab8f0bfe59363cab146ae989c2928d9560f829ea62da3cae3452a1006a6e19a7c8600ced96847ab9f453f74cc854cf51c39841

data/lib/sequel/plugins/state_machine.rb

@@ -2,56 +2,119 @@
 
 require "sequel"
 require "sequel/model"
+require "set"
 require "state_machines/sequel"
 
 module Sequel
   module Plugins
     module StateMachine
+      class InvalidConfiguration < RuntimeError; end
+
+      def self.apply(_model, _opts={})
+        nil
+      end
+
+      def self.configure(model, opts={})
+        (opts = {status_column: opts}) if opts.is_a?(Symbol)
+        model.instance_eval do
+          # See state_machine_status_column.
+          # We must defer defaulting the value in case the plugin
+          # comes ahead of the state  machine (we can see a valid state machine,
+          # but the attribute/name will always be :state, due to some configuration
+          # order of operations).
+          @sequel_state_machine_status_column = opts[:status_column] if opts[:status_column]
+          @sequel_state_machine_audit_logs_association = opts[:audit_logs_association] || :audit_logs
+        end
+      end
+
       module InstanceMethods
+        private def state_machine_status_column(machine=nil)
+          return machine if machine
+          col = self.class.instance_variable_get(:@sequel_state_machine_status_column)
+          return col unless col.nil?
+          if self.respond_to?(:_state_value_attr)
+            self.class.instance_variable_set(:@sequel_state_machine_status_column, self._state_value_attr)
+            return self._state_value_attr
+          end
+          if !self.class.respond_to?(:state_machines) || self.class.state_machines.empty?
+            msg = "Model must extend StateMachines::MacroMethods and have one state_machine."
+            raise InvalidConfiguration, msg
+          end
+          if self.class.state_machines.length > 1 && machine.nil?
+            msg = "You must provide the :machine keyword argument when working multiple state machines."
+            raise ArgumentError, msg
+          end
+          self.class.instance_variable_set(:@sequel_state_machine_status_column, self.class.state_machine.attribute)
+        end
+
+        def sequel_state_machine_status(machine=nil)
+          return self.send(self.state_machine_status_column(machine))
+        end
+
         def new_audit_log
-          audit_log_assoc = self.class.association_reflections[:audit_logs]
-          model = Kernel.const_get(audit_log_assoc[:class_name])
-          return model.new
+          assoc_name = self.class.instance_variable_get(:@sequel_state_machine_audit_logs_association)
+          unless (audit_log_assoc = self.class.association_reflections[assoc_name])
+            msg = "Association for audit logs '#{assoc_name}' does not exist. " \
+                  "Your model must have 'one_to_many :audit_logs' for its audit log lines, " \
+                  "or pass the :audit_logs_association parameter to the plugin to define its association name."
+            raise InvalidConfiguration, msg
+          end
+          audit_log_cls = audit_log_assoc[:class] || Kernel.const_get(audit_log_assoc[:class_name])
+          return audit_log_cls.new
         end
 
-        def current_audit_log
-          if @current_audit_log.nil?
+        def current_audit_log(machine: nil)
+          @current_audit_logs ||= {}
+          alog = @current_audit_logs[machine]
+          if alog.nil?
             StateMachines::Sequel.log(self, :debug, "preparing_audit_log", {})
-            @current_audit_log = self.new_audit_log
-            @current_audit_log.reason = ""
+            alog = self.new_audit_log
+            if machine
+              machine_name_col = alog.class.state_machine_column_mappings[:machine_name]
+              unless alog.respond_to?(machine_name_col)
+                msg = "Audit logs must have a :machine_name field for multi-machine models or if specifying :machine."
+                raise InvalidConfiguration, msg
+              end
+              alog.sequel_state_machine_set(:machine_name, machine)
+            end
+            @current_audit_logs[machine] = alog
+            alog.sequel_state_machine_set(:reason, "")
           end
-          return @current_audit_log
+          return alog
         end
 
         def commit_audit_log(transition)
-          StateMachines::Sequel.log(self, :debug, "committing_audit_log", {transition: transition})
-          current = self.current_audit_log
+          machine = self.class.state_machines.length > 1 ? transition.machine.name : nil
+          StateMachines::Sequel.log(
+            self, :debug, "committing_audit_log", {transition: transition, state_machine: machine},
+          )
+          current = self.current_audit_log(machine: machine)
 
           last_saved = self.audit_logs.find do |a|
-            a.event == transition.event.to_s &&
-              a.from_state == transition.from &&
-              a.to_state == transition.to
+            a.sequel_state_machine_get(:event) == transition.event.to_s &&
+              a.sequel_state_machine_get(:from_state) == transition.from &&
+              a.sequel_state_machine_get(:to_state) == transition.to
           end
           if last_saved
             StateMachines::Sequel.log(self, :debug, "updating_audit_log", {audit_log_id: last_saved.id})
-            last_saved.update(
+            last_saved.update(**last_saved.sequel_state_machine_map_columns(
               at: Time.now,
               actor: StateMachines::Sequel.current_actor,
               messages: current.messages,
               reason: current.reason,
-            )
+            ))
           else
             StateMachines::Sequel.log(self, :debug, "creating_audit_log", {})
-            current.set(
+            current.set(**current.sequel_state_machine_map_columns(
               at: Time.now,
               actor: StateMachines::Sequel.current_actor,
               event: transition.event.to_s,
               from_state: transition.from,
               to_state: transition.to,
-            )
+            ))
             self.add_audit_log(current)
           end
-          @current_audit_log = nil
+          @current_audit_logs[machine] = nil
         end
 
         def audit(message, reason: nil)
@@ -64,21 +127,31 @@ module Sequel
             audlog.messages += (audlog.messages.empty? ? message : (message + "\n"))
           end
           audlog.reason = reason if reason
+          return audlog
         end
 
-        def audit_one_off(event, messages, reason: nil)
+        def audit_one_off(event, messages, reason: nil, machine: nil)
           messages = [messages] unless messages.respond_to?(:to_ary)
           audlog = self.new_audit_log
-          audlog.set(
+          mapped_values = audlog.sequel_state_machine_map_columns(
             at: Time.now,
             event: event,
-            from_state: self.status,
-            to_state: self.status,
+            from_state: self.sequel_state_machine_status(machine),
+            to_state: self.sequel_state_machine_status(machine),
             messages: audlog.class.state_machine_messages_supports_array ? messages : messages.join("\n"),
             reason: reason || "",
             actor: StateMachines::Sequel.current_actor,
+            machine_name: machine,
           )
-          self.add_audit_log(audlog)
+          audlog.set(mapped_values)
+          return self.add_audit_log(audlog)
+        end
+
+        # Return audit logs for the given state machine name.
+        # Only useful for multi-state-machine models.
+        def audit_logs_for(machine)
+          lines = self.send(self.class.instance_variable_get(:@sequel_state_machine_audit_logs_association))
+          return lines.select { |ln| ln.sequel_state_machine_get(:machine_name) == machine.to_s }
         end
 
         # Send event with arguments inside of a transaction, save the changes to the receiver,
@@ -113,26 +186,39 @@ module Sequel
         end
 
         # Return true if the given event can be transitioned into by the current state.
-        def valid_state_path_through?(event)
-          current_state = self.send(self._state_value_attr).to_sym
-          event_obj = self.class.state_machine.events[event] or raise "Invalid event #{event}"
+        def valid_state_path_through?(event, machine: nil)
+          current_state_str = self.sequel_state_machine_status(machine).to_s
+          current_state_sym = current_state_str.to_sym
+          sm = find_state_machine(machine)
+          event_obj = sm.events[event] or
+            raise ArgumentError, "Invalid event #{event} (available #{sm.name} events: #{sm.events.keys.join(', ')})"
           event_obj.branches.each do |branch|
             branch.state_requirements.each do |state_req|
-              return true if state_req[:from]&.matches?(current_state)
+              next unless (from = state_req[:from])
+              return true if from.matches?(current_state_str) || from.matches?(current_state_sym)
             end
           end
           return false
         end
 
-        def _state_value_attr
-          return @_state_value_attr ||= self.class.state_machine.attribute
+        def validates_state_machine(machine: nil)
+          state_machine = find_state_machine(machine)
+          states = state_machine.states.map(&:value)
+          state = self.sequel_state_machine_status(state_machine.attribute)
+          return if states.include?(state)
+          self.errors.add(self.state_machine_status_column(machine),
+                          "state '#{state}' must be one of (#{states.sort.join(', ')})",)
         end
 
-        def validates_state_machine
-          states = self.class.state_machine.states.map(&:value)
-          state = self[self._state_value_attr]
-          return if states.include?(state)
-          self.errors.add(self._state_value_attr, "status '#{state}' must be one of (#{states.sort.join(', ')})")
+        private def find_state_machine(machine)
+          machines = self.class.state_machines
+          raise InvalidConfiguration, "no state machines defined" if machines.empty?
+          if machine
+            m = machines[machine]
+            raise ArgumentError, "no state machine named #{machine}" if m.nil?
+            return m
+          end
+          return machines.first[1]
         end
       end
 

data/lib/sequel/plugins/state_machine_audit_log.rb

@@ -6,26 +6,39 @@ require "sequel/model"
 module Sequel
   module Plugins
     module StateMachineAuditLog
+      DEFAULT_COLUMN_MAPPINGS = {
+        at: :at,
+        event: :event,
+        to_state: :to_state,
+        from_state: :from_state,
+        reason: :reason,
+        messages: :messages,
+        actor_id: :actor_id,
+        actor: :actor,
+        machine_name: :machine_name,
+      }.freeze
       DEFAULT_OPTIONS = {
         messages_supports_array: :undefined,
-        column_mappings: {
-          at: :at,
-          event: :event,
-          to_state: :to_state,
-          from_state: :from_state,
-          reason: :reason,
-          messages: :messages,
-          actor_id: :actor_id,
-        }.freeze,
+        column_mappings: DEFAULT_COLUMN_MAPPINGS,
       }.freeze
       def self.configure(model, opts=DEFAULT_OPTIONS)
         opts = DEFAULT_OPTIONS.merge(opts)
-        model.state_machine_column_mappings = opts[:column_mappings]
+        colmap = opts[:column_mappings]
+        actor_key_mismatch = (colmap.key?(:actor) && !colmap.key?(:actor_id)) ||
+          (!colmap.key?(:actor) && colmap.key?(:actor_id))
+        if actor_key_mismatch
+          msg = "Remapping columns :actor and :actor_id must both be supplied"
+          raise Sequel::Plugins::StateMachine::InvalidConfiguration, msg
+        end
+        colmap = DEFAULT_COLUMN_MAPPINGS.merge(colmap)
+        model.state_machine_column_mappings = colmap
         msgarray = opts[:messages_supports_array] || true
         if msgarray == :undefined
           msgcol = model.state_machine_column_mappings[:messages]
-          dbt = model.db_schema[msgcol][:db_type]
-          msgarray = dbt.include?("json") || dbt.include?("[]")
+          if model.db_schema && model.db_schema[msgcol]
+            dbt = model.db_schema[msgcol][:db_type]
+            msgarray = dbt.include?("json") || dbt.include?("[]")
+          end
         end
         model.state_machine_messages_supports_array = msgarray
       end
@@ -36,14 +49,14 @@ module Sequel
 
       module DatasetMethods
         def failed
-          colmap = self.state_machine_column_mappings
+          colmap = self.model.state_machine_column_mappings
           tostate_col = colmap[:to_state]
           fromstate_col = colmap[:from_state]
           return self.where(tostate_col => fromstate_col)
         end
 
         def succeeded
-          colmap = self.state_machine_column_mappings
+          colmap = self.model.state_machine_column_mappings
           tostate_col = colmap[:to_state]
           fromstate_col = colmap[:from_state]
           return self.exclude(tostate_col => fromstate_col)
@@ -52,13 +65,35 @@ module Sequel
 
       module InstanceMethods
         def failed?
-          colmap = self.state_machine_column_mappings
-          return colmap[:from_state] == colmap[:to_state]
+          from_state = self.sequel_state_machine_get(:from_state)
+          to_state = self.sequel_state_machine_get(:to_state)
+          return from_state == to_state
         end
 
         def succeeded?
-          colmap = self.state_machine_column_mappings
-          return colmap[:from_state] != colmap[:to_state]
+          return !self.failed?
+        end
+
+        def full_message
+          msg = self.sequel_state_machine_get(:messages)
+          return self.class.state_machine_messages_supports_array ? msg.join(", ") : msg
+        end
+
+        def sequel_state_machine_get(unmapped)
+          return self[self.class.state_machine_column_mappings[unmapped]]
+        end
+
+        def sequel_state_machine_set(unmapped, value)
+          self[self.class.state_machine_column_mappings[unmapped]] = value
+        end
+
+        def sequel_state_machine_map_columns(**kw)
+          # We may pass in a machine_name of nil when we are using single-state-machine models.
+          # In this case, we assume the audit logs don't have a machine_name column,
+          # so always remove the column if the machine is nil.
+          kw.delete(:machine_name) if kw[:machine_name].nil?
+          mappings = self.class.state_machine_column_mappings
+          return kw.transform_keys { |k| mappings[k] or raise KeyError, "field #{k} unmapped in #{mappings}" }
         end
       end
     end

data/lib/state_machines/sequel/spec_helpers.rb

@@ -4,9 +4,15 @@ require "rspec"
 
 RSpec::Matchers.define :transition_on do |event|
   match do |receiver|
-    raise 'must provide a "to" state' if (@to || "").to_s.empty?
+    raise ArgumentError, "must use :to to provide a target state" if (@to || "").to_s.empty?
+    raise ArgumentError, "must use :of_machine for use with multiple state machines" if
+      @machine.nil? && receiver.class.state_machines.length > 1
     receiver.send(event, *@args)
-    @to == receiver.status
+    @to == receiver.send(@machine || :sequel_state_machine_status)
+  end
+
+  chain :of_machine do |col|
+    @machine = col
   end
 
   chain :to do |to_state|
@@ -23,10 +29,10 @@ RSpec::Matchers.define :transition_on do |event|
 
   failure_message do |receiver|
     msg =
-      if @to == receiver.status
+      if @to == receiver.state_machine_status
         "expected that event #{event} would transition, but did not"
       else
-        "expected that event #{event} would transition to #{@to} but is #{receiver.status}"
+        "expected that event #{event} would transition to #{@to} but is #{receiver.state_machine_status}"
       end
     (msg += "\n#{receiver.audit_logs.map(&:inspect).join("\n")}") if @audit
     msg
@@ -43,11 +49,12 @@ RSpec::Matchers.define :not_transition_on do |event|
   end
 
   failure_message do |receiver|
-    "expected that event #{event} would not transition, but did and is now #{receiver.status}"
+    "expected that event #{event} would not transition, but did and is now #{receiver.state_machine_status}"
   end
 end
 
 RSpec.shared_examples "a state machine with audit logging" do |event, to_state|
+  let(:machine) { raise NotImplementedError, "must override let(:machine)" }
   it "logs transitions" do
     expect(machine).to transition_on(event).to(to_state)
     expect(machine.audit_logs).to contain_exactly(

data/lib/state_machines/sequel/version.rb

@@ -2,6 +2,6 @@
 
 module StateMachines
   module Sequel
-    VERSION = "1.0.0"
+    VERSION = "1.2.0"
   end
 end

data/lib/state_machines/sequel.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "state_machines"
+
 module StateMachines
   module Sequel
     class CurrentActorAlreadySet < StateMachines::Error; end
@@ -11,11 +13,12 @@ module StateMachines
         @event = event
         @object = obj
         msg = "#{obj.class}[#{obj.id}] failed to transition on #{event}"
-        if obj.respond_to?(:audit_logs) && obj.audit_logs.present?
+        if obj.respond_to?(:audit_logs) && !obj.audit_logs.empty?
           @audit_log = obj.audit_logs.max_by(&:id)
-          msg += ": #{@audit_log.messages.last}"
+          msg += ": #{@audit_log.full_message}"
+          msg = msg.tr("\n", " ").strip
         end
-        super(msg)
+        super(obj, msg)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-state-machine
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Lithic Tech
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-06 00:00:00.000000000 Z
+date: 2022-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   sequel-state-machine hooks together the excellent Ruby Sequel ORM to
   the state-machines library, with auditing and other tools.