wires 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3c79a4bb96ed3a79e94be39171fda18a4846025
-  data.tar.gz: 7dd1087d9f74885e1bbbf4a25d70e07ae98919e9
+  metadata.gz: 6396df6f8d7307b304ef8d37d8bc75b30de47dae
+  data.tar.gz: ae25aa3fac7ea8f28944e959ed3c4c502a6ea47d
 SHA512:
-  metadata.gz: 61b8a2c4881a8fdec36257a7ea4f5bfb2d4831a0157e1a9fbe53897c3d0d83d7746ba655025fbd23903a39af623d9bbf672f798ed5d15344972fa707bedb47bb
-  data.tar.gz: 962a6bca1dfa83c565920750b46bc9699915603a1e8a5c7bf00a7984477dad2a6cea79ba5323c06ae1686362f28a45b0b5a45db969b9f44bf12369b2991840a6
+  metadata.gz: 14589e34c908c567b13163fd14f658b76b8bef1eb98ccb86fee49fed2e138d148c9f29e49c082f79311d9d1aa674a18f744a5dfacc955a0da00262160c4395c4
+  data.tar.gz: 0b51394fa0aa581c1b95a4a623851be8814b8337a63c7fce7c9c46c2eec7ecf7af47b0d4da24f171993c26b703d09f28f80125610bf8999bc3eff4b3bf9c33d4

data/lib/wires/channel.rb

@@ -10,7 +10,7 @@ module Wires
     def inspect; "#{self.class}(#{name.inspect})"; end
     
     @hub    = Hub
-    @router = Router
+    @router = Router::Default
     @new_lock = Mutex.new
     @@aim_lock = Mutex.new
     
@@ -20,7 +20,8 @@ module Wires
       
       def new(*args)
         channel = @new_lock.synchronize do
-          router.get_channel(self, *args) { |name| super(name) }        end
+          router.get_channel(self, *args) { |name| super(name) }
+        end
       end
       alias_method :[], :new
     end
@@ -33,8 +34,8 @@ module Wires
     # Register a proc to be triggered by an event on this channel
     # Return the proc that was passed in
     def register(*events, &proc)
-      if not proc.is_a?(Proc) then raise SyntaxError, \
-        "No Proc given to execute on event: #{events}" end
+      raise ArgumentError, "No callable given to execute on event: #{events}" \
+        unless proc.respond_to? :call
       events = Event.new_from(*events)
       
       @@aim_lock.synchronize do
@@ -60,7 +61,7 @@ module Wires
     
     # Add hook methods
     class << self
-      include Hooks
+      include Util::Hooks
       
       def before_fire(*args, &proc)
         add_hook(:@before_fire, *args, &proc)
@@ -72,10 +73,13 @@ module Wires
     end
     
     # Fire an event on this channel
-    def fire(input, blocking:false)
+    def fire(input, blocking:false, parallel:!blocking)
       
       raise *@not_firable if @not_firable
       
+      return [] << Thread.new { fire(input, blocking:true, parallel:false) } \
+        if !blocking and !parallel
+      
       backtrace = caller
       
       event = Event.new_from(*input)
@@ -105,22 +109,27 @@ module Wires
       end
       
       # Fire to selected targets
-      procs.uniq.each do |pr|
+      threads = procs.uniq.map 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
+          parallel,  # boolean from parallel kwarg
           backtrace  # captured backtrace
-      end
+      end.reject &:nil?
+      
+      threads.each &:join if blocking and parallel
       
       self.class.run_hooks(:@after_fire, event, self)
       
-    nil end
+      threads
+    end
     
     # Fire a blocking event on this channel
-    def fire_and_wait(event)
-      self.fire(event, blocking:true)
+    def fire!(event)
+      kwargs[:blocking] ||= true
+      fire(*args, **kwargs)
     end
     
     # Returns true if listening on 'self' would hear a firing on 'other'
@@ -135,8 +144,6 @@ module Wires
       self.class.router.get_receivers self
     end
     
-    router.clear_channels
-    
   end
   
 end

data/lib/wires/convenience.rb

@@ -25,8 +25,8 @@ module Wires
       end
     nil end
     
-    def fire_and_wait(*args, **kwargs)
-      kwargs[:blocking]=true
+    def fire!(*args, **kwargs)
+      kwargs[:blocking] ||= true
       fire(*args, **kwargs)
     end
     

data/lib/wires/core_ext.rb

@@ -18,11 +18,11 @@ module Wires
       # Add methods to ::Time and ::Numeric
       def extend_core
         # Add Time#fire for timed firing of events
-        ::Time.class_eval do
+        ::Time.class_eval <<-CODE
           def fire(event, channel='*', **kwargs)
-            Wires::TimeScheduler.add(self, event, channel, **kwargs)
+            #{TimeScheduler}.add(self, event, channel, **kwargs)
           end
-        end
+        CODE
           
         # Add Numeric => Numeric time-factor converters
         {

data/lib/wires/hub.rb

@@ -66,22 +66,22 @@ module Wires
         return neglect(*args) \
           if @hold_lock.instance_variable_get(:@mon_mutex).locked?
         
-        event, chan, proc, blocking, fire_bt = *args
+        event, chan, proc, blocking, parallel, fire_bt = *args
         *proc_args = event, chan
         *exc_args  = event, chan, fire_bt
         
-        # If blocking, run the proc in this thread
-        if blocking
+        # If not parallel, run the proc in this thread
+        if !parallel
           begin
             proc.call(*proc_args)
           rescue Exception => exc
             unhandled_exception(exc, *exc_args)
           end
           
-          return :done
+          return nil
         end
         
-        # If not blocking, clear old threads and spawn a new thread
+        # If not parallel, clear old threads and spawn a new thread
         Thread.exclusive do
           begin
             # Raise ThreadError for user-set thread limit to mimic OS limit
@@ -94,7 +94,7 @@ module Wires
               rescue Exception => exc
                 unhandled_exception(exc, *exc_args)
               ensure
-                spawn_neglected_task_chain
+                spawn_neglected_task_chain unless blocking
                 @children.synchronize { @children.delete Thread.current }
               end
             end
@@ -112,11 +112,12 @@ module Wires
       
       # Join child threads, one by one, allowing more children to appear
       def join_children
-        a_thread = Thread.new{nil}
-        while a_thread
+        a_thread = nil
+        loop do
           @children.synchronize do
             a_thread = @children.shift
           end
+          break unless a_thread
           a_thread.join if ((a_thread) and (a_thread!=Thread.current))
           Thread.pass
         end

data/lib/wires/router.rb

@@ -1,42 +1,64 @@
 
 module Wires
-  
-  class Router
+  module 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."]
+    class Default
+      class << self
+        
+        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
         
-        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['*']]
+      clear_channels
+    end
+    
+    
+    class Simple
+      class << self
+        
+        def clear_channels()
+          @table = {}
+        end
+        
+        def get_channel(chan_cls, name)
+          @table[name] ||= yield name
+        end
+        
+        def get_receivers(chan)
+          [chan]
+        end
+        
       end
-      
+      clear_channels
     end
+    
+    
   end
-  
 end

data/lib/wires/time_scheduler.rb

@@ -0,0 +1,63 @@
+
+module Wires
+  
+  # A singleton class to schedule future firing of events
+  class TimeScheduler
+    @schedule       = Array.new
+    @thread         = Thread.new {nil}
+    @schedule_lock  = Monitor.new
+    @cond           = @schedule_lock.new_cond
+    
+    class << self
+      
+      # Add an event to the schedule
+      def add(*args)
+        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_lock.synchronize { @schedule.dup } end
+      # Clear the event schedule from outside the class
+      def clear; @schedule_lock.synchronize { @schedule.clear } end
+      # Make the scheduler wake up and re-evaluate
+      def refresh; schedule_update end
+      
+    private
+      
+      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
+      nil end
+      
+      def main_loop
+        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
+    
+    @thread = Thread.new { main_loop }
+    
+  end
+  
+end

data/lib/wires/{time.rb → time_scheduler_item.rb}

@@ -1,8 +1,6 @@
 
 module Wires
   
-  class TimeSchedulerAnonEvent < Event; end
-  
   class TimeSchedulerItem
     
     attr_reader :time, :event, :channel, :interval
@@ -14,7 +12,6 @@ module Wires
                    **kwargs)
       
       time ||= Time.now
-      expect_type time, Time
       
       @active = (not cancel)
       tempcount = count
@@ -81,63 +78,4 @@ module Wires
                :count_dec
   end
   
-  # A singleton class to schedule future firing of events
-  class TimeScheduler
-    @schedule       = Array.new
-    @thread         = Thread.new {nil}
-    @schedule_lock  = Monitor.new
-    @cond           = @schedule_lock.new_cond
-    
-    class << self
-      
-      # Add an event to the schedule
-      def add(*args)
-        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_lock.synchronize { @schedule.dup } end
-      # Clear the event schedule from outside the class
-      def clear; @schedule_lock.synchronize { @schedule.clear } end
-      # Make the scheduler wake up and re-evaluate
-      def refresh; schedule_update end
-      
-    private
-      
-      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
-      nil end
-      
-      def main_loop
-        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
-    
-    @thread = Thread.new { main_loop }
-    
-  end
-  
 end

data/lib/wires/util/build_alt.rb

@@ -0,0 +1,22 @@
+
+module Wires
+  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)
+      main_file = File.expand_path("../../wires.rb", File.dirname(__FILE__))
+      
+      File.read(main_file)
+        .scan(/require_relative[\s\(]+(["'])(.*)\1/)
+        .map(&:last)
+        .map  { |file| File.expand_path("#{file}.rb", File.dirname(main_file)) }
+        .map  { |file| File.read file }
+        .each { |code| eval code.gsub("Wires", "#{module_path}") }
+    end
+    
+  end
+end

data/lib/wires/util/hooks.rb

@@ -1,56 +1,58 @@
 
 module Wires
-  module Hooks
-    
-    # Register a hook - can be called multiple times if retain is true
-    def add_hook(hooks_sym, retain=false, &proc)
-      hooks = instance_variable_get(hooks_sym.to_sym)
-      if hooks
-        hooks << [proc, retain]
-      else
-        instance_variable_set(hooks_sym.to_sym, [[proc, retain]])
-      end
-      proc
-    end
-    
-    # Remove a hook by proc reference
-    def remove_hook(hooks_sym, &proc)
-      hooks = instance_variable_get(hooks_sym.to_sym)
-      return unless hooks
-      hooks.reject! {|h| h[0]==proc}
-    end
-    
-    # Run all hooks, deleting those not marked for retention
-    def run_hooks(hooks_sym, *exc_args)
-      hooks = instance_variable_get(hooks_sym.to_sym)
-      return unless hooks
-      for hook in hooks
-        proc, retain = hook
-        proc.call(*exc_args)
+  module Util
+    module Hooks
+      
+      # Register a hook - can be called multiple times if retain is true
+      def add_hook(hooks_sym, retain=false, &proc)
+        hooks = instance_variable_get(hooks_sym.to_sym)
+        if hooks
+          hooks << [proc, retain]
+        else
+          instance_variable_set(hooks_sym.to_sym, [[proc, retain]])
+        end
+        proc
       end
-    nil end
-    
-    # Clear hooks not marked for retention (or all hooks if force)
-    def clear_hooks(hooks_sym, force=false)
-      hooks = instance_variable_get(hooks_sym.to_sym)
-      return unless hooks
-      (force ? hooks.clear : hooks.select!{|h| h[1]})
-    nil end
-    
-    # Flush/run all hooks, keeping only those marked for retention
-    def flush_hooks(hooks_sym, *exc_args)
-      hooks = instance_variable_get(hooks_sym.to_sym)
-      return unless hooks
-      retained = Queue.new
-      while not hooks.empty?
-        proc, retain = hooks.shift
-        retained << [proc, retain] if retain
-        proc.call(*exc_args)
+      
+      # Remove a hook by proc reference
+      def remove_hook(hooks_sym, &proc)
+        hooks = instance_variable_get(hooks_sym.to_sym)
+        return unless hooks
+        hooks.reject! {|h| h[0]==proc}
       end
-      while not retained.empty?
-        hooks << retained.shift
+      
+      # Run all hooks, deleting those not marked for retention
+      def run_hooks(hooks_sym, *exc_args)
+        hooks = instance_variable_get(hooks_sym.to_sym)
+        return unless hooks
+        for hook in hooks
+          proc, retain = hook
+          proc.call(*exc_args)
+        end
+      nil end
+      
+      # Clear hooks not marked for retention (or all hooks if force)
+      def clear_hooks(hooks_sym, force=false)
+        hooks = instance_variable_get(hooks_sym.to_sym)
+        return unless hooks
+        (force ? hooks.clear : hooks.select!{|h| h[1]})
+      nil end
+      
+      # Flush/run all hooks, keeping only those marked for retention
+      def flush_hooks(hooks_sym, *exc_args)
+        hooks = instance_variable_get(hooks_sym.to_sym)
+        return unless hooks
+        retained = Queue.new
+        while not hooks.empty?
+          proc, retain = hooks.shift
+          retained << [proc, retain] if retain
+          proc.call(*exc_args)
+        end
+        while not retained.empty?
+          hooks << retained.shift
+        end
       end
-    end
     
+    end
   end
 end

data/lib/wires.rb

@@ -1,14 +1,15 @@
 
 require 'thread'
-require 'threadlock' # Easily add re-entrant lock to instance methods
+require 'threadlock'
 
-require_relative 'wires/util/expect_type'
 require_relative 'wires/util/hooks'
+require_relative 'wires/util/build_alt'
 
 require_relative 'wires/event'
 require_relative 'wires/hub'
 require_relative 'wires/router'
 require_relative 'wires/channel'
-require_relative 'wires/time'
+require_relative 'wires/time_scheduler_item'
+require_relative 'wires/time_scheduler'
 require_relative 'wires/core_ext'
 require_relative 'wires/convenience'

metadata

@@ -1,87 +1,88 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-19 00:00:00.000000000 Z
+date: 2013-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: threadlock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rake
   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'
 - !ruby/object:Gem::Dependency
   name: wires-test
   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'
 - !ruby/object:Gem::Dependency
   name: jemc-reporter
   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.
+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: []
 extra_rdoc_files: []
 files:
 - lib/wires.rb
-- lib/wires/time.rb
 - lib/wires/hub.rb
 - lib/wires/router.rb
 - lib/wires/core_ext.rb
-- lib/wires/util/expect_type.rb
+- lib/wires/util/build_alt.rb
 - lib/wires/util/hooks.rb
 - lib/wires/convenience.rb
 - lib/wires/channel.rb
+- lib/wires/time_scheduler_item.rb
+- lib/wires/time_scheduler.rb
 - lib/wires/event.rb
 - LICENSE
 - README.md
@@ -95,17 +96,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.1.5
 signing_key: 
 specification_version: 4
 summary: wires

data/lib/wires/util/expect_type.rb

@@ -1,6 +0,0 @@
-
-def expect_type(x, type)
-  unless x.is_a? type
-    raise "Expected #{x.inspect} to be an instance of #{type}."
-  end
-end