sequel-state-machine 1.0.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1eb11cc183e1cfcfc7917f505b02b0f801888492fcf73ac6538e5915972cc799
-  data.tar.gz: 355f305b70481b88cd306aed45e4bd6ec8b8706ecd921f17fb18e872e85ea36c
+  metadata.gz: 7ecbd578f38b3444f3e5174d6bee1fbceb3421eec1d2435a1d3435ec20904ed0
+  data.tar.gz: c336baa29efda7c18885264aae288e6fc15f975da155e87be320976be7ccb93d
 SHA512:
-  metadata.gz: e26ed08fbc26ece33859b8b68b1ce95573060437054ed1c2e7f69e751c80c5a9d0e29c0ad81ab2c2ec1985c54bcc0fd8327d940329868e7c0937b1baa0f4f64f
-  data.tar.gz: 32164513eb750973c18e54b73defeb9aa3e45635653725733ff4c1f0f1665693a2eecb569b2d749d04010c586c86bf44f20b8558e6c44f5df85ce9c73b47c8de
+  metadata.gz: e9718320cbc2646fd5e3dfdae80e98fda4c6ccd230643ac3301893cee210206400199359297c3e6cac5707b590cdcc065c225d93980ebce4cf3f5ae1b5b493fc
+  data.tar.gz: 666800f88b63defc4a2f336315c147eef1338f37574eacdcb2130c930784cbd63ba66cc6cd10df7ff2bbc3260d06315f3bc4686e855100ce577eb21ed2c4154a

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,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,52 +2,65 @@
 
 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.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.status
-        "expected that event #{event} would transition, but did not"
-      else
-        "expected that event #{event} would transition to #{@to} but is #{receiver.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.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
 
 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.1"
+    VERSION = "1.2.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-state-machine
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Lithic Tech
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-23 00:00:00.000000000 Z
+date: 2022-04-06 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.