queued_state_machine 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ee5afccef7f058cfd32f2c50641359447a77287c
+  data.tar.gz: 4125d5ef26e850d7854c3116f96e599cc1e1d0a0
+SHA512:
+  metadata.gz: 3102ab88418edb28b591044971e0d26b7ae3afc6fb1bb60479d1659f62af425a90932cf343d95767ed93e06ffaaf5912675a95ea930485c7af3ec97c43c9fc49
+  data.tar.gz: f33a5a56f2c9aec627c8a967b478d03007b0347a57c529d4ac4cecaae5fa1b8f4891567efc02dd872772880db5d0e1fb9f00d6c8fca34b7d24c0e05f3bf07e95

data/lib/queued_state_machine/invalid_transition.rb

@@ -0,0 +1,5 @@
+module QueuedStateMachine
+  class InvalidTransition < StandardError
+  
+  end
+end

data/lib/queued_state_machine.rb

@@ -0,0 +1,151 @@
+require 'queued_state_machine/invalid_transition'
+
+module QueuedStateMachine
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    
+    attr_reader :initial_state
+    
+    def inherited(subclass)
+      subclass.instance_variable_set("@states", instance_variable_get("@states").dup)
+      subclass.instance_variable_set("@initial_state", instance_variable_get("@initial_state"))
+      subclass.instance_variable_set("@transitions", instance_variable_get("@transitions").dup)
+      subclass.instance_variable_set("@callbacks", instance_variable_get("@callbacks").dup)
+    end
+    
+    def states
+      @states ||= []
+    end
+    
+    def transitions
+      @transitions ||= []
+    end
+    
+    def callbacks
+      @callbacks ||= []
+    end
+    
+    def state(name, initial: false)
+      unless transitions.empty? && callbacks.empty?
+        raise 'Error: all states must be defined before any transitions of callbacks'
+      end
+      name = clean_state(name)
+      self.initial_state = name if initial
+      states << name
+      nil
+    end
+    
+    def transition(from: nil, to: nil)
+      if block_given?
+        raise "Error: transitions do not accept blocks, use 'on_transition'"
+      end
+      from = clean_state_list(from)
+      to = clean_state_list(to)
+      missing_state = (from + to).find { |state| !states.include?(state) }
+      if missing_state
+        raise "Error: state #{missing_state} not defined"
+      end
+      transitions << {from: from, to: to}
+      nil
+    end
+    
+    def on_transition(from: nil, to: nil, &block)
+      unless block_given?
+        'Error: no callback defined'
+      end
+      from = clean_state_list(from)
+      to = clean_state_list(to)
+      missing_state = (from + to).find { |state| !states.include?(state) }
+      if missing_state
+        raise "Error: state #{missing_state} not defined"
+      end
+      callbacks << {from: from, to: to, callback: block}
+      nil
+    end
+    
+    def clean_state(name)
+      name.to_s
+    end
+    
+    def clean_state_list(arg)
+      case
+      when arg == nil
+        states
+      when arg.respond_to?(:to_a)
+        list = arg
+        list.map! {|name| clean_state(name) }
+        list
+      else
+        name = arg
+        [clean_state(name)]
+      end
+    end
+    
+    def initial_state
+      raise 'Error: no initial state set' unless @initial_state
+      @initial_state
+    end
+    
+    def initial_state=(name)
+      raise 'Error: initial state already set' if @initial_state
+      @initial_state = name
+    end
+    
+  end
+  
+  def initialize
+    super
+    @state = self.class.initial_state
+    @pending_transitions = []
+  end
+  
+  def to(state, quiet: false)
+    from = @state
+    to = self.class.clean_state(state)
+    @pending_transitions << {from: from, to: to, quiet: quiet}
+    return if @pending_transitions.length > 1
+    loop do
+      next_transition = @pending_transitions.first
+      break unless next_transition
+      @state = next_transition[:to]
+      unless next_transition[:quiet]
+        process_transition(next_transition[:from], next_transition[:to])
+      end
+      @pending_transitions.shift
+    end
+  end
+  
+  def quietly_to(state)
+    to(state, quiet: true)
+  end
+  
+  def at
+    @state
+  end
+  
+  def at?(arg)
+    list = self.class.clean_state_list(arg)
+    raise if list == nil
+    list.include?(@state)
+  end
+  
+  private
+  
+  def process_transition(from, to)
+    valid_transitions = self.class.transitions.select do |transition|
+      transition[:from].include?(from) && transition[:to].include?(to)
+    end
+    if valid_transitions.empty?
+      raise InvalidTransition, "Error: no valid transition from '#{from}' to '#{to}'"
+    end
+    valid_callbacks = self.class.callbacks.select do |transition|
+      transition[:from].include?(from) && transition[:to].include?(to)
+    end
+    valid_callbacks.each { |callback| instance_eval(&callback[:callback]) }
+  end
+  
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: queued_state_machine
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Rob Fors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-25 00:00:00.000000000 Z
+dependencies: []
+description: A state machine that supports queuing any callbacks that are triggered
+  during a callback.
+email: mail@robfors.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/queued_state_machine.rb
+- lib/queued_state_machine/invalid_transition.rb
+homepage: https://github.com/robfors/queued_state_machine
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A state machine supporting reentry.
+test_files: []