easy_timers 1.0.5

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/.idea/
+/.idea

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-18mode
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in easy_timers.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# EasyTimers
+
+[![Build Status](https://travis-ci.org/malakai97/easy_timers.svg?branch=master)](https://travis-ci.org/malakai97/easy_timers)
+
+A simple interface for creating timers with callbacks that handles all the threading for you.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'easy_timers'
+```
+
+Or install it yourself as:
+
+    $ gem install easy_timers
+
+## Usage
+
+Create a new group of timers with `EasyTimers::Timers.new`:
+
+```ruby
+require 'easy_timers'
+
+timers = EasyTimers::Timers.new
+```
+
+Schedule a timer to execute 10 seconds from now with `EasyTimers::Timers#after`:
+
+```ruby
+timers.after(10) { puts "Hello world" }
+```
+
+Now `timers` has a single timer that will call its block in ten seconds.
+
+You can also supply a ruby Time object instead of an interval.
+
+```ruby
+the_future = Time.now + 10
+timers.after(the_future) { put "Ten seconds have passed." }
+```
+
+If you want to be able to cancel a specific timer, you should give it a name:
+
+```ruby
+timers.after(60, :one_minute) { puts "It's been 60 seconds." }
+# do some work and decide to change our mind
+timers.cancel(:one_minute)
+```
+
+If you'd rather not mint your own names, one will be generated for you:
+
+```ruby
+timer_name = timers.after(10) { puts "hai" }
+timers.cancel(timer_name)
+```
+
+You can also create periodic timers with `EasyTimers::Timers#every`:
+
+```ruby
+timer_name = timers.every(1) { puts "One second has passed." }
+```
+
+Periodic timers will be scheduled repeatedly until cancelled.
+
+Need a combination of the above?  You can schedule a period timer to start at
+a certain time, then scheduled repeatedly using a different interval:
+
+```ruby
+timer_name = timers.after_then_every(0.5, 0.1, :my_timer) { puts "tic toc" }
+```
+
+The above timer will first fire after half a second, then fire every 0.1 seconds thereafter.
+
+## Contributing
+
+1. Fork it ( https://github.com/malakai97/easy_timers/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/easy_timers.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+require File.expand_path('../lib/easy_timers/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "easy_timers"
+  spec.version       = EasyTimers::VERSION
+  spec.authors       = ["Bryan Hockey"]
+  spec.email         = ["bryan.hockey@peimhal.com"]
+  spec.summary       = %q{Easily create and manage asynchronous timers using dates or durations.}
+  spec.description   = %q{Easily create and manage asynchronous timers using dates or durations.}
+  spec.homepage      = "http://github.com/malakai97/easy_timers"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/easy_timers/group.rb

@@ -0,0 +1,94 @@
+require 'easy_timers/timer'
+
+module EasyTimers
+
+  # Maintains a list of timers.
+  class Group
+
+    GRANULARITY = 1000 # milliseconds
+
+    # Create a new instance and begin the loop
+    def initialize
+      @events = []  # Maintained in sorted order of furthest-soonest, aka descending order.
+      @names = Hash.new do |hash,key| # Each array in descending order.
+        hash[key] = []
+      end
+      @looping_thread = Thread.new() do
+        while true
+          self.loop()
+        end
+      end
+    end
+
+
+    # Insert a new timer into the group
+    # @param timer [Timer]
+    def insert(timer)
+      index = @events.index do |element|
+        timer.time > element.time
+      end
+
+      if index == nil
+        @events.push(timer)
+      else
+        @events.insert(index, timer)
+      end
+
+      @names[timer.name].push(timer)
+      @looping_thread.run()
+      return timer.name
+    end
+
+
+    # Delete a timer from the group.
+    # @param name [Symbol]
+    def delete(name)
+      if @names[name].size() > 0
+        @names[name].each do |timer|
+          timer.cancel()
+        end
+        @names.delete(name)
+        @looping_thread.run()
+      end
+    end
+
+
+    # Perform a single loop.
+    def loop()
+      if @events.empty?
+        sleep #until woken
+      else
+        time = self.get_current_time()
+
+        while @events.last.time <= time
+          timer = @events.pop
+          @names[timer.name].pop
+          if timer.cancelled? == false
+            if timer.recurring == true
+              newTime = timer.time + timer.interval
+              newTimer = Timer.new(newTime, timer.name, timer.interval, timer.recurring, timer.callback)
+              self.insert(newTimer)
+            end
+            Thread.new do
+              timer.callback.call
+            end
+          end
+        end
+
+        untilNext = @events.last.time - time
+        if untilNext < 0.0
+          untilNext = 0.0
+        end
+        sleep untilNext
+      end
+    end
+
+
+    # Return the current time in seconds
+    def get_current_time()
+      return  Time.now.gmtime.to_f
+    end
+
+
+  end
+end

data/lib/easy_timers/timer.rb

@@ -0,0 +1,43 @@
+require 'time'
+
+module EasyTimers
+
+  # Wraps a timer
+  class Timer
+    attr_reader :time, :name, :interval, :recurring, :callback
+
+    # Create a new instance
+    # @param time [Float] Seconds since epoch.
+    # @param name [Symbol] A name for this timer; generated from the current clock time if nil.
+    # @param interval [Float] Seconds.
+    # @param recurring [Boolean]
+    # @param callback [Callable]
+    def initialize(time, name, interval, recurring, callback)
+      @time = time
+      @name = name
+      @interval = interval
+      @recurring = recurring
+      @callback = callback
+      @cancelled = false
+
+      if @name == nil
+        @name = Time.now.gmtime.to_f.to_s.to_sym
+      end
+    end
+
+
+    # Cancel the timer by overwriting the callback
+    def cancel()
+      @callback = nil
+      @cancelled = true
+    end
+
+
+    # Check if this timer has been cancelled.
+    def cancelled?
+      return @cancelled
+    end
+
+  end
+end
+

data/lib/easy_timers/timers.rb

@@ -0,0 +1,98 @@
+require 'easy_timers/timer'
+require 'easy_timers/group'
+require 'time'
+
+module EasyTimers
+  class Timers
+
+    # Create a new Timers instance to hold our timers.
+    # @return [Timers]
+    def initialize()
+      @group = Group.new()
+    end
+
+
+    # @overload after(time, name = nil, &block)
+    #   Schedule a block to be called immediately after the specified time.
+    #   @param time [Time] A time to fire the callback.
+    #   @param name [Symbol] An optional name for the timer.
+    #     Will be generated if not provided.
+    #   @return [Symbol] The name of the timer.
+    # @overload after(seconds, name = nil, &block)
+    #   Schedule a block to be called after the given number of seconds.
+    #   @param seconds [Float] Number of seconds to wait before firing the callback.
+    #   @param name [Symbol] An optional name for the timer.
+    #     Will be generated if not provided.
+    #   @return [Symbol] The name of the timer.
+    def after(time, name = nil, &block)
+      if time.is_a?(Time)
+        time = time.gmtime.to_f
+      elsif time.is_a?(Numeric)
+        time = Time.now.gmtime.to_f + time.to_f
+      else
+        raise ArgumentError, "Invalid arguments to method."
+      end
+
+      timer = Timer.new(time, name, 0, false, block)
+      name = @group.insert(timer)
+      return name
+    end
+
+
+    # Schedule a block to fire every given amount of seconds
+    # @param seconds [Float,Fixnum] Number of seconds to wait before firing the callback,
+    #   and the interval between subsequent events.
+    # @param name [Symbol] An optional name for the timer.
+    #   Will be generated if not provided.
+    # @return [Symbol] The name of the timer.
+    def every(seconds, name = nil, &block)
+      if seconds <= 0 # zero disallowed because you can't run it every 0 seconds.
+        raise ArgumentError, "Interval must be greater than 0."
+      end
+      interval = seconds.to_f
+      time = Time.now.gmtime.to_f + interval
+      timer = Timer.new(time, name, interval, true, block)
+      name = @group.insert(timer)
+      return name
+    end
+
+
+    # @overload after_then_every(start_date, interval, name = nil, &block)
+    #   Schedule a recurring timer that will first fire after the given time.
+    #   @param start_date [Time] A time to first fire the callback
+    #   @param interval [Float,Fixnum] Number of seconds to delay after the callback returns.
+    #   @param name [Symbol] An optional name for the timer.
+    #     Will be generated if not provided.
+    #   @return [Symbol] The name of the timer.
+    # @overload after_then_every(start_seconds, interval, name = nil, &block)
+    #   Schedule a recurring timer that will first fire after the given time.
+    #   The timer will then be rescheduled every interval.
+    #   @param start_seconds [Float,Fixnum] Number of seconds to delay before firing the
+    #     first callback.
+    #   @param interval [Float,Fixnum] Number of seconds to delay after the callback returns.
+    #   @param name [Symbol] An optional name for the timer.
+    #     Will be generated if not provided.
+    #   @return [Symbol] The name of the timer.
+    def after_then_every(start, interval, name = nil, &block)
+
+      if start.is_a?(Time) && interval.is_a?(Numeric) && block_given?
+        time = start.gmtime.to_f
+      elsif start.is_a?(Numeric) && interval.is_a?(Numeric) && block_given?
+        time = Time.now.gmtime.to_f + start.to_f
+      else
+        raise ArgumentError, "Invalid arguments."
+      end
+
+      timer = Timer.new(time, name, interval.to_f, true, block)
+      name = @group.insert(timer)
+      return name
+    end
+
+
+    # Cancel a timer.
+    def cancel(name)
+      @group.delete(name)
+    end
+
+  end
+end

data/lib/easy_timers/version.rb

@@ -0,0 +1,3 @@
+module EasyTimers
+  VERSION = "1.0.5"
+end

data/lib/easy_timers.rb

@@ -0,0 +1,5 @@
+require "easy_timers/version"
+
+module EasyTimers
+  # Your code goes here...
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'bundler/setup'
+require 'rspec'
+require 'easy_timers'

data/spec/timers_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+require 'easy_timers/timers'
+
+describe EasyTimers::Timers do
+
+  describe '#after(time, name = nil, &block)' do
+    before(:each) do
+      @timers = EasyTimers::Timers.new()
+    end
+
+    it 'fires at a future time' do
+      x = 1
+      time = Time.now + 0.1
+      @timers.after(time, :test) { x = 5}
+      expect(x).to eq(1)
+      sleep 0.12
+      expect(x).to eq(5)
+    end
+
+    it 'fires multiple times' do
+      x = []
+      now = Time.now
+      @timers.after(now + 0.6, :a) { x.push(:a) }
+      @timers.after(now + 0.5, :b) { x.push(:b) }
+      @timers.after(now + 0.4, :c) { x.push(:c) }
+      @timers.after(now + 0.3, :d) { x.push(:d) }
+      @timers.after(now + 0.2, :e) { x.push(:e) }
+      @timers.after(now + 0.1, :f) { x.push(:f) }
+      @timers.after(now + 0.25, :g) { x.push(:g) }
+      sleep 0.65
+      expect(x).to eq([:f, :e, :g, :d, :c, :b, :a])
+    end
+
+    it 'generates a custom name' do
+      name = nil
+      name = @timers.after(Time.now + 0.1) { true }
+      expect(name).to_not eq(nil)
+    end
+
+    it 'fires immediately when given a time in the past' do
+      x = 0
+      time = Time.now - 1
+      @timers.after(time, :test) { x = 5 }
+      sleep 0.1
+      expect(x).to eq(5)
+    end
+
+  end
+
+
+  describe '#after(seconds, name = nil, &block)' do
+    before(:each) do
+      @timers = EasyTimers::Timers.new()
+    end
+
+    it 'fires after an interval' do
+      x = 1
+      @timers.after(0.1, :test) do
+        x = 5
+      end
+      expect(x).to eq(1)
+      sleep 0.12
+      expect(x).to eq(5)
+    end
+
+    it 'fires multiple times in succession' do
+      x = []
+      @timers.after(0.6, :a) { x.push(:a) }
+      @timers.after(0.5, :b) { x.push(:b) }
+      @timers.after(0.4, :c) { x.push(:c) }
+      @timers.after(0.3, :d) { x.push(:d) }
+      @timers.after(0.2, :e) { x.push(:e) }
+      @timers.after(0.1, :f) { x.push(:f) }
+      @timers.after(0.25, :g) { x.push(:g) }
+      sleep 0.65
+      expect(x).to eq([:f, :e, :g, :d, :c, :b, :a])
+
+    end
+
+    it 'generates a custom name' do
+      name = nil
+      name = @timers.after(0.1) { true }
+      expect(name).to_not eq(nil)
+    end
+
+    it 'fires immediately when given a time in the past' do
+      x = 0
+      @timers.after(-1, :test) { x = 5 }
+      sleep 0.1
+      expect(x).to eq(5)
+    end
+
+  end
+
+
+  describe '#every' do
+    before(:each) do
+      @timers = EasyTimers::Timers.new()
+    end
+
+    it 'fires more than once' do
+      x = 0
+      @timers.every(0.2) { x += 1}
+      expect(x).to eq(0)
+      sleep 0.7
+      expect(x).to eq(3)
+    end
+
+    it 'works with a staggered timer' do
+      x = []
+      @timers.every(0.3) { x.push(:a) }
+      sleep 0.1
+      @timers.every(0.3) { x.push(:b) }
+      sleep 0.7
+      expect(x).to eq([:a, :b, :a, :b])
+    end
+
+    it 'works with a similar timer' do
+      x = 0
+      @timers.every(0.1) { x += 1 }
+      @timers.every(0.1) { x += 1 }
+      sleep 0.45
+      expect(x).to eq(8)
+    end
+
+    it 'generates a custom name' do
+      name = nil
+      name = @timers.every(0.1) { true }
+      expect(name).to_not eq(nil)
+    end
+
+  end
+
+
+  describe '#after_then_every(start_seconds, interval, name = nil, &block)' do
+    before(:each) do
+      @timers = EasyTimers::Timers.new()
+    end
+
+    it 'fires after seconds then fires again' do
+      x = 0
+      @timers.after_then_every(0.2, 0.1) { x += 1}
+      expect(x).to eq(0)
+      sleep 0.25
+      expect(x).to eq(1)
+      sleep 0.2
+      expect(x).to eq(3)
+    end
+
+    it 'works with a staggered timer' do
+      x = []
+      @timers.after_then_every(0.2, 0.3) { x.push(:a) }
+      @timers.after_then_every(0.3, 0.3) { x.push(:b) }
+      sleep 0.7
+      expect(x).to eq([:a, :b, :a, :b])
+    end
+
+    it 'works with a similar timer' do
+      x = 0
+      @timers.after_then_every(0.2, 0.4) { x += 1 }
+      @timers.after_then_every(0.2, 0.4) { x += 1 }
+      sleep 0.8
+      expect(x).to eq(4)
+    end
+
+    it 'generates a custom name' do
+      name = nil
+      name = @timers.after_then_every(0.1, 0.1) { true }
+      expect(name).to_not eq(nil)
+    end
+  end
+
+
+  describe '#cancel' do
+    before(:each) do
+      @timers = EasyTimers::Timers.new()
+    end
+
+    it 'deletes an #after timer' do
+      x = 0
+      @timers.after(0.1, :test) { x += 1 }
+      @timers.cancel(:test)
+      sleep 0.15
+      expect(x).to eq(0)
+    end
+
+    it 'deletes an #every timer after it has fired' do
+      x = 0
+      @timers.every(0.1, :test) { x += 1 }
+      sleep 0.25
+      @timers.cancel(:test)
+      sleep 0.1
+      expect(x).to eq(2)
+    end
+
+    it 'fails gracefully if the timer is past' do
+      x = 0
+      @timers.after(0.1, :test) { x += 1 }
+      sleep 0.15
+      @timers.cancel(:test)
+    end
+
+    it 'fails gracefully if the timer never existed' do
+      @timers.cancel(:fake)
+    end
+
+    it 'works with generated names' do
+      x = 0
+      name = @timers.after(0.1) { x += 1 }
+      @timers.cancel(name)
+      sleep 0.15
+      expect(x).to eq(0)
+    end
+  end
+
+
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: easy_timers
+version: !ruby/object:Gem::Version
+  version: 1.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Bryan Hockey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easily create and manage asynchronous timers using dates or durations.
+email:
+- bryan.hockey@peimhal.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- easy_timers.gemspec
+- lib/easy_timers.rb
+- lib/easy_timers/group.rb
+- lib/easy_timers/timer.rb
+- lib/easy_timers/timers.rb
+- lib/easy_timers/version.rb
+- spec/spec_helper.rb
+- spec/timers_spec.rb
+homepage: http://github.com/malakai97/easy_timers
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2036513913167786788
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2036513913167786788
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Easily create and manage asynchronous timers using dates or durations.
+test_files:
+- spec/spec_helper.rb
+- spec/timers_spec.rb
+has_rdoc: