wires 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 457cb2ed2bd4af2a473bdd857e373aee0d3d9266
-  data.tar.gz: 2f55be33795d9bccd37e7d90afe95ca0387ceb32
+  metadata.gz: bc852c0d3cd3cc7571a39f56b081a006d8e704f2
+  data.tar.gz: 937220faab14ab5bd4da7a0c3cb3877f99e56a76
 SHA512:
-  metadata.gz: 396cc5c23cb7b7b0e8cd9c52fa9b438310593dd03ba96e4eaf5731b7d7e1933326a31a89d35cc453301f3746016ec1806e39be2afba08f7c8f09c988c44e0097
-  data.tar.gz: dafd5997b103c258f9fd3776c4eb9f62d11d28c41f0b389e95df7f45827492f9035d5389b140e7edb1d2cdb6a2ce4c151cc3f8ecd096b05ea5c580c2c2f3de73
+  metadata.gz: 4f6f27c768dae1cc9bbf6b93495df61b5165c050f420a86317fc732aa8b670443a3b9d62ad5a7c1ae07e45c23267e6ad9b2b6e015beb2f708819896d1593ab66
+  data.tar.gz: d8b45765b30d6e690f5a4c6d49d3832a1e41f0b8d4f9bd2c8cb4cde7179a6db3ff62537a42266ede277cc689b9243d70c491f0930a7a364df020d1aa4921a7a1

data/lib/wires.rb

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

data/lib/wires/events.rb

@@ -1,91 +1,98 @@
+
 # Store a list of all Event classes that get loaded.
 class EventRegistry
-    @@registry = []
-    
-    def self.<<(cls)
-        @@registry << cls
-        @@registry.uniq!
-    end
-    
-    def self.list
-        @@registry
-    end
+  @@registry = []
+  
+  def self.<<(cls)
+    @@registry << cls
+    @@registry.uniq!
+  end
+  
+  def self.list
+    @@registry
+  end
 end
 
 # All Event classes should inherit from this one
-class Event
+class Event < Object # explicit for the sake of Event.ancestry
+  
+  # Register with the EventRegistry and make subclasses do the same
+  EventRegistry << self
+  
+  # Operate on the metaclass as a type of singleton pattern
+  class << self
     
-    # Register with the EventRegistry and make subclasses do the same
-    EventRegistry << self
-    def self.inherited(subcls)
+    def inherited(subcls)
+      
+      # Be sure codestring doesn't conflict
+      existing = _from_codestring(subcls.codestring)
+      if existing then raise NameError, \
+        "New Event subclass '#{subcls}' conflicts with"\
+        " existing Event subclass '#{existing}'."\
+        " The generated codestring '#{subcls.codestring}'"\
+        " must be unique for each Event subclass." end
         
-        # Be sure codestring doesn't conflict
-        existing = self._from_codestring(subcls.codestring)
-        if existing then raise NameError, \
-                "New Event subclass '#{subcls}' conflicts with"\
-                " existing Event subclass '#{existing}'."\
-                " The generated codestring '#{subcls.codestring}'"\
-                " must be unique for each Event subclass." end
-        
-        # Register, then call super
-        EventRegistry << subcls
-        super
+      # Register, then call super
+      EventRegistry << subcls
+      super
     end
     
     # List of class inheritance lineage back to but excluding Object
-    def self.ancestry(cls=self)
-        _next = cls.superclass
-        [cls==Object ? [] : [cls, self.ancestry(_next)]].flatten
+    def ancestry(cls=self)
+      _next = cls.superclass
+      [cls==Object ? [] : [cls, ancestry(_next)]].flatten
     end
     
     # Convert class <ClassNameEvent> to string "class_name"
-    def self.codestring(cls=self)
-        cls.to_s
-           .gsub(/(?<!(?:_|^))([A-Z])/, "_\\1")
-           .downcase
-           .gsub(/_event/, "")
+    def codestring(cls=self)
+      cls.to_s
+      .underscore
+      .gsub(/_event$/, "")
     end
     
     # List of codestrings associated with this event and ancestors
-    def self.codestrings
-        x = self.ancestry
-                .map {|cls| cls.codestring}
+    def codestrings
+      x = ancestry
+      .map {|cls| cls.codestring}
     end
     
     # Pull class from registry by codestring 
     # (more reliable than crafting a reverse regexp)
-    def self._from_codestring(str)
-        return EventRegistry.list
-                            .select{|e| e.codestring==str}[0]
-    end
-    def self.from_codestring(str)
-        cls = self._from_codestring(str)
-        if not cls then raise NameError,
-            "No known Event subclass with codestring: '#{str}'" end
-        cls
-    end
+    def _from_codestring(str)
+      return EventRegistry.list
+      .select{|e| e.codestring==str}[0]
+    end; private :_from_codestring
     
+    def from_codestring(str)
+      cls = _from_codestring(str.to_s)
+      if not cls then raise NameError,
+        "No known Event subclass with codestring: '#{str}'" end
+        cls
+      end
+      
     # Create attributes and accessors for all arguments to the constructor.
     # This is done here rather than in initialize so that the functionality
     # will remain if the user developer overrides initialize in the subclass.
-    def self.new(*args, &block)
-        obj = super
-        
-        kwargs = args[-1].is_a?(Hash) ? args.pop : Hash.new
-        kwargs[:args] = args
-        kwargs[:proc] = block if block
-        for key in kwargs.keys
-            att = key.to_s
-            obj.instance_variable_set("@#{att}", kwargs[key])
-            self.class_eval("def #{att}; @#{att}; end")
-            self.class_eval("def #{att}=(val); @#{att}=val; end")
-        end
-        
-        obj
+    def new(*args, &block)
+      obj = super
+      
+      kwargs = args[-1].is_a?(Hash) ? args.pop : Hash.new
+      kwargs[:args] = args
+      kwargs[:codeblock] = block if block
+      for key in kwargs.keys
+        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")
+      end
+      
+      obj
     end
-    
-    # Calling super in self.new with *args will complain if this isn't here
-    def initialize(*args, &block) end
+  
+  end
+  
+  # Calling super in new with *args will complain if this isn't here
+  def initialize(*args, &block) end
 end
 
 
@@ -95,37 +102,39 @@ end
 
 # Reopen Event and add comparison functions
 class Event
-    def self.==(other)
-        other.is_a?(Class) ? 
-            super : self.codestring==other.to_s
+  class << self
+    def ==(other)
+      other.is_a?(Class) ? 
+      super : codestring==other.to_s
     end
-    def self.<=(other)
-        other.is_a?(Class) ? 
-            super : self.codestrings.include?(other.to_s)
+    def <=(other)
+      other.is_a?(Class) ? 
+      super : codestrings.include?(other.to_s)
     end
-    def self.<(other)
-        other.is_a?(Class) ? 
-            super : (self<=other and not self==other)
+    def <(other)
+      other.is_a?(Class) ? 
+      super : (self<=other and not self==other)
     end
-    def self.>=(other)
-        other.is_a?(Class) ? 
-            super : Event.from_codestring(other.to_s)<=self
+    def >=(other)
+      other.is_a?(Class) ? 
+      super : Event.from_codestring(other.to_s)<=self
     end
-    def self.>(other)
-        other.is_a?(Class) ? 
-            super : Event.from_codestring(other.to_s)<self
+    def >(other)
+      other.is_a?(Class) ? 
+      super : Event.from_codestring(other.to_s)<self
     end
+  end
 end
 
 # Autogenerate the inverse comparison functions for Symbol/String
 for cls in [Symbol, String]
-    %w(== < > <= >=).zip(%w(== > < >= <=))
-                       .each do |ops|
-        op, opinv = ops # unzip operator and inverse operator
-        cls.class_eval(
-            "def #{op}(other)\n"\
-            "    (other.is_a?(Class) and other<=Event) ? \n"\
-            "        (other#{opinv}self) : super\n"\
-            "end\n")
-    end
+  %w(== < > <= >=).zip(%w(== > < >= <=))
+  .each do |ops|
+    op, opinv = ops # unzip operator and inverse operator
+    cls.class_eval(
+      "def #{op}(other)\n"\
+      "    (other.is_a?(Class) and other<=Event) ? \n"\
+      "        (other#{opinv}self) : super\n"\
+      "end\n")
+  end
 end

data/lib/wires/hub.rb

@@ -9,6 +9,9 @@ class Hub
   @queue = Queue.new
   @state = [:dead, :alive, :dying][0]
   
+  @child_threads      = Array.new
+  @child_threads_lock = Mutex.new
+  
   @before_kills = Queue.new
   @after_kills  = Queue.new
   
@@ -20,47 +23,66 @@ class Hub
     def dying?; @state==:dying end
     def state;  @state         end
     
+    # Clear the Hub queue, but do not kill working threads
     def clear;  @queue.clear   end
     
-    # Start the Hub event loop in a new thread
-    def run
-      if dead?
-        @thread = Thread.new() do
-          self.send(:run_loop)
-        end
+    ##
+    # Start the Hub event loop (optional flags change thread behavior)
+    #
+    # valid flags:
+    # [+:blocking+] Hub event loop will be run in calling thread,
+    #               blocking until Hub is killed.  If this flag is not
+    #               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
         
-        at_exit { @thread.join if not $! }
       end
+      
+      sleep 0 # Yield to other threads
+      
     nil end
     
-    # Start the Hub event loop in the current thread
-    def run_in_place()
-      self.send(:run_loop) if dead?
+    ##
+    # Kill the Hub event loop (optional flags change thread behavior)
+    #
+    # valid flags:
+    # [+: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 if alive?
+      @thread.join if (flags.include? :blocking)
     nil end
     
-    # Kill the Hub event loop (softly)
-    def kill()
-      # Stop the main event loop
-      @state=:dying;
-    end
-    
     # Register hook to execute before kill - can call multiple times
-    def before_kill(proc=nil, &block)
+    def before_kill(proc=nil, retain:false, &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
+      @before_kills << [func, retain]
+    nil end
     
     # Register hook to execute after kill - can call multiple times
-    def after_kill(proc=nil, &block)
+    def after_kill(proc=nil, retain:false, &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
+      @after_kills << [func, retain]
+    nil end
     
     # Put x in the queue, and block until x is processed (if Hub is running)
     def fire(x)
@@ -70,19 +92,67 @@ class Hub
       else        # don't wait if Hub isn't running - would cause lockup
         @queue << [x, nil]
       end
-    end
+    nil end
     def <<(x); fire(x); end
     
   private
   
-    def die
-      # Call the before kill hooks # TODO move
-      while not @before_kills.empty?
-        @before_kills.shift.call
+    # 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
+      end
+    nil end
+    
+    # Join child threads, one by one, allowing more children to appear
+    def join_children
+      a_thread = Thread.new{nil}
+      while a_thread
+        @child_threads_lock.synchronize do
+          a_thread = @child_threads.shift
+        end
+        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
       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
-    end
+    nil end
     
+    # Run main event loop, not finished until Hub is killed
     def run_loop
       @state = :alive
         
@@ -90,36 +160,48 @@ class Hub
         if @queue.empty? then sleep(0)
         else process_item(@queue.shift) end
         
-        if dying?; die_thread ||= Thread.new { die } end
+        if dying?
+          die_thread ||= Thread.new { die }
+        end
       end
       
-      while not @after_kills.empty?
-        @after_kills.shift.call
-      end
-    end
+      run_hooks(@after_kills)
+      @finish_all = false
+      
+    nil end
     
     def process_item(x)
       x, waiting_thread = x
       string, event, blocking, proc = x
-      Thread.new do
-        begin
-          waiting_thread.wakeup unless blocking or not waiting_thread
-          proc.call($event = event)
-          waiting_thread.wakeup if blocking and waiting_thread
-          
-        rescue Interrupt, SystemExit => e
-          @state = :dying
-          unhandled_exception(e)
-          
-        rescue Exception => e
-          unhandled_exception(e)
+      
+      # Do all dealings with @child_threads under mutex
+      @child_threads_lock.synchronize do
+        
+        # Clear dead child threads to free up memory
+        @child_threads.select! {|t| t.status}
+        
+        # Start the new child thread
+        @child_threads << Thread.new do
+          begin
+            waiting_thread.wakeup unless blocking or not waiting_thread
+            proc.call($event = 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
         end
       end
-    end
+    
+    nil end
     
     def unhandled_exception(x)
       $stderr.puts $!
       $stderr.puts $@
-    end
+    nil end
   end
 end

data/lib/wires/time.rb

@@ -1,66 +1,99 @@
+require 'pry'
 
-
-class StartSchedulerEvent < Event; end
+class TimeSchedulerEvent < Event; end
+class TimeSchedulerStartEvent < TimeSchedulerEvent; end
+class TimeSchedulerAnonEvent  < TimeSchedulerEvent; end
 
 # A singleton class to schedule future firing of events
 class TimeScheduler
   @schedule      = Array.new
   @schedule_lock = Mutex.new
-  @grain         = 0.2.seconds
+  @thread        = Thread.new {nil}
   
   # 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
+    # Get a copy of the event schedule from outside the class
+    def list;  @schedule_lock.synchronize {@schedule.clone} end
+    # Clear the event schedule from outside the class
+    def clear; @schedule_lock.synchronize {@schedule.clear} end
     
-    # Fire an event delayed by time value
-    def fire(time, event, channel='*')
+    # Fire an event at a specific time
+    def fire(time, event, channel='*', ignore_past:false)
       if not time.is_a? Time
         raise TypeError, "Expected #{time.inspect} to be an instance of Time."
       end
       
+      # Ignore past events if flag is set
+      if ignore_past and time < Time.now; return nil; 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] }
+        @schedule << {time:time, event:event, channel:channel}
+        @schedule.sort! { |a,b| a[:time] <=> b[:time] }
       end
       
-    end
+      # Wakeup main_loop thread if it is sleeping
+      begin @thread.wakeup; rescue ThreadError; end
+      
+    nil end
     
   private
     
+    # Do scheduled firing of events as long as Hub is alive
     def main_loop
       
+      @keepgoing = true
+      @thread = Thread.current
       pending = Array.new
+      on_deck = nil
       
-      while true
+      while @keepgoing
         
+        # Under mutex, pull any events that are ready into pending
         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]))
+          while ((not @schedule.empty?) and 
+                 (Time.now > @schedule[0][:time]))
             pending << @schedule.shift
           end
+          on_deck = @schedule[0]
         end
         
         # Fire pending events
-        pending.each { |x| Channel(x[2]).fire(x[1]) }
+        pending.each { |x| Channel(x[:channel]).fire(x[:event]) }
         
-        # Calculate the time to sleep based on the time left in the "grain"
-        sleep [@grain-(Time.now-this_time), 0].max
+        # Calculate the time to sleep based on next event's time
+        if on_deck
+          sleep [(on_deck[:time]-Time.now), 0].max
+        else
+          sleep # sleep until wakeup if no event is on deck
+        end
         
       end
-    end
+      
+    nil 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)
+  on :time_scheduler_start, self do; main_loop; end;
+  Channel(self).fire(:time_scheduler_start)
+  
+  # Stop the main loop upon death of Hub
+  Hub.before_kill(retain:true) do 
+    @keepgoing=false
+    @thread.wakeup
+    sleep 0
+  end
+  # Refire the start event after Hub dies in case it restarts
+  Hub.after_kill(retain:true) do 
+    Channel(self).fire(:time_scheduler_start)
+  end
+  
+  
 end
 
 
@@ -75,14 +108,14 @@ end
 
 # Reopen ActiveSupport::Duration to enable nifty syntax like:
 # 32.minutes.from_now do some_stuff end
-class TimeSchedulerAnonEvent < Event; end
 class ActiveSupport::Duration
   
   alias :__original_since :since
   def since(*args, &block)
     if block
       on :time_scheduler_anon, block.object_id do block.call end
-      __original_since(*args).fire :time_scheduler_anon, block.object_id
+      __original_since(*args).fire(:time_scheduler_anon, 
+                                    block.object_id)
       nil
     else
       __original_since(*args)
@@ -94,7 +127,8 @@ class ActiveSupport::Duration
   def ago(*args, &block)
     if block
       on :time_scheduler_anon, block.object_id do block.call end
-      __original_ago(*args).fire :time_scheduler_anon, block.object_id
+      __original_ago(*args).fire(:time_scheduler_anon, 
+                                  block.object_id)
       nil
     else
       __original_ago(*args)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-27 00:00:00.000000000 Z
+date: 2013-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport