stateful_model_rails 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 175a956c79dfaf1d4eac4f48154369a2c36467e810cb75a0674f330184429fa3
+  data.tar.gz: fe3c88e95de8cad9e9313e335c131296f923780b787b7f34bcbeff7121309af6
+SHA512:
+  metadata.gz: 37944551a657d3e516219dd6e97b16f6e684b99fc444324315f2c25cfe9c5152e5dafe03ca1595fc396113fec5646fe5c2c2e5e7fc020b2a13496519b5510669
+  data.tar.gz: a5cb4f7100d943cb29ec393c4a9465c72d0dc09010988ca1a170553bb0f743605c170dd275af5151ef410787cd0ec0b66c0996966e1f69828e5002e77f79b9b4

data/lib/stateful_model_rails/state_machine.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module StatefulModelRails::StateMachine
+  class State
+    class << self
+      attr_reader :before_leave_callbacks, :after_leave_callbacks, :before_enter_callbacks, :after_enter_callbacks
+    end
+
+    attr_reader :parent
+
+    def initialize(parent)
+      @parent = parent
+    end
+
+    def self.before_leave(&block)
+      @before_leave_callbacks ||= []
+      @before_leave_callbacks << block
+    end
+
+    def self.after_leave(&block)
+      @after_leave_callbacks ||= []
+      @after_leave_callbacks << block
+    end
+
+    def self.before_enter(&block)
+      @before_enter_callbacks ||= []
+      @before_enter_callbacks << block
+    end
+
+    def self.after_enter(&block)
+      @after_enter_callbacks ||= []
+      @after_enter_callbacks << block
+    end
+
+    def run_before_leave
+      return unless self.class.before_leave_callbacks
+
+      self.class.before_leave_callbacks.each { |b| parent.instance_exec(self, &b) }
+    end
+
+    def run_after_leave
+      return unless self.class.after_leave_callbacks
+
+      self.class.after_leave_callbacks.each { |b| parent.instance_exec(self, &b) }
+    end
+
+    def run_before_enter
+      return unless self.class.before_enter_callbacks
+
+      self.class.before_enter_callbacks.each { |b| parent.instance_exec(self, &b) }
+    end
+
+    def run_after_enter
+      return unless self.class.after_enter_callbacks
+
+      self.class.after_enter_callbacks.each { |b| parent.instance_exec(self, &b) }
+    end
+
+    def name
+      self.class.name
+    end
+  end
+
+  class StateMachineInternal
+    attr_reader :seen_states, :transition_map, :transition_callback, :field_name
+
+    def initialize(field_name)
+      @field_name = field_name
+      @seen_states = []
+      @transition_map = {}
+      @transition_callback = nil
+    end
+
+    def transition(event, from:, to:)
+      @transition_map[event] ||= []
+      Array(from).each do |from|
+        @transition_map[event] << StatefulModelRails::Transition.new(from, to)
+
+        @seen_states << from
+      end
+
+      @seen_states << to
+      @seen_states.uniq!
+    end
+
+    def record_transition_with(&block)
+      @transition_callback = block
+    end
+
+    def install_event_helpers!(base)
+      events = @transition_map.keys
+
+      events.each do |event|
+        fromtos = @transition_map[event]
+
+        base.instance_eval do
+          define_method(event) do |**kwargs|
+            with_lock do
+              matching_froms = fromtos.select { |fr| fr.from == state.class }
+
+              raise TooManyDestinationStates if matching_froms.length > 1
+              raise StatefulModelRails::NoMatchingTransition.new(state.name, event.to_s) if matching_froms.empty?
+
+              matching_from = matching_froms[0]
+
+              from_state = matching_from.from.new(self)
+              to_state = matching_from.to.new(self)
+
+              from_state.run_before_leave if from_state.respond_to?(:run_before_leave)
+              to_state.run_before_enter if to_state.respond_to?(:run_before_enter)
+
+              update!(self.class.state_machine_instance.field_name.to_sym => matching_from.to.name)
+              self.class.state_machine_instance.transition_callback&.call(matching_from.from.name, matching_from.to.name, **kwargs)
+
+              from_state.run_after_leave if from_state.respond_to?(:run_after_leave)
+              to_state.run_after_enter if to_state.respond_to?(:run_after_enter)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def self.included(base)
+    base.define_singleton_method(
+      :state_machine,
+      method(:included__state_machine)
+    )
+
+    base.define_method(
+      :state,
+      method(:included__state)
+    )
+
+    base.define_singleton_method(
+      :state_machine_instance,
+      method(:included__state_machine_instance)
+    )
+  end
+end
+
+def included__state_machine(opts = {}, &)
+  field_name = opts.fetch(:on, "state").to_s
+
+  @state_machine = StatefulModelRails::StateMachine::StateMachineInternal.new(field_name)
+  @state_machine.instance_eval(&)
+  @state_machine.install_event_helpers!(self)
+  @state_machine
+end
+
+def included__state
+  sm_instance = self.class.state_machine_instance
+  field_name = sm_instance.field_name
+
+  st = sm_instance.seen_states.detect do |sf|
+    sf.name.underscore == attributes[field_name].underscore
+  end
+
+  raise StatefulModelRails::MissingStateDefinition, attributes[field_name] if st.nil?
+
+  st.new(self)
+end
+
+def included__state_machine_instance
+  @state_machine
+end

data/lib/stateful_model_rails/transition.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class StatefulModelRails::Transition
+  attr_reader :from, :to
+
+  def initialize(from, to)
+    @from = from
+    @to = to
+  end
+
+  def ==(other)
+    from == other.from && to == other.to
+  end
+end

data/lib/stateful_model_rails/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module StatefulModelRails
+  VERSION = "0.2.0"
+end

data/lib/stateful_model_rails.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "stateful_model_rails/version"
+require "stateful_model_rails/state_machine"
+require "stateful_model_rails/transition"
+
+require "active_support/core_ext/string/inflections"
+
+module StatefulModelRails
+  class Error < StandardError; end
+
+  class MissingStateDefinition < Error
+    def initialize(missing_class_name)
+      @missing_class_name = missing_class_name
+
+      super()
+    end
+
+    def to_s
+      "Couldn't find class definition for state named #{@missing_class_name}"
+    end
+  end
+
+  class NoMatchingTransition < Error
+    def initialize(current_state, triggering_event)
+      @current_state = current_state
+      @triggering_event = triggering_event
+
+      super()
+    end
+
+    def to_s
+      "There is no event #{@triggering_event} from #{@current_state}"
+    end
+  end
+
+  class DirtyModel < Error
+    def to_s
+      "There are unsaved changes to this record that would be override by doing a state machine transition"
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: stateful_model_rails
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Ben Anderson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+description:
+email:
+- benanderson@acidic.co.nz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/stateful_model_rails.rb
+- lib/stateful_model_rails/state_machine.rb
+- lib/stateful_model_rails/transition.rb
+- lib/stateful_model_rails/version.rb
+homepage: https://github.com/bagedevimo/stateful-model-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bagedevimo/stateful-model-rails
+  source_code_uri: https://github.com/bagedevimo/stateful-model-rails
+  changelog_uri: https://github.com/bagedevimo/stateful-model-rails
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: A tiny library for making ActiveRecord models into state machines
+test_files: []