runt19 0.7.6

data/lib/runt/daterange.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'date'
+require 'runt'
+
+
+module Runt
+  # :title:DateRange
+  # == DateRange
+  #
+  #
+  # Based the <tt>range</tt>[http://martinfowler.com/ap2/range.html] pattern by Martin Fowler.
+  #
+  #
+  #
+  # Author:: Matthew Lipper
+  class DateRange < Range
+
+    include DPrecision
+
+    attr_reader :start_expr, :end_expr
+
+    def initialize(start_expr, end_expr,exclusive=false)
+      super(start_expr, end_expr,exclusive)
+      @start_expr, @end_expr = start_expr, end_expr
+    end
+
+    def include?(obj)
+      return super(obj.min) && super(obj.max) if obj.kind_of? Range
+      return super(obj)
+    end
+
+    def overlap?(obj)
+      return true if( member?(obj) || include?(obj.min) || include?(obj.max) )
+      return true if( obj.kind_of?(Range) && obj.include?(self) )
+      false
+    end
+
+    def empty?
+      return @start_expr >= @end_expr
+    end
+
+    def gap(obj)
+
+      return EMPTY if self.overlap? obj
+
+      lower=nil
+      higher=nil
+
+      if((self<=>obj)<0)
+        lower=self
+        higher=obj
+      else
+        lower=obj
+        higher=self
+      end
+
+      return DateRange.new((lower.end_expr+1),(higher.start_expr-1))
+    end
+
+    def <=>(other)
+      return @start_expr <=> other.start_expr if(@start_expr != other.start_expr)
+      return @end_expr <=> other.end_expr
+    end
+
+    def min; @start_expr  end
+    def max; @end_expr  end
+    def to_s; @start_expr.to_s + " " + @end_expr.to_s end
+
+
+    EMPTY = DateRange.new(PDate.day(2004,2,2),PDate.day(2004,2,1))
+
+  end
+end

data/lib/runt/dprecision.rb

@@ -0,0 +1,150 @@
+#!/usr/bin/env ruby
+
+require 'runt'
+require 'date'
+
+module Runt
+
+  # :title:DPrecision
+  # == DPrecision
+  # Module providing automatic precisioning of Date, DateTime, and PDate classes.
+  #
+  # Inspired by a <tt>pattern</tt>[http://martinfowler.com/ap2/timePoint.html] by Martin Fowler.
+  #
+  #
+  # Author:: Matthew Lipper
+  module DPrecision
+
+    def DPrecision.to_p(date,prec=DEFAULT)
+
+      case prec
+        when MIN then PDate.min(*DPrecision.explode(date,prec))
+        when DAY then PDate.day(*DPrecision.explode(date,prec))
+        when HOUR then PDate.hour(*DPrecision.explode(date,prec))
+        when WEEK then PDate.week(*DPrecision.explode(date,prec))
+        when MONTH then PDate.month(*DPrecision.explode(date,prec))
+        when YEAR then PDate.year(*DPrecision.explode(date,prec))
+        when SEC then PDate.sec(*DPrecision.explode(date,prec))
+        when MILLI then date #raise "Not implemented."
+        else PDate.default(*DPrecision.explode(date,prec))
+      end
+    end
+
+    def DPrecision.explode(date,prec)
+      result = [date.year,date.month,date.day]
+        if(date.respond_to?("hour"))
+          result << date.hour << date.min << date.sec
+        else
+          result << 0 << 0 << 0
+        end
+      result
+    end
+
+    #Simple value class for keeping track of precisioned dates
+    class Precision
+      include Comparable
+
+      attr_reader :precision
+      private_class_method :new
+
+      #Some constants w/arbitrary integer values used internally for comparisions
+      YEAR_PREC = 0
+      MONTH_PREC = 1
+      WEEK_PREC = 2
+      DAY_PREC = 3
+      HOUR_PREC = 4
+      MIN_PREC = 5
+      SEC_PREC = 6
+      MILLI_PREC = 7
+
+      #String values for display
+      LABEL = { YEAR_PREC => "YEAR",
+        MONTH_PREC => "MONTH",
+        WEEK_PREC => "WEEK",
+        DAY_PREC => "DAY",
+        HOUR_PREC => "HOUR",
+        MIN_PREC => "MINUTE",
+        SEC_PREC => "SECOND",
+        MILLI_PREC => "MILLISECOND"}
+
+      #Minimun values that precisioned fields get set to
+      FIELD_MIN = { YEAR_PREC => 1,
+      MONTH_PREC => 1,
+      WEEK_PREC => 1,
+      DAY_PREC => 1,
+      HOUR_PREC => 0,
+      MIN_PREC => 0,
+      SEC_PREC => 0,
+      MILLI_PREC => 0}
+
+      def Precision.year
+        new(YEAR_PREC)
+      end
+
+      def Precision.month
+        new(MONTH_PREC)
+      end
+
+      def Precision.week
+        new(WEEK_PREC)
+      end 
+      
+      def Precision.day
+        new(DAY_PREC)
+      end
+
+      def Precision.hour
+        new(HOUR_PREC)
+      end
+
+      def Precision.min
+        new(MIN_PREC)
+      end
+
+      def Precision.sec
+        new(SEC_PREC)
+      end
+
+      def Precision.millisec
+        new(MILLI_PREC)
+      end
+
+      def min_value()
+        FIELD_MIN[@precision]
+      end
+
+      def initialize(prec)
+        @precision = prec
+      end
+
+      def <=>(other)
+        self.precision <=> other.precision
+      end
+
+      def ===(other)
+        self.precision == other.precision
+      end
+
+      def to_s
+        "DPrecision::#{self.label}"
+      end
+
+      def label
+        LABEL[@precision]
+      end
+  end
+
+  #Pseudo Singletons:
+  YEAR = Precision.year
+  MONTH = Precision.month
+  WEEK = Precision.week
+  DAY = Precision.day
+  HOUR = Precision.hour
+  MIN = Precision.min
+  SEC = Precision.sec
+  MILLI = Precision.millisec
+  DEFAULT=MIN
+
+  end
+
+end

data/lib/runt/expressionbuilder.rb

@@ -0,0 +1,65 @@
+require 'runt'
+
+# Convenience class for building temporal expressions in a more 
+# human-friendly way. Used in conjunction with shortcuts defined in the 
+# sugar.rb file, this allows one to create expressions like the following:
+#   
+#   b = ExpressionBuilder.new
+#   expr = b.define do
+#     occurs daily_8_30am_to_9_45am
+#     on tuesday
+#     possibly wednesday
+#   end
+#
+# This equivalent to:
+#
+#   expr = REDay.new(8,30,9,45) & DIWeek.new(Tuesday) | DIWeek.new(Wednesday)
+#
+# ExpressionBuilder creates expressions by evaluating a block passed to the 
+# :define method. From inside the block, methods :occurs, :on, :every, :possibly,
+# and :maybe can be called with a temporal expression which will be added to
+# a composite expression as follows:
+#
+# * <b>:on</b> - creates an "and" (&)
+# * <b>:possibly</b> - creates an "or" (|)  
+# * <b>:except</b> - creates a "not" (-)
+# * <b>:every</b> - alias for :on method
+# * <b>:occurs</b> - alias for :on method
+# * <b>:maybe</b> - alias for :possibly method 
+#  
+class ExpressionBuilder
+
+  include Runt
+
+  attr_accessor :ctx
+
+  def initialize
+    @ctx = nil
+  end
+
+  def define(&block)
+    instance_eval(&block)
+  end
+  
+  def on(expr)
+    add(expr, :&)
+  end
+
+  def add(expr, op)
+    @ctx ||= expr
+    @ctx = @ctx.send(op, expr) unless @ctx == expr
+    @ctx # explicit return, previous line may not execute
+  end
+
+  def except(expr)
+    add(expr, :-)
+  end
+  
+  def possibly(expr)
+    add(expr, :|)
+  end
+
+  alias_method :every, :on
+  alias_method :occurs, :on
+  alias_method :maybe, :possibly
+end

data/lib/runt/pdate.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/env ruby
+
+require 'date'
+require 'runt'
+
+
+module Runt
+
+
+  # :title:PDate
+  # == PDate
+  # Date and DateTime with explicit precision.
+  #
+  # Based the <tt>pattern</tt>[http://martinfowler.com/ap2/timePoint.html] by Martin Fowler.
+  #
+  #
+  # Author:: Matthew Lipper
+  class PDate < DateTime
+    include DPrecision
+
+    attr_accessor :date_precision
+    
+    class << self
+      alias_method :old_civil, :civil
+
+      def civil(*args)
+	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
+      end
+    end
+
+    class << self; alias_method :new, :civil end
+
+    def include?(expr)
+      eql?(expr)
+    end
+
+    def + (n)
+      raise TypeError, 'expected numeric' unless n.kind_of?(Numeric)
+      case @date_precision
+      when YEAR then
+	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)
+      when WEEK then
+	return new_self_plus(n*7)	
+      when DAY then
+	return new_self_plus(n)
+      when HOUR then
+	return new_self_plus(n){ |n| n = (n*(1.to_r/24) ) }
+      when MIN then
+	return new_self_plus(n){ |n| n = (n*(1.to_r/1440) ) }
+      when SEC then
+	return new_self_plus(n){ |n| n = (n*(1.to_r/86400) ) }
+      when MILLI then
+	return self
+    end
+  end
+
+  def - (x)
+    case x
+      when Numeric then
+	return self+(-x)
+      #FIXME!!
+      when Date;    return @ajd - x.ajd
+    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)
+    end
+    #puts "#{self.to_s}<=>#{other.to_s} => #{result}" if $DEBUG
+    result
+  end
+
+  def new_self_plus(n)
+    if(block_given?)
+      n=yield(n)
+    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)
+    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.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.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.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.default(*args)
+    PDate.civil(DEFAULT, *args)
+  end
+
+  #
+  # Custom dump which preserves DatePrecision   
+  # 
+  # Author:: Jodi Showers
+  #
+  def marshal_dump
+    [date_precision, ajd, start, offset]
+  end
+
+  #
+  # Custom load which preserves DatePrecision   
+  # 
+  # Author:: Jodi Showers
+  #
+  def marshal_load(dumped_obj)
+    @date_precision, @ajd, @sg, @of=dumped_obj
+  end
+  
+end
+end