timers 4.1.1 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 107c4a8a97789c9580117a8eca6cb72af1390d54
-  data.tar.gz: 6687f8c8b655ce609a3ecf0a4519dd001baf4e2b
+  metadata.gz: 97c81b8ed305099faee9ecec3ee32f6960b70d54
+  data.tar.gz: 90d94a796bfe60e78963b0053648396aefdb19b6
 SHA512:
-  metadata.gz: 5f838fdcc30e595940ffc40325aea12578b16bf91a279feeafa247eb2d349d2724ec96715ab6d392531efcf7ff9f9e9a44a19b977bfb13a32629ead0a4358bda
-  data.tar.gz: 1fba4a0bad3f7b284ed4a45e6cc1e156cf66082041ec7a767cad14471e3b82a0c4bf068ea874d5e9f6bb90e3a8a571c73ebb710cb50df0d809dc3d65b470fffb
+  metadata.gz: dbea5311bcd5fb7bfe7c98191ac15146647b91ab5c994309f3bc14fe394ac97832361afa6ff7f257d844a802265125a5bafa051026fa1eed979f8310d8a21f87
+  data.tar.gz: 2097c9e9d6e838550fa3c4735db828173852dd5e598670a376a04de132274df6464687cfe0e72992c2469d5d355932808fe1147e44ec5f26e2162046267c37ad

data/.rspec

@@ -3,3 +3,4 @@
 --backtrace
 --order random
 --warnings
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,28 @@
+AllCops:
+  DisplayCopNames: true
+
+#
+# Style
+#
+
+LineLength:
+  Max: 128
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/SafeNavigation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+#
+# Metrics
+#
+
+Metrics/ClassLength:
+  Max: 100
+
+Metrics/MethodLength:
+  Max: 25

data/.ruby-version

@@ -0,0 +1 @@
+2.3.3

data/.travis.yml

@@ -1,18 +1,21 @@
+language: ruby
+sudo: false
+
+bundler_args: --without development doc
+
 rvm:
-  - 1.9.3
   - 2.0.0
-  - 2.1.2
-  - ruby-head
-  - jruby
-  - jruby-head
-  - rbx-2
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - jruby-9.1.6.0
 
 matrix:
   fast_finish: true
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
-    - rvm: rbx-2
+
+branches:
+  only:
+    - master
 
 notifications:
   irc: "irc.freenode.org#celluloid"

data/CHANGES.md

@@ -1,54 +1,62 @@
-4.1.1 (2015-08-21)
-------------------
+## 4.1.2 (2016-11-26)
+
+* RuboCop reformatting
+
+## 4.1.1 (2015-08-21)
+
 * Remove `RubyProf` from Gemfile and a test, due to it providing no substantial benefit while increasing problems building bundles under Rubinius.
 
-4.1.0 (2015-08-16)
-------------------
+## 4.1.0 (2015-08-16)
+
 * Addition of `now_and_every` method; fires block immediately, then sets recurring timer.
 * Includes `now_and_after` method; does the same as above for one-shot timers: essentially a "two-shot" timer.
 
-4.0.1 (2014-09-10)
-------------------
+# 4.0.4 (2015-09-01)
+
+* Re-release of the `4.1.1` version under the `4.0.4` designation to work-around issues caused by yanking `4.0.2` a couple weeks ago.
+
+## 4.0.1 (2014-09-10)
+
 * Memory leak fixes
 * mathn fix for those crazy enough to use it
 
-4.0.0 (2014-07-27)
-------------------
+## 4.0.0 (2014-07-27)
+
 * Replace Timers::Timeout with Timers::Wait
-* Timers::Group#wait_interval now returns nil when no timers, a postive or
+* Timers::Group#wait_interval now returns nil when no timers, a positive or
   negative interval which if positive is the amount of time required to wait
   and if negative, how far in the past the latest timer should have fired
 * Performance improvements
 
-3.0.1 (2014-06-27)
-------------------
+## 3.0.1 (2014-06-27)
+
 * Require 'set' automatically
 
-3.0.0 (2014-06-14)
-------------------
+# 3.0.0 (2014-06-14)
+
 * Refactor `Timers` class into `Timers::Group`
 * Add `Timers::Timeout` class for implementing timeouts
 * Fix timer fudging
 * Update to RSpec 3
 
-2.0.0 (2013-12-30)
-------------------
+## 2.0.0 (2013-12-30)
+
 * Switch to Hitimes for high precision monotonic counters
 * Removed Timers#time. Replaced with Timers#current_offset which provides a
   monotonic time counter.
 
-1.1.0
------
+## 1.1.0
+
 * Timers#after_milliseconds and #after_ms for waiting in milliseconds
 
-1.0.2
------
+## 1.0.2
+
 * Handle overdue timers correctly
 
-1.0.1
------
+## 1.0.1
+
 * Explicitly require Forwardable from stdlib
 
-1.0.0
------
+## 1.0.0
+
 * Initial release

data/Gemfile

@@ -1,6 +1,19 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-gem 'coveralls', :require => false
+source "https://rubygems.org"
 
-# Specify your gem's dependencies in timers.gemspec
 gemspec
+
+group :development do
+  gem "pry", require: false
+end
+
+group :test do
+  gem "rspec", "~> 3", require: false
+  gem "rubocop", "0.45.0", require: false
+  gem "coveralls", require: false
+end
+
+group :development, :test do
+  gem "rake"
+end

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012-14 The Celluloid Timers Developers: given in the file
+Copyright (c) 2012-16 The Celluloid Timers Developers: given in the file
 AUTHORS.md at https://github.com/celluloid/timers/blob/master/AUTHORS.md
 
 MIT License

data/README.md

@@ -1,20 +1,31 @@
-Timers
-======
-[![Gem Version](https://badge.fury.io/rb/timers.png)](http://rubygems.org/gems/timers)
-[![Build Status](https://secure.travis-ci.org/celluloid/timers.png?branch=master)](http://travis-ci.org/celluloid/timers)
-[![Code Climate](https://codeclimate.com/github/celluloid/timers.png)](https://codeclimate.com/github/celluloid/timers)
-[![Coverage Status](https://coveralls.io/repos/celluloid/timers/badge.png?branch=master)](https://coveralls.io/r/celluloid/timers)
+# Timers for Ruby [![Gem Version][gem-image]][gem-link] [![Build Status][build-image]][build-link] [![Code Climate][codeclimate-image]][codeclimate-link] [![Coverage Status][coverage-image]][coverage-link] [![MIT licensed][license-image]][license-link]
 
-Ruby timer collections. Schedule several procs to fire after configurable delays
-or at periodic intervals.
+[gem-image]: https://badge.fury.io/rb/timers.svg
+[gem-link]: http://rubygems.org/gems/timers
+[build-image]: https://secure.travis-ci.org/celluloid/timers.svg?branch=master
+[build-link]: https://travis-ci.org/celluloid/timers
+[codeclimate-image]: https://codeclimate.com/github/celluloid/timers.svg
+[codeclimate-link]: https://codeclimate.com/github/celluloid/timers
+[coverage-image]: https://coveralls.io/repos/celluloid/timers/badge.svg?branch=master
+[coverage-link]: https://coveralls.io/r/celluloid/timers
+[license-image]: https://img.shields.io/badge/license-MIT-blue.svg
+[license-link]: https://github.com/celluloid/timers/master/LICENSE.txt
 
-This gem is especially useful when you are faced with an API that accepts a
-single timeout but you want to run multiple timers on top of it. An example of
-such a library is [nio4r](https://github.com/celluloid/nio4r), a cross-platform
-Ruby library for using system calls like epoll and kqueue.
+Collections of one-shot and periodic timers, intended for use with event loops.
 
-Usage
------
+**Does not require Celluloid!** Though this gem was originally written
+to provide the timer subsystem for [Celluloid], it can be used independently
+in any sort of event loop context, or can provide a purely timer-based event
+loop itself.
+
+[Celluloid]: https://github.com/celluloid/celluloid/
+
+## Supported platforms
+
+* Ruby 2.0, 2.1, 2.2, and 2.3
+* JRuby 9000
+
+## Usage
 
 Create a new timer group with `Timers::Group.new`:
 
@@ -94,10 +105,9 @@ timers.resume
 10.times { timers.wait } # will fire all timers
 ```
 
-License
--------
+## License
 
-Copyright (c) 2014 Celluloid timers project developers (given in the file
+Copyright (c) 2012-2016 Celluloid timers project developers (given in the file
 AUTHORS.md).
 
 Distributed under the MIT License. See LICENSE file for further details.

data/Rakefile

@@ -1,7 +1,10 @@
-#!/usr/bin/env rake
+# frozen_string_literal: true
 require "bundler/gem_tasks"
-require 'rspec/core/rake_task'
 
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new
 
-task :default => :spec
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+task default: %w(spec rubocop)

data/lib/timers.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 
-require 'timers/version'
+require "timers/version"
 
-require 'timers/group'
-require 'timers/wait'
+require "timers/group"
+require "timers/wait"

data/lib/timers/events.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 
-require 'forwardable'
-require 'hitimes'
+require "forwardable"
+require "hitimes"
 
-require 'timers/timer'
+require "timers/timer"
 
 module Timers
   # Maintains an ordered list of events, which can be cancelled.
@@ -13,73 +14,67 @@ module Timers
         @time = time
         @callback = callback
       end
-      
+
       # The absolute time that the handle should be fired at.
-      attr :time
-      
+      attr_reader :time
+
       # Cancel this timer, O(1).
       def cancel!
         # The simplest way to keep track of cancelled status is to nullify the
         # callback. This should also be optimal for garbage collection.
         @callback = nil
       end
-      
+
       # Has this timer been cancelled? Cancelled timer's don't fire.
       def cancelled?
         @callback.nil?
       end
-      
-      def > other
+
+      def >(other)
         @time > other.to_f
       end
-      
+
       def to_f
         @time
       end
-      
+
       # Fire the callback if not cancelled with the given time parameter.
       def fire(time)
-        if @callback
-          @callback.call(time)
-        end
+        @callback.call(time) if @callback
       end
     end
-    
+
     def initialize
       # A sequence of handles, maintained in sorted order, future to present.
       # @sequence.last is the next event to be fired.
       @sequence = []
     end
-    
+
     # Add an event at the given time.
     def schedule(time, callback)
       handle = Handle.new(time.to_f, callback)
-      
+
       index = bisect_left(@sequence, handle)
-      
+
       # Maintain sorted order, O(logN) insertion time.
       @sequence.insert(index, handle)
-      
-      return handle
+
+      handle
     end
-    
+
     # Returns the first non-cancelled handle.
     def first
-      while handle = @sequence.last
-        if handle.cancelled?
-          @sequence.pop
-        else
-          return handle
-        end
+      while (handle = @sequence.last)
+        return handle unless handle.cancelled?
+        @sequence.pop
       end
-      # @sequence.reverse.find { |handle| !handle.cancelled? }
     end
-    
+
     # Returns the number of pending (possibly cancelled) events.
     def size
       @sequence.size
     end
-    
+
     # Fire all handles for which Handle#time is less than the given time.
     def fire(time)
       pop(time).reverse_each do |handle|
@@ -89,28 +84,28 @@ module Timers
 
     private
 
-    # Efficiently take k handles for which Handle#time is less than the given 
+    # Efficiently take k handles for which Handle#time is less than the given
     # time.
     def pop(time)
       index = bisect_left(@sequence, time)
-      
+
       @sequence.pop(@sequence.size - index)
     end
-    
-    # Return the left-most index where to insert item e, in a list a, assuming 
+
+    # Return the left-most index where to insert item e, in a list a, assuming
     # a is sorted in descending order.
     def bisect_left(a, e, l = 0, u = a.length)
       while l < u
-        m = l + (u-l).div(2)
-        
+        m = l + (u - l).div(2)
+
         if a[m] > e
-          l = m+1
+          l = m + 1
         else
           u = m
         end
       end
-      
-      return l
+
+      l
     end
   end
 end

data/lib/timers/group.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
 
-require 'set'
-require 'forwardable'
-require 'hitimes'
+require "set"
+require "forwardable"
+require "hitimes"
 
-require 'timers/timer'
-require 'timers/events'
+require "timers/timer"
+require "timers/events"
 
 module Timers
+  # A collection of timers which may fire at different times
   class Group
     include Enumerable
 
@@ -15,22 +17,22 @@ module Timers
 
     def initialize
       @events = Events.new
-      
+
       @timers = Set.new
       @paused_timers = Set.new
-      
+
       @interval = Hitimes::Interval.new
       @interval.start
     end
 
     # Scheduled events:
-    attr :events
-    
+    attr_reader :events
+
     # Active timers:
-    attr :timers
-    
+    attr_reader :timers
+
     # Paused timers:
-    attr :paused_timers
+    attr_reader :paused_timers
 
     # Call the given block after the given interval. The first argument will be
     # the time at which the group was asked to fire timers for.
@@ -41,11 +43,11 @@ module Timers
     # Call the given block immediately, and then after the given interval. The first
     # argument will be the time at which the group was asked to fire timers for.
     def now_and_after(interval, &block)
-      block.call
+      yield
       after(interval, &block)
     end
 
-    # Call the given block periodically at the given interval. The first 
+    # Call the given block periodically at the given interval. The first
     # argument will be the time at which the group was asked to fire timers for.
     def every(interval, recur = true, &block)
       Timer.new(self, interval, recur, &block)
@@ -54,28 +56,28 @@ module Timers
     # Call the given block immediately, and then periodically at the given interval. The first
     # argument will be the time at which the group was asked to fire timers for.
     def now_and_every(interval, recur = true, &block)
-      block.call
+      yield
       every(interval, recur, &block)
     end
 
     # Wait for the next timer and fire it. Can take a block, which should behave
     # like sleep(n), except that n may be nil (sleep forever) or a negative
     # number (fire immediately after return).
-    def wait(&block)
+    def wait
       if block_given?
         yield wait_interval
-        
-        while interval = wait_interval and interval > 0
+
+        while (interval = wait_interval) && interval > 0
           yield interval
         end
       else
-        while interval = wait_interval and interval > 0
+        while (interval = wait_interval) && interval > 0
           # We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
           sleep interval
         end
       end
 
-      return fire
+      fire
     end
 
     # Interval to wait until when the next timer will fire.
@@ -83,32 +85,27 @@ module Timers
     # - -ve: timers expired already
     # -   0: timers ready to fire
     # - +ve: timers waiting to fire
-    def wait_interval(offset = self.current_offset)
-      if handle = @events.first
-        return handle.time - Float(offset)
-      end
+    def wait_interval(offset = current_offset)
+      handle = @events.first
+      handle.time - Float(offset) if handle
     end
 
     # Fire all timers that are ready.
-    def fire(offset = self.current_offset)
+    def fire(offset = current_offset)
       @events.fire(offset)
     end
 
     # Pause all timers.
     def pause
-      @timers.dup.each do |timer|
-        timer.pause
-      end
+      @timers.dup.each(&:pause)
     end
 
     # Resume all timers.
     def resume
-      @paused_timers.dup.each do |timer|
-        timer.resume
-      end
+      @paused_timers.dup.each(&:resume)
     end
 
-    alias_method :continue, :resume
+    alias continue resume
 
     # Delay all timers.
     def delay(seconds)
@@ -119,9 +116,7 @@ module Timers
 
     # Cancel all timers.
     def cancel
-      @timers.dup.each do |timer|
-        timer.cancel
-      end
+      @timers.dup.each(&:cancel)
     end
 
     # The group's current time.