ztimer 0.4.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5e403be0894d09cc0bbc6c390b101665532e8a18
-  data.tar.gz: eb034343767cadf543893013f0e115319f51b2ed
+SHA256:
+  metadata.gz: 328b728b6ba74021474c30ef9093a1bca987a368b2bd211d5545abc888447ef2
+  data.tar.gz: df0ff61ae1bbf3901a1ddc9fa0ac3416dce79eeb1c4e05f1d9a3f61abce722c0
 SHA512:
-  metadata.gz: f80e696e261cdc59c62e1e4daae92d0734dd432130f8c18cdd80f7f2b701c0ec945344f12ce390ff8e797c900812ca6d31b9fe91e4fce81d3301404f0a3407ed
-  data.tar.gz: 786b8c931a6775197fb0475f92f5a3a223fb7845ed3a2f6a85faa920413ead1b32366424ddb80964c15152f367d53ccbaa15ecfbef01bdfee212db51cbf527b5
+  metadata.gz: d482e9792d40f7083258a66cac5b1857624d02dbc6f4297a3ea608c48f8f50908dc3fe429e0666b54bd67b3b3e9b846f7869aa8ea253e980167bd2502cfd4626
+  data.tar.gz: d5b3ce5d4189739c8a32851383775afe84bd238d324dc26806e122f2b19fd9a4dd65509c9b04ded9aae399b3eeff19bb3a01377155408b680ed533261401b1a3

data/.travis.yml

@@ -1,4 +1,9 @@
 language: ruby
 rvm:
-  - 2.2.1
+  - 2.2
+
 before_install: gem install bundler -v 1.11.2
+script:
+  - gem build ztimer.gemspec
+  - gem install ztimer --local
+  - bundle exec rspec

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in ztimer.gemspec
 gemspec
+
+group :test do
+  gem 'lounger', '~> 0.2.0'
+end

data/README.md

@@ -1,7 +1,9 @@
 # Ztimer
 
-**Ztimer** is a Ruby gem that allows to get asynchronous delayed notifications. You can enqueue callbacks to be
-called after some amount of time. 
+**Ztimer** is a simple Ruby implementation of an asynchronous timer, that allows to enqueue the execution of Ruby
+code, so that it will be asynchronously executed on timeout. It's very useful when you need a simple way to execute
+some code asynchronously or with a certain delay.
+
 
 ## Installation
 
@@ -32,6 +34,12 @@ Ztimer.after(delay) do
   puts "Doing something useful..."
 end
 
+# Async execution
+Ztimer.async do
+  # this code will be executed in background asyncronously
+  puts "Doing something useful in background..."
+end
+
 # Recurrent jobs
 job = Ztimer.every(delay) do # execute the block every second
   puts "Executing a recurrent job..."
@@ -40,17 +48,41 @@ end
 sleep 10    # wait for 10 seconds (10 executions)
 job.cancel! # cancel the recurrent job
 
+# Custom Ztimer instance
+my_timer = Ztimer.new(concurrency: 5) # create a new Ztimer instance
+10.times do
+  # Use the custom ztimer to execute jobs asynchronously
+  my_timer.async do
+    puts "Doing async job..."
+  end
+end
 ```
 
-By default **Ztimer** will run at maximum 20 notifications concurrently, so that if you have 100 notifications to be
-executed at the same time, at maximum 20 of them will run at the same time. This is necessary in order to prevent uncontrolled
-threads spawn when many notifications have to be sent at the same time.
+| Method | Description  |
+|--------|-------------|
+| `async(&block)` | Execute the block asynchronously. |
+| `after(milliseconds, &block)` | Execute the block after the specified amount of milliseconds. |
+| `at(datetime, &block)` | Execute the block at the specified timestamp. |
+| `every(milliseconds, start_at: nil, &block)` | Execute the block at the specified interval of milliseconds. A custom `:start_at` param could be provided to specify an offset timestamp. |
+| `secondly(seconds, offset: 0, &block)` | Executes the block every N seconds. An `:offset` of seconds could be specified to shift the begining of the time slot. By default the block will be exected at the begining of the time slot. Example: `secondly(5)` will run at second `0`, `5`, `10`, `15`, etc. |
+| `minutely(minutes, offset: 0, &block)` | Executes the block every N minutes. An `:offset` of minutes could be specified to shift the begining of the time slot. By default the block will be exected at the begining of the time slot. Example: `minutely(5)` will run at minute `0`, `5`, `10`, `15`, etc. |
+| `hourly(hours, offset: 0, &block)` | Executes the block every N hours. An `:offset` of hours could be specified to shift the begining of the time slot. By default the block will be exected at the begining of the time slot. Example: `hourly(5)` will run at hour `0`, `5`, `10`, `15`, etc. |
+| `daily(days, offset: 0, &block)` | Executes the block every N days. An `:offset` of days could be specified to shift the begining of the time slot. By default the block will be exected at the begining of the time slot. Example: `daily(5)` will run on day `0`, `5`, `10`, `15`, etc. |
+| `day_of_week(day, &block)` | Execute the block only on the specified day of week. Valid days are: `"sun", "mon", "tue", "thu", "wen", "fri", "sat"`. |
+| `days_of_week(days, &block)` | Execute the block on the specified days of week. |
 
-Anyway, you can change the concurrency by calling `Ztimer.concurrency = <concurrency>`, where `<concurrency>` is the maximum number
-of `Ztimer` workers allowed to run in parallel (ex: `Ztimer.concurrency = 50`).
 
-## Contributing
+By default **Ztimer** will run at maximum 20 jobs concurrently, so that if you have 100 jobs to be
+executed at the same time, at most 20 of them will run concurrently. This is necessary in order to prevent uncontrolled threads spawn when many jobs have to be run at the same time.
+
+Anyway, you can change the concurrency level by calling `Ztimer.concurrency = <concurrency>`, where `<concurrency>` is the maximum number of `Ztimer` workers allowed to run in parallel (ex: `Ztimer.concurrency = 50`).
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/serioja90/ztimer. This project is intended to be a safe,
-welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+If you're using custom **Ztimer** instance, you can specify the concurrency while creating the new instance:
+
+```ruby
+my_timer = Ztimer.new(concurrency: 42) # create a ztimer with concurrency set to 42
+```
+
+## Contributing
 
+Bug reports and pull requests are welcome on GitHub at https://github.com/serioja90/ztimer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/lib/ztimer/slot.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 
-module Ztimer
+class Ztimer
+  # Implements a slot, which represents a block of code to be executed at specified time slot.
   class Slot
     attr_reader :enqueued_at, :expires_at, :recurrency, :callback
     attr_accessor :started_at, :executed_at
 
-    def initialize(enqueued_at, expires_at,recurrency = -1, &callback)
+    def initialize(enqueued_at, expires_at, recurrency = -1, &callback)
       @enqueued_at = enqueued_at
       @expires_at  = expires_at
       @recurrency  = recurrency
@@ -15,17 +17,15 @@ module Ztimer
     end
 
     def recurrent?
-      return @recurrency > 0
+      @recurrency.positive?
     end
 
     def reset!
-      if recurrent?
-        @expires_at += recurrency
-      end
+      @expires_at += recurrency if recurrent?
     end
 
     def canceled?
-      return @canceled
+      @canceled
     end
 
     def cancel!
@@ -33,7 +33,7 @@ module Ztimer
     end
 
     def <=>(other)
-      return @expires_at <=> other.expires_at
+      @expires_at <=> other.expires_at
     end
   end
-end
+end

data/lib/ztimer/sorted_store.rb

@@ -1,97 +1,94 @@
+# frozen_string_literal: true
 
-module Ztimer
+class Ztimer
+  # Implements a performant sorted store for time slots, which uses binary search to optimize
+  # new items insertion and items retrievement.
   class SortedStore
-
     def initialize
       @store = []
     end
 
     def <<(value)
       @store.insert(position_for(value), value)
-      return self
+
+      self
     end
 
     def delete(value)
       index = index_of(value)
-      if index
-        @store.delete_at(index)
-      else
-        return nil
-      end
+
+      index.nil? ? nil : @store.delete_at(index)
     end
 
     def [](index)
-      return @store[index]
+      @store[index]
     end
 
     def first
-      return @store.first
+      @store.first
     end
 
     def last
-      return @store.last
+      @store.last
     end
 
     def shift
-      return @store.shift
+      @store.shift
     end
 
     def pop
-      return @store.pop
+      @store.pop
     end
 
     def index_of(value, start = 0, stop = [@store.count - 1, 0].max)
-      if start > stop
-        return nil
-      elsif start == stop
-        return value == @store[start] ? start : nil
-      else
-        position = ((stop + start)/ 2).to_i
-        case value <=> @store[position]
-        when -1 then return index_of(value, start, position)
-        when  0 then return position
-        when  1 then return index_of(value, position + 1, stop)
-        end
+      return nil if start > stop
+      return value == @store[start] ? start : nil if start == stop
+
+      position = ((stop + start) / 2).to_i
+
+      case value <=> @store[position]
+      when -1 then index_of(value, start, position)
+      when  0 then position
+      when  1 then index_of(value, position + 1, stop)
       end
     end
 
     def count
-      return @store.count
+      @store.count
     end
 
     def size
-      return @store.size
+      @store.size
     end
 
     def empty?
-      return @store.empty?
+      @store.empty?
     end
 
     def clear
-      return @store.clear
+      @store.clear
     end
 
     def to_a
-      return @store.dup
+      @store.dup
     end
 
-
     protected
 
     def position_for(item, start = 0, stop = [@store.count - 1, 0].max)
-      if start > stop
-        raise "Invalid range (#{start}, #{stop})"
-      elsif start == stop
+      raise "Invalid range (#{start}, #{stop})" if start > stop
+
+      if start == stop
         element = @store[start]
-        return element.nil? || ((item <=> element) <= 0) ? start : start + 1
+        element.nil? || ((item <=> element) <= 0) ? start : start + 1
       else
-        position = ((stop + start)/ 2).to_i
+        position = ((stop + start) / 2).to_i
         case item <=> @store[position]
-        when -1 then return position_for(item, start, position)
-        when  0 then return position
-        when  1 then return position_for(item, position + 1, stop)
+        when -1 then position_for(item, start, position)
+        when  0 then position
+        when  1 then position_for(item, position + 1, stop)
         end
       end
     end
   end
-end
+end

data/lib/ztimer/version.rb

@@ -1,3 +1,5 @@
-module Ztimer
-  VERSION = "0.4.3"
+# frozen_string_literal: true
+
+class Ztimer
+  VERSION = '1.0.0'
 end

data/lib/ztimer/watcher.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
 
-module Ztimer
+class Ztimer
+  # Implements a watcher which allows to enqueue Ztimer::Slot items, that will be executed
+  # as soon as the time of Ztimer::Slot is reached.
   class Watcher
-
     def initialize(&callback)
       @thread   = nil
       @slots    = Ztimer::SortedStore.new
@@ -10,17 +12,15 @@ module Ztimer
       @mutex    = Mutex.new
     end
 
-    def << (slot)
+    def <<(slot)
       @mutex.synchronize do
         @slots << slot
-        if @slots.first == slot
-          run
-        end
+        run if @slots.first == slot
       end
     end
 
     def jobs
-      return @slots.size
+      @slots.size
     end
 
     protected
@@ -37,10 +37,11 @@ module Ztimer
     def start
       @lock.synchronize do
         return if @thread
+
         @thread = Thread.new do
           loop do
             begin
-              delay = get_delay
+              delay = calculate_delay
               if delay.nil?
                 Thread.stop
                 next
@@ -48,10 +49,10 @@ module Ztimer
 
               select(nil, nil, nil, delay / 1_000_000.to_f) if delay > 1 # 1 microsecond of cranularity
 
-              while get_first_expired do
+              while fetch_first_expired
               end
-            rescue => e
-              puts e.inspect + "\n" + e.backtrace.join("\n")
+            rescue StandardError => e
+              puts "#{e.inspect}\n#{e.backtrace.join("\n")}"
             end
           end
         end
@@ -59,11 +60,11 @@ module Ztimer
       end
     end
 
-    def get_delay
-      return @mutex.synchronize { @slots.empty? ? nil : @slots.first.expires_at - utc_microseconds }
+    def calculate_delay
+      @mutex.synchronize { @slots.empty? ? nil : @slots.first.expires_at - utc_microseconds }
     end
 
-    def get_first_expired
+    def fetch_first_expired
       @mutex.synchronize do
         slot = @slots.first
         if slot && (slot.expires_at < utc_microseconds)
@@ -89,7 +90,7 @@ module Ztimer
     end
 
     def utc_microseconds
-      return Time.now.to_f * 1_000_000
+      Time.now.to_f * 1_000_000
     end
   end
-end
+end

data/lib/ztimer.rb

@@ -1,83 +1,197 @@
-require "ztimer/version"
-require "ztimer/slot"
-require "ztimer/sorted_store"
-require "ztimer/watcher"
-
-module Ztimer
-  @concurrency  = 20
-  @watcher      = Ztimer::Watcher.new(){|slot| execute(slot) }
-  @workers_lock = Mutex.new
-  @queue        = Queue.new
-  @running      = 0
-  @count        = 0
-
-  class << self
-    attr_reader :concurrency, :running, :count
-
-    def after(milliseconds, &callback)
-      enqueued_at = utc_microseconds
-      expires_at  = enqueued_at + milliseconds * 1000
-      slot        = Slot.new(enqueued_at, expires_at, -1, &callback)
-
-      add(slot)
-
-      return slot
-    end
+# frozen_string_literal: true
+
+require 'ztimer/version'
+require 'ztimer/slot'
+require 'ztimer/sorted_store'
+require 'ztimer/watcher'
+
+# Implements a timer which allows to execute a block with a delay, recurrently or asynchronously.
+class Ztimer
+  @default_instance = nil
+
+  attr_reader :concurrency, :running, :count, :watcher, :queue
+
+  def initialize(concurrency: 20)
+    @concurrency  = concurrency
+    @watcher      = Ztimer::Watcher.new { |slot| execute(slot) }
+    @workers_lock = Mutex.new
+    @count_lock   = Mutex.new
+    @queue        = Queue.new
+    @running      = 0
+    @count        = 0
+  end
 
-    def every(milliseconds, &callback)
-      enqueued_at = utc_microseconds
-      expires_at  = enqueued_at + milliseconds * 1000
-      slot        = Slot.new(enqueued_at, expires_at, milliseconds * 1000, &callback)
+  # Execute the code block asyncrhonously right now
+  def async(&callback)
+    enqueued_at = utc_microseconds
+    slot        = Slot.new(enqueued_at, enqueued_at, -1, &callback)
 
-      add(slot)
+    incr_counter!
+    execute(slot)
 
-      return slot
-    end
+    slot
+  end
 
-    def jobs_count
-      return @watcher.jobs
-    end
+  # Execute the code block after the specified delay
+  def after(milliseconds, &callback)
+    enqueued_at = utc_microseconds
+    expires_at  = enqueued_at + milliseconds * 1000
+    slot        = Slot.new(enqueued_at, expires_at, -1, &callback)
 
-    def concurrency=(new_value)
-      raise ArgumentError.new("Invalid concurrency value: #{new_value}") unless new_value.is_a?(Fixnum) && new_value >= 1
-      @concurrency = new_value
-    end
+    add(slot)
+
+    slot
+  end
+
+  # Execute the code block at a specific datetime
+  def at(datetime, &callback)
+    enqueued_at = datetime.to_f * 1_000_000
+
+    slot = Slot.new(enqueued_at, enqueued_at, -1, &callback)
+    add(slot)
+
+    slot
+  end
+
+  # Execute the code block every N milliseconds.
+  # When :start_at is specified, the first execution will start at specified date/time
+  def every(milliseconds, start_at: nil, &callback)
+    enqueued_at = start_at ? start_at.to_f * 1_000_000 : utc_microseconds
+    expires_at = enqueued_at + milliseconds * 1000
+    slot = Slot.new(enqueued_at, expires_at, milliseconds * 1000, &callback)
 
-    protected
+    add(slot)
+
+    slot
+  end
+
+  # Run ztimer every N seconds, starting with the nearest time slot (ex. secondly(5)
+  # will run at second 0, 5, 10, 15, etc.)
+  def secondly(seconds, offset: 0, &callback)
+    start_time = utc_microseconds
+    milliseconds = (seconds.to_f * 1000).to_i
+    enqueued_at = start_time - (start_time % (milliseconds * 1000)) + offset * 1_000_000
+    expires_at = enqueued_at + milliseconds * 1000
+
+    slot = Slot.new(enqueued_at, expires_at, milliseconds * 1000, &callback)
+    add(slot)
+
+    slot
+  end
+
+  # Run ztimer every N minutes, starting at the nearest time slot (ex. minutely(2) will run at minute 0, 2, 4, 6, etc.)
+  def minutely(minutes, offset: 0, &callback)
+    secondly(minutes.to_f * 60, offset: offset.to_f * 60, &callback)
+  end
+
+  # Run ztimer every N hours, starting at the nearest time slot (ex. hourly(2) will run at hour 0, 2, 4, 6, etc.)
+  def hourly(hours, offset: 0, &callback)
+    minutely(hours.to_f * 60, offset: offset.to_f * 60, &callback)
+  end
+
+  def daily(days, offset: 0, &callback)
+    raise ArgumentError, "Days number should be > 0: #{days.inspect}" if days.to_f <= 0
+
+    hourly(days.to_f * 24, offset: offset.to_f * 24, &callback)
+  end
 
-    def add(slot)
-      @count += 1
-      @watcher << slot
+  def day_of_week(day, &callback)
+    days = %w[sun mon tue thu wen fri sat]
+    current_day = Time.now.wday
+
+    index = day.to_i
+    if day.is_a?(String)
+      # Find day number by day name
+      index = days.index { |day_name| day.strip.downcase == day_name }
+      raise ArgumentError, "Invalid week day: #{day.inspect}" if index.nil?
+    elsif index.negative? || index > 6
+      raise ArgumentError, "Invalid week day: #{day.inspect}"
     end
 
+    offset = 0
+    offset = (current_day > index ? index - current_day : current_day - index) if current_day != index
 
-    def execute(slot)
-      @queue << slot
-
-      @workers_lock.synchronize do
-        [@concurrency - @running, @queue.size].min.times do
-          @running += 1
-          worker = Thread.new do
-            begin
-              while !@queue.empty? && (slot = @queue.pop(true)) do
-                slot.executed_at = utc_microseconds
-                slot.callback.call(slot) unless slot.callback.nil?
-              end
-            rescue ThreadError
-              # queue is empty
-              puts "queue is empty"
-            rescue => e
-              STDERR.puts e.inspect + (e.backtrace ? "\n" + e.backtrace.join("\n") : "")
-            end
-            @workers_lock.synchronize { @running -= 1 }
+    daily(7, offset: offset, &callback)
+  end
+
+  def days_of_week(*args, &callback)
+    args.map { |day| day_of_week(day, &callback) }
+  end
+
+  def jobs_count
+    @watcher.jobs
+  end
+
+  def concurrency=(new_value)
+    value_is_integer = new_value.is_a?(Integer)
+    raise ArgumentError, "Invalid concurrency value: #{new_value}" unless value_is_integer && new_value >= 1
+
+    @concurrency = new_value
+  end
+
+  def stats
+    {
+      running: @running,
+      scheduled: @watcher.jobs,
+      executing: @queue.size,
+      total: @count
+    }
+  end
+
+  def self.method_missing(name, *args, &block)
+    @default_instance ||= Ztimer.new(concurrency: 20)
+    @default_instance.send(name, *args, &block)
+  end
+
+  protected
+
+  def add(slot)
+    incr_counter!
+    @watcher << slot
+  end
+
+  def incr_counter!
+    @count_lock.synchronize{ @count += 1 }
+  end
+
+  def execute(slot)
+    @queue << slot
+
+    @workers_lock.synchronize do
+      [@concurrency - @running, @queue.size].min.times do
+        @running += 1
+        start_new_thread!
+      end
+    end
+  end
+
+  def start_new_thread!
+    worker = Thread.new do
+      begin
+        loop do
+          current_slot = nil
+          @workers_lock.synchronize do
+            current_slot = @queue.pop(true) unless @queue.empty?
+          end
+          break if current_slot.nil?
+
+          begin
+            current_slot.executed_at = utc_microseconds
+            current_slot.callback.call(current_slot) unless current_slot.callback.nil? || current_slot.canceled?
+          rescue StandardError => e
+            backtrace = e.backtrace ? "\n#{e.backtrace.join("\n")}" : ''
+            warn e.inspect + backtrace
           end
-          worker.abort_on_exception = true
         end
+      rescue ThreadError
+        puts 'queue is empty'
       end
+      @workers_lock.synchronize { @running -= 1 }
     end
+    worker.abort_on_exception = true
+  end
 
-    def utc_microseconds
-      return Time.now.to_f * 1_000_000
-    end
+  def utc_microseconds
+    Time.now.to_f * 1_000_000
   end
-end
+end

data/ztimer.gemspec

@@ -1,25 +1,28 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'ztimer/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "ztimer"
+  spec.name          = 'ztimer'
   spec.version       = Ztimer::VERSION
-  spec.authors       = ["Groza Sergiu"]
-  spec.email         = ["serioja90@gmail.com"]
+  spec.authors       = ['Groza Sergiu']
+  spec.email         = ['serioja90@gmail.com']
 
-  spec.summary       = %q{An asyncrhonous timer}
-  spec.description   = %q{Ruby asyncrhonous timer that allows you to enqueue tasks to be executed asyncrhonously after a delay}
-  spec.homepage      = "https://github.com/serioja90/ztimer"
-  spec.license       = "MIT"
+  spec.summary       = %(An asyncrhonous timer)
+  spec.description   = %(Ruby asyncrhonous timer that allows you to enqueue tasks to be executed asyncrhonously after a delay)
+  spec.homepage      = 'https://github.com/serioja90/ztimer'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.5'
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake",    "~> 10.0"
-  spec.add_development_dependency "rspec",   "~> 3.0"
+  spec.add_development_dependency 'bundler', '~>2.2', '>= 2.2.33'
+  spec.add_development_dependency 'rake', '~>12.3', '>= 12.3.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ztimer
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Groza Sergiu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-20 00:00:00.000000000 Z
+date: 2022-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,28 +16,40 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '2.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.33
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '2.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.33
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -87,17 +99,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: An asyncrhonous timer
 test_files: []
-has_rdoc: