em-timers 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd2dd3c97deb96f7c3d9f2681bc9d7a8f03e5431
+  data.tar.gz: aa73bcc16297daddf064b76ec2cb84815d3d7f10
+SHA512:
+  metadata.gz: 41c3dc4a4a28c1e8dcc790b5a7410e69d02bb18a08da38dbdb4e2f172987b8f3d5b6265e52070aa605245fb7eb8ce2fce414621d825a4d5071a4cde273550456
+  data.tar.gz: 42a47c94053fef639e74d7d952dce3a217a98ceff71f65e1231f5a56d5384481c29983435a8303e9f3b6c26525195388aee25c11bf8d2f4aff4e5c5fb637a6eb

data/README

@@ -0,0 +1,39 @@
+em-timers
+
+helper methods for timers in EventMachine
+
+examples:
+
+# Once per hour, starting now. Note the :now symbol must be passed for your block to be called immediately.
+EM::Timers.do_hourly(:starting => :now) { puts "drink a beer" }
+
+# Once per day, starting in 1 day.
+EM::Timers.do_daily { puts "take a shower" }
+
+# Once per week, starting in 10 hours
+EM::Timers.do_weekly(:starting => 10.hours.from_now) { puts "take out the garbage" }
+
+# Once per month, starting at this time tomorrow.
+EM::Timers.do_monthly(:starting => 1.day.from_now) { puts "pay the bills" }
+
+# Or you can simply pass a number of seconds til starting
+EM::Timers.do_monthly(:starting => 2592000) { puts "pay the bills, in seconds!" }
+
+# Leveraging the Chronic time parsing library. em-timers knows if you have required 
+# Chronic and uses it to parse strings if you have. Otherwise, it uses Time.parse.
+#
+# Every 2 hours, starting next Tuesday at 9AM.
+require 'chronic'
+EM::Timers.do(:every => 2.hours, :starting => 'next tuesday at 9am') { puts "go pee" }
+
+# You can add up units of time as well
+EM::Timers.do(:every => 1.minutes + 3.seconds) { puts "hi!" }
+
+# You can list and cancel timers, too
+EM::Timers.list.each { |timer|
+  timer.cancel
+}
+
+
+jakecdouglas@gmail.com
+yakischloba on Freenode #eventmachine

data/lib/em-timers.rb

@@ -0,0 +1,8 @@
+$:.unshift File.expand_path(File.dirname(File.expand_path(__FILE__)))
+require 'eventmachine'
+require 'time'
+require 'em-timers/em-timers'
+require 'em-timers/numericmixable'
+require 'em-timers/cron_line'
+
+Numeric.send :include, NumericMixable

data/lib/em-timers/cron_line.rb

@@ -0,0 +1,251 @@
+#--
+# Copyright (c) 2006-2009, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+
+module EventMachine
+
+  module Timers
+    
+    #
+    # A 'cron line' is a line in the sense of a crontab
+    # (man 5 crontab) file line.
+    #
+    class CronLine
+
+      #
+      # The string used for creating this cronline instance.
+      #
+      attr_reader :original
+
+      attr_reader \
+      :seconds,
+        :minutes,
+        :hours,
+        :days,
+        :months,
+        :weekdays
+
+      def initialize (line)
+
+        super()
+
+        @original = line
+
+        items = line.split
+
+        unless items.length == 5 or items.length == 6
+          raise(
+                "cron '#{line}' string should hold 5 or 6 items, not #{items.length}")
+        end
+
+        offset = items.length - 5
+
+        @seconds = offset == 1 ? parse_item(items[0], 0, 59) : [ 0 ]
+        @minutes = parse_item(items[0 + offset], 0, 59)
+        @hours = parse_item(items[1 + offset], 0, 24)
+        @days = parse_item(items[2 + offset], 1, 31)
+        @months = parse_item(items[3 + offset], 1, 12)
+        @weekdays = parse_weekdays(items[4 + offset])
+      end
+
+      #
+      # Returns true if the given time matches this cron line.
+      #
+      def matches? (time)
+
+        time = Time.at(time) unless time.kind_of?(Time)
+
+        return false unless sub_match?(time.sec, @seconds)
+        return false unless sub_match?(time.min, @minutes)
+        return false unless sub_match?(time.hour, @hours)
+        return false unless sub_match?(time.day, @days)
+        return false unless sub_match?(time.month, @months)
+        return false unless sub_match?(time.wday, @weekdays)
+        true
+      end
+
+      #
+      # Returns an array of 6 arrays (seconds, minutes, hours, days,
+      # months, weekdays).
+      # This method is used by the cronline unit tests.
+      #
+      def to_array
+
+        [ @seconds, @minutes, @hours, @days, @months, @weekdays ]
+      end
+
+      #
+      # Returns the next time that this cron line is supposed to 'fire'
+      #
+      # This is raw, 3 secs to iterate over 1 year on my macbook :( brutal.
+      #
+      # This method accepts an optional Time parameter. It's the starting point
+      # for the 'search'. By default, it's Time.now
+      #
+      # Note that the time instance returned will be in the same time zone that
+      # the given start point Time (thus a result in the local time zone will
+      # be passed if no start time is specified (search start time set to
+      # Time.now))
+      #
+      #   >> EventMachine::Timers::CronLine.new('30 7 * * *').next_time( Time.mktime(2008,10,24,7,29) )
+      #   => Fri Oct 24 07:30:00 -0500 2008
+      #
+      #   >> EventMachine::Timers::CronLine.new('30 7 * * *').next_time( Time.utc(2008,10,24,7,29) )
+      #   => Fri Oct 24 07:30:00 UTC 2008
+      #
+      #   >> EventMachine::Timers::CronLine.new('30 7 * * *').next_time( Time.utc(2008,10,24,7,29)  ).localtime
+      #   => Fri Oct 24 02:30:00 -0500 2008
+      #
+      # (Thanks to K Liu for the note and the examples)
+      #
+      def next_time (time=Time.now)
+
+        time -= time.usec * 1e-6
+        time += 1
+
+        loop do
+
+          unless date_match?(time)
+            time += (24 - time.hour) * 3600 - time.min * 60 - time.sec
+            next
+          end
+
+          unless sub_match?(time.hour, @hours)
+            time += (60 - time.min) * 60 - time.sec
+            next
+          end
+
+          unless sub_match?(time.min, @minutes)
+            time += 60 - time.sec
+            next
+          end
+
+          unless sub_match?(time.sec, @seconds)
+            time += 1
+            next
+          end
+
+          break
+        end
+
+        time
+      end
+
+      private
+
+      WDS = %w[ sun mon tue wed thu fri sat ]
+      #
+      # used by parse_weekday()
+
+      def parse_weekdays (item)
+
+        item = item.downcase
+
+        WDS.each_with_index { |day, index| item = item.gsub(day, index.to_s) }
+
+        r = parse_item(item, 0, 7)
+
+        r.is_a?(Array) ?
+        r.collect { |e| e == 7 ? 0 : e }.uniq :
+          r
+      end
+
+      def parse_item (item, min, max)
+
+        return nil if item == '*'
+        return parse_list(item, min, max) if item.index(',')
+        return parse_range(item, min, max) if item.index('*') or item.index('-')
+
+        i = Integer(item)
+
+        i = min if i < min
+        i = max if i > max
+
+        [ i ]
+      end
+
+      def parse_list (item, min, max)
+
+        item.split(',').inject([]) { |r, i|
+          r.push(parse_range(i, min, max))
+        }.flatten
+      end
+
+      def parse_range (item, min, max)
+
+        i = item.index('-')
+        j = item.index('/')
+
+        return item.to_i if (not i and not j)
+
+        inc = j ? Integer(item[j+1..-1]) : 1
+
+        istart = -1
+        iend = -1
+
+        if i
+
+          istart = Integer(item[0..i - 1])
+
+          if j
+            iend = Integer(item[i + 1..j])
+          else
+            iend = Integer(item[i + 1..-1])
+          end
+
+        else # case */x
+
+          istart = min
+          iend = max
+        end
+
+        istart = min if istart < min
+        iend = max if iend > max
+
+        result = []
+
+        value = istart
+        loop do
+          result << value
+          value = value + inc
+          break if value > iend
+        end
+
+        result
+      end
+
+      def sub_match?(value, values)
+        values.nil? || values.include?(value)
+      end
+
+      def date_match?(date)
+        return false unless sub_match?(date.day, @days)
+        return false unless sub_match?(date.month, @months)
+        return false unless sub_match?(date.wday, @weekdays)
+        true
+      end
+    end
+
+  end
+end

data/lib/em-timers/em-timers.rb

@@ -0,0 +1,164 @@
+module EventMachine
+
+  module Timers
+    
+    class Timer
+      @list = []
+      class << self
+        attr :list, false
+      end
+      attr :tag, false
+      attr :name, false
+      attr :options, true
+      attr :reschedule_timer, false
+      attr :kickoff_timer, false
+      def initialize(options, block)
+        @options = options
+        if options[:tag]
+          @tag = options[:tag]
+        end
+        if options[:name]
+          @name = options[:name]
+        end
+        @block = block
+        @repeats = true
+        Timer.list << self
+      end
+      def cancel
+        if @kickoff_timer
+          EM::cancel_timer(@kickoff_timer)
+          @kickoff_timer = nil
+        end
+        if @reschedule_timer
+          EM::cancel_timer(@reschedule_timer)
+          @reschedule_timer = nil
+        end
+        Timer.list.delete(self)
+      end
+      def schedule
+        increment = @options[:every] || 1
+        starting = @options[:starting]
+
+        if options[:cron]
+          starting =
+            EventMachine::Timers::CronLine.new(options[:cron]).next_time
+          @kickoff_timer = EM.add_timer(calculate_delta_time(starting)) {
+            @kickoff_timer = nil
+            run_and_reschedule_cron
+          }
+          return self
+        elsif @options[:at] || @options[:in]
+          @repeats = false
+          if @options[:at]
+            starting = parse_time(@options[:at])
+          else
+            starting = Time.now + parse_time(@options[:in])
+          end
+        end
+        
+        if starting == :now
+          run_and_reschedule(increment)
+          return self
+        else
+          starting = parse_time(starting)
+        end
+
+        time = calculate_delta_time(starting)
+        
+        @kickoff_timer = EM.add_timer(time) {
+          @kickoff_timer = nil
+          run_and_reschedule(increment)
+        }
+        self
+      end
+
+      protected
+
+      def calculate_delta_time(the_time)
+        increment = @options[:every] || 1
+        if the_time.is_a?(Time)
+          time = the_time - Time.now
+        else
+          time = the_time
+        end
+        while time < 0
+          time += increment
+        end
+        time
+      end
+
+      def parse_time(some_time)
+        if some_time.is_a?(String)
+          Object.const_defined?("Chronic") ? 
+            Chronic.parse(some_time) : 
+            Time.parse(some_time)
+        elsif some_time.is_a?(Time) || some_time.kind_of?(Numeric)
+          some_time
+        else
+          Time.now
+        end
+      end
+
+      def run_and_reschedule_cron
+        starting =
+          EventMachine::Timers::CronLine.new(options[:cron]).next_time
+        @reschedule_timer = EM.add_timer(calculate_delta_time(starting)) {
+          run_and_reschedule_cron
+        }
+        @block.call
+      end
+      
+      def run_and_reschedule(inc)
+        if @repeats
+          @reschedule_timer = EM.add_timer(inc) {
+            run_and_reschedule(inc)
+          }
+        end
+        @block.call
+      end
+      
+    end
+
+    def self.do(options={}, &blk)
+      Timer.new(options, blk).schedule
+    end
+
+    def self.do_hourly(options={}, &blk)
+      self.do({:every => 1.hour}.merge(options), &blk)
+    end
+
+    def self.do_daily(options={}, &blk)
+      self.do({:every => 1.day}.merge(options), &blk)
+    end
+
+    def self.do_weekly(options={}, &blk)
+      self.do({:every => 1.week}.merge(options), &blk)
+    end
+
+    def self.do_monthly(options={}, &blk)
+      self.do({:every => 1.month}.merge(options), &blk)
+    end
+
+    def self.cron(spec, &blk)
+      self.do({:cron => spec}, &blk)
+    end
+
+    def self.list
+      Timer.list
+    end
+
+    def self.find_by_tag(tag)
+      Timer.list.find_all { |t|
+        t.tag == tag
+      }
+    end
+
+    def self.find_by_name(name)
+      Timer.list.find_all { |t|
+        t.name == name
+      }
+    end
+
+  end
+
+end

data/lib/em-timers/numericmixable.rb

@@ -0,0 +1,56 @@
+# Stolen directly from ramaze/snippets
+module NumericMixable
+  def seconds
+    self
+  end
+  alias second seconds
+
+  # 60 seconds in a minute
+  def minutes
+    self * 60
+  end
+  alias minute minutes
+
+  # 60 minutes in an hour
+  def hours
+    self * 3600
+  end
+  alias hour hours
+
+  # 24 hours in a day
+  def days
+    self * 86400
+  end
+  alias day days
+
+  # 7 days in a week
+  def weeks
+    self * 604800
+  end
+  alias week weeks
+
+  # 30 days in a month
+  def months
+    self * 2592000
+  end
+  alias month months
+
+  # 365.25 days in a year
+  def years
+    self * 883612800
+  end
+  alias year years
+
+  # Time in the past, i.e. 3.days.ago
+  def ago t = Time.now
+    t - self
+  end
+  alias before ago
+
+  # Time in the future, i.e. 3.days.from_now
+  def from_now t = Time.now
+    t + self
+  end
+  alias since from_now
+
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: em-timers
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Jake Douglas
+- Colin Steele
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2009-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: helper methods for timers in EventMachine
+email: jakecdouglas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README
+- lib/em-timers.rb
+- lib/em-timers/numericmixable.rb
+- lib/em-timers/cron_line.rb
+- lib/em-timers/em-timers.rb
+homepage: http://www.github.com/yakischloba/em-timers
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: helper methods for timers in EventMachine
+test_files: []