stateful.rb 2.1.0 → 2.3.0

data/lib/Stateful/Poro/ClassMethods.rb

@@ -6,8 +6,8 @@ module Stateful
     module ClassMethods
       class << self
         def extended(klass)
-          klass.define_stateful_variable_name_setter_method
-          klass.define_stateful_variable_name_getter_method
+          klass.define_stateful_attribute_setter_method
+          klass.define_stateful_attribute_getter_method
           klass.define_next_state_method
           klass.define_transitions_method
           klass.define_initial_stateQ_method
@@ -15,15 +15,6 @@ module Stateful
         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
@@ -32,7 +23,7 @@ module Stateful
         @stateful_variable_name
       end
 
-      def variable_name_for_machine(machine_name = nil)
+      def stateful_attribute_name_for_machine(machine_name = nil)
         if machine_name
           "#{machine_name}_state"
         else
@@ -40,74 +31,25 @@ module Stateful
         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(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, machine_name: nil)
-        variable_name = variable_name_for_machine(machine_name)
-        define_method("#{state_name}?") do
-          self.send(variable_name).name == state_name
+      def define_stateful_attribute_setter_method(machine_name: nil)
+        attribute_name = stateful_attribute_name_for_machine(machine_name)
+        define_method("#{attribute_name}=") do |state|
+          instance_variable_set("@#{attribute_name}", self.class.stateful_state_machine(machine_name).find(state))
         end
       end
 
-      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(machine_name: nil)
-        variable_name = variable_name_for_machine(machine_name)
-        define_method(variable_name) do
-          if state = instance_variable_get("@#{variable_name}")
+      def define_stateful_attribute_getter_method(machine_name: nil)
+        attribute_name = stateful_attribute_name_for_machine(machine_name)
+        define_method(attribute_name) do
+          if state = instance_variable_get("@#{attribute_name}")
             state
           else
             initial_state = self.class.stateful_state_machine(machine_name).initial_state
-            self.send("#{variable_name}=", initial_state.name)
+            self.send("#{attribute_name}=", initial_state.name)
             initial_state
           end
         end
       end
-
-      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(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(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(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/Sequel/ClassMethods.rb

@@ -0,0 +1,59 @@
+# Stateful/Sequel/ClassMethods.rb
+# Stateful::Sequel::ClassMethods
+
+module Stateful
+  module Sequel
+    module ClassMethods
+      class << self
+        def extended(klass)
+          klass.define_stateful_attribute_setter_method
+          klass.define_stateful_attribute_getter_method
+          klass.define_next_state_method
+          klass.define_transitions_method
+          klass.define_initial_stateQ_method
+          klass.define_final_stateQ_method
+        end
+      end # class << self
+
+      def stateful_column_name=(stateful_column_name)
+        @stateful_column_name = stateful_column_name
+      end
+
+      def stateful_column_name
+        @stateful_column_name
+      end
+
+      def stateful_attribute_name_for_machine(machine_name = nil)
+        if machine_name
+          "#{machine_name}_state"
+        else
+          instance_variable_get(:@stateful_column_name)
+        end
+      end
+
+      def define_stateful_attribute_setter_method(machine_name: nil)
+        stateful_column_name = stateful_attribute_name_for_machine(machine_name)
+        define_method("#{stateful_column_name}=") do |state|
+          instance_variable_set("@#{stateful_column_name}", self.class.stateful_state_machine(machine_name).find(state))
+          self[stateful_column_name.to_sym] = instance_variable_get("@#{stateful_column_name}").name.to_s
+          self.save
+          instance_variable_get("@#{stateful_column_name}")
+        end
+      end
+
+      def define_stateful_attribute_getter_method(machine_name: nil)
+        stateful_column_name = stateful_attribute_name_for_machine(machine_name)
+        define_method(stateful_column_name) do
+          instance_variable_set("@#{stateful_column_name}", self.class.stateful_state_machine(machine_name).find(self[stateful_column_name.to_sym]))
+          if state = instance_variable_get("@#{stateful_column_name}")
+            state
+          else
+            initial_state = self.class.stateful_state_machine(machine_name).initial_state
+            self.send("#{stateful_column_name}=", initial_state.name)
+            initial_state
+          end
+        end
+      end
+    end
+  end
+end

data/lib/Stateful/Sequel.rb

@@ -0,0 +1,30 @@
+# Stateful/Sequel.rb
+# Stateful::Sequel
+
+require_relative 'ClassMethods'
+require_relative 'InstanceMethods'
+require_relative File.join('Sequel', 'ClassMethods')
+
+module Stateful
+  module Sequel
+
+    class << self
+
+      def set_column_name(klass)
+        unless klass.instance_variable_get(:@stateful_column_name)
+          klass.instance_variable_set(:@stateful_column_name, 'current_state')
+        end
+      end
+
+      def extended(klass)
+        klass.extend(Stateful::ClassMethods)
+        klass.send(:include, Stateful::InstanceMethods)
+        set_column_name(klass)
+        klass.extend(Stateful::Sequel::ClassMethods)
+      end
+      alias_method :included, :extended
+
+    end # class << self
+
+  end
+end

data/lib/Stateful/VERSION.rb

@@ -1,3 +1,3 @@
 module Stateful
-  VERSION = '2.1.0'
+  VERSION = '2.3.0'
 end

data/lib/Stateful.rb

@@ -9,6 +9,9 @@ module Stateful
       if Object.const_defined?(:ActiveRecord) && defined?(::ActiveRecord::Base) && klass < ::ActiveRecord::Base
         require_relative File.join('Stateful', 'ActiveRecord')
         klass.extend(Stateful::ActiveRecord)
+      elsif Object.const_defined?(:Sequel) && defined?(::Sequel::Model) && klass < ::Sequel::Model
+        require_relative File.join('Stateful', 'Sequel')
+        klass.extend(Stateful::Sequel)
       else
         require_relative File.join('Stateful', 'Poro')
         klass.extend(Stateful::Poro)

data/stateful.rb.gemspec

@@ -0,0 +1,42 @@
+require_relative './lib/Stateful/VERSION'
+
+class Gem::Specification
+  def development_dependencies=(gems)
+    gems.each{|gem| add_development_dependency(*gem)}
+  end
+end
+
+Gem::Specification.new do |spec|
+  spec.name = 'stateful.rb'
+  spec.version = Stateful::VERSION
+
+  spec.summary = "A Ruby state machine."
+  spec.description = "Easily add state to Poro, ActiveRecord, and Sequel objects."
+
+  spec.author = 'thoran'
+  spec.email = 'code@thoran.com'
+  spec.homepage = 'http://github.com/thoran/stateful'
+  spec.license = 'MIT'
+
+  # The required version of Ruby is this higher than it strictly needs to be solely because the migrations have been made to require AR 6.0, but otherwise this should work with much lower versions of Ruby and ActiveRecord, even down to 2.3 (or lower) and AR 3 (or lower).
+  spec.required_ruby_version = '>= 2.5'
+
+  spec.require_paths = ['lib']
+
+  spec.files = [
+    'stateful.rb.gemspec',
+    'CHANGELOG.md',
+    'Gemfile',
+    'README.md',
+    Dir['lib/**/*.rb'],
+    Dir['test/**/*.rb']
+  ].flatten
+
+  spec.development_dependencies = %w{
+    minitest
+    minitest-spec-context
+    activerecord
+    sequel
+    sqlite3
+  }
+end

data/test/ActiveRecord/WithColumnName.rb

@@ -0,0 +1,159 @@
+# test/ActiveRecord/WithColumnName.rb
+
+gem 'minitest'
+gem 'minitest-spec-context'
+
+require 'minitest/autorun'
+require 'minitest-spec-context'
+
+require_relative './test_helper'
+
+lib_dir = File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'Stateful'
+
+class CreateTableMachines < ActiveRecord::Migration[6.0]
+  def change
+    create_table :active_record_machine8s do |t|
+      t.string :status
+    end
+  end
+end
+
+class ActiveRecordMachine8 < ActiveRecord::Base
+  @stateful_column_name = 'status'
+
+  extend Stateful
+
+  initial_state :initial_state do
+    on :an_event => :next_state
+    on :another_event => :final_state
+  end
+
+  state :next_state do
+    on :yet_another_event => :final_state
+  end
+
+  final_state :final_state
+end
+
+CreateTableMachines.new.change
+
+describe Stateful::ActiveRecord do
+  let(:machine){ActiveRecordMachine8.create}
+
+  it "must have an initial state" do
+    _(machine.initial_state).wont_be_nil
+  end
+
+  it "must have a final state (if one has been specified)" do
+    if ActiveRecordMachine8.final_state?
+      _(machine.final_state).wont_be_nil
+    end
+  end
+
+  context "initial_state" do
+    it "must have an initial state before any events occur" do
+      _(machine.initial_state?).must_equal true
+    end
+
+    it "must have an initial state consistent with what is given" do
+      _(machine.initial_state).must_equal ActiveRecordMachine8.stateful_state_machine.initial_state
+    end
+
+    it "must have an initial state with name as per the name given" do
+      _(machine.initial_state.name).must_equal :initial_state
+    end
+
+    it "must not be in the final state (assuming that initial and final are different states)" do
+      _(machine.final_state?).must_equal false
+    end
+
+    it "must know what it's next state is given an event name" do
+      _(machine.next_state(:an_event)).must_equal ActiveRecordMachine8.stateful_state_machine.find(:next_state)
+      _(machine.next_state(:another_event)).must_equal ActiveRecordMachine8.stateful_state_machine.find(:final_state)
+    end
+
+    it "must have an intial state which has as set of transitions to other states" do
+      _(machine.transitions.class).must_equal Array
+    end
+
+    it "must have two transitions to other states" do
+      _(machine.transitions.size).must_equal 2
+    end
+
+    it "must know what transitions are available" do
+      _(machine.transitions.collect{|t| [t.event_name, t.next_state_name]}).must_equal [[:an_event, :next_state], [:another_event, :final_state]]
+    end
+
+    it "must be active" do
+      _(machine.active?).must_equal true
+    end
+  end
+
+  context "next_state" do
+    before do
+      machine.an_event
+    end
+
+    it "must not be in the initial state" do
+      _(machine.initial_state?).must_equal false
+    end
+
+    it "must not be in the final state" do
+      _(machine.final_state?).must_equal false
+    end
+
+    it "must be in the next_state state" do
+      _(machine.status.name).must_equal :next_state
+      _(machine.next_state?).must_equal true
+    end
+
+    it "must have a set of transitions to other states" do
+      _(machine.transitions.class).must_equal Array
+    end
+
+    it "must have one transition to other states" do
+      _(machine.transitions.size).must_equal 1
+    end
+
+    it "must know what transitions are available" do
+      _(machine.transitions.collect{|t| [t.event_name, t.next_state_name]}).must_equal [[:yet_another_event, :final_state]]
+    end
+
+    it "must be active" do
+      _(machine.active?).must_equal true
+    end
+  end
+
+  context "final_state" do
+    before do
+      machine.another_event
+    end
+
+    it "must have a final state" do
+      _(machine.final_state?).must_equal true
+    end
+
+    it "must have a final state consistent with what is given" do
+      _(machine.final_state).must_equal ActiveRecordMachine8.stateful_state_machine.final_state
+    end
+
+    it "must have a state with name as per the name given" do
+      _(machine.status.name).must_equal :final_state
+    end
+
+    it "must not be in the initial state (assuming that initial and final are different states)" do
+      _(machine.initial_state?).must_equal false
+    end
+
+    it "must have no transitions" do
+      _(machine.transitions.empty?).must_equal true
+    end
+
+    it "must not be active" do
+      _(machine.active?).must_equal false
+    end
+  end
+end

data/test/ActiveRecord/WithExplicitDeterministicEventOrdering.rb

@@ -0,0 +1,159 @@
+# test/ActiveRecord/WithExplicitDeterministicEventOrdering.rb
+
+gem 'minitest'
+gem 'minitest-spec-context'
+
+require 'minitest/autorun'
+require 'minitest-spec-context'
+
+require_relative './test_helper'
+
+lib_dir = File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'Stateful'
+
+class CreateTableMachines < ActiveRecord::Migration[6.0]
+  def change
+    create_table :active_record_machine5s do |t|
+      t.string :current_state
+    end
+  end
+end
+
+class ActiveRecordMachine5 < ActiveRecord::Base
+  extend Stateful
+
+  initial_state :initial_state, deterministic: true do
+    on :an_event => :next_state
+    on :another_event => :final_state
+  end
+
+  state :next_state do
+    on :yet_another_event => :final_state
+  end
+
+  final_state :final_state
+end
+
+CreateTableMachines.new.change
+
+describe Stateful::ActiveRecord do
+  let(:machine){ActiveRecordMachine5.create}
+
+  it "must have an initial state" do
+    _(machine.initial_state).wont_be_nil
+  end
+
+  it "must have a final state (if one has been specified)" do
+    if ActiveRecordMachine5.final_state?
+      _(machine.final_state).wont_be_nil
+    end
+  end
+
+  context "initial_state" do
+    it "must have an initial state before any events occur" do
+      _(machine.initial_state?).must_equal true
+    end
+
+    it "must have an initial state consistent with what is given" do
+      _(machine.initial_state).must_equal ActiveRecordMachine5.stateful_state_machine.initial_state
+    end
+
+    it "must have an initial state with name as per the name given" do
+      _(machine.initial_state.name).must_equal :initial_state
+    end
+
+    it "must not be in the final state (assuming that initial and final are different states)" do
+      _(machine.final_state?).must_equal false
+    end
+
+    it "must know what it's next state is given an event name" do
+      _(machine.next_state(:an_event)).must_equal ActiveRecordMachine5.stateful_state_machine.find(:next_state)
+      _(machine.next_state(:another_event)).must_equal ActiveRecordMachine5.stateful_state_machine.find(:final_state)
+    end
+
+    it "must have an intial state which has a collection of transitions to other states" do
+      _(machine.transitions.class).must_equal Array
+      _(machine.transitions.all?{|transition| transition.is_a?(Stateful::Transition)}).must_equal true
+    end
+
+    it "must have two transitions to other states" do
+      _(machine.transitions.size).must_equal 2
+    end
+
+    it "must know what transitions are available and in what order they are presented" do
+      _(machine.transitions.collect{|t| [t.event_name, t.next_state_name]}).must_equal [[:an_event, :next_state], [:another_event, :final_state]]
+    end
+
+    it "must be active" do
+      _(machine.active?).must_equal true
+    end
+  end
+
+  context "next_state" do
+    before do
+      machine.an_event
+    end
+
+    it "must not be in the initial state" do
+      _(machine.initial_state?).must_equal false
+    end
+
+    it "must not be in the final state" do
+      _(machine.final_state?).must_equal false
+    end
+
+    it "must be in the next_state state" do
+      _(machine.current_state.name).must_equal :next_state
+      _(machine.next_state?).must_equal true
+    end
+
+    it "must have a collection of transitions to other states" do
+      _(machine.transitions.class).must_equal Array
+      _(machine.transitions.all?{|transition| transition.is_a?(Stateful::Transition)}).must_equal true
+    end
+
+    it "must have one transition to other states" do
+      _(machine.transitions.size).must_equal 1
+    end
+
+    it "must know what transitions are available" do
+      _(machine.transitions.collect{|t| [t.event_name, t.next_state_name]}).must_equal [[:yet_another_event, :final_state]]
+    end
+
+    it "must be active" do
+      _(machine.active?).must_equal true
+    end
+  end
+
+  context "final_state" do
+    before do
+      machine.another_event
+    end
+
+    it "must have a final state" do
+      _(machine.final_state?).must_equal true
+    end
+
+    it "must have a final state consistent with what is given" do
+      _(machine.final_state).must_equal ActiveRecordMachine5.stateful_state_machine.final_state
+    end
+
+    it "must have a state with name as per the name given" do
+      _(machine.current_state.name).must_equal :final_state
+    end
+
+    it "must not be in the initial state (assuming that initial and final are different states)" do
+      _(machine.initial_state?).must_equal false
+    end
+
+    it "must have no transitions" do
+      _(machine.transitions.empty?).must_equal true
+    end
+
+    it "must not be active" do
+      _(machine.active?).must_equal false
+    end
+  end
+end