urge 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjYwNzQxMzM3ZmQyNGJlNzBhOWY2YTJmZTFlMzk0ODFlODA1NjExYw==
+  data.tar.gz: !binary |-
+    M2NmZGU5ZWY0OGVkZmI0MzU5NDYyMzc0NThhOTU2Yjc2NDA0ZGFkNw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MzA2NDVlMWQ1OWJkNzY1OGJjNDhkNzllMjI0NzlmODg3YzczOTQyYjUxMjZh
+    MzMyNjZmYzRlZmUwYmI1OTFlNGZlZDNhZmIyZjEwYThjZmM4Zjg4ZGQyZDY2
+    OTYxYjljZTQzYjNlYjdlYTcwYmNkYTZmNmFlNGRkYjlmMzU2NGM=
+  data.tar.gz: !binary |-
+    NmY5M2QwNjNkZWY0N2EyOTA5MWNiMzA1NjY1ZWVmZjgwOTA3YjQzNjg3NTk4
+    YjhmZjhmYWFmZTc4ODEyZDNkNzJhODZjZTUyZmJhZTNhY2EzMWNmNzhjYjg3
+    ZTgzZjRlYTUwNGFiM2FkMDc3MDAwMmVkYzNmYWQzYWE3MjMzZmM=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Nick Adams
+
+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,29 @@
+# Urge
+
+Urges action on a timed basis. Works with persistent and transient objects.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'urge'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install urge
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/urge/persistence/active_record_persistence.rb

@@ -0,0 +1,62 @@
+module Urge
+  module Persistence
+    module ActiveRecordPersistence
+
+      def self.included( base )
+        base.extend Urge::Persistence::Base::ClassMethods
+        base.extend Urge::Persistence::ActiveRecordPersistence::ClassMethods
+        base.send( :include, Urge::Persistence::ActiveRecordPersistence::InstanceMethods )
+      end
+
+      module ClassMethods
+
+        # AR finder
+        def ready_to_run( name, at = DateTime.now )
+          options = schedules[name]
+          raise 'Unknown schedule' unless options
+          where( "#{attr_name(name)} < ?", at )
+        end
+
+
+        # def self.retailer( criteria )
+        #   matches = joins( :retailer )
+        #   # Can specify name and account code explicitly
+        #   [:name, :account_code].each do |attribute|
+        #     matches = matches.where( Retailer.arel_table[attribute].matches("%#{criteria[attribute]}%" ) ) unless criteria[attribute].blank?
+        #   end
+        #   # Can specify general criteria
+        #   if !criteria[:retailer].blank?
+        #     restriction = nil
+        #     [:name, :account_code].each do |attribute|
+        #       predicate = Retailer.arel_table[attribute].matches( "%#{criteria[:retailer]}%" )
+        #       restriction = restriction ? restriction.or( predicate ) : predicate
+        #     end
+        #     matches = matches.where( restriction )
+        #   end
+        #   matches
+        # end
+  
+        # Same as Scheduled::run_all but saves the rescheduled task
+        def run_all!( name )
+          now = DateTime.now
+          logger.debug "run_all! Time now: #{now}"
+          ready_to_run( now ).each do |task|
+            logger.debug "Task of class #{task.class.name} is about to be run! (with a bang)"
+            task.run!( name )
+          end
+        end
+      
+      end
+      
+      module InstanceMethods
+        
+        def run!( name, options = {} )
+          run( name, options )
+          save!
+        end
+        
+      end
+
+    end
+  end
+end

data/lib/urge/persistence/base.rb

@@ -0,0 +1,74 @@
+module Urge
+  module Persistence
+    module Base
+
+      module ClassMethods
+
+        # # Maps to the aasm_column in the database.  Defaults to "aasm_state".  You can write
+        # # (example provided here for ActiveRecord, but it's true for Mongoid as well):
+        # #
+        # #   create_table :foos do |t|
+        # #     t.string :name
+        # #     t.string :aasm_state
+        # #   end
+        # #
+        # #   class Foo < ActiveRecord::Base
+        # #     include AASM
+        # #   end
+        # #
+        # # OR:
+        # #
+        # #   create_table :foos do |t|
+        # #     t.string :name
+        # #     t.string :status
+        # #   end
+        # #
+        # #   class Foo < ActiveRecord::Base
+        # #     include AASM
+        # #     aasm_column :status
+        # #   end
+        # #
+        # # This method is both a getter and a setter
+        # def aasm_column(column_name=nil)
+        #   if column_name
+        #     AASM::StateMachine[self].config.column = column_name.to_sym
+        #     # @aasm_column = column_name.to_sym
+        #   else
+        #     AASM::StateMachine[self].config.column ||= :aasm_state
+        #     # @aasm_column ||= :aasm_state
+        #   end
+        #   # @aasm_column
+        #   AASM::StateMachine[self].config.column
+        # end
+        
+        def persist_class_method
+          "This is Base::persist_class_method"
+        end
+      end
+
+    end # Base
+  end # Persistence
+
+  class Base
+    # def state_with_scope(name, *args)
+    #   state_without_scope(name, *args)
+    #   unless @clazz.respond_to?(name)
+    #     if @clazz.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
+    #       scope_options = {:conditions => { "#{@clazz.table_name}.#{@clazz.aasm_column}" => name.to_s}}
+    #       scope_method = ActiveRecord::VERSION::MAJOR >= 3 ? :scope : :named_scope
+    #       @clazz.send(scope_method, name, scope_options)
+    #     elsif @clazz.ancestors.map {|klass| klass.to_s}.include?("Mongoid::Document")
+    #       scope_options = lambda { @clazz.send(:where, {@clazz.aasm_column.to_sym => name.to_s}) }
+    #       @clazz.send(:scope, name, scope_options)
+    #     end
+    #   end
+    # end
+    # alias_method :state_without_scope, :state
+    # alias_method :state, :state_with_scope
+    
+    def method_in_persistence_base
+      "This is method_in_persistence_base"
+    end
+  end # Base
+
+end # Urge

data/lib/urge/persistence.rb

@@ -0,0 +1,20 @@
+module Urge
+  module Persistence
+
+    def self.set_persistence(base)
+
+      # Use a fancier auto-loading thingy, perhaps.  When there are more persistence engines.
+      hierarchy = base.ancestors.map {|klass| klass.to_s}
+
+      dir_name = File.join( File.dirname(__FILE__), 'persistence' )
+      require File.join( dir_name, 'base' )
+      # require File.join(File.dirname(__FILE__), 'persistence', 'read_state')
+      if hierarchy.include?( "ActiveRecord::Base" )
+        require File.join( dir_name, 'active_record_persistence' )
+        base.send( :include, Urge::Persistence::ActiveRecordPersistence )
+      end
+      
+    end
+  end
+
+end

data/lib/urge/scheduled.rb

@@ -0,0 +1,95 @@
+require 'logging'
+
+module Urge
+  module Scheduled
+    module ClassMethods
+
+      def run_all( name )
+        now = DateTime.now
+        logger.debug "run_all. Time now: #{now}"
+        ready_to_run( name, now ).each do |task|
+          logger.debug "Task of class #{task.class.name} named: #{name} is about to be run"
+          task.run( name )
+        end
+      end
+        
+      def inspect_all( name )
+        now = DateTime.now
+        tasks = ready_to_run( name, now )
+        logger.info "inspect_queue. Time now: #{now}. The following #{tasks.size} tasks are ready to run"
+        tasks.each { |task| logger.info task.inspect }
+        tasks
+      end
+      
+      def logger
+        @@logger ||= Logging.logger[self]
+      end
+
+      def urge_schedule( name, options = {} )
+        logger.info "Defining schedule: #{name}. Options: #{options}. Class: #{self.name}"
+        raise 'Cannot have two schedules with the same name' if schedules[name]
+        schedules[name] = options
+      end
+      
+      def schedules
+        @@per_class_schedules ||= {}
+        @@per_class_schedules[self.name] ||= {}
+      end
+
+      def attr_name( name )
+        raise 'Non existent schedule name' if schedules[name].blank?
+        schedules[name][:scheduled_for] || "scheduled_for_#{name}"
+      end
+      
+      def all_schedules
+        @@per_class_schedules
+      end
+
+    end
+  
+    module InstanceMethods
+
+      def ready_to_run?( name )
+        ts = self.send( attr_name( name ) )
+        ts ? (DateTime.now >= ts) : false
+      end
+
+      def reschedule( name, _when )
+        logger.debug "ScheduledTask#reschedule about to reschedule for #{_when}"
+        self.send( "#{attr_name(name)}=", _when )
+      end
+
+      # Takes action and reschedules itself. That is all, and that is enough!
+      def run( name, options = {} )
+
+        return false unless ready_to_run?( name )
+        
+        logger.debug "About to call take_action_#{name}"
+        interval = internal_take_action( name, options )
+
+        logger.debug "Action taken. Calculated run interval: #{interval ? interval : 'none - task will *not* be rescheduled'}"
+        reschedule( name, interval ? interval.from_now : nil )
+        
+        true
+
+      end
+
+    private
+
+      def internal_take_action( name, options )
+        self.send( self.class.schedules[name][:action] || "take_action_#{name}".to_sym, options )
+      end
+
+      def attr_name( name )
+        self.class.attr_name( name )
+      end
+      
+    end
+  
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+      Urge::Persistence.set_persistence(base)
+    end
+  end
+end

data/lib/urge/version.rb

@@ -0,0 +1,3 @@
+module Urge
+  VERSION = "0.0.1"
+end

data/lib/urge.rb

@@ -0,0 +1,10 @@
+require 'urge/version'
+require 'urge/scheduled'
+require 'urge/persistence'
+
+# require 'urge/credit_control'
+
+require 'logging'
+
+module Urge
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: spec/aasm.sqlite3.db

data/spec/factories/factory.rb

@@ -0,0 +1,24 @@
+FactoryGirl.define do
+
+  factory :client do
+    name "Cash It In Limited"
+    code "9999"
+  end
+
+  factory :guest do
+    sequence :joined_at do |n|
+      n.weeks.ago
+    end
+
+    first_name "Freddy"
+    sequence :last_name do |n|
+      "Starr#{n}"
+    end
+    
+    sequence :email do |n|
+      "fs#{n}@example.com"
+    end
+    
+  end
+
+end

data/spec/lib/active_record/dual_action_model_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+load_schema
+
+Logging.logger['simple'].tap {|logger| 
+  logger.add_appenders 'colourful_stdout'
+  logger.level = :debug
+}
+
+
+
+logger = Logging.logger['simple']
+
+
+class DualActionGuest < ActiveRecord::Base
+
+  include Urge::Scheduled
+
+  urge_schedule( :status_check,    :scheduled_for => :status_check_at, :action => :check_status )
+  urge_schedule( :insurance_check, :scheduled_for => :insurance_check_at, :action => :check_insurance )
+  
+  def status_checked?
+    @status_checked
+  end
+  
+  def insurance_checked?
+    @insurance_checked
+  end
+
+private
+
+  def check_status( options )
+    logger.debug "In check_status"
+    @status_checked = true
+    nil
+  end
+  
+  def check_insurance( options )
+    logger.debug "In check_insurance"
+    @insurance_checked = true
+    nil
+  end
+
+end
+
+Logging.logger[DualActionGuest].tap {|logger| 
+  logger.add_appenders 'colourful_stdout'
+  logger.level = :debug
+}
+
+FactoryGirl.define do
+
+  factory :dual_action_guest do
+    sequence :joined_at do |n|
+      n.weeks.ago
+    end
+  
+    first_name "Freddy"
+    sequence :last_name do |n|
+      "Starr#{n}"
+    end
+    
+    sequence :email do |n|
+      "fs#{n}@example.com"
+    end
+    
+  end
+
+end
+
+describe 'AR model with more than one schedule' do
+  
+  context "when created" do
+
+    before(:each) do
+      @guest = FactoryGirl.create :dual_action_guest, :status_check_at => 1.hour.ago, :insurance_check_at => 1.day.ago
+      @guest.should_not be_nil
+    end
+    
+    context "both checks" do
+
+      before(:each) do
+        @checks = [:status_check, :insurance_check]
+      end
+
+      it "both checks should be ready to run" do
+        @checks.each { |c| @guest.should be_ready_to_run( c ) }
+      end
+
+      context "when run" do
+        before(:each) do
+          @checks.each { |c| @guest.run( c )}
+        end
+        
+        it "should result in the guest having his status and his insurance checked" do
+          @guest.should be_status_checked
+          @guest.should be_insurance_checked
+        end
+        
+      end
+
+    end
+
+  end
+  
+end
+
+
+describe "AR finders" do
+  
+  before(:each) do
+    DualActionGuest.delete_all
+    @count = 10
+    @count.times do |index|
+      FactoryGirl.create :dual_action_guest, :status_check_at => 1.hour.ago, :insurance_check_at => 1.day.ago
+    end
+  end
+  
+  it "should return the correct number guests ready to run" do
+
+    logger.info "All schedules: #{DualActionGuest.all_schedules}"
+    
+    expect {
+      DualActionGuest.ready_to_run( :default )
+    }.to raise_error( RuntimeError )
+    
+    DualActionGuest.ready_to_run( :status_check ).should have(@count).items
+    DualActionGuest.ready_to_run( :insurance_check ).should have(@count).items
+  end
+  
+end

data/spec/lib/active_record/simple_model_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+load_schema
+
+class SimpleGuest < ActiveRecord::Base
+
+  include Urge::Scheduled
+
+  urge_schedule( :default, :scheduled_for => :scheduled_for, :action => :take_action )
+
+private
+
+  def take_action( options )
+    logger.debug "In take_action. About to return empty set"
+    nil
+  end
+
+end
+
+FactoryGirl.define do
+
+  factory :simple_guest do
+    sequence :joined_at do |n|
+      n.weeks.ago
+    end
+
+    first_name "Freddy"
+    sequence :last_name do |n|
+      "Starr#{n}"
+    end
+    
+    sequence :email do |n|
+      "fs#{n}@example.com"
+    end
+    
+  end
+
+end
+
+describe 'Simplest active record model' do
+  
+  before(:each) do
+    @guest = FactoryGirl.create :simple_guest, :scheduled_for => 1.day.ago
+  end
+  
+  it "can be created" do
+    @guest.should_not be_nil
+  end
+  
+  it "can be scheduled" do
+    @guest.scheduled_for.should_not be_nil
+  end
+  
+  it "should be ready to run" do
+    @guest.should be_ready_to_run( :default )
+  end
+  
+  it "should raise an exception if an attempt is made to access a schedule that doesn't exist" do
+    expect {
+      SimpleGuest.attr_name( :non_existent ).should be_nil
+    }.to raise_error
+  end
+  
+  context "when run" do
+    before(:each) do
+      @guest.run :default
+    end
+    
+    it "should not be rescheduled" do
+      @guest.scheduled_for.should be_nil
+    end
+  end
+  
+end
+
+describe "AR finders" do
+  
+  before(:each) do
+    
+    SimpleGuest.delete_all
+    
+    @count = 10
+    @count.times do |index|
+      FactoryGirl.create :simple_guest, :scheduled_for => 1.day.ago
+    end
+  end
+  
+  it "should return the correct number guests ready to run" do
+    SimpleGuest.ready_to_run( :default ).should have(@count).items
+  end
+  
+end
+

data/spec/lib/dual_action_spec.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+# 
+# 
+# 
+class TwoTask
+  
+  include Urge::Scheduled
+  
+  attr_accessor :scheduled_for_one, :scheduled_for_two
+  
+  attr_reader :logger
+  
+  def initialize( attrs, options )
+    @scheduled_for_one = attrs[:scheduled_for_one]
+    @scheduled_for_two = attrs[:scheduled_for_two]
+
+    @logger = options[:logger] || Logging.logger['scheduled_test']
+
+    @actions = options[:actions]
+  end
+
+  urge_schedule( :one, :scheduled_for => :scheduled_for_one, :action => :take_one )
+  urge_schedule( :two, :scheduled_for => :scheduled_for_two, :action => :take_two )
+  
+  def take_one( options )
+    @actions << :action_one
+    1.hour
+  end
+  
+  def take_two( options )
+    @actions << :action_two
+    2.hours
+  end
+  
+end
+
+describe Urge::Scheduled do
+  
+  context "when applied to an in memory object requiring two separate actions, that object" do
+    
+    before(:each) do
+      @actions = []
+      @attrs = {
+        :scheduled_for_one => 1.second.ago,
+        :scheduled_for_two => 2.seconds.ago
+      }
+      @object = TwoTask.new @attrs, :actions => @actions
+    end
+    
+    it "should exist with no actions" do
+      @object.should_not be_nil
+      @actions.should be_empty
+    end
+    
+    context "when run in the context of task 1" do
+      
+      before(:each) do
+        @object.run( :one )
+      end
+      
+      it "should produce one action" do
+        @actions.should have(1).item
+        @actions.first.should == :action_one
+      end
+      
+      it "should be rescheduled for one hour's time" do
+        @object.scheduled_for_one.to_i.should eq(( Time.now + 1.hour).to_i )
+      end
+      
+    end
+
+    context "when run in the context of task 2" do
+      
+      before(:each) do
+        @object.run( :two )
+      end
+      
+      it "should produce another action" do
+        @actions.should have(1).item
+        @actions.first.should == :action_two
+      end
+
+      it "should be rescheduled for two hours' time" do
+        @object.scheduled_for_two.to_i.should eq( (Time.now + 2.hours).to_i )
+      end
+      
+    end
+    
+    context "when run in the context of both tasks" do
+
+      before(:each) do
+        @object.run( :one )
+        @object.run( :two )
+      end
+
+      it "should produce two actions" do
+        @actions.should have(2).items
+        @actions.should include( :action_one)
+        @actions.should include( :action_two)
+      end
+
+    end
+    
+  end
+    
+end

data/spec/lib/scheduled_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+Logging.logger['simple'].tap {|logger| 
+  logger.add_appenders 'colourful_stdout'
+  logger.level = :info
+}
+
+
+# 
+# 
+# 
+class Simple
+  
+  include Urge::Scheduled
+  
+  attr_accessor :scheduled_for
+  attr_reader :actions, :logger
+  
+  def initialize( attrs = {} )
+    self.scheduled_for = attrs[:scheduled_for]
+
+    @logger = Logging.logger['simple']
+    @actions = []
+  end
+
+  urge_schedule( :something, :scheduled_for => :scheduled_for, :action => :do_something )
+  
+  def do_something( options )
+    @actions << :foo
+    nil
+  end
+  
+end
+
+describe Urge::Scheduled do
+  
+  context "when applied to a simple, in memory object" do
+    
+    before(:each) do
+      @object = Simple.new
+    end
+    
+    it "should exist with no actions" do
+      @object.should_not be_nil
+      @object.actions.should be_empty
+    end
+    
+    context "that is not scheduled" do
+      
+      context "when run in the correct context" do
+
+        before(:each) do
+          @object.run( :something )
+        end
+
+        it "should do nothing" do
+          @object.actions.should be_empty
+        end
+
+      end
+      
+    end
+    
+    context "that has been scheduled to run 1 second ago" do
+      
+      before(:each) do
+        @object.scheduled_for = 1.second.ago
+      end
+
+      context "when run in the correct context" do
+
+        before(:each) do
+          @object.run( :something )
+        end
+
+        it "should produce one action" do
+          @object.actions.should have(1).item
+          @object.actions.first.should == :foo
+        end
+
+        it "should not be rescheduled" do
+          @object.scheduled_for.should be_nil
+        end
+
+      end
+      
+      context "when run in a non existent context" do
+        
+        it "should raise an error" do
+          expect {
+            @object.run( :doesnt_exist )
+          }.to raise_error( RuntimeError )
+        end
+        
+      end
+      
+    end
+
+  end
+    
+end

data/spec/schema.rb

@@ -0,0 +1,39 @@
+ActiveRecord::Schema.define( :version => 0 ) do
+
+  create_table 'credit_control_tasks', :force => true do |t|
+    t.string 'name'
+    t.timestamp 'scheduled_for'
+    t.integer 'client_id'
+  end
+  
+  create_table 'clients', :force => true do |t|
+    t.string 'name'
+    t.string 'code'
+  end
+
+  create_table "simple_guests", :force => true do |t|
+    t.string   "first_name"
+    t.string   "last_name"
+    t.string   "email"
+    t.datetime "started_at"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+    t.string   "aasm_state"
+    t.datetime "joined_at"
+    t.datetime "scheduled_for"
+  end
+
+  create_table "dual_action_guests", :force => true do |t|
+    t.string   "first_name"
+    t.string   "last_name"
+    t.string   "email"
+    t.datetime "started_at"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+    t.string   "aasm_state"
+    t.datetime "joined_at"
+    t.datetime "status_check_at"
+    t.datetime "insurance_check_at"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+require 'urge'
+
+Logging.configure do
+  
+  Logging.logger.root.level = :debug
+  Logging.logger.root.appenders = [Logging.appenders.file( 'log/test.log' )]
+
+  # here we setup a color scheme called 'bright'
+  Logging.color_scheme( 'bright',
+    :levels => {
+      :info  => :green,
+      :warn  => :yellow,
+      :error => :red,
+      :fatal => [:white, :on_red]
+    },
+    :date => :blue,
+    :logger => :cyan,
+    :message => :magenta
+  )
+
+  Logging.appenders.stdout(
+    'colourful_stdout',
+    :layout => Logging.layouts.pattern(
+      :pattern => '[%d] %-5l %c: %m\n',
+      :color_scheme => 'bright'
+    )
+  )
+
+  test_loggers = %w{ scheduled_task_test credit_control_test scheduled_test scheduled }
+  # test_loggers = []
+    
+  test_loggers.each do |name|
+    Logging.logger[name].tap {|logger| 
+      logger.add_appenders 'colourful_stdout'
+      logger.level = :info
+    }
+  end
+  
+end
+
+require 'aasm'
+require 'logging'
+require 'urge/scheduled'
+require 'active_support/time'
+require 'active_record'
+require 'factory_girl'
+
+FactoryGirl.find_definitions
+
+class ScheduledTask
+
+  include Urge::Scheduled
+  
+  attr_reader :logger
+
+  def initialize( name, options = {} )
+    if options[:logger]
+      @logger = options[:logger]
+    else
+      @logger = Logging.logger['scheduled_task_test']
+    end
+    self.name = name
+  end
+
+end
+
+ActiveRecord::Base.logger = Logging.logger['credit_control_test']
+
+def load_schema
+  config = YAML::load( IO.read( File.dirname(__FILE__) + '/database.yml' ) )
+  ActiveRecord::Base.establish_connection config['sqlite3']
+  load( File.dirname(__FILE__) + "/schema.rb" )
+end
+
+class Client < ActiveRecord::Base
+end
+

data/urge.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'urge/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "urge"
+  gem.version       = Urge::VERSION
+  gem.authors       = ["Nick Adams"]
+  gem.email         = ["nadams@dsc.net"]
+  gem.description   = %q{Urges an object to take some form of action, on a timed basis}
+  gem.summary       = %q{Urges action}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  gem.add_dependency( 'activerecord' )
+  gem.add_dependency( 'aasm' )
+  gem.add_dependency( 'logging' )
+  
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'factory_girl'
+  
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: urge
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nick Adams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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'
+- !ruby/object:Gem::Dependency
+  name: aasm
+  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'
+- !ruby/object:Gem::Dependency
+  name: logging
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Urges an object to take some form of action, on a timed basis
+email:
+- nadams@dsc.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/urge.rb
+- lib/urge/persistence.rb
+- lib/urge/persistence/active_record_persistence.rb
+- lib/urge/persistence/base.rb
+- lib/urge/scheduled.rb
+- lib/urge/version.rb
+- spec/aasm.sqlite3.db
+- spec/database.yml
+- spec/factories/factory.rb
+- spec/lib/active_record/dual_action_model_spec.rb
+- spec/lib/active_record/simple_model_spec.rb
+- spec/lib/dual_action_spec.rb
+- spec/lib/scheduled_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- urge.gemspec
+homepage: ''
+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.0
+signing_key: 
+specification_version: 4
+summary: Urges action
+test_files:
+- spec/aasm.sqlite3.db
+- spec/database.yml
+- spec/factories/factory.rb
+- spec/lib/active_record/dual_action_model_spec.rb
+- spec/lib/active_record/simple_model_spec.rb
+- spec/lib/dual_action_spec.rb
+- spec/lib/scheduled_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb