wires 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b7c2dd1598b631eb5b5db562ca8fcc480c7e5bd
-  data.tar.gz: c04825a10cddd424a1e7a3dcab51c92106d72d94
+  metadata.gz: 04ad9bc6ef2ce9a54aad3343c13fca6ca69f1895
+  data.tar.gz: cf519182f4a9cd03776cb749d3bd922aeb5add3a
 SHA512:
-  metadata.gz: 1fa7da548738147947d300b015d6f6e3e0c1317429af697a41aa933b1f7f912402c45e367e7d43dc51d915aa7dd3a171b220c015108e9ca68758adec644d34de
-  data.tar.gz: 92d1414f7dabd03d733b1fdbb9a04ee618428c6e57c03efb3df6edff6f1baaba9da9f2c95c5c7f398a970d0e3d2974bedf0ada9410a5ddfebf597d8200155132
+  metadata.gz: 435a2df3af44aa3bd5b00a3f37d7abb273cb9be65276bfb717441b64bed14bb38b2b7bbc9044c60708b66db168799172319da9ef317bfb7ac0873d23ef3a9b15
+  data.tar.gz: b753ee2f1123be7b186f59ea37bfab07ba20d737e9fde3ec931d1cbe2cefc616d1149b4021da73b010210b81a4d3987b9dc9b424cdd39444909d2de3a53cea40

data/lib/wires/{channel.rb → base/channel.rb}

@@ -4,16 +4,19 @@ module Wires
   class Channel
     
     attr_reader :name
-    attr_reader :target_list
+    attr_reader :handlers
     attr_accessor :not_firable
     
     def inspect; "#{self.class}(#{name.inspect})"; end
     
     @hub    = Hub
     @router = Router::Default
-    @new_lock = Mutex.new
+    @new_lock = Monitor.new
     @@aim_lock = Mutex.new
     
+    # Add hook methods
+    extend Util::Hooks
+    
     class << self
       attr_accessor :hub
       attr_accessor :router
@@ -28,7 +31,7 @@ module Wires
     
     def initialize(name)
       @name = name
-      @target_list = []
+      @handlers = []
     end
     
     # Register a proc to be triggered by an event on this channel
@@ -36,11 +39,11 @@ module Wires
     def register(*events, &proc)
       raise ArgumentError, "No callable given to execute on event: #{events}" \
         unless proc.respond_to? :call
-      events = Event.new_from(*events)
+      events = Event.list_from *events
       
       @@aim_lock.synchronize do
-        @target_list << [events, proc] \
-          unless @target_list.include? [events, proc]
+        @handlers << [events, proc] \
+          unless @handlers.include? [events, proc]
       end
       
       proc
@@ -48,33 +51,16 @@ module Wires
     
     # 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)
-      events = events.empty? ? [] : Event.new_from(*events)
-      
+    def unregister(proc)
       @@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?)
+        !!(@handlers.reject! do |stored_events, stored_proc|
+          proc==stored_proc
         end)
       end
     end
     
-    # Add hook methods
-    class << self
-      include Util::Hooks
-      
-      def before_fire(*args, &proc)
-        add_hook(:@before_fire, *args, &proc)
-      end
-      
-      def after_fire(*args, &proc)
-        add_hook(:@after_fire, *args, &proc)
-      end
-    end
-    
     # Fire an event on this channel
     def fire(input, blocking:false, parallel:!blocking)
-      
       raise *@not_firable if @not_firable
       
       return [] << Thread.new { fire(input, blocking:true, parallel:false) } \
@@ -82,7 +68,7 @@ module Wires
       
       backtrace = caller
       
-      event = Event.new_from(*input)
+      event = Event.list_from input
       
       case event.count
       when 0
@@ -93,14 +79,14 @@ module Wires
         raise ArgumentError,"Can't fire on multiple events: #{event.inspect}"
       end
       
-      self.class.run_hooks(:@before_fire, event, self)
+      self.class.run_hooks(:@before_fire, event, self.name)
       
       # Select appropriate targets
       procs = []
       @@aim_lock.synchronize do
         self.class.router
         .get_receivers(self).each do |chan|
-          chan.target_list.each do |elist, pr|
+          chan.handlers.each do |elist, pr|
             elist.each do |e|
               procs << pr if e =~ event
             end
@@ -121,14 +107,14 @@ module Wires
       
       threads.each &:join if blocking and parallel
       
-      self.class.run_hooks(:@after_fire, event, self)
+      self.class.run_hooks(:@after_fire, event, self.name)
       
       threads
     end
     
     # Fire a blocking event on this channel
-    def fire!(event)
-      kwargs[:blocking] ||= true
+    def fire!(*args, **kwargs)
+      kwargs[:blocking] = true unless kwargs.has_key? :blocking
       fire(*args, **kwargs)
     end
     

data/lib/wires/{convenience.rb → base/convenience.rb}

@@ -26,7 +26,7 @@ module Wires
     nil end
     
     def fire!(*args, **kwargs)
-      kwargs[:blocking] ||= true
+      kwargs[:blocking] = true unless kwargs.has_key? :blocking
       fire(*args, **kwargs)
     end
     

data/lib/wires/base/event.rb

@@ -0,0 +1,71 @@
+
+module Wires
+  
+  class Event
+    attr_accessor :type
+    attr_accessor :kwargs
+    attr_accessor :args
+    attr_accessor :codeblock
+    
+    # Return a friendly output upon inspection
+    def inspect
+      list = [*args, **kwargs]
+      list << codeblock.to_s if codeblock
+      list = list.map(&:inspect).join ', '
+      the_type = type ? type.inspect : ''
+      "#{the_type}:[#{list}]"
+    end
+    
+    # Internalize all *args and **kwargs and &block to be accessed later
+    def initialize(*args, **kwargs, &block)
+      if kwargs.has_key? :type
+        @type = kwargs[:type]
+        kwargs.delete  :type
+      else
+        @type = :*
+      end
+      
+      @args      = args
+      @kwargs    = kwargs
+      @codeblock = block
+      
+      @kwargs.keys
+        .reject{ |m| [:kwargs, :args, :codeblock].include? m }
+        .each  { |m| singleton_class.send(:define_method, m) { @kwargs[m] } }
+    end
+    
+    # Convert to a Wires::Event; returns self, unaltered
+    def to_wires_event; self; end
+    
+    # Directly access contents of @kwargs by key
+    def [](key); @kwargs[key]; end
+    
+    # Returns true if all meaningful components of two events are equal
+    # Use #equal? instead if you want object identity comparison
+    def ==(other)
+      (other = other.to_wires_event if other.respond_to? :to_wires_event) ? 
+        ((self.type      == other.type)   and
+         (self.args      == other.args)   and
+         (self.kwargs    == other.kwargs) and
+         (self.codeblock == other.codeblock)) :
+        super
+    end
+    
+    # Returns true if listening for 'self' would hear a firing of 'other'
+    # (not commutative)
+    def =~(other)
+      (other = other.to_wires_event if other.respond_to? :to_wires_event) ? 
+        (([:*, other.type].include? self.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
+    
+    # Return an array of Event instance objects from the input
+    def self.list_from(*args)
+      args.flatten.map &:to_wires_event
+    end
+    
+  end
+  
+end

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

@@ -5,6 +5,9 @@ module Wires
   class self::Hub
     class << self
       
+      # Refuse to instantiate; it's a singleton!
+      private :new
+      
       # Allow user to get/set limit to number of child threads
       attr_accessor :max_children
       
@@ -60,12 +63,9 @@ module Wires
         spawn_neglected_task_threads
       end
       
-      # Spawn a task
+      # Spawn a task - user code should never call this directly
       def spawn(*args) # :args: event, chan, proc, blocking, fire_bt
         
-        return neglect(*args) \
-          if @hold_lock.instance_variable_get(:@mon_mutex).locked?
-        
         event, chan, proc, blocking, parallel, fire_bt = *args
         *proc_args = event, chan
         *exc_args  = event, chan, fire_bt
@@ -81,6 +81,9 @@ module Wires
           return nil
         end
         
+        return neglect(*args) \
+          if @hold_lock.instance_variable_get(:@mon_mutex).locked?
+        
         # If not parallel, clear old threads and spawn a new thread
         Thread.exclusive do
           begin

data/lib/wires/{router.rb → base/router.rb}

@@ -2,9 +2,10 @@
 module Wires
   module Router
     
-    
     class Default
       class << self
+        # Refuse to instantiate; it's a singleton!
+        private :new
         
         def clear_channels()
           @table       = {}
@@ -42,6 +43,8 @@ module Wires
     
     class Simple
       class << self
+        # Refuse to instantiate; it's a singleton!
+        private :new
         
         def clear_channels()
           @table = {}

data/lib/wires/{time_scheduler.rb → base/time_scheduler.rb}

@@ -10,6 +10,9 @@ module Wires
     
     class << self
       
+      # Refuse to instantiate; it's a singleton!
+      private :new
+      
       # Add an event to the schedule
       def add(*args)
         new_item = args.first

data/lib/wires/base/time_scheduler_item.rb

@@ -0,0 +1,92 @@
+
+module Wires
+  
+  class TimeSchedulerItem
+    
+    attr_accessor :schedulers
+    attr_reader   :time, :events, :channel, 
+                  :count, :interval, :jitter
+    attr_accessor :fire_kwargs
+    
+    def initialize(time, events, channel, 
+                   count:1, interval:0, jitter:0,
+                   ignore_past:false, active:true,
+                   **fire_kwargs)
+      
+      time ||= Time.now
+      
+      @events   = Event.list_from(events)
+      @channel  = channel.is_a?(Channel) ? channel : Channel.new(channel)
+      
+      @interval = interval
+      @jitter   = jitter
+      
+      @active   = active
+      @fire_kwargs   = fire_kwargs
+      
+      tempcount = count
+      if ignore_past
+        while (time < Time.now) and (tempcount > 0)
+          time += interval
+          tempcount -= 1
+        end
+      end
+      self.count = tempcount
+      
+      @time     = time
+
+      @schedulers = []
+    end
+    
+    def active?;   @active       end
+    def active=(x) @active=x     end
+    
+    def ready?(at_time=Time.now)
+      @active and (at_time>=@time)
+    end
+    
+    def time_until(from_time=Time.now)
+      (@active ? [(@time - from_time), 0].max : nil)
+    end
+    
+    # Set @count (and apply constraints)
+    def count=(new_count)
+      @count=[new_count,0].max
+        .tap { |c| @active&&=(c>0) }
+    end
+    
+    # Inc/dec @count. Necessary because += and -= without lock are not atomic!
+    def count_inc(diff=1); self.count=(@count+diff) end
+    def count_dec(diff=1); self.count=(@count-diff) end
+    
+    # Fire the event now, regardless of time or active status
+    def fire(**kwargs) # kwargs merge with and override @kwargs
+      @channel.fire(@events, **(@fire_kwargs.merge kwargs))
+      count_dec
+      
+      if @active
+        @time = [@time, Time.now].max + (@interval + (Random.rand*2-1)*@jitter)
+      end
+      notify_schedulers
+    true end
+    
+    # Fire the event only if it is ready
+    def fire_if_ready(**kwargs)
+      self.fire(**kwargs) if ready?
+    end
+    
+  private
+    
+    def notify_schedulers
+      @schedulers.each &:refresh
+    end
+    
+    # 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
+  
+end

data/lib/wires/{util → base/util}/build_alt.rb

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

data/lib/wires/base.rb

@@ -0,0 +1,14 @@
+
+require 'thread'
+require 'threadlock'
+
+require_relative 'base/util/hooks'
+require_relative 'base/util/build_alt'
+
+require_relative 'base/event'
+require_relative 'base/hub'
+require_relative 'base/router'
+require_relative 'base/channel'
+require_relative 'base/time_scheduler_item'
+require_relative 'base/time_scheduler'
+require_relative 'base/convenience'

data/lib/wires/core_ext/numeric.rb

@@ -0,0 +1,35 @@
+
+# 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
+        Wires::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

data/lib/wires/core_ext/symbol.rb

@@ -0,0 +1,11 @@
+
+# Add implicit conversion of symbol into an event
+class ::Symbol
+  # Create a Wires::Event from any symbol with a payload of arguments
+  def [](*args, **kwargs, &block)
+    Wires::Event.new(*args, **kwargs, type:self, &block)
+  end
+  
+  # Convert to a Wires::Event; returns an empty event with type:self
+  def to_wires_event; self.[]; end
+end

data/lib/wires/core_ext/time.rb

@@ -0,0 +1,7 @@
+
+# Add Time#fire for timed firing of events
+class ::Time
+  def fire(events, channel, **kwargs)
+    Wires::TimeScheduler.add(self, events, channel, **kwargs)
+  end
+end

data/lib/wires/core_ext.rb

@@ -1,65 +1,4 @@
 
-module Wires
-  module Convenience
-    
-    @core_ext = true
-    
-    class << self
-      
-      # Set this attribute to false to disable core_ext on include
-      attr_accessor :core_ext
-      
-      # Call extend_core on include unless attribute is set to false
-      def included(*args)
-        super
-        self.extend_core if @core_ext
-      end
-      
-      # Add methods to ::Time and ::Numeric
-      def extend_core
-        # Add Time#fire for timed firing of events
-        ::Time.class_eval <<-CODE
-          def fire(event, channel='*', **kwargs)
-            #{TimeScheduler}.add(self, event, channel, **kwargs)
-          end
-        CODE
-          
-        # 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
-    
-  end
-end
+require_relative 'core_ext/symbol'
+require_relative 'core_ext/time'
+require_relative 'core_ext/numeric'

data/lib/wires.rb

@@ -1,15 +1,7 @@
 
-require 'thread'
-require 'threadlock'
+# Require all core wires functionality through 'wires/clean'
+# If you don't consent to the core extensions, require 'wires/clean' directly
+require_relative 'wires/base'
 
-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_scheduler_item'
-require_relative 'wires/time_scheduler'
+# Add core extensions for syntax sugar and ease
 require_relative 'wires/core_ext'
-require_relative 'wires/convenience'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-06 00:00:00.000000000 Z
+date: 2013-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: threadlock
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: wires-test
+  name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,63 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: jemc-reporter
+  name: pry
+  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: pry-rescue
+  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: rspec
+  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: fivemat
+  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: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -74,16 +130,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/wires.rb
-- lib/wires/hub.rb
-- lib/wires/router.rb
 - lib/wires/core_ext.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
+- lib/wires/core_ext/time.rb
+- lib/wires/core_ext/symbol.rb
+- lib/wires/core_ext/numeric.rb
+- lib/wires/base/hub.rb
+- lib/wires/base/router.rb
+- lib/wires/base/util/build_alt.rb
+- lib/wires/base/util/hooks.rb
+- lib/wires/base/convenience.rb
+- lib/wires/base/channel.rb
+- lib/wires/base/time_scheduler_item.rb
+- lib/wires/base/time_scheduler.rb
+- lib/wires/base/event.rb
+- lib/wires/base.rb
 - LICENSE
 - README.md
 homepage: https://github.com/jemc/wires/
@@ -111,3 +171,4 @@ signing_key:
 specification_version: 4
 summary: wires
 test_files: []
+has_rdoc: 

data/lib/wires/event.rb

@@ -1,102 +0,0 @@
-
-module Wires
-  
-  class Event
-    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
-    
-    # Internalize all *args and **kwargs and &block to be accessed later
-    def initialize(*args, **kwargs, &block)
-      cls = self.class
-      self.event_type = cls unless cls==Wires::Event
-      
-      @ignore = []
-      @kwargs = kwargs.dup
-      
-      @kwargs.keys.each do |m|
-        if respond_to? m
-          (class << self; self; end).class_eval do
-            undef_method m
-          end
-        end
-      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
-    
-    # Directly access contents of @kwargs by key
-    def [](key); @kwargs[key]; end
-    
-    # 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
-    
-    # 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
-      
-      list.map! do |type, args|
-        case type
-        when Event; obj = type
-        when Class; 
-          if type<=Event 
-            obj = type.new(*args)
-          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
-    
-    # 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

data/lib/wires/time_scheduler_item.rb

@@ -1,81 +0,0 @@
-
-module Wires
-  
-  class TimeSchedulerItem
-    
-    attr_reader :time, :event, :channel, :interval
-    attr_accessor :schedulers
-    
-    def initialize(time, event, channel='*', 
-                   interval:0.seconds, count:1, 
-                   ignore_past:false, cancel:false,
-                   **kwargs)
-      
-      time ||= Time.now
-      
-      @active = (not cancel)
-      tempcount = count
-      
-      while (time < Time.now) and (tempcount > 0)
-        time += interval
-        tempcount -= 1
-      end
-      if not ignore_past
-        time -= interval
-        self.count = count
-      else
-        self.count = tempcount
-      end
-      
-      @time     = time
-      @interval = interval
-      
-      @event    = Event.new_from(event)
-      @channel  = channel.is_a?(Channel) ? channel : Channel.new(channel)
-      @kwargs   = kwargs
-      
-      @schedulers = []
-    end
-    
-    def active?;        @active                                      end
-    def inactive?;     !@active                                      end
-    
-    def ready?(at_time=Time.now);  @active and (at_time>=@time)      end
-    
-    def time_until;    (@active ? [(@time - Time.now), 0].max : nil) end
-    
-    def cancel;         self.count=0                            ;nil end
-    
-    # Get/set @count (and apply constraints on set)
-    def count;          @count                                       end
-                                          #TODO: handle explicit cancel?
-    def count=(x);      @count=[x,0].max; @active&&=(count>0)   ;nil end
-    
-    # Inc/dec @count. Necessary because += and -= outside of lock are not atomic!
-    def count_inc(x=1); self.count=(@count+x)                        end
-    def count_dec(x=1); self.count=(@count-x)                        end
-    
-    # Fire the event now, regardless of time or active status
-    def fire(**kwargs) # kwargs merge with and override @kwargs
-      @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
-    
-  private
-    
-    def notify_schedulers; @schedulers.each &:refresh                end
-    
-    # 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
-  
-end