wires 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eac9a387ed62e4acf7fc95260c323ace017c0f01
-  data.tar.gz: 97b7e1f9b746f68cd801d293bc126427df8e819f
+  metadata.gz: b10bb4a5abcff971b03e3ed715141508e21059b8
+  data.tar.gz: b2e95646c96b287a988ed2f0608b7b7159bce712
 SHA512:
-  metadata.gz: d423c7af695a85c07f48e6b0e5d1ba5be178205f09bb5588ea550fd40409ec775708959f64a1335a3ab72a6dff42f6a67d70834d5cb023bd04669ea1d2267594
-  data.tar.gz: f98fa6910fc0bd8418f8c8421bc25a48fb183e93689aa9dcd5134d03c5cfccb9a97f6128758bfa32d459e0a4e466f1f17c6c96d91a8f1497e1d0f68593e5201e
+  metadata.gz: b92ae83348fd8024b84324ab06d7f73978ffc516738201519e49898dd2ebd8469529792f99dbf7e3a4d1a0d26eb49bcace82e42cf4dabad279490b9d91c8ba70
+  data.tar.gz: 788c6c1ef24826e7b94661f0b5a7db4f30bcd83584e48c41c6438bd0e900f54dd7ad441702629723783c3218b66d2883b3edc0baa5eeab7aa4b1f9a5af8e17fe

data/lib/wires.rb

@@ -1,6 +1,8 @@
 require 'set'
 require 'thread'
+require 'active_support/core_ext' # For time convenience functions
 
 require 'wires/events'
 require 'wires/hub'
-require 'wires/channels'
+require 'wires/channels'
+require 'wires/time'

data/lib/wires/hub.rb

@@ -6,68 +6,104 @@ def puts(x) $stdout.puts(x) end
 # 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
-    @@running = false
+  @queue = Queue.new
+  @running = false
+  
+  @before_kills = Queue.new
+  @after_kills  = Queue.new
+  
+  # Operate on the metaclass as a type of singleton pattern
+  class << self
     
-    def self.running?; @@running; end
+    def running?; @running; end
     
     # Start the Hub event loop in a new thread
-    def self.run
-        if not @@running
-            @@running = true
-            @@thread = Thread.new() {Hub.run_loop}
-            at_exit { @@thread.join if not $! }
-        end
+    def run
+      if not @running
+        @running = true
+        @thread = Thread.new() {self.send(:run_loop)};
+        at_exit { @thread.join if not $! }
+      end
     nil end
     
     # Start the Hub event loop in the current thread
-    def self.run_in_place() 
-        self.run_loop() unless @@running
+    def run_in_place()
+      self.send(:run_loop) unless @running
     nil end
     
     # Kill the Hub event loop (softly)
-    def self.kill() @@running=false end
+    def kill(); 
+      # Call the before kill hooks
+      while not @before_kills.empty?
+        @before_kills.shift.call
+      end
+      # Stop the main event loop
+      @running=false;
+    end
+    
+    # Register hook to execute before kill - can call multiple times
+    def before_kill(proc=nil, &block)
+      func = (block or proc)
+      if not func.is_a?(Proc)
+        raise TypeError, "Expected a Proc or code block to execute."
+      end
+      @before_kills << func
+    end
+    
+    # Register hook to execute after kill - can call multiple times
+    def after_kill(proc=nil, &block)
+      func = (block or proc)
+      if not func.is_a?(Proc)
+        raise TypeError, "Expected a Proc or code block to execute."
+      end
+      @after_kills << func
+    end
     
     # Put x in the queue, and block until x is processed
-    def self.fire(x)
-        @@queue << [x, Thread.current]
-        # yield to event loop thread until awoken by it later
-        sleep unless not @@running
+    def fire(x)
+      @queue << [x, Thread.current]
+      # yield to event loop thread until awoken by it later
+      sleep unless not @running
     end
-    def self.<<(x) fire(x) end
+    def <<(x); fire(x); end
     
-private
+  private
     
-    def self.run_loop
-        @@running = true
-            
-        while @@running
-            if @@queue.empty? then sleep(0)
-            else process_item(@@queue.shift) end
-        end
+    def run_loop
+      @running = true
+        
+      while @running
+        if @queue.empty? then sleep(0)
+        else process_item(@queue.shift) end
+      end
+      
+      while not @after_kills.empty?
+        @after_kills.shift.call
+      end
     end
     
-    def self.process_item(x)
-        x, waiting_thread = x
-        string, event, blocking, proc = x
-        Thread.new do
-            begin
-                waiting_thread.wakeup unless blocking
-                proc.call($event = event)
-                waiting_thread.wakeup if blocking
-                
-            rescue Interrupt, SystemExit => e
-                @running = false
-                unhandled_exception(e)
-                
-            rescue Exception => e
-                unhandled_exception(e)
-            end
+    def process_item(x)
+      x, waiting_thread = x
+      string, event, blocking, proc = x
+      Thread.new do
+        begin
+          waiting_thread.wakeup unless blocking
+          proc.call($event = event)
+          waiting_thread.wakeup if blocking
+          
+        rescue Interrupt, SystemExit => e
+          @running = false
+          unhandled_exception(e)
+          
+        rescue Exception => e
+          unhandled_exception(e)
         end
+      end
     end
     
-    def self.unhandled_exception(x)
-        $stderr.puts $!
-        $stderr.puts $@
+    def unhandled_exception(x)
+      $stderr.puts $!
+      $stderr.puts $@
     end
+  end
 end

data/lib/wires/time.rb

@@ -0,0 +1,75 @@
+
+
+# class StartSchedulerEvent < Event; end
+
+# # A singleton class to schedule future firing of events
+# class TimeScheduler
+#   @schedule      = Array.new
+#   @schedule_lock = Mutex.new
+#   @grain         = 0.2.seconds
+  
+#   # Operate on the metaclass as a type of singleton pattern
+#   class << self
+    
+#     # Get or set the time grain from outside the class
+#     attr_accessor :grain
+    
+#     # Fire an event delayed by time value
+#     def fire(time, event, channel='*')
+#       if not time.is_a? Time
+#         raise TypeError, "Expected #{time.inspect} to be an instance of Time."
+#       end
+      
+#       # Under mutex, push the event into the schedule and sort
+#       @schedule_lock.synchronize do
+#         @schedule << [time, event, channel]
+#         @schedule.sort! { |a,b| a[0] <=> b[0] }
+#       end
+      
+#     end
+    
+#   private
+    
+#     def main_loop
+      
+#       pending = Array.new
+      
+#       while true
+        
+#         pending.clear
+#         this_time = Time.now
+        
+#         # Under mutex, pull any events that are ready
+#         @schedule_lock.synchronize do
+#           while ((not @schedule.empty?) and (this_time > @schedule[0][0]))
+#             puts 'thing'
+#             pending << @schedule.shift
+#           end
+#         end
+        
+#         # Fire pending events
+#         pending.each { |x| Channel(x[2]).fire(x[1]) }
+        
+#         # Calculate the time to sleep based on the time left in the "grain"
+#         sleep [@grain-(Time.now-this_time), 0].max
+        
+#       end
+#     end
+    
+#   end
+  
+#   # Use fired event to only start scheduler when Hub is running
+#   # This also gets the scheduler loop its own thread within the Hub's threads
+#   on :start_scheduler, self do; main_loop; end;
+#   Channel(self).fire(:start_scheduler)
+  
+#   # Channel(self).fire(:start_scheduler, blocking=true)
+# end
+
+# # Reopen the Time class and add the fire method to enable nifty syntax like:
+# # 32.minutes.from_now.fire :event
+# class Time
+#   def fire(*args)
+#     TimeScheduler.fire(self, *args)
+#   end
+# end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2013-06-27 00:00:00.000000000 Z
 dependencies: []
 description: An asynchronous (threaded) event routing framework in Ruby. Patch your
   objects together with wires. Inspired by the python 'circuits' framework.
@@ -18,6 +18,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/wires.rb
+- lib/wires/time.rb
 - lib/wires/hub.rb
 - lib/wires/events.rb
 - lib/wires/channels.rb