recurrent 0.0.1

data/.autotest

@@ -0,0 +1,13 @@
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+
+  # Run any test that changes
+  at.add_mapping(%r{^spec/.*_spec\.rb$}) do |f, _|
+    [f]
+  end
+
+  # Run tests for any file that changes in lib
+  at.add_mapping(%r{^lib/recurrent((/[^/]+)+)\.rb$}) do |_, m|
+    ["spec#{m[1]}_spec.rb"]
+  end
+end

data/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+coverage
+.rvmrc
+Gemfile.lock
+.bundle
+*.gem
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Zencoder
+
+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/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/bin/recurrent

@@ -0,0 +1,14 @@
+$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
+require 'rubygems'
+require 'trollop'
+begin
+  require 'config/environment'
+rescue LoadError
+  require 'recurrent'
+end
+
+opts = Trollop::options do
+  opt :tasks_file, "File containing task definitions and configuration", :default => 'config/recurrences.rb'
+end
+
+Recurrent::Worker.new(opts[:tasks_file]).start

data/lib/recurrent.rb

@@ -0,0 +1,14 @@
+require 'ice_cube'
+begin
+  require 'active_support/time'
+rescue LoadError
+  require 'active_support'
+end
+require 'recurrent/ice_cube_extensions'
+
+require 'recurrent/configuration'
+require 'recurrent/logger'
+require 'recurrent/scheduler'
+require 'recurrent/task'
+require 'recurrent/version'
+require 'recurrent/worker'

data/lib/recurrent/configuration.rb

@@ -0,0 +1,26 @@
+module Recurrent
+  class Configuration
+
+    class << self
+
+      attr_accessor :logging, :wait_for_running_tasks_on_exit_for
+
+      def self.block_accessor(*fields)
+        fields.each do |field|
+          attr_writer field
+          eval("
+          def #{field}
+            if block_given?
+              @#{field} = Proc.new
+            else
+              @#{field}
+            end
+          end
+          ")
+        end
+      end
+      block_accessor :logger, :save_task_schedule, :load_task_schedule, :save_task_return_value, :process_locking, :handle_slow_task
+
+    end
+  end
+end

data/lib/recurrent/ice_cube_extensions.rb

@@ -0,0 +1,22 @@
+module IceCube
+  class Rule
+    def frequency_in_seconds
+      rule_type = self.class
+      if rule_type == IceCube::YearlyRule
+        @interval.years
+      elsif rule_type == IceCube::MonthlyRule
+        @interval.months
+      elsif rule_type == IceCube::WeeklyRule
+        @interval.weeks
+      elsif rule_type == IceCube::DailyRule
+        @interval.days
+      elsif rule_type == IceCube::HourlyRule
+        @interval.hours
+      elsif rule_type == IceCube::MinutelyRule
+        @interval.minutes
+      elsif rule_type == IceCube::SecondlyRule
+        @interval.seconds
+      end
+    end
+  end
+end

data/lib/recurrent/logger.rb

@@ -0,0 +1,26 @@
+module Recurrent
+  class Logger
+
+    attr_reader :identifier
+
+    def initialize(identifier)
+      @identifier = identifier
+    end
+
+    def log_message(message)
+      "[Recurrent - Process:#{@identifier} - Timestamp:#{Time.now.to_s(:seconds)}] - #{message}"
+    end
+
+    def self.define_log_levels(*log_levels)
+      log_levels.each do |log_level|
+        define_method(log_level) do |message|
+          message = log_message(message)
+          puts message unless Configuration.logging == "quiet"
+          Configuration.logger.call(message, log_level) if Configuration.logger
+        end
+      end
+    end
+    define_log_levels :info, :debug, :warn
+
+  end
+end

data/lib/recurrent/scheduler.rb

@@ -0,0 +1,149 @@
+module Recurrent
+  class Scheduler
+
+    attr_accessor :tasks, :logger
+
+    def initialize(task_file=nil)
+      @tasks = []
+      identifier = "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+      @logger = Logger.new(identifier)
+      eval(File.read(task_file)) if task_file
+    end
+
+    def configure
+      Configuration
+    end
+
+    def create_rule_from_frequency(frequency)
+      logger.info "| Creating an IceCube Rule"
+      if yearly?(frequency)
+        logger.info "| Creating a yearly rule"
+        IceCube::Rule.yearly(frequency / 1.year)
+      elsif monthly?(frequency)
+        logger.info "| Creating a monthly rule"
+        IceCube::Rule.monthly(frequency / 1.month)
+      elsif weekly?(frequency)
+          logger.info "| Creating a weekly rule"
+          IceCube::Rule.weekly(frequency / 1.week)
+      elsif daily?(frequency)
+          logger.info "| Creating a daily rule"
+          IceCube::Rule.daily(frequency / 1.day)
+      elsif hourly?(frequency)
+        logger.info "| Creating an hourly rule"
+        IceCube::Rule.hourly(frequency / 1.hour)
+      elsif minutely?(frequency)
+          logger.info "| Creating a minutely rule"
+          IceCube::Rule.minutely(frequency / 1.minute)
+      else
+        logger.info "| Creating a secondly rule"
+        IceCube::Rule.secondly(frequency)
+      end
+    end
+
+    def create_schedule(name, frequency, start_time=nil)
+      logger.info "| Creating schedule"
+      if frequency.is_a? IceCube::Rule
+        logger.info "| Frequency is an IceCube Rule: #{frequency.to_s}"
+        rule = frequency
+        frequency_in_seconds = rule.frequency_in_seconds
+      else
+        logger.info "| Frequency is an integer: #{frequency}"
+        rule = create_rule_from_frequency(frequency)
+        logger.info "| IceCube Rule created: #{rule.to_s}"
+        frequency_in_seconds = frequency
+      end
+      start_time ||= derive_start_time(name, frequency_in_seconds)
+      schedule = IceCube::Schedule.new(start_time)
+      schedule.add_recurrence_rule rule
+      logger.info "| schedule created"
+      schedule
+    end
+
+    def derive_start_time(name, frequency)
+      logger.info "| No start time provided, deriving one."
+      if Configuration.load_task_schedule
+        logger.info "| Attempting to derive from saved schedule"
+        derive_start_time_from_saved_schedule(name, frequency)
+      else
+        derive_start_time_from_frequency(frequency)
+      end
+    end
+
+    def derive_start_time_from_saved_schedule(name, frequency)
+      saved_schedule = Configuration.load_task_schedule.call(name)
+      if saved_schedule
+        logger.info "| Saved schedule found"
+        if saved_schedule.rrules.first.frequency_in_seconds == frequency
+          logger.info "| Saved schedule frequency matches, setting start time to saved schedules next occurrence: #{saved_schedule.next_occurrence.to_s(:seconds)}"
+          saved_schedule.next_occurrence
+        else
+          logger.info "| Schedule frequency does not match saved schedule frequency"
+          derive_start_time_from_frequency(frequency)
+        end
+      else
+        derive_start_time_from_frequency(frequency)
+      end
+    end
+
+    def derive_start_time_from_frequency(frequency)
+      logger.info "| Deriving start time from frequency"
+      current_time = Time.now
+      if frequency < 1.minute
+        logger.info "| Setting start time to beginning of current minute"
+        current_time.change(:sec => 0, :usec => 0)
+      elsif frequency < 1.hour
+        logger.info "| Setting start time to beginning of current hour"
+        current_time.change(:min => 0, :sec => 0, :usec => 0)
+      elsif frequency < 1.day
+        logger.info "| Setting start time to beginning of current day"
+        current_time.beginning_of_day
+      elsif frequency < 1.week
+        logger.info "| Setting start time to beginning of current week"
+        current_time.beginning_of_week
+      elsif frequency < 1.month
+        logger.info "| Setting start time to beginning of current month"
+        current_time.beginning_of_month
+      elsif frequency < 1.year
+        logger.info "| Setting start time to beginning of current year"
+        current_time.beginning_of_year
+      end
+    end
+
+    def every(frequency, key, options={}, &block)
+      logger.info "Adding Task: #{key}"
+      @tasks << Task.new(:name => key,
+                         :schedule => create_schedule(key, frequency, options[:start_time]),
+                         :action => block,
+                         :save => options[:save],
+                         :logger => logger)
+      logger.info "| #{key} added to Scheduler"
+    end
+
+    def next_task_time
+      tasks.map { |task| task.next_occurrence }.sort.first
+    end
+
+    def running_tasks
+      tasks.select do |task|
+        task.running?
+      end
+    end
+
+    def tasks_at_time(time)
+      tasks.select do |task|
+        task.next_occurrence == time
+      end
+    end
+
+    def self.define_frequencies(*frequencies)
+      frequencies.each do |frequency|
+        method_name = frequency == :day ? :daily? : :"#{frequency}ly?"
+        define_method(method_name) do |number|
+          (number % 1.send(frequency)) == 0
+        end
+      end
+    end
+    define_frequencies :year, :month, :week, :day, :hour, :minute, :second
+
+  end
+end

data/lib/recurrent/task.rb

@@ -0,0 +1,57 @@
+module Recurrent
+  class Task
+    attr_accessor :action, :name, :logger, :save, :schedule, :thread
+
+    def initialize(options={})
+      @name = options[:name]
+      @schedule = options[:schedule]
+      @action = options[:action]
+      @save = options[:save]
+      @logger = options[:logger]
+      Configuration.save_task_schedule.call(name, schedule) if Configuration.save_task_schedule
+    end
+
+    def execute(execution_time)
+      return handle_still_running(execution_time) if running?
+      @thread = Thread.new do
+        Thread.current["execution_time"] = execution_time
+        return_value = action.call
+        save_results(return_value) if save?
+      end
+    end
+
+    def handle_still_running(current_time)
+      logger.info "#{name}: Execution from #{thread['execution_time'].to_s(:seconds)} still running, aborting this execution."
+      if Configuration.handle_slow_task
+        Configuration.handle_slow_task.call(name, current_time)
+      end
+    end
+
+    def next_occurrence
+      return @next_occurrence if @next_occurrence && @next_occurrence.future?
+      @next_occurrence = schedule.next_occurrence
+    end
+
+    def save?
+      !!save
+    end
+
+    def save_results(return_value)
+      logger.info "#{name}: Wants to save its return value."
+      if Configuration.save_task_return_value
+        Configuration.save_task_return_value.call(:name => name,
+                                                  :return_value => return_value,
+                                                  :executed_at => thread['execution_time'],
+                                                  :executed_by => logger.identifier)
+        logger.info "#{name}: Return value saved."
+      else
+        logger.info "#{name}: No method to save return values is configured."
+      end
+    end
+
+    def running?
+      thread.try(:alive?)
+    end
+
+  end
+end

data/lib/recurrent/version.rb

@@ -0,0 +1,3 @@
+module Recurrent
+  VERSION = '0.0.1'
+end

data/lib/recurrent/worker.rb

@@ -0,0 +1,101 @@
+module Recurrent
+  class Worker
+
+    attr_accessor :scheduler, :logger
+
+    def initialize(task_file=nil)
+      @scheduler = Scheduler.new(task_file)
+      @logger = scheduler.logger
+    end
+
+    def start
+      logger.info "Starting Recurrent"
+
+      trap('TERM') { logger.info 'Waiting for running tasks and exiting...'; $exit = true }
+      trap('INT')  { logger.info 'Waiting for running tasks and exiting...'; $exit = true }
+      trap('QUIT') { logger.info 'Waiting for running tasks and exiting...'; $exit = true }
+
+      if Configuration.process_locking
+        execute_with_locking
+      else
+        execute
+      end
+
+      logger.info("Goodbye.")
+    end
+
+    def execute
+      loop do
+        execution_time = scheduler.next_task_time
+        tasks_to_execute = scheduler.tasks_at_time(execution_time)
+
+        wait_for_running_tasks && break if $exit
+
+        wait_until(execution_time)
+
+        wait_for_running_tasks && break if $exit
+
+        tasks_to_execute.each do |task|
+          logger.info "#{task.name}: Executing at #{execution_time.to_s(:seconds)}"
+          task.execute(execution_time)
+        end
+
+        wait_for_running_tasks && break if $exit
+      end
+    end
+
+    def execute_with_locking
+      lock_established = nil
+      until lock_established
+        break if $exit
+        lock_established = Configuration.process_locking.call('recurrent') do
+          execute
+        end
+        break if $exit
+        logger.info 'Tasks are being monitored by another process. Standing by.'
+        sleep(5)
+      end
+    end
+
+    def wait_for_running_tasks
+      if Configuration.wait_for_running_tasks_on_exit_for
+        wait_for_running_tasks_for(Configuration.wait_for_running_tasks_on_exit_for)
+      else
+        wait_for_running_tasks_indefinitely
+      end
+    end
+
+    def wait_for_running_tasks_for(seconds)
+      while scheduler.running_tasks.any? do
+        logger.info "Killing running tasks in #{seconds.inspect}."
+        seconds -= 1
+        sleep(1)
+        if seconds == 0
+          scheduler.running_tasks.each do |task|
+            logger.info "Killing #{task.name}."
+            task.thread = nil unless task.thread.try(:kill).try(:alive?)
+          end
+        end
+      end
+      true
+    end
+
+    def wait_for_running_tasks_indefinitely
+      if task = scheduler.running_tasks.first
+        logger.info "Waiting for #{task.name} to finish."
+        task.thread.try(:join)
+        wait_for_running_tasks_indefinitely
+      else
+        logger.info "All tasks finished, exiting..."
+        true
+      end
+    end
+
+    def wait_until(time)
+      until time.past?
+        sleep(0.5) unless $exit
+      end
+    end
+
+  end
+end

data/recurrent.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'recurrent/version'
+
+Gem::Specification.new do |s|
+  s.name         = "recurrent"
+  s.version      = Recurrent::VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.authors      = ["Adam Kittelson"]
+  s.email        = ["adam@zencoder.com"]
+  s.homepage     = "http://github.com/zencoder/recurrent"
+  s.summary      = "Task scheduler that doesn't need to bootstrap your Rails environment every time it executes a task the way running a rake task via cron does."
+  s.description  = "Task scheduler that doesn't need to bootstrap your Rails environment every time it executes a task the way running a rake task via cron does."
+
+  s.add_dependency "ice_cube", "0.6.8"
+  s.add_dependency "activesupport"
+  s.add_dependency "i18n"
+  s.add_dependency "trollop"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "autotest"
+  s.add_development_dependency "timecop"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "pry-doc"
+  s.executables << "recurrent"
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_path = ["lib"]
+end

data/spec/logger_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Recurrent
+  describe Logger do
+    before(:each) do
+      @logger = Logger.new('logtastic')
+      @users_logger = stub('logger')
+      Configuration.logger do |message, log_level|
+        @users_logger.info(message) if log_level == :info
+        @users_logger.debug(message) if log_level == :debug
+        @users_logger.warn(message) if log_level == :warn
+      end
+    end
+
+    after(:all) do
+      Configuration.logger = nil
+    end
+
+    describe "#info" do
+      it "should send a message to the logger with the info logging level" do
+        @users_logger.should_receive(:info).with(@logger.log_message("testing logger"))
+        @logger.info("testing logger")
+      end
+    end
+
+    describe "#debug" do
+      it "should send a message to the logger with the debug logging level" do
+        @users_logger.should_receive(:debug).with(@logger.log_message("testing logger"))
+        @logger.debug("testing logger")
+      end
+    end
+
+    describe "#warn" do
+      it "should send a message to the logger with the info logging level" do
+        @users_logger.should_receive(:warn).with(@logger.log_message("testing logger"))
+        @logger.warn("testing logger")
+      end
+    end
+
+    describe "#log_message" do
+      it "adds the scheduler's identifier to the message" do
+        @logger.log_message("testing").should == "[Recurrent - Process:logtastic - Timestamp:#{Time.now.to_s(:seconds)}] - testing"
+      end
+    end
+
+  end
+end

data/spec/scheduler_spec.rb

@@ -0,0 +1,310 @@
+require 'spec_helper'
+
+module Recurrent
+  describe Scheduler do
+    before(:all) do
+      Configuration.logging = "quiet"
+    end
+
+    describe "schedule creation methods" do
+      before(:all) do
+        @scheduler = Scheduler.new
+      end
+
+      describe "#create_rule_from_frequency" do
+        context "when the frequency is in years" do
+          it "should create a yearly rule" do
+            @scheduler.create_rule_from_frequency(2.years).class.should == IceCube::YearlyRule
+          end
+        end
+
+        context "when the frequency is in months" do
+          it "should create a yearly rule" do
+            @scheduler.create_rule_from_frequency(3.months).class.should == IceCube::MonthlyRule
+          end
+        end
+
+        context "when the frequency is in weeks" do
+          it "should create a weekly rule" do
+            @scheduler.create_rule_from_frequency(2.weeks).class.should == IceCube::WeeklyRule
+          end
+        end
+
+        context "when the frequency is in days" do
+          it "should create a daily rule" do
+            @scheduler.create_rule_from_frequency(3.days).class.should == IceCube::DailyRule
+          end
+        end
+
+        context "when the frequency is in hours" do
+          it "should create an hourly rule" do
+            @scheduler.create_rule_from_frequency(6.hours).class.should == IceCube::HourlyRule
+          end
+        end
+
+        context "when the frequency is in minutes" do
+          it "should create a minutely rule" do
+            @scheduler.create_rule_from_frequency(10.minutes).class.should == IceCube::MinutelyRule
+          end
+        end
+
+        context "when the frequency is in seconds" do
+          it "should create a secondly rule" do
+            @scheduler.create_rule_from_frequency(30.seconds).class.should == IceCube::SecondlyRule
+          end
+        end
+      end
+
+      describe "create_schedule" do
+        context "when frequency is an IceCube Rule" do
+          subject do
+            rule = IceCube::Rule.daily(1)
+            @scheduler.create_schedule(:test, rule)
+          end
+          it "should be a schedule" do
+            subject.class.should == IceCube::Schedule
+          end
+          it "should have the correct rule" do
+            subject.rrules.first.is_a? IceCube::DailyRule
+          end
+        end
+
+        context "when frequency is a number" do
+          subject do
+            @scheduler.create_schedule(:test, 1.day)
+          end
+          it "should be a schedule" do
+            subject.class.should == IceCube::Schedule
+          end
+          it "should have the correct rule" do
+            subject.rrules.first.is_a? IceCube::DailyRule
+          end
+        end
+
+        context "when start time is not provided" do
+          it "should derive its own start time" do
+            @scheduler.should_receive(:derive_start_time)
+            @scheduler.create_schedule(:test, 1.day)
+          end
+        end
+
+        context "when start time is provided" do
+          it "should not derive its own start time" do
+            @scheduler.should_not_receive(:derive_start_time)
+            @scheduler.create_schedule(:test, 1.day, Time.now)
+          end
+        end
+      end
+
+      describe "derive_start_time_from_frequency" do
+        context "when the current time is 11:35:12 am on July 26th, 2011" do
+          before(:all) do
+            Timecop.freeze(Time.local(2011, 7, 26, 11, 35, 12))
+          end
+
+          context "and the frequency is less than a minute" do
+            it "should be 11:35:00, the beginning of the current minute" do
+              start_time = @scheduler.derive_start_time_from_frequency(30.seconds)
+              start_time.should == Time.local(2011, 7, 26, 11, 35, 00)
+            end
+          end
+
+          context "and the frequency is less than an hour" do
+            it "should be 11:00:00, the beginning of the current hour" do
+              start_time = @scheduler.derive_start_time_from_frequency(15.minutes)
+              start_time.should == Time.local(2011, 7, 26, 11, 00, 00)
+            end
+          end
+
+          context "and the frequency is less than a day" do
+            it "should be 00:00:00 on July 26th, 2011, the beginning of the current day" do
+              start_time = @scheduler.derive_start_time_from_frequency(3.hours)
+              start_time.should == Time.local(2011, 7, 26, 00, 00, 00)
+            end
+          end
+
+          context "and the frequency is less than a week" do
+            it "should be 00:00:00 on July 25th, 2011, the beginning of the current week" do
+              start_time = @scheduler.derive_start_time_from_frequency(3.days)
+              start_time.should == Time.local(2011, 7, 25, 00, 00, 00)
+            end
+          end
+
+          context "and the frequency is less than a month" do
+            it "should be 00:00:00 on July 1st, 2011, the beginning of the current month" do
+              start_time = @scheduler.derive_start_time_from_frequency(10.days)
+              start_time.should == Time.local(2011, 7, 01, 00, 00, 00)
+            end
+          end
+
+          context "and the frequency is less than a year" do
+            it "should be 00:00:00 on January 1st, 2011, the beginning of the current year" do
+              start_time = @scheduler.derive_start_time_from_frequency(2.months)
+              start_time.should == Time.local(2011, 1, 01, 00, 00, 00)
+            end
+          end
+
+          after(:all) do
+            Timecop.return
+          end
+        end
+      end
+
+      describe "derive_start_time_from_saved_schedule" do
+        before(:all) do
+          @scheduler = Scheduler.new
+          Configuration.load_task_schedule do |name|
+            current_time = Time.new
+            current_time.change(:sec => 0, :usec => 0)
+            @scheduler.create_schedule(:test, 10.seconds, current_time) if name == :test
+          end
+        end
+
+        describe "a schedule being created with a saved schedule with the same name and frequency" do
+          it "derives its start time from the saved schedule" do
+            @scheduler.should_not_receive(:derive_start_time_from_frequency)
+            @scheduler.create_schedule(:test, 10.seconds)
+          end
+
+          describe "the created schedule's start time" do
+            it "should be the next occurrence of the saved schedule" do
+              saved_schedule = Configuration.load_task_schedule.call(:test)
+              created_schedule = @scheduler.create_schedule(:test, 10.seconds)
+              created_schedule.start_date.to_s(:seconds).should == saved_schedule.next_occurrence.to_s(:seconds)
+            end
+          end
+
+        end
+
+        describe "a schedule being created with a saved schedule with the same name and different frequency" do
+          it "derives its start time from the frequency" do
+            @scheduler.should_receive(:derive_start_time_from_frequency)
+            @scheduler.create_schedule(:test, 15.seconds)
+          end
+        end
+
+        describe "a schedule being created without a saved schedule" do
+          it "derives its start time from the frequency" do
+            @scheduler.should_receive(:derive_start_time_from_frequency)
+            @scheduler.create_schedule(:new_test, 10.seconds)
+          end
+        end
+
+
+        after(:all) do
+          Configuration.load_task_schedule = nil;
+        end
+      end
+    end
+
+    describe "#next_task_time" do
+      context "when there are multiple tasks" do
+        it "should return the soonest time at which a task is scheduled" do
+          task1 = stub('task1')
+          task1.stub(:next_occurrence).and_return(10.minutes.from_now)
+          task2 = stub('task2')
+          task2.stub(:next_occurrence).and_return(5.minutes.from_now)
+          task3 = stub('task3')
+          task3.stub(:next_occurrence).and_return(15.minutes.from_now)
+          schedule = Scheduler.new
+          schedule.tasks << task1
+          schedule.tasks << task2
+          schedule.tasks << task3
+          schedule.next_task_time.should == task2.next_occurrence
+        end
+      end
+    end
+
+    describe "#tasks_at_time" do
+      context "when there are multiple tasks" do
+        it "should return all the tasks whose next_occurrence is at the specified time" do
+          in_five_minutes = 5.minutes.from_now
+          task1 = stub('task1')
+          task1.stub(:next_occurrence).and_return(in_five_minutes)
+          task2 = stub('task2')
+          task2.stub(:next_occurrence).and_return(10.minutes.from_now)
+          task3 = stub('task3')
+          task3.stub(:next_occurrence).and_return(in_five_minutes)
+          schedule = Scheduler.new
+          schedule.tasks << task1
+          schedule.tasks << task2
+          schedule.tasks << task3
+          schedule.tasks_at_time(in_five_minutes).should =~ [task1, task3]
+        end
+      end
+    end
+
+    describe "methods created by .define_frequencies" do
+      before :all do
+        @scheduler = Scheduler.new
+      end
+
+      describe "#yearly?" do
+        it "should return true if a frequency is divisible by years" do
+          @scheduler.yearly?(3.years).should == true
+        end
+
+        it "should return false if a frequency is divisible by years" do
+          @scheduler.yearly?(3.days).should == false
+        end
+      end
+
+      describe "#monthly?" do
+        it "should return true if a frequency is divisible by months" do
+          @scheduler.monthly?(3.months).should == true
+        end
+
+        it "should return false if a frequency is not divisible by months" do
+          @scheduler.monthly?(3.days).should == false
+        end
+      end
+
+      describe "#weekly?" do
+        it "should return true if a frequency is divisible by weeks" do
+          @scheduler.weekly?(3.weeks).should == true
+        end
+
+        it "should return false if a frequency is not divisible by weeks" do
+          @scheduler.weekly?(3.days).should == false
+        end
+      end
+
+      describe "#daily?" do
+        it "should return true if a frequency is divisible by days" do
+          @scheduler.daily?(3.days).should == true
+        end
+
+        it "should return false if a frequency is not divisible by days" do
+          @scheduler.daily?(3.hours).should == false
+        end
+      end
+
+      describe "#hourly?" do
+        it "should return true if a frequency is divisible by hours" do
+          @scheduler.hourly?(3.hours).should == true
+        end
+
+        it "should return false if a frequency is not divisible by hours" do
+          @scheduler.hourly?(3.minutes).should == false
+        end
+      end
+
+      describe "#minutely?" do
+        it "should return true if a frequency is divisible by minutes" do
+          @scheduler.minutely?(3.minutes).should == true
+        end
+
+        it "should return false if a frequency is not divisible by years" do
+          @scheduler.minutely?(3.seconds).should == false
+        end
+      end
+
+      describe "#secondly?" do
+        it "should return true if a frequency is divisible by seconds" do
+          @scheduler.secondly?(3.years).should == true
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'recurrent'
+require 'timecop'
+require 'pry'
+

data/spec/task_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+module Recurrent
+  describe Task do
+    before(:all) do
+      Configuration.logging = "quiet"
+    end
+
+    describe "#execute" do
+      before :each do
+        @executing_task_time = 5.minutes.ago
+        @current_time = Time.now
+        @task = Task.new :name => 'execute test', :logger => Logger.new('some identifier')
+      end
+
+      context "The task is still running a previous execution" do
+        before :each do
+          @task.thread = Thread.new { Thread.current["execution_time"] = @executing_task_time; sleep(1) }
+        end
+
+        it "calls #handle_still_running and does not execute the task" do
+          @task.should_receive(:handle_still_running).with(@current_time)
+          Thread.should_not_receive(:new)
+          @task.execute(@current_time)
+        end
+      end
+
+      it "doesn't call #handle_still_running" do
+        @task.should_not_receive(:handle_still_running)
+        @task.execute(@current_time)
+      end
+
+      it "creates a thread" do
+        Thread.should_receive(:new)
+        @task.execute(@current_time)
+      end
+
+      it "sets its execution_time" do
+        @task.execute(@current_time)
+        @task.thread['execution_time'].should == @current_time
+      end
+
+      it "calls the action" do
+        @task.action.should_receive(:call)
+        @task.execute(@current_time)
+      end
+    end
+
+    describe "#next_occurrence" do
+      context "a task that occurs ever 10 seconds and has just occurred" do
+        subject do
+          current_time = Time.new
+          current_time.change(:sec => 0, :usec => 0)
+          Timecop.freeze(current_time)
+          Task.new(:name => :test, :schedule => Scheduler.new.create_schedule(:test, 10.seconds, current_time))
+        end
+
+        it "should occur 10 seconds from now" do
+          subject.next_occurrence.should == 10.seconds.from_now
+        end
+
+        it "should cache its next occurrence while it's still valid" do
+          subject.schedule.should_receive(:next_occurrence).and_return(10.seconds.from_now)
+          subject.next_occurrence
+          subject.schedule.should_not_receive(:next_occurrence)
+          subject.next_occurrence
+        end
+
+        after(:each) do
+          Timecop.return
+        end
+
+      end
+    end
+
+    describe "#handle_still_running" do
+      before(:all) do
+        @executing_task_time = 5.minutes.ago
+        @current_time = Time.now
+        @task = Task.new :name => 'handle_still_running_test', :logger => Logger.new('some identifier')
+        @task.thread = Thread.new { Thread.current["execution_time"] = @executing_task_time }
+      end
+
+      context "When no method for handling a still running task is configured" do
+        it "just logs that the task is still running" do
+          @task.logger.should_receive(:info).with("handle_still_running_test: Execution from #{@executing_task_time.to_s(:seconds)} still running, aborting this execution.")
+          @task.handle_still_running(@current_time)
+        end
+      end
+
+      context "When a method for handling a still running task is configured" do
+        before(:each) do
+          Configuration.handle_slow_task { |options| 'testing is fun' }
+        end
+
+        it "logs that the task is still running and calls the method" do
+          @task.logger.should_receive(:info).with("handle_still_running_test: Execution from #{@executing_task_time.to_s(:seconds)} still running, aborting this execution.")
+          Configuration.handle_slow_task.should_receive(:call).with('handle_still_running_test', @current_time)
+          @task.handle_still_running(@current_time)
+        end
+
+        after(:each) do
+          Configuration.handle_slow_task = nil
+        end
+      end
+    end
+
+    describe "#save?" do
+      describe "A task initialized with :save => true" do
+        it "returns true" do
+          Task.new(:save => true).save?.should == true
+        end
+      end
+
+      describe "A task initialized with :save => false" do
+        it "returns false" do
+          Task.new(:save => false).save?.should == false
+        end
+      end
+
+      describe "A task initialized with no :save option" do
+        it "returns false" do
+          Task.new.save?.should == false
+        end
+      end
+    end
+
+    describe "#save_results" do
+      context "When no method for saving results is configured" do
+        it "logs that information" do
+          t = Task.new :name => 'save_results_test', :logger => Logger.new('some identifier')
+          t.logger.should_receive(:info).with("save_results_test: Wants to save its return value.")
+          t.logger.should_receive(:info).with("save_results_test: No method to save return values is configured.")
+          t.save_results('some value')
+        end
+      end
+
+      context "When a method for saving results is configured" do
+        before(:each) do
+          Configuration.save_task_return_value = lambda { |options| 'testing is fun'}
+          @task = Task.new :name => 'save_results_test', :logger => Logger.new('some identifier')
+          @current_time = Time.now
+          @task.thread = Thread.new { Thread.current["execution_time"] = @current_time }
+        end
+
+        it "calls the method and logs that the value was saved" do
+          @task.logger.should_receive(:info).with("save_results_test: Wants to save its return value.")
+          Configuration.save_task_return_value.should_receive(:call).with(:name => 'save_results_test',
+                                                                          :return_value => 'some value',
+                                                                          :executed_at => @current_time,
+                                                                          :executed_by => 'some identifier')
+          @task.logger.should_receive(:info).with("save_results_test: Return value saved.")
+          @task.save_results('some value')
+        end
+
+        after(:each) do
+          Configuration.save_task_return_value = nil
+        end
+      end
+
+    end
+
+    describe "#running?" do
+      describe "A task with a live thread" do
+        it "returns true" do
+          t = Task.new
+          t.thread = Thread.new { sleep 1 }
+          t.running?.should be_true
+        end
+      end
+
+      describe "A task with a dead thread" do
+        it "returns false" do
+          t = Task.new
+          t.thread = Thread.new { sleep 1 }
+          t.thread.kill
+          t.running?.should be_false
+        end
+      end
+
+      describe "A task with no thread" do
+        it "returns false" do
+          t = Task.new
+          t.thread = nil
+          t.running?.should be_false
+        end
+      end
+
+    end
+  end
+end

data/spec/worker_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Recurrent
+  describe Worker do
+    describe "#wait_until" do
+      it "waits until a specified time" do
+        Timecop.freeze(Time.local(2011, 7, 26, 11, 35, 00))
+        waiting_thread = Thread.new { Worker.new.wait_until(Time.local(2011, 7, 26, 11, 40, 00)) }
+        waiting_thread.alive?.should be_true
+        Timecop.travel(Time.local(2011, 7, 26, 11, 40, 00))
+        sleep(0.5)
+        waiting_thread.alive?.should be_false
+        Timecop.return
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,221 @@
+--- !ruby/object:Gem::Specification 
+name: recurrent
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Adam Kittelson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-05 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ice_cube
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 6
+        - 8
+        version: 0.6.8
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: pry
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: pry-doc
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
+description: Task scheduler that doesn't need to bootstrap your Rails environment every time it executes a task the way running a rake task via cron does.
+email: 
+- adam@zencoder.com
+executables: 
+- recurrent
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.markdown
+- Rakefile
+- autotest/discover.rb
+- bin/recurrent
+- lib/recurrent.rb
+- lib/recurrent/configuration.rb
+- lib/recurrent/ice_cube_extensions.rb
+- lib/recurrent/logger.rb
+- lib/recurrent/scheduler.rb
+- lib/recurrent/task.rb
+- lib/recurrent/version.rb
+- lib/recurrent/worker.rb
+- recurrent.gemspec
+- spec/logger_spec.rb
+- spec/scheduler_spec.rb
+- spec/spec_helper.rb
+- spec/task_spec.rb
+- spec/worker_spec.rb
+has_rdoc: true
+homepage: http://github.com/zencoder/recurrent
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.9.2
+signing_key: 
+specification_version: 3
+summary: Task scheduler that doesn't need to bootstrap your Rails environment every time it executes a task the way running a rake task via cron does.
+test_files: 
+- spec/logger_spec.rb
+- spec/scheduler_spec.rb
+- spec/spec_helper.rb
+- spec/task_spec.rb
+- spec/worker_spec.rb