sequel-state-machine 1.1.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32bf94c0e52e6d2fcaf7593f02f4834f689ee462a378dfc7d561e3e29db79258
-  data.tar.gz: a99a5e2ccd052cecd228ccc7c702bde70b675b86afac2fbf2b69d95432a9b8b5
+  metadata.gz: 94b067e5d260a2c467a1f1b8b4ec206054c29ab7fc54a86d2b5a89cc7a6620b1
+  data.tar.gz: aea214e6ab04cb78cffc4d580ae1de70011d9f0052562aa3649c217447d9ae0b
 SHA512:
-  metadata.gz: 10d259cf6ff25cdabe78ef6699ff6fa9be62de332cd9c45901b5295be687159cbf10e7738426ab94c0f2f4f2c0af3cccf44d3ba371c026f30e00bb6677910747
-  data.tar.gz: 349b9378af67e386b705d9d1d6e26ca2a48ff953b322f1a47dc40da308ab240e289d1042b53acbaaf2525df408a9c05be5fd62c33b4986b28452a4d51351ced5
+  metadata.gz: 9e8ee131d5e6da8495c7fb998ca81fbfdb43f8a6b7feb52bb919011e51d2d79c38ca190ba12fbf3d866d4aaf0484ae5db7601f903aec162736abdea1f6f05187
+  data.tar.gz: de91701d5ae07856d516c64963cfb988b12333c1e2bcc929f29d37cabad1cc779929cc9d07216fd6af6afb8780e19a2714b40dbb497918b32ca0e1971ce0cd64

data/lib/sequel/plugins/state_machine.rb

@@ -2,6 +2,7 @@
 
 require "sequel"
 require "sequel/model"
+require "set"
 require "state_machines/sequel"
 
 module Sequel
@@ -14,19 +15,21 @@ module Sequel
       end
 
       def self.configure(model, opts={})
-        col = opts.is_a?(Symbol) ? opts : nil
+        (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 = col if col
+          @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
+        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)
@@ -37,71 +40,85 @@ module Sequel
             msg = "Model must extend StateMachines::MacroMethods and have one state_machine."
             raise InvalidConfiguration, msg
           end
-          if self.class.state_machines.length > 1
-            msg = "Cannot use sequel-state-machine with multiple state machines. " \
-                  "Please file an issue at https://github.com/lithictech/sequel-state-machine/issues " \
-                  "if you need this capability."
-            raise InvalidConfiguration, msg
+          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
 
-        private def state_machine_status
-          return self.send(self.state_machine_status_column)
-        end
-
-        def sequel_state_machine_status
-          return state_machine_status
+        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)
-          audlog = self.current_audit_log
+        def audit(message, reason: nil, machine: nil)
+          audlog = self.current_audit_log(machine: machine)
           if audlog.class.state_machine_messages_supports_array
             audlog.messages ||= []
             audlog.messages << message
@@ -110,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.state_machine_status,
-            to_state: self.state_machine_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,
@@ -159,10 +186,12 @@ 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_str = self.state_machine_status.to_s
+        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
-          event_obj = self.class.state_machine.events[event] or raise "Invalid event #{event}"
+          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|
               next unless (from = state_req[:from])
@@ -172,13 +201,25 @@ module Sequel
           return false
         end
 
-        def validates_state_machine
-          states = self.class.state_machine.states.map(&:value)
-          state = self.state_machine_status
+        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,
+          self.errors.add(self.state_machine_status_column(machine),
                           "state '#{state}' must be one of (#{states.sort.join(', ')})",)
         end
+
+        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
 
       module ClassMethods

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
@@ -52,8 +65,8 @@ module Sequel
 
       module InstanceMethods
         def failed?
-          from_state = self._get_mapped_column_value(:from_state)
-          to_state = self._get_mapped_column_value(: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
 
@@ -62,12 +75,25 @@ module Sequel
         end
 
         def full_message
-          msg = self._get_mapped_column_value(:messages)
+          msg = self.sequel_state_machine_get(:messages)
           return self.class.state_machine_messages_supports_array ? msg.join(", ") : msg
         end
 
-        def _get_mapped_column_value(col)
-          return self[self.class.state_machine_column_mappings[col]]
+        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

@@ -2,48 +2,60 @@
 
 require "rspec"
 
-RSpec::Matchers.define :transition_on do |event|
-  match do |receiver|
-    raise 'must provide a "to" state' if (@to || "").to_s.empty?
-    receiver.send(event, *@args)
-    @to == receiver.send(:state_machine_status)
-  end
+module StateMachines
+  module Sequel
+    module SpecHelpers
+      module_function def find_state_machine(receiver, event)
+        state_machine = receiver.class.state_machines.values.find { |sm| sm.events[event] }
+        raise ArgumentError, "receiver #{receiver.class} has no state machine for event #{event}" unless state_machine
+        return state_machine
+      end
 
-  chain :to do |to_state|
-    @to = to_state
-  end
+      RSpec::Matchers.define :transition_on do |event|
+        match do |receiver|
+          raise ArgumentError, "must use :to to provide a target state" if (@to || "").to_s.empty?
+          machine = StateMachines::Sequel::SpecHelpers.find_state_machine(receiver, event)
+          receiver.send(event, *@args)
+          current_status = receiver.send(machine.attribute)
+          @to == current_status
+        end
 
-  chain :with do |*args|
-    @args = args
-  end
+        chain :to do |to_state|
+          @to = to_state
+        end
 
-  chain :audit do
-    @audit = true
-  end
+        chain :with do |*args|
+          @args = args
+        end
+
+        chain :audit do
+          @audit = true
+        end
 
-  failure_message do |receiver|
-    msg =
-      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.state_machine_status}"
+        failure_message do |receiver|
+          status = receiver.send(StateMachines::Sequel::SpecHelpers.find_state_machine(receiver, event).attribute)
+          msg =
+            "expected that event #{event} would transition to #{@to} but is #{status}"
+          (msg += "\n#{receiver.audit_logs.map(&:inspect).join("\n")}") if @audit
+          msg
+        end
       end
-    (msg += "\n#{receiver.audit_logs.map(&:inspect).join("\n")}") if @audit
-    msg
-  end
-end
 
-RSpec::Matchers.define :not_transition_on do |event|
-  match do |receiver|
-    !receiver.send(event, *@args)
-  end
+      RSpec::Matchers.define :not_transition_on do |event|
+        match do |receiver|
+          !receiver.send(event, *@args)
+        end
 
-  chain :with do |*args|
-    @args = args
-  end
+        chain :with do |*args|
+          @args = args
+        end
 
-  failure_message do |receiver|
-    "expected that event #{event} would not transition, but did and is now #{receiver.state_machine_status}"
+        failure_message do |receiver|
+          status = receiver.send(StateMachines::Sequel::SpecHelpers.find_state_machine(receiver, event).attribute)
+          "expected that event #{event} would not transition, but did and is now #{status}"
+        end
+      end
+    end
   end
 end
 

data/lib/state_machines/sequel/version.rb

@@ -2,6 +2,6 @@
 
 module StateMachines
   module Sequel
-    VERSION = "1.1.0"
+    VERSION = "1.2.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-state-machine
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.2
 platform: ruby
 authors:
 - Lithic Tech
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-05 00:00:00.000000000 Z
+date: 2022-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec