suprdate 1.0.0

data/lib/suprdate/day.rb

@@ -0,0 +1,94 @@
+module Suprdate
+
+  class Day < Unit
+
+    require 'date'
+    attr_reader :month
+
+    def initialize(month, value)
+      @month = month
+      unless (1..month.num_days).include? value
+        raise DateConstructionError.new("There are not #{value} days in #{month.of_year_as_s}")
+      end
+      super(value)
+    end
+
+    protected :initialize
+
+    STRFTIME_STR = '%Y-%m-%d'
+
+    def inspect() "#@month-#{@value.to_s.rjust(2, '0')}" end
+    def year() @month.year end
+
+    # This day as a Ruby Time object.
+    def time() Time.mktime(*parts) end
+
+    # This day as a Ruby Date object.
+    def date() Date.new(*parts) end
+
+    # This day as a Ruby DateTime object.
+    def datetime() DateTime.new(*parts) end
+
+    # Polymorphic feature; guarantees you a list of Suprdate::Day
+    def days() [self] end
+
+    # Polymorphic feature; guarantees you a Suprdate::Day
+    def day() self end
+
+    # Day of the week as a symbol. (See Suprdate::WEEKDAYS_AS_SYM)
+    def of_week_as_sym() WEEKDAYS_AS_SYM[of_week_as_i] end
+
+    # Day of the week as a string. (See Suprdate::WEEKDAYS_AS_STR)
+    def of_week_as_s() WEEKDAYS_AS_STR[of_week_as_i] end
+
+    # Day of the week as an integer. Presently Sunday is 1, Monday is 2 etc.
+    def of_week_as_i() date.wday + 1 end
+
+    # Day of the year. January 1st is 1.
+    def of_year() (date - Date.new(year.value, 1, 1)).numerator + 1 end
+
+    # Whether this day is a leap day or, in other words, February 29th.
+    def leap?() value == 29 && @month.value == 2 end
+
+    # Next successive day.
+    def succ() self + 1 end
+
+    # Return a new day incremented by an integer.
+    def +(increase) new_from_date(date + increase) end
+
+    # Return a new day decremented by an integer.
+    def -(decrease) new_from_date(date - decrease) end
+
+    # The number of days since parameter#day.
+    def since(operand) (date - operand.day.date).numerator end
+
+    # The number of days until parameter#day.
+    def until(operand) (operand.day.date - date).numerator end
+
+    def <=>(operand)
+      return -1 if operand == Infinity
+      date <=> operand.day.date
+    end
+
+    # If this day is the first Monday of the month this method returns 1.
+    # If this day is the second Monday of the month this method returns 2.
+    # Works for all days.
+    def weekday_occurrence_this_month
+      w = of_week_as_i
+      w_days_this_month = @month.days[0..value - 1].select do |day|
+        day.of_week_as_i == w
+      end
+      ORDINALS[w_days_this_month.nitems]
+    end
+
+    alias :of_month :value
+
+    def parts() [year.value, @month.value, value] end # :nodoc:
+
+    def new_from_date(date) # :nodoc:
+      new(@month.new(year.new(date.year), date.month), date.day)
+    end
+
+  end
+
+end

data/lib/suprdate/month.rb

@@ -0,0 +1,95 @@
+module Suprdate
+
+  class Month < Unit
+
+    attr_accessor :day_factory
+    attr_reader :year
+
+    STRFTIME_STR = '%Y-%m'
+
+    def initialize(year, value)
+      @year = year
+      @value = if value.kind_of?(Symbol)
+        MONTHS_SYM_TO_I.fetch(value)
+      else
+        unless MONTH_RANGE.include?(value)
+          raise "Month value must specified as symbol or be within range #{MONTH_RANGE.inspect}"
+        end
+        value
+      end
+      self # intentional
+    end
+
+    protected :initialize
+
+    # Name of month as symbol.
+    def to_sym() MONTHS_AS_SYM[@value] end
+
+    # Number of day in this month.
+    def num_days
+      return 29 if leap?
+      NUM_DAYS_IN_MONTHS[@value]
+    end
+
+    # All the days in this month
+    def days
+      (1..num_days).to_a.map { |i| day_factory.new(self, i) }
+    end
+
+    # A choice of some specific days from this month.
+    def day(*indices)
+      indices = [1] if indices.empty?
+      rval = indices.map do |i|
+        i = num_days + 1 - i.abs if i < 0
+        day_factory.new(self, i)
+      end
+      Utility::disarray(rval)
+    end
+
+    # Whether this month contains a leap day.
+    def leap?() @value == 2 && @year.leap? end
+
+    def inspect() "#@year-#{@value.to_s.rjust(2, '0')}" end
+
+    def <=>(operand)
+      return -1 if operand == Infinity
+      operand = operand.month
+      (@year.value * NUM_MONTHS_IN_YEAR + @value) - (operand.year.value * NUM_MONTHS_IN_YEAR + operand.value)
+    end
+
+    # Number of months since parameter#month.
+    def since(operand) sum - operand.month.sum end
+
+    # Number of months until parameter#month.
+    def until(operand) operand.month.sum - sum end
+
+    # Return a new month incremented by an integer.
+    def +(increase) new_from_sum(sum + increase) end
+
+    # Return a new month decremented by an integer.
+    def -(decrease) new_from_sum(sum - decrease) end
+
+    # Next successive month.
+    def succ() self + 1 end
+
+    def of_year_as_sym() MONTHS_AS_SYM[@value] end
+    def of_year_as_s() MONTHS_AS_STR[@value] end
+    def month() self end
+
+    alias :of_year_as_i :value
+    alias :[] :day
+
+    protected
+
+    # total number of months from 0 years 0 months
+    def sum
+      @year.value * NUM_MONTHS_IN_YEAR + @value - 1
+    end
+
+    def new_from_sum(sum)
+      new(@year.new(sum / NUM_MONTHS_IN_YEAR), sum % NUM_MONTHS_IN_YEAR + 1)
+    end
+
+  end
+
+end

data/lib/suprdate/year.rb

@@ -0,0 +1,62 @@
+module Suprdate
+
+  class Year < Unit
+
+    attr_accessor :month_factory, :day_factory, :week_factory, :week_definition
+
+    MINIMUM_VALUE = 1582 # year when leap years were first standardized
+    STRFTIME_STR = '%Y'
+
+    def initialize(v)
+      v = v.to_i
+      raise DateConstructionError.new(
+        "Attempted to create a year valued #{v}, #{MINIMUM_VALUE - v} less than minimum " +
+        "allowed value of #{MINIMUM_VALUE}"
+      ) if v < MINIMUM_VALUE
+      super(v)
+    end
+
+    protected :initialize # for + and -
+
+    def <=>(operand)
+      return -1 if operand == Infinity
+      operand = operand.year
+      @value - operand.value
+    end
+
+    def month(*indices)
+      indices = [1] if indices.empty?
+      Utility::disarray(indices.map { |i| new_month(i) })
+    end
+
+    def +(increase) new(@value + increase) end
+    def -(decrease) new(@value - decrease) end
+    def succ() self + 1 end
+    def months() MONTH_RANGE.to_a.map { |i| new_month(i) }  end
+    def days() months.map { |m| m.days }.flatten end
+    def day(*args) month(1).day(*args) end
+    def inspect() @value.to_s end
+    def year() self end
+    def since(year) @value - year.value end
+    def until(year) year.value - @value end
+
+    def leap?
+      return true  if @value % 400 == 0
+      return false if @value % 100 == 0
+      return true  if @value % 4   == 0
+      false
+    end
+
+    alias :[] :month
+
+    protected
+
+    def new_month(value)
+      month = month_factory.new(self, value)
+      month.day_factory = day_factory
+      month
+    end
+
+  end
+
+end

data/spec/array_diff.spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'array diff' do
+
+  it 'should remove equal year elems' do
+    ([y(2010), y(2011)] - [y(2010)]).should == [y(2011)]
+  end
+
+  it 'should remove equal month elems' do
+    ([m(2010,1), m(2010, 2)] - [m(2010,1)]).should == [m(2010, 2)]
+  end
+
+  it 'should remove equal day elems' do
+    ([d(2010, 1, 1), d(2010, 1, 2)] - [d(2010, 1, 1)]).should == [d(2010, 1, 2)]
+  end
+
+end

data/spec/builder.spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Builder, 'normal unit methods' do
+
+  it "should build years" do
+    year = Builder.new.year(expected = (rand * 100).round + 1700)
+    year.should be_instance_of(Year)
+    year.to_i.should == expected
+    year.month_factory.should == Month
+    year.day_factory.should == Day
+
+    # reminds me to update the builder when I add this functionality
+    year.week_definition.should == nil
+  end
+
+  it "should build months" do
+    month = Builder.new.month(2008, expected = (rand * 11).round + 1)
+    month.should be_instance_of(Month)
+    month.to_i.should == expected
+    month.day_factory.should == Day
+    month.year.week_definition.should == nil
+  end
+
+  it "should build days" do
+    day = Builder.new.day(2008, 1, expected = (rand * 30).round + 1)
+    day.should be_instance_of(Day)
+    day.year.week_definition.should == nil
+    day.year.month_factory.should == Month
+  end
+
+  it "should build today" do
+    Builder.new.today.should be_instance_of(Day)
+    Builder.new.today.to_s.should == Time.now.strftime(Day::STRFTIME_STR)
+  end
+
+end
+
+describe Builder, 'date method' do
+
+  it "should abstract the other methods of Builder" do
+    Builder::DATE_NUM_PARTS_RANGE.each do |num_parts|
+      b = Builder.new
+      b.should_receive(Builder::UNIT_NUM_PARTS[num_parts]).once.and_return(expected = rand_int)
+      b.date(*date_parts(num_parts)).should == expected
+    end
+  end
+
+  it "should raise if wrong number of args" do
+    lambda { Builder.new.date(1,2,3,4) }.should raise_error(DateConstructionError)
+    lambda { Builder.new.date() }.should raise_error(DateConstructionError)
+  end
+
+end
+
+describe Builder, 'exported builder methods' do
+
+  it "should be defined" do
+    defined = ['Year', 'Month', 'Day', 'Date', 'Today'].each do |e|
+      respond_to?(e).should == true
+    end
+    (Builder.builder_methods.map { |m| m.to_export } - defined).should == []
+    Day(2008, 10, 10).should == DEFAULT_BUILDER.day(2008, 10, 10)
+  end
+
+end

data/spec/day.spec.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Day, 'creation' do
+
+  it "should work from an integer" do
+    d(2000, 1, 1).to_s.should == '2000-01-01'
+    d(2000, 1, 8).to_s.should == '2000-01-08'
+    d(2000, 2, 3).to_s.should == '2000-02-03'
+    d(1999, 3, 4).to_s.should == '1999-03-04'
+  end
+
+  it "should prevent the creation of impossible days" do
+    lambda { d(2000, 1, 40) }.should raise_error(DateConstructionError)
+    lambda { d(2000, 2, 30) }.should raise_error(DateConstructionError)
+    lambda { d(2000, 4, 31) }.should raise_error(DateConstructionError)
+  end
+
+end
+
+describe Day, 'readers' do
+
+  it "should give you the day of the year" do
+    d(2000, 1, 1).of_year.should == 1
+    d(2000, 1, 5).of_year.should == 5
+    d(2000, 2, 2).of_year.should == 33
+  end
+
+  it "should give you the day of the week" do
+    d(2008, 11, 9).of_week_as_s.should == "Sunday"
+    d(2008, 11, 29).of_week_as_sym.should == :sat
+    d(2008, 11, 28).of_week_as_sym.should == :fri
+    d(2008, 11, 28).of_week_as_i.should == 6
+    d(2008, 12, 1).of_week_as_i.should == 2
+  end
+
+  it "should give you equivalent Date, DateTime and Time objects" do
+    day = d(2000, 1, 1)
+    day.date.should be_instance_of(Date)
+    day.time.should be_instance_of(Time)
+    day.datetime.should be_instance_of(DateTime)
+    # returns are representitive:
+    day.date.strftime('%Y-%m-%d').should == day.to_s
+    day.time.strftime('%Y-%m-%d').should == day.to_s
+    day.datetime.strftime('%Y-%m-%d').should == day.to_s
+  end
+
+  it "should return appropriate symbol" do
+    d(2008, 11,  2).weekday_occurrence_this_month.should == :first
+    d(2008, 11,  9).weekday_occurrence_this_month.should == :second
+    d(2008, 11, 30).weekday_occurrence_this_month.should == :fifth
+    d(2008, 11, 19).weekday_occurrence_this_month.should == :third
+  end
+
+  it "should know when it is one" do
+    d(2000, 2, 29).leap?.should == true
+    d(2000, 2, 28).leap?.should == false
+    lambda { d(2001, 2, 29) }.should raise_error(DateConstructionError)
+  end
+
+end
+
+describe Day, 'math and logic' do
+
+  it "should be comparable" do
+    (d(2000, 1, 21) == d(2000, 1, 21)).should == true
+    (d(2000, 1, 20) == d(2000, 1, 21)).should == false
+    (d(2000, 6, 21) == d(2000, 5, 21)).should == false
+    (d(2000, 5, 21) == d(2001, 5, 21)).should == false
+    (d(2000, 1, 21) >  d(2000, 1, 22)).should == false
+    (d(2000, 1, 22) >  d(2000, 1, 21)).should == true
+    (d(2000, 6, 21) >  d(2000, 5, 21)).should == true
+    (d(2000, 5, 21) >  d(2000, 6, 21)).should == false
+    (d(2000, 5, 21) >  d(2001, 5, 21)).should == false
+    (d(2001, 5, 21) >  d(2000, 5, 21)).should == true
+  end
+
+  it "should be able to add with integers" do
+    (d(2000, 1,  11) + 1).should == d(2000, 1, 12)
+    (d(1999, 12, 31) + 1).should == d(2000, 1, 1)
+    # accounts for leap
+    (d(2000, 2,  28) + 2).should == d(2000, 3, 1)
+    (d(2001, 2,  28) + 2).should == d(2001, 3, 2)
+  end
+
+  it "should be able to subtract with integers" do
+    (d(2000, 1, 12) - 1).should == d(2000, 1, 11)
+    (d(2000, 1,  1) - 1).should == d(1999, 12, 31)
+    # accounts for leap
+    (d(2000, 3,  1) - 2).should == d(2000, 2, 28)
+    (d(2001, 3,  2) - 2).should == d(2001, 2, 28)
+  end
+
+  it "should hold state after arithmetic" do
+    a = d(2000, 1, 28)
+    # Because Day has no writable state of it's own (but Year does) I am assigning a random value
+    # to month_factory (an attribute on the year).
+    a.year.month_factory = expected = rand_int
+    b = a + 5 # the month and the day change
+    # but the month should still hold the original random value
+    b.year.month_factory.should == expected
+    b.object_id.should_not == a.object_id
+  end
+
+  it "should be enumerable in a range" do
+    (d(2000, 1, 1)..d(2000, 1, 4)).to_a.should == [
+      d(2000, 1, 1), d(2000, 1, 2), d(2000, 1, 3), d(2000, 1, 4)
+    ]
+  end
+
+  it "should be able to get days since and until other days" do
+    d(2000, 1, 3).since(d(2000, 1, 1)).should == 2
+    d(2000, 2, 1).since(d(2000, 1, 1)).should == 31
+    d(2000, 1, 1).until(d(2000, 1, 3)).should == 2
+    d(2000, 1, 1).until(d(2000, 2, 1)).should == 31
+  end
+
+  it "should be able to get days since and until other months and years" do
+    d(2000, 1, 3).since(m(2000, 1)).should == 2
+    d(2000, 1, 3).since(y(2000)).should == 2
+    d(2000, 3, 3).since(m(2000, 3)).should == 2
+    d(2000, 1, 3).since(y(2000)).should == 2
+  end
+
+end