wires 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9c6a74afd25b600883e65a5bb6e54ac1e966eca
-  data.tar.gz: 920c223d33dc8128fd0fc7f1b9af13992f5da51e
+  metadata.gz: 00826eb63c92ee41f33d4b9afca45cf79f6074ef
+  data.tar.gz: 7547996adc41b8f58905b22b50f317f403ef56b3
 SHA512:
-  metadata.gz: 18d14b246f4f015b56e8fe9d0122201ecd27f6627764c62b814b1683aedfb705c5d1fb5b101432ec1f42a7dbdf0047916287d112a7555c94b81e851a478fe0e7
-  data.tar.gz: ea363328dceda12c2c2b933be15018ddf16dd84125232718c7189c9a81562d01664dcf884b9ef31bdd0ba2eb3f333608a82c565f9f03eb9f9743dc4229ee26c5
+  metadata.gz: 64f55f73930e572d8fdb589a8c84f302396a87ff56ec851e0a6fe24b7666dd8f572ee6638169a0571728e6364ea9b85d38d6d843b133656690cd22072cd00e8c
+  data.tar.gz: efac20e8fc999a1e219ff778ee92cbeb0c5ebfd2e520708b382bd86411a6133c6ceac8ab7084620439e6c8ae4a4ff98bdece2136aa3f4bcc9a73dc3bb968bf71

data/lib/wires/channels.rb

@@ -1,105 +1,107 @@
 
 def on(events, channels='*', &codeblock)
-    channels = [channels] unless channels.is_a? Array
-    for channel in channels
-        Channel(channel).register(events, codeblock)
-    end
+  channels = [channels] unless channels.is_a? Array
+  for channel in channels
+    Channel.new(channel).register(events, codeblock)
+  end
 nil end
 
 
 def fire(event, channel='*') 
-    Channel(channel).fire(event, blocking=false)
+  Channel.new(channel).fire(event, blocking:false)
 nil end
 
 def fire_and_wait(event, channel='*') 
-    Channel(channel).fire(event, blocking=true)
+  Channel.new(channel).fire(event, blocking:true)
 nil end
 
 
 def Channel(*args) Channel.new(*args) end
 
 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)
     
-    attr_reader :name
-    attr_reader :target_list
+    if not proc.is_a?(Proc) then raise SyntaxError, \
+      "No Proc given to execute on event: #{events}" end
     
-    def initialize(name)
-        @name = name
-        @target_list = Set.new
-    nil 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!
     
-    # Ensure that there is only one instance of Channel per name
-    @@channel_hash = Hash.new
-    @@new_lock = Mutex.new
-    def self.new(*args, &block)
-        @@new_lock.synchronize do
-            @@channel_hash[args[0]] ||= super(*args, &block)
-        end
-    end
+    @target_list << [events, proc]
+  nil end
+  
+  # Fire an event on this channel
+  def fire(event, blocking:false)
     
-    # Class-wide reference to the global channel and event hub
-    @@channel_star = Channel('*')
+    # Create an instance object from one of several acceptable input forms
+    event = Event.new_from event
     
-    # 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 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
     
-    # Fire an event on this channel
-    def fire(_event, blocking=false)
-        
-        # Pull out args from optional array notation
-        _event = [_event] unless _event.is_a? Array
-        _event, *args = _event
-        
-        # Create event object from event as an object, class, or symbol/string
-        event = case _event
-            when Event
-                _event
-            when Class
-                _event.new(*args) if _event < Event
-            else
-                cls = Event.from_codestring(_event.to_s).new(*args)
-        end
-        
-        # 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
-                    Hub << [string, event, blocking, *target[1..-1]]
-        end end end
-        
-    nil end
+  nil end
+  
+  def relevant_channels
+    return @@channel_hash[hub].values if self==channel_star
     
-    def relevant_channels
-        return @@channel_hash.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.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
+    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
-        return relevant.uniq
     end
+    return relevant.uniq
+  end
 end

data/lib/wires/events.rb

@@ -69,7 +69,26 @@ class Event < Object # explicit for the sake of Event.ancestry
         "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.

data/lib/wires/expect_type.rb

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

data/lib/wires/hub.rb

@@ -62,25 +62,21 @@ class Hub
     # [+:blocking+] calling thread won't be done until Hub thread is done
     def kill(*flags)
       @finish_all = (flags.include? :finish_all)
-      @state=:dying if alive?
-      @thread.join if (flags.include? :blocking)
+      @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)
-      if not func.is_a?(Proc)
-        raise TypeError, "Expected a Proc or code block to execute."
-      end
+      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)
-      if not func.is_a?(Proc)
-        raise TypeError, "Expected a Proc or code block to execute."
-      end
+      expect_type func, Proc
       @after_kills << [func, retain]
     nil end
     
@@ -195,6 +191,7 @@ class Hub
             unhandled_exception(e)
           end
         end
+        
       end
     
     nil end

data/lib/wires/time.rb

@@ -1,45 +1,137 @@
-require 'pry'
 
-class TimeSchedulerEvent < Event; end
-class TimeSchedulerStartEvent < TimeSchedulerEvent; end
-class TimeSchedulerAnonEvent  < TimeSchedulerEvent; end
+class TimeSchedulerStartEvent < Event; end
+class TimeSchedulerAnonEvent  < Event; end
+
+
+class TimeSchedulerItem
+  
+  attr_reader :time, :event, :channel, :interval
+  
+  def initialize(time, event, channel='*', 
+                 interval:0.seconds, count:1, 
+                 ignore_past:false, cancel:false)
+    
+    expect_type time, Time
+    
+    @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
+    @event    = Event.new_from(event)
+    @channel  = channel
+    @interval = interval
+    
+  end
+  
+  def active?;        @active                                      end
+  def inactive?;      not @active                                  end
+  def ready?;         @active and (Time.now >= @time)              end
+  def time_until;    (@active ? [(Time.now - @time), 0].max : nil) end
+  
+  def cancel;         @active = false                         ;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(*args)
+    Channel.new(@channel).fire(@event, *args)
+    count_dec
+    @time += @interval if @active
+  nil end
+  
+  # Fire the event only if it is ready
+  def fire_if_ready(*args); self.fire(*args) if ready? end
+  
+  # Block until event is ready
+  def wait_until_ready; sleep 0 until ready? end
+  
+  # Block until event is ready, then fire and block until it is done
+  def fire_when_ready(*args);
+    wait_until_ready
+    fire_if_ready(*args)
+  end
+  
+  # Lock (almost) all instance methods with common re-entrant lock
+  threadlock instance_methods-superclass.instance_methods-[
+                              :block_until_ready,
+                              :fire_when_ready]
+end
 
 # A singleton class to schedule future firing of events
 class TimeScheduler
   @schedule       = Array.new
-  @schedule_lock  = Mutex.new
   @thread         = Thread.new {nil}
-  @keepgoing_lock = Mutex.new
+  @schedule_lock  = Monitor.new
+  @dont_sleep     = false
   
   # Operate on the metaclass as a type of singleton pattern
   class << self
     
+    # Add an event to the schedule
+    def add(new_item)
+      expect_type new_item, TimeSchedulerItem
+      schedule_add(new_item)
+      wakeup
+    nil end
+    # Add an event to the schedule using << operator
+    alias_method :<<, :add
+    
     # Get a copy of the event schedule from outside the class
-    def list;  @schedule_lock.synchronize {@schedule.clone} end
+    def list;  @schedule.clone end
     # Clear the event schedule from outside the class
-    def clear; @schedule_lock.synchronize {@schedule.clear} end
+    def clear; @schedule.clear end
     
-    # Fire an event at a specific time
-    def fire(time, event, channel='*', ignore_past:false)
-      if not time.is_a? Time
-        raise TypeError, "Expected #{time.inspect} to be an instance of Time."
-      end
-      
-      # Ignore past events if flag is set
-      if ignore_past and time < Time.now; return nil; end
-      
-      # Under mutex, push the event into the schedule and sort
-      @schedule_lock.synchronize do
-        @schedule << {time:time, event:event, channel:channel}
-        @schedule.sort! { |a,b| a[:time] <=> b[:time] }
-      end
-      
-      # Wakeup main_loop thread if it is sleeping
-      begin @thread.wakeup; rescue ThreadError; end
-      
+  private
+  
+    def schedule_reshuffle
+      @schedule.select! {|x| x.active?}
+      @schedule.sort! {|a,b| a.time <=> b.time}
     nil end
     
-  private
+    def schedule_add(new_item)
+      @schedule << new_item
+      schedule_reshuffle
+    nil end
+    
+    def schedule_concat(other_list)
+      @schedule.concat other_list
+      schedule_reshuffle
+    nil end
+    
+    def schedule_pull
+      pending = Array.new
+      while ((not @schedule.empty?) and @schedule[0].ready?)
+        pending << @schedule.shift
+      end
+      [pending, @schedule[0]]
+    end
+    
+    # Put all functions dealing with @schedule under @schedule_lock
+    threadlock :list,
+               :clear,
+               :schedule_reshuffle,
+               :schedule_add,
+               :schedule_concat,
+               :schedule_pull,
+         lock: :@schedule_lock
     
     # Do scheduled firing of events as long as Hub is alive
     def main_loop
@@ -51,60 +143,56 @@ class TimeScheduler
       
       while @keepgoing
         
-        # Under mutex, pull any events that are ready into pending
-        pending.clear
-        @schedule_lock.synchronize do
-          while ((not @schedule.empty?) and 
-                 (Time.now > @schedule[0][:time]))
-            pending << @schedule.shift
-          end
-          on_deck = @schedule[0]
-        end
-        
-        # Fire pending events
-        pending.each { |x| Channel(x[:channel]).fire(x[:event]) }
+        # Pull, fire, and requeue relevant events
+        pending, on_deck = schedule_pull
+        pending.each { |x| x.fire }
+        schedule_concat pending
         
+        @sleepzone = true
         # Calculate the time to sleep based on next event's time
         if on_deck
-          sleep [(on_deck[:time]-Time.now), 0].max
+          sleep on_deck.time_until
         else # sleep until wakeup if no event is on deck
-          sleep if @keepgoing
+          sleep
         end
-        
+        @sleepzone = false
       end
       
     nil end
     
+    def wakeup
+      sleep 0 until @sleepzone==true
+      sleep 0 until @thread.status=='sleep'
+      @thread.wakeup
+    nil end
     
   end
   
   # Use fired event to only start scheduler when Hub is running
   # This also gets the scheduler loop its own thread within the Hub's threads
   on :time_scheduler_start, self do; main_loop; end;
-  Channel(self).fire(:time_scheduler_start)
+  Channel.new(self).fire(:time_scheduler_start)
   
   # Stop the main loop upon death of Hub
   Hub.before_kill(retain:true) do 
-    @keepgoing_lock.synchronize do
-      @keepgoing=false
-      @thread.wakeup
-    end
-    sleep 0
+    sleep 0 until @sleepzone==true
+    @keepgoing=false
+    wakeup
   end
+  
   # Refire the start event after Hub dies in case it restarts
   Hub.after_kill(retain:true) do 
-    Channel(self).fire(:time_scheduler_start)
+    Channel.new(self).fire(:time_scheduler_start)
   end
   
-  
 end
 
 
 # Reopen the Time class and add the fire method to enable nifty syntax like:
 # 32.minutes.from_now.fire :event
 class Time
-  def fire(*args)
-    TimeScheduler.fire(self, *args)
+  def fire(event, channel='*', **kwargs)
+    TimeScheduler << TimeSchedulerItem.new(self, event, channel, **kwargs)
   end
 end
 
@@ -116,7 +204,7 @@ class ActiveSupport::Duration
   alias :__original_since :since
   def since(*args, &block)
     if block
-      on :time_scheduler_anon, block.object_id do block.call end
+      on :time_scheduler_anon, block.object_id do |e| block.call(e) end
       __original_since(*args).fire(:time_scheduler_anon, 
                                     block.object_id)
       nil
@@ -129,7 +217,7 @@ class ActiveSupport::Duration
   alias :__original_ago :ago
   def ago(*args, &block)
     if block
-      on :time_scheduler_anon, block.object_id do block.call end
+      on :time_scheduler_anon, block.object_id do |e| block.call(e) end
       __original_ago(*args).fire(:time_scheduler_anon, 
                                   block.object_id)
       nil
@@ -139,4 +227,8 @@ class ActiveSupport::Duration
   end
   alias :until :ago
   
-end
+end
+
+
+# TODO: Repeatable event sugar?
+# TODO: Tests for all new functionality

data/lib/wires.rb

@@ -1,7 +1,9 @@
 require 'set'
 require 'thread'
 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/hub'
 require 'wires/channels'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-01 00:00:00.000000000 Z
+date: 2013-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: threadlock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: An asynchronous (threaded) event routing framework in Ruby. Patch your
   objects together with wires. Inspired by the python 'circuits' framework.
 email: joe.eli.mac@gmail.com
@@ -34,6 +48,7 @@ files:
 - lib/wires.rb
 - lib/wires/time.rb
 - lib/wires/hub.rb
+- lib/wires/expect_type.rb
 - lib/wires/events.rb
 - lib/wires/channels.rb
 - LICENSE