wires 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba088fc39b2036139e5a89f2d89d57f76fa345c7
-  data.tar.gz: df9a99b434ea93b343142cae93583aac4e654128
+  metadata.gz: 358d9d6b0b4094ed729bc94b80a5af81d2b6db25
+  data.tar.gz: 33eb37077d42bb24312b0a56ad910b4360396ee7
 SHA512:
-  metadata.gz: f684f5c1d7d636a9c57b2f6a65b912cfc6408a8a81f79747786705cb8248d68907f6ba6b02bb2c79d938f78431062310a0b97cd198fc755b18771167beecc073
-  data.tar.gz: 8b6b36cd2763e2a5a24516248cc87c510f67bf2833aa70d845745e30c346e8a32b9d8dc3f8aedff34df74a8667624e3aad25dbe1f2d90cc232e40feade372020
+  metadata.gz: ffd7d42fa653093a03c07528487629192a1a8007733e300a8aac1eafb52746beccb10362b9ef215af400f81e538e5768a49bf8b17af07659d98ef73f10e53d0d
+  data.tar.gz: e99e2c37b935818c4641a2a381e19d9774846563b5f57adfd1f6baff51d87462c3363f36a365588a25cf9b6a1e3a25e2d96baafd9a0792d3acc5346032f84342

data/lib/wires/channel.rb

@@ -88,7 +88,11 @@ module Wires
       for chan in relevant_channels()
         for target in chan.target_list
           for string in target[0] & event.class.codestrings
-            self.class.hub.spawn(event, string, *target[1], blocking, backtrace)
+            self.class.hub.spawn(event,     # fired event object event
+                                 self.name, # name of channel fired from
+                                 target[1], # proc to execute
+                                 blocking,  # boolean from blocking kwarg
+                                 backtrace) # captured backtrace
       end end end
       
       self.class.run_hooks(:@after_fires, event, self)

data/lib/wires/convenience.rb

@@ -3,29 +3,32 @@ module Wires
 
   module Convenience
     
-    # @original_instance_methods = 
+    def Channel(*args) Channel.new(*args) end
     
     def on(events, channels='*', &codeblock)
       channels = [channels] unless channels.is_a? Array
       for channel in channels
-        Channel.new(channel).register(events, codeblock)
+        channel=Channel.new(channel) unless channel.is_a? Channel
+        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)
+    def fire(event, channel='*', **kwargs)
+      channel = Channel.new(channel) unless channel.is_a? Channel
+      unless kwargs[:time] or (kwargs[:count] and kwargs[:count]!=1)
+        channel.fire(event, **kwargs)
+      else
+        time = kwargs[:time] or Time.now
+        kwargs.reject!{|k,v| k==:time}
+        TimeScheduler.add(time, event, channel, **kwargs)
+      end
     nil end
     
-    def fire_every(interval, event, channel='*', **kwargs)
-      Wires::TimeScheduler << \
-        Wires::TimeSchedulerItem.new(self, event, channel, **kwargs)
+    def fire_and_wait(*args, **kwargs)
+      kwargs[:blocking]=true
+      fire(*args, **kwargs)
     end
     
-    def Channel(*args) Channel.new(*args) end
     
     
     class << self

data/lib/wires/hub.rb

@@ -127,12 +127,13 @@ module Wires
         return neglect(*args) if dead?
         
         event, ch_string, proc, blocking, fire_bt = *args
-        *exc_args = event, ch_string, fire_bt
+        *proc_args = event, ch_string
+        *exc_args  = event, ch_string, fire_bt
         
         # If blocking, run the proc in this thread
         if blocking
           begin
-            proc.call(event, ch_string)
+            proc.call(*proc_args)
           rescue Exception => exc
             unhandled_exception(exc, *exc_args)
           end
@@ -155,10 +156,11 @@ module Wires
             # Start the new child thread; follow with chain of neglected tasks
             new_thread = Thread.new do
               begin
-                proc.call(event, ch_string)
-                spawn_neglected_task_chain
+                proc.call(*proc_args)
               rescue Exception => exc
                 unhandled_exception(exc, *exc_args)
+              ensure
+                spawn_neglected_task_chain
               end
             end
             

data/lib/wires/time.rb

@@ -9,8 +9,10 @@ module Wires
     
     def initialize(time, event, channel='*', 
                    interval:0.seconds, count:1, 
-                   ignore_past:false, cancel:false)
+                   ignore_past:false, cancel:false,
+                   **kwargs)
       
+      time ||= Time.now
       expect_type time, Time
       
       @active = (not cancel)
@@ -28,10 +30,11 @@ module Wires
       end
       
       @time     = time
-      @event    = Event.new_from(event)
-      @channel  = channel
       @interval = interval
       
+      @event    = Event.new_from(event)
+      @channel  = Channel.new(channel) unless channel.is_a? Channel
+      @kwargs   = kwargs
     end
     
     def active?;        @active                                      end
@@ -53,28 +56,28 @@ module Wires
     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)
+    def fire(**kwargs) # kwargs merge with and override @kwargs
+      @channel.fire(@event, **(@kwargs.merge(kwargs)))
       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
+    def fire_if_ready(**args); self.fire(**kwargs) 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);
+    def fire_when_ready(**kwargs);
       wait_until_ready
-      fire(*args)
+      self.fire(**kwargs)
     end
     
     # Lock (almost) all instance methods with common re-entrant lock
-    threadlock instance_methods-superclass.instance_methods-[
-                                :block_until_ready,
-                                :fire_when_ready]
+    threadlock instance_methods(false)-[\
+                 :wait_until_ready,
+                 :fire_when_ready]
   end
   
   # A singleton class to schedule future firing of events
@@ -90,12 +93,15 @@ module Wires
     class << self
       
       # Add an event to the schedule
-      def add(new_item)
-        expect_type new_item, TimeSchedulerItem
+      def add(*args)
+        new_item = (args.first.is_a? TimeSchedulerItem) ?
+                     (args.first) :
+                     (TimeSchedulerItem.new(*args))
         schedule_add(new_item)
       nil end
+      
       # Add an event to the schedule using << operator
-      alias_method :<<, :add
+      def <<(arg); add(*arg); end
       
       # Get a copy of the event schedule from outside the class
       def list;  @schedule.clone end
@@ -114,12 +120,26 @@ module Wires
       nil end
       
       def schedule_add(new_item)
+        
+        if new_item.ready?
+          loop do
+            new_item.fire
+            break unless new_item.ready?
+          end
+        end
+        
         if new_item.ready?(@next_pass)
-          Thread.new{ new_item.fire_when_ready(blocking:true) }
-        else
-          @schedule << new_item
-          schedule_reshuffle
+          Thread.new do
+            loop do
+              new_item.fire_when_ready(blocking:true)
+              break unless new_item.ready?(@next_pass)
+            end
+          end
         end
+        
+        @schedule << new_item
+        schedule_reshuffle
+        
       nil end
       
       def schedule_concat(other_list)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Joe McIlvain