days_and_times 1.0.1

data/History.txt

@@ -0,0 +1,7 @@
+== 1.0.1 2009-11-20
+
+* Published to gemcutter.
+
+== 1.0.0 2008-08-06
+
+* Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 BehindLogic
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/days_and_times.rb
+lib/days_and_times/duration.rb
+lib/days_and_times/numeric.rb
+lib/days_and_times/object.rb
+lib/days_and_times/time.rb
+spec/days_and_times/numeric_spec.rb
+spec/days_and_times_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,72 @@
+= days_and_times
+
+* Homepage: http://dcparker.github.com/days_and_times
+* Code: http://github.com/dcparker/days_and_times
+* Download: http://gemcutter.com/gems/days_and_times
+
+== DESCRIPTION:
+
+Natural language method chaining for Time, Durations and the like.
+
+== FEATURES:
+
+* Singular and plural of the concrete time units (second, minute, hour, day, week) are added to the Numeric object.
+* Use the Duration class to do lots of cool things.
+* Perform mathematical operations between numbers and durations, durations and durations, and durations and numbers, and the 'unit' will be respected as expected in the algebraic rules.
+* Iterate over Duration objects, by the time-unit the duration was instantiated with, or a unit of choice.
+* Durations can be 'anchored' to a begin or end time.
+
+== PROBLEMS:
+
+* Months are variable and do not lend themselves to concrete mathematics, so as of now they are not implemented.
+
+== SYNOPSIS:
+
+  1.day #=> A duration of 1 day
+  7.days #=> A duration of 7 days
+  1.week #=> A duration of 1 week
+  1.week - 2.days #=> A duration of 5 days
+  1.week.from(Now()) #=> The time of 1 week from this moment
+  1.week.from(Today()) #=> The time of 1 week from the beginning of today
+  3.minutes.ago.until(7.minutes.from(Now())) #=> duration 3 minutes ago to 7 minutes from now
+  3.minutes.ago.until(7.minutes.from(Now())) - 2.minutes #=> duration 3 minutes ago to 5 minutes from now
+  4.weeks.from(2.days.from(Now())).until(8.weeks.from(Yesterday())) #=> A duration, starting in 4 weeks and 2 days, and ending 8 weeks from yesterday
+  1.week - 1.second #=> A duration of 6 days, 23 hours, 59 minutes, and 59 seconds
+  4.weeks / 2 #=> A duration of 2 weeks
+  4.weeks / 2.weeks #=> The integer 2
+  8.weeks.each {|week| ...} #=> Runs code for each week contained in the duration (of 8 weeks)
+  8.weeks.starting(Now()).each {|week| ...} #=> Runs code for each week in the duration, but each week is also anchored to a starting time, in sequence through the duration.
+  1.week.each {|week| ...} #=> Automatically chooses week as its iterator
+  7.days.each {|day| ...} #=> Automatically chooses day as its iterator
+  1.week.each_day {|day| ...} #=> Forcing the week to iterate through days
+  1.week.each(10.hours) {|ten_hour_segment| ...} #=> Using a custom iterator of 10 hours. There would be 17 of them, but notice that the last iteration will only be 8 hours.
+  # ... and more!
+
+== INSTALL:
+
+  gem install days_and_times -s http://gemcutter.com
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 BehindLogic
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'days_and_times' do
+  developer 'Daniel Parker', 'gems@behindlogic.com'
+  self.url = "http://dcparker.github.com/days_and_times"
+end

data/lib/days_and_times.rb

@@ -0,0 +1,8 @@
+module DaysAndTimes
+  VERSION = '1.0.1'
+end
+
+require 'days_and_times/duration'
+require 'days_and_times/numeric'
+require 'days_and_times/time'
+require 'days_and_times/object'

data/lib/days_and_times/duration.rb

@@ -0,0 +1,367 @@
+require 'time'
+class Duration
+  # Length is the length of the time span, in seconds
+  # Unit is a length of time (in seconds) to use in collection methods
+  # StartTime is an optional attribute that can 'anchor' a duration
+  #   to a specific real time.
+  attr_accessor :length, :unit, :start_time
+  def initialize(count=0,unit=1,start_time=nil,auto_klass={})
+    if unit.is_a?(Time) || unit.is_a?(DateTime)
+      start_time = unit
+      unit = 1
+    end
+    options = {:count => count || 0, :unit => unit || 1, :start_time => start_time}.merge(count.is_a?(Hash) ? count : {})
+
+    @unit = options[:unit]
+    @length = (@unit * options[:count].to_f).round
+    @start_time = options[:start_time]
+  end
+  def self.new(*args)
+    a = super
+    if self.name == 'Duration' && (args.last.is_a?(Hash) ? args.last[:auto_class] == true : true)
+      a.send(:auto_class)
+    else
+      a
+    end
+  end
+  def self.length
+    1
+  end
+
+  # * * * * * * * * * * * * * * * *
+  # A Duration is a LENGTH of Time
+  #   -This is measured in seconds,
+  #    but set in terms of the unit
+  #    currently being used.
+  def length=(value)
+    if value.respond_to?(:to_f)
+      @length = (self.unit * value.to_f).round
+    else
+      raise TypeError, "Can't set a Duration's length to a #{value.class.name} object."
+    end
+  end
+  def length
+    length  = @length.to_f / self.unit
+    length.to_i == length ? length.to_i : length
+  end
+  def abs_length=(value)
+    if value.respond_to?(:to_i)
+      @length = value.to_i
+    else
+      raise TypeError, "Can't set a Duration's length to a #{value.class.name} object."
+    end
+  end
+  def abs_length
+    @length
+  end
+  def to_i
+    self.abs_length.to_i
+  end
+  def to_f
+    self.abs_length.to_f
+  end
+  def to_s
+    "#{self.length} #{self.class.name}"
+  end
+  def coerce(*args)
+    to_f.coerce(*args)
+  end
+
+  def ===(other)
+    self.to_f == other.to_f
+  end
+  def inspect
+    "#<#{self.class.name}:#{self.object_id} (length=#{self.length.inspect}) #{self.instance_variables.reject {|d| d=='@length' || self.instance_variable_get(d).nil?}.collect {|iv| "#{iv}=#{self.instance_variable_get(iv).inspect}"}.join(' ')}>"
+  end
+  # * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * *
+  # A Duration's calculations utilize a UNIT
+  #   -This is stored as the number of
+  #    seconds equal to the unit's value.
+  def unit=(value)
+    if value.respond_to?(:to_i)
+      @unit = value.to_i
+    else
+      raise TypeError, "Can't set a Duration's unit to a #{value.class.name} object."
+    end
+  end
+  def -(value)
+    if value.respond_to?(:to_i)
+      auto_class(Duration.new(@length - value.to_i))
+    else
+      raise TypeError, "Can't convert #{value.class.name} to an integer."
+    end
+  end
+  def +(value)
+    if value.respond_to?(:to_i)
+      auto_class(Duration.new(@length + value.to_i))
+    else
+      raise TypeError, "Can't convert #{value.class.name} to an integer."
+    end
+  end
+  def *(value)
+    if value.is_a?(Duration)
+      @length * value.length * value.unit
+    elsif value.respond_to?(:to_i)
+      auto_class(Duration.new(@length * value))
+    else
+      raise TypeError, "Can't convert #{value.class.name} to an integer."
+    end
+  end
+  def /(value)
+    if value.is_a?(Duration)
+      @length / (value.length * value.unit)
+    elsif value.respond_to?(:to_i)
+      auto_class(Duration.new(@length / value))
+    else
+      raise TypeError, "Can't convert #{value.class.name} to an integer."
+    end
+  end
+  def in_weeks
+    self.unit = Week.length
+    auto_class(self)
+  end
+  def in_days
+    self.unit = Day.length
+    auto_class(self)
+  end
+  def in_hours
+    self.unit = Hour.length
+    auto_class(self)
+  end
+  def in_minutes
+    self.unit = Minute.length
+    auto_class(self)
+  end
+  def in_seconds
+    self.unit = Second.length
+    auto_class(self)
+  end
+  def weeks
+    @length.to_f / Week.length
+  end
+  def days
+    @length.to_f / Day.length
+  end
+  def hours
+    @length.to_f / Hour.length
+  end
+  def minutes
+    @length.to_f / Minute.length
+  end
+  def seconds
+    @length.to_f / Second.length
+  end
+  # * * * * * * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * * * *
+  # A Duration can be 'anchored' to a START_TIME
+  #   -This start_time is a Time object
+  def start_time=(value)
+    if value.is_a?(Time) || value.is_a?(DateTime)
+      @start_time = value.to_time
+    else
+      raise TypeError, "A Duration's start_time must be a Time or DateTime object."
+    end
+  end
+  def end_time=(value)
+    if value.is_a?(Time) || value.is_a?(DateTime)
+      @start_time = value.to_time - self #Subtracts this duration from the end_time to get the start_time
+    else
+      raise TypeError, "A Duration's end_time must be a Time or DateTime object."
+    end
+  end
+  def end_time
+    @start_time + self
+  end
+  def anchored?
+    !self.start_time.nil?
+  end
+  # * * * * * * * * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * * * * *
+  # Calculations using Duration as an intermediate
+  def from(time)
+    time + @length
+  end
+  def before(time)
+    time - @length
+  end
+  def from_now
+    self.from(Time.now)
+  end
+  def ago
+    self.before(Time.now)
+  end
+  def starting(time)
+    self.start_time = time
+    self
+  end
+  def ending(time)
+    self.end_time = time
+    self
+  end
+  # * * * * * * * * * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  # A Duration can be treated as a 'collection' of units
+  def each_week(&block)
+    self.each(Week.length,&block)
+  end
+  def each_day(&block)
+    self.each(Day.length,&block)
+  end
+  def each_hour(&block)
+    self.each(Hour.length,&block)
+  end
+  def each_minute(&block)
+    self.each(Minute.length,&block)
+  end
+  def each_second(&block)
+    self.each(Second.length,&block)
+  end
+  def collect(use_unit=self.class.length,&block)
+    ary = []
+    self.each(use_unit) do |x|
+      ary << (block_given? ? yield(x) : x)
+    end
+    ary
+  end
+  def each(use_unit=self.class.length)
+    remainder = @length.to_f % use_unit
+    ret = []
+    if self.start_time.nil?
+      (@length.to_f / use_unit).to_i.times do |i|
+        ret << Duration.new(1, use_unit)
+        yield(ret[-1])
+      end
+    else
+      (@length.to_f / use_unit).to_i.times do |i|
+        ret << Duration.new(1, use_unit, (self.start_time + (use_unit * i)))
+        yield(ret[-1])
+      end
+    end
+    if remainder > 0
+      ret << (self.start_time.nil? ? Duration.new(remainder, 1) : Duration.new(remainder, 1, (self.start_time + @length - remainder)))
+      yield(ret[-1])
+    end
+    ret
+  end
+  # * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  # Through some ingenious metacoding (see 'def bind_object_method') below,
+  # it is possible to create a new method on a Duration object
+  # to a method on another object, in order to gather information
+  # based on the duration mentioned.
+  def create_find_within_method_for(other, method_name, other_method_name)
+    self.bind_object_method(other, method_name, other_method_name, [[], ['self.start_time', 'self.end_time']])
+  end
+  def self.create_find_within_method_for(other, method_name, other_method_name)
+    self.bind_class_object_method(other, method_name, other_method_name, [[], ['self.start_time', 'self.end_time']])
+  end
+  # * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+  def method_missing(method_name, *args)
+    # Delegate any missing methods to the start_time Time object, if we have a start_time and the method exists there.
+    return self.start_time.send(method_name, *args) if self.anchored? && self.start_time.respond_to?(method_name)
+    super
+  end
+
+  private
+    def auto_class(obj=self)
+      new_obj = case obj.unit
+      when 1
+        obj.class.name == 'Seconds'  ? obj : (obj.length == 1 ? Second.new(obj.start_time) : Seconds.new(obj.length,obj.start_time))
+      when 60
+        obj.class.name == 'Minutes'  ? obj : (obj.length == 1 ? Minute.new(obj.start_time) : Minutes.new(obj.length,obj.start_time))
+      when 3600
+        obj.class.name == 'Hours'    ? obj : (obj.length == 1 ? Hour.new(obj.start_time) : Hours.new(obj.length,obj.start_time))
+      when 86400
+        obj.class.name == 'Days'     ? obj : (obj.length == 1 ? Day.new(obj.start_time) : Days.new(obj.length,obj.start_time))
+      when 604800
+        obj.class.name == 'Weeks'    ? obj : (obj.length == 1 ? Week.new(obj.start_time) : Weeks.new(obj.length,obj.start_time))
+      else
+        obj.class.name == 'Duration' ? obj : Duration.new(obj.length,obj.unit,obj.start_time,{:auto_class => false})
+      end
+      # Now, auto-transform class if possible:
+      case
+      when !['Weeks', 'Week'].include?(new_obj.class.name) && new_obj.to_i.remainder(Week.length) == 0
+        new_obj.to_i == Week.length ? Week.new(new_obj.start_time) : Weeks.new(new_obj.to_f / Week.length,new_obj.start_time)
+      when !['Weeks', 'Week', 'Days', 'Day'].include?(new_obj.class.name) && new_obj.to_i.remainder(Day.length) == 0
+        new_obj.to_i == Day.length ? Day.new(new_obj.start_time) : Days.new(new_obj.to_f / Day.length,new_obj.start_time)
+      when !['Weeks', 'Week', 'Days', 'Day', 'Hours', 'Hour'].include?(new_obj.class.name) && new_obj.to_i.remainder(Hour.length) == 0
+        new_obj.to_i == Hour.length ? Hour.new(new_obj.start_time) : Hours.new(new_obj.to_f / Hour.length,new_obj.start_time)
+      when !['Weeks', 'Week', 'Days', 'Day', 'Hours', 'Hour', 'Minutes', 'Minute'].include?(new_obj.class.name) && new_obj.to_f.remainder(Minute.length) == 0
+        new_obj.to_i == Minute.length ? Minute.new(new_obj.start_time) : Minutes.new(new_obj.to_f / Minute.length,new_obj.start_time)
+      else
+        new_obj
+      end
+    end
+end
+class Weeks < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Week.length,start_time)
+  end
+  def self.length
+    604800
+  end
+end
+class Week < Weeks
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end
+class Days < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Day.length,start_time)
+  end
+  def self.length
+    86400
+  end
+end
+class Day < Days
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end
+class Hours < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Hour.length,start_time)
+  end
+  def self.length
+    3600
+  end
+end
+class Hour < Hours
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end
+class Minutes < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Minute.length,start_time)
+  end
+  def self.length
+    60
+  end
+end
+class Minute < Minutes
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end
+class Seconds < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Second.length,start_time)
+  end
+  def self.length
+    1
+  end
+end
+class Second < Seconds
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end

data/lib/days_and_times/numeric.rb

@@ -0,0 +1,48 @@
+require 'days_and_times/duration'
+class Numeric
+  def weeks
+    self == 1 ? Week.new : Weeks.new(self)
+  end
+  def week
+    self.weeks
+  end
+
+  def days
+    self == 1 ? Day.new : Days.new(self)
+  end
+  def day
+    self.days
+  end
+
+  def hours
+    self == 1 ? Hour.new : Hours.new(self)
+  end
+  def hour
+    self.hours
+  end
+
+  def minutes
+    self == 1 ? Minute.new : Minutes.new(self)
+  end
+  def minute
+    self.minutes
+  end
+
+  def seconds
+    self == 1 ? Second.new : Seconds.new(self)
+  end
+  def second
+    self.seconds
+  end
+
+  def is_multiple_of?(num)
+    self % num == 0
+  end
+
+  def am
+    Time.parse("#{self}:00:00")
+  end
+  def pm
+    Time.parse("#{self+12}:00:00")
+  end
+end

data/lib/days_and_times/object.rb

@@ -0,0 +1,19 @@
+class Object
+  def bind_class_object_method(other, self_method_name, other_method_name, args=[[],[]])
+    # Since I can't pass the 'other' object into eval as a string, I have to
+    #   set a class instance variable and copy the contents to a class variable
+    #   so that the generated method will play nicely with subclasses.
+    self.instance_variable_set("@#{self_method_name.to_s}_OBJ", other)
+    self.send :eval, "@@#{self_method_name.to_s}_OBJ = @#{self_method_name.to_s}_OBJ
+    def #{self_method_name.to_s}(#{args[0].join(', ')})
+      @@#{self_method_name.to_s}_OBJ.#{other_method_name.to_s}(#{args[1].join(', ')})
+    end"
+    self
+  end
+  def bind_object_method(other, self_method_name, other_method_name, args=[[],[]])
+    self.instance_variable_set("@#{self_method_name}_OBJ", other)
+    eval "def self.#{self_method_name}(#{args[0].join(', ')})
+      @#{self_method_name}_OBJ.#{other_method_name}(#{args[1].join(', ')})
+    end"
+  end
+end

data/lib/days_and_times/time.rb

@@ -0,0 +1,137 @@
+require 'time'
+class Time
+  def to_time
+    self
+  end
+
+  # Returns a new Time where one or more of the elements have been changed according to the +options+ parameter. The time options
+  # (hour, minute, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and
+  # minute is passed, then sec and usec is set to 0.
+  def change(options)
+    ::Time.send(
+      self.utc? ? :utc_time : :local_time,
+      options[:year]  || self.year,
+      options[:month] || self.month,
+      options[:day]   || options[:mday] || self.day, # mday is deprecated
+      options[:hour]  || self.hour,
+      options[:min]   || (options[:hour] ? 0 : self.min),
+      options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
+      options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : self.usec)
+    )
+  end
+
+  def day_name
+    self.strftime("%A")
+  end
+  def month_name
+    self.strftime("%B")
+  end
+
+  # Seconds since midnight: Time.now.seconds_since_midnight
+  def seconds_since_midnight
+    self.to_i - self.change(:hour => 0).to_i + (self.usec/1.0e+6)
+  end
+
+  # Returns a new Time representing the start of the day (0:00)
+  def beginning_of_day
+    (self - self.seconds_since_midnight).change(:usec => 0)
+  end
+  alias :midnight :beginning_of_day
+  alias :at_midnight :beginning_of_day
+  alias :at_beginning_of_day :beginning_of_day
+
+  # Returns a new Time if requested year can be accomodated by Ruby's Time class
+  # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
+  # otherwise returns a DateTime
+  def self.time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
+    ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
+  rescue
+    offset = if utc_or_local.to_sym == :utc then 0 else ::DateTime.now.offset end
+    ::DateTime.civil(year, month, day, hour, min, sec, offset, 0)
+  end
+
+  # wraps class method time_with_datetime_fallback with utc_or_local == :utc
+  def self.utc_time(*args)
+    time_with_datetime_fallback(:utc, *args)
+  end
+
+  # wraps class method time_with_datetime_fallback with utc_or_local == :local
+  def self.local_time(*args)
+    time_with_datetime_fallback(:local, *args)
+  end
+
+  def self.tomorrow
+    Time.now.beginning_of_day + 1.day
+  end
+  def tomorrow
+    self.beginning_of_day + 1.day
+  end
+  def self.yesterday
+    Time.now.beginning_of_day - 1.day
+  end
+  def yesterday
+    self.beginning_of_day - 1.day
+  end
+  def self.today
+    Time.now.beginning_of_day
+  end
+  def self.next_month
+    today.change(:day => 1, :month => today.month + 1)
+  end
+
+  def until(end_time)
+    Duration.new(end_time - self, self)
+  end
+  def through(duration)
+    self.until(duration)
+  end
+  def for(duration)
+    raise TypeError, "must be a Duration object." unless duration.is_a?(Duration)
+    duration.start_time = self
+    duration
+  end
+  def is_today?
+    self.beginning_of_day == Time.today
+  end
+  def strfsql
+    self.strftime("%Y-#{self.strftime("%m").to_i.to_s}-#{self.strftime("%d").to_i.to_s}")
+  end
+  def self.from_tzid(tzid) #We aren't handling the Time Zone part here...
+     if tzid =~ /(\d\d\d\d)(\d\d)(\d\d)T(\d\d)(\d\d)(\d\d)Z/ # yyyymmddThhmmss
+       Time.xmlschema("#{$1}-#{$2}-#{$3}T#{$4}:#{$5}:#{$6}")
+     else
+       return nil
+     end
+  end
+  def humanize_time
+    self.strftime("%M").to_i > 0 ? self.strftime("#{self.strftime("%I").to_i.to_s}:%M%p").downcase : self.strftime("#{self.strftime("%I").to_i.to_s}%p").downcase
+  end
+  def humanize_date(length_profile='medium') #There may be decent reason to change how this works entirely...
+    case length_profile
+    when 'abbr' || 'abbreviated'
+      self.strftime("%m/%d/%y")
+    when 'short'
+      self.strftime("%b #{self.strftime("%d").to_i.to_s}")
+    when 'medium'
+      self.strftime("%B #{self.strftime("%d").to_i.to_s}")
+    when 'long'
+      self.strftime("%B #{self.strftime("%d").to_i.to_s}, %Y")
+    end
+  end
+  def humanize_date_time
+    self.humanize_date + ' ' + self.humanize_time
+  end
+end
+
+def Today
+  Time.today
+end
+def Yesterday
+  Time.yesterday
+end
+def Tomorrow
+  Time.tomorrow
+end
+def Now
+  Time.now
+end

data/spec/days_and_times/numeric_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe Numeric do
+  it "should generate am and pm times" do
+    3.am.to_s.should eql(Time.parse("3:00:00").to_s)
+    3.pm.to_s.should eql(Time.parse("15:00:00").to_s)
+    19.am.to_s.should eql(Time.parse("19:00:00").to_s)
+  end
+end

data/spec/days_and_times_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Duration do
+  it "should be backward-compatible with previous english time statements" do
+    10.minutes.from_now.inspect.should eql((Time.now + 600).inspect)
+    3.days.ago.inspect.should eql((Time.now - 3*24*60*60).inspect)
+    # More english statements need to be written!!
+  end
+
+  it "should store a duration correctly in minutes if told to do so, even when created in seconds" do
+    132.seconds.in_minutes.should be_is_a(Minutes)
+    132.seconds.in_minutes.unit.should eql(60)
+    132.seconds.in_minutes.length.to_s.should eql('2.2')
+  end
+
+  it "should add a duration properly to a Time object" do
+    (Time.now+1.day).inspect.should eql((Time.now+86400).inspect)
+  end
+
+  it "should properly represent time in string, depending on the unit" do
+    23.seconds.to_s.should eql("23 Seconds")
+  end
+
+  it "should properly perform mathmatical operations, yet considering the unit" do
+    (2.days / 2 === 1.day).should eql(true)
+    (2.days / 2).in_days.length.should eql(1.day.length)
+  end
+
+  it "should automatically map to Day, Minute, Hour, etc if the length matches" do
+    (1.week - 6.days).class.name.should eql('Day')
+  end
+
+  it "should render durations properly" do
+    1.day.should === Duration.new(1, 86400) #=> A duration of 1 day
+    7.days.should === Duration.new(7, 86400) #=> A duration of 7 days
+    1.week.should === Duration.new(1, 604800) #=> A duration of 1 week
+  end
+  
+  it "should perform mathematics on unanchored durations" do
+    (1.week - 2.days).should === Duration.new(5, 86400) #=> A duration of 5 days
+  end
+  
+  it "should perform mathematics on an anchored duration" do
+    (3.minutes.ago.until(7.minutes.from(Now())) - 2.minutes).should === Duration.new(8, 60) #=> duration 3 minutes ago to 5 minutes from now
+  end
+
+  it "should generate durations from numeric and time arguments" do
+    1.week.from(Now()).to_s.should eql((Time.now + 604800).to_s) #=> The time of 1 week from this moment
+    1.week.from(Today()).should eql((Time.now + 604800).beginning_of_day) #=> The time of 1 week from the beginning of today
+    3.minutes.ago.until(7.minutes.from(Now())).should === Duration.new(10, 60) #=> duration 3 minutes ago to 7 minutes from now
+    4.weeks.from(2.days.from(Now())).until(8.weeks.from(Yesterday())) #=> A duration, starting in 4 weeks and 2 days, and ending 8 weeks from yesterday
+  end
+  
+  it "should perform cross-unit calculations" do
+    1.week - 1.second #=> A duration of 6 days, 23 hours, 59 minutes, and 59 seconds
+  end
+  
+  it "should perform algebraic calculations respecting the unit" do
+    4.weeks / 2 #=> A duration of 2 weeks
+    4.weeks / 2.weeks #=> The integer 2
+  end
+  
+  it "should perform iterations respecting the default unit and custom units" do
+    8.weeks.each {|week|
+      week.should === Duration.new(1, 604800)
+    } #=> Runs code for each week contained in the duration (of 8 weeks)
+    8.weeks.starting(Now()).each {|week| } #=> Runs code for each week in the duration, but each week is also anchored to a starting time, in sequence through the duration.
+    1.week.each {|week| } #=> Automatically chooses week as its iterator
+    7.days.each {|day| } #=> Automatically chooses day as its iterator
+    1.week.each_day {|day| } #=> Forcing the week to iterate through days
+  end
+
+  it "should perform iterations with a remainder that also runs" do
+    count = 0
+    1.week.each(10.hours.to_f) {|ten_hour_segment|
+      count += 1
+      ten_hour_segment.should === Duration.new(10, 3600) unless count == 17
+    }[-1].should === Duration.new(8, 3600) #=> Using a custom iterator of 10 hours. There would be 17 of them, but notice that the last iteration will only be 8 hours.
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/days_and_times'

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: days_and_times
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- Daniel Parker
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMQ0wCwYDVQQDDARnZW1z
+  MRswGQYKCZImiZPyLGQBGRYLYmVoaW5kbG9naWMxEzARBgoJkiaJk/IsZAEZFgNj
+  b20wHhcNMDkxMTE5MDQ0NzIzWhcNMTAxMTE5MDQ0NzIzWjBBMQ0wCwYDVQQDDARn
+  ZW1zMRswGQYKCZImiZPyLGQBGRYLYmVoaW5kbG9naWMxEzARBgoJkiaJk/IsZAEZ
+  FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDs+2PvSoBC5mCz
+  Nm95RXKOb/u+CmPA70DoG9cF0zipCie003Vm0DYL3Rtobcr32eMvHxkWoJ6xoz0I
+  h74yNKtHjTTCxj86HWBPsE6xVMxVCftClndjCyKsiMiqvvp1wDNO0FFK+6LijmL3
+  2Xkp4brWq1JO92y9vYct34R7o2X//+nwZs+sss+EYhNdvdUJfWy7tA5dghGdLvRn
+  UhJJSAtTefkBCwO7bufLEt+n7wIRbiJJ5dDCwE3NIX4wUSrNeYwXGXA/Ybki+BUl
+  3KJF9IC0XR9fY9DGF0FXBKrkfDlZRrnQOem2aIxeuln0KQLJXXJuDTQPHO+mK3EG
+  UPhR7IAHAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+  BBQn32ZStKmqwFqs2vuglYzkvDzBZjANBgkqhkiG9w0BAQUFAAOCAQEAe3Z+iMmy
+  IX9ChQW4hNNb1HOpgCMc2RL+vUwku9WE95dZ+BE4A6mOYTj5JXdYf4R4Z2vavr+d
+  nwJWtXPeIBWxireb8gUU0DwqodYTpsmkj5LD1zIaZ59rXlwDA9O0V4fwE1iRG5MD
+  mB7m8fT8WNOeg4AfjH4aSiHI1+HX1RQkc7KFdLotKnCevzYU6Jza5VUbXyJ+yCEH
+  DFARN3mkfGI+18MRDEi39nK2O/bBd6Wf0cYPEKsGQjNNAIBtv9belepSMd1KKfQ2
+  L7j8CnNDCrsHDe7/251D85wSvTH4Q/41NE5ahdCkkHwzDJeyhXpmNuUSswdn7woz
+  teST6sOe8lUhZQ==
+  -----END CERTIFICATE-----
+
+date: 2009-11-20 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: Natural language method chaining for Time, Durations and the like.
+email: 
+- gems@behindlogic.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/days_and_times.rb
+- lib/days_and_times/duration.rb
+- lib/days_and_times/numeric.rb
+- lib/days_and_times/object.rb
+- lib/days_and_times/time.rb
+- spec/days_and_times/numeric_spec.rb
+- spec/days_and_times_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://dcparker.github.com/days_and_times
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: days_and_times
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Natural language method chaining for Time, Durations and the like.
+test_files: []
+