fat_core 4.12.0 → 4.13.0

data/spec/lib/date_spec.rb

@@ -4,58 +4,58 @@ require 'spec_helper'
 require 'fat_core/date'
 
 describe Date do
-  before :each do
+  before do
     # Pretend it is this date. Not at beg or end of year, quarter,
     # month, or week.  It is a Wednesday
-    allow(Date).to receive_messages(today: Date.parse('2012-07-18'))
-    allow(Date).to receive_messages(current: Date.parse('2012-07-18'))
+    allow(described_class).to receive_messages(today: described_class.parse('2012-07-18'))
+    allow(described_class).to receive_messages(current: described_class.parse('2012-07-18'))
   end
 
   describe 'class methods' do
     describe 'ensure_date parsing' do
-      it 'should parse a String as a date' do
-        expect(Date.ensure_date('2018-11-12').class).to be Date
+      it 'parses a String as a date' do
+        expect(described_class.ensure_date('2018-11-12').class).to be described_class
       end
 
-      it 'should leave a Date as a date' do
-        expect(Date.ensure_date(Date.today).class).to be Date
+      it 'leaves a Date as a date' do
+        expect(described_class.ensure_date(described_class.today).class).to be described_class
       end
 
-      it 'should convert Time as a date' do
-        expect(Date.ensure_date(Time.now).class).to be Date
+      it 'converts Time as a date' do
+        expect(described_class.ensure_date(Time.now).class).to be described_class
       end
 
       it 'raises an error for bad date string' do
-        expect { Date.ensure_date('2012-mm-tu') }.to raise_error /invalid date/
+        expect { described_class.ensure_date('2012-mm-tu') }.to raise_error(/invalid date/)
       end
 
       it 'raises an error for unknown class' do
-        expect { Date.ensure_date([2011, 11, 12]) }
-          .to raise_error /requires String, Date, DateTime, or Time/
+        expect { described_class.ensure_date([2011, 11, 12]) }
+          .to raise_error(/requires String, Date, DateTime, or Time/)
       end
     end
 
     describe 'date arithmetic' do
-      it 'should know the number of days in a month' do
-        expect(Date.days_in_month(2000, 1)).to eq 31
-        expect(Date.days_in_month(1900, 2)).to eq 28
-        expect(Date.days_in_month(2000, 2)).to eq 29
-        expect(Date.days_in_month(2001, 2)).to eq 28
-        expect(Date.days_in_month(2004, 2)).to eq 29
-        expect(Date.days_in_month(2004, 3)).to eq 31
-        expect(Date.days_in_month(2004, 4)).to eq 30
-        expect(Date.days_in_month(2004, 5)).to eq 31
-        expect(Date.days_in_month(2004, 6)).to eq 30
-        expect(Date.days_in_month(2004, 7)).to eq 31
-        expect(Date.days_in_month(2004, 8)).to eq 31
-        expect(Date.days_in_month(2004, 9)).to eq 30
-        expect(Date.days_in_month(2004, 10)).to eq 31
-        expect(Date.days_in_month(2004, 11)).to eq 30
-        expect(Date.days_in_month(2004, 12)).to eq 31
-        expect { Date.days_in_month(2004, 13) }.to raise_error(ArgumentError)
-      end
-
-      it 'should know the nth weekday in a year, month' do
+      it 'knows the number of days in a month' do
+        expect(described_class.days_in_month(2000, 1)).to eq 31
+        expect(described_class.days_in_month(1900, 2)).to eq 28
+        expect(described_class.days_in_month(2000, 2)).to eq 29
+        expect(described_class.days_in_month(2001, 2)).to eq 28
+        expect(described_class.days_in_month(2004, 2)).to eq 29
+        expect(described_class.days_in_month(2004, 3)).to eq 31
+        expect(described_class.days_in_month(2004, 4)).to eq 30
+        expect(described_class.days_in_month(2004, 5)).to eq 31
+        expect(described_class.days_in_month(2004, 6)).to eq 30
+        expect(described_class.days_in_month(2004, 7)).to eq 31
+        expect(described_class.days_in_month(2004, 8)).to eq 31
+        expect(described_class.days_in_month(2004, 9)).to eq 30
+        expect(described_class.days_in_month(2004, 10)).to eq 31
+        expect(described_class.days_in_month(2004, 11)).to eq 30
+        expect(described_class.days_in_month(2004, 12)).to eq 31
+        expect { described_class.days_in_month(2004, 13) }.to raise_error(ArgumentError)
+      end
+
+      it 'knows the nth weekday in a year, month' do
         # Sunday is 0, Saturday is 6
         #     January 2014
         # Su Mo Tu We Th Fr Sa
@@ -66,42 +66,42 @@ describe Date do
         # 26 27 28 29 30 31
 
         # First Monday
-        expect(Date.nth_wday_in_year_month(1, 1, 2014, 1))
-          .to eq Date.parse('2014-01-06')
+        expect(described_class.nth_wday_in_year_month(1, 1, 2014, 1))
+          .to eq described_class.parse('2014-01-06')
         # Second Monday
-        expect(Date.nth_wday_in_year_month(2, 1, 2014, 1))
-          .to eq Date.parse('2014-01-13')
+        expect(described_class.nth_wday_in_year_month(2, 1, 2014, 1))
+          .to eq described_class.parse('2014-01-13')
         # Third Sunday
-        expect(Date.nth_wday_in_year_month(3, 0, 2014, 1))
-          .to eq Date.parse('2014-01-19')
+        expect(described_class.nth_wday_in_year_month(3, 0, 2014, 1))
+          .to eq described_class.parse('2014-01-19')
         # Third Sunday (float floored)
-        expect(Date.nth_wday_in_year_month(3.2, 0, 2014, 1))
-          .to eq Date.parse('2014-01-19')
+        expect(described_class.nth_wday_in_year_month(3.2, 0, 2014, 1))
+          .to eq described_class.parse('2014-01-19')
         # Negative wday counts from end: Last Sunday
-        expect(Date.nth_wday_in_year_month(-1, 0, 2014, 1))
-          .to eq Date.parse('2014-01-26')
-        expect(Date.nth_wday_in_year_month(-3, 0, 2014, 1))
-          .to eq Date.parse('2014-01-12')
+        expect(described_class.nth_wday_in_year_month(-1, 0, 2014, 1))
+          .to eq described_class.parse('2014-01-26')
+        expect(described_class.nth_wday_in_year_month(-3, 0, 2014, 1))
+          .to eq described_class.parse('2014-01-12')
         # Negative wday counts from end: Last Thursday
-        expect(Date.nth_wday_in_year_month(-1, 4, 2014, 1))
-          .to eq Date.parse('2014-01-30')
+        expect(described_class.nth_wday_in_year_month(-1, 4, 2014, 1))
+          .to eq described_class.parse('2014-01-30')
 
         # Exceptions
         expect {
           # N is zero
-          Date.nth_wday_in_year_month(0, 6, 2014, 1)
+          described_class.nth_wday_in_year_month(0, 6, 2014, 1)
         }.to raise_error(ArgumentError)
         expect {
           # Wday too big
-          Date.nth_wday_in_year_month(3, 7, 2014, 1)
+          described_class.nth_wday_in_year_month(3, 7, 2014, 1)
         }.to raise_error(ArgumentError)
         expect {
           # Month too big
-          Date.nth_wday_in_year_month(3, 1, 2014, 13)
+          described_class.nth_wday_in_year_month(3, 1, 2014, 13)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should know Easter for a given year' do
+      it 'knows Easter for a given year' do
         # Grabbed these dates of Easter from
         # http://tlarsen2.tripod.com/thomaslarsen/easterdates.html
         easters = {
@@ -207,21 +207,21 @@ describe Date do
           2099 => '2099-04-12'
         }
         easters.each_pair do |year, date|
-          expect(Date.easter(year)).to eq Date.parse(date)
+          expect(described_class.easter(year)).to eq described_class.parse(date)
         end
       end
     end
 
     describe 'parsing' do
-      it 'should be able to parse an American-style date' do
-        expect(Date.parse_american('2/12/2011').iso).to eq('2011-02-12')
-        expect(Date.parse_american('2 / 12/ 2011').iso).to eq('2011-02-12')
-        expect(Date.parse_american('2 / 1 / 2011').iso).to eq('2011-02-01')
-        expect(Date.parse_american('  2 / 1 / 2011  ').iso).to eq('2011-02-01')
-        expect(Date.parse_american('  2 / 1 / 15  ').iso).to eq('2015-02-01')
-        expect(Date.parse_american('  2-1-15  ').iso).to eq('2015-02-01')
+      it 'parses an American-style date' do
+        expect(described_class.parse_american('2/12/2011').iso).to eq('2011-02-12')
+        expect(described_class.parse_american('2 / 12/ 2011').iso).to eq('2011-02-12')
+        expect(described_class.parse_american('2 / 1 / 2011').iso).to eq('2011-02-01')
+        expect(described_class.parse_american('  2 / 1 / 2011  ').iso).to eq('2011-02-01')
+        expect(described_class.parse_american('  2 / 1 / 15  ').iso).to eq('2015-02-01')
+        expect(described_class.parse_american('  2-1-15  ').iso).to eq('2015-02-01')
         expect {
-          Date.parse_american('xx/1/15')
+          described_class.parse_american('xx/1/15')
         }.to raise_error(ArgumentError)
       end
     end
@@ -229,683 +229,682 @@ describe Date do
     describe 'parse_spec' do
       # For these tests, today is 2012-07-18
 
-      it 'should choke if spec type is neither :from or :to' do
+      it 'chokes if spec type is neither :from or :to' do
         expect {
-          Date.parse_spec('2011-07-15', :form)
+          described_class.parse_spec('2011-07-15', :form)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should parse plain iso dates correctly' do
-        expect(Date.parse_spec('2011-07-15')).to eq Date.parse('2011-07-15')
-        expect(Date.parse_spec('2011/08/05')).to eq Date.parse('2011-08-05')
+      it 'parses plain iso dates correctly' do
+        expect(described_class.parse_spec('2011-07-15')).to eq described_class.parse('2011-07-15')
+        expect(described_class.parse_spec('2011/08/05')).to eq described_class.parse('2011-08-05')
       end
 
-      it "should parse week numbers such as 'W23' or '23W' correctly" do
-        expect(Date.parse_spec('W1')).to eq Date.parse('2012-01-02')
-        expect(Date.parse_spec('W23')).to eq Date.parse('2012-06-04')
-        expect(Date.parse_spec('W23', :to)).to eq Date.parse('2012-06-10')
-        expect(Date.parse_spec('23W')).to eq Date.parse('2012-06-04')
-        expect(Date.parse_spec('23W', :to)).to eq Date.parse('2012-06-10')
+      it "parses week numbers such as 'W23' or '23W' correctly" do
+        expect(described_class.parse_spec('W1')).to eq described_class.parse('2012-01-02')
+        expect(described_class.parse_spec('W23')).to eq described_class.parse('2012-06-04')
+        expect(described_class.parse_spec('W23', :to)).to eq described_class.parse('2012-06-10')
+        expect(described_class.parse_spec('23W')).to eq described_class.parse('2012-06-04')
+        expect(described_class.parse_spec('23W', :to)).to eq described_class.parse('2012-06-10')
         expect {
-          Date.parse_spec('W83', :to)
+          described_class.parse_spec('W83', :to)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should parse year-week numbers \'YYYY-W23\' correctly' do
-        expect(Date.parse_spec('2003-W1')).to eq Date.parse('2002-12-30')
-        expect(Date.parse_spec('2003-W1', :to)).to eq Date.parse('2003-01-05')
-        expect(Date.parse_spec('2003-W23')).to eq Date.parse('2003-06-02')
-        expect(Date.parse_spec('2003-W23', :to)).to eq Date.parse('2003-06-08')
-        expect(Date.parse_spec('2003-23W')).to eq Date.parse('2003-06-02')
-        expect(Date.parse_spec('2003/23W', :to)).to eq Date.parse('2003-06-08')
+      it 'parse year-week numbers \'YYYY-W23\' correctly' do
+        expect(described_class.parse_spec('2003-W1')).to eq described_class.parse('2002-12-30')
+        expect(described_class.parse_spec('2003-W1', :to)).to eq described_class.parse('2003-01-05')
+        expect(described_class.parse_spec('2003-W23')).to eq described_class.parse('2003-06-02')
+        expect(described_class.parse_spec('2003-W23', :to)).to eq described_class.parse('2003-06-08')
+        expect(described_class.parse_spec('2003-23W')).to eq described_class.parse('2003-06-02')
+        expect(described_class.parse_spec('2003/23W', :to)).to eq described_class.parse('2003-06-08')
         expect {
-          Date.parse_spec('2003-W83', :to)
+          described_class.parse_spec('2003-W83', :to)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should parse year-half specs such as YYYY-NH or YYYY-HN' do
-        expect(Date.parse_spec('2011-2H', :from)).to eq Date.parse('2011-07-01')
-        expect(Date.parse_spec('2011-2H', :to)).to eq Date.parse('2011-12-31')
-        expect(Date.parse_spec('2011-H1', :from)).to eq Date.parse('2011-01-01')
-        expect(Date.parse_spec('2011/H1', :to)).to eq Date.parse('2011-06-30')
-        expect { Date.parse_spec('2011-3H') }.to raise_error(ArgumentError)
+      it 'parses year-half specs such as YYYY-NH or YYYY-HN' do
+        expect(described_class.parse_spec('2011-2H', :from)).to eq described_class.parse('2011-07-01')
+        expect(described_class.parse_spec('2011-2H', :to)).to eq described_class.parse('2011-12-31')
+        expect(described_class.parse_spec('2011-H1', :from)).to eq described_class.parse('2011-01-01')
+        expect(described_class.parse_spec('2011/H1', :to)).to eq described_class.parse('2011-06-30')
+        expect { described_class.parse_spec('2011-3H') }.to raise_error(ArgumentError)
       end
 
-      it 'should parse half-only specs such as NH or HN' do
-        expect(Date.parse_spec('2H', :from)).to eq Date.parse('2012-07-01')
-        expect(Date.parse_spec('H2', :to)).to eq Date.parse('2012-12-31')
-        expect(Date.parse_spec('1H', :from)).to eq Date.parse('2012-01-01')
-        expect(Date.parse_spec('H1', :to)).to eq Date.parse('2012-06-30')
-        expect { Date.parse_spec('8H') }.to raise_error(ArgumentError)
-      end
-
-      it 'should parse year-quarter specs such as YYYY-NQ or YYYY-QN' do
-        expect(Date.parse_spec('2011-4Q', :from)).to eq Date.parse('2011-10-01')
-        expect(Date.parse_spec('2011-4Q', :to)).to eq Date.parse('2011-12-31')
-        expect(Date.parse_spec('2011-Q4', :from)).to eq Date.parse('2011-10-01')
-        expect(Date.parse_spec('2011/Q4', :to)).to eq Date.parse('2011-12-31')
-        expect { Date.parse_spec('2011-5Q') }.to raise_error(ArgumentError)
+      it 'parses half-only specs such as NH or HN' do
+        expect(described_class.parse_spec('2H', :from)).to eq described_class.parse('2012-07-01')
+        expect(described_class.parse_spec('H2', :to)).to eq described_class.parse('2012-12-31')
+        expect(described_class.parse_spec('1H', :from)).to eq described_class.parse('2012-01-01')
+        expect(described_class.parse_spec('H1', :to)).to eq described_class.parse('2012-06-30')
+        expect { described_class.parse_spec('8H') }.to raise_error(ArgumentError)
+      end
+
+      it 'parses year-quarter specs such as YYYY-NQ or YYYY-QN' do
+        expect(described_class.parse_spec('2011-4Q', :from)).to eq described_class.parse('2011-10-01')
+        expect(described_class.parse_spec('2011-4Q', :to)).to eq described_class.parse('2011-12-31')
+        expect(described_class.parse_spec('2011-Q4', :from)).to eq described_class.parse('2011-10-01')
+        expect(described_class.parse_spec('2011/Q4', :to)).to eq described_class.parse('2011-12-31')
+        expect { described_class.parse_spec('2011-5Q') }.to raise_error(ArgumentError)
       end
 
-      it 'should parse quarter-only specs such as NQ or QN' do
-        expect(Date.parse_spec('4Q', :from)).to eq Date.parse('2012-10-01')
-        expect(Date.parse_spec('4Q', :to)).to eq Date.parse('2012-12-31')
-        expect(Date.parse_spec('Q4', :from)).to eq Date.parse('2012-10-01')
-        expect(Date.parse_spec('Q4', :to)).to eq Date.parse('2012-12-31')
-        expect { Date.parse_spec('5Q') }.to raise_error(ArgumentError)
+      it 'parses quarter-only specs such as NQ or QN' do
+        expect(described_class.parse_spec('4Q', :from)).to eq described_class.parse('2012-10-01')
+        expect(described_class.parse_spec('4Q', :to)).to eq described_class.parse('2012-12-31')
+        expect(described_class.parse_spec('Q4', :from)).to eq described_class.parse('2012-10-01')
+        expect(described_class.parse_spec('Q4', :to)).to eq described_class.parse('2012-12-31')
+        expect { described_class.parse_spec('5Q') }.to raise_error(ArgumentError)
       end
 
-      it 'should parse year-month specs such as YYYY-MM' do
-        expect(Date.parse_spec('2010-5', :from)).to eq Date.parse('2010-05-01')
-        expect(Date.parse_spec('2010/5', :to)).to eq Date.parse('2010-05-31')
-        expect { Date.parse_spec('2010-13') }.to raise_error(ArgumentError)
+      it 'parses year-month specs such as YYYY-MM' do
+        expect(described_class.parse_spec('2010-5', :from)).to eq described_class.parse('2010-05-01')
+        expect(described_class.parse_spec('2010/5', :to)).to eq described_class.parse('2010-05-31')
+        expect { described_class.parse_spec('2010-13') }.to raise_error(ArgumentError)
       end
 
-      it 'should parse month-only specs such as MM' do
-        expect(Date.parse_spec('10', :from)).to eq Date.parse('2012-10-01')
-        expect(Date.parse_spec('10', :to)).to eq Date.parse('2012-10-31')
-        expect { Date.parse_spec('99') }.to raise_error(ArgumentError)
-        expect { Date.parse_spec('011') }.to raise_error(ArgumentError)
+      it 'parses month-only specs such as MM' do
+        expect(described_class.parse_spec('10', :from)).to eq described_class.parse('2012-10-01')
+        expect(described_class.parse_spec('10', :to)).to eq described_class.parse('2012-10-31')
+        expect { described_class.parse_spec('99') }.to raise_error(ArgumentError)
+        expect { described_class.parse_spec('011') }.to raise_error(ArgumentError)
       end
 
-      it 'should parse month-day specs such as MM-DD' do
-        expect(Date.parse_spec('10-12', :from)).to eq Date.parse('2012-10-12')
-        expect(Date.parse_spec('10-2', :from)).to eq Date.parse('2012-10-02')
-        expect(Date.parse_spec('5-12', :from)).to eq Date.parse('2012-05-12')
-        expect(Date.parse_spec('5-2', :from)).to eq Date.parse('2012-05-02')
-        expect(Date.parse_spec('10/12', :from)).to eq Date.parse('2012-10-12')
-        expect(Date.parse_spec('10/2', :from)).to eq Date.parse('2012-10-02')
-        expect(Date.parse_spec('5/12', :from)).to eq Date.parse('2012-05-12')
-        expect(Date.parse_spec('5/2', :from)).to eq Date.parse('2012-05-02')
-        expect { Date.parse_spec('99-3') }.to raise_error(ArgumentError)
-        expect { Date.parse_spec('3-33') }.to raise_error(ArgumentError)
-        expect { Date.parse_spec('99/3') }.to raise_error(ArgumentError)
-        expect { Date.parse_spec('3/33') }.to raise_error(ArgumentError)
+      it 'parses month-day specs such as MM-DD' do
+        expect(described_class.parse_spec('10-12', :from)).to eq described_class.parse('2012-10-12')
+        expect(described_class.parse_spec('10-2', :from)).to eq described_class.parse('2012-10-02')
+        expect(described_class.parse_spec('5-12', :from)).to eq described_class.parse('2012-05-12')
+        expect(described_class.parse_spec('5-2', :from)).to eq described_class.parse('2012-05-02')
+        expect(described_class.parse_spec('10/12', :from)).to eq described_class.parse('2012-10-12')
+        expect(described_class.parse_spec('10/2', :from)).to eq described_class.parse('2012-10-02')
+        expect(described_class.parse_spec('5/12', :from)).to eq described_class.parse('2012-05-12')
+        expect(described_class.parse_spec('5/2', :from)).to eq described_class.parse('2012-05-02')
+        expect { described_class.parse_spec('99-3') }.to raise_error(ArgumentError)
+        expect { described_class.parse_spec('3-33') }.to raise_error(ArgumentError)
+        expect { described_class.parse_spec('99/3') }.to raise_error(ArgumentError)
+        expect { described_class.parse_spec('3/33') }.to raise_error(ArgumentError)
       end
 
-      it 'should parse year-only specs such as YYYY' do
-        expect(Date.parse_spec('2010', :from)).to eq Date.parse('2010-01-01')
-        expect(Date.parse_spec('2010', :to)).to eq Date.parse('2010-12-31')
-        expect { Date.parse_spec('99999') }.to raise_error(ArgumentError)
+      it 'parses year-only specs such as YYYY' do
+        expect(described_class.parse_spec('2010', :from)).to eq described_class.parse('2010-01-01')
+        expect(described_class.parse_spec('2010', :to)).to eq described_class.parse('2010-12-31')
+        expect { described_class.parse_spec('99999') }.to raise_error(ArgumentError)
       end
 
-      it 'should parse relative day names: today, yesterday' do
-        expect(Date.parse_spec('today')).to eq Date.current
-        expect(Date.parse_spec('this_day')).to eq Date.current
-        expect(Date.parse_spec('yesterday')).to eq Date.current - 1.day
-        expect(Date.parse_spec('last_day')).to eq Date.current - 1.day
+      it 'parses relative day names: today, yesterday' do
+        expect(described_class.parse_spec('today')).to eq described_class.current
+        expect(described_class.parse_spec('this_day')).to eq described_class.current
+        expect(described_class.parse_spec('yesterday')).to eq described_class.current - 1.day
+        expect(described_class.parse_spec('last_day')).to eq described_class.current - 1.day
       end
 
-      it 'should parse relative weeks: this_week, last_week' do
-        expect(Date.parse_spec('this_week')).to eq Date.parse('2012-07-16')
-        expect(Date.parse_spec('this_week', :to)).to eq Date.parse('2012-07-22')
-        expect(Date.parse_spec('last_week')).to eq Date.parse('2012-07-09')
-        expect(Date.parse_spec('last_week', :to)).to eq Date.parse('2012-07-15')
+      it 'parses relative weeks: this_week, last_week' do
+        expect(described_class.parse_spec('this_week')).to eq described_class.parse('2012-07-16')
+        expect(described_class.parse_spec('this_week', :to)).to eq described_class.parse('2012-07-22')
+        expect(described_class.parse_spec('last_week')).to eq described_class.parse('2012-07-09')
+        expect(described_class.parse_spec('last_week', :to)).to eq described_class.parse('2012-07-15')
       end
 
-      it 'should parse relative biweeks: this_biweek, last_biweek' do
-        expect(Date.parse_spec('this_biweek')).to eq Date.parse('2012-07-16')
-        expect(Date.parse_spec('this_biweek', :to))
-          .to eq Date.parse('2012-07-29')
-        expect(Date.parse_spec('last_biweek')).to eq Date.parse('2012-07-02')
-        expect(Date.parse_spec('last_biweek', :to))
-          .to eq Date.parse('2012-07-15')
+      it 'parses relative biweeks: this_biweek, last_biweek' do
+        expect(described_class.parse_spec('this_biweek')).to eq described_class.parse('2012-07-16')
+        expect(described_class.parse_spec('this_biweek', :to))
+          .to eq described_class.parse('2012-07-29')
+        expect(described_class.parse_spec('last_biweek')).to eq described_class.parse('2012-07-02')
+        expect(described_class.parse_spec('last_biweek', :to))
+          .to eq described_class.parse('2012-07-15')
       end
 
-      it 'should parse relative months: this_semimonth, last_semimonth' do
-        expect(Date.parse_spec('this_semimonth')).to eq Date.parse('2012-07-16')
-        expect(Date.parse_spec('this_semimonth', :to))
-          .to eq Date.parse('2012-07-31')
-        expect(Date.parse_spec('last_semimonth'))
-          .to eq Date.parse('2012-07-01')
-        expect(Date.parse_spec('last_semimonth', :to))
-          .to eq Date.parse('2012-07-15')
+      it 'parses relative semi-months: this_semimonth, last_semimonth' do
+        expect(described_class.parse_spec('this_semimonth')).to eq described_class.parse('2012-07-16')
+        expect(described_class.parse_spec('this_semimonth', :to))
+          .to eq described_class.parse('2012-07-31')
+        expect(described_class.parse_spec('last_semimonth'))
+          .to eq described_class.parse('2012-07-01')
+        expect(described_class.parse_spec('last_semimonth', :to))
+          .to eq described_class.parse('2012-07-15')
       end
 
-      it 'should parse relative months: this_month, last_month' do
-        expect(Date.parse_spec('this_month')).to eq Date.parse('2012-07-01')
-        expect(Date.parse_spec('this_month', :to))
-          .to eq Date.parse('2012-07-31')
-        expect(Date.parse_spec('last_month')).to eq Date.parse('2012-06-01')
-        expect(Date.parse_spec('last_month', :to))
-          .to eq Date.parse('2012-06-30')
+      it 'parses relative months: this_month, last_month' do
+        expect(described_class.parse_spec('this_month')).to eq described_class.parse('2012-07-01')
+        expect(described_class.parse_spec('this_month', :to))
+          .to eq described_class.parse('2012-07-31')
+        expect(described_class.parse_spec('last_month')).to eq described_class.parse('2012-06-01')
+        expect(described_class.parse_spec('last_month', :to))
+          .to eq described_class.parse('2012-06-30')
       end
-
-      it 'should parse relative bimonths: this_bimonth, last_bimonth' do
-        expect(Date.parse_spec('this_bimonth')).to eq Date.parse('2012-07-01')
-        expect(Date.parse_spec('this_bimonth', :to))
-          .to eq Date.parse('2012-08-31')
-        expect(Date.parse_spec('last_bimonth'))
-          .to eq Date.parse('2012-05-01')
-        expect(Date.parse_spec('last_bimonth', :to))
-          .to eq Date.parse('2012-06-30')
+
+      it 'parses relative bimonths: this_bimonth, last_bimonth' do
+        expect(described_class.parse_spec('this_bimonth')).to eq described_class.parse('2012-07-01')
+        expect(described_class.parse_spec('this_bimonth', :to))
+          .to eq described_class.parse('2012-08-31')
+        expect(described_class.parse_spec('last_bimonth'))
+          .to eq described_class.parse('2012-05-01')
+        expect(described_class.parse_spec('last_bimonth', :to))
+          .to eq described_class.parse('2012-06-30')
 
         # Set today to 2014-12-12: Found that last_bimonth was reporting
         # current bimonth when today was in the second month of the current
         # bimonth, i.e., an even month
-        allow(Date).to receive_messages(today: Date.parse('2014-12-12'))
-        allow(Date).to receive_messages(current: Date.parse('2014-12-12'))
+        allow(Date).to receive_messages(today: described_class.parse('2014-12-12'))
+        allow(Date).to receive_messages(current: described_class.parse('2014-12-12'))
 
-        expect(Date.parse_spec('last_bimonth'))
-          .to eq Date.parse('2014-09-01')
-        expect(Date.parse_spec('last_bimonth', :to))
-          .to eq Date.parse('2014-10-31')
+        expect(described_class.parse_spec('last_bimonth'))
+          .to eq described_class.parse('2014-09-01')
+        expect(described_class.parse_spec('last_bimonth', :to))
+          .to eq described_class.parse('2014-10-31')
 
-        allow(Date).to receive_messages(today: Date.parse('2012-07-18'))
-        allow(Date).to receive_messages(current: Date.parse('2012-07-18'))
+        allow(Date).to receive_messages(today: described_class.parse('2012-07-18'))
+        allow(Date).to receive_messages(current: described_class.parse('2012-07-18'))
       end
 
-      it 'should parse relative quarters: this_quarter, last_quarter' do
-        expect(Date.parse_spec('this_quarter')).to eq Date.parse('2012-07-01')
-        expect(Date.parse_spec('this_quarter', :to))
-          .to eq Date.parse('2012-09-30')
-        expect(Date.parse_spec('last_quarter'))
-          .to eq Date.parse('2012-04-01')
-        expect(Date.parse_spec('last_quarter', :to))
-          .to eq Date.parse('2012-06-30')
+      it 'parses relative quarters: this_quarter, last_quarter' do
+        expect(described_class.parse_spec('this_quarter')).to eq described_class.parse('2012-07-01')
+        expect(described_class.parse_spec('this_quarter', :to))
+          .to eq described_class.parse('2012-09-30')
+        expect(described_class.parse_spec('last_quarter'))
+          .to eq described_class.parse('2012-04-01')
+        expect(described_class.parse_spec('last_quarter', :to))
+          .to eq described_class.parse('2012-06-30')
       end
 
       # Today is set to '2012-07-18'
-      it 'should parse relative halves: this_half, last_half' do
-        expect(Date.parse_spec('this_half')).to eq Date.parse('2012-07-01')
-        expect(Date.parse_spec('this_half', :to)).to eq Date.parse('2012-12-31')
-        expect(Date.parse_spec('last_half')).to eq Date.parse('2012-01-01')
-        expect(Date.parse_spec('last_half', :to)).to eq Date.parse('2012-06-30')
-      end
-
-      it 'should parse relative years: this_year, last_year' do
-        expect(Date.parse_spec('this_year')).to eq Date.parse('2012-01-01')
-        expect(Date.parse_spec('this_year', :to)).to eq Date.parse('2012-12-31')
-        expect(Date.parse_spec('last_year')).to eq Date.parse('2011-01-01')
-        expect(Date.parse_spec('last_year', :to)).to eq Date.parse('2011-12-31')
-      end
-
-      it 'should parse forever and never' do
-        expect(Date.parse_spec('forever')).to eq Date::BOT
-        expect(Date.parse_spec('forever', :to)).to eq Date::EOT
-        expect(Date.parse_spec('never')).to be_nil
-      end
-
-      it 'should be able to convert a month name into its sequential number' do
-        expect(Date.mo_name_to_num(' January')).to eq 1
-        expect(Date.mo_name_to_num(' feb  ')).to eq 2
-        expect(Date.mo_name_to_num(' mAr  ')).to eq 3
-        expect(Date.mo_name_to_num(' Aprol  ')).to eq 4
-        expect(Date.mo_name_to_num("\t  \tmaybe")).to eq 5
-        expect(Date.mo_name_to_num("\t  \tjunta\t  \t")).to eq 6
-        expect(Date.mo_name_to_num("\t  \tjulia\t  \t")).to eq 7
-        expect(Date.mo_name_to_num("\t  \tAugustus\t  \t")).to eq 8
-        expect(Date.mo_name_to_num("September")).to eq 9
-        expect(Date.mo_name_to_num("octagon")).to eq 10
-        expect(Date.mo_name_to_num("   novena   this month")).to eq 11
-        expect(Date.mo_name_to_num("decimal")).to eq 12
-        expect(Date.mo_name_to_num("  dewey decimal")).to be nil
+      it 'parses relative halves: this_half, last_half' do
+        expect(described_class.parse_spec('this_half')).to eq described_class.parse('2012-07-01')
+        expect(described_class.parse_spec('this_half', :to)).to eq described_class.parse('2012-12-31')
+        expect(described_class.parse_spec('last_half')).to eq described_class.parse('2012-01-01')
+        expect(described_class.parse_spec('last_half', :to)).to eq described_class.parse('2012-06-30')
+      end
+
+      it 'parses relative years: this_year, last_year' do
+        expect(described_class.parse_spec('this_year')).to eq described_class.parse('2012-01-01')
+        expect(described_class.parse_spec('this_year', :to)).to eq described_class.parse('2012-12-31')
+        expect(described_class.parse_spec('last_year')).to eq described_class.parse('2011-01-01')
+        expect(described_class.parse_spec('last_year', :to)).to eq described_class.parse('2011-12-31')
+      end
+
+      it 'parses forever and never' do
+        expect(described_class.parse_spec('forever')).to eq Date::BOT
+        expect(described_class.parse_spec('forever', :to)).to eq Date::EOT
+        expect(described_class.parse_spec('never')).to be_nil
+      end
+
+      it 'converts a month name into its sequential number' do
+        expect(described_class.mo_name_to_num(' January')).to eq 1
+        expect(described_class.mo_name_to_num(' feb  ')).to eq 2
+        expect(described_class.mo_name_to_num(' mAr  ')).to eq 3
+        expect(described_class.mo_name_to_num(' Aprol  ')).to eq 4
+        expect(described_class.mo_name_to_num("\t  \tmaybe")).to eq 5
+        expect(described_class.mo_name_to_num("\t  \tjunta\t  \t")).to eq 6
+        expect(described_class.mo_name_to_num("\t  \tjulia\t  \t")).to eq 7
+        expect(described_class.mo_name_to_num("\t  \tAugustus\t  \t")).to eq 8
+        expect(described_class.mo_name_to_num("September")).to eq 9
+        expect(described_class.mo_name_to_num("octagon")).to eq 10
+        expect(described_class.mo_name_to_num("   novena   this month")).to eq 11
+        expect(described_class.mo_name_to_num("decimal")).to eq 12
+        expect(described_class.mo_name_to_num("  dewey decimal")).to be nil
       end
     end
   end
 
   describe 'instance methods' do
     describe 'print as string' do
-      it 'should be able to print itself as an American-style date' do
-        expect(Date.parse('2011-02-12').american).to eq('2/12/2011')
+      it 'prints itself as an American-style date' do
+        expect(described_class.parse('2011-02-12').american).to eq('2/12/2011')
       end
 
-      it 'should be able to print itself in iso form' do
-        expect(Date.today.iso).to eq '2012-07-18'
+      it 'prints itself in iso form' do
+        expect(described_class.today.iso).to eq '2012-07-18'
       end
 
-      it 'should be able to print itself in tex_quote form' do
-        expect(Date.today.tex_quote).to eq '2012--07--18'
+      it 'prints itself in tex_quote form' do
+        expect(described_class.today.tex_quote).to eq '2012--07--18'
       end
 
-      it 'should be able to print itself in org form' do
-        expect(Date.today.org).to eq('[2012-07-18 Wed]')
-        expect((Date.today + 1.day).org).to eq('[2012-07-19 Thu]')
-        expect((Date.today + 1.day).org(true)).to eq('<2012-07-19 Thu>')
+      it 'prints itself in org form' do
+        expect(described_class.today.org).to eq('[2012-07-18 Wed]')
+        expect((described_class.today + 1.day).org).to eq('[2012-07-19 Thu]')
+        expect((described_class.today + 1.day).org(true)).to eq('<2012-07-19 Thu>')
       end
 
-      it 'should be able to print itself in eng form' do
-        expect(Date.parse('2016-01-05').eng).to eq('January 5, 2016')
-        expect(Date.today.eng).to eq('July 18, 2012')
-        expect((Date.today + 1.day).eng).to eq('July 19, 2012')
+      it 'prints itself in eng form' do
+        expect(described_class.parse('2016-01-05').eng).to eq('January 5, 2016')
+        expect(described_class.today.eng).to eq('July 18, 2012')
+        expect((described_class.today + 1.day).eng).to eq('July 19, 2012')
       end
 
-      it 'should be able to print itself in numeric form' do
-        expect(Date.today.num).to eq('20120718')
-        expect((Date.today + 1.day).num).to eq('20120719')
+      it 'prints itself in numeric form' do
+        expect(described_class.today.num).to eq('20120718')
+        expect((described_class.today + 1.day).num).to eq('20120719')
       end
     end
 
     describe 'date arithmetic' do
-      it 'should know if its the nth weekday in a given month' do
-        expect(Date.parse('2014-11-13').nth_wday_in_month?(2, 4, 11))
+      it 'knows if its the nth weekday in a given month' do
+        expect(described_class.parse('2014-11-13').nth_wday_in_month?(2, 4, 11))
           .to be true
-        expect(Date.parse('2014-11-13').nth_wday_in_month?(-3, 4, 11))
+        expect(described_class.parse('2014-11-13').nth_wday_in_month?(-3, 4, 11))
           .to be true
-        expect(Date.parse('2014-11-13').nth_wday_in_month?(2, 4, 10))
+        expect(described_class.parse('2014-11-13').nth_wday_in_month?(2, 4, 10))
           .to be false
       end
 
-      it 'should know if its a weekend or a weekday' do
-        expect(Date.parse('2014-05-17')).to be_weekend
-        expect(Date.parse('2014-05-17')).to_not be_weekday
-        expect(Date.parse('2014-05-18')).to be_weekend
-        expect(Date.parse('2014-05-18')).to_not be_weekday
-
-        expect(Date.parse('2014-05-22')).to be_weekday
-        expect(Date.parse('2014-05-22')).to_not be_weekend
-      end
-
-      it 'should know its pred and succ (for Range)' do
-        expect(Date.today.pred).to eq(Date.today - 1)
-        expect(Date.today.succ).to eq(Date.today + 1)
-      end
-
-      it 'should be able to state its quarter' do
-        expect(Date.today.quarter).to eq(3)
-        expect(Date.parse('2012-02-29').quarter).to eq(1)
-        expect(Date.parse('2012-01-01').quarter).to eq(1)
-        expect(Date.parse('2012-03-31').quarter).to eq(1)
-        expect(Date.parse('2012-04-01').quarter).to eq(2)
-        expect(Date.parse('2012-05-15').quarter).to eq(2)
-        expect(Date.parse('2012-06-30').quarter).to eq(2)
-        expect(Date.parse('2012-07-01').quarter).to eq(3)
-        expect(Date.parse('2012-08-15').quarter).to eq(3)
-        expect(Date.parse('2012-09-30').quarter).to eq(3)
-        expect(Date.parse('2012-10-01').quarter).to eq(4)
-        expect(Date.parse('2012-11-15').quarter).to eq(4)
-        expect(Date.parse('2012-12-31').quarter).to eq(4)
-      end
-
-      it 'should know about years' do
-        expect(Date.parse('2013-01-01')).to be_beginning_of_year
-        expect(Date.parse('2013-12-31')).to be_end_of_year
-        expect(Date.parse('2013-04-01')).to_not be_beginning_of_year
-        expect(Date.parse('2013-12-30')).to_not be_end_of_year
-      end
-
-      it 'should know about halves' do
-        expect(Date.parse('2013-01-01')).to be_beginning_of_half
-        expect(Date.parse('2013-12-31')).to be_end_of_half
-        expect(Date.parse('2013-07-01')).to be_beginning_of_half
-        expect(Date.parse('2013-06-30')).to be_end_of_half
-        expect(Date.parse('2013-05-01')).to_not be_beginning_of_half
-        expect(Date.parse('2013-05-01').half).to eq(1)
-        expect(Date.parse('2013-07-31').half).to eq(2)
-      end
-
-      it 'should know about quarters' do
-        expect(Date.parse('2013-01-01')).to be_beginning_of_quarter
-        expect(Date.parse('2013-12-31')).to be_end_of_quarter
-        expect(Date.parse('2013-04-01')).to be_beginning_of_quarter
-        expect(Date.parse('2013-06-30')).to be_end_of_quarter
-        expect(Date.parse('2013-05-01')).to_not be_beginning_of_quarter
-        expect(Date.parse('2013-07-31')).to_not be_end_of_quarter
-      end
-
-      it 'should know about bimonths' do
-        expect(Date.parse('2013-11-04').beginning_of_bimonth)
-          .to eq Date.parse('2013-11-01')
-        expect(Date.parse('2013-11-04').end_of_bimonth)
-          .to eq Date.parse('2013-12-31')
-        expect(Date.parse('2013-03-01')).to be_beginning_of_bimonth
-        expect(Date.parse('2013-04-30')).to be_end_of_bimonth
-        expect(Date.parse('2013-01-01')).to be_beginning_of_bimonth
-        expect(Date.parse('2013-12-31')).to be_end_of_bimonth
-        expect(Date.parse('2013-05-01')).to be_beginning_of_bimonth
-        expect(Date.parse('2013-06-30')).to be_end_of_bimonth
-        expect(Date.parse('2013-06-01')).to_not be_beginning_of_bimonth
-        expect(Date.parse('2013-07-31')).to_not be_end_of_bimonth
-      end
-
-      it 'should know about months' do
-        expect(Date.parse('2013-01-01')).to be_beginning_of_month
-        expect(Date.parse('2013-12-31')).to be_end_of_month
-        expect(Date.parse('2013-05-01')).to be_beginning_of_month
-        expect(Date.parse('2013-07-31')).to be_end_of_month
-        expect(Date.parse('2013-05-02')).to_not be_beginning_of_month
-        expect(Date.parse('2013-07-30')).to_not be_end_of_month
-      end
-
-      it 'should know about semimonths' do
-        expect(Date.parse('2013-11-24').beginning_of_semimonth)
-          .to eq Date.parse('2013-11-16')
-        expect(Date.parse('2013-11-04').beginning_of_semimonth)
-          .to eq Date.parse('2013-11-01')
-        expect(Date.parse('2013-11-04').end_of_semimonth)
-          .to eq Date.parse('2013-11-15')
-        expect(Date.parse('2013-11-24').end_of_semimonth)
-          .to eq Date.parse('2013-11-30')
-        expect(Date.parse('2013-03-01'))
+      it 'knows if its a weekend or a weekday' do
+        expect(described_class.parse('2014-05-17')).to be_weekend
+        expect(described_class.parse('2014-05-17')).not_to be_weekday
+        expect(described_class.parse('2014-05-18')).to be_weekend
+        expect(described_class.parse('2014-05-18')).not_to be_weekday
+
+        expect(described_class.parse('2014-05-22')).to be_weekday
+        expect(described_class.parse('2014-05-22')).not_to be_weekend
+      end
+
+      it 'knows its pred and succ (for Range)' do
+        expect(described_class.today.pred).to eq(described_class.today - 1)
+        expect(described_class.today.succ).to eq(described_class.today + 1)
+      end
+
+      it 'knows its quarter' do
+        expect(described_class.today.quarter).to eq(3)
+        expect(described_class.parse('2012-02-29').quarter).to eq(1)
+        expect(described_class.parse('2012-01-01').quarter).to eq(1)
+        expect(described_class.parse('2012-03-31').quarter).to eq(1)
+        expect(described_class.parse('2012-04-01').quarter).to eq(2)
+        expect(described_class.parse('2012-05-15').quarter).to eq(2)
+        expect(described_class.parse('2012-06-30').quarter).to eq(2)
+        expect(described_class.parse('2012-07-01').quarter).to eq(3)
+        expect(described_class.parse('2012-08-15').quarter).to eq(3)
+        expect(described_class.parse('2012-09-30').quarter).to eq(3)
+        expect(described_class.parse('2012-10-01').quarter).to eq(4)
+        expect(described_class.parse('2012-11-15').quarter).to eq(4)
+        expect(described_class.parse('2012-12-31').quarter).to eq(4)
+      end
+
+      it 'knows about years' do
+        expect(described_class.parse('2013-01-01')).to be_beginning_of_year
+        expect(described_class.parse('2013-12-31')).to be_end_of_year
+        expect(described_class.parse('2013-04-01')).not_to be_beginning_of_year
+        expect(described_class.parse('2013-12-30')).not_to be_end_of_year
+      end
+
+      it 'knows about halves' do
+        expect(described_class.parse('2013-01-01')).to be_beginning_of_half
+        expect(described_class.parse('2013-12-31')).to be_end_of_half
+        expect(described_class.parse('2013-07-01')).to be_beginning_of_half
+        expect(described_class.parse('2013-06-30')).to be_end_of_half
+        expect(described_class.parse('2013-05-01')).not_to be_beginning_of_half
+        expect(described_class.parse('2013-05-01').half).to eq(1)
+        expect(described_class.parse('2013-07-31').half).to eq(2)
+      end
+
+      it 'knows about quarters' do
+        expect(described_class.parse('2013-01-01')).to be_beginning_of_quarter
+        expect(described_class.parse('2013-12-31')).to be_end_of_quarter
+        expect(described_class.parse('2013-04-01')).to be_beginning_of_quarter
+        expect(described_class.parse('2013-06-30')).to be_end_of_quarter
+        expect(described_class.parse('2013-05-01')).not_to be_beginning_of_quarter
+        expect(described_class.parse('2013-07-31')).not_to be_end_of_quarter
+      end
+
+      it 'knows about bimonths' do
+        expect(described_class.parse('2013-11-04').beginning_of_bimonth)
+          .to eq described_class.parse('2013-11-01')
+        expect(described_class.parse('2013-11-04').end_of_bimonth)
+          .to eq described_class.parse('2013-12-31')
+        expect(described_class.parse('2013-03-01')).to be_beginning_of_bimonth
+        expect(described_class.parse('2013-04-30')).to be_end_of_bimonth
+        expect(described_class.parse('2013-01-01')).to be_beginning_of_bimonth
+        expect(described_class.parse('2013-12-31')).to be_end_of_bimonth
+        expect(described_class.parse('2013-05-01')).to be_beginning_of_bimonth
+        expect(described_class.parse('2013-06-30')).to be_end_of_bimonth
+        expect(described_class.parse('2013-06-01')).not_to be_beginning_of_bimonth
+        expect(described_class.parse('2013-07-31')).not_to be_end_of_bimonth
+      end
+
+      it 'knows about months' do
+        expect(described_class.parse('2013-01-01')).to be_beginning_of_month
+        expect(described_class.parse('2013-12-31')).to be_end_of_month
+        expect(described_class.parse('2013-05-01')).to be_beginning_of_month
+        expect(described_class.parse('2013-07-31')).to be_end_of_month
+        expect(described_class.parse('2013-05-02')).not_to be_beginning_of_month
+        expect(described_class.parse('2013-07-30')).not_to be_end_of_month
+      end
+
+      it 'knows about semimonths' do
+        expect(described_class.parse('2013-11-24').beginning_of_semimonth)
+          .to eq described_class.parse('2013-11-16')
+        expect(described_class.parse('2013-11-04').beginning_of_semimonth)
+          .to eq described_class.parse('2013-11-01')
+        expect(described_class.parse('2013-11-04').end_of_semimonth)
+          .to eq described_class.parse('2013-11-15')
+        expect(described_class.parse('2013-11-24').end_of_semimonth)
+          .to eq described_class.parse('2013-11-30')
+        expect(described_class.parse('2013-03-01'))
           .to be_beginning_of_semimonth
-        expect(Date.parse('2013-03-16'))
+        expect(described_class.parse('2013-03-16'))
           .to be_beginning_of_semimonth
-        expect(Date.parse('2013-04-15'))
+        expect(described_class.parse('2013-04-15'))
           .to be_end_of_semimonth
-        expect(Date.parse('2013-04-30'))
+        expect(described_class.parse('2013-04-30'))
           .to be_end_of_semimonth
       end
 
       it 'knows about biweeks' do
-        expect(Date.parse('2013-11-07').beginning_of_biweek)
-          .to eq Date.parse('2013-11-04')
-        expect(Date.parse('2013-11-07').end_of_biweek)
-          .to eq Date.parse('2013-11-17')
-        expect(Date.parse('2013-03-11')).to be_beginning_of_biweek
-        expect(Date.parse('2013-03-24')).to be_end_of_biweek
-        expect(Date.parse('2013-12-30').end_of_biweek)
-          .to eq Date.parse('2014-01-12')
-        expect(Date.parse('2009-12-30').end_of_biweek)
-          .to eq Date.parse('2010-01-03')
+        expect(described_class.parse('2013-11-07').beginning_of_biweek)
+          .to eq described_class.parse('2013-11-04')
+        expect(described_class.parse('2013-11-07').end_of_biweek)
+          .to eq described_class.parse('2013-11-17')
+        expect(described_class.parse('2013-03-11')).to be_beginning_of_biweek
+        expect(described_class.parse('2013-03-24')).to be_end_of_biweek
+        expect(described_class.parse('2013-12-30').end_of_biweek)
+          .to eq described_class.parse('2014-01-12')
+        expect(described_class.parse('2009-12-30').end_of_biweek)
+          .to eq described_class.parse('2010-01-03')
       end
 
       it 'knows that a Monday is the beginning of the week' do
         # A Monday
-        expect(Date.parse('2013-11-04')).to be_beginning_of_week
-        expect(Date.parse('2013-12-02')).to be_beginning_of_week
+        expect(described_class.parse('2013-11-04')).to be_beginning_of_week
+        expect(described_class.parse('2013-12-02')).to be_beginning_of_week
         # A Sunday
-        expect(Date.parse('2013-10-13')).to_not be_beginning_of_week
+        expect(described_class.parse('2013-10-13')).not_to be_beginning_of_week
       end
 
       it 'knows that a Sunday is the end of the week' do
         # A Sunday
-        expect(Date.parse('2013-11-10')).to be_end_of_week
-        expect(Date.parse('2013-12-08')).to be_end_of_week
+        expect(described_class.parse('2013-11-10')).to be_end_of_week
+        expect(described_class.parse('2013-12-08')).to be_end_of_week
         # A Saturday
-        expect(Date.parse('2013-10-19')).to_not be_end_of_week
-      end
-
-      it 'should know the beginning of non-week chunks' do
-        expect(Date.parse('2013-11-04').beginning_of_chunk(:year))
-          .to eq Date.parse('2013-01-01')
-        expect(Date.parse('2013-11-04').beginning_of_chunk(:half))
-          .to eq Date.parse('2013-07-01')
-        expect(Date.parse('2013-11-04').beginning_of_chunk(:quarter))
-          .to eq Date.parse('2013-10-01')
-        expect(Date.parse('2013-12-04').beginning_of_chunk(:bimonth))
-          .to eq Date.parse('2013-11-01')
-        expect(Date.parse('2013-11-04').beginning_of_chunk(:month))
-          .to eq Date.parse('2013-11-01')
-        expect(Date.parse('2013-11-04').beginning_of_chunk(:semimonth))
-          .to eq Date.parse('2013-11-01')
-        expect(Date.parse('2013-11-24').beginning_of_chunk(:semimonth))
-          .to eq Date.parse('2013-11-16')
+        expect(described_class.parse('2013-10-19')).not_to be_end_of_week
+      end
+
+      it 'knows the beginning of non-week chunks' do
+        expect(described_class.parse('2013-11-04').beginning_of_chunk(:year))
+          .to eq described_class.parse('2013-01-01')
+        expect(described_class.parse('2013-11-04').beginning_of_chunk(:half))
+          .to eq described_class.parse('2013-07-01')
+        expect(described_class.parse('2013-11-04').beginning_of_chunk(:quarter))
+          .to eq described_class.parse('2013-10-01')
+        expect(described_class.parse('2013-12-04').beginning_of_chunk(:bimonth))
+          .to eq described_class.parse('2013-11-01')
+        expect(described_class.parse('2013-11-04').beginning_of_chunk(:month))
+          .to eq described_class.parse('2013-11-01')
+        expect(described_class.parse('2013-11-04').beginning_of_chunk(:semimonth))
+          .to eq described_class.parse('2013-11-01')
+        expect(described_class.parse('2013-11-24').beginning_of_chunk(:semimonth))
+          .to eq described_class.parse('2013-11-16')
       end
 
       it 'knows the beginning and end of bi-week-based chunks' do
         # First Friday to prior Monday
-        expect(Date.parse('2013-11-08').beginning_of_chunk(:biweek))
-          .to eq Date.parse('2013-11-04')
+        expect(described_class.parse('2013-11-08').beginning_of_chunk(:biweek))
+          .to eq described_class.parse('2013-11-04')
         # Second Wednesday to 2 prior Monday
-        expect(Date.parse('2013-11-13').beginning_of_chunk(:biweek))
-          .to eq Date.parse('2013-11-04')
+        expect(described_class.parse('2013-11-13').beginning_of_chunk(:biweek))
+          .to eq described_class.parse('2013-11-04')
       end
 
       it 'knows the beginning and end of week-based chunks' do
         # A Friday to prior Monday
-        expect(Date.parse('2013-11-08').beginning_of_chunk(:week))
-          .to eq Date.parse('2013-11-04')
+        expect(described_class.parse('2013-11-08').beginning_of_chunk(:week))
+          .to eq described_class.parse('2013-11-04')
         # A Friday to following Sunday
-        expect(Date.parse('2013-11-08').end_of_chunk(:week))
-          .to eq Date.parse('2013-11-10')
+        expect(described_class.parse('2013-11-08').end_of_chunk(:week))
+          .to eq described_class.parse('2013-11-10')
         # A Sunday to prior Monday
-        expect(Date.parse('2013-11-10').beginning_of_chunk(:week))
-          .to eq Date.parse('2013-11-04')
+        expect(described_class.parse('2013-11-10').beginning_of_chunk(:week))
+          .to eq described_class.parse('2013-11-04')
         # A Sunday to itself
-        expect(Date.parse('2013-11-10').end_of_chunk(:week))
-          .to eq Date.parse('2013-11-10')
+        expect(described_class.parse('2013-11-10').end_of_chunk(:week))
+          .to eq described_class.parse('2013-11-10')
         expect {
-          Date.parse('2013-11-04').beginning_of_chunk(:wek)
+          described_class.parse('2013-11-04').beginning_of_chunk(:wek)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should be able to test the beginning of chunks' do
-        expect(Date.parse('2013-11-04').beginning_of_chunk?(:year))
+      it 'tests the beginning of chunks' do
+        expect(described_class.parse('2013-11-04').beginning_of_chunk?(:year))
           .to be false
-        expect(Date.parse('2013-01-01').beginning_of_chunk?(:year))
+        expect(described_class.parse('2013-01-01').beginning_of_chunk?(:year))
           .to be true
-        expect(Date.parse('2013-11-04').beginning_of_chunk?(:half))
+        expect(described_class.parse('2013-11-04').beginning_of_chunk?(:half))
           .to be false
-        expect(Date.parse('2013-01-01').beginning_of_chunk?(:half))
+        expect(described_class.parse('2013-01-01').beginning_of_chunk?(:half))
           .to be true
-        expect(Date.parse('2013-07-01').beginning_of_chunk?(:half))
+        expect(described_class.parse('2013-07-01').beginning_of_chunk?(:half))
           .to be true
-        expect(Date.parse('2013-11-04').beginning_of_chunk?(:quarter))
+        expect(described_class.parse('2013-11-04').beginning_of_chunk?(:quarter))
           .to be false
-        expect(Date.parse('2013-01-01').beginning_of_chunk?(:quarter))
+        expect(described_class.parse('2013-01-01').beginning_of_chunk?(:quarter))
           .to be true
-        expect(Date.parse('2013-07-01').beginning_of_chunk?(:quarter))
+        expect(described_class.parse('2013-07-01').beginning_of_chunk?(:quarter))
           .to be true
-        expect(Date.parse('2013-10-01').beginning_of_chunk?(:quarter))
+        expect(described_class.parse('2013-10-01').beginning_of_chunk?(:quarter))
           .to be true
-        expect(Date.parse('2013-11-04').beginning_of_chunk?(:bimonth))
+        expect(described_class.parse('2013-11-04').beginning_of_chunk?(:bimonth))
           .to be false
-        expect(Date.parse('2013-01-01').beginning_of_chunk?(:bimonth))
+        expect(described_class.parse('2013-01-01').beginning_of_chunk?(:bimonth))
           .to be true
-        expect(Date.parse('2013-02-01').beginning_of_chunk?(:bimonth))
+        expect(described_class.parse('2013-02-01').beginning_of_chunk?(:bimonth))
           .to be false
-        expect(Date.parse('2013-11-04').beginning_of_chunk?(:month))
+        expect(described_class.parse('2013-11-04').beginning_of_chunk?(:month))
           .to be false
-        expect(Date.parse('2013-01-01').beginning_of_chunk?(:month))
+        expect(described_class.parse('2013-01-01').beginning_of_chunk?(:month))
           .to be true
-        expect(Date.parse('2013-11-04').beginning_of_chunk?(:semimonth))
+        expect(described_class.parse('2013-11-04').beginning_of_chunk?(:semimonth))
           .to be false
-        expect(Date.parse('2013-01-01').beginning_of_chunk?(:semimonth))
+        expect(described_class.parse('2013-01-01').beginning_of_chunk?(:semimonth))
           .to be true
-        expect(Date.parse('2013-01-16').beginning_of_chunk?(:semimonth))
+        expect(described_class.parse('2013-01-16').beginning_of_chunk?(:semimonth))
           .to be true
-        expect(Date.parse('2013-11-01').beginning_of_chunk?(:week))
+        expect(described_class.parse('2013-11-01').beginning_of_chunk?(:week))
           .to be false
-        expect(Date.parse('2013-11-04').beginning_of_chunk?(:week))
+        expect(described_class.parse('2013-11-04').beginning_of_chunk?(:week))
           .to be true
         # Sunday is not beginning of commercial week
-        expect(Date.parse('2013-11-03').beginning_of_chunk?(:week))
+        expect(described_class.parse('2013-11-03').beginning_of_chunk?(:week))
           .to be false
-        expect(Date.parse('2013-11-01').beginning_of_chunk?(:day))
+        expect(described_class.parse('2013-11-01').beginning_of_chunk?(:day))
           .to be true
-        expect(Date.parse('2013-11-04').beginning_of_chunk?(:day))
+        expect(described_class.parse('2013-11-04').beginning_of_chunk?(:day))
           .to be true
-        expect(Date.parse('2013-11-03').beginning_of_chunk?(:day))
+        expect(described_class.parse('2013-11-03').beginning_of_chunk?(:day))
           .to be true
 
         expect {
-          Date.parse('2013-11-04').beginning_of_chunk?(:wek)
+          described_class.parse('2013-11-04').beginning_of_chunk?(:wek)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should be able to test the end of chunks' do
-        expect(Date.parse('2013-11-04').end_of_chunk?(:year))
+      it 'tests the end of chunks' do
+        expect(described_class.parse('2013-11-04').end_of_chunk?(:year))
           .to be false
-        expect(Date.parse('2013-12-31').end_of_chunk?(:year))
+        expect(described_class.parse('2013-12-31').end_of_chunk?(:year))
           .to be true
-        expect(Date.parse('2013-11-04').end_of_chunk?(:half))
+        expect(described_class.parse('2013-11-04').end_of_chunk?(:half))
           .to be false
-        expect(Date.parse('2013-12-31').end_of_chunk?(:half))
+        expect(described_class.parse('2013-12-31').end_of_chunk?(:half))
           .to be true
-        expect(Date.parse('2013-06-30').end_of_chunk?(:half))
+        expect(described_class.parse('2013-06-30').end_of_chunk?(:half))
           .to be true
-        expect(Date.parse('2013-11-04').end_of_chunk?(:quarter))
+        expect(described_class.parse('2013-11-04').end_of_chunk?(:quarter))
           .to be false
-        expect(Date.parse('2013-12-31').end_of_chunk?(:quarter))
+        expect(described_class.parse('2013-12-31').end_of_chunk?(:quarter))
           .to be true
-        expect(Date.parse('2013-06-30').end_of_chunk?(:quarter))
+        expect(described_class.parse('2013-06-30').end_of_chunk?(:quarter))
           .to be true
-        expect(Date.parse('2013-09-30').end_of_chunk?(:quarter))
+        expect(described_class.parse('2013-09-30').end_of_chunk?(:quarter))
           .to be true
-        expect(Date.parse('2013-11-04').end_of_chunk?(:bimonth))
+        expect(described_class.parse('2013-11-04').end_of_chunk?(:bimonth))
           .to be false
-        expect(Date.parse('2013-12-31').end_of_chunk?(:bimonth))
+        expect(described_class.parse('2013-12-31').end_of_chunk?(:bimonth))
           .to be true
-        expect(Date.parse('2013-02-01').end_of_chunk?(:bimonth))
+        expect(described_class.parse('2013-02-01').end_of_chunk?(:bimonth))
           .to be false
-        expect(Date.parse('2013-11-04').end_of_chunk?(:month))
+        expect(described_class.parse('2013-11-04').end_of_chunk?(:month))
           .to be false
-        expect(Date.parse('2013-12-31').end_of_chunk?(:month))
+        expect(described_class.parse('2013-12-31').end_of_chunk?(:month))
           .to be true
-        expect(Date.parse('2013-11-04').end_of_chunk?(:semimonth))
+        expect(described_class.parse('2013-11-04').end_of_chunk?(:semimonth))
           .to be false
-        expect(Date.parse('2013-12-31').end_of_chunk?(:semimonth))
+        expect(described_class.parse('2013-12-31').end_of_chunk?(:semimonth))
           .to be true
-        expect(Date.parse('2013-01-15').end_of_chunk?(:semimonth))
+        expect(described_class.parse('2013-01-15').end_of_chunk?(:semimonth))
           .to be true
-        expect(Date.parse('2013-11-01').end_of_chunk?(:week))
+        expect(described_class.parse('2013-11-01').end_of_chunk?(:week))
           .to be false
-        expect(Date.parse('2013-11-04').end_of_chunk?(:week))
+        expect(described_class.parse('2013-11-04').end_of_chunk?(:week))
           .to be false
         # Sunday is not end of commercial week
-        expect(Date.parse('2013-11-03').end_of_chunk?(:week))
+        expect(described_class.parse('2013-11-03').end_of_chunk?(:week))
           .to be true
-        expect(Date.parse('2013-11-01').end_of_chunk?(:day))
+        expect(described_class.parse('2013-11-01').end_of_chunk?(:day))
           .to be true
-        expect(Date.parse('2013-11-04').end_of_chunk?(:day))
+        expect(described_class.parse('2013-11-04').end_of_chunk?(:day))
           .to be true
-        expect(Date.parse('2013-11-03').end_of_chunk?(:day))
+        expect(described_class.parse('2013-11-03').end_of_chunk?(:day))
           .to be true
 
         expect {
-          Date.parse('2013-11-04').end_of_chunk?(:wek)
+          described_class.parse('2013-11-04').end_of_chunk?(:wek)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should be able to add a chunk sym to itself' do
-        # Date.today is '2012-07-18'
-        expect(Date.today.add_chunk(:year)).to eq(Date.parse('2013-07-18'))
-        expect(Date.today.add_chunk(:half)).to eq(Date.parse('2013-01-18'))
-        expect(Date.today.add_chunk(:quarter)).to eq(Date.parse('2012-10-18'))
-        expect(Date.today.add_chunk(:bimonth)).to eq(Date.parse('2012-09-18'))
-        expect(Date.today.add_chunk(:month)).to eq(Date.parse('2012-08-18'))
-        expect(Date.today.add_chunk(:semimonth)).to eq(Date.parse('2012-08-03'))
-        expect(Date.today.add_chunk(:biweek)).to eq(Date.parse('2012-08-01'))
-        expect(Date.today.add_chunk(:week)).to eq(Date.parse('2012-07-25'))
-        expect(Date.today.add_chunk(:day)).to eq(Date.parse('2012-07-19'))
+      it 'adds a chunk sym to itself' do
+        # described_class.today is '2012-07-18'
+        expect(described_class.today.add_chunk(:year)).to eq(described_class.parse('2013-07-18'))
+        expect(described_class.today.add_chunk(:half)).to eq(described_class.parse('2013-01-18'))
+        expect(described_class.today.add_chunk(:quarter)).to eq(described_class.parse('2012-10-18'))
+        expect(described_class.today.add_chunk(:bimonth)).to eq(described_class.parse('2012-09-18'))
+        expect(described_class.today.add_chunk(:month)).to eq(described_class.parse('2012-08-18'))
+        expect(described_class.today.add_chunk(:semimonth)).to eq(described_class.parse('2012-08-03'))
+        expect(described_class.today.add_chunk(:biweek)).to eq(described_class.parse('2012-08-01'))
+        expect(described_class.today.add_chunk(:week)).to eq(described_class.parse('2012-07-25'))
+        expect(described_class.today.add_chunk(:day)).to eq(described_class.parse('2012-07-19'))
         expect {
-          Date.today.add_chunk(:hour)
+          described_class.today.add_chunk(:hour)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should be able to add n chunks sym to itself' do
-        # Date.today is '2012-07-18'
-        expect(Date.today.add_chunk(:year, 5)).to eq(Date.parse('2017-07-18'))
-        expect(Date.today.add_chunk(:half, 5)).to eq(Date.parse('2015-01-18'))
-        expect(Date.today.add_chunk(:quarter, 5)).to eq(Date.parse('2013-10-18'))
-        expect(Date.today.add_chunk(:bimonth, 5)).to eq(Date.parse('2013-05-18'))
-        expect(Date.today.add_chunk(:month, 5)).to eq(Date.parse('2012-12-18'))
-        expect(Date.today.add_chunk(:semimonth, 5)).to eq(Date.parse('2012-10-03'))
-        expect(Date.today.add_chunk(:biweek, 5)).to eq(Date.parse('2012-09-26'))
-        expect(Date.today.add_chunk(:week, 5)).to eq(Date.parse('2012-08-22'))
-        expect(Date.today.add_chunk(:day, 5)).to eq(Date.parse('2012-07-23'))
+      it 'adds n chunks to itself' do
+        # described_class.today is '2012-07-18'
+        expect(described_class.today.add_chunk(:year, 5)).to eq(described_class.parse('2017-07-18'))
+        expect(described_class.today.add_chunk(:half, 5)).to eq(described_class.parse('2015-01-18'))
+        expect(described_class.today.add_chunk(:quarter, 5)).to eq(described_class.parse('2013-10-18'))
+        expect(described_class.today.add_chunk(:bimonth, 5)).to eq(described_class.parse('2013-05-18'))
+        expect(described_class.today.add_chunk(:month, 5)).to eq(described_class.parse('2012-12-18'))
+        expect(described_class.today.add_chunk(:semimonth, 5)).to eq(described_class.parse('2012-10-03'))
+        expect(described_class.today.add_chunk(:biweek, 5)).to eq(described_class.parse('2012-09-26'))
+        expect(described_class.today.add_chunk(:week, 5)).to eq(described_class.parse('2012-08-22'))
+        expect(described_class.today.add_chunk(:day, 5)).to eq(described_class.parse('2012-07-23'))
         expect {
-          Date.today.add_chunk(:hour)
+          described_class.today.add_chunk(:hour)
         }.to raise_error(ArgumentError)
       end
 
-      it 'should know the end of chunks' do
-        expect(Date.parse('2013-07-04').end_of_chunk(:year))
-          .to eq Date.parse('2013-12-31')
-        expect(Date.parse('2013-05-04').end_of_chunk(:half))
-          .to eq Date.parse('2013-06-30')
-        expect(Date.parse('2013-07-04').end_of_chunk(:quarter))
-          .to eq Date.parse('2013-09-30')
-        expect(Date.parse('2013-12-04').end_of_chunk(:bimonth))
-          .to eq Date.parse('2013-12-31')
-        expect(Date.parse('2013-07-04').end_of_chunk(:month))
-          .to eq Date.parse('2013-07-31')
-        expect(Date.parse('2013-11-04').end_of_chunk(:semimonth))
-          .to eq Date.parse('2013-11-15')
-        expect(Date.parse('2013-11-24').end_of_chunk(:semimonth))
-          .to eq Date.parse('2013-11-30')
-        expect(Date.parse('2013-11-08').end_of_chunk(:biweek))
-          .to eq Date.parse('2013-11-17')
-        expect(Date.parse('2013-07-04').end_of_chunk(:week))
-          .to eq Date.parse('2013-07-07')
+      it 'knows the end of chunks' do
+        expect(described_class.parse('2013-07-04').end_of_chunk(:year))
+          .to eq described_class.parse('2013-12-31')
+        expect(described_class.parse('2013-05-04').end_of_chunk(:half))
+          .to eq described_class.parse('2013-06-30')
+        expect(described_class.parse('2013-07-04').end_of_chunk(:quarter))
+          .to eq described_class.parse('2013-09-30')
+        expect(described_class.parse('2013-12-04').end_of_chunk(:bimonth))
+          .to eq described_class.parse('2013-12-31')
+        expect(described_class.parse('2013-07-04').end_of_chunk(:month))
+          .to eq described_class.parse('2013-07-31')
+        expect(described_class.parse('2013-11-04').end_of_chunk(:semimonth))
+          .to eq described_class.parse('2013-11-15')
+        expect(described_class.parse('2013-11-24').end_of_chunk(:semimonth))
+          .to eq described_class.parse('2013-11-30')
+        expect(described_class.parse('2013-11-08').end_of_chunk(:biweek))
+          .to eq described_class.parse('2013-11-17')
+        expect(described_class.parse('2013-07-04').end_of_chunk(:week))
+          .to eq described_class.parse('2013-07-07')
         expect {
-          Date.parse('2013-11-04').end_of_chunk(:wek)
+          described_class.parse('2013-11-04').end_of_chunk(:wek)
         }.to raise_error(ArgumentError)
       end
 
-      it "should know if it's within 6 months of another date" do
+      it "knows if it's within 6 months of another date" do
         # This uses Section 16's logic that one date is "within a
         # period of less than six months" of another date only if it
         # is within the date six months minus 2 days away from the
-        # current date.
-        expect(Date.parse('2014-01-12'))
-          .to be_within_6mos_of(Date.parse('2014-06-12'))
-        expect(Date.parse('2014-01-12'))
-          .not_to be_within_6mos_of(Date.parse('2014-07-12'))
-        expect(Date.parse('2014-01-12'))
-          .not_to be_within_6mos_of(Date.parse('2014-07-11'))
-        expect(Date.parse('2014-01-12'))
-          .to be_within_6mos_of(Date.parse('2014-07-10'))
+        # current described_class.
+        expect(described_class.parse('2014-01-12'))
+          .to be_within_6mos_of(described_class.parse('2014-06-12'))
+        expect(described_class.parse('2014-01-12'))
+          .not_to be_within_6mos_of(described_class.parse('2014-07-12'))
+        expect(described_class.parse('2014-01-12'))
+          .not_to be_within_6mos_of(described_class.parse('2014-07-11'))
+        expect(described_class.parse('2014-01-12'))
+          .to be_within_6mos_of(described_class.parse('2014-07-10'))
       end
 
       it "knows if it's within 6 months of another date if it's near end of month" do
         # This tests for the Jammies Interntional twist where there is no
-        # corresponding day in the sixth month before or after the given date.
+        # corresponding day in the sixth month before or after the given described_class.
 
         # Looking backward to Feb
-        expect(Date.parse('2014-02-28'))
-          .not_to be_within_6mos_of(Date.parse('2014-08-31'))
-        expect(Date.parse('2014-03-01'))
-          .not_to be_within_6mos_of(Date.parse('2014-08-31'))
-        expect(Date.parse('2014-03-02'))
-          .to be_within_6mos_of(Date.parse('2014-08-31'))
+        expect(described_class.parse('2014-02-28'))
+          .not_to be_within_6mos_of(described_class.parse('2014-08-31'))
+        expect(described_class.parse('2014-03-01'))
+          .not_to be_within_6mos_of(described_class.parse('2014-08-31'))
+        expect(described_class.parse('2014-03-02'))
+          .to be_within_6mos_of(described_class.parse('2014-08-31'))
         # Looking forward to Feb
-        expect(Date.parse('2015-02-28'))
-          .not_to be_within_6mos_of(Date.parse('2014-08-31'))
-        expect(Date.parse('2015-02-27'))
-          .not_to be_within_6mos_of(Date.parse('2014-08-31'))
-        expect(Date.parse('2015-02-26'))
-          .to be_within_6mos_of(Date.parse('2014-08-31'))
+        expect(described_class.parse('2015-02-28'))
+          .not_to be_within_6mos_of(described_class.parse('2014-08-31'))
+        expect(described_class.parse('2015-02-27'))
+          .not_to be_within_6mos_of(described_class.parse('2014-08-31'))
+        expect(described_class.parse('2015-02-26'))
+          .to be_within_6mos_of(described_class.parse('2014-08-31'))
         # Same in a leap year, backward
-        expect(Date.parse('2012-02-29'))
-          .not_to be_within_6mos_of(Date.parse('2012-08-31'))
-        expect(Date.parse('2012-03-01'))
-          .not_to be_within_6mos_of(Date.parse('2012-08-31'))
-        expect(Date.parse('2012-03-02'))
-          .to be_within_6mos_of(Date.parse('2012-08-31'))
+        expect(described_class.parse('2012-02-29'))
+          .not_to be_within_6mos_of(described_class.parse('2012-08-31'))
+        expect(described_class.parse('2012-03-01'))
+          .not_to be_within_6mos_of(described_class.parse('2012-08-31'))
+        expect(described_class.parse('2012-03-02'))
+          .to be_within_6mos_of(described_class.parse('2012-08-31'))
         # Same in a leap year, forward
-        expect(Date.parse('2012-02-29'))
-          .not_to be_within_6mos_of(Date.parse('2011-08-31'))
-        expect(Date.parse('2012-02-28'))
-          .not_to be_within_6mos_of(Date.parse('2011-08-31'))
-        expect(Date.parse('2012-02-27'))
-          .to be_within_6mos_of(Date.parse('2011-08-31'))
+        expect(described_class.parse('2012-02-29'))
+          .not_to be_within_6mos_of(described_class.parse('2011-08-31'))
+        expect(described_class.parse('2012-02-28'))
+          .not_to be_within_6mos_of(described_class.parse('2011-08-31'))
+        expect(described_class.parse('2012-02-27'))
+          .to be_within_6mos_of(described_class.parse('2011-08-31'))
 
         # Now try from October to April, as 31->30 test.
-        expect(Date.parse('2012-04-30'))
-          .not_to be_within_6mos_of(Date.parse('2012-10-31'))
-        expect(Date.parse('2012-05-01'))
-          .not_to be_within_6mos_of(Date.parse('2012-10-31'))
-        expect(Date.parse('2012-05-02'))
-          .to be_within_6mos_of(Date.parse('2012-10-31'))
+        expect(described_class.parse('2012-04-30'))
+          .not_to be_within_6mos_of(described_class.parse('2012-10-31'))
+        expect(described_class.parse('2012-05-01'))
+          .not_to be_within_6mos_of(described_class.parse('2012-10-31'))
+        expect(described_class.parse('2012-05-02'))
+          .to be_within_6mos_of(described_class.parse('2012-10-31'))
         # And forward
-        expect(Date.parse('2013-04-30'))
-          .not_to be_within_6mos_of(Date.parse('2012-10-31'))
-        expect(Date.parse('2013-04-29'))
-          .not_to be_within_6mos_of(Date.parse('2012-10-31'))
-        expect(Date.parse('2013-04-28'))
-          .to be_within_6mos_of(Date.parse('2012-10-31'))
+        expect(described_class.parse('2013-04-30'))
+          .not_to be_within_6mos_of(described_class.parse('2012-10-31'))
+        expect(described_class.parse('2013-04-29'))
+          .not_to be_within_6mos_of(described_class.parse('2012-10-31'))
+        expect(described_class.parse('2013-04-28'))
+          .to be_within_6mos_of(described_class.parse('2012-10-31'))
 
         # It's not symmetrical: notice the second example here is within six
         # months if measured from April, but not if measured from October.
-        expect(Date.parse('2012-10-31'))
-          .not_to be_within_6mos_of(Date.parse('2013-04-30'))
-        expect(Date.parse('2012-10-31'))
-          .to be_within_6mos_of(Date.parse('2013-04-29'))
-        expect(Date.parse('2012-10-31'))
-          .to be_within_6mos_of(Date.parse('2013-04-28'))
-
+        expect(described_class.parse('2012-10-31'))
+          .not_to be_within_6mos_of(described_class.parse('2013-04-30'))
+        expect(described_class.parse('2012-10-31'))
+          .to be_within_6mos_of(described_class.parse('2013-04-29'))
+        expect(described_class.parse('2012-10-31'))
+          .to be_within_6mos_of(described_class.parse('2013-04-28'))
       end
     end
 
     describe 'holidays' do
-      it 'should know Easter in its year' do
-        expect(Date.today.easter_this_year).to eq(Date.parse('2012-04-08'))
-        expect(Date.parse('2014-04-20').easter?).to be true
-        expect(Date.parse('2014-03-20').easter?).to be false
+      it 'knows Easter in its year' do
+        expect(described_class.today.easter_this_year).to eq(described_class.parse('2012-04-08'))
+        expect(described_class.parse('2014-04-20').easter?).to be true
+        expect(described_class.parse('2014-03-20').easter?).to be false
       end
 
-      it 'should know if its a federal holiday' do
+      it 'knows if its a federal holiday' do
         # Got these from:
         # http://www.opm.gov/policy-data-oversight/snow-dismissal-procedures/federal-holidays/
 
@@ -920,16 +919,16 @@ describe Date do
         # Friday, November 11   Veterans Day
         # Thursday, November 24   Thanksgiving Day
         # Tuesday, December 26 ***  Christmas Day
-        expect(Date.parse('2010-12-31')).to be_fed_holiday
-        expect(Date.parse('2011-01-17')).to be_fed_holiday
-        expect(Date.parse('2011-02-21')).to be_fed_holiday
-        expect(Date.parse('2011-05-30')).to be_fed_holiday
-        expect(Date.parse('2011-07-04')).to be_fed_holiday
-        expect(Date.parse('2011-09-05')).to be_fed_holiday
-        expect(Date.parse('2011-10-10')).to be_fed_holiday
-        expect(Date.parse('2011-11-11')).to be_fed_holiday
-        expect(Date.parse('2011-11-24')).to be_fed_holiday
-        expect(Date.parse('2011-12-26')).to be_fed_holiday
+        expect(described_class.parse('2010-12-31')).to be_fed_holiday
+        expect(described_class.parse('2011-01-17')).to be_fed_holiday
+        expect(described_class.parse('2011-02-21')).to be_fed_holiday
+        expect(described_class.parse('2011-05-30')).to be_fed_holiday
+        expect(described_class.parse('2011-07-04')).to be_fed_holiday
+        expect(described_class.parse('2011-09-05')).to be_fed_holiday
+        expect(described_class.parse('2011-10-10')).to be_fed_holiday
+        expect(described_class.parse('2011-11-11')).to be_fed_holiday
+        expect(described_class.parse('2011-11-24')).to be_fed_holiday
+        expect(described_class.parse('2011-12-26')).to be_fed_holiday
 
         # For 2014:
         # Wednesday, January 1  New Year's Day
@@ -942,19 +941,19 @@ describe Date do
         # Tuesday, November 11  Veterans Day
         # Thursday, November 27   Thanksgiving Day
         # Thursday, December 25   Christmas Day
-        expect(Date.parse('2014-01-01')).to be_fed_holiday
-        expect(Date.parse('2014-01-20')).to be_fed_holiday
-        expect(Date.parse('2014-02-17')).to be_fed_holiday
-        expect(Date.parse('2014-05-26')).to be_fed_holiday
-        expect(Date.parse('2014-07-04')).to be_fed_holiday
-        expect(Date.parse('2014-09-01')).to be_fed_holiday
-        expect(Date.parse('2014-10-13')).to be_fed_holiday
-        expect(Date.parse('2014-11-11')).to be_fed_holiday
-        expect(Date.parse('2014-11-27')).to be_fed_holiday
-        expect(Date.parse('2014-12-25')).to be_fed_holiday
+        expect(described_class.parse('2014-01-01')).to be_fed_holiday
+        expect(described_class.parse('2014-01-20')).to be_fed_holiday
+        expect(described_class.parse('2014-02-17')).to be_fed_holiday
+        expect(described_class.parse('2014-05-26')).to be_fed_holiday
+        expect(described_class.parse('2014-07-04')).to be_fed_holiday
+        expect(described_class.parse('2014-09-01')).to be_fed_holiday
+        expect(described_class.parse('2014-10-13')).to be_fed_holiday
+        expect(described_class.parse('2014-11-11')).to be_fed_holiday
+        expect(described_class.parse('2014-11-27')).to be_fed_holiday
+        expect(described_class.parse('2014-12-25')).to be_fed_holiday
         # Not holidays
-        expect(Date.parse('2014-02-14')).not_to be_fed_holiday
-        expect(Date.parse('2014-04-18')).not_to be_fed_holiday
+        expect(described_class.parse('2014-02-14')).not_to be_fed_holiday
+        expect(described_class.parse('2014-04-18')).not_to be_fed_holiday
 
         # For 2017:
         # Monday, January 2  New Year's Day
@@ -967,59 +966,59 @@ describe Date do
         # Friday, November 10  Veterans Day
         # Thursday, November 23   Thanksgiving Day
         # Monday, December 25   Christmas Day
-        expect(Date.parse('2017-01-02')).to be_fed_holiday
-        expect(Date.parse('2017-01-16')).to be_fed_holiday
-        expect(Date.parse('2017-02-20')).to be_fed_holiday
-        expect(Date.parse('2017-05-29')).to be_fed_holiday
-        expect(Date.parse('2017-07-04')).to be_fed_holiday
-        expect(Date.parse('2017-09-04')).to be_fed_holiday
-        expect(Date.parse('2017-10-09')).to be_fed_holiday
-        expect(Date.parse('2017-11-10')).to be_fed_holiday
-        expect(Date.parse('2017-11-23')).to be_fed_holiday
-        expect(Date.parse('2017-12-25')).to be_fed_holiday
+        expect(described_class.parse('2017-01-02')).to be_fed_holiday
+        expect(described_class.parse('2017-01-16')).to be_fed_holiday
+        expect(described_class.parse('2017-02-20')).to be_fed_holiday
+        expect(described_class.parse('2017-05-29')).to be_fed_holiday
+        expect(described_class.parse('2017-07-04')).to be_fed_holiday
+        expect(described_class.parse('2017-09-04')).to be_fed_holiday
+        expect(described_class.parse('2017-10-09')).to be_fed_holiday
+        expect(described_class.parse('2017-11-10')).to be_fed_holiday
+        expect(described_class.parse('2017-11-23')).to be_fed_holiday
+        expect(described_class.parse('2017-12-25')).to be_fed_holiday
 
         # 2003 and 2008 had Christmas on Thur and this apparently makes
         # the following Friday a holiday.  I can't find any authority
         # for this, but the government appeared to be shut down on these
         # days.
-        expect(Date.parse('2003-12-26')).to be_fed_holiday
-        expect(Date.parse('2008-12-26')).to be_fed_holiday
+        expect(described_class.parse('2003-12-26')).to be_fed_holiday
+        expect(described_class.parse('2008-12-26')).to be_fed_holiday
 
         # Some non-holidays
         # New Year's Eve is /not/ a holiday unless on a weekend
         # New Year's Eve on a Thursday
-        expect(Date.parse('2015-12-31')).not_to be_fed_holiday
+        expect(described_class.parse('2015-12-31')).not_to be_fed_holiday
         # New Year's Eve on a Saturday
-        expect(Date.parse('2016-12-31')).to be_fed_holiday
+        expect(described_class.parse('2016-12-31')).to be_fed_holiday
         # Monday
-        expect(Date.parse('2014-11-17')).not_to be_fed_holiday
+        expect(described_class.parse('2014-11-17')).not_to be_fed_holiday
         # Tuesday
-        expect(Date.parse('2014-11-18')).not_to be_fed_holiday
+        expect(described_class.parse('2014-11-18')).not_to be_fed_holiday
         # Wednesday
-        expect(Date.parse('2014-11-19')).not_to be_fed_holiday
+        expect(described_class.parse('2014-11-19')).not_to be_fed_holiday
         # Thursday
-        expect(Date.parse('2014-11-20')).not_to be_fed_holiday
+        expect(described_class.parse('2014-11-20')).not_to be_fed_holiday
         # Friday
-        expect(Date.parse('2014-11-21')).not_to be_fed_holiday
+        expect(described_class.parse('2014-11-21')).not_to be_fed_holiday
 
         # Weekends are holidays, regardless
-        expect(Date.parse('2014-11-22')).to be_fed_holiday
-        expect(Date.parse('2014-11-23')).to be_fed_holiday
+        expect(described_class.parse('2014-11-22')).to be_fed_holiday
+        expect(described_class.parse('2014-11-23')).to be_fed_holiday
       end
 
       it 'knows that Juneteenth is a federal holiday from 2021' do
-        expect(Date.parse('2020-06-19')).not_to be_fed_holiday
+        expect(described_class.parse('2020-06-19')).not_to be_fed_holiday
         # Saturday
-        expect(Date.parse('2021-06-19')).to be_fed_holiday
+        expect(described_class.parse('2021-06-19')).to be_fed_holiday
         # Observed Friday
-        expect(Date.parse('2021-06-18')).to be_fed_holiday
+        expect(described_class.parse('2021-06-18')).to be_fed_holiday
         # Sunday
-        expect(Date.parse('2022-06-19')).to be_fed_holiday
+        expect(described_class.parse('2022-06-19')).to be_fed_holiday
         # Observed Monday
-        expect(Date.parse('2022-06-20')).to be_fed_holiday
+        expect(described_class.parse('2022-06-20')).to be_fed_holiday
       end
 
-      it 'should know if its an NYSE holiday' do
+      it 'knows if its an NYSE holiday' do
         #################  2014         2015       2016
         # New Year's Day  January 1   January 1   January 1
         # Martin Luther King, Jr. Day   January 20  January 19  January 18
@@ -1030,191 +1029,191 @@ describe Date do
         # Labor Day   September 1   September 7   September 5
         # Thanksgiving Day  November 27   November 26   November 24
         # Christmas Day   December 25   December 25   December 26
-        expect(Date.parse('2014-01-01')).to be_nyse_holiday
-        expect(Date.parse('2014-01-20')).to be_nyse_holiday
-        expect(Date.parse('2014-02-17')).to be_nyse_holiday
-        expect(Date.parse('2014-04-18')).to be_nyse_holiday
-        expect(Date.parse('2014-05-26')).to be_nyse_holiday
-        expect(Date.parse('2014-07-04')).to be_nyse_holiday
-        expect(Date.parse('2014-09-01')).to be_nyse_holiday
-        expect(Date.parse('2014-10-13')).not_to be_nyse_holiday
-        expect(Date.parse('2014-11-11')).not_to be_nyse_holiday
-        expect(Date.parse('2014-11-27')).to be_nyse_holiday
-        expect(Date.parse('2014-12-25')).to be_nyse_holiday
-
-        expect(Date.parse('2015-01-01')).to be_nyse_holiday
-        expect(Date.parse('2015-01-19')).to be_nyse_holiday
-        expect(Date.parse('2015-02-16')).to be_nyse_holiday
-        expect(Date.parse('2015-04-03')).to be_nyse_holiday
-        expect(Date.parse('2015-05-25')).to be_nyse_holiday
-        expect(Date.parse('2015-07-03')).to be_nyse_holiday
-        expect(Date.parse('2015-09-07')).to be_nyse_holiday
-        expect(Date.parse('2015-10-13')).not_to be_nyse_holiday
-        expect(Date.parse('2015-11-11')).not_to be_nyse_holiday
-        expect(Date.parse('2015-11-26')).to be_nyse_holiday
-        expect(Date.parse('2015-12-25')).to be_nyse_holiday
-
-        expect(Date.parse('2016-01-01')).to be_nyse_holiday
-        expect(Date.parse('2016-01-18')).to be_nyse_holiday
-        expect(Date.parse('2016-02-15')).to be_nyse_holiday
-        expect(Date.parse('2016-03-25')).to be_nyse_holiday
-        expect(Date.parse('2016-05-30')).to be_nyse_holiday
-        expect(Date.parse('2016-07-04')).to be_nyse_holiday
-        expect(Date.parse('2016-09-05')).to be_nyse_holiday
-        expect(Date.parse('2016-10-13')).not_to be_nyse_holiday
-        expect(Date.parse('2016-11-11')).not_to be_nyse_holiday
-        expect(Date.parse('2016-11-26')).to be_nyse_holiday
-        expect(Date.parse('2016-12-26')).to be_nyse_holiday
+        expect(described_class.parse('2014-01-01')).to be_nyse_holiday
+        expect(described_class.parse('2014-01-20')).to be_nyse_holiday
+        expect(described_class.parse('2014-02-17')).to be_nyse_holiday
+        expect(described_class.parse('2014-04-18')).to be_nyse_holiday
+        expect(described_class.parse('2014-05-26')).to be_nyse_holiday
+        expect(described_class.parse('2014-07-04')).to be_nyse_holiday
+        expect(described_class.parse('2014-09-01')).to be_nyse_holiday
+        expect(described_class.parse('2014-10-13')).not_to be_nyse_holiday
+        expect(described_class.parse('2014-11-11')).not_to be_nyse_holiday
+        expect(described_class.parse('2014-11-27')).to be_nyse_holiday
+        expect(described_class.parse('2014-12-25')).to be_nyse_holiday
+
+        expect(described_class.parse('2015-01-01')).to be_nyse_holiday
+        expect(described_class.parse('2015-01-19')).to be_nyse_holiday
+        expect(described_class.parse('2015-02-16')).to be_nyse_holiday
+        expect(described_class.parse('2015-04-03')).to be_nyse_holiday
+        expect(described_class.parse('2015-05-25')).to be_nyse_holiday
+        expect(described_class.parse('2015-07-03')).to be_nyse_holiday
+        expect(described_class.parse('2015-09-07')).to be_nyse_holiday
+        expect(described_class.parse('2015-10-13')).not_to be_nyse_holiday
+        expect(described_class.parse('2015-11-11')).not_to be_nyse_holiday
+        expect(described_class.parse('2015-11-26')).to be_nyse_holiday
+        expect(described_class.parse('2015-12-25')).to be_nyse_holiday
+
+        expect(described_class.parse('2016-01-01')).to be_nyse_holiday
+        expect(described_class.parse('2016-01-18')).to be_nyse_holiday
+        expect(described_class.parse('2016-02-15')).to be_nyse_holiday
+        expect(described_class.parse('2016-03-25')).to be_nyse_holiday
+        expect(described_class.parse('2016-05-30')).to be_nyse_holiday
+        expect(described_class.parse('2016-07-04')).to be_nyse_holiday
+        expect(described_class.parse('2016-09-05')).to be_nyse_holiday
+        expect(described_class.parse('2016-10-13')).not_to be_nyse_holiday
+        expect(described_class.parse('2016-11-11')).not_to be_nyse_holiday
+        expect(described_class.parse('2016-11-26')).to be_nyse_holiday
+        expect(described_class.parse('2016-12-26')).to be_nyse_holiday
 
         # Some non-holidays
         # Monday
-        expect(Date.parse('2014-11-17')).not_to be_nyse_holiday
+        expect(described_class.parse('2014-11-17')).not_to be_nyse_holiday
         # Tuesday
-        expect(Date.parse('2014-11-18')).not_to be_nyse_holiday
+        expect(described_class.parse('2014-11-18')).not_to be_nyse_holiday
         # Wednesday
-        expect(Date.parse('2014-11-19')).not_to be_nyse_holiday
+        expect(described_class.parse('2014-11-19')).not_to be_nyse_holiday
         # Thursday
-        expect(Date.parse('2014-11-20')).not_to be_nyse_holiday
+        expect(described_class.parse('2014-11-20')).not_to be_nyse_holiday
         # Friday
-        expect(Date.parse('2014-11-21')).not_to be_nyse_holiday
+        expect(described_class.parse('2014-11-21')).not_to be_nyse_holiday
 
         # Weekends are holidays, regardless
-        expect(Date.parse('2014-11-22')).to be_nyse_holiday
-        expect(Date.parse('2014-11-23')).to be_nyse_holiday
+        expect(described_class.parse('2014-11-22')).to be_nyse_holiday
+        expect(described_class.parse('2014-11-23')).to be_nyse_holiday
 
         # 9-11 Attacks
-        expect(Date.parse('2001-09-11')).to be_nyse_holiday
-        expect(Date.parse('2001-09-14')).to be_nyse_holiday
+        expect(described_class.parse('2001-09-11')).to be_nyse_holiday
+        expect(described_class.parse('2001-09-14')).to be_nyse_holiday
 
         # 1968 Paperwork Crisis (Closed every Wed unless other holiday in
         # week) from June 12 to December 31, 1968
-        expect(Date.parse('1968-06-12')).to be_nyse_holiday
-        expect(Date.parse('1968-07-03')).not_to be_nyse_holiday
-        expect(Date.parse('1968-08-21')).to be_nyse_holiday
+        expect(described_class.parse('1968-06-12')).to be_nyse_holiday
+        expect(described_class.parse('1968-07-03')).not_to be_nyse_holiday
+        expect(described_class.parse('1968-08-21')).to be_nyse_holiday
 
         # Hurricane Sandy
-        expect(Date.parse('2012-10-29')).to be_nyse_holiday
-        expect(Date.parse('2012-10-30')).to be_nyse_holiday
+        expect(described_class.parse('2012-10-29')).to be_nyse_holiday
+        expect(described_class.parse('2012-10-30')).to be_nyse_holiday
 
         # Death of President Ford
-        expect(Date.parse('2007-01-02')).to be_nyse_holiday
+        expect(described_class.parse('2007-01-02')).to be_nyse_holiday
       end
 
-      it 'should know if it is a Federal workday' do
+      it 'knows if it is a Federal workday' do
         # Some holidays
-        expect(Date.parse('2017-02-20')).not_to be_fed_workday
-        expect(Date.parse('2017-05-29')).not_to be_fed_workday
-        expect(Date.parse('2017-07-04')).not_to be_fed_workday
+        expect(described_class.parse('2017-02-20')).not_to be_fed_workday
+        expect(described_class.parse('2017-05-29')).not_to be_fed_workday
+        expect(described_class.parse('2017-07-04')).not_to be_fed_workday
 
         # Some non-holidays
         # Monday
-        expect(Date.parse('2014-11-17')).to be_fed_workday
+        expect(described_class.parse('2014-11-17')).to be_fed_workday
         # Tuesday
-        expect(Date.parse('2014-11-18')).to be_fed_workday
+        expect(described_class.parse('2014-11-18')).to be_fed_workday
         # Wednesday
-        expect(Date.parse('2014-11-19')).to be_fed_workday
+        expect(described_class.parse('2014-11-19')).to be_fed_workday
         # Thursday
-        expect(Date.parse('2014-11-20')).to be_fed_workday
+        expect(described_class.parse('2014-11-20')).to be_fed_workday
         # Friday
-        expect(Date.parse('2014-11-21')).to be_fed_workday
+        expect(described_class.parse('2014-11-21')).to be_fed_workday
 
         # Weekends are holidays, regardless
-        expect(Date.parse('2014-11-22')).not_to be_fed_workday
-        expect(Date.parse('2014-11-23')).not_to be_fed_workday
+        expect(described_class.parse('2014-11-22')).not_to be_fed_workday
+        expect(described_class.parse('2014-11-23')).not_to be_fed_workday
       end
 
-      it 'should know if it is an NYSE workday' do
+      it 'knows if it is an NYSE workday' do
         # Some holidays
-        expect(Date.parse('2016-01-01')).not_to be_nyse_workday
-        expect(Date.parse('2016-01-18')).not_to be_nyse_workday
-        expect(Date.parse('2016-02-15')).not_to be_nyse_workday
+        expect(described_class.parse('2016-01-01')).not_to be_nyse_workday
+        expect(described_class.parse('2016-01-18')).not_to be_nyse_workday
+        expect(described_class.parse('2016-02-15')).not_to be_nyse_workday
 
         # Some non-holidays
         # Monday
-        expect(Date.parse('2014-11-17')).to be_nyse_workday
+        expect(described_class.parse('2014-11-17')).to be_nyse_workday
         # Tuesday
-        expect(Date.parse('2014-11-18')).to be_nyse_workday
+        expect(described_class.parse('2014-11-18')).to be_nyse_workday
         # Wednesday
-        expect(Date.parse('2014-11-19')).to be_nyse_workday
+        expect(described_class.parse('2014-11-19')).to be_nyse_workday
         # Thursday
-        expect(Date.parse('2014-11-20')).to be_nyse_workday
+        expect(described_class.parse('2014-11-20')).to be_nyse_workday
         # Friday
-        expect(Date.parse('2014-11-21')).to be_nyse_workday
+        expect(described_class.parse('2014-11-21')).to be_nyse_workday
 
         # Weekends are holidays, regardless
-        expect(Date.parse('2014-11-22')).not_to be_nyse_workday
-        expect(Date.parse('2014-11-23')).not_to be_nyse_workday
+        expect(described_class.parse('2014-11-22')).not_to be_nyse_workday
+        expect(described_class.parse('2014-11-23')).not_to be_nyse_workday
 
         # Alias to trading_day?
-        expect(Date.parse('2014-11-22')).not_to be_trading_day
-        expect(Date.parse('2014-11-23')).not_to be_trading_day
+        expect(described_class.parse('2014-11-22')).not_to be_trading_day
+        expect(described_class.parse('2014-11-23')).not_to be_trading_day
       end
 
-      it 'should know the next federal workday' do
-        expect(Date.parse('2015-12-31').next_fed_workday)
-          .to eq Date.parse('2016-01-04')
-        expect(Date.parse('2016-04-20').next_fed_workday)
-          .to eq Date.parse('2016-04-21')
-        expect(Date.parse('2016-04-22').next_fed_workday)
-          .to eq Date.parse('2016-04-25')
+      it 'knows the next federal workday' do
+        expect(described_class.parse('2015-12-31').next_fed_workday)
+          .to eq described_class.parse('2016-01-04')
+        expect(described_class.parse('2016-04-20').next_fed_workday)
+          .to eq described_class.parse('2016-04-21')
+        expect(described_class.parse('2016-04-22').next_fed_workday)
+          .to eq described_class.parse('2016-04-25')
       end
 
-      it 'should know the prior federal workday' do
-        expect(Date.parse('2016-01-04').prior_fed_workday)
-          .to eq Date.parse('2015-12-31')
-        expect(Date.parse('2016-04-21').prior_fed_workday)
-          .to eq Date.parse('2016-04-20')
-        expect(Date.parse('2016-04-25').prior_fed_workday)
-          .to eq Date.parse('2016-04-22')
+      it 'knows the prior federal workday' do
+        expect(described_class.parse('2016-01-04').prior_fed_workday)
+          .to eq described_class.parse('2015-12-31')
+        expect(described_class.parse('2016-04-21').prior_fed_workday)
+          .to eq described_class.parse('2016-04-20')
+        expect(described_class.parse('2016-04-25').prior_fed_workday)
+          .to eq described_class.parse('2016-04-22')
       end
 
-      it 'should know the next NYSE workday' do
-        expect(Date.parse('2015-12-31').next_nyse_workday)
-          .to eq Date.parse('2016-01-04')
-        expect(Date.parse('2016-04-20').next_nyse_workday)
-          .to eq Date.parse('2016-04-21')
-        expect(Date.parse('2016-04-22').next_nyse_workday)
-          .to eq Date.parse('2016-04-25')
-        expect(Date.parse('2016-04-22').next_trading_day)
-          .to eq Date.parse('2016-04-25')
+      it 'knows the next NYSE workday' do
+        expect(described_class.parse('2015-12-31').next_nyse_workday)
+          .to eq described_class.parse('2016-01-04')
+        expect(described_class.parse('2016-04-20').next_nyse_workday)
+          .to eq described_class.parse('2016-04-21')
+        expect(described_class.parse('2016-04-22').next_nyse_workday)
+          .to eq described_class.parse('2016-04-25')
+        expect(described_class.parse('2016-04-22').next_trading_day)
+          .to eq described_class.parse('2016-04-25')
       end
 
-      it 'should know the prior NYSE workday' do
+      it 'knows the prior NYSE workday' do
         # The Monday after Easter; go to prior Thur since Good Friday
         # is an NYSE holiday.
-        expect(Date.parse('2014-04-21').prior_nyse_workday)
-          .to eq Date.parse('2014-04-17')
-        expect(Date.parse('2016-01-04').prior_nyse_workday)
-          .to eq Date.parse('2015-12-31')
-        expect(Date.parse('2016-04-21').prior_nyse_workday)
-          .to eq Date.parse('2016-04-20')
-        expect(Date.parse('2016-04-25').prior_nyse_workday)
-          .to eq Date.parse('2016-04-22')
-        expect(Date.parse('2016-04-25').prior_trading_day)
-          .to eq Date.parse('2016-04-22')
-      end
-
-      it 'should be able to skip until it hits a trading day' do
+        expect(described_class.parse('2014-04-21').prior_nyse_workday)
+          .to eq described_class.parse('2014-04-17')
+        expect(described_class.parse('2016-01-04').prior_nyse_workday)
+          .to eq described_class.parse('2015-12-31')
+        expect(described_class.parse('2016-04-21').prior_nyse_workday)
+          .to eq described_class.parse('2016-04-20')
+        expect(described_class.parse('2016-04-25').prior_nyse_workday)
+          .to eq described_class.parse('2016-04-22')
+        expect(described_class.parse('2016-04-25').prior_trading_day)
+          .to eq described_class.parse('2016-04-22')
+      end
+
+      it 'can skip until it hits a trading day' do
         # A Wednesday
-        expect(Date.parse('2014-03-26').prior_until_trading_day)
-          .to eq(Date.parse('2014-03-26'))
+        expect(described_class.parse('2014-03-26').prior_until_trading_day)
+          .to eq(described_class.parse('2014-03-26'))
         # A Sunday
-        expect(Date.parse('2014-03-30').prior_until_trading_day)
-          .to eq(Date.parse('2014-03-28'))
+        expect(described_class.parse('2014-03-30').prior_until_trading_day)
+          .to eq(described_class.parse('2014-03-28'))
         # A Wednesday
-        expect(Date.parse('2014-03-26').next_until_trading_day)
-          .to eq(Date.parse('2014-03-26'))
+        expect(described_class.parse('2014-03-26').next_until_trading_day)
+          .to eq(described_class.parse('2014-03-26'))
         # A Sunday
-        expect(Date.parse('2014-03-30').next_until_trading_day)
-          .to eq(Date.parse('2014-03-31'))
+        expect(described_class.parse('2014-03-30').next_until_trading_day)
+          .to eq(described_class.parse('2014-03-31'))
       end
 
-      it 'should be able to add n trading days' do
+      it 'can add n trading days' do
         # Add n trading days
-        expect(Date.parse('2014-03-30').add_trading_days(10))
-          .to eq(Date.parse('2014-04-11'))
-        expect(Date.parse('2014-03-30').add_trading_days(-10))
-          .to eq(Date.parse('2014-03-17'))
+        expect(described_class.parse('2014-03-30').add_trading_days(10))
+          .to eq(described_class.parse('2014-04-11'))
+        expect(described_class.parse('2014-03-30').add_trading_days(-10))
+          .to eq(described_class.parse('2014-03-17'))
       end
     end
   end