wires 0.5.8 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b26a6c6020e7909d89cd9a3f87da0e721ffe9ea
-  data.tar.gz: 021904136183e2874fb7cc9e054642cf1a8dd04b
+  metadata.gz: ed1477b941ed3c64b10f1d6d7f0087fc17f07aad
+  data.tar.gz: db91d0d10df1770328f942a8f4febe4be4c90502
 SHA512:
-  metadata.gz: 46a6c48fe72d56da690f27811eac4087560c1b7eb24e53c1e066543eb3036add3965706092a19ba6dfd6a7275f7a6a7a74c8cda5318426b3fff3b747ac00f081
-  data.tar.gz: f2d03f3ff04f99d04158b6170f02b44f661b1bc171c1f275a0898e95bbeda923a5f080a011ee6b1b87545b03321f2d81fd2e298b9d7d20a96731f0ce202e7b12
+  metadata.gz: d179bf2b1d6d0642ef84483c9f8521f49f8628bd676dd11a87da1d9108da152827ed657887e43dd6458ddaa10eb7b027941644578243844c8370249584dfb20c
+  data.tar.gz: f88af8249cceebf4774de1ba33e60bb9f203d5d0da6f13fdadb128ea0fc244cbb35bb717e50c0f573b3feea95dcf73418897bc8122236e612fa85ce0d20ccda5

data/LICENSE

@@ -1,2 +1,2 @@
-Copyright (c) 2013 : Joe McIlvain
+Copyright 2013-2014 Joe McIlvain
 All rights reserved.

data/README.md

@@ -1,6 +1,9 @@
 Wires
 =====
 
+[![Build Status](https://travis-ci.org/jemc/wires.png)](https://travis-ci.org/jemc/wires)
+[![Gem Version](https://badge.fury.io/rb/wires.png)](http://badge.fury.io/rb/wires)
+
 A lightweight, extensible asynchronous event routing framework in Ruby.
 
 Patch your objects together with wires.

data/lib/wires/base.rb

@@ -1,6 +1,7 @@
 
 require 'thread'
 require 'threadlock'
+require 'ref'
 
 
 module Wires
@@ -44,10 +45,10 @@ loader = Proc.new do |path|
 end
 
 loader.call 'base/util/hooks'
-loader.call 'base/util/build_alt'
+loader.call 'base/util/router_table'
 
 loader.call 'base/event'
-loader.call 'base/hub'
+loader.call 'base/launcher'
 loader.call 'base/router'
 loader.call 'base/channel'
 loader.call 'base/time_scheduler_item'

data/lib/wires/base/actor.rb

@@ -0,0 +1,204 @@
+
+module Wires.current_network::Namespace
+  
+  # A module to aid in making objects that interact with {Wires}.
+  #
+  # Because event handlers created with {Channel#register} or {Convenience#on}
+  # are global and permanent (until unregistered), other {Wires} patterns
+  # are more conducive to global or singleton structures, but an {Actor}
+  # can easily be more transient and dynamic.
+  #
+  # An {Actor} marks one or more of its methods as event handlers with
+  # {ClassMethods#handler} or {#handler}, and indicates the channels to 
+  # listen on with {#listen_on}. Events fired on those channels will generate
+  # invocations of the corresponding marked event handler methods.
+  #
+  # A basic {Actor} might look something like this:
+  #
+  #  class Node
+  #    include Wires::Actor
+  #    
+  #    def initialize(instream, outstream)
+  #      @instream  = instream
+  #      @outstream = outstream
+  #      @pending_ids = []
+  #      listen_on self, :in=>@instream, :out=>@outstream
+  #    end
+  #    
+  #    def request(id, command, payload)
+  #      if command_valid? command, payload
+  #        fire :pending[id], @outstream
+  #        fire :process[id, command, payload], self
+  #      else
+  #        fire :invalid[id], @outstream
+  #      end
+  #    end
+  #    handler :request, :channel=>:in
+  #    
+  #    private
+  #    
+  #    def command_valid?(command, payload)
+  #      # ...
+  #      # Return true if the command is determined to be valid, else false
+  #      # ...
+  #    end
+  #    
+  #    def process(id, command, payload)
+  #      # ...
+  #      # Do some time consuming operation to produce a result
+  #      # ...
+  #      @pending_ids -= [id]
+  #      fire :done[id, result], @outstream
+  #    end
+  #    handler :process
+  #    
+  #    def track_pending(id)
+  #      @pending_ids << id
+  #    end
+  #    handler :track_pending, :event=>:pending, :channel=>:out
+  #  end
+  #
+  module Actor
+    include Wires::Convenience
+    
+    # When included into a class, extend {ClassMethods} in.
+    #
+    def self.included(obj)
+      obj.extend ClassMethods
+    end
+    
+    # Define the list of channels that the Actor's handlers listen on.
+    # Each subsequent call to {#listen_on} will overwrite the last call,
+    # so the entire list of tagged and untagged channels should be specified
+    # all in one invocation.
+    #
+    # @param channels [Array] The untagged channels to listen_on.
+    #   An event fired on any one of these channels will be routed to any
+    #   {#handler} that did not specify a :channel when {#handler} was
+    #   invoked.  Each object in the array is treated as the {Channel#name},
+    #   unless it is itself a {Channel} object.
+    #
+    # @param coded_channels [Hash] The tagged channels to listen_on,
+    #   with each key symbol as the channel code, and each value treated as
+    #   the {Channel#name} (or {Channel} object).
+    #   An event fired on the given channel will be routed to any
+    #   {#handler} that specified the same :channel when {#handler} was
+    #   invoked.
+    #
+    # @TODO handle Channel objects instead of names 
+    # @TODO handle Channel matching correctly (respecting Router)
+    #
+    def listen_on(*channels, **coded_channels)
+      @_wires_actor_listen_proc ||= Proc.new do |e,c|
+        e = e.dup
+        e.kwargs[:_wires_actor_original_channel] = c
+        @_wires_actor_channel.fire! e
+      end
+      
+      unreg = Proc.new { |c| Channel[c].unregister &@_wires_actor_listen_proc }
+      reg = Proc.new { |c| Channel[c].register :*, &@_wires_actor_listen_proc }
+      
+      @_wires_actor_coded_channels ||= {nil=>[]}
+      
+      old_channels       = @_wires_actor_coded_channels.delete nil
+      old_coded_channels = @_wires_actor_coded_channels
+      
+      old_channels.each              &unreg
+      old_coded_channels.values.each &unreg
+      
+      channels.each              &reg
+      coded_channels.values.each &reg
+      
+      @_wires_actor_coded_channels      = coded_channels.dup
+      @_wires_actor_coded_channels[nil] = channels
+      
+      nil
+    end
+    
+    # Mark a method by name to receive events of the same type name on the
+    # channels specified by the most recent call to {#listen_on}. By default,
+    # the method is called with the arguments used in {Event} creation.
+    #
+    # @param method_name [Symbol] The name of the instance method to mark
+    #   as an event handler.
+    # @param event [Symbol] The type of events to listen for.
+    # @param channel [Symbol] The channel code corresponding to one of
+    #   the keywords to be used in a call to {#listen_on}. This channel code
+    #   is used rather than a literal {Channel#name} because the name may or
+    #   may not be known at the time of {#handler} call; the code will be
+    #   resolved to an actual {Channel#name} at time of event reception
+    #   based on the last call to {#listen_on}. If no channel is 
+    #   specified, the handler will listen for the event on the untagged
+    #   channels specified in {#listen_on}.
+    #
+    # @param expand [Boolean] Specify the form of the arguments to be
+    #   passed to the method when called. This argument is +true+ by default,
+    #   indicating the default behavior of passing the arguments used in
+    #   {Event} creation.  If +false+ is specified, the method will receive
+    #   the same arguments a block registered as an event handler with
+    #   {Channel#register} or {Convenience#on} would receive - namely,
+    #   the {Event} object and the {Channel#name} that it was fired on.
+    #
+    def handler(method_name,
+                event:   method_name,
+                channel: nil,
+                expand:  true)
+      @_wires_actor_handler_procs << (
+        @_wires_actor_channel.register event, weak:true do |e|
+          orig_channel = e.kwargs.delete :_wires_actor_original_channel
+          
+          channel_list = @_wires_actor_coded_channels[channel]
+          channel_list = [channel_list] unless channel_list.is_a? Array
+          
+          if channel_list.include? orig_channel
+            if expand
+              send method_name, *e.args, **e.kwargs, &e.codeblock
+            else
+              send method_name, e, orig_channel
+            end
+          end
+        end
+      )
+      
+      nil
+    end
+    
+    # A collection of methods to aid in class definitions that include {Actor}.
+    # This module gets extended into the class object by {Actor.included}.
+    #
+    module ClassMethods
+      
+      # This method is used in class definitions to mark a method as an event
+      # handler. This creates a delayed call to {Actor#handler} upon instance
+      # object creation inside {#new}.
+      #
+      # Refer to the argument specification in {Actor#handler}, because
+      # arguments are passed on verbatim.
+      #
+      def handler(*args)
+        @_wires_actor_handlers ||= []
+        @_wires_actor_handlers << args
+        
+        nil
+      end
+      
+      # On object creation, transfer any handlers specified with {#handler}
+      # in the class definition into the instance object created.
+      #
+      def new(*args, &block)
+        super(*args, &block).tap do |obj|
+          obj.instance_eval do
+            @_wires_actor_channel = Channel.new Object.new
+            @_wires_actor_handler_procs = []
+            @_wires_actor_handlers = 
+              self.class.instance_variable_get(:@_wires_actor_handlers) || []
+            
+            @_wires_actor_handlers.each { |a| handler(*a) }
+          end
+        end
+      end
+      
+    end
+  end
+  
+end

data/lib/wires/base/channel.rb

@@ -10,9 +10,9 @@ module Wires.current_network::Namespace
   # level, so registering a hook will affect all instances of {Channel}. 
   # There are two hooks types that {Channel} will invoke:
   # * +:@before_fire+ - yields the event object and channel {#name} to the 
-  #   user block before {#fire} invokes {Hub.spawn} (see source code).
+  #   user block before {#fire} invokes {Launcher.spawn} (see source code).
   # * +:@after_fire+ - yields the event object and channel {#name} to the 
-  #   user block after {#fire} invokes {Hub.spawn} (see source code).
+  #   user block after {#fire} invokes {Launcher.spawn} (see source code).
   class Channel
     
     # The unique name of the channel, which can be any kind of hashable object.
@@ -20,7 +20,7 @@ module Wires.current_network::Namespace
     # Because it is unique, a reference to the channel may be obtained from 
     # the class-level method {Channel.[] Channel[]} using only the {#name}.
     #
-    attr_reader :name
+    def name; @name.object end
     
     # An array specifying the exception type and string to raise if {#fire} is
     # called, or +nil+ if it's okay to {#fire} from this channel.
@@ -33,8 +33,6 @@ module Wires.current_network::Namespace
     # @return [String] friendly output showing the class and channel {#name}
     def inspect; "#{self.class}[#{name.inspect}]"; end
     
-    @hub    = Hub
-    @router = Router::Default
     @new_lock = Monitor.new
     @@aim_lock = Mutex.new # @api private
     
@@ -42,13 +40,6 @@ module Wires.current_network::Namespace
     
     class << self
       
-      # The currently selected {Hub} for all channels ({Hub} by default).
-      #
-      # It is the {Hub}'s responsibility to execute event handlers.
-      # @api private
-      #
-      attr_accessor :hub
-      
       # The currently selected {Router} for all channels 
       # ({Router::Default} by default).
       #
@@ -78,10 +69,29 @@ module Wires.current_network::Namespace
       #
       def new(name)
         channel = @new_lock.synchronize do
-          router.get_channel(self, name) { |name| super(name) }
+          router.get_channel(name) { |name| super(name) }
         end
       end
+      
       alias_method :[], :new
+      
+      # Forget a channel by {#name}.  All registered handlers are forgotten,
+      # and a future attempt to access the channel object by name will create 
+      # a new object.
+      #
+      # The work of forgetting the object with the given {#name} is delegated 
+      # to the currently selected {.router}.
+      #
+      # @param name [#hash] a hashable object of any type as the channel {#name}
+      #
+      # @return [nil]
+      #
+      def forget(name)
+        @new_lock.synchronize do
+          router.forget_channel(name)
+        end
+        nil
+      end
     end
     
     # Assigns the given +name+ as the {#name} of this channel object
@@ -89,8 +99,8 @@ module Wires.current_network::Namespace
     # @param name [#hash] a hashable object of any type, unique to this channel
     #
     def initialize(name)
-      @name = name
-      @handlers = {}
+      @name = RouterTable::Reference.new name
+      @handlers = []
     end
     
     # Register an event handler to be executed when a matching event occurs.
@@ -121,36 +131,33 @@ module Wires.current_network::Namespace
     # @raise [ArgumentError] if no ampersand-argument or inline block is 
     #   given as the +&callable+.
     #
-    def register(*events, &callable)
+    def register(*events, weak:false, &callable)
       raise ArgumentError, "No callable given to execute on event: #{events}" \
         unless callable.respond_to? :call
       events = Event.list_from *events
       
-      # Register the events under the callable in the @handlers hash
+      ref = weak ? Ref::WeakReference.new(callable) :
+                   Ref::StrongReference.new(callable)
       @@aim_lock.synchronize do
-        ary = (@handlers.has_key?(callable) ?
-                 @handlers[callable]        :
-                 @handlers[callable] = [])
-        events.each { |e| ary << e unless ary.include? e }
+        self.class.router.hold_channel name if @handlers.empty?
+        @handlers << [events, ref]
+        callable.extend RegisteredHandler
+        callable.register_on_channel self
       end
       
-      # Insert the @registered_channels variable into the callable
-      channels = callable.instance_variable_get(:@registered_channels)
-      if channels
-        channels << self
-      else
-        callable.instance_variable_set(:@registered_channels, [self])
+      callable
+    end
+    
+    module RegisteredHandler
+      def register_on_channel(channel)
+        (@registered_channels ||= []) << channel
       end
       
-      # Insert the #unregister method into the callable
-      callable.singleton_class.send :define_method, :unregister do
-        singleton_class.send :remove_method, :unregister
+      def unregister
         @registered_channels.each do |c|
           c.unregister &self
-        end
-      end unless callable.respond_to? :unregister
-      
-      callable
+        end.tap { @registered_channels = [] }
+      end
     end
     
     # Unregister an event handler that was defined with #register
@@ -181,7 +188,10 @@ module Wires.current_network::Namespace
     #
     def unregister(&callable)
       @@aim_lock.synchronize do
-        !!(@handlers.delete callable)
+        !!@handlers.reject! do |stored|
+          stored.last.object == callable
+        end
+        .tap { self.class.router.release_channel name if @handlers.empty? }
       end
     end
     
@@ -191,7 +201,8 @@ module Wires.current_network::Namespace
     #   containing an array of event patterns followed by the associated Proc.
     #
     def handlers
-      @handlers.map { |callable, events| [events, callable] }
+      @handlers.reject! { |_, ref| ref.object.nil? }
+      @handlers.map { |events, ref| [events, ref.object] }
     end
     
     # Fire an event on this channel.
@@ -254,7 +265,7 @@ module Wires.current_network::Namespace
       
       # Fire to selected targets
       threads = procs.uniq.map do |pr|
-        self.class.hub.spawn \
+        Launcher.spawn \
           event,     # fired event object event
           self.name, # name of channel fired from
           pr,        # proc to execute
@@ -453,5 +464,8 @@ module Wires.current_network::Namespace
       self.class.router.get_receivers self
     end
     
+    Channel.router = Router::Default
+    Router::Default.clear_channels
+    Router::Simple.clear_channels
   end
 end

data/lib/wires/base/event.rb

@@ -40,6 +40,16 @@ module Wires.current_network::Namespace
     # Directly access contents of @kwargs by key
     def [](key); @kwargs[key]; end
     
+    # Duplicate this event, ensuring that the args Array and kwargs Hash are
+    #   not the same object, and receivers of an event can't modify that
+    #   Array or Hash in ways that might affect other receivers of the event
+    def dup
+      super.tap do |e|
+        e.args   = e.args.dup
+        e.kwargs = e.kwargs.dup
+      end
+    end
+    
     # Returns true if all meaningful components of two events are equal
     # Use #equal? instead if you want object identity comparison
     def ==(other)

data/lib/wires/base/{hub.rb → launcher.rb}

@@ -1,8 +1,8 @@
 
 module Wires.current_network::Namespace
-  # An Event Hub. Event/proc associations come in, and the procs 
+  # An Event Launcher. Event/proc associations come in, and the procs 
   # get called in new threads in the order received
-  class Hub
+  class Launcher
     class << self
       
       # Refuse to instantiate; it's a singleton!

data/lib/wires/base/router.rb

@@ -1,67 +1,113 @@
 
 module Wires.current_network::Namespace
-  module Router
+  class Channel; end
+  
+  class Router
     
-    class Default
-      class << self
-        # Refuse to instantiate; it's a singleton!
-        private :new
-        
-        def clear_channels()
-          @table       = {}
-          @fuzzy_table = {}
-          @star        = nil
-        end
-        
-        def get_channel(chan_cls, name)
-          @chan_cls ||= chan_cls
-          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
-          return @table.values if name == '*'
-          
-          @fuzzy_table.each_pair.select do |k,v|
-            (begin; name =~ k; rescue TypeError; end)
-          end.map { |k,v| v } + [chan, (@star||=@chan_cls['*'])]
-        end
+    class Category
+      def initialize(name)
+        @name = name
+        @table = RouterTable.new
+        @exclusive = true
+        @qualifiers = []
+        @executions = []
         
+        yield self if block_given?
       end
-      clear_channels
+      
+      attr_reader :name
+      attr_reader :table
+      attr_accessor :exclusive
+      attr_accessor :qualifiers
+      attr_accessor :executions
+      
+      def qualify(&block) @qualifiers << block unless block.nil? end
+      def execute(&block) @executions << block unless block.nil? end
     end
     
+    attr_accessor :refreshes
+    def refresh(&block) @refreshes << block unless block.nil? end
     
-    class Simple
-      class << self
-        # Refuse to instantiate; it's a singleton!
-        private :new
-        
-        def clear_channels()
-          @table = {}
-        end
-        
-        def get_channel(chan_cls, name)
-          @table[name] ||= yield name
-        end
-        
-        def get_receivers(chan)
-          [chan]
+    def initialize(&block)
+      @refreshes = []
+      
+      singleton_class.class_exec self, &block if block
+      category :all unless @categories
+    end
+    
+    def category sym, &block
+      @categories ||= []
+      @categories << [sym, Category.new(sym, &block)]
+    end
+    
+    def table(key)
+      Hash[@categories][key].table
+    end
+    
+    def clear_channels
+      @categories.map(&:last).each { |c| c.table.clear }
+      @refreshes.each { |r| instance_eval &r }
+    end
+    
+    def get_channel(name, &block)
+      channel = nil
+      @categories.map(&:last).each do |c|
+        if c.qualifiers.map { |q| instance_exec name, &q }.all?
+          channel = (c.table[name] ||= (channel or yield name))
+          c.executions.each { |e| instance_exec channel, &e }
+          return channel if c.exclusive
         end
-        
       end
-      clear_channels
+      channel
+    end
+    
+    def get_receivers(chan)
+      [chan]
+    end
+    
+    def forget_channel(name)
+      @categories.map(&:last).each { |c| c.table.delete name }
+    end
+    
+    def hold_channel(name)
+      @categories.map(&:last).each { |c| c.table.make_strong name }
+    end
+    
+    def release_channel(name)
+      @categories.map(&:last).each { |c| c.table.make_weak name }
     end
     
     
+    Simple = Router.new
+    
+    Default = Router.new do |r|
+      r.category :star do |c|
+        c.qualify { |name| @star and name == '*' }
+        c.execute { |chan| @star = chan }
+      end
+      r.category :fuzzy do |c|
+        c.exclusive = false
+        c.qualify { |name| name.is_a? Regexp }
+        c.execute { |chan| chan.not_firable = [TypeError,
+              "Cannot fire on Regexp channel: #{chan.name.inspect}."\
+              "  Regexp channels can only used in event handlers."] }
+      end
+      r.category :main
+      
+      r.refresh { @star = Channel['*'.freeze] }
+      
+      def get_receivers(chan)
+        name = chan.name
+        if name == '*'
+          table(:main).values
+        else
+          table(:fuzzy).each_pair.select do |k,v|
+            (begin; name =~ k; rescue TypeError; end)
+          end.map { |k,v| v } + [chan, @star]
+        end
+      end
+    end
+    
   end
+  
 end

data/lib/wires/base/util/router_table.rb

@@ -0,0 +1,143 @@
+
+module Wires.current_network::Namespace
+  
+  class RouterTable
+    
+    class Reference
+      attr_reader :ref
+      def object; @ref.object; end
+      def weak?; @weak end
+      
+      def initialize(obj)
+        raise ValueError "#{self.class} referent cannot be nil" if obj.nil?
+        
+        # Make initial weak reference (if possible)
+        begin
+          @ref = Ref::WeakReference.new obj
+          @weak = true
+        rescue RuntimeError;
+          @ref = Ref::StrongReference.new obj
+          @weak = false
+        end
+      end
+      
+      def make_weak
+        unless @weak
+          @ref = Ref::WeakReference.new @ref.object
+          @weak = true
+        end
+      rescue RuntimeError
+      end
+      
+      def make_strong
+        if @weak
+          @ref = Ref::StrongReference.new @ref.object
+          @weak = false
+        end
+      end
+      
+      def inspect
+        "<##{self.class} #{object.nil? ? "#Object not available" : object.inspect}>"
+      end
+    end
+    
+  end
+  
+  
+  class RouterTable
+    include Enumerable
+    
+    def initialize
+      @keys = {}
+      @key_ids = {}
+      @values = {}
+      @lock = Mutex.new
+      @finalizer = lambda { |id| remove_reference_to_key id }
+    end
+    
+    def [](key)
+      @lock.synchronize do
+        ref = @values[@key_ids[key.hash]]
+        ref.object if ref
+      end
+    end
+    
+    def []=(key, value)
+      begin; ObjectSpace.define_finalizer key, @finalizer
+      rescue RuntimeError; end
+      
+      @lock.synchronize do
+        id    = key.object_id
+        key   = RouterTable::Reference.new key
+        value = RouterTable::Reference.new value
+        
+        @keys[id] = key
+        @values[id] = value
+        @key_ids[key.object.hash] = id
+      end
+    end
+    
+    def delete(key)
+      @lock.synchronize do
+        id = @key_ids[key.hash]
+        @key_ids.delete key.hash
+        @keys.delete id
+        @values.delete id
+      end
+    end
+    
+    def clear
+      @lock.synchronize do
+        @keys.clear
+        @values.clear
+        @key_ids.clear
+      end
+      nil
+    end
+    
+    def keys;     @keys.values.map(&:object) end
+    def values; @values.values.map(&:object) end
+    
+    def each
+      Enumerator.new do |y|
+        @key_ids.values.each do |id|
+          key = @keys[id]
+          val = @values[id]
+          y << [key.object,val.object] unless key.nil? or val.nil?
+        end
+      end.each
+    end
+    alias_method :each_pair, :each
+    
+    def make_weak(key)
+      @lock.synchronize do
+        id = @key_ids[key.hash]
+        kref = @keys[id]
+        vref = @values[id]
+        kref.make_weak if kref
+        vref.make_weak if vref
+      end
+    end
+    
+    def make_strong(key)
+      @lock.synchronize do
+        id = @key_ids[key.hash]
+        kref = @keys[id]
+        vref = @values[id]
+        kref.make_strong if kref
+        vref.make_strong if vref
+      end
+    end
+    
+  private
+    
+    def remove_reference_to_key(object_id)
+      @lock.synchronize do
+        @key_ids.delete_if { |k,v| v==object_id }
+        @keys.delete object_id
+        @values.delete object_id
+      end
+    end
+  end
+  
+end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.6.0
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-05 00:00:00.000000000 Z
+date: 2014-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: threadlock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ref
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -137,7 +151,6 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: A lightweight, extensible asynchronous event routing framework in Ruby.
-  Patch your objects together with wires. Inspired by the python 'circuits' framework.
 email: joe.eli.mac@gmail.com
 executables: []
 extensions: []
@@ -147,15 +160,16 @@ files:
 - README.md
 - lib/wires.rb
 - lib/wires/base.rb
+- lib/wires/base/actor.rb
 - lib/wires/base/channel.rb
 - lib/wires/base/convenience.rb
 - lib/wires/base/event.rb
-- lib/wires/base/hub.rb
+- lib/wires/base/launcher.rb
 - lib/wires/base/router.rb
 - lib/wires/base/time_scheduler.rb
 - lib/wires/base/time_scheduler_item.rb
-- lib/wires/base/util/build_alt.rb
 - lib/wires/base/util/hooks.rb
+- lib/wires/base/util/router_table.rb
 - lib/wires/core_ext.rb
 - lib/wires/core_ext/numeric.rb
 - lib/wires/core_ext/symbol.rb

data/lib/wires/base/util/build_alt.rb

@@ -1,18 +0,0 @@
-
-module Wires.current_network::Namespace
-  module Util
-    
-    # Build an alternate version of the Wires module that doesn't 
-    # know about or interfere with the original Wires module.
-    # Specify the module_path as a string, starting with global locator '::':
-    # >> module MyModule; end
-    # >> Wires::Util.build_alt "::MyModule::MyWires"
-    def self.build_alt(module_path)
-      warn "DEPRECATED: Wires::Util.build_alt('::MyModule::MyWires')"\
-           " is deprecated, and will be removed in version 0.6."\
-           "  Please use ::MyModule::MyWires=Wires.replicate"
-      eval "#{module_path} = Wires.replicate"
-    end
-    
-  end
-end