sequel-state-machine 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32bf94c0e52e6d2fcaf7593f02f4834f689ee462a378dfc7d561e3e29db79258
-  data.tar.gz: a99a5e2ccd052cecd228ccc7c702bde70b675b86afac2fbf2b69d95432a9b8b5
+  metadata.gz: 3f0c0bd5c716d726e9e8ba679d545038637a3ed7da8a569918e24725d0558021
+  data.tar.gz: dcba20e8cb5eb3fbcbad3e70e5e5d0662d3515c44ebb6fa033efc5ae4f1e7a02
 SHA512:
-  metadata.gz: 10d259cf6ff25cdabe78ef6699ff6fa9be62de332cd9c45901b5295be687159cbf10e7738426ab94c0f2f4f2c0af3cccf44d3ba371c026f30e00bb6677910747
-  data.tar.gz: 349b9378af67e386b705d9d1d6e26ca2a48ff953b322f1a47dc40da308ab240e289d1042b53acbaaf2525df408a9c05be5fd62c33b4986b28452a4d51351ced5
+  metadata.gz: 78367e0296561bc60d3474dad00650cf1865bd50ee8c96eef1e430c24da24b47ab9f2a70c21f2560a1417ec014b0437e4cbc374c276ab8f18a1f162f4e1dfe5c
+  data.tar.gz: 48c59a255b6d6c4736ceed4e75ab8f0bfe59363cab146ae989c2928d9560f829ea62da3cae3452a1006a6e19a7c8600ced96847ab9f453f74cc854cf51c39841

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,67 +40,81 @@ 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)
@@ -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

@@ -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.send(:state_machine_status)
+    @to == receiver.send(@machine || :sequel_state_machine_status)
+  end
+
+  chain :of_machine do |col|
+    @machine = col
   end
 
   chain :to do |to_state|

data/lib/state_machines/sequel/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel-state-machine
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Lithic Tech