runt 0.5.0 → 0.6.0

data/CHANGES

@@ -1,5 +1,23 @@
 = Runt Changelog
 
+== Version 0.6.0
+
+* Refactored and improved temporal expression tests, moving them to separate files per class
+
+* Fixed bug #5741: REYear incorrect handling of default args
+
+* Fixed bug #5749: Fixed spans midnight for REDay (Revision 156), changed semantics when dealing with lower precision arguments
+
+* Fixed bug #10640: incorrect tutorial section for tutorial_te.rdoc
+
+* Fixed bug #10605: DateRange.empty? should be true for min == max
+
+* Finished Schedule API tutorial
+
+* Fixed bug #16143: Typo in Schedule RDoc
+
+* Added README (and related files) in the generated rdoc
+
 == Version 0.5.0
 
 * Refactored Schedule implementation which greatly simplifies customization but does potentially break existing clients who relied on the ability to call add mulitple times (SEE BELOW)

data/Rakefile

@@ -19,7 +19,7 @@ require 'fileutils'
 #####################################################################
 
 # Build Settings
-PKG_VERSION = "0.5.0"
+PKG_VERSION = "0.6.0"
 
 # Files to be included in Runt distribution
 PKG_FILES = FileList[
@@ -27,6 +27,7 @@ PKG_FILES = FileList[
   '[A-Z]*',
   'lib/**/*.rb',
   'test/**/*.rb',
+  'examples/**/*.rb',
   'doc/**/*',
   'site/**/*'
 ].exclude("*.ses")
@@ -63,8 +64,8 @@ Rake::RDocTask.new do |rd|
 end
 
 Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.pattern = 'test/*test.rb'
+  t.libs << "test" << "examples"
+  t.pattern = '**/*test.rb'
   t.verbose = false	
 end
 
@@ -103,7 +104,9 @@ else
     s.email = 'mlipper@gmail.com'
     s.homepage = 'http://runt.rubyforge.org'
     s.has_rdoc = true
-    s.test_files = Dir['test/*test.rb']
+    s.rdoc_options += %w{--main README --title Runt}
+    s.extra_rdoc_files = FileList["README","CHANGES","TODO","LICENSE.txt","doc/*.rdoc"]    
+    s.test_files = Dir['**/*test.rb']
     s.rubyforge_project = 'runt'
     s.description = <<EOF
 Runt is a Ruby version of temporal patterns by

data/TODO

@@ -4,8 +4,10 @@ Send suggestions, questions, threats, etc. for this list to Matt[mailto:mlipper@
 
 === To Do
 
-* Tutorials
+* WIMonth#dates behaves unintuitively (see dates mixin tests)
 
-* Better examples
+* DayIntervalTE matches date multiples prior to start date (see tests)
+
+* Better docs, examples, tutorials
 
 * Laundry

data/doc/tutorial_schedule.rdoc

@@ -1,80 +1,389 @@
 = Schedule Tutorial
 
-If you haven't done so already, took a look the temporal expression 
-tutorial[http://runt.rubyforge.org/doc/files/doc/tutorial_te_rdoc.html].
+<em> This tutorial assumes you are familiar with use of the Runt API to
+create temporal expressions. If you're unfamiliar with how and why to write
+temporal expressions, take a look at the temporal expression 
+tutorial[http://runt.rubyforge.org/doc/files/doc/tutorial_te_rdoc.html].</em>
 
-So, you've defined some temporal expressions, now what? In his 
-paper[http://martinfowler.com/apsupp/recurring.pdf] about recurring events, 
-Martin Fowler also discusses a simple schedule API which is used, surprisingly
-enough, to build a schedule.
+In his paper[http://martinfowler.com/apsupp/recurring.pdf] about recurring 
+events, Martin Fowler also discusses a simple schedule API which is used, 
+surprisingly enough, to build a schedule. We're not going to cover the pattern 
+itself in this tutorial as Fowler already does a nice job. Because it is such 
+a simple pattern (once you invent it!), you'll be able understand it even if 
+you decide not to read his paper[http://martinfowler.com/apsupp/recurring.pdf].
 
-We're not going to cover the pattern itself in this tutorial as Fowler already 
-does a nice job. Luckily, because it is such a simple pattern (once you invent 
-it!), you'll be able understand it even if you decide not to skim the 
-aforementioned paper[http://martinfowler.com/apsupp/recurring.pdf].
+So, let's pretend that I own a car. Since I don't want to get a ticket, I 
+decide to create an application which will tell me where and when I can park 
+it on my street. (Since this is all make believe anyway, my car is a late 60's 
+model black Ford Mustang with flame detailing (and on the back seat is one 
+million dollars)). 
 
-In the last tutorial we learned about the exciting world of NYC street cleaning 
-regulations. For the uptown side of my block, the sign says:
-    
-    #############################
-    #                           #
-    #       NO PARKING          #
-    #                           #
-    #  Mon, Wed, Fri 8am-11am   #
-    #                           #
-    #   T,Th 11:30am-2:00pm     #
-    #                           #
-    #  Violators will be towed! #
-    #                           #
-    #############################
-                # #
-                # #
-                # #
- 
-We created a temporal expression to match this time period, like so: 
+We'll build a Runt Schedule that models the parking regulations. Our app 
+will check this Schedule at regular intervals and send us reminders to 
+move our car so we don't get a ticket. YAY!
+
+First, let's visit the exciting world of NYC street cleaning regulations.
+Let's pretend the following rules are in place for our block:
+
+* For the north side of the street, there is no parking Monday, Wednesday, or Friday, from 8am thru 11am
 
-    expr1=(DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)
+* For the south side of the street, there is no parking Tuesday or Thursday between 11:30am and 2pm
+
+Thus...
     
-    expr2=(DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)
+  #############################   #############################
+  #                           #   #                           #                             
+  #       NO PARKING          #   #       NO PARKING          #                            
+  #                           #   #                           #                            
+  #  Mon, Wed, Fri 8am-11am   #   #  Tu, Th 11:30am-2:00pm    #                            
+  #                           #   #                           #                            
+  #                           #   #                           #                             
+  #  Violators will be towed! #   #  Violaters will be towed! #                            
+  #                           #   #                           #                            
+  #############################   #############################                          
+              # #                              # #
+              # #                              # #
+              # #                              # #
+
+    North side of the street      South side of the street
+
+
+We'll start by creating temporal expressions which describe the verboten 
+parking times: 
+
+
+  north_expr = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)
     
-    ticket=expr1 | expr2
+  south_expr = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)    
 
-What we need at this point is a way to associate this expression with the rest 
-of our domain model. For this purpose, we can use a Schedule and an associated
-Event both of which are supplied by Runt.
+ 
+What we need at this point is a way to write queries against these expressions 
+to determine whether we need to send a reminder. For this purpose, we can use 
+a Schedule and an associated Event, both of which are supplied by Runt.
+
+  schedule = Schedule.new
 
 A Schedule holds zero or more Event/TemporalExpression pairs, allowing clients
 to easily query and update TemporalExpressions as well perform certain range
-operations as we will see in a moment.
+operations as we will see in a moment. We'll create two events, one for each 
+side of the street:
+
+  north_event = Event.new("north side")
+  
+  south_event = Event.new("south side")
+
+Now we add each event and its associated occurrence to our Schedule:
+
+  schedule.add(north_event, north_expr)
+
+  schedule.add(south_event, south_expr)
 
 An Event is simply a container for domain data. Although Runt uses Events 
 by default, Schedules will happily house any kind of Object. Internally, a 
 Schedule is really just a Hash where the keys are whatever it is you are 
 scheduling and the values are the TemporalExpressions you create.
 
+  class Schedule
+  ...
 
     def add(obj, expression)
       @elems[obj]=expression
     end
+  ...
+
+Now that we have a Schedule configured, we need something to check it and 
+then let us know if we need to move the car. For this, we'll create a simple
+class called Reminder which will function as the "main-able" part of 
+our app. 
+
+We'll start by creating an easily testable constructor which will be passed
+a Schedule instance (like the one we just created) and an SMTP server. 
+
+   
+  class Reminder
+    
+    attr_reader :schedule, :mail_server
+  
+    def initialize(schedule,mail_server)
+      @schedule = schedule
+      @mail_server = mail_server
+    end
+  ...
 
+Being devoted Agilists, we'll of course also create a unit test to 
+help flesh out the specifics of our new Reminder class. We'll create
+test fixtures using the Runt Objects described above.
 
-For the remainder of this tutorial I will refer to Events specifically, but 
-just remember that anything reasonably Hash-keyable will do.
 
+  class ReminderTest < Test::Unit::TestCase
+  
+    include Runt
+  
+    def setup
+      @schedule = Schedule.new
+      @north_event = Event.new("north side of the street will be ticketed")
+      north_expr = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)  
+      @schedule.add(@north_event, north_expr)
+      @south_event = Event.new("south side of the street will be ticketed")
+      south_expr = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)
+      @schedule.add(@south_event, south_expr)
+      @mail_server = MailServer.new
+      @reminder = Reminder.new(@schedule, @mail_server)
+      @saturday_at_10 = PDate.min(2007,11,24,10,0,0)
+      @monday_at_10 = PDate.min(2007,11,26,10,0,0)
+      @tuesday_at_noon = PDate.min(2007,11,27,12,0,0)
+    end
+
+    def test_initalize
+      assert_same @schedule, @reminder.schedule, "Expected #{@schedule} instead was #{@reminder.schedule}"
+      assert_same @mail_server, @reminder.mail_server, "Expected #{@mail_server} instead was #{@reminder.mail_server}"
+    end
+  ...
+
+For the purposes of this tutorial, the mail server will simply be a stub to 
+illustrate how a real one might be used.
+
+  class MailServer
+
+    Struct.new("Email",:to,:from,:subject,:text)
+
+    def send(to, from, subject, text)
+      Struct::Email.new(to, from, subject, text)
+      # etc... 
+    end
+
+  end
+
+Next, let's add a method to our Reminder class which actually checks our 
+schedule using a date which is passed in as a parameter.
+  
+  class Reminder
+  ...
+  def check(date)
+    return @schedule.events(date)
+  end
+  ...
+
+The Schedule#events method will return an Array of Event Objects for any 
+events which occur at the date and time given by the method's argument. Usage
+is easily demonstrated by a test case which makes use of the fixtures created
+by the TestCase#setup method defined above.
+
+  class ReminderTest < Test::Unit::TestCase
+    ...
+    def test_check
+      assert_equal 1, @reminder.check(@monday_at_10).size, "Unexpected size #{@reminder.check(@monday_at_10).size} returned"
+      assert_same @north_event, @reminder.check(@monday_at_10)[0], "Expected Event #{@north_event}. Got #{@reminder.check(@monday_at_10)[0]}."
+      assert_equal 1, @reminder.check(@tuesday_at_noon).size, "Unexpected size #{@reminder.check(@tuesday_at_noon).size} returned"
+      assert_same @south_event, @reminder.check(@tuesday_at_noon)[0], "Expected Event #{@south_event}. Got #{@reminder.check(@tuesday_at_noon)[0]}."
+      assert @reminder.check(@saturday_at_10).empty?, "Expected empty Array. Got #{@reminder.check(@saturday_at_10)}"
+    end
+    ...
 
-So, let's pretend that I own a car. Since I don't want to get a ticket, I 
-decide to create a little cron-like utility daemon to remind myself whenever
-it's time for me to move it.
 
-  class Ron
+There are other methods in the Schedule API which allow a client to query for
+information. Although we don't need them for this tutorial, I'll mention two 
+briefly because they are generally useful. The first is Schedule#dates
+which will return an Array of PDate Objects which occur during the DateRange
+supplied as a parameter. The second is Schedule#include? which returns a 
+boolean value indicating whether the Event occurs on the date which are both 
+supplied as arguments.
 
+Next, let's make use of the mail server argument given to the Reminder class
+in it's constructor. This is the method that will be called when a call to the
+Reminder#check method produces results.
+
+  class Reminder
+    ...
+    def send(date)
+      text = "Warning: " + events.join(', ')
+      return @mail_server.send(TO, FROM, SUBJECT, text)
+    end
+    ...
+
+
+Testing this is simple thanks to our MailServer stub which simply regurgitates
+the text argument it's passed as a result. 
+
+  class ReminderTest < Test::Unit::TestCase
+    ...
+    def test_send
+      params = [@north_event, @south_event]
+      result = @reminder.send(params)
+      assert_email result, Reminder::TEXT + params.join(', ')
+    end
+
+    def assert_email(result, text)
+      assert_equal Reminder::TO, result.to, "Unexpected value for 'to' field of Email Struct: #{result.to}"
+      assert_equal Reminder::FROM, result.from, "Unexpected value for 'from' field of Email Struct: #{result.from}"
+      assert_equal Reminder::SUBJECT, result.subject, "Unexpected value for 'subject' field of Email Struct: #{result.subject}"
+      assert_equal text, result.text, "Unexpected value for 'text' field of Email Struct: #{result.text}"
+    end
+    ...
+
+Note the ReminderTest#assert_email method we've added to make assertions 
+common to multiple test cases.
+
+
+Now, let's tie the whole thing together with a method which which checks for
+occuring Events and (upon finding some) sends a reminder. This method is 
+really the only one in the Reminder class that needs to be public.
+
+  class Reminder
+    ...
+    def run(date)
+      result = self.check(date)
+      self.send(result) if !result.empty?
+    end
+    ...
+
+  class ReminderTest < Test::Unit::TestCase
+    ...
+    def test_send
+      params = [@north_event, @south_event]
+      result = @reminder.send(params)
+      assert_email result, Reminder::TEXT + params.join(', ')
+    end
+    ...
+
+Finally, we'll cheat a bit and stitch every thing together so it can be run 
+from a command line.
 
-    def run
-      loop 
  
-    etc...
+  include Runt
+
+  schedule = Schedule.new
+  north_event = Event.new("north side")
+  north_expr = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)
+  schedule.add(north_event, north_expr)
+  south_event = Event.new("south side")
+  south_expr = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)      
+  schedule.add(south_event, south_expr)
+  reminder = Reminder.new(schedule, MailServer.new)
+  while true
+    sleep 15.minutes
+    reminder.run Time.now
+  end
+
+So, here's all the code for this tutorial (it's in the Runt distribution under 
+the examples folder):
+
+### schedule_tutorial.rb ###
+
+#!/usr/bin/ruby
+
+require 'runt'
+
+class Reminder
+  
+  TO = "me@myselfandi.com"
+  FROM = "reminder@daemon.net"
+  SUBJECT = "Move your car!"
+  TEXT = "Warning: "
+
+  attr_reader :schedule, :mail_server
+
+  def initialize(schedule,mail_server)
+    @schedule = schedule
+    @mail_server = mail_server
+  end
+  def run(date)
+    result = self.check(date)
+    self.send(result) if !result.empty?
+  end
+  def check(date)
+    puts "Checking the schedule..." if $DEBUG
+    return @schedule.events(date)
+  end
+  def send(events)
+    text = TEXT + events.join(', ')
+    return @mail_server.send(TO, FROM, SUBJECT, text)
+  end
+end
+
+class MailServer
+  Struct.new("Email",:to,:from,:subject,:text)
+  def send(to, from, subject, text)
+    puts "Sending message TO: #{to} FROM: #{from} RE: #{subject}..." if $DEBUG
+    Struct::Email.new(to, from, subject, text)
+   # etc... 
+  end
+end
+
+
+if __FILE__ == $0
+
+  include Runt
+
+  schedule = Schedule.new
+  north_event = Event.new("north side")
+  north_expr = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)
+  schedule.add(north_event, north_expr)
+  south_event = Event.new("south side")
+  south_expr = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)      
+  schedule.add(south_event, south_expr)
+  reminder = Reminder.new(schedule, MailServer.new)
+  while true
+    sleep 15.minutes
+    reminder.run Time.now
+  end
+
+end
+
+
+### schedule_tutorialtest.rb ###
+
+#!/usr/bin/ruby
+
+require 'test/unit'
+require 'runt'
+require 'schedule_tutorial'
+
+class ReminderTest < Test::Unit::TestCase
+
+  include Runt
 
-=.....FINISH ME!......
+  def setup
+    @schedule = Schedule.new
+    @north_event = Event.new("north side of the street will be ticketed")
+    north_expr = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)  
+    @schedule.add(@north_event, north_expr)
+    @south_event = Event.new("south side of the street will be ticketed")
+    south_expr = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)
+    @schedule.add(@south_event, south_expr)
+    @mail_server = MailServer.new
+    @reminder = Reminder.new(@schedule, @mail_server)
+    @saturday_at_10 = PDate.min(2007,11,24,10,0,0)
+    @monday_at_10 = PDate.min(2007,11,26,10,0,0)
+    @tuesday_at_noon = PDate.min(2007,11,27,12,0,0)
+  end
+  def test_initalize
+    assert_same @schedule, @reminder.schedule, "Expected #{@schedule} instead was #{@reminder.schedule}"
+    assert_same @mail_server, @reminder.mail_server, "Expected #{@mail_server} instead was #{@reminder.mail_server}"
+  end
+  def test_send
+    params = [@north_event, @south_event]
+    result = @reminder.send(params)
+    assert_email result, Reminder::TEXT + params.join(', ')
+  end
+  def test_check
+    assert_equal 1, @reminder.check(@monday_at_10).size, "Unexpected size #{@reminder.check(@monday_at_10).size} returned"
+    assert_same @north_event, @reminder.check(@monday_at_10)[0], "Expected Event #{@north_event}. Got #{@reminder.check(@monday_at_10)[0]}."
+    assert_equal 1, @reminder.check(@tuesday_at_noon).size, "Unexpected size #{@reminder.check(@tuesday_at_noon).size} returned"
+    assert_same @south_event, @reminder.check(@tuesday_at_noon)[0], "Expected Event #{@south_event}. Got #{@reminder.check(@tuesday_at_noon)[0]}."
+    assert @reminder.check(@saturday_at_10).empty?, "Expected empty Array. Got #{@reminder.check(@saturday_at_10)}"
+  end
+  def test_run
+    result = @reminder.run(@monday_at_10)
+    assert_email result, Reminder::TEXT + @north_event.to_s
+  end
+  def assert_email(result, text)
+    assert_equal Reminder::TO, result.to, "Unexpected value for 'to' field of Email Struct: #{result.to}"
+    assert_equal Reminder::FROM, result.from, "Unexpected value for 'from' field of Email Struct: #{result.from}"
+    assert_equal Reminder::SUBJECT, result.subject, "Unexpected value for 'subject' field of Email Struct: #{result.subject}"
+    assert_equal text, result.text, "Unexpected value for 'text' field of Email Struct: #{result.text}"
+  end
+end
 
 
 <em>See Also:</em>

data/doc/tutorial_te.rdoc

@@ -42,8 +42,8 @@ Alrighty, then...less talkin', more tutorin'!
   10  expr.include?(Date.new(2002,8,29)) #Thurs 8/29/02 => true
   11  expr.include?(Date.new(2003,8,28)) #Thurs 8/28/03 => true
   12  expr.include?(Date.new(2004,8,26)) #Thurs 8/26/04 => true
-  13  expr.include?(Date.new(2004,3,18)) #Thurs 3/18/04 => true
-  14
+  13  
+  14  expr.include?(Date.new(2004,3,18)) #Thurs 3/18/04 => false
   15  expr.include?(Date.new(2004,8,27)) #Fri 8/27/04 => false
 
 A couple things are worth noting before we move on to more complicated
@@ -86,7 +86,7 @@ will all match dates and ranges occurring within 'the last Thursday'
 <b>OR</b> 'the month of August'.
 
 
-Now what? Beginning on line 11, you can see that calling the
+Now what? Beginning on line 10, you can see that calling the
 <tt>#include?</tt> method will let you know whether the expression you've
 defined includes a given date (or, in some cases, a range, or another
 TE). This is much like the way you use the standard <tt>Range#include?</tt>.

data/examples/reminder.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby
+
+# NOTE this is slightly broken; it is in the process of being fixed
+base = File.basename(Dir.pwd)
+if base == "examples" || base =~ /runt/
+  Dir.chdir("..") if base == "examples"
+  $LOAD_PATH.unshift(Dir.pwd + '/lib')
+  Dir.chdir("examples") if base =~ /runt/
+end
+
+
+
+
+require 'runt'
+
+class Reminder
+  include Runt
+
+  def initialize(schedule)
+    @schedule=schedule
+  end
+
+  def next_times(event,end_point,now=Time.now)
+    @schedule.dates(event,DateRange.new(now,end_point))
+  end
+end 
+
+# start of range whose occurrences we want to list
+# TODO fix Runt so this can be done with Time instead 
+#      e.g., now=Time.now
+#now=Time.parse("13:00")
+#now.date_precision=Runt::DPrecision::MIN
+now=Runt::PDate.min(2006,12,8,13,00)
+
+# end of range
+soon=(now + 10.minutes)
+
+# Sanity check
+print "start: #{now.to_s} (#{now.date_precision}) end: #{soon.to_s} (#{soon.date_precision})\n"
+
+#
+# Schedule used to house TemporalExpression describing the recurrence from 
+# which we'd list to generate a list of dates. In this example, some Event
+# occuring every 5 minutes.
+# 
+schedule=Runt::Schedule.new
+
+# Some event whose schedule we're interested in
+event=Runt::Event.new("whatever")
+
+# Add the event to the schedule (
+# NOTE: any Object that is a sensible Hash key can be used
+schedule.add(event,Runt::EveryTE.new(now,5.minutes))
+
+# Example domain Object using Runt 
+reminder=Reminder.new(schedule)
+
+# Call our domain Object with the start and end times and the event
+# in which we're interested
+#puts "times (inclusive) = #{reminder.next_times(event,soon,now).join('\n')}"
+
+puts "times (inclusive):"
+reminder.next_times(event,soon,now).each{|t| puts t}

data/examples/schedule_tutorial.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/ruby
+
+require 'runt'
+
+class Reminder
+  
+  TO = "me@myselfandi.com"
+  FROM = "reminder@daemon.net"
+  SUBJECT = "Move your car!"
+  TEXT = "Warning: "
+
+  attr_reader :schedule, :mail_server
+
+  def initialize(schedule,mail_server)
+    @schedule = schedule
+    @mail_server = mail_server
+  end
+  def run(date)
+    result = self.check(date)
+    self.send(result) if !result.empty?
+  end
+  def check(date)
+    puts "Checking the schedule..." if $DEBUG
+    return @schedule.events(date)
+  end
+  def send(events)
+    text = TEXT + events.join(', ')
+    return @mail_server.send(TO, FROM, SUBJECT, text)
+  end
+end
+
+class MailServer
+  Struct.new("Email",:to,:from,:subject,:text)
+  def send(to, from, subject, text)
+    puts "Sending message TO: #{to} FROM: #{from} RE: #{subject}..." if $DEBUG
+    Struct::Email.new(to, from, subject, text)
+   # etc... 
+  end
+end
+
+
+if __FILE__ == $0
+
+  include Runt
+
+  schedule = Schedule.new
+  north_event = Event.new("north side")
+  north_expr = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)
+  schedule.add(north_event, north_expr)
+  south_event = Event.new("south side")
+  south_expr = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)      
+  schedule.add(south_event, south_expr)
+  reminder = Reminder.new(schedule, MailServer.new)
+  while true
+    sleep 15.minutes
+    reminder.run Time.now
+  end
+
+end