stateful.rb 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3f4cfb8d236347a8d199abc2b7515fd4f5077d87b88e462a412a7cf86579749
-  data.tar.gz: 7b5d4ccd5763b8b811dad8dd8f8d98d61a1d54868ce047d28d6361d7d4efb016
+  metadata.gz: 5da7e8a527bd572e70442a09736ecd50fb6a16b4d3d9b6b23ccddf0630919b7b
+  data.tar.gz: 0254fcbc662dabddb91a94891c55f6e786d6b990845b15bdfebd1aa1a94e65c5
 SHA512:
-  metadata.gz: ce7f007acb38f9990ee27a0fe1c3fbaea93094317cf2449560b3c8198acf10940acbaa7a7033c6699fad7b1f19d1a4faf95965e3f2af98e9aa69e50eceeadeaa
-  data.tar.gz: 62960371a9e9fdc190bbfd97726a43e8e5a0a392becdec48278ded2c4acd6d00aed4a94466b82d1195f964923bd5cc1faa005a4cdda990237c3aadc59f91f2cf
+  metadata.gz: 8832fda98fcdedd0a931c7822d6144026ca053f79b840b6f28845bddb8e1bbfe14f5bf55ccf5e5389ea3d0d78b4ac38dc1d79311eaaebd1c47d1667aba565038
+  data.tar.gz: 30fa4829c8979de205b41c65174e4e033e00efbc7923b9dcb0b4e90ef1cb6f91eb6188783341bdc24ce4eec069b20ebe587a67dc24a617293fb7c7053f08b754

data/lib/Stateful/ActiveRecord/ClassMethods.rb

@@ -4,9 +4,7 @@
 module Stateful
   module ActiveRecord
     module ClassMethods
-
       class << self
-
         def extended(klass)
           klass.define_stateful_column_name_setter_method
           klass.define_stateful_column_name_getter_method
@@ -15,9 +13,17 @@ module Stateful
           klass.define_initial_stateQ_method
           klass.define_final_stateQ_method
         end
-
       end # class << self
 
+      def define_named_machine_methods(machine_name)
+        define_stateful_column_name_setter_method(machine_name: machine_name)
+        define_stateful_column_name_getter_method(machine_name: machine_name)
+        define_next_state_method(machine_name: machine_name)
+        define_transitions_method(machine_name: machine_name)
+        define_initial_stateQ_method(machine_name: machine_name)
+        define_final_stateQ_method(machine_name: machine_name)
+      end
+
       def stateful_column_name=(stateful_column_name)
         @stateful_column_name = stateful_column_name
       end
@@ -26,75 +32,86 @@ module Stateful
         @stateful_column_name
       end
 
-      def define_event_method(transition)
-        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
+      def column_name_for_machine(machine_name = nil)
+        if machine_name
+          "#{machine_name}_state"
+        else
+          instance_variable_get(:@stateful_column_name)
+        end
+      end
+
+      def define_event_method(transition, machine_name: nil)
+        stateful_column_name = column_name_for_machine(machine_name)
         define_method(transition.event_name) do
           next_state_name = self.send(stateful_column_name).next_state_name(transition.event_name)
-          next_state = self.class.stateful_states.find(next_state_name)
+          next_state = self.class.stateful_state_machine(machine_name).find(next_state_name)
           self.send("#{stateful_column_name}=", next_state)
         end
       end
 
-      def define_status_predicate_method(state_name)
-        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
+      def define_status_predicate_method(state_name, machine_name: nil)
+        stateful_column_name = column_name_for_machine(machine_name)
         define_method("#{state_name}?") do
           self.send(stateful_column_name).name == state_name
         end
       end
 
-      def define_stateful_column_name_setter_method
-        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
+      def define_stateful_column_name_setter_method(machine_name: nil)
+        stateful_column_name = column_name_for_machine(machine_name)
         define_method("#{stateful_column_name}=") do |state|
-          instance_variable_set("@#{stateful_column_name}", self.class.stateful_states.find(state))
+          instance_variable_set("@#{stateful_column_name}", self.class.stateful_state_machine(machine_name).find(state))
           write_attribute(stateful_column_name, instance_variable_get("@#{stateful_column_name}").name)
           self.save
           instance_variable_get("@#{stateful_column_name}")
         end
       end
 
-      def define_stateful_column_name_getter_method
-        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
+      def define_stateful_column_name_getter_method(machine_name: nil)
+        stateful_column_name = column_name_for_machine(machine_name)
         define_method(stateful_column_name) do
-          instance_variable_set("@#{stateful_column_name}", self.class.stateful_states.find(read_attribute(stateful_column_name)))
+          instance_variable_set("@#{stateful_column_name}", self.class.stateful_state_machine(machine_name).find(read_attribute(stateful_column_name)))
           if state = instance_variable_get("@#{stateful_column_name}")
             state
           else
-            initial_state = self.class.stateful_states.initial_state
+            initial_state = self.class.stateful_state_machine(machine_name).initial_state
             self.send("#{stateful_column_name}=", initial_state.name)
             initial_state
           end
         end
       end
 
-      def define_next_state_method
-        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
-        define_method(:next_state) do |event_name|
+      def define_next_state_method(machine_name: nil)
+        stateful_column_name = column_name_for_machine(machine_name)
+        method_name = machine_name ? "#{machine_name}_next_state" : :next_state
+        define_method(method_name) do |event_name|
           next_state_name = self.send(stateful_column_name).next_state_name(event_name)
-          all_states.find(next_state_name)
+          self.class.stateful_state_machine(machine_name).find(next_state_name)
         end
       end
 
-      def define_transitions_method
-        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
-        define_method(:transitions) do
+      def define_transitions_method(machine_name: nil)
+        stateful_column_name = column_name_for_machine(machine_name)
+        method_name = machine_name ? "#{machine_name}_transitions" : :transitions
+        define_method(method_name) do
           self.send(stateful_column_name).transitions
         end
       end
 
-      def define_initial_stateQ_method
-        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
-        define_method(:initial_state?) do
-          self.send(stateful_column_name) == initial_state
+      def define_initial_stateQ_method(machine_name: nil)
+        stateful_column_name = column_name_for_machine(machine_name)
+        method_name = machine_name ? "#{machine_name}_initial_state?" : :initial_state?
+        define_method(method_name) do
+          self.send(stateful_column_name) == self.class.stateful_state_machine(machine_name).initial_state
         end
       end
 
-      def define_final_stateQ_method
-        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
-        define_method(:final_state?) do
-          final_states.include?(self.send(stateful_column_name))
+      def define_final_stateQ_method(machine_name: nil)
+        stateful_column_name = column_name_for_machine(machine_name)
+        method_name = machine_name ? "#{machine_name}_final_state?" : :final_state?
+        define_method(method_name) do
+          self.class.stateful_state_machine(machine_name).final_states.include?(self.send(stateful_column_name))
         end
       end
-
     end
   end
 end

data/lib/Stateful/ClassMethods.rb

@@ -1,35 +1,52 @@
 # Stateful/ClassMethods.rb
 # Stateful::ClassMethods
 
-require_relative 'States'
+require_relative 'StateMachine'
 
 module Stateful
   module ClassMethods
+    def state_machines
+      @state_machines ||= {}
+    end
 
-    def stateful_states
-      @stateful_states ||= Stateful::States.new(self)
+    def stateful_state_machine(machine_name = nil)
+      if machine_name
+        state_machines[machine_name] ||= Stateful::StateMachine.new(self, machine_name: machine_name)
+      else
+        @stateful_state_machine ||= Stateful::StateMachine.new(self)
+      end
     end
 
     # start DSL
 
     def stateful(options = {}, &block)
-      stateful_states.stateful(options, &block)
+      stateful_state_machine.options = options unless options.empty?
+      class_eval(&block) if block
+    end
+
+    def state_machine(name, options = {}, &block)
+      unless state_machines.key?(name)
+        define_named_machine_methods(name)
+      end
+      sm = stateful_state_machine(name)
+      sm.options = options unless options.empty?
+      sm.instance_eval(&block) if block
     end
 
     def initial_state(state_name = nil, options = {}, &block)
-      stateful_states.initial_state(state_name, options, &block)
+      stateful_state_machine.initial_state(state_name, options, &block)
     end
 
     def state(state_name, options = {}, &block)
-      stateful_states.state(state_name, options, &block)
+      stateful_state_machine.state(state_name, options, &block)
     end
 
     def final_state(*state_names)
-      stateful_states.final_state(*state_names)
+      stateful_state_machine.final_state(*state_names)
     end
 
     def final_states(*state_names)
-      stateful_states.final_states(*state_names)
+      stateful_state_machine.final_states(*state_names)
     end
 
     # end DSL
@@ -37,9 +54,12 @@ module Stateful
     # predicate methods
 
     def final_state?
-      !final_states.empty?
+      if state_machines.empty?
+        !final_states.empty?
+      else
+        state_machines.all?{|_name, states| !states.final_states.empty?}
+      end
     end
     alias_method :has_final_state?, :final_state?
-
   end
 end

data/lib/Stateful/InstanceMethods.rb

@@ -3,28 +3,40 @@
 
 module Stateful
   module InstanceMethods
+    def state_machines
+      self.class.state_machines
+    end
+
+    def state_machine(name)
+      state_machines[name]
+    end
 
-    def all_states
-      self.class.stateful_states
+    def all_states(machine_name = nil)
+      self.class.stateful_state_machine(machine_name)
     end
 
-    def initial_state
-      self.class.initial_state
+    def initial_state(machine_name = nil)
+      self.class.stateful_state_machine(machine_name).initial_state
     end
 
-    def final_state
-      self.class.final_state
+    def final_state(machine_name = nil)
+      self.class.stateful_state_machine(machine_name).final_state
     end
 
-    def final_states
-      self.class.final_states
+    def final_states(machine_name = nil)
+      self.class.stateful_state_machine(machine_name).final_states
     end
 
     # predicate methods
 
-    def active?
-      !final_state?
+    def active?(machine_name = nil)
+      if machine_name
+        !send("#{machine_name}_final_state?")
+      elsif state_machines.empty?
+        !final_state?
+      else
+        state_machines.keys.any?{|name| !send("#{name}_final_state?")}
+      end
     end
-
   end
 end

data/lib/Stateful/Poro/ClassMethods.rb

@@ -4,9 +4,7 @@
 module Stateful
   module Poro
     module ClassMethods
-
       class << self
-
         def extended(klass)
           klass.define_stateful_variable_name_setter_method
           klass.define_stateful_variable_name_getter_method
@@ -15,9 +13,17 @@ module Stateful
           klass.define_initial_stateQ_method
           klass.define_final_stateQ_method
         end
-
       end # class << self
 
+      def define_named_machine_methods(machine_name)
+        define_stateful_variable_name_setter_method(machine_name: machine_name)
+        define_stateful_variable_name_getter_method(machine_name: machine_name)
+        define_next_state_method(machine_name: machine_name)
+        define_transitions_method(machine_name: machine_name)
+        define_initial_stateQ_method(machine_name: machine_name)
+        define_final_stateQ_method(machine_name: machine_name)
+      end
+
       def stateful_variable_name=(stateful_variable_name)
         @stateful_variable_name = stateful_variable_name
       end
@@ -26,71 +32,82 @@ module Stateful
         @stateful_variable_name
       end
 
-      def define_event_method(transition)
-        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
+      def variable_name_for_machine(machine_name = nil)
+        if machine_name
+          "#{machine_name}_state"
+        else
+          instance_variable_get(:@stateful_variable_name)
+        end
+      end
+
+      def define_event_method(transition, machine_name: nil)
+        variable_name = variable_name_for_machine(machine_name)
         define_method(transition.event_name) do
-          next_state_name = self.send(stateful_variable_name).next_state_name(transition.event_name)
-          next_state = self.class.stateful_states.find(next_state_name)
-          self.send("#{stateful_variable_name}=", next_state)
+          next_state_name = self.send(variable_name).next_state_name(transition.event_name)
+          next_state = self.class.stateful_state_machine(machine_name).find(next_state_name)
+          self.send("#{variable_name}=", next_state)
         end
       end
 
-      def define_status_predicate_method(state_name)
-        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
+      def define_status_predicate_method(state_name, machine_name: nil)
+        variable_name = variable_name_for_machine(machine_name)
         define_method("#{state_name}?") do
-          self.send(stateful_variable_name).name == state_name
+          self.send(variable_name).name == state_name
         end
       end
 
-      def define_stateful_variable_name_setter_method
-        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
-        define_method("#{stateful_variable_name}=") do |state|
-          instance_variable_set("@#{stateful_variable_name}", self.class.stateful_states.find(state))
+      def define_stateful_variable_name_setter_method(machine_name: nil)
+        variable_name = variable_name_for_machine(machine_name)
+        define_method("#{variable_name}=") do |state|
+          instance_variable_set("@#{variable_name}", self.class.stateful_state_machine(machine_name).find(state))
         end
       end
 
-      def define_stateful_variable_name_getter_method
-        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
-        define_method(stateful_variable_name) do
-          if state = instance_variable_get("@#{stateful_variable_name}")
+      def define_stateful_variable_name_getter_method(machine_name: nil)
+        variable_name = variable_name_for_machine(machine_name)
+        define_method(variable_name) do
+          if state = instance_variable_get("@#{variable_name}")
             state
           else
-            initial_state = self.class.stateful_states.initial_state
-            self.send("#{stateful_variable_name}=", initial_state.name)
+            initial_state = self.class.stateful_state_machine(machine_name).initial_state
+            self.send("#{variable_name}=", initial_state.name)
             initial_state
           end
         end
       end
 
-      def define_next_state_method
-        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
-        define_method(:next_state) do |event_name|
-          next_state_name = self.send(stateful_variable_name).next_state_name(event_name)
-          all_states.find(next_state_name)
+      def define_next_state_method(machine_name: nil)
+        variable_name = variable_name_for_machine(machine_name)
+        method_name = machine_name ? "#{machine_name}_next_state" : :next_state
+        define_method(method_name) do |event_name|
+          next_state_name = self.send(variable_name).next_state_name(event_name)
+          self.class.stateful_state_machine(machine_name).find(next_state_name)
         end
       end
 
-      def define_transitions_method
-        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
-        define_method(:transitions) do
-          self.send(stateful_variable_name).transitions
+      def define_transitions_method(machine_name: nil)
+        variable_name = variable_name_for_machine(machine_name)
+        method_name = machine_name ? "#{machine_name}_transitions" : :transitions
+        define_method(method_name) do
+          self.send(variable_name).transitions
         end
       end
 
-      def define_initial_stateQ_method
-        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
-        define_method(:initial_state?) do
-          self.send(stateful_variable_name) == initial_state
+      def define_initial_stateQ_method(machine_name: nil)
+        variable_name = variable_name_for_machine(machine_name)
+        method_name = machine_name ? "#{machine_name}_initial_state?" : :initial_state?
+        define_method(method_name) do
+          self.send(variable_name) == self.class.stateful_state_machine(machine_name).initial_state
         end
       end
 
-      def define_final_stateQ_method
-        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
-        define_method(:final_state?) do
-          final_states.include?(self.send(stateful_variable_name))
+      def define_final_stateQ_method(machine_name: nil)
+        variable_name = variable_name_for_machine(machine_name)
+        method_name = machine_name ? "#{machine_name}_final_state?" : :final_state?
+        define_method(method_name) do
+          self.class.stateful_state_machine(machine_name).final_states.include?(self.send(variable_name))
         end
       end
-
     end
   end
 end

data/lib/Stateful/State.rb

@@ -1,7 +1,6 @@
 # Stateful/State.rb
 # Stateful::State
 
-require_relative File.join('..', 'Array', 'shuffle')
 require_relative 'Transition'
 
 module Stateful
@@ -19,7 +18,7 @@ module Stateful
     def event(event)
       event_name, new_state = event.keys.first, event.values.first
       transitions << Transition.new(event_name, new_state)
-      transitions.shuffle if non_deterministic_event_ordering?
+      transitions.shuffle! if non_deterministic_event_ordering?
       transitions
     end
     alias_method :on, :event
@@ -35,8 +34,7 @@ module Stateful
     def non_deterministic_event_ordering?
       @options[:non_deterministic_event_ordering] ||
         @options[:non_deterministic] ||
-          (@options[:deterministic] && !@options[:deterministic])
+        (@options.key?(:deterministic) && !@options[:deterministic])
     end
-
   end
 end

data/lib/Stateful/{States.rb → StateMachine.rb}

@@ -1,15 +1,20 @@
-# Stateful/States.rb
-# Stateful::States
+# Stateful/StateMachine.rb
+# Stateful::StateMachine
 
 require_relative 'State'
 
 module Stateful
-  class States
+  class StateMachine
 
-    attr_reader :all
+    attr_accessor :options
+    attr_reader(
+      :all,
+      :machine_name
+    )
 
-    def initialize(klass, options = {})
+    def initialize(klass, machine_name: nil, options: {})
       @klass = klass
+      @machine_name = machine_name
       @options = options
       @all = []
       @initial_state = nil
@@ -65,6 +70,7 @@ module Stateful
           final_state = State.new(state_name)
           @final_states << final_state
           all << final_state
+          @klass.define_status_predicate_method(state_name, machine_name: @machine_name)
         end
         @final_states
       else
@@ -77,25 +83,20 @@ module Stateful
       state = find_or_create(state_name, options)
       state.instance_eval(&block) if block
       state.transitions.each do |transition|
-        @klass.define_event_method(transition)
+        @klass.define_event_method(transition, machine_name: @machine_name)
       end
-      @klass.define_status_predicate_method(state_name)
+      @klass.define_status_predicate_method(state_name, machine_name: @machine_name)
       state
     end
 
-    def stateful(options = {}, &block)
-      @options = options
-      instance_eval(&block) if block
-    end
-
     private
 
     def global_non_deterministic_event_ordering?
+      @options ||= {}
       @options[:global_non_deterministic_event_ordering] ||
         @options[:non_deterministic_event_ordering] ||
-          @options[:non_deterministic] ||
-            (@options[:deterministic] && !@options[:deterministic])
+        @options[:non_deterministic] ||
+        (@options.key?(:deterministic) && !@options[:deterministic])
     end
-
   end
 end

data/lib/Stateful/VERSION.rb

@@ -1,5 +1,3 @@
 module Stateful
-
-  VERSION = '1.0.1'
-
+  VERSION = '2.0.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: stateful.rb
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - thoran
 bindir: bin
 cert_chain: []
-date: 2026-02-16 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -52,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -71,7 +71,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/Array/shuffle.rb
 - lib/Stateful.rb
 - lib/Stateful/ActiveRecord.rb
 - lib/Stateful/ActiveRecord/ClassMethods.rb
@@ -80,7 +79,7 @@ files:
 - lib/Stateful/Poro.rb
 - lib/Stateful/Poro/ClassMethods.rb
 - lib/Stateful/State.rb
-- lib/Stateful/States.rb
+- lib/Stateful/StateMachine.rb
 - lib/Stateful/Transition.rb
 - lib/Stateful/VERSION.rb
 homepage: http://github.com/thoran/Stateful

data/lib/Array/shuffle.rb

@@ -1,18 +0,0 @@
-# Array/shuffle.rb
-# Array#shuffle
-
-# 20130922
-# 0.3.0
-
-# Description: Reorders an array randomly.
-
-# Changes since 0.2:
-# 1. Removed the aliases to their own files.
-
-class Array
-
-  def shuffle
-    sort_by{rand}
-  end
-
-end