stateful.rb 0.14.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '018501c0d47d3cb20bda391c184d7321e8fb090d9ef7042e5d949eadf2d655bf'
+  data.tar.gz: 7eee0d0b0dbd26a3d223b6b029b95cfdef37eec8a52d1d3248a136a71bf685c5
+SHA512:
+  metadata.gz: 1237f18c8b2899e7fc6d79f9f7a72bf69a1ffa727fd5bbd44ef77c62b75d1a9b8195a50f7dd49d62b851e5c5a2e1590167f8e4b0648f279051aa6d9b288cc781
+  data.tar.gz: 617ffddbc3d9011a50e8908cdcc8f0019ee230a17eab96c85496a9555e9a27c7a775de9457947db1b117d93e34e09cf8b76fb0bc33597d3c7b26c18b3c33e5e7

data/lib/Array/shuffle.rb

@@ -0,0 +1,18 @@
+# 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

data/lib/Stateful.rb

@@ -0,0 +1,61 @@
+# Stateful.rb
+# Stateful
+
+# 20150206
+# 0.14.0
+
+require_relative File.join('Stateful', 'ClassMethods')
+require_relative File.join('Stateful', 'InstanceMethods')
+
+module Stateful
+
+  class << self
+
+    def set_column_name(klass)
+      if defined?(::ActiveRecord::Base) && klass < ::ActiveRecord::Base
+        unless klass.instance_variable_get(:@stateful_column_name)
+          klass.instance_variable_set(:@stateful_column_name, 'current_state')
+        end
+      else
+        unless klass.instance_variable_get(:@stateful_variable_name)
+          klass.instance_variable_set(:@stateful_variable_name, 'current_state')
+        end
+      end
+    end
+
+    def load_persistence_class_methods(klass)
+      if defined?(::ActiveRecord::Base) && klass < ::ActiveRecord::Base
+        require_relative File.join('Stateful', 'ActiveRecord')
+        klass.extend(Stateful::ActiveRecord::ClassMethods)
+      else
+        require_relative File.join('Stateful', 'Poro')
+        klass.extend(Stateful::Poro::ClassMethods)
+      end
+    end
+
+    def define_instance_methods(klass)
+      if defined?(::ActiveRecord::Base) && klass < ::ActiveRecord::Base
+        klass.define_stateful_column_name_setter_method
+        klass.define_stateful_column_name_getter_method
+      else
+        klass.define_stateful_variable_name_setter_method
+        klass.define_stateful_variable_name_getter_method
+      end
+      klass.define_next_state_method
+      klass.define_transitions_method
+      klass.define_initial_stateQ_method
+      klass.define_final_stateQ_method
+    end
+
+    def extended(klass)
+      klass.extend(Stateful::ClassMethods)
+      klass.send(:include, Stateful::InstanceMethods)
+      set_column_name(klass)
+      load_persistence_class_methods(klass)
+      define_instance_methods(klass)
+    end
+    alias_method :included, :extended
+
+  end # class << self
+
+end

data/lib/Stateful/ActiveRecord.rb

@@ -0,0 +1,39 @@
+# Stateful/ActiveRecord.rb
+# Stateful::ActiveRecord
+
+require_relative File.join('..', 'Stateful')
+require_relative File.join('ActiveRecord', 'ClassMethods')   
+
+module Stateful
+  module ActiveRecord
+
+    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 define_instance_methods(klass)
+        klass.define_stateful_column_name_setter_method
+        klass.define_stateful_column_name_getter_method
+        klass.define_next_state_method
+        klass.define_transitions_method
+        klass.define_initial_stateQ_method
+        klass.define_final_stateQ_method
+      end
+
+      def extended(klass)
+        klass.extend(Stateful::ClassMethods)
+        klass.send(:include, Stateful::InstanceMethods)
+        set_column_name(klass)
+        klass.extend(Stateful::ActiveRecord::ClassMethods)
+        define_instance_methods(klass)
+      end
+      alias_method :included, :extended
+
+    end # class << self
+
+  end
+end

data/lib/Stateful/ActiveRecord/ClassMethods.rb

@@ -0,0 +1,87 @@
+# Stateful/ActiveRecord/ClassMethods.rb
+# Stateful::ActiveRecord::ClassMethods
+
+module Stateful
+  module ActiveRecord
+    module ClassMethods
+
+      def stateful_column_name=(stateful_column_name)
+        @stateful_column_name = stateful_column_name
+      end
+
+      def stateful_column_name
+        @stateful_column_name
+      end
+
+      def define_event_method(transition)
+        stateful_column_name = self.instance_variable_get(:@stateful_column_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)
+          self.send("#{stateful_column_name}=", next_state)
+        end
+      end
+
+      def define_status_boolean_method(state_name)
+        stateful_column_name = self.instance_variable_get(:@stateful_column_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)
+        define_method("#{stateful_column_name}=") do |state|
+          instance_variable_set("@#{stateful_column_name}", self.class.stateful_states.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)
+        define_method(stateful_column_name) do
+          instance_variable_set("@#{stateful_column_name}", self.class.stateful_states.find(read_attribute(stateful_column_name)))
+          if state = instance_variable_get("@#{stateful_column_name}")
+            state
+          else
+            initial_state = self.class.stateful_states.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|
+          next_state_name = self.send(stateful_column_name).next_state_name(event_name)
+          all_states.find(next_state_name)
+        end
+      end
+
+      def define_transitions_method
+        stateful_column_name = self.instance_variable_get(:@stateful_column_name)
+        define_method(:transitions) 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
+        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))
+        end
+      end
+
+    end
+  end
+end

data/lib/Stateful/ClassMethods.rb

@@ -0,0 +1,45 @@
+# Stateful/ClassMethods.rb
+# Stateful::ClassMethods
+
+require_relative 'States'
+
+module Stateful
+  module ClassMethods
+
+    def stateful_states
+      @stateful_states ||= Stateful::States.new(self)
+    end
+
+    # start DSL
+
+    def initial_state(state_name = nil, options = {}, &block)
+      stateful_states.initial_state(state_name, options, &block)
+    end
+
+    def final_state(*state_names)
+      stateful_states.final_state(*state_names)
+    end
+
+    def final_states(*state_names)
+      stateful_states.final_states(*state_names)
+    end
+
+    def state(state_name, options = {}, &block)
+      stateful_states.state(state_name, options, &block)
+    end
+
+    def stateful(options = {}, &block)
+      stateful_states.stateful(options, &block)
+    end
+
+    # end DSL
+
+    # boolean methods
+
+    def final_state?
+      !final_states.empty?
+    end
+    alias_method :has_final_state?, :final_state?
+
+  end
+end

data/lib/Stateful/InstanceMethods.rb

@@ -0,0 +1,30 @@
+# Stateful/InstanceMethods.rb
+# Stateful::InstanceMethods
+
+module Stateful
+  module InstanceMethods
+
+    def all_states
+      self.class.stateful_states
+    end
+
+    def initial_state
+      self.class.initial_state
+    end
+
+    def final_state
+      self.class.final_state
+    end
+
+    def final_states
+      self.class.final_states
+    end
+
+    # boolean methods
+
+    def active?
+      !final_state?
+    end
+
+  end
+end

data/lib/Stateful/Poro.rb

@@ -0,0 +1,39 @@
+# Stateful/Poro.rb
+# Stateful::Poro
+
+require_relative File.join('..', 'Stateful')
+require_relative File.join('Poro', 'ClassMethods')
+
+module Stateful
+  module Poro
+
+    class << self
+
+      def set_variable_name(klass)
+        unless klass.instance_variable_get(:@stateful_variable_name)
+          klass.instance_variable_set(:@stateful_variable_name, 'current_state')
+        end
+      end
+
+      def define_instance_methods(klass)
+        klass.define_stateful_variable_name_setter_method
+        klass.define_stateful_variable_name_getter_method
+        klass.define_next_state_method
+        klass.define_transitions_method
+        klass.define_initial_stateQ_method
+        klass.define_final_stateQ_method
+      end
+
+      def extended(klass)
+        klass.extend(Stateful::ClassMethods)
+        klass.send(:include, Stateful::InstanceMethods)
+        set_variable_name(klass)
+        klass.extend(Stateful::Poro::ClassMethods)
+        define_instance_methods(klass)
+      end
+      alias_method :included, :extended
+
+    end # class << self
+
+  end
+end

data/lib/Stateful/Poro/ClassMethods.rb

@@ -0,0 +1,83 @@
+# Stateful/Poro/ClassMethods.rb
+# Stateful::Poro::ClassMethods
+
+module Stateful
+  module Poro
+    module ClassMethods
+
+      def stateful_variable_name=(stateful_variable_name)
+        @stateful_variable_name = stateful_variable_name
+      end
+
+      def stateful_variable_name
+        @stateful_variable_name
+      end
+
+      def define_event_method(transition)
+        stateful_variable_name = self.instance_variable_get(:@stateful_variable_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)
+        end
+      end
+
+      def define_status_boolean_method(state_name)
+        stateful_variable_name = self.instance_variable_get(:@stateful_variable_name)
+        define_method("#{state_name}?") do
+          self.send(stateful_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))
+        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}")
+            state
+          else
+            initial_state = self.class.stateful_states.initial_state
+            self.send("#{stateful_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)
+        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
+        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
+        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))
+        end
+      end
+
+    end
+  end
+end

data/lib/Stateful/State.rb

@@ -0,0 +1,42 @@
+# Stateful/State.rb
+# Stateful::State
+
+require_relative File.join('..', 'Array', 'shuffle')
+require_relative 'Transition'
+
+module Stateful
+  class State
+
+    attr_accessor :name
+    attr_accessor :transitions
+
+    def initialize(name, options = {})
+      @name = name
+      @options = options
+      @transitions = []
+    end
+
+    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
+    end
+    alias_method :on, :event
+
+    def next_state_name(event_name)
+      if matching_transition = transitions.detect{|transition| transition.event_name == event_name}
+        matching_transition.next_state_name
+      end
+    end
+
+    private
+
+    def non_deterministic_event_ordering?
+      @options[:non_deterministic_event_ordering] ||
+        @options[:non_deterministic] ||
+          (@options[:deterministic] && !@options[:deterministic])
+    end
+
+  end
+end

data/lib/Stateful/States.rb

@@ -0,0 +1,101 @@
+# Stateful/States.rb
+# Stateful::States
+
+require_relative 'State'
+
+module Stateful
+  class States
+
+    attr_reader :all
+
+    def initialize(klass, options = {})
+      @klass = klass
+      @options = options
+      @all = []
+      @initial_state = nil
+      @final_states = []
+    end
+
+    def detect(candidate_state)
+      candidate_state_name = (
+        if candidate_state.is_a?(State)
+          candidate_state.name
+        else
+          candidate_state && candidate_state.to_sym
+        end
+      )
+      self.all.detect{|state| state.name == candidate_state_name}
+    end
+    alias_method :find, :detect
+
+    def missing?(state)
+      !detect(state)
+    end
+    alias_method :new_state?, :missing?
+
+    def present?(state)
+      !!detect(state)
+    end
+
+    def find_or_create(state_name, options = {})
+      find(state_name) || (
+        state = State.new(state_name, options)
+        all << state
+        state
+      )
+    end
+
+    def initial_state(state_name = nil, options = {}, &block)
+      if state_name
+        @initial_state = state(state_name, options, &block)
+      else
+        @initial_state
+      end
+    end
+
+    def final_state(*state_names)
+      final_states(*state_names).first
+    end
+    alias_method :final_state=, :final_state
+
+    def final_states(*state_names)
+      state_names = state_names.flatten
+      if !state_names.empty?
+        state_names.each do |state_name|
+          final_state = State.new(state_name)
+          @final_states << final_state
+          all << final_state
+        end
+        @final_states
+      else
+        @final_states
+      end
+    end
+
+    def state(state_name, options = {}, &block)
+      options.merge!(non_deterministic_event_ordering: global_non_deterministic_event_ordering?)
+      state = find_or_create(state_name, options)
+      state.instance_eval(&block) if block
+      state.transitions.each do |transition|
+        @klass.define_event_method(transition)
+      end
+      @klass.define_status_boolean_method(state_name)
+      state
+    end
+
+    def stateful(options = {}, &block)
+      @options = options
+      instance_eval(&block) if block
+    end
+
+    private
+
+    def global_non_deterministic_event_ordering?
+      @options[:global_non_deterministic_event_ordering] ||
+        @options[:non_deterministic_event_ordering] ||
+          @options[:non_deterministic] ||
+            (@options[:deterministic] && !@options[:deterministic])
+    end
+
+  end
+end

data/lib/Stateful/Transition.rb

@@ -0,0 +1,15 @@
+# Stateful/Transition.rb
+# Stateful::Transition
+
+module Stateful
+  class Transition
+
+    attr_reader :event_name
+    attr_reader :next_state_name
+
+    def initialize(event_name, next_state_name)
+      @event_name, @next_state_name = event_name, next_state_name
+    end
+
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: stateful.rb
+version: !ruby/object:Gem::Version
+  version: 0.14.1
+platform: ruby
+authors:
+- thoran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-02 00:00:00.000000000 Z
+dependencies: []
+description: Easily add state and manage it with Poro and ActiveRecord objects.
+email: code@thoran.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/Array/shuffle.rb
+- lib/Stateful.rb
+- lib/Stateful/ActiveRecord.rb
+- lib/Stateful/ActiveRecord/ClassMethods.rb
+- lib/Stateful/ClassMethods.rb
+- lib/Stateful/InstanceMethods.rb
+- lib/Stateful/Poro.rb
+- lib/Stateful/Poro/ClassMethods.rb
+- lib/Stateful/State.rb
+- lib/Stateful/States.rb
+- lib/Stateful/Transition.rb
+homepage: http://github.com/thoran/Stateful
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A Ruby state machine.
+test_files: []