runt 0.7.0 → 0.9.0

data/lib/runt/pdate.rb

@@ -16,27 +16,35 @@ module Runt
   #
   # Author:: Matthew Lipper
   class PDate < DateTime
+	include Comparable
     include DPrecision
 
     attr_accessor :date_precision
-    
+
     class << self
-      alias_method :old_civil, :civil
 
       def civil(*args)
-	precision=nil
+        precision=nil
         if(args[0].instance_of?(DPrecision::Precision))
           precision = args.shift
         else
           return PDate::sec(*args)
         end
-        _civil = old_civil(*args)
-        _civil.date_precision = precision
-        _civil
+        pdate = super(*args)
+        pdate.date_precision = precision
+        pdate
+      end
+      
+      def parse(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        pdate = super(*args)
+        pdate.date_precision = opts[:precision] || opts[:date_precision]
+        pdate
       end
-    end
 
-    class << self; alias_method :new, :civil end
+	  alias_method :new, :civil
+      
+    end
 
     def include?(expr)
       eql?(expr)
@@ -44,122 +52,120 @@ module Runt
 
     def + (n)
       raise TypeError, 'expected numeric' unless n.kind_of?(Numeric)
+	  ndays = n
       case @date_precision
       when YEAR then
-	return DPrecision::to_p(PDate::civil(year+n,month,day),@date_precision)
+        return DPrecision::to_p(PDate::civil(year+n,month,day),@date_precision)
       when MONTH then
-	current_date = self.class.to_date(self)
-	return DPrecision::to_p((current_date>>n),@date_precision)
+        return DPrecision::to_p((self.to_date>>n),@date_precision)
       when WEEK then
-	return new_self_plus(n*7)	
+        ndays = n*7	
       when DAY then
-	return new_self_plus(n)
+        ndays = n
       when HOUR then
-	return new_self_plus(n){ |n| n = (n*(1.to_r/24) ) }
+        ndays = n*(1.to_r/24)
       when MIN then
-	return new_self_plus(n){ |n| n = (n*(1.to_r/1440) ) }
+        ndays = n*(1.to_r/1440)
       when SEC then
-	return new_self_plus(n){ |n| n = (n*(1.to_r/86400) ) }
+        ndays = n*(1.to_r/86400)
       when MILLI then
-	return self
+        ndays = n*(1.to_r/86400000)
+      end
+	  DPrecision::to_p((self.to_date + ndays),@date_precision)
     end
-  end
 
-  def - (x)
-    case x
+    def - (x)
+      case x
       when Numeric then
-	return self+(-x)
-      #FIXME!!
-      when Date;    return @ajd - x.ajd
+        return self+(-x)
+      when Date then
+	 	return super(DPrecision::to_p(x,@date_precision))
+      end
+      raise TypeError, 'expected numeric or date'
     end
-    raise TypeError, 'expected numeric or date'
-  end
 
-  def <=> (other)
-    result = nil
-    if(other.respond_to?("date_precision") && other.date_precision>@date_precision)
-      result = super(DPrecision::to_p(other,@date_precision))
-    else
-      result = super(other)
+    def <=> (other)
+      result = nil
+	  raise "I'm broken #{self.to_s}" if @date_precision.nil?
+      if(!other.nil? && other.respond_to?("date_precision") && other.date_precision>@date_precision)
+        result = super(DPrecision::to_p(other,@date_precision))
+      else
+        result = super(other)
+      end
+      puts "self<#{self.to_s}><=>other<#{other.to_s}> => #{result}" if $DEBUG
+      result
     end
-    #puts "#{self.to_s}<=>#{other.to_s} => #{result}" if $DEBUG
-    result
-  end
 
-  def new_self_plus(n)
-    if(block_given?)
-      n=yield(n)
+    def succ
+	  result = self + 1
+	end
+
+    def to_date
+      (self.date_precision > DAY) ? DateTime.new(self.year,self.month,self.day,self.hour,self.min,self.sec) : Date.new(self.year, self.month, self.day)
     end
-    return DPrecision::to_p(self.class.new!(@ajd + n, @of, @sg),@date_precision)
-  end
 
-  def PDate.to_date(pdate)
-    if( pdate.date_precision > DPrecision::DAY) then
-      DateTime.new(pdate.year,pdate.month,pdate.day,pdate.hour,pdate.min,pdate.sec)
+    def PDate.year(yr,*ignored)
+      PDate.civil(YEAR, yr, MONTH.min_value, DAY.min_value  )
     end
-    return Date.new(pdate.year,pdate.month,pdate.day)
-  end
 
-  def PDate.year(yr,*ignored)
-    PDate.civil(YEAR, yr, MONTH.min_value, DAY.min_value  )
-  end
+    def PDate.month( yr,mon,*ignored )
+      PDate.civil(MONTH, yr, mon, DAY.min_value  )
+    end
 
-  def PDate.month( yr,mon,*ignored )
-    PDate.civil(MONTH, yr, mon, DAY.min_value  )
-  end
+    def PDate.week( yr,mon,day,*ignored )
+      #LJK: need to calculate which week this day implies,
+      #and then move the day back to the *first* day in that week;
+      #note that since rfc2445 defaults to weekstart=monday, I'm 
+      #going to use commercial day-of-week
+      raw = PDate.day(yr, mon, day)
+      cooked = PDate.commercial(raw.cwyear, raw.cweek, 1)
+      PDate.civil(WEEK, cooked.year, cooked.month, cooked.day)
+    end
 
-  def PDate.week( yr,mon,day,*ignored )
-    #LJK: need to calculate which week this day implies,
-    #and then move the day back to the *first* day in that week;
-    #note that since rfc2445 defaults to weekstart=monday, I'm 
-    #going to use commercial day-of-week
-    raw = PDate.day(yr, mon, day)
-    cooked = PDate.commercial(raw.cwyear, raw.cweek, 1)
-    PDate.civil(WEEK, cooked.year, cooked.month, cooked.day)
-  end
+    def PDate.day( yr,mon,day,*ignored )
+      PDate.civil(DAY, yr, mon, day )
+    end
 
-  def PDate.day( yr,mon,day,*ignored )
-    PDate.civil(DAY, yr, mon, day )
-  end
+    def PDate.hour( yr,mon,day,hr=HOUR.min_value,*ignored )
+      PDate.civil(HOUR, yr, mon, day,hr,MIN.min_value, SEC.min_value)
+    end
 
-  def PDate.hour( yr,mon,day,hr=HOUR.min_value,*ignored )
-    PDate.civil(HOUR, yr, mon, day,hr,MIN.min_value, SEC.min_value)
-  end
+    def PDate.min( yr,mon,day,hr=HOUR.min_value,min=MIN.min_value,*ignored )
+      PDate.civil(MIN, yr, mon, day,hr,min, SEC.min_value)
+    end
 
-  def PDate.min( yr,mon,day,hr=HOUR.min_value,min=MIN.min_value,*ignored )
-    PDate.civil(MIN, yr, mon, day,hr,min, SEC.min_value)
-  end
+    def PDate.sec( yr,mon,day,hr=HOUR.min_value,min=MIN.min_value,sec=SEC.min_value,*ignored )
+      PDate.civil(SEC, yr, mon, day,hr,min, sec)
+    end
 
-  def PDate.sec( yr,mon,day,hr=HOUR.min_value,min=MIN.min_value,sec=SEC.min_value,*ignored )
-    PDate.civil(SEC, yr, mon, day,hr,min, sec)
-  end
+    def PDate.millisecond( yr,mon,day,hr,min,sec,ms,*ignored )
+      PDate.civil(SEC, yr, mon, day,hr,min, sec, ms, *ignored)
+      #raise "Not implemented yet."
+    end
 
-  def PDate.millisecond( yr,mon,day,hr,min,sec,ms,*ignored )
-    PDate.civil(SEC, yr, mon, day,hr,min, sec, ms, *ignored)
-    #raise "Not implemented yet."
-  end
+    def PDate.default(*args)
+      PDate.civil(DEFAULT, *args)
+    end
 
-  def PDate.default(*args)
-    PDate.civil(DEFAULT, *args)
-  end
+	#FIXME: marshall broken in 1.9
+    #
+    # Custom dump which preserves DatePrecision   
+    # 
+    # Author:: Jodi Showers
+    #
+    def marshal_dump
+      [date_precision, ajd, start, offset]
+    end
 
-  #
-  # Custom dump which preserves DatePrecision   
-  # 
-  # Author:: Jodi Showers
-  #
-  def marshal_dump
-    [date_precision, ajd, start, offset]
-  end
+	#FIXME: marshall broken in 1.9
+    #
+    # Custom load which preserves DatePrecision   
+    # 
+    # Author:: Jodi Showers
+    #
+    def marshal_load(dumped_obj)
+      @date_precision, @ajd, @sg, @of=dumped_obj
+    end
 
-  #
-  # Custom load which preserves DatePrecision   
-  # 
-  # Author:: Jodi Showers
-  #
-  def marshal_load(dumped_obj)
-    @date_precision, @ajd, @sg, @of=dumped_obj
   end
-  
-end
 end

data/lib/runt/schedule.rb

@@ -30,6 +30,10 @@ module Runt
       end
       result
     end
+    
+    def scheduled_dates(date_range)
+      @elems.values.collect{|expr| expr.dates(date_range)}.flatten.sort.uniq
+    end
 
     # Return true or false depend on if the supplied event is scheduled to occur on the
     # given date.
@@ -66,7 +70,21 @@ module Runt
       block.call(@elems[event])
     end
 
+    def date_to_event_hash(event_attribute=:id)
+      start_date = end_date = nil
+      @elems.keys.each do |event|
+        start_date = event.start_date if start_date.nil? || start_date > event.start_date
+        end_date = event.end_date if end_date.nil? || end_date < event.end_date
+      end
+      
+      scheduled_dates(DateRange.new(start_date, end_date)).inject({}) do |h, date|
+        h[date] = events(date).collect{|e| e.send(event_attribute)}
+        h
+      end
+    end
   end
+  
+  # TODO: Extend event to take other attributes
 
   class Event
 

data/lib/runt/sugar.rb

@@ -108,8 +108,35 @@
 #
 #    DIMonth.new(First, Saturday)
 #    DIMonth.new(Last, Tuesday)
-# 
-
+#    
+# === AfterTE 
+#
+#    self.after(date [, inclusive])
+#
+#  Example:
+#
+#    self.after(date)
+#    self.after(date, true)
+#
+#  is equivilant to
+#
+#    AfterTE.new(date)
+#    AfterTE.new(date, true)
+#
+# === BeforeTE 
+#
+#    self.before(date [, inclusive])
+#
+#  Example:
+#
+#    self.before(date)
+#    self.before(date, true)
+#
+#  is equivilant to
+#
+#    BeforeTE.new(date)
+#    BeforeTE.new(date, true)
+#    
 require 'runt'
 
 module Runt
@@ -125,12 +152,7 @@ module Runt
   end
 
   def method_missing(name, *args, &block) 
-    result = self.build(name, *args, &block)
-    return result unless result.nil?
-    super
-  end
-
-  def build(name, *args, &block)
+	#puts "method_missing(#{name},#{args},#{block}) => #{result}"
     case name.to_s
     when /^daily_(\d{1,2})_(\d{2})([ap]m)_to_(\d{1,2})_(\d{2})([ap]m)$/
       # REDay
@@ -160,10 +182,20 @@ module Runt
       return DIMonth.new(Runt.const(ordinal), Runt.const(day))
     else
       # You're hosed
-      nil
+	  super
     end
   end
 
+  # Shortcut for AfterTE(date, ...).new
+  def after(date, inclusive=false)
+    AfterTE.new(date, inclusive)
+  end
+
+  # Shortcut for BeforeTE(date, ...).new
+  def before(date, inclusive=false)
+    BeforeTE.new(date, inclusive)
+  end
+
   def parse_time(hour, minute, ampm)
     hour = hour.to_i + 12 if ampm =~ /pm/
     [hour.to_i, minute.to_i]

data/lib/runt/temporalexpression.rb

@@ -76,7 +76,7 @@ module TExpr
     end
     result
   end
-
+  
 end
 
 # Base class for TExpr classes that can be composed of other
@@ -87,15 +87,29 @@ class Collection
   
   attr_reader :expressions
 
-  def initialize
-    @expressions = Array.new
+  def initialize(expressions = [])
+    @expressions = expressions
+  end
+  
+  def ==(other)
+    if other.is_a?(Collection)
+      o_exprs = other.expressions.dup
+      expressions.each do |e|
+        return false unless i = o_exprs.index(e)
+        o_exprs.delete_at(i)
+      end
+      o_exprs.each {|e| return false unless i == expressions.index(e)}
+      return true
+    else
+      super(other)
+    end
   end
 
   def add(anExpression)
     @expressions.push anExpression
     self
   end
-
+  
   # Will return true if the supplied object overlaps with the range used to
   # create this instance
   def overlap?(date_expr)
@@ -110,11 +124,11 @@ class Collection
       first_expr, next_exprs = yield
       result = '' 
       @expressions.map do |expr|
-	if @expressions.first===expr
-	  result = first_expr + expr.to_s
-	else
-	 result = result + next_exprs + expr.to_s
-	end 
+        if @expressions.first===expr
+          result = first_expr + expr.to_s
+        else
+          result = result + next_exprs + expr.to_s
+        end 
       end
       result
     else
@@ -142,7 +156,7 @@ class Union < Collection
     end
     false
   end
-
+  
   def to_s
     super {['every ',' or ']}
   end
@@ -159,7 +173,7 @@ class Intersect < Collection
     end
     result
   end
-
+  
   def to_s 
     super {['every ', ' and ']}  
   end
@@ -178,6 +192,10 @@ class Diff
     @expr2 = expr2
   end
 
+  def ==(o)
+    o.is_a?(Diff) ? expr1 == o.expr1 && expr2 == o.expr2 : super(o)
+  end
+
   def include?(aDate)
     return false unless (@expr1.include?(aDate) && !@expr2.include?(aDate))
     true
@@ -189,7 +207,7 @@ class Diff
 end
 
 # TExpr that provides for inclusion of an arbitrary date.
-class Spec
+class TemporalDate
   
   include TExpr
 
@@ -199,6 +217,10 @@ class Spec
     @date_expr = date_expr
   end
 
+  def ==(o)
+    o.is_a?(TemporalDate) ? date_expr == o.date_expr : super(o)
+  end
+
   # Will return true if the supplied object is == to that which was used to
   # create this instance
   def include?(date_expr)
@@ -217,7 +239,7 @@ end
 # facilitating inclusion of an arbitrary range in a temporal expression.
 #
 #  See also: Range
-class RSpec < Spec 
+class TemporalRange < TemporalDate 
 
   ## Will return true if the supplied object is included in the range used to
   ## create this instance
@@ -225,6 +247,10 @@ class RSpec < Spec
     return @date_expr.include?(date_expr)
   end
   
+  def ==(o)
+    o.is_a?(TemporalRange) ? date_expr == o.date_expr : super(o)
+  end
+  
   # Will return true if the supplied object overlaps with the range used to
   # create this instance
   def overlap?(date_expr)
@@ -315,11 +341,17 @@ class DIMonth
   include TExpr
   include TExprUtils
 
+  attr_reader :day_index, :week_of_month_index
+
   def initialize(week_of_month_index,day_index)
     @day_index = day_index
     @week_of_month_index = week_of_month_index
   end
 
+  def ==(o)
+    o.is_a?(DIMonth) ? day_index == o.day_index && week_of_month_index == o.week_of_month_index : super(o)
+  end
+
   def include?(date)
     ( day_matches?(date) ) && ( week_matches?(@week_of_month_index,date) )
   end
@@ -354,6 +386,8 @@ class DIWeek
   include TExpr
 
   VALID_RANGE = 0..6
+  
+  attr_reader :ordinal_weekday
 
   def initialize(ordinal_weekday)
     unless VALID_RANGE.include?(ordinal_weekday)
@@ -361,6 +395,10 @@ class DIWeek
     end
     @ordinal_weekday = ordinal_weekday
   end
+  
+  def ==(o)
+    o.is_a?(DIWeek) ? ordinal_weekday == o.ordinal_weekday : super(o)
+  end
 
   def include?(date)
     @ordinal_weekday == date.wday
@@ -384,6 +422,8 @@ class REWeek
 
   VALID_RANGE = 0..6
 
+  attr_reader :start_day, :end_day
+
   # Creates a REWeek using the supplied start
   # day(range = 0..6, where 0=>Sunday) and an optional end
   # day. If an end day is not supplied, the maximum value
@@ -393,6 +433,10 @@ class REWeek
     @start_day = start_day
     @end_day = end_day
   end
+  
+  def ==(o)
+    o.is_a?(REWeek) ? start_day == o.start_day && end_day == o.end_day : super(o)
+  end
 
   def include?(date)
     return true if all_week?
@@ -494,24 +538,28 @@ class REYear
     else
       case args.size
       when 1
-	@end_month = args[0]
-	@start_day = NO_DAY
-	@end_day = NO_DAY
+        @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
+        @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]
+        @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"
+        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 ==(o)
+    o.is_a?(REYear) ? start_day == o.start_day && end_day == o.end_day && start_month == o.start_month && end_month == o.end_month : super(o)
+  end
+
   def include?(date)
    
     return same_start_month_include_day?(date) \
@@ -555,9 +603,13 @@ end
 # NOTE: By default, this class will match any date expression whose
 # precision is less than or equal to DPrecision::DAY. To override
 # this behavior, pass the optional fifth constructor argument the 
-# value: false.
+# value: false. 
+#
+# When the less_precise_match argument is true, the 
+# date-like object passed to :include? will be "promoted" to
+# DPrecision::MINUTE if it has a precision of DPrecision::DAY or
+# less.
 #
-#  See also: Date
 class REDay 
 
   include TExpr
@@ -565,6 +617,8 @@ class REDay
   CURRENT=28
   NEXT=29
   ANY_DATE=PDate.day(2002,8,CURRENT)
+  
+  attr_reader :range, :spans_midnight
 
   def initialize(start_hour, start_minute, end_hour, end_minute, less_precise_match=true)
 
@@ -580,19 +634,26 @@ class REDay
     @range = start_time..end_time
     @less_precise_match = less_precise_match
   end
-
+  
+  def ==(o)
+    o.is_a?(REDay) ? spans_midnight == o.spans_midnight && range == o.range : super(o)
+  end
+  
   def include?(date)
     # 
     # If @less_precise_match == true and the precision of the argument
     #  is day or greater, then the result is always true
-    return true if @less_precise_match && date.date_precision <= DPrecision::DAY
-    if(@spans_midnight&&date.hour<12) then
+    return true if @less_precise_match && less_precise?(date)
+	
+	date_to_use = ensure_precision(date)
+    
+	if(@spans_midnight&&date_to_use.hour<12) then
       #Assume next day
-      return @range.include?(get_next(date.hour,date.min))
+      return @range.include?(get_next(date_to_use.hour,date_to_use.min))
     end
 
     #Same day
-    return @range.include?(get_current(date.hour,date.min))
+    return @range.include?(get_current(date_to_use.hour,date_to_use.min))
   end
 
   def to_s
@@ -600,6 +661,16 @@ class REDay
   end
 
   private
+  
+  def less_precise?(date)
+	date.date_precision <= DPrecision::DAY
+  end
+
+  def ensure_precision(date)
+	return date unless less_precise?(date)
+	DPrecision.to_p(date,DPrecision::MIN)
+  end
+
   def spans_midnight?(start_hour, end_hour)
     return end_hour < start_hour
   end
@@ -627,12 +698,18 @@ class WIMonth
 
   VALID_RANGE = -2..5
 
+  attr_reader :ordinal
+  
   def initialize(ordinal)
     unless VALID_RANGE.include?(ordinal)
       raise ArgumentError, 'invalid ordinal week of month'
     end
     @ordinal = ordinal
   end
+  
+  def ==(o)
+    o.is_a?(WIMonth) ? ordinal == o.ordinal : super(o)
+  end
 
   def include?(date)
     week_matches?(@ordinal,date)
@@ -656,11 +733,17 @@ class REMonth
 
   include TExpr
 
+  attr_reader :range
+  
   def initialize(start_day, end_day=0)
     end_day=start_day if end_day==0
     @range = start_day..end_day
   end
 
+  def ==(o)
+    o.is_a?(REMonth) ? range == o.range : super(o)
+  end
+
   def include?(date)
     @range.include? date.mday
   end
@@ -678,6 +761,8 @@ end
 class EveryTE
 
   include TExpr
+  
+  attr_reader :start, :interval, :precision
 
   def initialize(start,n,precision=nil)
     @start=start
@@ -686,6 +771,10 @@ class EveryTE
     @precision=precision || @start.date_precision
   end
 
+  def ==(o)
+    o.is_a?(EveryTE) ? start == o.start && precision == o.precision && interval == o.interval  : super(o)
+  end
+
   def include?(date)
     i=DPrecision.to_p(@start,@precision)
     d=DPrecision.to_p(date,@precision)
@@ -710,10 +799,16 @@ class DayIntervalTE
 
   include TExpr
 
+  attr_reader :interval, :base_date
+
   def initialize(base_date,n)
     @base_date = DPrecision.to_p(base_date,DPrecision::DAY)
     @interval = n
   end
+  
+  def ==(o)
+    o.is_a?(DayIntervalTE) ? base_date == o.base_date && interval == o.interval  : super(o)
+  end
 
   def include?(date)
     return ((DPrecision.to_p(date,DPrecision::DAY) - @base_date).to_i % @interval == 0)   
@@ -725,6 +820,107 @@ class DayIntervalTE
 
 end
 
+# 
+# This class creates an expression which matches dates occuring during the weeks 
+# alternating at the given interval begining on the week containing the date 
+# used to create the instance. 
+#  
+#    WeekInterval.new(starting_date, interval)
+# 
+# Weeks are defined as Sunday to Saturday, as opposed to the commercial week
+# which starts on a Monday. For example,
+#
+#     every_other_week = WeekInterval.new(Date.new(2013,04,24), 2)
+#  
+# will match any date that occurs during every other week begining with the
+# week of 2013-04-21 (2013-04-24 is a Wednesday and 2013-04-21 is the Sunday
+# that begins the containing week).
+#    
+#     # Sunday of starting week
+#     every_other_week.include?(Date.new(2013,04,21)) #==> true     
+#     # Saturday of starting week
+#     every_other_week.include?(Date.new(2013,04,27)) #==> true
+#     # First week _after_ start week     
+#     every_other_week.include?(Date.new(2013,05,01)) #==> false     
+#     # Second week _after_ start week     
+#     every_other_week.include?(Date.new(2013,05,06)) #==> true     
+#
+# NOTE: The idea and tests for this class were originally contributed as the 
+# REWeekWithIntervalTE class by Jeff Whitmire. The behavior of the original class 
+# provided both the matching of every n weeks and the specification of specific
+# days of that week in a single class. This class only provides the matching
+# of every n weeks. The exact functionality of the original class is easy to create
+# using the Runt set operators and the DIWeek class:
+#
+#     # Old way
+#     tu_thurs_every_third_week = REWeekWithIntervalTE.new(Date.new(2013,04,24),2,[2,4])
+#
+#     # New way
+#     tu_thurs_every_third_week = 
+#         WeekInterval.new(Date.new(2013,04,24),2) & (DIWeek.new(Tuesday) | DIWeek.new(Thursday))
+# 
+# Notice that the compound expression (in parens after the "&") can be replaced 
+# or combined with any other appropriate temporal expression to provide different
+# functionality (REWeek to provide a range of days, REDay to provide certain times, etc...). 
+# 
+# Contributed by Jeff Whitmire
+class WeekInterval
+  include TExpr
+  def initialize(start_date,interval=2)
+    @start_date = DPrecision.to_p(start_date,DPrecision::DAY)
+    # convert base_date to the start of the week
+    @base_date = @start_date - @start_date.wday
+    @interval = interval
+  end
+  
+  def include?(date)
+	return false if @base_date > date
+	((adjust_for_year(date) - week_num(@base_date)) % @interval) == 0 
+  end
+  
+  def to_s
+    "every #{Runt.ordinalize(@interval)} week starting with the week containing #{Runt.format_date(@start_date)}"
+  end
+
+  private
+  def week_num(date)
+	# %U - Week number of the year. The week starts with Sunday.  (00..53)
+	date.strftime("%U").to_i    
+  end
+  def max_week_num(year)	
+	d = Date.new(year,12,31)
+	max = week_num(d)
+	while max < 52
+	  d = d - 1
+	  max = week_num(d)
+	end
+	max
+  end
+  def adjust_for_year(date)
+	# Exclusive range: if date.year == @base_date.year, this will be empty
+	range_of_years = @base_date.year...date.year
+	in_same_year = range_of_years.to_a.empty?
+	# Week number of the given date argument
+	week_number = week_num(date)
+	# Default (most common case) date argument is in same year as @base_date
+    # and the week number is also part of the same year. This starting value 
+	# is also necessary for the case where they're not in the same year.
+	adjustment = week_number
+	if in_same_year && (week_number < week_num(@base_date)) then
+	  # The given date occurs within the same year 
+	  # but is actually week number 1 of the next year
+	  adjustment = adjustment + max_week_num(date.year)
+	elsif !in_same_year then
+	  # Date occurs in different year
+	  range_of_years.each do |year|
+	    # Max week number taking into account we are not using commercial week
+	    adjustment = adjustment + max_week_num(year)
+	  end
+	end
+	adjustment
+  end
+end
+
 # Simple expression which returns true if the supplied arguments
 # occur within the given year.
 #
@@ -732,10 +928,16 @@ class YearTE
 
   include TExpr
 
+  attr_reader :year
+
   def initialize(year)
     @year = year
   end
 
+  def ==(o)
+    o.is_a?(YearTE) ? year == o.year  : super(o)
+  end
+
   def include?(date)
     return date.year == @year
   end
@@ -750,13 +952,20 @@ end
 class BeforeTE
 
   include TExpr
+  
+  attr_reader :date, :inclusive
 
   def initialize(date, inclusive=false)
     @date = date
     @inclusive = inclusive
   end
+  
+  def ==(o)
+    o.is_a?(BeforeTE) ? date == o.date && inclusive == o.inclusive  : super(o)
+  end
 
   def include?(date)
+    return false unless date
     return (date < @date) || (@inclusive && @date == date)
   end
 
@@ -771,11 +980,18 @@ class AfterTE
 
   include TExpr
 
+  attr_reader :date, :inclusive
+
   def initialize(date, inclusive=false)
     @date = date
     @inclusive = inclusive
   end
 
+  def ==(o)
+    o.is_a?(AfterTE) ? date == o.date && inclusive == o.inclusive  : super(o)
+  end
+
+
   def include?(date)
     return (date > @date) || (@inclusive && @date == date)
   end