tempr 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+scratch
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/README.markdown

@@ -0,0 +1,5 @@
+# Tempr
+## a Ruby temporal expressions library
+
+
+This is a work in progress. See date_time_range.rb for usage examples.

data/lib/tempr.rb

@@ -0,0 +1,2 @@
+require File.expand_path('tempr/version', File.dirname(__FILE__))
+require File.expand_path('tempr/date_time_range', File.dirname(__FILE__))

data/lib/tempr/date_time_range.rb

@@ -0,0 +1,600 @@
+require 'date'
+require 'time'
+
+module Tempr
+
+  # Extensions for date or time ranges (or range-like objects)
+  # To generate subranges from chainable rules
+  #
+  # For example, 
+  #
+  # To generate a recurring hourly appointment at 2pm on the third Thursdays of each month in 2012:
+  #
+  #     range = (Date.civil(2012,1,1)...Date.civil(2013,1,1)).extend(Tempr::DateTimeRange)
+  #     subrange = range.each_month.thursday(2).at_time('2:00pm',60*60)
+  #
+  # This gives you an enumerable you can iterate over:
+  #
+  #     pp subrange.to_a
+  #     #=>  [ 2012-01-19 14:00:00 -0500...2012-01-19 15:00:00 -0500,
+  #            2012-02-16 14:00:00 -0500...2012-02-16 15:00:00 -0500,
+  #            2012-03-15 14:00:00 -0400...2012-03-15 15:00:00 -0400,
+  #            2012-04-19 14:00:00 -0400...2012-04-19 15:00:00 -0400,
+  #            2012-05-17 14:00:00 -0400...2012-05-17 15:00:00 -0400,
+  #            2012-06-21 14:00:00 -0400...2012-06-21 15:00:00 -0400,
+  #            2012-07-19 14:00:00 -0400...2012-07-19 15:00:00 -0400,
+  #            2012-08-16 14:00:00 -0400...2012-08-16 15:00:00 -0400,
+  #            2012-09-20 14:00:00 -0400...2012-09-20 15:00:00 -0400,
+  #            2012-10-18 14:00:00 -0400...2012-10-18 15:00:00 -0400,
+  #            2012-11-15 14:00:00 -0500...2012-11-15 15:00:00 -0500,
+  #            2012-12-20 14:00:00 -0500...2012-12-20 15:00:00 -0500  ]
+  #
+  # Or check for inclusion of a date/time:
+  #
+  #     subrange.any? {|r| r.cover?(Time.parse("2012-05-17 2:30pm")) }
+  #
+  # Note that the order of the chained rules is important, they must be defined
+  # from the widest to the narrowest date/time range.
+  #
+  # During iteration, each rule is applied on the array of ranges defined by the
+  # previous rule.
+  #
+  # The methods are roughly divided into methods for generating recurring subranges (e.g., "each_month"),
+  # and methods for finding a single subrange, by offset (e.g., "wednesday(1)" for the second wednesday)
+  #
+  # In both cases, an enumerable is returned so that you can continue to chain rules together.
+  #   
+  module DateTimeRange
+
+    # day of week shortcuts - as methods so accessible to mixin target classes
+    # Note probably should change this so it copies constants over in extend_object or something
+    def Sunday    ; Date::DAYNAMES.index("Sunday");    end
+    def Monday    ; Date::DAYNAMES.index("Monday");    end
+    def Tuesday   ; Date::DAYNAMES.index("Tuesday");   end
+    def Wednesday ; Date::DAYNAMES.index("Wednesday"); end
+    def Thursday  ; Date::DAYNAMES.index("Thursday");  end
+    def Friday    ; Date::DAYNAMES.index("Friday");    end
+    def Saturday  ; Date::DAYNAMES.index("Saturday");  end
+    def Sun ; self.Sunday;    end
+    def Mon ; self.Monday;    end
+    def Tue ; self.Tuesday;   end
+    def Wed ; self.Wednesday; end
+    def Thu ; self.Thursday;  end
+    def Fri ; self.Friday;    end
+    def Sat ; self.Saturday;  end
+
+    def WEEKDAYS; [self.Mon, self.Tue, self.Wed, self.Thu, self.Fri]; end
+    def WEEKENDS; [self.Sat, self.Sun]; end
+    
+    # month shortcuts - as methods so accessible to mixin target classes
+    
+    def January   ; Date::MONTHNAMES.index("January");   end
+    def February  ; Date::MONTHNAMES.index("February");  end
+    def March     ; Date::MONTHNAMES.index("March");     end
+    def April     ; Date::MONTHNAMES.index("April");     end
+    def May       ; Date::MONTHNAMES.index("May");       end
+    def June      ; Date::MONTHNAMES.index("June");      end
+    def July      ; Date::MONTHNAMES.index("July");      end
+    def August    ; Date::MONTHNAMES.index("August");    end
+    def September ; Date::MONTHNAMES.index("September"); end
+    def October   ; Date::MONTHNAMES.index("October");   end
+    def November  ; Date::MONTHNAMES.index("November");  end
+    def December  ; Date::MONTHNAMES.index("December");  end
+    def Jan ; self.January;   end
+    def Feb ; self.February;  end
+    def Mar ; self.March;     end
+    def Apr ; self.April;     end
+    def Jun ; self.June;      end
+    def Jul ; self.July;      end
+    def Aug ; self.August;    end
+    def Sep ; self.September; end
+    def Oct ; self.October;   end
+    def Nov ; self.November;  end
+    def Dec ; self.December;  end
+    
+    # ---
+    
+    # seconds iterator:
+    #   "every +n+ seconds, starting at +offset+, grouped into +dur+ second intervals"
+    #
+    # if no parameters passed,
+    #   "every second of range grouped into one-second intervals"
+    def each_seconds(n=1, offset=0, dur=1)
+      build_subrange do |s|
+        s.step    = n
+        s.adjust_range { |r| time_range(r) }
+        s.offset       { |tm|   tm.to_time + offset }
+        s.increment    { |tm,i| tm.to_time + i }
+        s.span         { |tm| tm.to_time + dur }
+      end
+    end
+    alias each_second each_seconds
+    
+    def second(offset=0); each_seconds(1,offset).limit_to(1); end
+    
+    # minutes iterator:
+    # "every +n+ minutes, starting at +offset+ minutes, +dur+ minute intervals"
+    #
+    # if no parameters passed,
+    #   "every minute of range grouped into one-minute intervals"
+    def each_minutes(n=1, offset=0, dur=1)
+      each_seconds(n*60, offset*60, dur*60)
+    end
+    alias each_minute each_minutes
+    
+    def minute(offset=0); each_minutes(1,offset).limit_to(1); end
+    
+    # hours iterator:
+    # "every +n+ hours, starting at +offset+ hours, +dur+ hour intervals"
+    #
+    # if no parameters passed,
+    #   "every hour of range grouped into one-hour intervals"
+    def each_hours(n=1, offset=0, dur=1)
+      each_seconds(n*60*60, offset*60*60, dur*60*60)
+    end
+    alias each_hour each_hours
+    
+    def hour(offset=0); each_hours(1,offset).limit_to(1); end
+    
+    # days iterator:
+    # "every +n+ days, starting at +offset+ days, +dur+ day intervals"
+    #
+    # if no parameters passed,
+    #   "every day of range grouped into one-day intervals"
+    def each_days(n=1,offset=0,dur=1)
+      build_subrange do |s|
+        s.step    = n
+        s.adjust_range  { |r| day_range(r) }
+        s.offset        { |dt|   dt.to_date + offset }
+        s.increment     { |dt,i| dt.to_date + i }
+        s.span          { |dt| dt.to_date + dur }
+      end
+    end
+    alias each_day each_days
+    
+    def day(offset=0); each_day(1,offset).limit_to(1); end
+    
+    # weeks iterator:
+    # "every +n+ weeks, starting at +offset+ weeks, +dur+ week intervals"
+    #
+    # if no parameters passed,
+    #   "every week of range grouped into one-week intervals"
+    def each_weeks(n=1, offset=0, dur=1)
+      each_days(n*7, offset*7, dur*7)
+    end
+    alias each_week each_weeks
+    
+    def week(offset=0); each_weeks(1,offset).limit_to(1); end
+    
+    # single day-of-week iterator:
+    # "every +n+th weekday +wd+, starting at +offset+ weeks, +dur+ day intervals"
+    #
+    # +wd+ is required. Typically, `each_sunday`, `each_monday` called instead.
+    #
+    # if no other parameters passed,
+    #   "every weekday +wd+ of range grouped into one-day intervals"
+    def each_wdays(wd,n=1,offset=0,dur=1)
+      build_subrange do |s|
+        s.step    = n
+        s.adjust_range  { |r| day_range(r) }
+        s.offset        { |dt|   dt.to_date + (wd - dt.to_date.wday)%7 + offset*7 }
+        s.increment     { |dt,i| dt.to_date + i*7 }
+        s.span          { |dt| dt.to_date + dur }
+      end
+    end
+    alias each_wday each_wdays
+              
+    # "every +n+th Sunday, starting at +offset+ weeks, +dur+ day intervals"
+    def each_sunday(   n=1, offset=0, dur=1); each_wdays(self.Sun,n,offset,dur); end
+
+    # "every +n+th Monday, starting at +offset+ weeks, +dur+ day intervals"
+    def each_monday(   n=1, offset=0, dur=1); each_wdays(self.Mon,n,offset,dur); end
+
+    # "every +n+th Tuesday, starting at +offset+ weeks, +dur+ day intervals"
+    def each_tuesday(  n=1, offset=0, dur=1); each_wdays(self.Tue,n,offset,dur); end
+
+    # "every +n+th Wednesday, starting at +offset+ weeks, +dur+ day intervals"
+    def each_wednesday(n=1, offset=0, dur=1); each_wdays(self.Wed,n,offset,dur); end
+
+    # "every +n+th Thursday, starting at +offset+ weeks, +dur+ day intervals"
+    def each_thursday( n=1, offset=0, dur=1); each_wdays(self.Thu,n,offset,dur); end
+
+    # "every +n+th Friday, starting at +offset+ weeks, +dur+ day intervals"
+    def each_friday(   n=1, offset=0, dur=1); each_wdays(self.Fri,n,offset,dur); end
+
+    # "every +n+th Saturday, starting at +offset+ weeks, +dur+ day intervals"
+    def each_saturday( n=1, offset=0, dur=1); each_wdays(self.Sat,n,offset,dur); end
+    
+    
+    def wday(wd,offset=0)
+      each_wdays(wd,1,offset).limit_to(1)
+    end
+    
+    def sunday(offset=0);    wday(self.Sun,offset); end
+    def monday(offset=0);    wday(self.Mon,offset); end
+    def tuesday(offset=0);   wday(self.Tue,offset); end
+    def wednesday(offset=0); wday(self.Wed,offset); end
+    def thursday(offset=0);  wday(self.Thu,offset); end
+    def friday(offset=0);    wday(self.Fri,offset); end
+    def saturday(offset=0);  wday(self.Sat,offset); end
+    
+    # multiple day-of-week iterator:
+    # "every days of the week +wdays+"
+    #
+    # For example, 
+    #     `range.each_days_of_week(range.Tue, range.Thu)`
+    #     # "every Tuesday and Thursday in range"
+    #
+    # if no parameter passed, identical to each_days
+    def each_days_of_week(*wdays)
+      if wdays.empty?
+        each_days
+      else
+        each_days.except {|dt| !wdays.include?(dt.wday) }
+      end
+    end
+    alias each_day_of_week each_days_of_week
+    
+    # every weekday
+    def each_weekdays
+      each_days_of_week(*self.WEEKDAYS)
+    end
+    alias each_weekday each_weekdays
+    
+    # every weekend (Saturday and Sunday)
+    def each_weekends
+      each_days_of_week(*self.WEEKENDS)
+    end
+    alias each_weekend each_weekends
+    
+    # every Friday, Saturday, and Sunday
+    def each_weekends_including_friday
+      each_days_of_week(*([self.Fri] + self.WEEKENDS))
+    end
+    alias each_weekend_including_friday each_weekends_including_friday
+    
+    
+    # month iterator:
+    # "every +n+ months, starting at +offset+ months, +dur+ month intervals"
+    #
+    # if no parameters passed,
+    #   "every month of range grouped into one-month intervals"
+    def each_months(n=1,offset=0,dur=1)
+      build_subrange do |s|
+        s.step    = n
+        s.adjust_range { |r| day_range(r) }
+        s.offset       { |dt|   dt.to_date >> offset }
+        s.increment    { |dt,i| dt.to_date >> i }
+        s.span         { |dt| dt.to_date >> dur }
+      end
+    end
+    alias each_month each_months
+    
+    def month(offset=0); each_months(1,offset).limit_to(1); end
+
+    # month-of-year iterator:
+    # "every +n+th month +nmonth+ grouped into one-month intervals"
+    #
+    # +nmonth+ is required. Typically, `each_january`, etc. called instead.
+    #
+    # if +n+ parameter not passed,
+    #   "every month number +nmonth+ of range grouped into one-month intervals"
+    def each_monthnum(nmonth,n=1)
+      build_subrange do |s|
+        s.step   = n
+        s.adjust_range { |r| day_range(r) }
+        s.offset       { |dt| dt >> (nmonth - dt.month)%12 }
+        s.increment    { |dt,i| dt.to_date >> i*12 }      
+        s.span         { |dt| dt.to_date >> 1 }
+      end
+    end
+    
+    # "every +n+th January, grouped into one-month intervals"
+    def each_january(  n=1); each_monthnum(self.Jan,n); end
+
+    # "every +n+th February, grouped into one-month intervals"
+    def each_february( n=1); each_monthnum(self.Feb,n); end
+
+    # "every +n+th Mary, grouped into one-month intervals"
+    def each_march(    n=1); each_monthnum(self.Mar,n); end
+
+    # "every +n+th April, grouped into one-month intervals"
+    def each_april(    n=1); each_monthnum(self.Apr,n); end
+
+    # "every +n+th May, grouped into one-month intervals"
+    def each_may(      n=1); each_monthnum(self.May,n); end
+
+    # "every +n+th June, grouped into one-month intervals"
+    def each_june(     n=1); each_monthnum(self.Jun,n); end
+
+    # "every +n+th July, grouped into one-month intervals"
+    def each_july(     n=1); each_monthnum(self.Jul,n); end
+
+    # "every +n+th August, grouped into one-month intervals"
+    def each_august(   n=1); each_monthnum(self.Aug,n); end
+
+    # "every +n+th September, grouped into one-month intervals"
+    def each_september(n=1); each_monthnum(self.Sep,n); end
+
+    # "every +n+th October, grouped into one-month intervals"
+    def each_october(  n=1); each_monthnum(self.Oct,n); end
+
+    # "every +n+th November, grouped into one-month intervals"
+    def each_november( n=1); each_monthnum(self.Nov,n); end
+
+    # "every +n+th December, grouped into one-month intervals"
+    def each_december( n=1); each_monthnum(self.Dec,n); end
+    
+    
+    # year iterator:
+    # "every +n+ years, starting at +offset+ years, +dur+ year intervals"
+    #
+    # if no parameters passed,
+    #   "every year of range grouped into one-year intervals"
+    def each_years(n=1,offset=0,dur=1)
+      build_subrange do |s|
+        s.step    = n
+        s.adjust_range { |r| day_range(r) }
+        s.offset       { |dt|   Date.civil(dt.year + offset, dt.month, dt.day) }
+        s.increment    { |dt,i| Date.civil(dt.year + i,      dt.month, dt.day) }
+        s.span         { |dt|   Date.civil(dt.year + dur, dt.month, dt.day) }
+      end 
+    end
+    alias each_year each_years
+    
+    def year(offset=0); each_year(1,offset).limit_to(1); end
+    
+    # ---
+    
+    # day-of-month iterator:
+    # "every +nday+th day of the month, grouped into +dur+ day intervals"
+    #
+    # +nday+ is required.
+    #
+    # if no +dur+ parameter passed,
+    #   "every +nday+th day of the month, grouped into one-day intervals"
+    def on_day(nday,dur=1)
+      build_subrange do |s|
+        s.step   = 1
+        s.adjust_range   { |r| day_range(r) }
+        s.offset         do |dt| 
+                              totdays = ((Date.civil(dt.year,dt.month,1) >> 1)-1).day
+                              dt.to_date + (nday - dt.day)%totdays
+                         end
+        s.increment      { |dt,i| dt.to_date >> i }
+        s.span           { |dt| dt.to_date + dur  }
+      end
+    end
+    
+    # time-of-day iterator:
+    # "every day at +tm+, grouped into +dur+ second intervals"
+    #
+    # +tm+ is any string that can be Time.parse'd. Note the date portion is ignored, if given.
+    #
+    # if no +dur+ parameter passed, intervals are 'instantaneous' time ranges
+    def at_time(tm,dur=0)
+      tm_p = Time.parse(tm)
+      build_subrange do |s|
+        s.step    = 60*60*24
+        s.adjust_range    { |r| time_range(r) }        
+        s.offset          do |tm| 
+                               Time.new( 
+                                 tm.year,   tm.month, tm.day,
+                                 tm_p.hour, tm_p.min, tm_p.sec, (tm + s.step).utc_offset
+                               )
+                          end
+        s.increment       { |tm,i| tm.to_time + i }
+        s.span            { |tm| tm.to_time + dur }
+      end
+    end
+      
+    # ---
+    
+    # Helper methods - these are a bit hacky and possibly buggy.
+    # Used in iterator `adjust_range` procs to ensure the right data type
+    # before iterating
+    
+    # convert to date range
+    # and make exclusive if not already
+    # For example,
+    #
+    #   `2012-02-01..2012-02-29`   becomes
+    #   `2012-02-01...2012-03-01`
+    #
+    # while
+    #
+    #   `2012-02-01...2012-02-29`  is unmodified.
+    #
+    def day_range(rng=self)
+      if rng.respond_to?(:exclude_end?) && rng.exclude_end?
+        Range.new(rng.begin.to_date, rng.end.to_date, true)
+      else
+        Range.new(rng.begin.to_date, rng.end.to_date + 1, true)
+      end
+    end
+    
+    # unless already a time range,
+    # convert to exclusive date range, and then to time range
+    # For example,
+    #
+    #   `2012-02-01..2012-02-29`   becomes
+    #   `2012-02-01 00:00:00 UTC...2012-03-01 00:00:00 UTC`
+    #
+    def time_range(rng=self)
+      if rng.begin.respond_to?(:sec) && rng.end.respond_to?(:sec)
+        rng.dup
+      else
+        adj_rng = day_range(rng)
+        Range.new(adj_rng.begin.to_time, adj_rng.end.to_time, true)
+      end
+    end
+    
+    # convenience wrapper for SubRangeIterator.new(self) { ... }
+    def build_subrange(&builder)
+      SubRangeIterator.new(self, &builder)
+    end
+    
+    # ---
+    
+    # Iterators are defined by
+    #   
+    # - `range`:         base range (required)
+    # - `step`:          repetition length (default = 1)
+    # - `adjust_range`:  proc that adjusts base range before iteration (optional)
+    # - `offset`:        proc that adjusts start of adjusted range prior to iteration (optional)
+    # - `increment`:     proc that defines scale of each step (required)
+    # - `span`:          proc that defines duration of each returned subrange (required)
+    # - `except`:        proc(s) that don't yield subrange if true of current step date (but don't stop iteration)
+    # - `limit`:         stop iteration after self.limit steps (yields)
+    #
+    # TODO: 
+    # - `until`:    proc that stops iteration if true of current step date
+    #
+    # Note that SubRangeIterator is coupled to DateTimeRange since it itself includes DateTimeRange (for chaining);
+    # However, otherwise it could be used just as well on other (e.g. numeric) ranges
+    #
+    class SubRangeIterator
+      include Enumerable
+      include DateTimeRange
+      
+      attr_accessor :range, :step, :limit
+      def step;  @step ||= 1;   end
+      
+      # a bit hacky - used to extend concrete subranges
+      # with the same extensions as the range
+      def range_extensions
+        @range_extensions ||= 
+          class << self.range
+            self.included_modules - [Kernel]
+          end
+      end
+      
+      def initialize(range)
+        self.range = range
+        yield self if block_given?
+      end
+    
+      # note: useful for chaining instead of step=
+      def step_by(n)
+        self.step = n
+        self
+      end
+      
+      # note: useful for chaining instead of limit=
+      def limit_to(n)
+        self.limit = n
+        self
+      end
+      
+      def adjust_range(&p)
+        self.range_proc = p
+        self
+      end
+      
+      def offset(&p)
+        self.offset_proc = p
+        self
+      end
+      
+      def increment(&p)
+        self.step_proc = p
+        self
+      end
+      
+      def span(&p)
+        self.span_proc = p
+        self
+      end
+      
+      def except(&p)
+        exception_procs << p
+        self
+      end
+      
+      # Recursive madness...
+      # note this could possibly use cached results stored by #all method,
+      # similar to Sequel
+      def each(&b)
+        if self.range.respond_to?(:each_by_step)
+          self.range.each do |sub|
+            each_by_step(sub, &b)
+          end
+        else
+          each_by_step do |sub|
+  #          puts "self.range = #{self.range} yielded: #{sub}"
+            yield sub
+          end
+        end
+      end
+      
+      # Iteration
+      # 1. adjust base range
+      # 2. get offset
+      # 3. for each step,
+      #    3.1. if limit reached, break
+      #    3.2. find begin of next subrange (step_proc)
+      #    3.3. find end of next subrange (span_proc)
+      #    3.4. check if begin in adjusted base range, stop iteration if not
+      #    3.5. check if begin matches any exceptions (exception_procs)
+      #         3.5.1 if not, increment the yield count (i)
+      #         3.5.2 and yield the subrange, extended with same modules as base range
+      def each_by_step(rng=self.range)
+        rng = range_proc.call(rng)
+  #      puts "each_by_step range: #{rng}"
+        initial = offset_proc.call(rng.begin)
+        i=0
+        by_step(self.step).each do |n|
+          break if self.limit && self.limit <= i
+          next_begin = step_proc.call(initial,n)
+          next_end   = span_proc.call(next_begin)
+          if rng.respond_to?(:cover?) && !rng.cover?(next_begin) 
+            raise StopIteration
+          end
+          unless exception_procs.any? {|except| except.call(next_begin)}
+            i+=1
+            yield((next_begin...next_end).extend(*range_extensions))
+          end
+        end
+      end
+      
+      # 'stateless' step enumerator
+      # simply generates infinite integer sequence
+      # if ruby already has such a facility built-in, let me know
+      def by_step(n)
+        @step_enumerator ||= Enumerator.new do |y|
+          i=0
+          loop do
+            y << i; i+=n
+          end
+        end
+      end
+    
+      private
+      
+      attr_accessor :offset_proc, :step_proc, :span_proc, :range_proc
+      def range_proc
+        @range_proc ||= lambda {|r| r}
+      end
+      def offset_proc
+        @offset_proc ||= lambda {|dt| dt}
+      end
+      
+      def exception_procs; @exception_procs ||= []; end
+      
+    end
+    
+  end
+
+end
+
+
+if $0 == __FILE__
+
+  require 'pp'
+  
+   range = (Date.civil(2012,1,1)...Date.civil(2013,1,1)).extend(Tempr::DateTimeRange)
+   subrange = range.each_month.thursday(2).at_time('2:00pm',60*60)
+
+   pp subrange.to_a
+   
+end

data/lib/tempr/version.rb

@@ -0,0 +1,9 @@
+
+module Tempr
+  module Version
+    MAJOR  = 0
+    MINOR  = 1
+    TINY   = 0
+    STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
+  end
+end

data/test/at_time.rb

@@ -0,0 +1,36 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+module AtTimeTests
+  module Fixtures
+
+    BaseRanges = {:local => Time.parse('2012-01-01 00:00:00 -0500')...
+                            Time.parse('2013-01-01 00:00:00 -0500'),
+                  :utc   => Time.parse('2012-01-01 00:00:00 UTC')...
+                            Time.parse('2013-01-01 00:00:00 UTC')
+                 }
+                
+  end
+
+  describe 'DateTimeRange#at_time' do
+
+    [:local, :utc].each do |time_type|
+    
+      describe "across daylight savings time boundaries for #{time_type} times" do
+      
+        let(:subject) { Fixtures::BaseRanges[time_type].extend(Tempr::DateTimeRange) }
+        
+        it 'should be at the same time of day regardless of time zone' do
+          subject.each_day.at_time("2:00pm",60*60).each do |range|
+            offset = range.begin.utc_offset
+            actual = range.begin.getlocal(offset).hour
+            #puts "#{range}"
+            assert_equal 14, actual, "for range: #{range}"
+          end
+        end
+        
+      end
+      
+    end
+  end
+
+end  # namespace

data/test/suite.rb

@@ -0,0 +1,3 @@
+%w[ time_subrange at_time ].each do |test|
+  require File.expand_path(test,File.dirname(__FILE__))
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../lib/tempr', File.dirname(__FILE__))
+
+gem "minitest" 
+
+require 'minitest/spec'
+MiniTest::Unit.autorun

data/test/time_subrange.rb

@@ -0,0 +1,257 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+module TimeSubRangeTests
+  module Fixtures
+    
+    # 20 seconds / minutes / hours
+    BaseRanges = { :each_seconds => Time.parse('2012-02-13 15:32:41')...
+                                    Time.parse('2012-02-13 15:33:01'),
+                   :each_minutes => Time.parse('2012-02-13 13:46:25')...
+                                    Time.parse('2012-02-13 14:06:25'),
+                   :each_hours   => Time.parse('2012-02-13 12:52:22')...
+                                    Time.parse('2012-02-14 08:52:22')
+                 }
+    
+    ExclusiveDateRange    = Date.parse('2012-02-13')...Date.parse('2012-02-15')
+    NonExclusiveDateRange = Date.parse('2012-02-13')..Date.parse('2012-02-14')
+    
+    # note: I don't particularly like generating fixtures like this,
+    # but it's probably just as suceptible to error as hand-typing here
+    module Expected
+      
+      Default = { 
+        :each_seconds => 
+          (0..19).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_seconds].begin
+            memo << (s0+i...s0+i+1)
+          end,
+        :each_minutes => 
+          (0..19).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_minutes].begin
+            memo << (s0+i*60...s0+(i+1)*60)
+          end,
+        :each_hours   => 
+          (0..19).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_hours].begin
+            memo << (s0+i*60*60...s0+(i+1)*60*60)
+          end      
+      }
+      
+      Params3_0_1 = {
+        :each_seconds => 
+          (0..6).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_seconds].begin
+            memo << (s0+(i*3)...s0+(i*3)+1)
+          end,
+        :each_minutes => 
+          (0..6).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_minutes].begin
+            memo << (s0+(i*3)*60...s0+(i*3+1)*60)
+          end,
+        :each_hours   => 
+          (0..6).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_hours].begin
+            memo << (s0+(i*3)*60*60...s0+(i*3+1)*60*60)
+          end         
+      }
+
+      Params1_5_1 = {
+        :each_seconds => 
+          (0..14).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_seconds].begin+5
+            memo << (s0+i...s0+i+1)
+          end,
+        :each_minutes => 
+          (0..14).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_minutes].begin+5*60
+            memo << (s0+i*60...s0+(i+1)*60)
+          end,
+        :each_hours   => 
+          (0..14).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_hours].begin+5*60*60
+            memo << (s0+i*60*60...s0+(i+1)*60*60)
+          end      
+      }
+      
+      Params3_0_3 = {
+        :each_seconds => 
+          (0..6).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_seconds].begin
+            memo << (s0+(i*3)...s0+(i*3)+3)
+          end,
+        :each_minutes => 
+          (0..6).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_minutes].begin
+            memo << (s0+(i*3)*60...s0+(i*3+3)*60)
+          end,
+        :each_hours   => 
+          (0..6).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_hours].begin
+            memo << (s0+(i*3)*60*60...s0+(i*3+3)*60*60)
+          end         
+      }
+      
+      Params5_0_2 = {
+        :each_seconds => 
+          (0..3).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_seconds].begin
+            memo << (s0+(i*5)...s0+(i*5)+2)
+          end,
+        :each_minutes => 
+          (0..3).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_minutes].begin
+            memo << (s0+(i*5)*60...s0+(i*5+2)*60)
+          end,
+        :each_hours   => 
+          (0..3).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_hours].begin
+            memo << (s0+(i*5)*60*60...s0+(i*5+2)*60*60)
+          end         
+      }
+
+      Params1_0_3 = { 
+        :each_seconds => 
+          (0..19).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_seconds].begin
+            memo << (s0+i...s0+i+3)
+          end,
+        :each_minutes => 
+          (0..19).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_minutes].begin
+            memo << (s0+i*60...s0+(i+3)*60)
+          end,
+        :each_hours   => 
+          (0..19).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_hours].begin
+            memo << (s0+i*60*60...s0+(i+3)*60*60)
+          end      
+      }
+      
+      Params7_1_3 = {
+        :each_seconds => 
+          (0..2).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_seconds].begin+1
+            memo << (s0+(i*7)...s0+(i*7)+3)
+          end,
+        :each_minutes => 
+          (0..2).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_minutes].begin+1*60
+            memo << (s0+(i*7)*60...s0+(i*7+3)*60)
+          end,
+        :each_hours   => 
+          (0..2).inject([]) do |memo, i|
+            s0 = BaseRanges[:each_hours].begin+1*60*60
+            memo << (s0+(i*7)*60*60...s0+(i*7+3)*60*60)
+          end         
+      }
+      
+    end
+    
+  end
+
+  # ---
+
+  describe 'DateTimeRange, single time iterators' do
+    
+    [:each_seconds, :each_minutes, :each_hours].each do |meth|
+      describe meth do
+        
+        let(:subject) { Fixtures::BaseRanges[meth].extend(Tempr::DateTimeRange) }
+        
+        it 'must exhibit default behavior if no parameters passed' do
+          results = subject.send(meth).to_a
+          assert_equal Fixtures::Expected::Default[meth], results
+        end
+        
+        it 'must iterate using passed step length' do
+          results = subject.send(meth,3).to_a
+          assert_equal Fixtures::Expected::Params3_0_1[meth], results
+        end
+        
+        it 'must iterate starting at passed offset' do
+          results = subject.send(meth,1,5).to_a
+          assert_equal Fixtures::Expected::Params1_5_1[meth], results
+        end
+        
+        it 'must return ranges of passed duration, duration == step' do
+          results = subject.send(meth,3,0,3).to_a
+          assert_equal Fixtures::Expected::Params3_0_3[meth], results
+        end
+        
+        it 'must return ranges of passed duration, duration < step' do
+          results = subject.send(meth,5,0,2).to_a
+          assert_equal Fixtures::Expected::Params5_0_2[meth], results
+        end
+        
+        it 'must return ranges of passed duration, duration > step' do
+          results = subject.send(meth,1,0,3).to_a
+          assert_equal Fixtures::Expected::Params1_0_3[meth], results
+        end
+
+        it 'must return ranges of passed step, offset, and duration' do
+          results = subject.send(meth,7,1,3).to_a
+          assert_equal Fixtures::Expected::Params7_1_3[meth], results
+        end
+        
+      end
+    
+    end
+    
+    describe "with exclusive date ranges" do
+      
+      let(:subject) { Fixtures::ExclusiveDateRange.extend(Tempr::DateTimeRange) }
+      
+      it 'each_seconds must return ranges starting up to 23:59:59 of the end date' do
+        last_result = subject.each_seconds.to_a.last
+        assert_equal ( (Fixtures::ExclusiveDateRange.end.to_time - 1)...
+                       Fixtures::ExclusiveDateRange.end.to_time ), 
+                     last_result
+      end
+
+      it 'each_minutes must return ranges starting up to 23:59:00 of the end date' do
+        last_result = subject.each_minutes.to_a.last
+        assert_equal ( (Fixtures::ExclusiveDateRange.end.to_time - 60)...
+                       Fixtures::ExclusiveDateRange.end.to_time ), 
+                     last_result
+      end
+
+      it 'each_minutes must return ranges starting up to 23:00:00 of the end date' do
+        last_result = subject.each_hours.to_a.last
+        assert_equal ( (Fixtures::ExclusiveDateRange.end.to_time - 60*60)...
+                       Fixtures::ExclusiveDateRange.end.to_time ), 
+                     last_result
+      end
+      
+    end
+
+    describe "with non-exclusive date ranges" do
+      
+      let(:subject) { Fixtures::NonExclusiveDateRange.extend(Tempr::DateTimeRange) }
+      
+      it 'each_seconds must return ranges starting up to 23:59:59 of the end date + 1' do
+        last_result = subject.each_seconds.to_a.last
+        assert_equal ( ((Fixtures::NonExclusiveDateRange.end+1).to_time - 1)...
+                       (Fixtures::NonExclusiveDateRange.end+1).to_time ), 
+                     last_result
+      end
+
+      it 'each_minutes must return ranges starting up to 23:59:00 of the end date + 1' do
+        last_result = subject.each_minutes.to_a.last
+        assert_equal ( ((Fixtures::NonExclusiveDateRange.end+1).to_time - 60)...
+                       (Fixtures::NonExclusiveDateRange.end+1).to_time ), 
+                     last_result
+      end
+
+      it 'each_minutes must return ranges starting up to 23:00:00 of the end date + 1' do
+        last_result = subject.each_hours.to_a.last
+        assert_equal ( ((Fixtures::NonExclusiveDateRange.end+1).to_time - 60*60)...
+                       (Fixtures::NonExclusiveDateRange.end+1).to_time ), 
+                     last_result
+      end
+      
+    end
+      
+    
+  end
+
+end   # namespace

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: tempr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Eric Gjertsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-16 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &16129140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16129140
+description: ''
+email:
+- ericgj72@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- lib/tempr.rb
+- lib/tempr/date_time_range.rb
+- lib/tempr/version.rb
+- test/at_time.rb
+- test/suite.rb
+- test/test_helper.rb
+- test/time_subrange.rb
+homepage: http://github.com/ericgj/tempr
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: tempr
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: No-fussin' temporal expressions library
+test_files: []