wires 0.3.8 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 486d20e1c2995dea50118010dd60c4b9c8a5bbd8
-  data.tar.gz: d93b97c600da203bfcabd55781b80f2e6b0190ab
+  metadata.gz: a3c79a4bb96ed3a79e94be39171fda18a4846025
+  data.tar.gz: 7dd1087d9f74885e1bbbf4a25d70e07ae98919e9
 SHA512:
-  metadata.gz: 204086554b9b668d2ca5d559d99e3abf0173c23de146fb7232d80c9cb728e2f2c0de2dd82cd8ac619e0a5bc010beaf6c6a83e1b0d09e5682b170f418cd8cf598
-  data.tar.gz: f392ff623d48525508a535ea280d1924ea214f3a9276c1351a7d68d661ee78f70a164185be9585b7f560e0310f47f8ea3aa2dc23a4a59a338cf79d65381d04a8
+  metadata.gz: 61b8a2c4881a8fdec36257a7ea4f5bfb2d4831a0157e1a9fbe53897c3d0d83d7746ba655025fbd23903a39af623d9bbf672f798ed5d15344972fa707bedb47bb
+  data.tar.gz: 962a6bca1dfa83c565920750b46bc9699915603a1e8a5c7bf00a7984477dad2a6cea79ba5323c06ae1686362f28a45b0b5a45db969b9f44bf12369b2991840a6

data/lib/wires/channel.rb

@@ -5,44 +5,29 @@ module Wires
     
     attr_reader :name
     attr_reader :target_list
-    attr_reader :relevant_channels
+    attr_accessor :not_firable
     
-    def inspect; "Channel(#{name.inspect})"; end
+    def inspect; "#{self.class}(#{name.inspect})"; end
     
-    # Redefine this class method to use an alternate Hub
-    def self.hub; Hub; end
-    # Don't redefine this instance method!
-    def hub; self.class.hub; end
+    @hub    = Hub
+    @router = Router
+    @new_lock = Mutex.new
+    @@aim_lock = Mutex.new
     
-    # Give out references to the star channel
-    def self.channel_star; @@channel_star; end
-    def      channel_star; @@channel_star; end
-    
-    # Ensure that there is only one instance of Channel per name
-    @@new_lock = Mutex.new
-    def self.new(*args, &block)
-      (args.include? :recursion_guard) ?
-        (args.delete :recursion_guard) :
-        (@@channel_star ||= self.new('*', :recursion_guard))
+    class << self
+      attr_accessor :hub
+      attr_accessor :router
       
-      @@new_lock.synchronize do
-        @@channel_hash ||= Hash.new
-        @@channel_hash[args[0]] ||= super(*args, &block)
+      def new(*args)
+        channel = @new_lock.synchronize do
+          router.get_channel(self, *args) { |name| super(name) }        end
       end
+      alias_method :[], :new
     end
     
     def initialize(name)
       @name = name
-      @target_list = Set.new
-      unless @@channel_hash.empty?
-        _relevant_init
-        @@channel_hash.values.each do |c| 
-          c.send(:_test_relevance, self)
-          _test_relevance c
-        end
-      else
-        @relevant_channels = []
-      end
+      @target_list = []
     end
     
     # Register a proc to be triggered by an event on this channel
@@ -50,18 +35,27 @@ module Wires
     def register(*events, &proc)
       if not proc.is_a?(Proc) then raise SyntaxError, \
         "No Proc given to execute on event: #{events}" end
-      _normalize_event_list(events)
-      @target_list << [events, proc]
+      events = Event.new_from(*events)
+      
+      @@aim_lock.synchronize do
+        @target_list << [events, proc] \
+          unless @target_list.include? [events, proc]
+      end
+      
       proc
     end
     
     # Unregister a proc from the target list of this channel
     # Return true if at least one matching target was unregistered, else false
     def unregister(*events, &proc)
-      _normalize_event_list(events)
-      !!(@target_list.reject! do |e, p|
-        (proc and proc==p) and (events.map{|event| e.include? event}.all?)
-      end)
+      events = events.empty? ? [] : Event.new_from(*events)
+      
+      @@aim_lock.synchronize do
+        !!(@target_list.reject! do |es,pr|
+          (proc and proc==pr) and \
+            (events.map{|event| es.map{|e| event=~e}.any?}.all?)
+        end)
+      end
     end
     
     # Add hook methods
@@ -78,27 +72,47 @@ module Wires
     end
     
     # Fire an event on this channel
-    def fire(event, blocking:false)
+    def fire(input, blocking:false)
       
       raise *@not_firable if @not_firable
       
       backtrace = caller
       
-      # Create an instance object from one of several acceptable input forms
-      event = Event.new_from event
+      event = Event.new_from(*input)
+      
+      case event.count
+      when 0
+        raise ArgumentError,"Can't create an event from input: #{input.inspect}"
+      when 1
+        event = event.first
+      else
+        raise ArgumentError,"Can't fire on multiple events: #{event.inspect}"
+      end
       
       self.class.run_hooks(:@before_fire, event, self)
       
-      # Fire to each relevant target on each channel
-      for chan in relevant_channels()
-        for target in chan.target_list
-          for string in target[0] & event.class.codestrings
-            self.class.hub.spawn(event,     # fired event object event
-                                 self.name, # name of channel fired from
-                                 target[1], # proc to execute
-                                 blocking,  # boolean from blocking kwarg
-                                 backtrace) # captured backtrace
-      end end end
+      # Select appropriate targets
+      procs = []
+      @@aim_lock.synchronize do
+        self.class.router
+        .get_receivers(self).each do |chan|
+          chan.target_list.each do |elist, pr|
+            elist.each do |e|
+              procs << pr if e =~ event
+            end
+          end
+        end
+      end
+      
+      # Fire to selected targets
+      procs.uniq.each do |pr|
+        self.class.hub.spawn \
+          event,     # fired event object event
+          self.name, # name of channel fired from
+          pr,        # proc to execute
+          blocking,  # boolean from blocking kwarg
+          backtrace  # captured backtrace
+      end
       
       self.class.run_hooks(:@after_fire, event, self)
       
@@ -109,61 +123,20 @@ module Wires
       self.fire(event, blocking:true)
     end
     
-    # Convert events to array of unique codestrings
-    def _normalize_event_list(events)
-      events = [events] unless events.is_a? Array
-      events.flatten!
-      events.map! { |e| (e.is_a?(Class) ? e.codestring : e.to_s) }
-      events.uniq!
-    end
-    
-    def _relevant_init
-      @relevant_channels = [@@channel_star]
-      @my_names = (self.name.is_a? Array) ? self.name : [self.name]
-      @my_names.map {|o| (o.respond_to? :channel_name) ? o.channel_name : o.to_s}
-              .flatten(1)
-      _test_relevance self
-    end
-    
-    def _test_relevance(other_chan)
-      if self==@@channel_star
-        @relevant_channels << other_chan
-        return
-      end
-      
-      for my_name in @my_names
-        
-        if my_name.is_a?(Regexp) then 
-          @not_firable = [TypeError,
-          "Cannot fire on Regexp channel: #{self.name}."\
-          "  Regexp channels can only used in event handlers."]
-          return
-        end
-        
-        other_name = other_chan.name
-        other_name = (other_name.respond_to? :channel_name) ? \
-                        other_name.channel_name : other_name
-        
-        @relevant_channels << other_chan if \
-          !@relevant_channels.include?(other_chan) and \
-          if other_name.is_a?(Regexp)
-            my_name =~ other_name
-          else
-            my_name.to_s == other_name.to_s
-          end
-      end
-    end
-    
-    # Compare matching with another Channel
+    # Returns true if listening on 'self' would hear a firing on 'other'
+    # (not commutative)
     def =~(other)
-      (other.is_a? Channel) ? (other.relevant_channels.include? self) : super
+      (other.is_a? Channel) ?
+        (self.class.router.get_receivers(other).include? self) : 
+        super
     end
     
-    hub.before_kill(true) do
-      self.clear_hooks(:@before_fire)
-      self.clear_hooks(:@after_fire)
+    def receivers
+      self.class.router.get_receivers self
     end
     
+    router.clear_channels
+    
   end
   
 end

data/lib/wires/convenience.rb

@@ -3,25 +3,25 @@ module Wires
 
   module Convenience
     
-    def Channel(*args) Channel.new(*args) end
-    
-    def on(events, channels='*', &codeblock)
-      channels = [channels] unless channels.is_a? Array
-      for channel in channels
+    def on(events, channels=self, &codeblock)
+      [*channels].each do |channel|
         channel=Channel.new(channel) unless channel.is_a? Channel
+        
         channel.register(*events, &codeblock)
       end
       codeblock
     end
     
-    def fire(event, channel='*', **kwargs)
-      channel = Channel.new(channel) unless channel.is_a? Channel
-      unless kwargs[:time] or (kwargs[:count] and kwargs[:count]!=1)
-        channel.fire(event, **kwargs)
-      else
-        time = kwargs[:time] or Time.now
-        kwargs.reject!{|k,v| k==:time}
-        TimeScheduler.add(time, event, channel, **kwargs)
+    def fire(event, channels=self, **kwargs)
+      [*channels].each do |channel|
+        channel = Channel.new(channel) unless channel.is_a? Channel
+        
+        if kwargs[:time] or (kwargs[:count] and kwargs[:count]!=1)
+          time = kwargs.delete(:time) or Time.now
+          TimeScheduler.add(time, event, channel, **kwargs)
+        else
+          channel.fire(event, **kwargs)
+        end
       end
     nil end
     
@@ -30,28 +30,6 @@ module Wires
       fire(*args, **kwargs)
     end
     
-    
-    
-    class << self
-      def prefix_methods(prefix)
-        
-        return unless prefix
-        prefix = prefix.to_s
-        
-        instance_methods.each do |thing|
-          thing = thing.to_s
-          f2 = (prefix+'_'+thing)
-          f2 = (thing[0]=~/[[:lower:]]/) ? f2.underscore : f2.camelcase
-          f2 = f2.to_sym; thing = thing.to_sym
-          alias_method f2, thing
-          remove_method thing
-        end
-        
-        # remove_method :prefix_methods
-        
-      end
-    end
-    
   end
 
 end

data/lib/wires/core_ext.rb

@@ -1,49 +1,65 @@
 
-# Reopen the Time class and add the fire method to enable nifty syntax like:
-# 32.minutes.from_now.fire :event
-class ::Time
-  unless instance_methods.include? :fire
-    def fire(event, channel='*', **kwargs)
-      Wires::TimeScheduler << \
-        Wires::TimeSchedulerItem.new(self, event, channel, **kwargs)
-    end
-  end
-end
-
-
-# Reopen ActiveSupport::Duration to enable nifty syntax like:
-# 32.minutes.from_now do some_stuff end
-class ::ActiveSupport::Duration
-  
-  unless instance_methods.include? :__original_since
-    alias_method :__original_since, :since
-    def since(*args, &block)
+module Wires
+  module Convenience
+    
+    @core_ext = true
+    
+    class << self
+      
+      # Set this attribute to false to disable core_ext on include
+      attr_accessor :core_ext
       
-      if block
-        on :time_scheduler_anon, block.object_id do |e| block.call(e) end
-        __original_since(*args).fire(:time_scheduler_anon, 
-                                      block.object_id)
-        nil
-      else
-        __original_since(*args)
+      # Call extend_core on include unless attribute is set to false
+      def included(*args)
+        super
+        self.extend_core if @core_ext
       end
-    end
-    alias :from_now :since
-  end
-  
-  unless instance_methods.include? :__original_ago
-    alias :__original_ago :ago
-    def ago(*args, &block)
-      if block
-        on :time_scheduler_anon, block.object_id do |e| block.call(e) end
-        __original_ago(*args).fire(:time_scheduler_anon, 
-                                    block.object_id)
-        nil
-      else
-        __original_ago(*args)
+      
+      # Add methods to ::Time and ::Numeric
+      def extend_core
+        # Add Time#fire for timed firing of events
+        ::Time.class_eval do
+          def fire(event, channel='*', **kwargs)
+            Wires::TimeScheduler.add(self, event, channel, **kwargs)
+          end
+        end
+          
+        # Add Numeric => Numeric time-factor converters
+        {
+          [:second,     :seconds]    => '1',
+          [:minute,     :minutes]    => '60',
+          [:hour,       :hours]      => '3600',
+          [:day,        :days]       => '24.hours',
+          [:week,       :weeks]      => '7.days',
+          [:fortnight,  :fortnights] => '2.weeks',
+        }.each_pair do |k,v|
+          ::Numeric.class_eval <<-CODE
+            def #{k.last}
+              self * #{v}
+            end
+            alias #{k.first.inspect} #{k.last.inspect}
+          CODE
+        end
+        
+        # Add Numeric => Time converters with implicit anonymous fire
+        {
+          [:from_now, :since] => '+',
+          [:until,    :ago]   => '-',
+        }.each_pair do |k,v|
+          ::Numeric.class_eval <<-CODE
+            def #{k.last}(time = ::Time.now, &block)
+              if block
+                Channel[block.object_id].register :time_scheduler_anon, &block
+                self.#{k.last}(time).fire(:time_scheduler_anon, block.object_id)
+              end
+              time #{v} self
+            end
+            alias #{k.first.inspect} #{k.last.inspect}
+          CODE
+        end
       end
+      
     end
-    alias :until :ago
+    
   end
-  
-end
+end

data/lib/wires/event.rb

@@ -2,166 +2,91 @@
 module Wires
   
   class Event
-    class << self
-      def event_registry_create
-        @@registry = []
-        event_registry_register
-      end
-      def event_registry_register(cls=self)
-        @@registry << cls
-        @@registry.uniq!
-      end
+    attr_accessor :event_type
+    
+    # Return a friendly output upon inspection
+    def inspect
+      list = [*args, **kwargs].map(&:inspect).join ', '
+      type = event_type ? event_type.inspect : ''
+      "#{self.class}#{type}(#{list})"
     end
-    event_registry_create
-  end
-  
-  # All Event classes should inherit from this one
-  class Event
     
-    # Operate on the metaclass as a type of singleton pattern
-    class << self
-      
-      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
-        
-        super
-        event_registry_register(subcls)
-      end
-      
-      # List of class inheritance lineage back to but excluding Object
-      def ancestry(cls=self)
-        _next = cls.superclass
-        [cls==Object ? [] : [cls, ancestry(_next)]].flatten
-      end
-      
-      # Convert class <ClassNameEvent> to string "class_name"
-      def codestring(cls=self)
-        @codestring ||= \
-          File.basename cls.to_s
-            .underscore
-            .gsub(/_event$/, "")
-      end
-      
-      # List of codestrings associated with this event and ancestors
-      def codestrings
-        x = ancestry
-        .map {|cls| cls.codestring}
-      end
-      
-      # Pull class from registry by codestring 
-      # (more reliable than crafting a reverse regexp)
-      def _from_codestring(str)
-        return @@registry.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
-      
-      # Convert an event from 'array notation' to an Event subclass instance
-      # TODO: List acceptable input forms here for documentation
-      def new_from(input)
-        
-        # Standardize to array and pull out arguments if they exist
-        input = [input] unless input.is_a? Array
-        input, *args = input
-        
-        # Create event object from event as an object, class, or symbol/string
-        event = case input
-          when Event
-            input
-          when Class
-            input.new(*args) if input <= Event
-          else
-            Event.from_codestring(input.to_s).new(*args)
-        end
-      end
+    # Internalize all *args and **kwargs and &block to be accessed later
+    def initialize(*args, **kwargs, &block)
+      @ignore = []
+      @kwargs = kwargs.dup
       
-      # 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 new(*args, &block)
-        obj = super
-        
-        kwargs = args[-1].is_a?(Hash) ? args.pop.dup : Hash.new
-        kwargs[:kwargs] = kwargs.dup.freeze
-        kwargs[:args]   =   args.dup.freeze
-        kwargs[:codeblock] = block if block
-        for key in kwargs.keys
-          att = key.to_s
-          obj.instance_variable_set("@#{att}", kwargs[key])
-          class_eval { attr_reader att }
-          # class_eval { attr_writer att }
-        end
-        
-        obj
-      end
-    
+      (@kwargs[:args] = args.freeze; @ignore<<:args) \
+        unless @kwargs.has_key? :args
+      (@kwargs[:codeblock] = block; @ignore<<:codeblock) \
+        unless @kwargs.has_key? :codeblock
+      @kwargs.freeze
     end
     
-    # Calling super in new with *args will complain if this isn't here
-    def initialize(*args, &block) end
+    # Directly access contents of @kwargs by key
+    def [](key); @kwargs[key]; end
     
-  end
-  
-  #
-  # Comparison support for Events and Symbols/Strings
-  #
-  
-  # Reopen Event and add comparison functions
-  class Event
+    # Used to fake a sort of read-only openstruct from contents of @kwargs
+    def method_missing(sym, *args, &block)
+      args.empty? and @kwargs.has_key?(sym) ?
+        @kwargs[sym] :
+        (sym==:kwargs ? @kwargs.reject{|k| @ignore.include? k} : super)
+    end
     
+    # Returns true if listening for 'self' would hear a firing of 'other'
+    # (not commutative)
     def =~(other)
       (other.is_a? Event) ? 
         ((self.class >= other.class) \
+          and (self.event_type.nil? or self.event_type==other.event_type \
+              or (self.event_type.is_a? Class and other.event_type.is_a? Class \
+                  and self.event_type >= other.event_type)) \
           and (not self.kwargs.each_pair.detect{|k,v| other.kwargs[k]!=v}) \
           and (not self.args.each_with_index.detect{|a,i| other.args[i]!=a})) :
         super
     end
     
-    class << self
-      def ==(other)
-        other.is_a?(Class) ? 
-        super : codestring==other.to_s
-      end
-      def <=(other)
-        other.is_a?(Class) ? 
-        super : codestrings.include?(other.to_s)
-      end
-      def <(other)
-        other.is_a?(Class) ? 
-        super : (self<=other and not self==other)
-      end
-      def >=(other)
-        other.is_a?(Class) ? 
-        super : Event.from_codestring(other.to_s)<=self
+    # Return an array of Event instance objects generated from
+    # specially formatted input (see spec/event_spec.rb).
+    def self.new_from(*args)
+      args.flatten!
+      list = []
+      
+      args.each do |x|
+        (x.is_a? Hash) ? 
+          (x.each_pair { |x,y| list << [x,y] }) :
+          (list << [x,[]])
       end
-      def >(other)
-        other.is_a?(Class) ? 
-        super : Event.from_codestring(other.to_s)<self
+      
+      list.map! do |type, args|
+        case type
+        when Event; obj = type
+        when Class; 
+          if type<=Event 
+            obj = type.new(*args)
+            obj.event_type = type unless type==Wires::Event
+          end
+        when Symbol
+          obj = self.new(*args)
+          obj.event_type = type
+          obj if self==Wires::Event
+        end
+        obj
+      end.tap do |x|
+        raise ArgumentError, 
+        "Invalid event creation input: #{args} \noutput: #{x}" \
+          if x.empty? or !x.all?
       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")
+    
+    # Ensure that self.new_from is not inherited
+    def self.inherited(subcls)
+      super
+      class << subcls
+        undef_method :new_from
+      end if self == Wires::Event
     end
+    
   end
-end
+  
+end

data/lib/wires/hub.rb

@@ -3,11 +3,10 @@ module Wires
   # An Event Hub. Event/proc associations come in, and the procs 
   # get called in new threads in the order received
   class self::Hub
-    # Operate on the metaclass as a type of singleton pattern
     class << self
       
       # Allow user to get/set limit to number of child threads
-      attr_accessor :max_child_threads
+      attr_accessor :max_children
       
     private
     
@@ -17,85 +16,21 @@ module Wires
       # Moved to a dedicated method for subclass' sake
       def class_init
         # @queue = Queue.new
-        @max_child_threads   = nil
-        @child_threads       = Array.new
-        @child_threads_lock  = Monitor.new
-        @neglected           = Array.new
-        @neglected_lock      = Monitor.new
-        @spawning_count      = 0
-        @spawning_count_lock = Monitor.new
+        @max_children   = nil
+        @children       = Array.new
+        @children .extend MonitorMixin
+        @neglected      = Array.new
+        @neglected.extend MonitorMixin
         
-        @before_runs  = Queue.new
-        @after_runs   = Queue.new
-        @before_kills = Queue.new
-        @after_kills  = Queue.new
-        @before_fires = []
-        @after_fires  = []
-        
-        @please_finish_all = false
+        @hold_lock = Monitor.new
         
         reset_neglect_procs
         reset_handler_exception_proc
         
-        # at_exit { (sleep 0.05 until dead?) unless $! }
-        
-        state_machine_init
-        
       nil end
       
     public
       
-      def dead?;  state==:dead  end
-      def alive?; state==:alive end
-      
-      ##
-      # Start the Hub to allow task spawning.
-      #
-      def run(*flags)
-        sleep 0 until @spawning_count <= 0
-        @spawning_count_lock.synchronize do
-          sleep 0 until request_state :alive
-        end
-        spawn_neglected_task_threads
-        join_children
-      nil end
-      
-      ##
-      # Kill the Hub event loop (optional flags change thread behavior)
-      #
-      # valid flags:
-      # [+:nonblocking+]
-      #   Without this flag, calling thread will be blocked
-      #   until Hub thread is done
-      # [+:purge_tasks+]
-      #   Without this flag, Hub thread won't be done 
-      #   until all child threads are done
-      def kill(*flags)
-        sleep 0 until @spawning_count <= 0
-        @please_finish_all = (not flags.include? :purge_tasks)
-        sleep 0 until request_state :dead unless (flags.include? :nonblocking)
-      nil end
-      
-      # Add hook methods
-      include Hooks
-      
-      def before_run(*args, &proc)
-        add_hook(:@before_run, *args, &proc)
-      end
-      
-      def after_run(*args, &proc)
-        add_hook(:@after_run, *args, &proc)
-      end
-      
-      def before_kill(*args, &proc)
-        add_hook(:@before_kill, *args, &proc)
-      end
-      
-      def after_kill(*args, &proc)
-        add_hook(:@after_kill, *args, &proc)
-      end
-      
-      
       def on_neglect(&block)
         @on_neglect=block
       nil end
@@ -104,7 +39,7 @@ module Wires
       nil end
       def on_handler_exception(&block)
         @on_handler_exception=block
-      end
+      nil end
       
       def reset_neglect_procs
         @on_neglect = Proc.new do |args|
@@ -117,18 +52,23 @@ module Wires
       
       def reset_handler_exception_proc
         @on_handler_exception = Proc.new { raise }
+      nil end
+      
+      # Execute a block while neglecting all child threads
+      def hold
+        @hold_lock.synchronize { yield }
+        spawn_neglected_task_threads
       end
       
       # Spawn a task
-      def spawn(*args) # :args: event, ch_string, proc, blocking, fire_bt
-        
-        @spawning_count_lock.synchronize { @spawning_count += 1 }
+      def spawn(*args) # :args: event, chan, proc, blocking, fire_bt
         
-        return neglect(*args) if dead?
+        return neglect(*args) \
+          if @hold_lock.instance_variable_get(:@mon_mutex).locked?
         
-        event, ch_string, proc, blocking, fire_bt = *args
-        *proc_args = event, ch_string
-        *exc_args  = event, ch_string, fire_bt
+        event, chan, proc, blocking, fire_bt = *args
+        *proc_args = event, chan
+        *exc_args  = event, chan, fire_bt
         
         # If blocking, run the proc in this thread
         if blocking
@@ -142,78 +82,59 @@ module Wires
         end
         
         # If not blocking, clear old threads and spawn a new thread
-        new_thread = nil
-        
-        @child_threads_lock.synchronize do
-          
-          # Clear out dead threads
-          @child_threads.select!{|t| t.status}
-          
+        Thread.exclusive do
           begin
             # Raise ThreadError for user-set thread limit to mimic OS limit
-            raise ThreadError if (@max_child_threads) and \
-                                 (@max_child_threads <= @child_threads.size)
+            raise ThreadError if (@max_children) and \
+                                 (@max_children <= @children.count)
             # Start the new child thread; follow with chain of neglected tasks
-            new_thread = Thread.new do
+            @children << Thread.new do
               begin
                 proc.call(*proc_args)
               rescue Exception => exc
                 unhandled_exception(exc, *exc_args)
               ensure
                 spawn_neglected_task_chain
+                @children.synchronize { @children.delete Thread.current }
               end
             end
             
           # Capture ThreadError from either OS or user-set limitation
           rescue ThreadError; return neglect(*args) end
           
-          @child_threads << new_thread
-          return new_thread
+          return @children.last
         end
         
-      ensure
-        @spawning_count_lock.synchronize { @spawning_count -= 1 }
       end
       
-      def purge_neglected
-        @neglected_lock.synchronize do
-          @neglected.clear
-        end
-      nil end
-      
-      def number_neglected
-        @neglected_lock.synchronize do
-          @neglected.size
-        end
-      end
+      def clear_neglected; @neglected.synchronize { @neglected.clear; nil } end
+      def count_neglected; @neglected.synchronize { @neglected.count }      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
+          @children.synchronize do
+            a_thread = @children.shift
           end
           a_thread.join if ((a_thread) and (a_thread!=Thread.current))
-          sleep 0 # Yield to other threads
+          Thread.pass
         end
       nil end
       
     private
     
       # Send relevant data to a custom exception handler
-      def unhandled_exception(exception, event, ch_string, fire_bt)
-        
+      def unhandled_exception(exception, event, chan, fire_bt)
         class << exception;  attr_reader :fire_backtrace; end
         exception.instance_variable_set(:@fire_backtrace, fire_bt.dup)
         
-        @on_handler_exception.call(exception, event, ch_string)
-        
+        @on_handler_exception.call(exception, event, chan)
       end
       
       # Temporarily neglect a task until resources are available to run it
       def neglect(*args)
-        @neglected_lock.synchronize do
+        @neglected.synchronize do
           @on_neglect.call(*args)
           @neglected << args
         end
@@ -221,7 +142,7 @@ module Wires
       
       # Run a chain of @neglected tasks in place until no more are waiting
       def spawn_neglected_task_chain
-        args = @neglected_lock.synchronize do
+        args = @neglected.synchronize do
           return nil if @neglected.empty?
           ((@neglected.shift)[0...-1]<<true) # Call with blocking
         end
@@ -233,7 +154,7 @@ module Wires
       # Flush @neglected task queue, each in a new thread
       def spawn_neglected_task_threads
         until (cease||=false)
-          args = @neglected_lock.synchronize do
+          args = @neglected.synchronize do
             break if (cease = @neglected.empty?)
             ((@neglected.shift)[0...-1]<<false) # Call without blocking
           end
@@ -245,49 +166,6 @@ module Wires
       
     end
     
-    
-    #***
-    # Initialize state machine properties
-    #***
-    class << self
-      include Hegemon
-      
-      # Protect Hub users methods that could cause deadlock
-      # if called from inside an event
-      private :state_obj,
-              :state_objs,
-              :request_state,
-              :update_state,
-              :do_state_tasks,
-              :iter_hegemon_auto_loop,
-              :start_hegemon_auto_thread,
-              :join_hegemon_auto_thread,
-              :end_hegemon_auto_thread
-      
-      def state_machine_init
-        
-        impose_state :dead
-        
-        declare_state :dead do
-          transition_to :alive do
-            before { flush_hooks :@before_run }
-            after  { flush_hooks :@after_run }
-          end
-        end
-        
-        declare_state :alive do
-          transition_to :dead do
-            before { flush_hooks :@before_kill }
-            before { purge_neglected }
-            before { join_children if @please_finish_all }
-            after  { @please_finish_all = false }
-            after  { flush_hooks :@after_kill }
-          end
-        end
-        
-      end
-    end
-    
     class_init
   end
 end

data/lib/wires/router.rb

@@ -0,0 +1,42 @@
+
+module Wires
+  
+  class Router
+    
+    @table = Hash.new
+    
+    class << self
+      
+      attr_accessor :table
+      
+      def clear_channels()
+        @initialized = true
+        @table       = {}
+        @fuzzy_table = {}
+        Channel['*']
+      end
+      
+      def get_channel(chan_cls, name)
+        channel = @table[name] ||= (new_one=true; yield name)
+        
+        if new_one and name.is_a? Regexp then
+          @fuzzy_table[name] = channel
+          channel.not_firable = [TypeError,
+            "Cannot fire on Regexp channel: #{name.inspect}."\
+            "  Regexp channels can only used in event handlers."]
+        end
+        
+        channel
+      end
+      
+      def get_receivers(chan)
+        name = chan.name
+        @fuzzy_table.keys.select do |k|
+          (begin; name =~ k; rescue TypeError; end)
+        end.map { |k| @fuzzy_table[k] } + [chan, @table['*']]
+      end
+      
+    end
+  end
+  
+end

data/lib/wires/time.rb

@@ -1,11 +1,12 @@
 
 module Wires
   
-  class TimeSchedulerAnonEvent  < Event; end
+  class TimeSchedulerAnonEvent < Event; end
   
   class TimeSchedulerItem
     
     attr_reader :time, :event, :channel, :interval
+    attr_accessor :schedulers
     
     def initialize(time, event, channel='*', 
                    interval:0.seconds, count:1, 
@@ -33,18 +34,20 @@ module Wires
       @interval = interval
       
       @event    = Event.new_from(event)
-      @channel  = Channel.new(channel) unless channel.is_a? Channel
+      @channel  = channel.is_a?(Channel) ? channel : Channel.new(channel)
       @kwargs   = kwargs
+      
+      @schedulers = []
     end
     
     def active?;        @active                                      end
-    def inactive?;      not @active                                  end
+    def inactive?;     !@active                                      end
     
-    def ready?(at_time=Time.now); @active and at_time and (at_time>=@time) end
+    def ready?(at_time=Time.now);  @active and (at_time>=@time)      end
     
-    def time_until;    (@active ? [(Time.now - @time), 0].max : nil) end
+    def time_until;    (@active ? [(@time - Time.now), 0].max : nil) end
     
-    def cancel;         @active = false                         ;nil end
+    def cancel;         self.count=0                            ;nil end
     
     # Get/set @count (and apply constraints on set)
     def count;          @count                                       end
@@ -60,24 +63,22 @@ module Wires
       @channel.fire(@event, **(@kwargs.merge(kwargs)))
       count_dec
       @time += @interval if @active
+      notify_schedulers
     nil end
     
     # Fire the event only if it is ready
     def fire_if_ready(**args); self.fire(**kwargs) if ready? end
     
-    # Block until event is ready
-    def wait_until_ready; sleep 0 until ready? end
+  private
     
-    # Block until event is ready, then fire and block until it is done
-    def fire_when_ready(**kwargs);
-      wait_until_ready
-      self.fire(**kwargs)
-    end
+    def notify_schedulers; @schedulers.each &:refresh                end
     
-    # Lock (almost) all instance methods with common re-entrant lock
-    threadlock instance_methods(false)-[\
-                 :wait_until_ready,
-                 :fire_when_ready]
+    # Lock some of the methods to try to make them atomic
+    # Must exclude methods that get called from within the TimeScheduler lock
+    threadlock :fire,
+               :count=,
+               :count_inc,
+               :count_dec
   end
   
   # A singleton class to schedule future firing of events
@@ -85,142 +86,58 @@ module Wires
     @schedule       = Array.new
     @thread         = Thread.new {nil}
     @schedule_lock  = Monitor.new
-    @dont_sleep     = false
-    
-    @grain = 1.seconds
+    @cond           = @schedule_lock.new_cond
     
-    # Operate on the metaclass as a type of singleton pattern
     class << self
       
-      attr_accessor :grain
-      
       # Add an event to the schedule
       def add(*args)
-        new_item = (args.first.is_a? TimeSchedulerItem) ?
-                     (args.first) :
-                     (TimeSchedulerItem.new(*args))
-        schedule_add(new_item)
-      nil end
+        new_item = args.first
+        new_item = (TimeSchedulerItem.new *args) \
+          unless new_item.is_a? TimeSchedulerItem
+        
+        new_item.schedulers << self
+        schedule_update new_item
+        new_item
+      end
       
       # Add an event to the schedule using << operator
       def <<(arg); add(*arg); end
       
       # Get a copy of the event schedule from outside the class
-      def list;  @schedule.clone end
+      def list; @schedule_lock.synchronize { @schedule.dup } end
       # Clear the event schedule from outside the class
-      def clear; schedule_clear end
+      def clear; @schedule_lock.synchronize { @schedule.clear } end
+      # Make the scheduler wake up and re-evaluate
+      def refresh; schedule_update end
       
     private
-    
-      def schedule_clear
-        @schedule.clear
-      end
-    
-      def schedule_reshuffle
-        @schedule.select! {|x| x.active?}
-        @schedule.sort! {|a,b| a.time <=> b.time}
-      nil end
       
-      def schedule_add(new_item)
-        
-        if @keepgoing
-          if new_item.ready?
-            loop do
-              new_item.fire
-              break unless new_item.ready?
-            end
-          end
-          
-          if new_item.ready?(@next_pass)
-            Thread.new do
-              loop do
-                new_item.fire_when_ready(blocking:true)
-                break unless new_item.ready?(@next_pass)
-              end
-            end
-          end
+      def schedule_update(item_to_add=nil)
+        @schedule_lock.synchronize do
+          @schedule << item_to_add if item_to_add
+          @schedule.select! {|x| x.active?}
+          @schedule.sort! {|a,b| a.time <=> b.time}
+          @cond.broadcast
         end
-        
-        @schedule << new_item
-        schedule_reshuffle
-        
-      nil end
-      
-      def schedule_concat(other_list)
-        @schedule.concat other_list
-        schedule_reshuffle
       nil end
       
-      def schedule_pull
-        pending_now  = Array.new
-        pending_soon = Array.new
-        while ((not @schedule.empty?) and @schedule[0].ready?)
-          pending_now << @schedule.shift
-        end
-        while ((not @schedule.empty?) and @schedule[0].ready?(@next_pass))
-          pending_soon << @schedule.shift
-        end
-        return [pending_now, pending_soon]
-      end
-      
-      def schedule_next_pass
-        @next_pass = Time.now+@grain
-      end
-      
-      # Put all functions dealing with @schedule under @schedule_lock
-      threadlock :list,
-                 :schedule_clear,
-                 :schedule_reshuffle,
-                 :schedule_add,
-                 :schedule_concat,
-                 :schedule_pull,
-                 :schedule_next_pass,
-           lock: :@schedule_lock
-      
       def main_loop
-        
-        # @keepgoing = true
-        pending = Array.new
-        on_deck = nil
-        
-        while @keepgoing
-          
-          schedule_next_pass
-          
-          # Pull, fire, and requeue relevant events
-          pending_now, pending_soon = schedule_pull
-          pending_now.each { |x| x.fire }
-          pending_soon.each{ |x| Thread.new{ x.fire_when_ready(blocking:true) }}
-          # schedule_concat pending_now
-          
-          sleep [@next_pass-Time.now, 0].max
+        pending = []
+        loop do
+          @schedule_lock.synchronize do
+            timeout = (@schedule.first.time_until unless @schedule.empty?)
+            @cond.wait timeout
+            pending = @schedule.take_while &:ready?
+          end
+          pending.each &:fire
         end
-        
       nil end
       
     end
     
-    # Start the main loop upon run of Hub
-    Hub.after_run(true) do 
-      @keepgoing = true
-      @thread = Thread.new { main_loop }
-    end
-    
-    # Stop the main loop upon death of Hub
-    Hub.before_kill(true) do
-      Thread.exclusive do
-        @keepgoing=false
-        @next_pass=Time.now
-        @thread.wakeup
-      end
-      @thread.join
-      schedule_clear
-    end
+    @thread = Thread.new { main_loop }
     
   end
   
 end
-
-
-# TODO: Repeatable event sugar?
-# TODO: Tests for all new functionality

data/lib/wires.rb

@@ -1,18 +1,14 @@
-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/util/expect_type'
-require 'wires/util/hooks'
-
-require 'wires/event'
-require 'wires/hub'
-require 'wires/channel'
-require 'wires/time'
 
-require 'wires/core_ext'
-require 'wires/convenience'
-include Wires::Convenience # require 'wires/clean' to uninclude Convenience
+require_relative 'wires/util/expect_type'
+require_relative 'wires/util/hooks'
 
+require_relative 'wires/event'
+require_relative 'wires/hub'
+require_relative 'wires/router'
+require_relative 'wires/channel'
+require_relative 'wires/time'
+require_relative 'wires/core_ext'
+require_relative 'wires/convenience'

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.0
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-03 00:00:00.000000000 Z
+date: 2013-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport-core-ext
+  name: threadlock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: hegemon
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.0.8
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.0.8
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +66,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: starkfish
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 description: An asynchronous (threaded) event routing framework in Ruby. Patch your
   objects together with wires. Inspired by the python 'circuits' framework.
 email: joe.eli.mac@gmail.com
@@ -104,8 +76,8 @@ files:
 - lib/wires.rb
 - lib/wires/time.rb
 - lib/wires/hub.rb
+- lib/wires/router.rb
 - lib/wires/core_ext.rb
-- lib/wires/clean.rb
 - lib/wires/util/expect_type.rb
 - lib/wires/util/hooks.rb
 - lib/wires/convenience.rb
@@ -115,7 +87,7 @@ files:
 - README.md
 homepage: https://github.com/jemc/wires/
 licenses:
-- 'Copyright (c) Joe McIlvain. All rights reserved '
+- Copyright 2013 Joe McIlvain. All rights reserved.
 metadata: {}
 post_install_message: 
 rdoc_options: []

data/lib/wires/clean.rb

@@ -1,9 +0,0 @@
-require 'wires'
-
-class << self
-  target_owner = Wires::Convenience
-  target_owner.instance_methods(false)
-              .select { |sym| respond_to?(sym) }
-              .select { |sym| method(sym).owner==target_owner }
-              .each   { |sym| undef_method sym }
-end