ActionTimer 0.1.1 → 0.2.1

data/CHANGELOG

@@ -1,5 +1,18 @@
 = CHANGELOG
 
+== 0.2.1
+* Use simple monitor
+* Add support for rounding sleep time within a delta
+* Raise unexpected exception to creator thread after shutting down
+* Fix arity checks for < 1.9 versions
+
+== 0.2.0
+* hashed arguments for Timer#add and Action#new
+* Timer#mass_add replaced with Timer#register for single and arrays of Actions
+* Timer#registered? added to see if an Action is registered with the timer
+* Timer#actions to see Actions registered with the timer
+* Action#timer= to allow Actions to be moved
+
 == 0.1.1
 * fix for float calculations 
 * downcased gem name

data/README.rdoc

@@ -16,6 +16,15 @@ ActionTimer is a helper for timed events. It allows for single and recurring act
 
 {rip}[http://hellorip.com/about.html] makes it easy to install directly from a github repository.
 
+=== Testing
+
+ActionTimer is currently tested on:
+
+* Ruby 1.8.6-p383
+* Ruby 1.8.7-p248
+* Ruby 1.9.1-p376
+* JRuby 1.4.0
+
 === Using the timer:
 
 ==== Simple example:
@@ -92,10 +101,10 @@ What if you want to add multiple actions at one time? We can do this:
     timer = ActionTimer::Timer.new
     result = 0
     actions = []
-    actions << ActionTimer::Action.new(@timer, 0.1){ result += 1}
-    actions << ActionTimer::Action.new(@timer, 0.2){ result += 1}
-    actions << ActionTimer::Action.new(@timer, 0.3){ result += 1}
-    timer.mass_add(actions)
+    actions << ActionTimer::Action.new(timer, 0.1){ result += 1}
+    actions << ActionTimer::Action.new(timer, 0.2){ result += 1}
+    actions << ActionTimer::Action.new(timer, 0.3){ result += 1}
+    timer.register(actions)
     sleep(0.41)
     p result
     

data/actiontimer.gemspec

@@ -2,7 +2,7 @@ spec = Gem::Specification.new do |s|
     s.name              = 'ActionTimer'
     s.author            = 'spox'
     s.email             = 'spox@modspox.com'
-    s.version           = '0.1.1'
+    s.version           = '0.2.1'
     s.summary           = 'Simple timer for a complex world'
     s.platform          = Gem::Platform::RUBY
     s.has_rdoc          = true
@@ -10,7 +10,8 @@ spec = Gem::Specification.new do |s|
     s.extra_rdoc_files  = %w(README.rdoc LICENSE CHANGELOG)
     s.files             = Dir['**/*']
     s.require_paths     = %w(lib)
-    s.add_dependency 'ActionPool'
+    s.add_dependency 'actionpool', '~> 0.2.3'
+    s.add_dependency 'splib', '~> 1.4'
     s.required_ruby_version = '>= 1.8.6'
     s.homepage          = 'http://github.com/spox/actiontimer'
     s.description       = 'ActionTimer is a simple timer for recurring actions. It supports single and recurring actions with an easy to use API.'

data/lib/actiontimer.rb

@@ -1 +1,4 @@
-require 'actiontimer/Timer.rb'
+require 'rubygems'
+require 'actiontimer/Timer.rb'
+require 'splib'
+Splib.load :Array, :Float, :Monitor

data/lib/actiontimer/Action.rb

@@ -2,21 +2,36 @@ module ActionTimer
     class Action
     
         attr_accessor :owner
+        attr_accessor :timer
     
         # timer:: Timer this action resides within
         # period:: amount of time between runs
         # once:: only run this action once
         # data:: data to pass to block
         # block:: block to be executed
-        def initialize(timer, period, once=false, data=nil, &block)
-            @period = period.to_f
+        def initialize(hash, &block)
+            raise ArgumentError.new('Period must be supplied') unless hash[:period]
+            raise ArgumentError.new('Block must be provided') unless block_given?
+            raise ArgumentError.new('Block must accept data value') if hash[:data] && block.arity == 0
+            if((block.arity > 0 || block.arity < -1) && (!hash.has_key?(:data) || hash[:data].nil?))
+                raise ArgumentError.new('Data must be supplied for block')
+            end
+            args = {:once => false, :data => nil, :owner => nil}.merge(hash)
+            @period = args[:period].to_f
             @block = block
-            @data = data
-            @once = once
-            @timer = timer
+            @data = args[:data]
+            @once = args[:once]
+            @timer = args[:timer]
             @completed = false
             @wait_remaining = @period
-            @owner = nil
+            @owner = args[:owner]
+        end
+
+        # t:: ActionTimer::Timer
+        # Set timer for action to be associated with
+        def timer=(t)
+            raise ArgumentError.new('Expecting an ActionTimer::Timer') unless t.is_a?(ActionTimer::Timer)
+            @timer = t
         end
         
         # o:: Object that added this action
@@ -30,6 +45,8 @@ module ActionTimer
         # amount:: amount of time that has passed
         # Decrement remaining wait time by given amount
         def tick(amount)
+            amount = amount.to_f
+            amount = 0 if amount < 0
             @wait_remaining = @wait_remaining - amount if @wait_remaining > 0
             @wait_remaining = 0 if @wait_remaining < 0
             @completed = true if @once && @wait_remaining <= 0
@@ -45,7 +62,8 @@ module ActionTimer
         def reset_period(new_time)
             @period = new_time.to_f
             @wait_remaining = @period
-            @timer.wakeup
+            @completed = false
+            @timer.wakeup unless @timer.nil?
         end
         
         # Action is ready to be destroyed

data/lib/actiontimer/Timer.rb

@@ -8,10 +8,12 @@ module ActionTimer
         # Argument hash: {:pool, :logger, :auto_start}
         def initialize(args={}, extra=nil)
             auto_start = true
+            @delta = nil
             if(args.is_a?(Hash))
                 @pool = args[:pool] ? args[:pool] : ActionPool::Pool.new
                 @logger = args[:logger] && args[:logger].is_a?(Logger) ? args[:logger] : Logger.new(nil)
                 auto_start = args.has_key?(:auto_start) ? args[:auto_start] : true
+                @delta = args[:delta] ? args[:delta].to_f : nil
             else
                 @pool = args.is_a?(ActionPool::Pool) ? args : ActionPool::Pool.new
                 @logger = extra && extra.is_a?(Logger) ? extra : Logger.new(nil)
@@ -20,17 +22,21 @@ module ActionTimer
             @new_actions = []
             @timer_thread = nil
             @stop_timer = false
-            @add_lock = Mutex.new
-            @awake_lock = Mutex.new
+            @add_lock = Splib::Monitor.new
+            @awake_lock = Splib::Monitor.new
+            @sleeper = Splib::Monitor.new
+            @respond_to = Thread.current
             start if auto_start
         end
         
         # Forcibly wakes the timer early
         def wakeup
             raise NotRunning.new unless running?
-            return unless @awake_lock.try_lock
-            @timer_thread.wakeup if @timer_thread.status == 'sleep'
-            @awake_lock.unlock
+            if(@sleeper.waiters > 0)
+                @sleeper.signal
+            else
+                @timer_thread.wakeup if @timer_thread.alive? && @timer_thread.stop?
+            end
         end
         
         # period:: amount of time between runs
@@ -39,22 +45,30 @@ module ActionTimer
         # owner:: owner of Action
         # func:: block to be executed
         # Add a new action to block
-        def add(period, once=false, data=nil, owner=nil, &func)
-            action = Action.new(self, period, once, data, &func)
-            action.owner = owner unless owner.nil?
+        def add(hash, &func)
+            raise ArgumentError.new('Expecting hash of arguments') unless hash.is_a?(Hash)
+            raise ArgumentError.new('A period must be provided for timed action') unless hash[:period]
+            raise ArgumentError.new('Block must be provided') unless block_given?
+            raise ArgumentError.new('Block must accept data value') if hash[:data] && func.arity == 0
+            args = {:once => false, :data => nil, :owner => nil}.merge(hash)
+            action = Action.new(args.merge(:timer => self), &func)
             @add_lock.synchronize{ @new_actions << action }
             wakeup if running?
-            return action
+            action
         end
         
-        # actions:: Array of actions
-        # Add multiple Actions to the timer at once
-        def mass_add(actions)
-            raise ArgumentError.new('Expecting an array') unless actions.is_a?(Array)
-            actions.each do |action|
-                raise ArgumentError.new('Expecting an Action') unless action.is_a?(Action)
+        # actions:: Array of actions or single ActionTimer::Action
+        # Add single or multiple Actions to the timer at once
+        def register(action)
+            if(action.is_a?(Array))
+                if(action.find{|x|x.is_a?(Action)}.nil?)
+                    raise ArgumentError.new('Array contains non ActionTimer::Action objects')
+                end
+            else
+                raise ArgumentError.new('Expecting an ActionTimer::Action object') unless action.is_a?(Action)
+                action = [action]
             end
-            @add_lock.synchronize{ @new_actions = @new_actions + actions }
+            @add_lock.synchronize{ @new_actions = @new_actions + action }
             wakeup if running?
         end
         
@@ -76,19 +90,24 @@ module ActionTimer
                         to_sleep = get_min_sleep
                         if((to_sleep.nil? || to_sleep > 0) && @new_actions.empty?)
                             @awake_lock.unlock if @awake_lock.locked?
-                            actual_sleep = to_sleep.nil? ? sleep : sleep(to_sleep)
+                            start = Time.now.to_f
+                            to_sleep.nil? ? @sleeper.wait : sleep(to_sleep)
+                            actual_sleep = Time.now.to_f - start
+                            if(@delta && to_sleep && actual_sleep.within_delta?(:expected => to_sleep, :delta => @delta))
+                                actual_sleep = to_sleep
+                            end
                             @awake_lock.lock
                         else
                             actual_sleep = 0
                         end
-                        actual_sleep = to_sleep if actual_sleep <= 0
                         tick(actual_sleep)
                         add_waiting_actions
                     end
                 rescue Object => boom
                     @timer_thread = nil
                     clean_actions
-                    @logger.fatal("Timer encountered an unexpected error: #{boom}\n#{boom.backtrace.join("\n")}")
+                    @logger.fatal("Timer encountered an unexpected error and is shutting down: #{boom}\n#{boom.backtrace.join("\n")}")
+                    @respond_to.raise boom
                 end
             end
         end
@@ -125,23 +144,30 @@ module ActionTimer
             else
                 @actions.each{|a| @actions.delete(a) if a.owner == owner}
             end
-            wakeup
+            wakeup if running?
         end
         
         # Is timer currently running?
         def running?
-            return !@timer_thread.nil?
+            !@timer_thread.nil?
+        end
+
+        # action:: ActionTimer::Action
+        # Is action currently in timer
+        def registered?(action)
+            @actions.include?(action)
+        end
+
+        # Actions registered with the timer
+        def actions
+            @actions.dup
         end
         
         private
         
         def get_min_sleep
-            min = @actions.map{|a|a.remaining}.sort[0]
-            unless(min.nil? || min > 0)
-                @actions.each{|a|@actions.delete(a) if a.remaining == 0} # kill stuck actions
-                min = get_min_sleep
-            end
-            return min
+            min = @actions.min{|a,b|a.remaining <=> b.remaining}
+            min.remaining if min
         end
         
         def add_waiting_actions

data/tests/cases/action.rb

@@ -0,0 +1,128 @@
+require 'test/unit'
+require 'actiontimer'
+
+class ActionTests < Test::Unit::TestCase
+    def setup
+        @timer = ActionTimer::Timer.new
+    end
+    def teardown
+    end
+
+    def test_create
+        assert_raise(ArgumentError) do
+            action = ActionTimer::Action.new(:timer => @timer){true}
+        end
+        assert_raise(ArgumentError) do
+            action = ActionTimer::Action.new(:timer => @timer, :period => 1){|x|true}
+        end
+        assert_raise(ArgumentError) do
+            action = ActionTimer::Action.new(:timer => @timer, :period => 1, :data => 1)
+        end
+        if(RUBY_VERSION > "1.9.0")
+            assert_raise(ArgumentError) do
+                action = ActionTimer::Action.new(:timer => @timer, :period => 1, :data => 1){true}
+            end
+        end
+        assert_kind_of(ActionTimer::Action, ActionTimer::Action.new(:timer => @timer, :period => 1){true})
+        assert_kind_of(ActionTimer::Action, ActionTimer::Action.new(:timer => @timer, :period => 1, :once => true){true})
+        assert_kind_of(ActionTimer::Action, ActionTimer::Action.new(:timer => @timer, :period => 1, :once => false){true})
+    end
+
+    def test_timer
+        mytimer = ActionTimer::Timer.new
+        action = ActionTimer::Action.new(:timer => @timer, :period => 1){true}
+        assert_equal(@timer, action.timer)
+        action.timer = mytimer
+        assert_equal(mytimer, action.timer)
+    end
+    
+    def test_owner
+        object = Object.new
+        action = ActionTimer::Action.new(:timer => @timer, :period => 1, :owner => object){true}
+        assert_equal(object, action.owner)
+        other_object = Object.new
+        action.owner = other_object
+        assert_equal(other_object, action.owner)
+        action.owner = object
+        assert_equal(object, action.owner)
+    end
+
+    def test_tick
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2){true}
+        action.tick(1)
+        assert_equal(1, action.remaining)
+        action.tick(0.1)
+        assert_equal(0.9, action.remaining)
+        action.tick(0.11)
+        assert_equal(0.79, action.remaining)
+    end
+
+    def test_reset_period
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2){true}
+        action.tick(1)
+        assert_equal(1, action.remaining)
+        action.reset_period(3)
+        assert_equal(3, action.remaining)
+        action.tick(3)
+        assert_equal(0, action.remaining)
+        assert(!action.is_complete?)
+    end
+
+    def test_complete
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2, :once => true){true}
+        action.tick(2)
+        assert_equal(0, action.remaining)
+        assert(action.is_complete?)
+    end
+
+    def test_schedule
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2){true}
+        action.tick(1)
+        assert_equal(1, action.remaining)
+        assert_equal(action, action.schedule)
+        assert_equal(2, action.remaining)
+    end
+
+    def test_due
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2){true}
+        assert(!action.due?)
+        action.tick(2)
+        assert(action.due?)
+    end
+
+    def test_run_noargs
+        a = false
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2){ a = true }
+        assert(!a)
+        action.run
+        assert(a)
+    end
+
+    def test_run_args
+        a = []
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2, :data => [1,2,[3]]) do |b,c,d|
+            a << b
+            a << c
+            a << d
+        end
+        action.run
+        assert_kind_of(Array, a.pop)
+        assert_equal(2, a.pop)
+        assert_equal(1, a.pop)
+        assert(a.empty?)
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2, :data => [1,2,[3]]) do |*b|
+            a = b
+        end
+        action.run
+        assert_kind_of(Array, a)
+        assert_kind_of(Array, a.pop)
+        assert_equal(2, a.pop)
+        assert_equal(1, a.pop)
+        assert(a.empty?)        
+        action = ActionTimer::Action.new(:timer => @timer, :period => 2, :data => :foo) do |b|
+            a = b
+        end
+        action.run
+        assert_equal(:foo, a)
+    end
+end

data/tests/cases/timer.rb

@@ -0,0 +1,85 @@
+require 'test/unit'
+require 'actiontimer'
+
+class TimerTests < Test::Unit::TestCase
+    def setup
+        @timer = ActionTimer::Timer.new
+    end
+    
+    def teardown
+    end
+
+    def test_add_bad
+        assert_raise(ArgumentError) do
+            @timer.add{true}
+        end
+        assert_raise(ArgumentError) do
+            @timer.add(1){true}
+        end
+        assert_raise(ArgumentError) do
+            @timer.add(:period => 1)
+        end
+        if(RUBY_VERSION > "1.9.0")
+            assert_raise(ArgumentError) do
+                @timer.add(:period => 1, :data => 2){true}
+            end
+        end
+    end
+
+    def test_add
+        output = []
+        action = @timer.add(:period => 0.1){true}
+        assert_kind_of(ActionTimer::Action, action)
+        sleep(0.01)
+        assert_equal(1, @timer.actions.size)
+        assert(@timer.registered?(action))
+        @timer.add(:period => 0.1, :once => true, :data => :foo){|x| output << x }
+        sleep(0.01)
+        assert_equal(2, @timer.actions.size)
+        sleep(0.14)
+        assert_equal(:foo, output.pop)
+        assert_equal(1, @timer.actions.size)
+    end
+
+    def test_register
+        output = []
+        action = ActionTimer::Action.new(:period => 0.01){output << :action}
+        @timer.register(action)
+        sleep(0.113)
+        @timer.pause
+        assert_equal(10, output.size)
+        assert_equal(1, @timer.actions.size)
+        assert(@timer.registered?(action))
+        @timer.clear
+        assert(@timer.actions.empty?)
+        @timer.start
+        output.clear
+        actions = [action]
+        actions << ActionTimer::Action.new(:period => 0.02){output << :fubar}
+        @timer.register(actions)
+        sleep(0.051)
+        @timer.pause
+        assert_equal(7, output.size)
+        assert(output.include?(:fubar))
+        assert_equal(2, @timer.actions.size)
+        actions.each{|x| assert(@timer.registered?(x)) }
+    end
+
+    def test_remove
+        output = []
+        action = ActionTimer::Action.new(:period => 0.01){output << :action}
+        @timer.register(action)
+        sleep(0.029)
+        @timer.remove(action)
+        assert_equal(2, output.size)
+        assert(@timer.actions.empty?)
+        output.clear
+        assert(output.empty?)
+        action = @timer.add(:period => 0.01){output << :action}
+        sleep(0.021)
+        @timer.remove(action)
+        assert(!@timer.registered?(action))
+        assert(2, output.size)
+    end
+
+end

data/tests/run_tests.rb

@@ -3,143 +3,148 @@ $LOAD_PATH.unshift(File.expand_path("#{__FILE__}/../../lib"))
 require 'test/unit'
 require 'actiontimer'
 
-class TimerTests < Test::Unit::TestCase
-    def setup
-        @timer = ActionTimer::Timer.new
-    end
-
-    # Simple test of basic repetitive action
-    def test_basic
-        result = 0
-        @timer.add(2){ result += 1 }
-        sleep(5)
-        assert_equal(2, result)
-    end
-
-    # Check the the running? method properly reports
-    def test_running
-        @timer.add(1){ 1 + 1}
-        assert(@timer.running?)
-        @timer.pause
-        assert(!@timer.running?)
-        @timer.start
-        assert(@timer.running?)
-        @timer.stop
-        assert(!@timer.running?)
-    end
-    
-    # Check that a value 0 < t < 1 works
-    # as expected
-    def test_float
-        result = 0
-        @timer.add(0.1){ result += 1 }
-        sleep(1.01)
-        assert_equal(10, result)
-    end
-
-    # Check that a single iterative action is only
-    # completed once
-    def test_once
-        result = 0
-        @timer.add(1, true){ result += 1 }
-        sleep(3)
-        assert_equal(1, result)
-    end
-
-    # Check that timer can be paused and restarted
-    # without registered actions being effected
-    def test_pause
-        result = 0
-        @timer.add(1){ result += 1 }
-        sleep(3.1)
-        @timer.pause
-        sleep(2)
-        @timer.start
-        sleep(2)
-        assert_equal(5, result)
-    end
-
-    # Check that data can be passed to the block
-    # properly when created
-    def test_data
-        result = 0
-        @timer.add(1, true, 3){|a| result = a}
-        sleep(2)
-        assert_equal(3, result)
-        @timer.add(1, true, [3,4,['foobar']]){|a,b,c| result = [b,a,c]}
-        sleep(2)
-        assert_equal(4, result[0])
-        assert_equal(3, result[1])
-        assert(result[2].is_a?(Array))
-    end
-
-    # Check that the timer's auto starting mechanism
-    # can be disabled
-    def test_auto_start
-        timer = ActionTimer::Timer.new(:auto_start => false)
-        timer.add(1){ 1+1 }
-        assert(!timer.running?)
-        timer.start
-        assert(timer.running?)
-    end
-
-    # Check that the actions can be cleared out of the
-    # timer and the timer is still left in a "running"
-    # state.
-    def test_clear
-        result = 0
-        @timer.add(1){ result += 1 }
-        sleep(3)
-        @timer.clear
-        sleep(2)
-        assert_equal(2, result)
-        assert(@timer.running?)
-    end
-
-    # Check that the timer throws an exception when it
-    # is instructed to wakeup while not running
-    def test_wakeup
-        @timer.stop
-        assert_raise(ActionTimer::NotRunning){ @timer.wakeup }
-    end
-
-    # Check that the timer throws an exception when it
-    # is instructed to start but is already running
-    def test_start
-        assert_raise(ActionTimer::AlreadyRunning){ @timer.start }
-    end
-
-    # Check that multiple actions can be added at once
-    def test_mass_add
-        result = 0
-        actions = []
-        actions << ActionTimer::Action.new(@timer, 1){ result += 1}
-        actions << ActionTimer::Action.new(@timer, 3){ result += 1}
-        actions << ActionTimer::Action.new(@timer, 5){ result += 1}
-        @timer.mass_add(actions)
-        sleep(5.3)
-        assert_equal(7, result)
-    end
-
-    # Check that an action can be properly removed from
-    # the timer
-    def test_remove
-        result = 0
-        action = @timer.add(1){result += 1}
-        sleep(2.1)
-        @timer.remove(action)
-        sleep(2)
-        assert_equal(2, result)
-    end
-
-    # Check that an action's period can be dynamically
-    # reset
-    def test_action_reset
-        result = 0
-        action = @timer.add(1){ result += 1}
-        sleep(2.1)
-        action.reset_period(3)
-        sleep(3.1)
-        assert_equal(result, 3)
-    end
-end
+Dir.new("#{File.dirname(__FILE__)}/cases").each{|f|
+    require "#{File.dirname(__FILE__)}/cases/#{f}" if f[-2..f.size] == 'rb'
+}
+# 
+# 
+# class TimerTests < Test::Unit::TestCase
+#     def setup
+#         @timer = ActionTimer::Timer.new
+#     end
+# 
+#     # Simple test of basic repetitive action
+#     def test_basic
+#         result = 0
+#         @timer.add(2){ result += 1 }
+#         sleep(5)
+#         assert_equal(2, result)
+#     end
+# 
+#     # Check the the running? method properly reports
+#     def test_running
+#         @timer.add(1){ 1 + 1}
+#         assert(@timer.running?)
+#         @timer.pause
+#         assert(!@timer.running?)
+#         @timer.start
+#         assert(@timer.running?)
+#         @timer.stop
+#         assert(!@timer.running?)
+#     end
+#     
+#     # Check that a value 0 < t < 1 works
+#     # as expected
+#     def test_float
+#         result = 0
+#         @timer.add(0.1){ result += 1 }
+#         sleep(1.01)
+#         assert_equal(10, result)
+#     end
+# 
+#     # Check that a single iterative action is only
+#     # completed once
+#     def test_once
+#         result = 0
+#         @timer.add(1, true){ result += 1 }
+#         sleep(3)
+#         assert_equal(1, result)
+#     end
+# 
+#     # Check that timer can be paused and restarted
+#     # without registered actions being effected
+#     def test_pause
+#         result = 0
+#         @timer.add(1){ result += 1 }
+#         sleep(3.1)
+#         @timer.pause
+#         sleep(2)
+#         @timer.start
+#         sleep(2)
+#         assert_equal(5, result)
+#     end
+# 
+#     # Check that data can be passed to the block
+#     # properly when created
+#     def test_data
+#         result = 0
+#         @timer.add(1, true, 3){|a| result = a}
+#         sleep(2)
+#         assert_equal(3, result)
+#         @timer.add(1, true, [3,4,['foobar']]){|a,b,c| result = [b,a,c]}
+#         sleep(2)
+#         assert_equal(4, result[0])
+#         assert_equal(3, result[1])
+#         assert(result[2].is_a?(Array))
+#     end
+# 
+#     # Check that the timer's auto starting mechanism
+#     # can be disabled
+#     def test_auto_start
+#         timer = ActionTimer::Timer.new(:auto_start => false)
+#         timer.add(1){ 1+1 }
+#         assert(!timer.running?)
+#         timer.start
+#         assert(timer.running?)
+#     end
+# 
+#     # Check that the actions can be cleared out of the
+#     # timer and the timer is still left in a "running"
+#     # state.
+#     def test_clear
+#         result = 0
+#         @timer.add(1){ result += 1 }
+#         sleep(3)
+#         @timer.clear
+#         sleep(2)
+#         assert_equal(2, result)
+#         assert(@timer.running?)
+#     end
+# 
+#     # Check that the timer throws an exception when it
+#     # is instructed to wakeup while not running
+#     def test_wakeup
+#         @timer.stop
+#         assert_raise(ActionTimer::NotRunning){ @timer.wakeup }
+#     end
+# 
+#     # Check that the timer throws an exception when it
+#     # is instructed to start but is already running
+#     def test_start
+#         assert_raise(ActionTimer::AlreadyRunning){ @timer.start }
+#     end
+# 
+#     # Check that multiple actions can be added at once
+#     def test_mass_add
+#         result = 0
+#         actions = []
+#         actions << ActionTimer::Action.new(@timer, 1){ result += 1}
+#         actions << ActionTimer::Action.new(@timer, 3){ result += 1}
+#         actions << ActionTimer::Action.new(@timer, 5){ result += 1}
+#         @timer.mass_add(actions)
+#         sleep(5.3)
+#         assert_equal(7, result)
+#     end
+# 
+#     # Check that an action can be properly removed from
+#     # the timer
+#     def test_remove
+#         result = 0
+#         action = @timer.add(1){result += 1}
+#         sleep(2.1)
+#         @timer.remove(action)
+#         sleep(2)
+#         assert_equal(2, result)
+#     end
+# 
+#     # Check that an action's period can be dynamically
+#     # reset
+#     def test_action_reset
+#         result = 0
+#         action = @timer.add(1){ result += 1}
+#         sleep(2.1)
+#         action.reset_period(3)
+#         sleep(3.1)
+#         assert_equal(result, 3)
+#     end
+# end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ActionTimer
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors: 
 - spox
@@ -9,18 +9,28 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-05 00:00:00 -08:00
+date: 2010-01-13 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: ActionPool
+  name: actionpool
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 0.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: splib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.4"
     version: 
 description: ActionTimer is a simple timer for recurring actions. It supports single and recurring actions with an easy to use API.
 email: spox@modspox.com
@@ -33,16 +43,18 @@ extra_rdoc_files:
 - LICENSE
 - CHANGELOG
 files: 
-- lib/actiontimer/Exceptions.rb
+- actiontimer.gemspec
+- tests/cases/timer.rb
+- tests/cases/action.rb
+- tests/run_tests.rb
+- lib/actiontimer.rb
 - lib/actiontimer/Timer.rb
 - lib/actiontimer/Action.rb
-- lib/actiontimer.rb
-- test
-- tests/run_tests.rb
+- lib/actiontimer/Exceptions.rb
 - CHANGELOG
 - LICENSE
 - README.rdoc
-- actiontimer.gemspec
+- actiontimer-0.2.1.gem
 has_rdoc: true
 homepage: http://github.com/spox/actiontimer
 licenses: []

data/test

@@ -1,11 +0,0 @@
-    require 'actiontimer'
-    timer = ActionTimer::Timer.new
-    result = 0
-    actions = []
-    actions << ActionTimer::Action.new(@timer, 0.1){ result += 1}
-    actions << ActionTimer::Action.new(@timer, 0.2){ result += 1}
-    actions << ActionTimer::Action.new(@timer, 0.3){ result += 1}
-    timer.mass_add(actions)
-    sleep(0.41)
-    p result
-