runt 0.7.0 → 0.9.0

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0

data/{CHANGES → CHANGES.txt}

@@ -1,5 +1,21 @@
 = Runt Changelog
 
+== Version 0.9.0
+
+* Replaced RDoc-based tutorials with Markdown files
+
+* Removed old-school setup.rb
+
+* Switched to MIT license
+
+* Switched to Bundler for gemification
+
+* Fixed compatiblity with Ruby 1.9 and Ruby 2.0
+
+* Merged several commits from Paydici GitHub repo which included various enhancements and fixes by multiple contributors
+
+* Moved to GitHub (finally)
+
 == Version 0.7.0
 
 * Addded tutorial_sugar.rdoc for new builder and shortcut stuff
@@ -9,7 +25,7 @@
 * Fixed bug #20723: using modified patch contributed by Justin Cunningham. This partially reverted changes made by bug fix #5749, REDay by default now returns true for less precise arguments but accepts an optional constructor parameter which will override this behavior
 
 * Removed deprecated "autorequire" property configuration from Rakefile
- 
+
 * Added properly spelled constant Runt::Eighth to the Runt module
 
 * Added month constants defined in Date class to runt.rb for use by shortcuts
@@ -22,7 +38,7 @@
 
 * Changed runttest.rb to use local Time so test doesn't fail when run from another time zone
 
-* Fixed usage of deprecated methods in Date when accessing them from PDate subclass 
+* Fixed usage of deprecated methods in Date when accessing them from PDate subclass
 
 * Applied patches providing week precision and expanded RFC2445 compliance tests contributed by Larry Karnowski
 
@@ -52,9 +68,9 @@
 
 * Added update method to Schedule allowing clients to update existing expressions
 
-* Added select method to Schedule allowing clients to query Events using arbitrary criteria   
+* Added select method to Schedule allowing clients to query Events using arbitrary criteria
 
-* Added events method to Schedule which returns an Array of the currrently held Events   
+* Added events method to Schedule which returns an Array of the currrently held Events
 
 * Added time-related shortcuts to Runt module contributed by Ara T. Howard
 
@@ -62,7 +78,7 @@
 
 * Implemented meaningful to_s methods for TExpr classes
 
-* Added include? method to Standard Library Date class allowing Spec class better interaction with other expressions
+* Added include? method to Standard Library Date class allowing TemporalDate class better interaction with other expressions
 
 * Applied patch to fix PDate serialization bug contributed by Jodi Showers
 
@@ -84,12 +100,12 @@
 
 == Version 0.3.0
 
-* TExpr (finally!) becomes a Module instead of a superclass 
+* TExpr (finally!) becomes a Module instead of a superclass
 
 * Added overlap? method for all temporal expressions and DateRange
 
 * Added REMonth expression which matches a range of dates each month
- 
+
 * Contributed by Emmett Shear: TExpr#dates method which returns an array of dates occurring within the supplied DateRange
 
 * Rakefile fixes:
@@ -114,7 +130,7 @@
 * Renamed file dateprecisiontest.rb to dprecisiontest.rb
 * Renamed several methods on PDate:
   - second -> sec
-  - minute -> min  
+  - minute -> min
   - hour_of_day -> hour
   - day_of_month -> day
 

data/Gemfile

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

data/LICENSE.txt

@@ -1,44 +1,22 @@
-The Apache Software License, Version 1.1
-
- Copyright (c) 2003-2004 Digital Clash LLC.  All rights
- reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
-
- 1. Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in
-    the documentation and/or other materials provided with the
-    distribution.
-
- 3. The end-user documentation included with the redistribution,
-    if any, must include the following acknowledgment:
-    "This product includes software developed by the
-    Runt team (http://runt.rubyforge.org/)."
-    Alternately, this acknowledgment may appear in the software itself,
-    if and wherever such third-party acknowledgments normally appear.
-
- 4. The names "Runt" and "Digital Clash" not be used to endorse or
-     promote products derived from this software without prior written
-     permission. For written permission, please contact
-     info@digitalclash.com.
-
- 5. Products derived from this software may not be called "Runt",
-    "Digital Clash", nor may "Runt" or "Digital Clash" appear in
-    their name, without prior written permission of Digital Clash LLC.
-
- THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
- WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED.  IN NO EVENT SHALL DIGITAL CLASH LLC OR ITS CONTRIBUTORS
- BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- THE POSSIBILITY OF SUCH DAMAGE.
+Copyright (c) 2013 Matthew Lipper
+
+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,79 @@
+# RUNT -- Ruby Temporal Expressions
+
+* Runt is a [Ruby](http://www.ruby-lang.org/en/) implementation of select temporal patterns by Martin Fowler described in this [paper](http://martinfowler.com/apsupp/recurring.pdf).
+
+* Temporal expressions allow a developer to define patterns of date recurrence using set expressions.
+
+## INSTALL
+
+*   gem install runt
+
+
+## QUICK START
+
+```ruby
+require 'date'
+require 'runt'
+
+include Runt
+
+a_monday = Date.new(2013,5,13)                  # Monday, May 13 - has "day-level" precision
+a_wednesday = DateTime.new(2013,5,15,8,45)      # Wednesday, May 15 at 8:45am - has "minute-level" precision
+
+monday_expr = DIWeek.new(Mon)                   # Matches any Monday
+monday_expr.include?(a_monday)                  # => true 
+monday_expr.include?(a_wednesday)               # => false 
+
+wednesday_expr = DIWeek.new(Wed)                # Matches any Wednesday
+wednesday_expr.include?(a_monday)               # => false 
+wednesday_expr.include?(a_wednesday)            # => true 
+
+#
+# Use an "OR" between two expressions
+#
+mon_or_wed_expr = monday_expr | wednesday_expr  # Matches any Monday OR any Wednesday
+mon_or_wed_expr.include?(a_monday)              # => true
+mon_or_wed_expr.include?(a_wednesday)           # => true
+
+daily_8_to_11_expr =REDay.new(8,00,11,00,false) # Matches from 8am to 11am on ANY date. 
+                                                # The 'false' argument says not to auto-match expressions of lesser precision.
+at_9 = DateTime.new(2013,5,12,9,0)              # Sunday, May 12 at 9:00am
+daily_8_to_11_expr.include?(at_9)               # => true 
+#
+# On the next line, the given Date instance is "promoted" to the minute-level precision 
+# required by the temporal expression so the time component defaults to 00:00
+#
+daily_8_to_11_expr.include?(a_monday)           # => false 
+
+#
+# Use an "AND" between two expressions to match
+#
+#   (Monday OR Wednesday) AND (8am to 11am)
+#
+mon_or_wed_8_to_11_expr = mon_or_wed_expr & daily_8_to_11_expr
+
+mon_or_wed_8_to_11_expr.include?(a_monday)      # => false - 00:00 is not between 8:00 and 11:00
+mon_or_wed_8_to_11_expr.include?(at_9)          # => false - on Sunday
+mon_or_wed_8_to_11_expr.include?(a_wednesday)   # => true - a Wednesday at 8:45
+
+```
+
+## Tutorials
+
+* Basic temporal expression [tutorial](doc/tutorial_te.md)
+* Schedule [tutorial](doc/tutorial_schedule.md)
+* Runt syntatic sugar [tutorial](doc/tutorial_sugar.md)
+
+## Etc...
+
+**Author:** Matthew Lipper <mlipper@gmail.com>  
+
+**Requires:** Tested with J/Ruby 1.8.7, 1.9.3 and Ruby 2.0.x 
+
+**License:** Released under the MIT License (see LICENSE.txt).
+
+## Warranty
+
+This software is provided "as is" and without any express or implied warranties, including, without limitation, the implied warranties of merchantibility and fitness for a particular purpose.
+
+![DCL Logo](site/dcl-small.gif)

data/Rakefile

@@ -1,122 +1,9 @@
-# Rakefile for runt        -*- ruby -*-
+require "bundler/gem_tasks"
+require "rake/testtask"
 
-begin
-  require 'rubygems'
-  require 'rake/gempackagetask'
-rescue Exception
-  nil
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/*test.rb"
 end
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/contrib/sshpublisher'
-require 'rake/contrib/rubyforgepublisher'
-require 'fileutils'
 
-#####################################################################
-# Constants
-#####################################################################
-
-# Build Settings
-PKG_VERSION = "0.7.0"
-
-# Files to be included in Runt distribution
-PKG_FILES = FileList[
-  'setup.rb',
-  '[A-Z]*',
-  'lib/**/*.rb',
-  'test/**/*.rb',
-  'examples/**/*.rb',
-  'doc/**/*',
-  'site/**/*'
-].exclude("*.ses")
-
-if(RUBY_PLATFORM =~ /win32/i)
-  PKG_EXEC_TAR = false
-else
-  PKG_EXEC_TAR = true 
-end
-  
-# build directory
-TARGET_DIR = "target"
-
-#####################################################################
-# Targets
-#####################################################################
-
-task :default => [:test]
-task :clobber => [:clobber_build_dir]
-
-# Make the build directory
-directory TARGET_DIR
-
-# Calling this task directly doesn't work?
-desc "Clobber the entire build directory."
-task :clobber_build_dir do |t|
-    CLOBBER.include(TARGET_DIR)
-end
-
-Rake::RDocTask.new do |rd|
-  rd.rdoc_dir="#{TARGET_DIR}/doc"
-  rd.options << "-S"
-  rd.rdoc_files.include('lib/*','doc/*.rdoc','README','CHANGES','TODO','LICENSE.txt')
-end
-
-Rake::TestTask.new do |t|
-  t.libs << "test" << "examples"
-  t.pattern = '**/*test.rb'
-  t.verbose = false	
-  t.warning = false
-end
-
-desc "Copy html files for the Runt website to the build directory."
-file "copy_site" => TARGET_DIR
-file "copy_site" do
-    cp_r Dir["site/*.{html,gif,png,css}"], TARGET_DIR
-end
-
-desc "Publish the Documentation to RubyForge."
-task :publish => [:rdoc,:copy_site,:clobber_package] do |t|
-  publisher = Rake::CompositePublisher.new
-        publisher.add Rake::SshDirPublisher.new("mlipper@rubyforge.org", "/var/www/gforge-projects/runt",TARGET_DIR)
-  publisher.upload
-end
-
-desc "Publish the Documentation to the build dir."
-task :test_publish => [:rdoc,:copy_site,:clobber_package] do |t|
-  puts "YAY! We've tested publish! YAY!"
-end
-
-
-if ! defined?(Gem)
-  puts "Package Target requires RubyGEMs"
-else
-  spec = Gem::Specification.new do |s|
-    s.platform = Gem::Platform::RUBY
-    s.summary = "Ruby Temporal Expressions."
-    s.name = 'runt'
-    s.version = PKG_VERSION
-    s.requirements << 'none'
-    s.require_path = 'lib'
-    s.files = PKG_FILES.to_a
-    s.author = 'Matthew Lipper'
-    s.email = 'mlipper@gmail.com'
-    s.homepage = 'http://runt.rubyforge.org'
-    s.has_rdoc = true
-    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
-Martin Fowler. Runt provides an API for scheduling
- recurring events using set-like semantics. 
-EOF
-  end
-  
-  Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_zip = true
-    pkg.need_tar = PKG_EXEC_TAR
-  end
-end
+task :default => :test

data/doc/tutorial_schedule.md

@@ -0,0 +1,365 @@
+# Schedule Tutorial
+
+* 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](tutorial_te.md).
+
+* 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.
+
+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)). 
+
+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
+
+* For the south side of the street, there is no parking Tuesday or Thursday between 11:30am and 2pm
+
+Thus...
+
+<pre>
+    #############################   #############################
+    #                           #   #                           #                             
+    #       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
+</pre>
+
+We'll start by creating temporal expressions which describe the verboten parking times: 
+
+```ruby
+north_expr = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)  
+
+south_expr = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)  
+```
+
+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.
+
+```ruby
+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. We'll create two events, one for each side of the street:
+
+```ruby
+north_event = Event.new("north side")
+
+south_event = Event.new("south side")
+```
+
+Now we add each event and its associated occurrence to our Schedule:
+
+```ruby
+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.
+
+```ruby
+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. 
+
+```ruby
+class Reminder
+
+  attr_reader :schedule, :mail_server
+
+  def initialize(schedule,mail_server)
+    @schedule = schedule
+    @mail_server = mail_server
+  end
+...
+```
+
+Being rabid foaming-at-the-mouth 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.
+
+```ruby
+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.
+
+```ruby
+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.
+
+```ruby
+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.
+
+```ruby
+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
+  ...
+```
+
+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.
+
+```ruby
+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. 
+
+```ruby
+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.
+
+```ruby
+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.
+
+```ruby
+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):
+
+```ruby
+### 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
+
+    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
+```
+
+*See Also:*
+
+* Temporal Expressions [tutorial](tutorial_te.md)
+* Runt syntax sugar [tutorial](tutorial_sugar.md)
+* Fowler's recurring event [pattern](http://martinfowler.com/apsupp/recurring.pdf)
+* Other temporal [patterns](http://martinfowler.com/eaaDev/timeNarrative.html)
+