wires 0.1.12 → 0.2.0

data/lib/wires/time.rb

@@ -1,198 +1,202 @@
 
-class TimeSchedulerStartEvent < Event; end
-class TimeSchedulerAnonEvent  < Event; end
-
-
-class TimeSchedulerItem
+module Wires
   
-  attr_reader :time, :event, :channel, :interval
+  class TimeSchedulerStartEvent < Event; end
+  class TimeSchedulerAnonEvent  < Event; end
   
-  def initialize(time, event, channel='*', 
-                 interval:0.seconds, count:1, 
-                 ignore_past:false, cancel:false)
-    
-    expect_type time, Time
+  
+  class TimeSchedulerItem
     
-    @active = (not cancel)
-    tempcount = count
+    attr_reader :time, :event, :channel, :interval
     
-    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
+    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
     
-    @time     = time
-    @event    = Event.new_from(event)
-    @channel  = channel
-    @interval = interval
+    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
     
-  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
-  @thread         = Thread.new {nil}
-  @schedule_lock  = Monitor.new
-  @dont_sleep     = false
-  
-  # Operate on the metaclass as a type of singleton pattern
-  class << self
+    def cancel;         @active = false                         ;nil end
     
-    # 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/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
     
-    # Get a copy of the event schedule from outside the class
-    def list;  @schedule.clone end
-    # Clear the event schedule from outside the class
-    def clear; @schedule.clear 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
     
-  private
-  
-    def schedule_reshuffle
-      @schedule.select! {|x| x.active?}
-      @schedule.sort! {|a,b| a.time <=> b.time}
+    # 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
     
-    def schedule_add(new_item)
-      @schedule << new_item
-      schedule_reshuffle
-    nil end
+    # Fire the event only if it is ready
+    def fire_if_ready(*args); self.fire(*args) if ready? end
     
-    def schedule_concat(other_list)
-      @schedule.concat other_list
-      schedule_reshuffle
-    nil end
+    # Block until event is ready
+    def wait_until_ready; sleep 0 until ready? end
     
-    def schedule_pull
-      pending = Array.new
-      while ((not @schedule.empty?) and @schedule[0].ready?)
-        pending << @schedule.shift
-      end
-      [pending, @schedule[0]]
+    # 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
     
-    # 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
+    # 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
+    @thread         = Thread.new {nil}
+    @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.clone end
+      # Clear the event schedule from outside the class
+      def clear; @schedule.clear end
+      
+    private
+    
+      def schedule_reshuffle
+        @schedule.select! {|x| x.active?}
+        @schedule.sort! {|a,b| a.time <=> b.time}
+      nil end
+      
+      def schedule_add(new_item)
+        @schedule << new_item
+        schedule_reshuffle
+      nil end
       
-      @keepgoing = true
-      @thread = Thread.current
-      pending = Array.new
-      on_deck = nil
+      def schedule_concat(other_list)
+        @schedule.concat other_list
+        schedule_reshuffle
+      nil end
       
-      while @keepgoing
+      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
         
-        # Pull, fire, and requeue relevant events
-        pending, on_deck = schedule_pull
-        pending.each { |x| x.fire }
-        schedule_concat pending
+        @keepgoing = true
+        @thread = Thread.current
+        pending = Array.new
+        on_deck = nil
         
-        @sleepzone = true
-        # Calculate the time to sleep based on next event's time
-        if on_deck
-          sleep on_deck.time_until
-        else # sleep until wakeup if no event is on deck
-          sleep
+        while @keepgoing
+          
+          # 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_until
+          else # sleep until wakeup if no event is on deck
+            sleep
+          end
+          @sleepzone = false
         end
-        @sleepzone = false
-      end
+        
+      nil 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.new(self).fire(:time_scheduler_start)
     
-    def wakeup
+    # Stop the main loop upon death of Hub
+    Hub.before_kill(retain:true) do 
       sleep 0 until @sleepzone==true
-      sleep 0 until @thread.status=='sleep'
-      @thread.wakeup
-    nil end
+      @keepgoing=false
+      wakeup
+    end
+    
+    # Refire the start event after Hub dies in case it restarts
+    Hub.after_kill(retain:true) do 
+      Channel.new(self).fire(:time_scheduler_start)
+    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.new(self).fire(:time_scheduler_start)
-  
-  # Stop the main loop upon death of Hub
-  Hub.before_kill(retain:true) do 
-    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.new(self).fire(:time_scheduler_start)
-  end
-  
-end
-
+end # End Wires module.
 
 # Reopen the Time class and add the fire method to enable nifty syntax like:
 # 32.minutes.from_now.fire :event
 class Time
   def fire(event, channel='*', **kwargs)
-    TimeScheduler << TimeSchedulerItem.new(self, event, channel, **kwargs)
+    Wires::TimeScheduler << \
+      Wires::TimeSchedulerItem.new(self, event, channel, **kwargs)
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.0
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-05 00:00:00.000000000 Z
+date: 2013-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,6 +38,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !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: minitest
+  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.
 email: joe.eli.mac@gmail.com
@@ -49,8 +77,8 @@ files:
 - lib/wires/time.rb
 - lib/wires/hub.rb
 - lib/wires/expect_type.rb
-- lib/wires/events.rb
-- lib/wires/channels.rb
+- lib/wires/channel.rb
+- lib/wires/event.rb
 - LICENSE
 - README.md
 homepage: https://github.com/jemc/wires/

data/lib/wires/channels.rb

@@ -1,107 +0,0 @@
-
-def on(events, channels='*', &codeblock)
-  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.new(channel).fire(event, blocking:false)
-nil end
-
-def fire_and_wait(event, channel='*') 
-  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)
-    
-    if not proc.is_a?(Proc) then raise SyntaxError, \
-      "No Proc given to execute on event: #{events}" end
-    
-    # Convert all events to strings
-    events = [events] unless events.is_a? Array
-    events.flatten!
-    events.map! { |e| (e.is_a?(Class) ? e.codestring : e.to_s) }
-    events.uniq!
-    
-    @target_list << [events, proc]
-  nil end
-  
-  # Fire an event on this channel
-  def fire(event, blocking:false)
-    
-    # Create an instance object from one of several acceptable input forms
-    event = Event.new_from event
-    
-    # Fire to each relevant target on each channel
-    for chan in relevant_channels()
-      for target in chan.target_list
-        for string in target[0] & event.class.codestrings
-          self.class.hub << [string, event, blocking, *target[1..-1]]
-    end end end
-    
-  nil end
-  
-  def relevant_channels
-    return @@channel_hash[hub].values if self==channel_star
-    
-    if self.name.is_a?(Regexp) then raise TypeError,
-      "Cannot fire on Regexp channel: #{self.name}."\
-      "  Regexp channels can only used in event handlers." end
-      
-    relevant = [channel_star]
-    for c in @@channel_hash[hub].values
-      relevant << c if \
-        if c.name.is_a?(Regexp)
-          self.name =~ c.name
-        elsif (defined?(c.name.channel_name) and
-             defined?(self.name.channel_name))
-          self.name.channel_name == c.name.channel_name
-        else
-          self.name.to_s == c.name.to_s
-        end
-    end
-    return relevant.uniq
-  end
-end