runt19 0.7.6

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/TODO

@@ -0,0 +1,13 @@
+= Runt - Ruby Temporal Expressions -- To Do List
+
+Send suggestions, questions, threats, etc. for this list to Matt[mailto:mlipper@gmail.com]
+
+=== To Do
+
+* WIMonth#dates behaves unintuitively (see dates mixin tests)
+
+* DayIntervalTE matches date multiples prior to start date (see tests)
+
+* Better docs, examples, tutorials
+
+* Laundry

data/examples/payment_report.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/ruby
+
+require 'runt'
+
+class Report
+  
+  attr_reader :schedule
+
+  def initialize(schedule)
+    @schedule = schedule
+  end
+  def list(range)
+    result = {}
+    range.each do |dt|
+      events = @schedule.events(dt)
+      result[dt]=events unless events.empty?
+    end
+    result
+  end
+end
+
+class Payment < Runt::Event
+  attr_accessor :amount
+  def initialize(id, amount)
+    super(id)
+    @amount = amount
+  end
+end
+
+
+if __FILE__ == $0
+
+  include Runt
+
+  schedule = Schedule.new
+
+  # Gas payment on the first Wednesday of every month
+  gas_payment = Payment.new("Gas", 234)
+  gas_expr = DIMonth.new(First, Wednesday)
+  schedule.add(gas_payment, gas_expr)
+
+  # Insurance payment every year on January 7th
+  insurance_payment = Payment.new("Insurance", 345)
+  insurance_expr = REYear.new(1, 7, 1, 7)
+  schedule.add(insurance_payment, insurance_expr)
+  
+  # Run a report
+  report = Report.new(schedule)
+  result = report.list(PDate.day(2008, 1, 1)..PDate.day(2008,1,31))
+  result.keys.sort.each do |dt|
+    unless result[dt].empty? then
+      print "#{dt.ctime} - "
+      result[dt].each do |event|
+	puts "#{event.id}, $#{event.amount}"
+      end
+    end
+  end
+
+end

data/examples/payment_reporttest.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/ruby
+
+require 'test/unit'
+require 'runt'
+require 'payment_report'
+
+class ReportTest < Test::Unit::TestCase
+
+  include Runt
+
+  def setup
+    @schedule = Schedule.new
+
+    # Gas payment on the first Wednesday of every month
+    @gas_payment = Payment.new("Gas", 234)
+    @gas_expr = DIMonth.new(First, Wednesday)
+    @schedule.add(@gas_payment, @gas_expr)
+
+    # Insurance payment every year on January 7th
+    @insurance_payment = Payment.new("Insurance", 345)
+    @insurance_expr = REYear.new(1, 7, 1, 7)
+    @schedule.add(@insurance_payment, @insurance_expr)
+    @report = Report.new(@schedule)
+  end
+  def test_initialize
+    assert_equal @schedule, @report.schedule
+  end
+  def test_list
+    range = PDate.day(2008, 1, 1)..PDate.day(2008,1,31)
+    result = @report.list(range) 
+    assert_equal(2, result.size)
+    assert_equal(@gas_payment, result[PDate.day(2008, 1, 2)][0])
+    assert_equal(@insurance_payment, result[PDate.day(2008, 1, 7)][0])
+  end
+end
+
+class PaymentTest < Test::Unit::TestCase
+
+  include Runt
+
+  def test_initialize
+    p = Payment.new "Foo", 12
+    assert_equal "Foo", p.id
+    assert_equal 12, p.amount
+  end
+
+end
+
+

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

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.rb

@@ -0,0 +1,249 @@
+#!/usr/bin/env ruby
+
+# :title:Runt -- Ruby Temporal Expressions
+#
+# == Runt -- Ruby Temporal Expressions
+#
+# The usage and design patterns expressed in this library are mostly...*uhm*..
+# <em>entirely</em>..*cough*...based on a series of
+# <tt>articles</tt>[http://www.martinfowler.com] by Martin Fowler.
+#
+# It highly recommended that anyone using Runt (or writing
+# object-oriented software :) take a moment to peruse the wealth of useful info
+# that Fowler has made publicly available:
+#
+# * An excellent introductory summation of temporal <tt>patterns</tt>[http://martinfowler.com/ap2/timeNarrative.html]
+# * Recurring event <tt>pattern</tt>[http://martinfowler.com/apsupp/recurring.pdf]
+#
+# Also, for those of you (like me, for example) still chained in your cubicle and forced
+# to write <tt>Java</tt>[http://java.sun.com] code, check out the original version of
+# project called <tt>ChronicJ</tt>[http://chronicj.org].
+#
+# ---
+# Author::    Matthew Lipper (mailto:mlipper@gmail.com)
+# Copyright:: Copyright (c) 2004 Digital Clash, LLC
+# 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.
+
+require 'yaml'
+require 'time'
+require 'date'
+require 'date/format'
+require "runt/version"
+require "runt/dprecision"
+require "runt/pdate"
+require "runt/temporalexpression"
+require "runt/schedule"
+require "runt/daterange"
+require "runt/sugar"
+require "runt/expressionbuilder"
+
+#
+# The Runt module is the main namespace for all Runt modules and classes. Using
+# require statements, it makes the entire Runt library available.It also
+# defines some new constants and exposes some already defined in the standard
+# library classes <tt>Date</tt> and <tt>DateTime</tt>.
+#
+# <b>See also</b> runt/sugar_rb which re-opens this module and adds 
+# some additional functionality
+#
+# <b>See also</b> date.rb
+#
+module Runt
+  class << self
+    
+    def day_name(number)
+      Date::DAYNAMES[number]
+    end
+    
+    def month_name(number)
+      Date::MONTHNAMES[number]
+    end
+
+    def format_time(date)
+      date.strftime('%I:%M%p')
+    end
+
+    def format_date(date)
+      date.ctime
+    end
+    
+    #
+    # Cut and pasted from activesupport-1.2.5/lib/inflector.rb
+    #
+    def ordinalize(number)
+      if (number.to_i==-1)
+	'last'
+      elsif (number.to_i==-2)
+	'second to last'  
+      elsif (11..13).include?(number.to_i % 100)
+	"#{number}th"
+      else
+	case number.to_i%10
+	  when 1 then "#{number}st"
+	  when 2 then "#{number}nd"
+	  when 3 then "#{number}rd"
+	  else    "#{number}th"
+	end
+      end
+    end
+
+  end
+  
+  #Yes it's true, I'm a big idiot!
+  Sunday = Date::DAYNAMES.index("Sunday")
+  Monday = Date::DAYNAMES.index("Monday")
+  Tuesday = Date::DAYNAMES.index("Tuesday")
+  Wednesday = Date::DAYNAMES.index("Wednesday")
+  Thursday = Date::DAYNAMES.index("Thursday")
+  Friday = Date::DAYNAMES.index("Friday")
+  Saturday = Date::DAYNAMES.index("Saturday")
+  Sun = Date::ABBR_DAYNAMES.index("Sun")
+  Mon = Date::ABBR_DAYNAMES.index("Mon")
+  Tue = Date::ABBR_DAYNAMES.index("Tue")
+  Wed = Date::ABBR_DAYNAMES.index("Wed")
+  Thu = Date::ABBR_DAYNAMES.index("Thu")
+  Fri = Date::ABBR_DAYNAMES.index("Fri")
+  Sat = Date::ABBR_DAYNAMES.index("Sat")
+  January = Date::MONTHNAMES.index("January")
+  February = Date::MONTHNAMES.index("February")
+  March = Date::MONTHNAMES.index("March")
+  April = Date::MONTHNAMES.index("April")
+  May = Date::MONTHNAMES.index("May")
+  June = Date::MONTHNAMES.index("June")
+  July = Date::MONTHNAMES.index("July")
+  August = Date::MONTHNAMES.index("August")
+  September = Date::MONTHNAMES.index("September")
+  October = Date::MONTHNAMES.index("October")
+  November = Date::MONTHNAMES.index("November")
+  December = Date::MONTHNAMES.index("December")
+  First = 1
+  Second = 2
+  Third = 3
+  Fourth = 4
+  Fifth = 5
+  Sixth = 6
+  Seventh = 7
+  Eighth = 8
+  Eigth = 8  # Will be removed in v0.9.0
+  Ninth = 9
+  Tenth = 10
+
+  private
+  class ApplyLast #:nodoc:
+    def initialize
+      @negate=Proc.new{|n| n*-1}
+    end
+    def [](arg)
+      @negate.call(arg)
+    end
+  end
+  LastProc = ApplyLast.new
+
+  public
+  Last = LastProc[First]
+  Last_of = LastProc[First]
+  Second_to_last = LastProc[Second]
+
+end
+
+#
+# Add precision +Runt::DPrecision+ to standard library classes Date and DateTime 
+# (which is a subclass of Date). Also, add an inlcude? method for interoperability
+# with +Runt::TExpr+ classes
+#
+class Date
+
+  include Runt
+
+  attr_accessor :date_precision
+  alias_method :precision, :date_precision
+  def include?(expr)
+    eql?(expr)
+  end
+
+  def date_precision
+    return @date_precision unless @date_precision.nil? 
+    return Runt::DPrecision::DEFAULT 
+  end 	  
+end
+
+#
+# Add the ability to use Time class 
+#
+# Contributed by Paul Wright
+#
+class Time
+  
+  include Runt
+
+  attr_accessor :date_precision
+  alias_method :old_initialize, :initialize
+  alias_method :precision, :date_precision
+
+  def initialize(*args)
+    if(args[0].instance_of?(Runt::DPrecision::Precision))
+      @precision=args.shift
+    else
+      @precision=Runt::DPrecision::DEFAULT
+    end
+    old_initialize(*args)
+  end
+  
+  alias :old_to_yaml :to_yaml
+  def to_yaml(options)
+    if self.instance_variables.empty?
+      self.old_to_yaml(options)
+    else
+      Time.old_parse(self.to_s).old_to_yaml(options)
+    end
+  end
+
+  class << self
+    alias_method :old_parse, :parse
+    def parse(*args)
+      precision=Runt::DPrecision::DEFAULT
+      if(args[0].instance_of?(Runt::DPrecision::Precision))
+        precision=args.shift
+      end
+      _parse=old_parse(*args)
+      _parse.date_precision=precision
+      _parse
+    end
+  end
+
+  def date_precision
+    return @date_precision unless @date_precision.nil?
+    return Runt::DPrecision::DEFAULT
+  end
+end
+
+#
+# Useful shortcuts!
+#
+# Contributed by Ara T. Howard who is pretty sure he got the idea from 
+# somewhere else. :-)
+#
+class Numeric #:nodoc:
+  def microseconds() Float(self  * (10 ** -6)) end unless self.instance_methods.include?('microseconds')
+  def milliseconds() Float(self  * (10 ** -3)) end unless self.instance_methods.include?('milliseconds')
+  def seconds() self end unless self.instance_methods.include?('seconds')
+  def minutes() 60 * seconds end unless self.instance_methods.include?('minutes')
+  def hours() 60 * minutes end unless self.instance_methods.include?('hours')
+  def days() 24 * hours end unless self.instance_methods.include?('days')
+  def weeks() 7 * days end unless self.instance_methods.include?('weeks')
+  def months() 30 * days end unless self.instance_methods.include?('months')
+  def years() 365 * days end unless self.instance_methods.include?('years')
+  def decades() 10 * years end unless self.instance_methods.include?('decades')
+  # This causes RDoc to hurl:  
+  %w[
+  microseconds milliseconds seconds minutes hours days weeks months years decades
+  ].each{|m| alias_method m.chop, m}
+end
+