runt 0.5.0 → 0.6.0

data/examples/schedule_tutorialtest.rb

@@ -0,0 +1,52 @@
+#!/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
+

data/lib/runt/daterange.rb

@@ -37,7 +37,7 @@ module Runt
     end
 
     def empty?
-      return @start_expr>@end_expr
+      return @start_expr >= @end_expr
     end
 
     def gap(obj)

data/lib/runt/pdate.rb

@@ -80,7 +80,7 @@ module Runt
     else
       result = super(other)
     end
-    puts "#{self.to_s}<=>#{other.to_s} => #{result}" if $DEBUG
+    #puts "#{self.to_s}<=>#{other.to_s} => #{result}" if $DEBUG
     result
   end
 

data/lib/runt/schedule.rb

@@ -39,7 +39,7 @@ module Runt
     end
 
     #
-    # Returns all Events whose Tempoarl Expression includes the given date/expression
+    # Returns all Events whose Temporal Expression includes the given date/expression
     #
     def events(date)
       self.select{|ev,xpr| xpr.include?(date);}

data/lib/runt/temporalexpression.rb

@@ -86,7 +86,6 @@ class Collection
   include TExpr
   
   attr_reader :expressions
-  #protected :expressions
 
   def initialize
     @expressions = Array.new
@@ -172,6 +171,8 @@ class Diff
 
   include TExpr
 
+  attr_reader :expr1, :expr2
+
   def initialize(expr1, expr2)
     @expr1 = expr1
     @expr2 = expr2
@@ -191,6 +192,8 @@ end
 class Spec
   
   include TExpr
+
+  attr_reader :date_expr
   
   def initialize(date_expr)
     @date_expr = date_expr
@@ -214,16 +217,10 @@ end
 # facilitating inclusion of an arbitrary range in a temporal expression.
 #
 #  See also: Range
-class RSpec 
-
-  include TExpr
-
-  def initialize(date_expr)
-    @date_expr = date_expr
-  end
+class RSpec < Spec 
 
-  # Will return true if the supplied object is included in the range used to
-  # create this instance
+  ## Will return true if the supplied object is included in the range used to
+  ## create this instance
   def include?(date_expr)
     return @date_expr.include?(date_expr)
   end
@@ -237,9 +234,6 @@ class RSpec
     false    
   end
 
-  def to_s
-    @date_expr.to_s
-  end
 end
 
 #######################################################################
@@ -421,21 +415,102 @@ class REWeek
   end
 end
 
+#
+# TExpr that matches date ranges within a single year. Assumes that the start 
+# and end parameters occur within the same year. 
+#
+#
 class REYear 
 
+  # Sentinel value used to denote that no specific day was given to create
+  # the expression.
+  NO_DAY = 0
+
   include TExpr
+
+  attr_accessor :start_month, :start_day, :end_month, :end_day
   
-  def initialize(start_month, start_day=0, end_month=start_month, end_day=0)
+  #
+  # == Synopsis
+  # 
+  #   REYear.new(start_month [, (start_day | end_month), ...]
+  #
+  # == Args
+  # 
+  # One or two arguments given::
+  #
+  # +start_month+::
+  #   Start month. Valid values are 1..12. When no other parameters are given 
+  #   this value will be used for the end month as well. Matches the entire
+  #   month through the ending month.
+  # +end_month+::
+  #   End month. Valid values are 1..12. When given in two argument form
+  #   will match through the entire month.   
+  # 
+  # Three or four arguments given::
+  #
+  # +start_month+::
+  #   Start month. Valid values are 1..12.
+  # +start_day+::
+  #   Start day. Valid values are 1..31, depending on the month.
+  # +end_month+::
+  #   End month. Valid values are 1..12. If a fourth argument is not given,
+  #   this value will cover through the entire month.
+  # +end_day+::
+  #   End day. Valid values are 1..31, depending on the month.
+  # 
+  # == Description
+  #
+  # Create a new REYear expression expressing a range of months or days 
+  # within months within a year.
+  #
+  # == Usage
+  #
+  #   # Creates the range March 12th through May 23rd
+  #   expr = REYear.new(3,12,5,23)
+  #
+  #   # Creates the range March 1st through May 31st
+  #   expr = REYear.new(3,5)
+  #
+  #   # Creates the range March 12th through May 31st
+  #   expr = REYear.new(3,12,5)
+  #
+  #   # Creates the range March 1st through March 30th
+  #   expr = REYear.new(3)
+  #
+  def initialize(start_month, *args)
     @start_month = start_month
-    @start_day = start_day
-    @end_month = end_month
-    @end_day = end_day
+    if (args.nil? || args.size == NO_DAY) then
+      # One argument given
+      @end_month = start_month
+      @start_day = NO_DAY
+      @end_day = NO_DAY
+    else
+      case args.size
+      when 1
+	@end_month = args[0]
+	@start_day = NO_DAY
+	@end_day = NO_DAY
+      when 2
+	@start_day = args[0]
+	@end_month = args[1]
+	@end_day = NO_DAY
+      when 3
+	@start_day = args[0]
+	@end_month = args[1]
+	@end_day = args[2]
+      else
+	raise "Invalid number of var args: 1 or 3 expected, #{args.size} given"
+      end
+    end
+    @same_month_dates_provided = (@start_month == @end_month) && (@start_day!=NO_DAY && @end_day != NO_DAY)
   end
 
   def include?(date)
-    months_include?(date) ||
-      start_month_include?(date) ||
-        end_month_include?(date)
+    return ((@start_day <= date.day) && (@end_day >= date.day)) if @same_month_dates_provided
+    is_between_months?(date) ||
+      (same_start_month_include_day?(date) ||
+        same_end_month_include_day?(date))
   end
 
   def save
@@ -448,19 +523,20 @@ class REYear
   end
 
   private
-  def months_include?(date)
+  def is_between_months?(date)
     (date.mon > @start_month) && (date.mon < @end_month)
   end
 
-  def end_month_include?(date)
+  def same_end_month_include_day?(date)
     return false unless (date.mon == @end_month)
-    (@end_day == 0)  || (date.day <= @end_day)
+    (@end_day == NO_DAY)  || (date.day <= @end_day)
   end
 
-  def start_month_include?(date)
+  def same_start_month_include_day?(date)
     return false unless (date.mon == @start_month)
-    (@start_day == 0) || (date.day >= @start_day)
+    (@start_day == NO_DAY) || (date.day >= @start_day)
   end
+
 end
 
 # TExpr that matches periods of the day with minute
@@ -491,8 +567,11 @@ class REDay
   end
 
   def include?(date)
+    # 2007-11-9: Not completely sure of the implications of commenting this 
+    # out but...
+    # 
     # If precision is day or greater, then the result is always true
-    return true if date.date_precision <= DPrecision::DAY
+    #return true if date.date_precision <= DPrecision::DAY
     
     if(@spans_midnight&&date.hour<12) then
       #Assume next day
@@ -509,7 +588,9 @@ class REDay
 
   private
   def spans_midnight?(start_hour, end_hour)
-    return end_hour <= start_hour
+    #puts "spans midnight? #{end_hour < start_hour} (end==#{end_hour} <= start==#{start_hour})"
+    #return end_hour <= start_hour
+    return end_hour < start_hour
   end
 
   def get_current(hour,minute)
@@ -527,6 +608,7 @@ end
 #     WIMonth.new(1)
 #
 #  See also: Date
+#  FIXME .dates mixin seems functionally broken
 class WIMonth 
 
   include TExpr

data/test/baseexpressiontest.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'runt'
+require 'date'
+require 'time'
+
+$DEBUG=false
+
+# Base test case for refactored temporal expression unit tests
+# Author:: Matthew Lipper
+
+class BaseExpressionTest < Test::Unit::TestCase
+
+  include Runt
+  include DPrecision
+
+  def setup
+    @stub1 = StubExpression.new(false, "stub 1", false)
+    @stub2 = StubExpression.new(false, "stub 2", false)
+    @pdate_198606 = PDate.month(1986,6)                 # June, 1986
+    @pdate_20040531 = PDate.day(2004,5,31)              # Monday, May 31st, 2004
+    @pdate_20040704 = PDate.day(2004,7,4)               # Sunday, July 4th, 2004
+    @pdate_20060914 = PDate.day(2006,9,14)              # Thursday, September 14th, 2006
+    @pdate_20060921 = PDate.day(2006,9,21)              # Thursday, September 21st, 2006
+    @pdate_20071008 = PDate.day(2007,10,8)              # Monday, October 8th, 2007
+    @pdate_20071024 = PDate.day(2007,10,24)             # Wednesday, October 24th, 2007
+    @pdate_20071028 = PDate.day(2007,10,28)             # Sunday, October 28th, 2007
+    @pdate_20071030 = PDate.day(2007,10,30)             # Tuesday, October 30th, 2007
+    @pdate_20071114 = PDate.day(2007,11,14)             # Wednesday, November 14th, 2007
+    @pdate_1922041816 = PDate.hour(1922,4,18,16)        # 4pm, Tuesday, April 18th, 1922
+    @pdate_1975060512 = PDate.hour(1975,6,5,12)         # 12pm, Thursday, June 5th, 1975
+    @pdate_2004090600 = PDate.hour(2004,9,6,0)          # 12am, Monday, September 6th, 2004
+    @pdate_2012050803 = PDate.hour(2012,5,8,3)          # 3am, Tuesday, May 8th, 2012
+    @pdate_2012050815 = PDate.hour(2012,5,8,15)         # 3pm, Tuesday, May 8th, 2012
+    @pdate_200401282100 = PDate.min(2004,1,28,21,0)     # 9:00pm, Wednesday, January 28th, 2004
+    @pdate_200401280000 = PDate.min(2004,1,28,0,0)      # 12:00am, Wednesday, January 28th, 2004 
+    @pdate_200401280001 = PDate.min(2004,1,28,0,1)      # 12:01am, Wednesday, January 28th, 2004
+    @pdate_200405010806 = PDate.min(2004,5,1,8,6)       # 8:06am, Saturday, May 1st, 2004
+    @pdate_200405030906 = PDate.min(2004,5,3,9,6)       # 9:06am, Monday, May 3rd, 2004
+    @pdate_200405040806 = PDate.min(2004,5,4,8,6)       # 8:06am, Tuesday, May 4th, 2004
+    @pdate_200605291012 = PDate.min(2006,5,29,10,12)
+    @pdate_200605301400 = PDate.min(2006,5,30,14,00)
+    @pdate_200609211001 = PDate.min(2006,9,21,10,1)
+    @pdate_200609211002 = PDate.min(2006,9,21,10,2)
+    @pdate_20071116100030 = PDate.sec(2007,11,16,10,0,30)
+    @date_19611101 = Date.civil(1961,11,1)
+    @date_20040109 = Date.civil(2004,1,9)   # Friday, January 9th 2004
+    @date_20040116 = Date.civil(2004,1,16)  # Friday, January 16th 2004
+    @date_20040125 = Date.civil(2004,1,25)  # Sunday, January 25th 2004
+    @date_20040501 = Date.civil(2004,5,1)
+    @date_20040806 = Date.civil(2004,8,6)
+    @date_20050101 = Date.civil(2005,1,1)
+    @date_20050102 = Date.civil(2005,1,2)
+    @date_20050109 = Date.civil(2005,1,9)
+    @date_20050116 = Date.civil(2005,1,16)
+    @date_20050123 = Date.civil(2005,1,23)
+    @date_20050130 = Date.civil(2005,1,30)
+    @date_20050131 = Date.civil(2005,1,31)
+    @date_20050228 = Date.civil(2005,2,28)
+    @date_20051231 = Date.civil(2005,12,31)
+    @date_20060504 = Date.civil(2006,5,4)
+    @datetime_200403081200 = DateTime.new(2004,3,8,12,0)   # 12:00pm, Monday, March 8th, 2004
+    @datetime_200403100800 = DateTime.new(2004,3,10,8,00)
+    @datetime_200403100915 = DateTime.new(2004,3,10,9,15)
+    @datetime_200403101915 = DateTime.new(2004,3,10,19,15) # 7:15pm, Wednesday, March 10th, 2004
+    @datetime_200403110000 = DateTime.new(2004,3,11,0,0)   # 12:00am, Thursday, March 11th, 2004
+    @datetime_200403110115 = DateTime.new(2004,3,11,1,15)
+    @datetime_200403111215 = DateTime.new(2004,3,11,12,15)
+    @datetime_200403140900 = DateTime.new(2004,3,14,9,00)  # 9:00am, Sunday, March 14th, 2004
+    @datetime_200709161007 = DateTime.new(2007,9,16,10,7)
+    @time_20070925115959 = Time.mktime(2007,9,25,11,59,59) # 11:59:59am, Tuesday, September 25th, 2007
+    @time_20070926000000 = Time.mktime(2007,9,26,0,0,0)    # 12:00:00am, Wednesday, September 26th, 2007
+    @time_20070927065959 = Time.mktime(2007,9,27,6,59,59)  #  6:59:59am, Thursday, September 27th, 2007
+    @time_20070927115900 = Time.mktime(2007,9,27,11,59,0)  # 11:59:00am, Thursday, September 27th, 2007
+    @time_20070928000000 = Time.mktime(2007,9,28,0,0,0)    # 12:00:00am, Friday, September 28th, 2007
+    @time_20070929110000 = Time.mktime(2007,9,29,11,0,0)   # 11:00:00am, Saturday, September 29th, 2007
+    @time_20070929000000 = Time.mktime(2007,9,29,0,0,0)    # 12:00:00am, Saturday, September 29th, 2007
+    @time_20070929235959 = Time.mktime(2007,9,29,23,59,59) # 11:59:59pm, Saturday, September 29th, 2007
+    @time_20070930235959 = Time.mktime(2007,9,30,23,59,59) # 11:59:59am, Sunday, September 30th, 2007
+  end
+
+  def test_nothing
+    # Sigh...I should figure out how to tell TestUnit that this is an "abstract" class
+  end
+
+end
+
+class StubExpression
+  include Runt
+  include TExpr
+  attr_accessor :match, :string, :overlap, :args
+  def initialize(match=false, string="StubExpression",overlap=false)
+    @match=match
+    @string=string
+    @overlap=overlap
+    @args=[]
+  end
+  def include?(arg)
+    @args << arg
+    @match
+  end
+  def overlap?(arg)
+    @args << arg
+    @overlap
+  end
+  def to_s
+    @string
+  end
+end

data/test/collectiontest.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for Collection class
+# Author:: Matthew Lipper
+
+class CollectionTest < BaseExpressionTest
+
+  def setup
+    super
+    @expr = Collection.new
+  end
+
+  def test_initialize
+    assert !@expr.expressions.nil?, "Newly created Collection should have a non-nil @expressions attribute"
+    assert @expr.expressions.empty?, "Newly created Collection should have an empty @expressions attribute"
+  end
+
+  def test_include
+    #base class that should always return false
+    assert !@expr.include?(StubExpression.new(true)), "Collection#include? should always return false"
+  end
+  
+
+  def test_to_s
+    assert_equal 'empty', @expr.to_s
+    assert_equal 'empty', @expr.to_s{['b','oo']}
+    dim = StubExpression.new(false,"Mock1")
+    @expr.expressions << dim
+    assert_equal 'ff' + dim.to_s, @expr.to_s{['ff','nn']}
+    red = StubExpression.new(false, "Mock2")
+    @expr.expressions << red
+    assert_equal 'ff' + dim.to_s + 'nn' + red.to_s, @expr.to_s{['ff','nn']}
+    wim = StubExpression.new(false, "Mock3")
+    @expr.expressions << wim
+    assert_equal 'ff' + dim.to_s + 'nn' + red.to_s + 'nn' + wim.to_s, @expr.to_s{['ff','nn']}
+  end
+
+  def test_add
+    e1 = StubExpression.new
+    e2 = StubExpression.new
+    assert @expr.expressions.empty?, "Empty Collection should not include any expressions"
+    result = @expr.add(e1)
+    assert_same @expr, result, "Collection#add method should return self instance"
+    assert @expr.expressions.include?(e1), "Collection should include added expression"
+    @expr.add(e2)
+    assert @expr.expressions.include?(e2), "Collection should include added expression"
+    assert_same e2, @expr.expressions.pop, "Collection should keep added expressions in stack order"
+    assert_same e1, @expr.expressions.pop, "Collection should keep added expressions in stack order"
+  end
+
+  def test_overlap
+    stub = StubExpression.new(false, "stubby", true) # start with "always overlap?" stub
+    assert !@expr.overlap?(stub), "Empty Collection should never overlap"
+    @expr.add StubExpression.new
+    assert @expr.overlap?(stub), "Collection should overlap with given stub argument"
+    assert_same stub.args[0], @expr.expressions.first, "First expression should be given to stub in the first call to overlap?"
+    stub.overlap = false
+    assert !@expr.overlap?(stub), "Collection should not overlap with given stub argument"
+  end
+
+end

data/test/combinedexpressionstest.rb

@@ -0,0 +1,158 @@
+
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for composite temporal expressions
+# Author:: Matthew Lipper
+
+class CombinedExpressionTest < BaseExpressionTest
+
+  def test_dates_on_last_fri_or_first_tues
+    date_range = @date_20050101..@date_20051231
+    expr = DIMonth.new(Last, Friday) | DIMonth.new(First, Tuesday)
+    dates = expr.dates(date_range)
+    assert_equal 24, dates.size, "Expected 24 dates in 2005 which were either on the last Friday or first Tuesday of the month"
+    month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] 
+    dates.each do |d|
+      unless (d.wday == 2 and d.day < 8) or \
+	(d.wday == 5 and d.day > month_days[d.month-1] - 8)
+	# Fail
+        assert false, d.to_s 
+      end
+    end
+  end
+
+  def test_january_except_from_7th_to_15th
+    date_range = @date_20050101..@date_20050131
+    dates = (REYear.new(1, 1, 1, 31) - REMonth.new(7, 15)).dates(date_range)
+    assert_equal 22, dates.size, "Expected 22 dates: 1/1-1/6, 1/16-1/31"
+  end
+
+  def test_work_day
+    # Should match for 9am to 5pm except for 12pm to 1pm
+    expr = REDay.new(9,0,17,0) - REDay.new(12,0,13,0)
+    assert expr.include?(@pdate_200405030906), "Expression #{expr.to_s} should include #{@pdate_200405030906.to_s}"
+    assert !expr.include?(@pdate_1975060512), "Expression #{expr.to_s} should not include #{@pdate_1975060512.to_s}"
+  end
+
+  def test_monday_tuesday_8am_to_9am
+    expr = REWeek.new(Mon,Fri) & REDay.new(8,0,9,0)
+    assert expr.include?(@pdate_200405040806), "Expression #{expr.to_s} should include #{@pdate_200405040806.to_s}"
+    assert !expr.include?(@pdate_200405010806), "Expression #{expr.to_s} should not include #{@pdate_200405010806.to_s}"
+    assert !expr.include?(@pdate_200405030906), "Expression #{expr.to_s} should not include #{@pdate_200405030906.to_s}"
+  end
+  
+
+  def test_midnight_to_9am_or_tuesday
+    expr = REDay.new(0,0,9,0) | DIWeek.new(Tuesday)
+    assert expr.include?(@pdate_20071030), "Expression #{expr.to_s} should include #{@pdate_20071030.to_s}"
+    assert expr.include?(@pdate_2012050803), "Expression #{expr.to_s} should include #{@pdate_2012050803.to_s}"
+    assert !expr.include?(@pdate_20071116100030), "Expression #{expr.to_s} should not include #{@pdate_20071116100030.to_s}"
+  end
+
+  def test_wednesday_thru_saturday_6_to_12am
+    expr = REWeek.new(Wed, Sat) & REDay.new(6,0,12,00)
+    assert !expr.include?(@time_20070926000000), "Expression #{expr.to_s} should include #{@time_20070926000000.to_s}"
+    assert expr.include?(@time_20070927065959), "Expression #{expr.to_s} should include #{@time_20070927065959.to_s}"
+    assert !expr.include?(@time_20070928000000), "Expression #{expr.to_s} should include #{@time_20070928000000.to_s}"
+    assert expr.include?(@time_20070929110000), "Expression #{expr.to_s} should include #{@time_20070929110000.to_s}"
+  end
+
+  def test_memorial_day
+    # Monday through Friday, from 9am to 5pm
+    job = REWeek.new(Mon,Fri) & REDay.new(9,00,17,00)
+    # Memorial Day (U.S.)
+    memorial_day = REYear.new(5) & DIMonth.new(Last,Monday)
+    # May 29th, 2006
+    last_monday_in_may = @pdate_200605291012
+    # Before 
+    assert job.include?(last_monday_in_may), "Expression #{job.to_s} should include #{last_monday_in_may.to_s}"
+    assert job.include?(@pdate_200605301400), "Expression #{job.to_s} should include #{@pdate_200605301400.to_s}"
+    # Add Diff expression
+    job_with_holiday = job - last_monday_in_may
+    assert !job_with_holiday.include?(last_monday_in_may), "Expression #{job_with_holiday.to_s} should not include #{last_monday_in_may.to_s}"
+    # Still have to work on Tuesday
+    assert job.include?(@pdate_200605301400), "Expression #{job.to_s} should include #{@pdate_200605301400.to_s}"
+  end
+  
+  def test_summertime
+    #This is a hack.....
+    #In the U.S., Memorial Day begins the last Monday of May
+    #
+    #The month of May
+    may=REYear.new(5)
+    #Monday through Saturday
+    monday_to_saturday = REWeek.new(1,6)
+    #Last week of (any) month
+    last_week_in = WIMonth.new(Last_of)
+    #So, to say 'starting from the last Monday in May',
+    #we need to select just that last week of May begining with
+    #the Monday of that week
+    last_week_of_may = may & monday_to_saturday & last_week_in
+
+    #This is another hack similar to the above, except instead of selecting a range
+    #starting at the begining of the month, we need to select only the time period in
+    #September up until Labor Day.
+    #
+    #In the U.S., Labor Day is the first Monday in September
+    #
+    #The month of September
+    september=REYear.new(9)
+    #First week of (any) month
+    first_week_in = WIMonth.new(First)
+    entire_first_week_of_september = september & first_week_in
+    #To exclude everything in the first week which occurs on or after Monday.
+    first_week_of_september=entire_first_week_of_september - monday_to_saturday
+    #June through August
+    june_through_august=REYear.new(6, 1, 8)
+    assert june_through_august.include?(@pdate_20040704), "Expression #{june_through_august.to_s} should include #{@pdate_20040704.to_s}"
+    #Finally!
+    summer_time = last_week_of_may | first_week_of_september | june_through_august
+
+    #Will work, but will be incredibly slow:
+    #  assert(summer_time.include?(PDate.min(2004,5,31,0,0)))
+    assert summer_time.include?(@pdate_20040531), "Expression #{summer_time.to_s} should include #{@pdate_20040704.to_s}"
+    assert summer_time.include?(@pdate_20040704), "Expression #{summer_time.to_s} should include #{@pdate_20040704.to_s}"
+    #also works...also slow:
+    #  assert(!summer_time.include?(PDate.min(2004,9,6,0,0)))
+    assert !summer_time.include?(@pdate_2004090600), "Expression #{summer_time.to_s} should not include #{@pdate_2004090600.to_s}"
+
+  end
+  def test_nyc_parking_te
+
+    #Monday, Wednesday, Friday
+    mon_wed_fri = DIWeek.new(Mon) | \
+                    DIWeek.new(Wed) | \
+                      DIWeek.new(Fri)
+
+    assert mon_wed_fri.include?(@datetime_200403101915), "Expression #{mon_wed_fri.to_s} should include #{@datetime_200403101915.to_s}"
+    assert !mon_wed_fri.include?(@datetime_200403140900), "Expression #{mon_wed_fri.to_s} should not include #{@datetime_200403140900.to_s}"
+    # 8am to 11am
+    eight_to_eleven = REDay.new(8,00,11,00)
+    # => Mon,Wed,Fri - 8am to 11am
+    expr1 = mon_wed_fri & eight_to_eleven
+    # Tuesdays, Thursdays
+    tues_thurs = DIWeek.new(Tue) | DIWeek.new(Thu)
+    # 11:30am to 2pm
+    eleven_thirty_to_two = REDay.new(11,30,14,00)
+    assert eleven_thirty_to_two.include?(@datetime_200403081200), "Expression #{eleven_thirty_to_two.to_s} should include #{@datetime_200403081200.to_s}"
+    assert !eleven_thirty_to_two.include?(@datetime_200403110000), "Expression #{eleven_thirty_to_two.to_s} should not include #{@datetime_200403110000.to_s}"
+    # => Tues,Thurs - 11:30am to 2pm
+    expr2 = tues_thurs & eleven_thirty_to_two
+    #
+    # No parking: Mon Wed Fri, 8am - 11am
+    #             Tu Thu, 11:30am - 2pm
+    parking_ticket = expr1 | expr2
+    assert parking_ticket.include?(@datetime_200403111215), "Expression #{parking_ticket.to_s} should include #{@datetime_200403111215.to_s}"
+    assert parking_ticket.include?(@datetime_200403100915), "Expression #{parking_ticket.to_s} should include #{@datetime_200403100915.to_s}"
+    assert parking_ticket.include?(@datetime_200403100800), "Expression #{parking_ticket.to_s} should include #{@datetime_200403100800.to_s}"
+    assert !parking_ticket.include?(@datetime_200403110115), "Expression #{parking_ticket.to_s} should not include #{@datetime_200403110115.to_s}"
+
+    # The preceeding example can be condensed to:
+    #   e1 = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)
+    #   e2 = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)
+    #   ticket = e1 | e2
+ end
+
+end

data/test/daterangetest.rb

@@ -70,6 +70,8 @@ class DateRangeTest < Test::Unit::TestCase
     empty_range = DateRange.new(r_start,r_end)
     assert(empty_range.empty?)
     assert(DateRange::EMPTY.empty?)
+    # start == end should be empty
+    assert DateRange.new(r_start,r_start).empty?, "Range should be empty when start == end"
   end
 
   def test_gap

data/test/dayintervaltetest.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for DayIntervalTE class
+# Author:: Matthew Lipper
+
+class DayIntervalTETest < BaseExpressionTest
+
+
+  def test_every_8_days
+    date = @date_20040116
+    # Match every 8 days
+    expr = DayIntervalTE.new(date, 8)
+    assert expr.include?(date + 8), "Expression #{expr.to_s} should include #{(date + 8).to_s}"
+    assert expr.include?(date + 16), "Expression #{expr.to_s} should include #{(date + 16).to_s}"
+    assert expr.include?(date + 64), "Expression #{expr.to_s} should include #{(date + 64).to_s}"
+    assert !expr.include?(date + 4), "Expression #{expr.to_s} should not include #{(date + 4).to_s}"
+    # FIXME This test fails
+    #assert !expr.include?(date - 8), "Expression #{expr.to_s} should not include #{(date - 8).to_s}"
+  end
+
+  def test_every_2_days
+    date = @datetime_200709161007
+    expr = DayIntervalTE.new(date, 2)
+    assert expr.include?(date + 2), "Expression #{expr.to_s} should include #{(date + 2).to_s}"
+    assert expr.include?(date + 4), "Expression #{expr.to_s} should include #{(date + 4).to_s}"
+    assert !expr.include?(date + 3), "Expression #{expr.to_s} should not include #{(date + 3).to_s}"
+  end
+  
+  def test_to_s
+    every_four_days = DayIntervalTE.new(Date.new(2006,2,26), 4)
+    assert_equal "every 4th day after #{Runt.format_date(Date.new(2006,2,26))}", every_four_days.to_s
+  end
+
+  
+end