wires 0.1.12 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 00826eb63c92ee41f33d4b9afca45cf79f6074ef
-  data.tar.gz: 7547996adc41b8f58905b22b50f317f403ef56b3
+  metadata.gz: c13e2e944a09925c428bbcfd549162c0dd64a782
+  data.tar.gz: a7addc2fbf45a815e96ead41faf7bc9bd9f9e006
 SHA512:
-  metadata.gz: 64f55f73930e572d8fdb589a8c84f302396a87ff56ec851e0a6fe24b7666dd8f572ee6638169a0571728e6364ea9b85d38d6d843b133656690cd22072cd00e8c
-  data.tar.gz: efac20e8fc999a1e219ff778ee92cbeb0c5ebfd2e520708b382bd86411a6133c6ceac8ab7084620439e6c8ae4a4ff98bdece2136aa3f4bcc9a73dc3bb968bf71
+  metadata.gz: d175ae2bc54184972ca61169961256df0ff323a1fa0bbd77cdb328932d9f6f6a224902d181a23e8824bf7d57a7e715a8ffd5ace9ebab1978ea065a01d62afb23
+  data.tar.gz: f65e946b8aa4ac6ec4ceb3510d3ecb1ee65669e570f9989b6f276471386b7f3f9fb849c51b1c64d2db756ad2d73397817f4f81e332f5857aa07dba7d8f7f564b

data/lib/wires.rb

@@ -4,7 +4,7 @@ require 'active_support/core_ext' # Convenience functions from Rails
 require 'threadlock' # Easily add re-entrant lock to instance methods
 
 require 'wires/expect_type'
-require 'wires/events'
+require 'wires/event'
 require 'wires/hub'
-require 'wires/channels'
+require 'wires/channel'
 require 'wires/time'

data/lib/wires/channel.rb

@@ -0,0 +1,109 @@
+
+def on(events, channels='*', &codeblock)
+  channels = [channels] unless channels.is_a? Array
+  for channel in channels
+    Wires::Channel.new(channel).register(events, codeblock)
+  end
+nil end
+
+
+def fire(event, channel='*') 
+  Wires::Channel.new(channel).fire(event, blocking:false)
+nil end
+
+def fire_and_wait(event, channel='*') 
+  Wires::Channel.new(channel).fire(event, blocking:true)
+nil end
+
+
+def Channel(*args) Wires::Channel.new(*args) end
+
+module Wires
+  class Channel
+    
+    attr_reader :name
+    attr_reader :target_list
+    
+    def initialize(name)
+      @name = name
+      @target_list = Set.new
+    nil 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
+    
+    # Channel registry hash and star channel reference are values
+    # In this Hash with the key being the reference to the Hub
+    @@channel_hash = Hash.new
+    @@channel_star = Hash.new
+    
+    # Give out references to the star channel
+    def self.channel_star; @@channel_star[self.hub]; end
+    def      channel_star; @@channel_star[self.hub]; end
+    
+    # Ensure that there is only one instance of Channel per name
+    @@new_lock = Mutex.new
+    def self.new(*args, &block)
+      @@channel_star[self.hub] ||= Channel.new('*') unless (args[0]=='*')
+      @@new_lock.synchronize do
+        @@channel_hash[self.hub] ||= Hash.new
+        @@channel_hash[self.hub][args[0]] ||= super(*args, &block)
+      end
+    end
+    
+    # Register a proc to be triggered by an event on this channel
+    def register(events, proc)
+      
+      if not proc.is_a?(Proc) then raise SyntaxError, \
+        "No Proc given to execute on event: #{events}" end
+      
+      # Convert all events to strings
+      events = [events] unless events.is_a? Array
+      events.flatten!
+      events.map! { |e| (e.is_a?(Class) ? e.codestring : e.to_s) }
+      events.uniq!
+      
+      @target_list << [events, proc]
+    nil end
+    
+    # Fire an event on this channel
+    def fire(event, blocking:false)
+      
+      # Create an instance object from one of several acceptable input forms
+      event = Event.new_from event
+      
+      # 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 << [string, event, blocking, *target[1..-1]]
+      end end end
+      
+    nil end
+    
+    def relevant_channels
+      return @@channel_hash[hub].values if self==channel_star
+      
+      if self.name.is_a?(Regexp) then raise TypeError,
+        "Cannot fire on Regexp channel: #{self.name}."\
+        "  Regexp channels can only used in event handlers." end
+        
+      relevant = [channel_star]
+      for c in @@channel_hash[hub].values
+        relevant << c if \
+          if c.name.is_a?(Regexp)
+            self.name =~ c.name
+          elsif (defined?(c.name.channel_name) and
+               defined?(self.name.channel_name))
+            self.name.channel_name == c.name.channel_name
+          else
+            self.name.to_s == c.name.to_s
+          end
+      end
+      return relevant.uniq
+    end
+  end
+end

data/lib/wires/event.rb

@@ -0,0 +1,161 @@
+
+module Wires
+  # 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
+  end
+  
+  # All Event classes should inherit from this one
+  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
+      
+      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
+          
+        # Register, then call super
+        EventRegistry << subcls
+        super
+      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)
+        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 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
+      
+      # 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
+      
+      # 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 : 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
+    
+    end
+    
+    # Calling super in new with *args will complain if this isn't here
+    def initialize(*args, &block) end
+  end
+  
+  
+  #
+  # Comparison support for Events and Symbols/Strings
+  #
+  
+  # Reopen Event and add comparison functions
+  class Event
+    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
+      end
+      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
+  end
+end

data/lib/wires/hub.rb

@@ -2,203 +2,204 @@
 # Make sure puts goes to $stdout for all threads!
 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
-  @state = [:dead, :alive, :dying][0]
-  
-  @child_threads      = Array.new
-  @child_threads_lock = Mutex.new
-  
-  @before_kills = Queue.new
-  @after_kills  = Queue.new
-  
-  # Operate on the metaclass as a type of singleton pattern
-  class << self
+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]
     
-    def dead?;  @state==:dead  end
-    def alive?; @state==:alive end
-    def dying?; @state==:dying end
-    def state;  @state         end
+    @child_threads      = Array.new
+    @child_threads_lock = Mutex.new
     
-    # Clear the Hub queue, but do not kill working threads
-    def clear;  @queue.clear   end
+    @before_kills = Queue.new
+    @after_kills  = Queue.new
     
-    ##
-    # 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 $! }
+    # 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
+      
+      ##
+      # 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
+          
+        end
         
-        # If :blocking is set, run in main thread and block until Hub death
-        else self.send(:run_loop) end
+        sleep 0 # Yield to other threads
         
-      end
+      nil end
       
-      sleep 0 # Yield to other threads
+      ##
+      # 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
+        @thread.join if (dying? and flags.include? :blocking)
+      nil end
       
-    nil end
-    
-    ##
-    # 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
-      @thread.join if (dying? and flags.include? :blocking)
-    nil end
-    
-    # Register hook to execute before kill - can call multiple times
-    def before_kill(proc=nil, retain:false, &block)
-      func = (block or proc)
-      expect_type func, Proc
-      @before_kills << [func, retain]
-    nil end
-    
-    # Register hook to execute after kill - can call multiple times
-    def after_kill(proc=nil, retain:false, &block)
-      func = (block or proc)
-      expect_type func, Proc
-      @after_kills << [func, retain]
-    nil end
-    
-    # Put x in the queue, and block until x is processed (if Hub is running)
-    def fire(x)
-      if not dead? # yield to event loop thread until awoken by it later
-        @queue << [x, Thread.current]
-        sleep
-      else        # don't wait if Hub isn't running - would cause lockup
-        @queue << [x, nil]
-      end
-    nil end
-    def <<(x); fire(x); 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
+      # Register hook to execute before kill - can call multiple times
+      def before_kill(proc=nil, retain:false, &block)
+        func = (block or proc)
+        expect_type func, Proc
+        @before_kills << [func, retain]
+      nil end
+      
+      # Register hook to execute after kill - can call multiple times
+      def after_kill(proc=nil, retain:false, &block)
+        func = (block or proc)
+        expect_type func, Proc
+        @after_kills << [func, retain]
+      nil end
+      
+      # Put x in the queue, and block until x is processed (if Hub is running)
+      def fire(x)
+        if not dead? # yield to event loop thread until awoken by it later
+          @queue << [x, Thread.current]
+          sleep
+        else        # don't wait if Hub isn't running - would cause lockup
+          @queue << [x, nil]
         end
-        clear
-      end
-    nil end
+      nil end
+      def <<(x); fire(x); end
+      
+    private
     
-    # Join child threads, one by one, allowing more children to appear
-    def join_children
-      a_thread = Thread.new{nil}
-      while a_thread
+      # 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
-          a_thread = @child_threads.shift
+          until @child_threads.empty?
+            @child_threads.shift.exit
+          end
         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
-    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 }
+      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
-      end
+      nil end
       
-      run_hooks(@after_kills)
-      @finish_all = false
+      # 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
       
-    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
     
-    def process_item(x)
-      x, waiting_thread = x
-      string, event, blocking, proc = x
+      # 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
       
-      # Do all dealings with @child_threads under mutex
-      @child_threads_lock.synchronize do
+      # 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 }
+          end
+        end
         
-        # Clear dead child threads to free up memory
-        @child_threads.select! {|t| t.status}
+        run_hooks(@after_kills)
+        @finish_all = false
         
-        # 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)
+      nil end
+      
+      def process_item(x)
+        x, waiting_thread = x
+        string, event, blocking, proc = x
+        
+        # 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)
+              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 $@
-    nil end
+      
+      nil end
+      
+      def unhandled_exception(x)
+        $stderr.puts $!
+        $stderr.puts $@
+      nil end
+    end
   end
-end
+end