wires 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20865bb4eb206ffbcbbf1213093615337bcfddb8
-  data.tar.gz: 765995fb8eaa1bda0dbf45f9cfd87317c17cd3f5
+  metadata.gz: d72f9190bfd10374aa6b7a6dd5b6514cda1cd439
+  data.tar.gz: 09da831c965785c1fa55faaf48f1276ecec12d2c
 SHA512:
-  metadata.gz: cbd2971bd9d192b39cc20f97b3f301eb8175ac25cb1548db7f0e5ffeb1461cf777dcf377ed700d3694f80b9f39bc3017ccf0bf7cb236141cbde96b99e233776b
-  data.tar.gz: c85542dec7dabf46d30a7108dd71a83c2fd3791dc9f1956555c6fc4ed623f411e9bf878d772f6dac6344f3a1307787ec65cb81bef0635c4c81845ab03de7a1d2
+  metadata.gz: 0187c7ade4378ebaa10f861e3e0f9c20a60b84ce319c914644b0a598c7274a8ee054c12708aab0843557152e66ae2adbbc13cf05fbbf7037d0072caa0e3ca023
+  data.tar.gz: c00baf917ecbfca83f43cbefac1877c1eecfb14043f4834863288cbf777ecb66c0c328d4dfd1a6701a74de2ab593d8d60ee1404fd92417bb3fad9635d4999fa1

data/lib/wires/event.rb

@@ -103,7 +103,7 @@ module Wires
           att = key.to_s
           obj.instance_variable_set("@#{att}", kwargs[key])
           class_eval("def #{att}; @#{att}; end")
-          class_eval("def #{att}=(val); @#{att}=val; end")
+          # class_eval("def #{att}=(val); @#{att}=val; end")
         end
         
         obj

data/lib/wires/hub.rb

@@ -6,8 +6,8 @@ module Wires
   # An Event Hub. Event/proc associations come in, and the procs 
   # get called in new threads in the order received
   class Hub
+    
     @queue = Queue.new
-    @state = [:dead, :alive, :dying][0]
     
     @child_threads      = Array.new
     @child_threads_lock = Mutex.new
@@ -18,13 +18,8 @@ module Wires
     # Operate on the metaclass as a type of singleton pattern
     class << self
       
-      def dead?;  @state==:dead  end
-      def alive?; @state==:alive end
-      def dying?; @state==:dying end
-      def state;  @state         end
-      
-      # Clear the Hub queue, but do not kill working threads
-      def clear;  @queue.clear   end
+      def dead?;  state==:dead  end
+      def alive?; state==:alive end
       
       ##
       # Start the Hub event loop (optional flags change thread behavior)
@@ -35,24 +30,13 @@ module Wires
       #               specified, the Hub event loop is run in a new thread, 
       #               which the main thread joins in at_exit.
       def run(*flags)
-        if dead? # Only run if not already alive or dying
-          
-          # If :blocking is not set, run in a new thread and join at_exit
-          if not (flags.include? :blocking)
-            @thread = Thread.new() do
-              self.send(:run_loop)
-            end
-            # Only join if main thread wasn't killed by an exception
-            at_exit { @thread.join if not $! }
-          
-          # If :blocking is set, run in main thread and block until Hub death
-          else self.send(:run_loop) end
-          
-        end
+        request_state :alive until alive?
         
-        sleep 0 # Yield to other threads
-        
-      nil end
+        # If :blocking, block now, else block at exit
+        (flags.include? :blocking)   ?
+          (join_hegemon_auto_thread) :
+          (at_exit { join_hegemon_auto_thread unless $! })
+      end
       
       ##
       # Kill the Hub event loop (optional flags change thread behavior)
@@ -61,9 +45,9 @@ module Wires
       # [+:finish_all+] Hub thread won't be done until all child threads done
       # [+:blocking+] calling thread won't be done until Hub thread is done
       def kill(*flags)
-        @finish_all = (flags.include? :finish_all)
-        @state=:dying
-        @thread.join if (dying? and flags.include? :blocking)
+        @please_finish_all = (flags.include? :finish_all)
+        @please_kill = true
+        block_until_state :dead if (flags.include? :blocking)
       nil end
       
       # Register hook to execute before kill - can call multiple times
@@ -91,28 +75,25 @@ module Wires
       nil end
       def <<(x); fire(x); end
       
+      def flush_queue
+        (process_item(@queue.shift) until @queue.empty?)
+      end
+      
+      
     private
-    
-      # Kill all currently working child threads
-      # Newly fired events could still queue up, 
-      # Waiting to be born until this thread is done killing
-      def kill_children
-        @child_threads_lock.synchronize do
-          until @child_threads.empty?
-            @child_threads.shift.exit
-          end
-        end
-      nil end
       
-      # Kill all currently working child threads
-      # Newly fired events could still queue up, 
-      # But they will be cleared out and never be born
-      def kill_children_and_clear
-        @child_threads_lock.synchronize do
-          until @child_threads.empty?
-            @child_threads.shift.exit
-          end
-          clear
+      
+      # Flush/run queue of [proc, retain]s, retaining those with retain==true
+      def run_hooks(hooks)
+        retained = Queue.new
+        while not hooks.empty?
+          proc, retain = hooks.shift
+          retained << [proc, retain] if retain
+          proc.call
+          flush_queue if alive?
+        end
+        while not retained.empty?
+          hooks << retained.shift
         end
       nil end
       
@@ -123,47 +104,33 @@ module Wires
           @child_threads_lock.synchronize do
             a_thread = @child_threads.shift
           end
+          flush_queue if alive?
           a_thread.join if a_thread
           sleep 0 # Yield to other threads
         end
       nil end
       
-      # Flush/run queue of [proc, retain]s, retaining those with retain==true
-      def run_hooks(queue)
-        retained = Queue.new
-        while not queue.empty?
-          proc, retain = queue.shift
-          retained << [proc, retain] if retain
-          proc.call
-        end
-        while not retained.empty?
-          queue << retained.shift
+      # Kill all currently working child threads
+      # Newly fired events could still queue up, 
+      # Waiting to be born until this thread is done killing
+      def kill_children
+        @child_threads_lock.synchronize do
+          until @child_threads.empty?
+            @child_threads.shift.exit
+          end
         end
       nil end
-    
-      # Run before_kill hooks, optionally join child threads, then die
-      def die
-        run_hooks(@before_kills)
-        join_children if @finish_all
-        @state = :dead
-      nil end
       
-      # Run main event loop, not finished until Hub is killed
-      def run_loop
-        @state = :alive
-          
-        while not dead?
-          if @queue.empty? then sleep(0)
-          else process_item(@queue.shift) end
-          
-          if dying?
-            die_thread ||= Thread.new { die }
+      # Kill all currently working child threads
+      # Newly fired events could still queue up, 
+      # But they will be cleared out and never be born
+      def kill_children_and_clear
+        @child_threads_lock.synchronize do
+          until @child_threads.empty?
+            @child_threads.shift.exit
           end
+          clear
         end
-        
-        run_hooks(@after_kills)
-        @finish_all = false
-        
       nil end
       
       def process_item(x)
@@ -178,28 +145,62 @@ module Wires
           
           # Start the new child thread
           @child_threads << Thread.new do
-            begin
-              waiting_thread.wakeup unless blocking or not waiting_thread
-              proc.call(event)
-              waiting_thread.wakeup if blocking and waiting_thread
-              
-            rescue Interrupt, SystemExit => e
-              @state = :dying
-              unhandled_exception(e)
-              
-            rescue Exception => e
-              unhandled_exception(e)
-            end
+            waiting_thread.wakeup unless blocking or not waiting_thread
+            proc.call(event)
+            waiting_thread.wakeup if blocking and waiting_thread
           end
-          
         end
-      
       nil end
       
-      def unhandled_exception(x)
-        $stderr.puts $!
-        $stderr.puts $@
-      nil end
     end
+    
+    
+    #***
+    # Initialize state machine properties
+    #***
+    class << self
+      include Hegemon
+      def state_machine_init
+        
+        impose_state :dead
+        
+        declare_state :dead do
+          # task { puts "I'm dead!" }
+          
+          transition_to :alive do
+            after { start_hegemon_auto_thread }
+          end
+        end
+        
+        declare_state :alive do
+          # task { puts "I'm alive!" }
+          # task { sleep 0.05 } 
+          task do
+            # puts "task #{Thread.current.inspect}"; 
+            if @queue.empty? then sleep(0)
+            else process_item(@queue.shift) end
+          end
+          
+          transition_to :dead do
+            condition {@please_kill}
+            
+            before { run_hooks @before_kills }
+            
+            before { join_children if @please_finish_all }
+            
+            after  { run_hooks @after_kills  }
+            
+            after  { @please_kill = false }
+            after  { @please_finish_all = false }
+            
+            after  { end_hegemon_auto_thread }
+            after  { do_state_tasks }
+          end
+        end
+        
+      end
+    end
+    state_machine_init
+    
   end
 end

data/lib/wires.rb

@@ -2,6 +2,7 @@ require 'set'
 require 'thread'
 require 'active_support/core_ext' # Convenience functions from Rails
 require 'threadlock' # Easily add re-entrant lock to instance methods
+require 'hegemon'    # State machine management
 
 require 'wires/expect_type'
 require 'wires/event'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-06 00:00:00.000000000 Z
+date: 2013-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: hegemon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement