suprdate 1.0.0

data/spec/inter_class_ranges.spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+# http://refactormycode.com/codes/681-rspec-example-does-not-contain-a-should
+
+describe 'range enumeration' do
+
+  def enumerate_infinitely_with(expected)
+    simple_matcher('enumerate infinitely with') do |given, matcher|
+      matcher.failure_message = "expected #{given} to enumerate infinitely with #{expected}"
+      matcher.negative_failure_message = "expected #{given} not to enumerate infinitely with #{expected}"
+      test_times = 50
+      (given..expected).each do |x|
+        test_times -= 1
+        break if test_times <= 0
+      end
+      test_times == 0
+    end
+  end
+
+  it "each unit should had readers that return equivalents of another unit" do
+    y(2008).month.should == m(2008, 1)
+    y(2008).day.should === d(2008, 1, 1)
+    m(2008, 1).day.should === d(2008, 1, 1)
+  end
+
+  it "should work with years and months" do
+    (y(2008)..m(2008, 03)).to_a.should == [y(2008)]
+    (y(2008)..m(2009, 03)).to_a.should == [y(2008), y(2009)]
+    (m(2008, 11)..y(2009)).to_a.should == [m(2008, 11), m(2008, 12), m(2009, 1)]
+  end
+
+  it "should work with years and days" do
+    (y(2008)..d(2008, 1, 3)).to_a.should == [y(2008)]
+    (y(2008)..d(2009, 1, 3)).to_a.should == [y(2008), y(2009)]
+    (d(2008, 12, 30)..y(2009)).to_a.should == [d(2008, 12, 30), d(2008, 12, 31), d(2009, 1, 1)]
+  end
+
+  it "should work with months and days" do
+    (d(2000, 1, 30)..m(2000, 2)).to_a.should == [d(2000, 1, 30), d(2000, 1, 31), d(2000, 2, 1)]
+    (m(2000, 1)..d(2000, 2, 1)).to_a.should == [m(2000, 1), m(2000, 2)]
+  end
+
+  it "should work with infinity" do
+    y(2008).should enumerate_infinitely_with(Infinity)
+    m(2008, 10).should enumerate_infinitely_with(Infinity)
+    d(2008, 10, 1).should enumerate_infinitely_with(Infinity)
+    w(2008, 1).should enumerate_infinitely_with(Infinity) if defined? Week
+  end
+
+  it "should not have bug#1" do
+    lambda { d(2008, 12, 28)..m(2009, 4) }.should_not raise_error
+  end
+
+end

data/spec/month.spec.rb

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Month, 'creation' do
+
+  it "should work from an integer" do
+    m(2000, 1).to_sym.should == :jan
+    lambda { m(2000, 13) }.should raise_error
+    lambda { m(2000, 0) }.should raise_error
+  end
+
+  it "should work from a symbol" do
+    m(2000, :jan).to_i.should == 1
+    m(2000, :feb).to_i.should == 2
+  end
+
+end
+
+describe Month, 'provides days correctly' do
+
+  def have_num_days(expected)
+    simple_matcher('have correct number of days') do |given, matcher|
+      matcher.failure_message = "expected #{given} to have #{expected} number of days"
+      given.num_days == expected && given.days.nitems == expected
+    end
+  end
+
+  it "should know number of days" do
+    m(2000, 11).should have_num_days(30)
+    m(2000, 12).should have_num_days(31)
+    m(2001, 2 ).should have_num_days(28)
+    m(2000, 2 ).should have_num_days(29)
+  end
+
+  it "should create days with day factory" do
+    month = m(2000, 1)
+    month.day_factory = mock_day_factory = mock('day factory')
+    mock_day_factory.should_receive(:new).
+      # RSpec is failing this part I'm pretty sure it shouldn't be:
+      #with(month, an_instance_of(Integer)).
+      at_least(:once)
+    month.days
+  end
+
+  it "should return days in correct order" do
+    # CONSIDERATION: This spec is overzelously testing more than it claims. Consider using
+    # mocks over state or repurposing as an integration test.
+    day_numbers = m(2000, 1).days.map { |day| day.value }
+    day_numbers.sort.should == day_numbers
+  end
+
+end
+
+describe Month, 'provides individual days' do
+
+  before(:each) do
+    @month = m(2000, 1)
+    @month.day_factory = @mock_day_factory = mock('day factory')
+  end
+
+  it "should provide multiple individual days on demand" do
+    @mock_day_factory.should_receive(:new).with(@month, 1).once.and_return 1
+    @mock_day_factory.should_receive(:new).with(@month, 3).once.and_return 2
+    @mock_day_factory.should_receive(:new).with(@month, 5).once.and_return 3
+    @month.day(1, 3, 5).should == [1, 2, 3]
+  end
+
+  it "should provide multiple individual days on demand specified with negative offset" do
+    @mock_day_factory.should_receive(:new).with(@month, 31).once.and_return :foo
+    @mock_day_factory.should_receive(:new).with(@month, 29).once.and_return :bar
+    @month.day(-1, -3).should == [:foo, :bar]
+  end
+
+  it "should provide day 1 when no day value actually specified" do
+    @mock_day_factory.should_receive(:new).with(@month, 1).once.and_return(expected = rand_int)
+    @month.day.should == expected
+  end
+
+end
+
+describe Month, 'leap?' do
+
+  it "should not delegate to year if not Febuary" do
+    month = Month.new(y = mock('year'), 1)
+    y.should_not_receive(:leap?)
+    month.leap?.should == false
+  end
+
+  it "should delegate to year if Febuary" do
+    month = Month.new(y = mock('year'), 2)
+    y.should_receive(:leap?).and_return(expected = rand_int)
+    month.leap?.should == expected
+  end
+
+end
+
+describe Month, 'math and logic' do
+
+  it "should be comparable" do
+    (m(2000, 11) == m(2000, 11)).should == true
+    (m(2000, 10) == m(2000, 11)).should == false
+    (m(2001, 11) == m(2000, 11)).should == false
+    (m(2000, 11)  > m(2000, 12)).should == false
+    (m(2000, 12)  > m(2000, 11)).should == true
+    (m(2001, 11)  > m(2000, 11)).should == true
+    (m(2000, 11)  > m(2001, 11)).should == false
+  end
+
+  it "should be able to add with integers" do
+    (m(2000, 11) + 1).should == m(2000, 12)
+    (m(1999, 11) + 2).should == m(2000, 1)
+  end
+
+  it "should be able to subtract with integers " do
+    (m(2001, 5) - 3).should == m(2001, 2)
+    (m(2001, 1) - 1).should == m(2000, 12)
+  end
+
+  it "should hold state after arithmetic" do
+    a = m(2000, 5)
+    # day_factory is not used in any of these operations
+    # so it's ok to abuse it with a nonsense value
+    a.day_factory = :foo
+    b = a + 1
+    b.day_factory.should == :foo
+    b.object_id.should_not == a.object_id
+  end
+
+  it "should be rangeable" do
+    (m(2000, 1)..m(2000, 4)).to_a.should == [m(2000, 1), m(2000, 2), m(2000, 3), m(2000, 4)]
+  end
+
+  it "should be able to get months since and until other months" do
+    m(2000, 3).since(m(2000, 1)).should == 2
+    m(2000, 1).since(m(1999, 1)).should == 12
+    m(2000, 1).until(m(2000, 3)).should == 2
+    m(1999, 1).until(m(2000, 1)).should == 12
+  end
+
+  it "should be able to get months since and until years" do
+    m(2000, 3).since(y(2000)).should == 2
+    m(2000, 10).until(y(2001)).should == 3
+  end
+
+  it "should not permit you to get months since or until days" do
+    lambda { m.since(d) }.should raise_error
+    lambda { m.until(d) }.should raise_error
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..")) + '/lib/suprdate'
+include Suprdate
+
+def rand_int(size = 80_000) (rand * size).round - size / 2 end
+def y_rand_int() (rand * 8000).round + 1600 end
+
+def rand_between(range)
+  (rand * (range.last - range.first)).round + range.first
+end
+
+def rand_year() rand_between(1600..2000) end
+
+def date_parts(num_parts)
+  [rand_year, rand_between(1..12), rand_between(1..28)][0..num_parts - 1]
+end
+
+alias :d :Day
+alias :m :Month
+alias :y :Year

data/spec/suprdate.spec.rb

@@ -0,0 +1,193 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Suprdate, :every do
+
+  it "should filter lists by integer and symbol" do
+    list = (1..10).to_a
+    every(1, list).should == list
+    every(2, list).should == [1, 3, 5, 7, 9]
+    every(3, list).should == third = [1, 4, 7, 10]
+    every(4, list).should == [1, 5, 9]
+    every(:third, list).should == third
+  end
+
+  it "should return the whole list if a block is provided" do
+    i = 0
+    every(2, [1,2]) { |x| x.should == 1; i+= 1 }.should == [1,2]
+    i.should == 1
+  end
+
+  it "should raise if using an unknown symbol" do
+    lambda { every(:keith, [1,2,3]) }.should raise_error(IndexError)
+  end
+
+end
+
+module BeAListOfIdenticalInstances
+
+  def be_a_list_of_identical_instances(expected)
+    simple_matcher('be a list of the same objects') do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to be the same as #{expected.inspect}"
+      matcher.negative_failure_message =
+        "expected #{given.inspect} not to be the same as #{expected.inspect}"
+      sorted_object_ids(expected) == sorted_object_ids(given)
+    end
+  end
+
+  private
+  def sorted_object_ids(list) list.map { |x| x.object_id }.sort end
+
+end
+
+describe Suprdate::UNITS do
+
+  include BeAListOfIdenticalInstances
+
+  it "should contain all the units" do
+    units = []
+    Module.constants.each do |const|
+      const = Kernel.const_get(const)
+      next unless const.respond_to?(:ancestors)
+      const.ancestors[1..-1].find { |x| units << const if x == Unit }
+    end
+    UNITS.should be_a_list_of_identical_instances(units)
+  end
+
+end
+
+describe Utility, :disarray do
+
+  it "should return unaltered array if 2 or more elements" do
+    Utility::disarray(array = Array.new(2)).should == array
+    Utility::disarray(array = Array.new(5)).should == array
+    Utility::disarray(array = Array.new(10)).should == array
+  end
+
+  it "should return first element of a single element array" do
+    Utility::disarray([:foo]).should == :foo
+    Utility::disarray([80081355]).should == 80081355
+  end
+
+end
+
+describe Utility, :english_list do
+
+  it "should return string forms of single items" do
+    Utility::english_list([1]).should == '1'
+    (mock_item = mock('item')).should_receive(:to_s).and_return(expected = rand_int.to_s)
+    Utility::english_list([mock_item]).should == expected
+  end
+
+  it "should return two-item lists with and in the middle" do
+    Utility::english_list([1, 2]).should == '1 and 2'
+    Utility::english_list([:Fox, :Hounds]).should == 'Fox and Hounds'
+  end
+
+  it "should use commas in lists of any length greater than do" do
+    Utility::english_list([1, 2, 3]).should == '1, 2, and 3'
+    Utility::english_list(['Loud', 'scary', 'extremely flatulent']).should == 'Loud, scary, and extremely flatulent'
+  end
+
+end
+
+describe Utility::CleanConstantName do
+
+  module FooNamespace
+    class Monkey
+      extend Utility::CleanConstantName
+    end
+  end
+
+  it "should provide short version of the original" do
+    FooNamespace::Monkey.name.should == 'FooNamespace::Monkey'
+    FooNamespace::Monkey.name_singular.should == 'monkey'
+    FooNamespace::Monkey.to_sym.should == 'monkey'.to_sym
+    FooNamespace::Monkey.name_plural.should == 'monkeys'
+  end
+
+end
+
+describe 'self building integration' do
+
+  it "should allow years to build months and months to build days" do
+
+    year = Year.new(2000)
+    year.month_factory = mock_month_factory = mock('month factory')
+    year.day_factory = mock_day_factory = mock('day factory')
+
+    mock_month_factory.should_receive(:new).once.
+      with(year, month_value = rand_int).and_return(mock_month = mock('month'))
+
+    mock_month.should_receive(:day_factory=).once.
+      with(mock_day_factory).and_return(mock_day_factory)
+
+    mock_month.should_receive(:day).once.
+      with(day_value = rand_int).and_return(mock_day = rand_int)
+
+    year.month(month_value).day(day_value).should == mock_day
+
+  end
+
+  it "should allow months to build days" do
+
+    month = Month.new(Year.new(2008), 10)
+    month.day_factory = mock_day_factory = mock('day factory')
+
+    mock_day_factory.should_receive(:new).once.
+      with(month, day_value = rand_int.abs).and_return(mock_day = rand_int)
+
+    month.day(day_value).should == mock_day
+
+  end
+
+  it "should another one for weeks" do
+    pending if defined? Week
+  end
+
+end
+
+describe 'all unit classes' do
+
+  it "should have CleanConstantName included" do
+    UNITS.each do |klass|
+      class << klass
+        ancestors
+      end.include?(Utility::CleanConstantName).should == true
+    end
+  end
+
+  it "should have a leap? method" do
+    UNITS.each { |c| c.public_method_defined?(:leap?).should == true }
+  end
+
+  it "should know its significance related to each other unit" do
+    (Year <=> Year).should == 0
+    (Year <=> Month).should == 1
+    (Year <=> Day).should == 1
+    (Month <=> Year).should == -1
+    (Month <=> Month).should == 0
+    (Month <=> Day).should == 1
+    (Day <=> Year).should == -1
+    (Day <=> Month).should == -1
+    (Day <=> Day).should == 0
+    (Year > Month).should == true
+    (Year > Year).should == false
+    (Year <=> Array).should == nil
+    pending 'Missing weeks' if defined? Week
+  end
+
+  include BeAListOfIdenticalInstances
+
+  it "should have polymorphic interfaces" do
+    units = [y(2000), m(2000, 1), d(2000, 1, 1)]
+    # to make sure these really are all the units.
+    units.map { |i| i.class }.should be_a_list_of_identical_instances(UNITS)
+    units.each do |u|
+      u.day.class.should == Day
+      u.month.class.should == Month
+      u.year.class.should == Year
+      u.days[0].class.should == Day
+    end
+  end
+
+end

data/spec/year.spec.rb

@@ -0,0 +1,167 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'year is like an integer' do
+
+  it "should initialize with an integer" do
+    3.times { y(ex = y_rand_int).to_i.should == ex }
+  end
+
+  it "should be comparable with years" do
+    (y(ex = y_rand_int) == y(ex)).should == true
+    (y(ex = y_rand_int) == y(ex + 1)).should == false
+    (y(2001) > y(2000)).should == true
+    (y(2000) > y(2000)).should == false
+    (y(2000) < y(2001)).should == true
+    (y(2000) < y(2000)).should == false
+  end
+
+  it "should know the successive year" do
+    y(2000).succ.should == y(2001)
+    (y(2000) .. y(2003)).to_a.should == [y(2000), y(2001), y(2002), y(2003)]
+  end
+
+  it "should respond to addition with an integer" do
+    (y(a = y_rand_int) + b = y_rand_int).should == y(a + b)
+  end
+
+  it "should respond to subtraction with an integer" do
+    (y(a = y_rand_int) - b = 10).should == y(a - b)
+  end
+
+  it "should hold state after arithmetic" do
+    a = Year.new(2000)
+    # month_factory is not used in any of these operations
+    # so it's ok to abuse it with a nonsense value
+    a.month_factory = :foo
+    b = a + 1
+    b.month_factory.should == :foo
+    b.object_id.should_not == a.object_id
+  end
+
+  it "should be able to get years since and until other years" do
+    y(2005).since(y(2000)).should == 5
+    y(2000).until(y(2005)).should == 5
+  end
+
+  it "should not permit you to get years since or until months or days" do
+    lambda { y.since(d) }.should raise_error
+    lambda { y.until(d) }.should raise_error
+    lambda { y.since(m) }.should raise_error
+    lambda { y.until(m) }.should raise_error
+  end
+
+end
+
+describe 'year comprised of months' do
+
+  before(:each) do
+    @year = y(2000)
+    @year.day_factory = @mock_day_factory = mock('day factory')
+    @mock_month = mock('month')
+    @year.month_factory = @month_factory = mock('month factory')
+  end
+
+  it "should return an array of months" do
+    nums = []
+    @month_factory.should_receive(:new) do |year, n|
+      year.should == @year
+      nums << n
+      @mock_month
+    end.exactly(NUM_MONTHS_IN_YEAR).times
+
+    @mock_month.should_receive(:day_factory=).with(@mock_day_factory).
+      exactly(NUM_MONTHS_IN_YEAR).times.and_return(@mock_day_factory)
+
+    @year.months[0].should == @mock_month
+    nums.sort.should == nums
+    nums[0].should == 1
+  end
+
+  it "should provide individual months on demand" do
+    @month_factory.should_receive(:new).with(@year, 1).once.and_return @mock_month
+    @mock_month.should_receive(:day_factory=).with(@mock_day_factory).once.and_return(@mock_day_factory)
+    @year.month(1).should == @mock_month
+  end
+
+  it "should provide month 1 when no month value actually specified" do
+    @month_factory.should_receive(:new).with(@year, 1).once.and_return @mock_month
+    @mock_month.should_receive(:day_factory=).with(@mock_day_factory).once.and_return(@mock_day_factory)
+    @year.month.should == @mock_month
+  end
+
+  it "should provide multiple individual months on demand" do
+    @month_factory.should_receive(:new).with(@year, 1).once.and_return @mock_month
+    @month_factory.should_receive(:new).with(@year, 3).once.and_return @mock_month
+    @month_factory.should_receive(:new).with(@year, 5).once.and_return @mock_month
+    @mock_month.should_receive(:day_factory=).with(@mock_day_factory).
+      exactly(3).times.and_return(@mock_day_factory)
+    @year.month(1, 3, 5).should == Array.new(3, @mock_month)
+  end
+
+end
+
+describe 'year misc' do
+
+  it "should not allow years before 1582 to be created" do
+    lambda { y(300) }.should raise_error(DateConstructionError)
+    lambda { y(1500) }.should raise_error(DateConstructionError)
+    lambda { y(1582); y(1600) }.should_not raise_error
+  end
+
+  it "should known when it's a leap year" do
+    # http://en.wikipedia.org/wiki/Leap_year#Gregorian_calendar
+    [1600, 1604, 1608, 1612, 2000, 2400, 2800].each do |year|
+      y(year).leap?.should be_true
+    end
+    [1700, 1800, 1900, 2100, 2200, 2300, 2500, 2600, 2700, 2900, 3000].each do |year|
+      y(year).leap?.should be_false
+    end
+  end
+
+end
+
+describe 'year comprised of days (via months)' do
+
+  NO_LEAP = false
+  LEAP = true
+
+  before(:each) do
+    @year = y(2000)
+    @expected = rand_int
+    @year.month_factory = @month_factory = mock('month factory')
+    @month = mock('month')
+  end
+
+  it "should return an array of days" do
+    # days can only be created through months
+
+    @month_factory.should_receive(:new).
+      # RSpec is failing this part I'm pretty sure it shouldn't be:
+      #with(@year, an_instance_of(Integer)).
+      exactly(NUM_MONTHS_IN_YEAR).times.and_return(@month)
+
+    @month.should_receive(:day_factory=).with(@year.day_factory).
+      exactly(NUM_MONTHS_IN_YEAR).times.and_return(@year.day_factory)
+
+    @month.should_receive(:days).with(no_args).
+      # each month creates only two days in this example...
+      exactly(NUM_MONTHS_IN_YEAR).times.and_return Array.new(list_size = (rand * 6).round + 1, @expected)
+
+    days = @year.days
+    days.nitems.should == list_size * NUM_MONTHS_IN_YEAR
+    days[0].should == @expected
+  end
+
+end
+
+describe 'year copies' do
+
+  it "should hold state" do
+    a = Year.new(2000)
+    a.month_factory = :foo
+    b= a.new(2001)
+    b.object_id.should_not == a.object_id
+    b.month_factory.should == a.month_factory
+  end
+
+end