hegemon 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3c4e4c6087e43a78b89a9b70561a2c53978eb66
-  data.tar.gz: 2ecc3d78169f174681623f0835ad590a896e202e
+  metadata.gz: 16c25ed67f2ba46414da653d229bd42fc2305bb6
+  data.tar.gz: 07eb0d874631e68ea5bca5457186bfa9b8d766bf
 SHA512:
-  metadata.gz: 2cbd7490ec74838d7ad5ac3c2808564490a4ec630813b3599d7a570efd6e3feb93d259db935a9ea6f94d85b3d6c9e15834ad2b8b650563fd8460c2eb8c12b1e8
-  data.tar.gz: d748f7d8650510f8ac56a9d8612d66cfa478b9b5402cf2ca50925c479776b4aa9fd7d0d0859516be86eb83db18789920d7714c56293160d2e9eaa58aa21fb87b
+  metadata.gz: 2420e9542dfdcc16a5a7bba5b5c00e13c181628a79c4e637450c31c38da86d06cc1ae571fc204ec86e3ed363acdb588a849ef442c816471c1cf111379c6abd63
+  data.tar.gz: a2bcef08cee2efe18568c88ae54a012035b8afa4d3ebba9f815bfce887ab71075d9b0c4d3122fb98bd23cfd6b4f1842570827eb2be6559a8366fa771c2bd26bf

data/lib/hegemon.rb

@@ -1 +1,223 @@
-require 'threadlock'
+require 'threadlock'
+
+Thread.abort_on_exception = true
+def puts(*args); $stdout.puts(*args); end
+
+module Hegemon
+  
+  #***
+  # Accessor functions
+  #***
+  
+  def state;      @_hegemon_state;                   end
+  def states;     @_hegemon_states.keys;             end
+  def state_obj;  @_hegemon_states[@_hegemon_state]; end
+  def state_objs; @_hegemon_states.clone;            end
+  
+  threadlock :state, :states, :state_obj, :state_objs, :lock=>:@_hegemon_lock
+  
+  #***
+  # Declarative functions
+  #***
+  # Run these inside of your object's #initialize method
+  #  to set the parameters of the state machine
+  # All user-provided action blocks will have the scope of the instance object
+  #  in which the state machine parameters are initialized, and all parameters
+  #  should be initialized in the same place (in #initialize, typically)
+  #***
+  
+  ##
+  # Bypass all transition requirements and actions to directly impose state +s+
+  # This should not be used in the public API except to set the initial state
+  def impose_state(s); @_hegemon_state = s; end
+  threadlock :impose_state, :lock=>:@_hegemon_lock
+  
+  ##
+  # Declare a state in the state machine
+  # [+state+] The state name to use, as a symbol
+  # [+&block+] The state's declarative block 
+  #  (refer to Declarative Functions of HegemonState)
+  def declare_state(state, &block)
+    @_hegemon_states ||= Hash.new
+    @_hegemon_states[state] = HegemonState.new(self, state, &block)
+  end
+  threadlock :declare_state, :lock=>:@_hegemon_lock
+  
+  # Attempt a transition from the current state to state +s+
+  def request_state(s, *flags)
+    return false unless @_hegemon_states[@_hegemon_state].transitions[s]
+    @_hegemon_states[@_hegemon_state].transitions[s].try(*flags)
+  end
+  threadlock :request_state, :lock=>:@_hegemon_lock
+  
+  # Check for relevant state updates and do.
+  #  Using :only_auto flag will ignore all transitions with auto_update false
+  def update_state(*flags)
+    return false unless @_hegemon_states[@_hegemon_state]
+    trans = @_hegemon_states[@_hegemon_state].transitions
+    trans = trans.select{|k,t| t.auto_update} if (flags.include? :only_auto)
+    trans.each {|k,t| return true if t.try}
+  false end
+  threadlock :update_state, :lock=>:@_hegemon_lock
+  
+  def block_until_state(s);
+    raise ArgumentError, "Cannot block until undefined state :#{s}" \
+      unless @_hegemon_states.keys.include? s
+    sleep 0 until @_hegemon_state==s
+  end
+  
+  def do_state_tasks(i=0)
+    return nil unless @_hegemon_states[@_hegemon_state]
+    @_hegemon_states[@_hegemon_state].do_tasks(i)
+  nil end
+  threadlock :do_state_tasks, :lock=>:@_hegemon_lock
+  
+  def iter_hegemon_auto_loop(i=0)
+    do_state_tasks(i)
+    update_state(:only_auto)
+  end
+  threadlock :iter_hegemon_auto_loop, :lock=>:@_hegemon_lock
+  
+  # Run the automatic hegemon thread
+  def start_hegemon_auto_thread
+    if (not @_hegemon_auto_thread) \
+    or (not @_hegemon_auto_thread.status)
+      
+      @_end_hegemon_auto_thread = false
+      @_hegemon_auto_thread = Thread.new do
+        i = 0
+        until @_end_hegemon_auto_thread
+          iter_hegemon_auto_loop(i)
+          i += 1
+        end
+      end
+    end
+  end
+  
+  def join_hegemon_auto_thread
+    @_hegemon_auto_thread.join if @_hegemon_auto_thread
+  end
+  
+  def end_hegemon_auto_thread
+    @_end_hegemon_auto_thread = true
+  end
+  threadlock :end_hegemon_auto_thread, :lock=>:@_hegemon_lock
+end
+
+
+class HegemonState
+  
+  attr_reader :state
+  
+  def initialize(object, state, &block)
+    
+    raise ScriptError, "HegemonState must be initialized with a block"\
+      unless block.is_a? Proc
+    
+    @object = object
+    @state  = state
+    
+    @tasks       = []
+    @transitions = Hash.new
+    
+    instance_eval(&block)
+  end
+  
+  def task(&block);  @tasks << block if block;  end
+  
+  def transition_to(state, &block)
+    @transitions[state] = HegemonTransition.new(@object, @state, state, &block)
+  end
+  
+  def do_tasks(i=0)
+    @tasks.each {|proc| @object.instance_exec(i,&proc) }
+  end
+  
+  def transitions; @transitions; end
+  
+  threadlock self.instance_methods-Object.instance_methods
+  
+end
+
+
+class HegemonTransition
+  
+  attr_reader :src_state, :dest_state
+  
+  def initialize(object, src_state, dest_state, &block)
+    
+    raise ScriptError, "HegemonTransition must be initialized with a block"\
+      unless block.is_a? Proc
+    
+    @object     = object
+    @src_state  = src_state
+    @dest_state = dest_state
+    
+    @conditions   = []
+    @sufficients  = []
+    @requirements = []
+    @befores      = []
+    @afters       = []
+    
+    @progress     = nil
+    @auto_update  = true
+    
+    instance_eval(&block)
+  end
+  
+  def condition  (&block);  @conditions   << block if block;  end
+  def sufficient (&block);  @sufficients  << block if block;  end
+  def requirement(&block);  @requirements << block if block;  end
+  def before     (&block);  @befores      << block if block;  end
+  def after      (&block);  @afters       << block if block;  end
+  
+  # Get or set the @auto_update value
+  def auto_update(val=:just_ask)
+    (val==:just_ask) ?
+      (@auto_update) :
+      (@auto_update = (true and val))
+  end
+  
+  def ready?(*flags)
+    return false unless @object.state==@src_state
+    return false if @progress
+    
+    result = (procs_and @requirements)
+    return result if (flags.include? :force)
+    
+    return result && ((procs_or @sufficients) or (procs_and @conditions))
+  end
+  
+  def try(*flags)
+    (ready?(*flags)) ? 
+      (perform; true) :
+      (false)
+  end
+  
+private
+  
+  def perform
+    @progress = :pre
+    procs_run(@befores)
+    @progress = :impose
+    @object.impose_state(@dest_state)
+    @progress = :post
+    procs_run(@afters)
+    @progress = nil
+  nil end
+  
+  def procs_run(list)
+    list.each {|proc| @object.instance_eval(&proc) }
+  nil end
+  
+  def procs_and(list)
+    list.each {|proc| return false if not @object.instance_eval(&proc)}
+  true end
+  
+  def procs_or(list)
+    list.each {|proc| return true if @object.instance_eval(&proc)}
+  false end
+  
+  threadlock self.instance_methods-Object.instance_methods
+  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hegemon
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-05 00:00:00.000000000 Z
+date: 2013-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: threadlock