timely 0.5.0 → 0.6.0

data/spec/date_group_spec.rb

@@ -1,23 +1,29 @@
-require "spec_helper"
+# frozen_string_literal: true
 
+require 'spec_helper'
 
 RSpec.describe Timely::DateGroup do
   before do
     @date_group = Timely::DateGroup.new(
-      :start_date => '2000-01-01', :end_date => '2000-01-03', :weekdays => %w(1 1 1 1 1 1 1)
+      start_date: '2000-01-01', end_date: '2000-01-03', weekdays: %w[1 1 1 1 1 1 1]
     )
   end
 
+  it 'is not valid to set nil weekdays' do
+    @date_group.weekdays_bit_array = nil
+    expect(@date_group).not_to be_valid
+  end
+
   it 'should detect overlaps' do
     expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-01'.to_date))).to be true
     expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-06'.to_date))).to be true
     expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2001-01-01'.to_date, '2001-01-01'.to_date))).to be false
-    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('1999-12-29'.to_date, '2000-01-05'.to_date))).to be true 
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('1999-12-29'.to_date, '2000-01-05'.to_date))).to be true
   end
 
   it "should detect overlaps when certain weekdays aren't selected" do
     @date_group = Timely::DateGroup.create!(
-      :start_date => '2012-01-01', :end_date => '2012-01-07', :weekdays => %w(1 0 1 0 1 0 1)
+      start_date: '2012-01-01', end_date: '2012-01-07', weekdays: %w[1 0 1 0 1 0 1]
     )
     # Note: 2012-01-1 is a Sunday
     expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-01'.to_date, '2012-01-01'.to_date))).to be true
@@ -27,21 +33,18 @@ RSpec.describe Timely::DateGroup do
   end
 end
 
+RSpec.describe Timely::DateGroup, 'without weekdays' do
+  subject { Timely::DateGroup.new(start_date: Date.current, end_date: Date.current) }
+  it { is_expected.to be_valid }
+end
 
 RSpec.describe 'Timely::DateGroup.for_any_weekdays' do
   let(:date_range) { ('2019-10-17'.to_date)..('2019-10-18'.to_date) }
   let(:weekdays_int) { Timely::WeekDays.from_range(date_range).weekdays_int }
 
-  let(:special_group) {
-    Timely::DateGroup.create(start_date: date_range.first, end_date: date_range.last).tap { |date_group|
-      date_group.update_column(:weekdays_bit_array, nil)
-    }.reload
-  }
-
   let!(:date_groups) { [
     Timely::DateGroup.create(start_date: date_range.first, end_date: date_range.last, weekdays: { thu: true }),
     Timely::DateGroup.create(start_date: date_range.first, end_date: date_range.last, weekdays: { mon: true }),
-    special_group,
   ] }
 
   RSpec.shared_examples 'finds expected date groups' do
@@ -61,15 +64,15 @@ RSpec.describe 'Timely::DateGroup.for_any_weekdays' do
 
   context '#within_range' do
     let(:scoped_result) { Timely::DateGroup.within_range(date_range).to_a }
-    let(:expected_groups) { [ date_groups[0], date_groups[1], date_groups[2] ] }
-    let(:absent_groups) { [ ] }
+    let(:expected_groups) { [date_groups[0], date_groups[1]] }
+    let(:absent_groups) { [] }
     let(:includes_date_groups) { [] }
     it_behaves_like 'finds expected date groups'
   end
 
   let(:includes_date_groups) { expected_groups }
-  let(:expected_groups) { [ date_groups[0], date_groups[2] ] }
-  let(:absent_groups) { [ date_groups[1] ] }
+  let(:expected_groups) { [date_groups[0]] }
+  let(:absent_groups) { [date_groups[1]] }
 
   context '#for_any_weekdays' do
     let(:scoped_result) { Timely::DateGroup.for_any_weekdays(weekdays_int).to_a }

data/spec/date_range_spec.rb

@@ -1,22 +1,23 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Timely::DateRange do
-
-  it "should allow initialization with two dates" do
+  it 'should allow initialization with two dates' do
     expect { @date_range = Timely::DateRange.new(Date.today, Date.today + 3) }.to_not raise_error
     expect(@date_range.start_date).to eq Date.today
     expect(@date_range.end_date).to eq Date.today + 3
     expect(@date_range.number_of_nights).to eq 4
   end
 
-  it "should allow initialization with one date" do
+  it 'should allow initialization with one date' do
     expect { @date_range = Timely::DateRange.new(Date.today) }.to_not raise_error
     expect(@date_range.start_date).to eq Date.today
     expect(@date_range.end_date).to eq Date.today
     expect(@date_range.number_of_nights).to eq 1
   end
 
-  it "should allow initialization with a range" do
+  it 'should allow initialization with a range' do
     expect { @date_range = Timely::DateRange.new(Date.today..Date.today + 3) }.to_not raise_error
     expect(@date_range.start_date).to eq Date.today
     expect(@date_range.end_date).to eq Date.today + 3
@@ -59,21 +60,30 @@ describe Timely::DateRange do
     expect(today.last).to eq '2000-01-05'.to_date
   end
 
-  it "should correctly find the interesection between two date ranges" do
-    @date_range = Timely::DateRange.new("2000-01-03".to_date, "2000-01-06".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-07".to_date))).to eq ("2000-01-04".to_date.."2000-01-06".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-02".to_date))).to eq []
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-03".to_date))).to eq ("2000-01-03".to_date.."2000-01-03".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-06".to_date, "2000-01-07".to_date))).to eq ("2000-01-06".to_date.."2000-01-06".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-06".to_date, "2000-01-07".to_date))).to eq ("2000-01-06".to_date.."2000-01-06".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-05".to_date))).to eq ("2000-01-04".to_date.."2000-01-05".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-05".to_date, "2000-01-05".to_date))).to eq ("2000-01-05".to_date.."2000-01-05".to_date)
+  it 'should correctly find the interesection between two date ranges' do
+    @date_range = Timely::DateRange.new('2000-01-03'.to_date, '2000-01-06'.to_date)
+    {
+      ['2000-01-04'.to_date, '2000-01-07'.to_date] => '2000-01-04'.to_date..'2000-01-06'.to_date,
+      ['2000-01-01'.to_date, '2000-01-02'.to_date] => [],
+      ['2000-01-01'.to_date, '2000-01-03'.to_date] => '2000-01-03'.to_date..'2000-01-03'.to_date,
+      ['2000-01-06'.to_date, '2000-01-07'.to_date] => '2000-01-06'.to_date..'2000-01-06'.to_date,
+      ['2000-01-06'.to_date, '2000-01-07'.to_date] => '2000-01-06'.to_date..'2000-01-06'.to_date,
+      ['2000-01-04'.to_date, '2000-01-05'.to_date] => '2000-01-04'.to_date..'2000-01-05'.to_date,
+      ['2000-01-05'.to_date, '2000-01-05'.to_date] => '2000-01-05'.to_date..'2000-01-05'.to_date
+    }.each do |args, result|
+      tdr = Timely::DateRange.new(*args)
+      expect(@date_range.intersecting_dates(tdr)).to eq(result)
+    end
 
-    @date_range = Timely::DateRange.new("2000-01-03".to_date, "2000-01-03".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-07".to_date))).to eq []
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-03".to_date))).to eq ("2000-01-03".to_date.."2000-01-03".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-03".to_date, "2000-01-05".to_date))).to eq ("2000-01-03".to_date.."2000-01-03".to_date)
-    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-02".to_date, "2000-01-04".to_date))).to eq ("2000-01-03".to_date.."2000-01-03".to_date)
+    @date_range = Timely::DateRange.new('2000-01-03'.to_date, '2000-01-03'.to_date)
+    {
+      ['2000-01-04'.to_date, '2000-01-07'.to_date] => [],
+      ['2000-01-01'.to_date, '2000-01-03'.to_date] => '2000-01-03'.to_date..'2000-01-03'.to_date,
+      ['2000-01-03'.to_date, '2000-01-05'.to_date] => '2000-01-03'.to_date..'2000-01-03'.to_date,
+      ['2000-01-02'.to_date, '2000-01-04'.to_date] => '2000-01-03'.to_date..'2000-01-03'.to_date
+    }.each do |args, result|
+      tdr = Timely::DateRange.new(*args)
+      expect(@date_range.intersecting_dates(tdr)).to eq(result)
+    end
   end
-
 end

data/spec/date_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Date do
@@ -63,7 +65,7 @@ describe Date do
     end
 
     it 'should return the passed-in time on the date' do
-      @time = Time.now - 12345
+      @time = Time.now - 12_345
       expected = Time.local(@date.year, @date.month, @date.day, @time.hour, @time.min, @time.sec)
       expect(@date.at_time(@time)).to eq expected
     end

data/spec/extensions_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'timely/rails/extensions'
 
@@ -13,20 +15,14 @@ describe Timely::Extensions do
 
   it 'should cache boundary start' do
     season = Timely::Season.new
-    season.date_groups.build(:start_date => Date.current, :end_date => Date.current + 2)
-    season.date_groups.build(:start_date => Date.current - 1, :end_date => Date.current + 1)
+    season.date_groups.build(start_date: Date.current, end_date: Date.current + 2)
+    season.date_groups.build(start_date: Date.current - 1, end_date: Date.current + 1)
     season.save!
 
     o = TimelyExtensionsTestSeasonal.new
     o.season = season
     o.save!
     expect(o.boundary_start).to eq Date.current - 1
-    expect(o.boundary_end  ).to eq Date.current + 2
-
-    expect(TimelyExtensionsTestSeasonal.season_on(Date.current + 3)).to be_empty
-    expect(TimelyExtensionsTestSeasonal.season_on(Date.current + 2)).to eq [o]
-    expect(TimelyExtensionsTestSeasonal.season_on(Date.current - 1)).to eq [o]
-    expect(TimelyExtensionsTestSeasonal.season_on(Date.current - 2)).to be_empty
-
+    expect(o.boundary_end).to eq Date.current + 2
   end
 end

data/spec/rails/date_spec.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Date do
-  let(:date) { Date.parse("2010-01-01") }
+  let(:date) { Date.parse('2010-01-01') }
 
-  before { Time.zone = ActiveSupport::TimeZone["Adelaide"] }
+  before { Time.zone = ActiveSupport::TimeZone['Adelaide'] }
 
   subject(:converted) { date.to_time_in_time_zone }
 
-  it "should convert to time in time zone" do
+  it 'should convert to time in time zone' do
     expect(converted.year).to eq date.year
     expect(converted.month).to eq date.month
     expect(converted.day).to eq date.day

data/spec/rails/date_time_spec.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe DateTime do
-  let(:date_time) { parse_time("2010-01-01 00:00:00") }
+  let(:date_time) { parse_time('2010-01-01 00:00:00') }
 
-  it "should allow advancing by calendar days" do
+  it 'should allow advancing by calendar days' do
     expect(date_time.advance_considering_calendar(:calendar_days, 10))
-      .to eq parse_time("2010-01-10 23:59:59")
+      .to eq parse_time('2010-01-10 23:59:59')
   end
 
-  it "should allow advancing by calendar months" do
+  it 'should allow advancing by calendar months' do
     expect(date_time.advance_considering_calendar(:calendar_months, 10))
-      .to eq parse_time("2010-10-31 23:59:59")
+      .to eq parse_time('2010-10-31 23:59:59')
   end
 
-  it "should allow advancing by calendar years" do
+  it 'should allow advancing by calendar years' do
     expect(date_time.advance_considering_calendar(:calendar_years, 10))
-      .to eq parse_time("2019-12-31 23:59:59")
+      .to eq parse_time('2019-12-31 23:59:59')
   end
 
   def parse_time(time)

data/spec/rails/period_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 require 'timely/rails/period'

data/spec/rails/time_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 TestRailsTime = Class.new(Time) do
@@ -9,7 +11,7 @@ describe TestRailsTime do
 
   it 'should be able to set date on a time' do
     xmas = Date.new(2012, 12, 25)
-    lunch_time = TestRailsTime.parse("12:00")
+    lunch_time = TestRailsTime.parse('12:00')
     xmas_lunch = lunch_time.on_date(xmas)
     expect(xmas_lunch.year).to eq 2012
     expect(xmas_lunch.month).to eq 12
@@ -19,9 +21,9 @@ describe TestRailsTime do
     expect(xmas_lunch.sec).to eq 0
   end
 
-  it "should allow setting the date part given a date" do
-    time = TestRailsTime.parse("2010-01-01 09:30:00")
-    expect(time.on_date(Date.parse("2012-12-31"))).to eq TestRailsTime.zone.parse("2012-12-31 09:30:00")
+  it 'should allow setting the date part given a date' do
+    time = TestRailsTime.parse('2010-01-01 09:30:00')
+    expect(time.on_date(Date.parse('2012-12-31'))).to eq TestRailsTime.zone.parse('2012-12-31 09:30:00')
   end
 end
 

data/spec/schema.rb

@@ -1,4 +1,6 @@
-ActiveRecord::Schema.define(:version => 1) do
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define(version: 1) do
   create_table :seasonals do |t|
     t.date :boundary_start, :boundary_end
     t.integer :season_id
@@ -9,8 +11,7 @@ ActiveRecord::Schema.define(:version => 1) do
   end
 
   create_table :date_groups do |t|
-    t.integer :season_id, :weekdays_bit_array
+    t.integer :season_id, :weekdays_bit_array, null: false, default: Timely::WeekDays::ALL_WEEKDAYS.weekdays_int
     t.date :start_date, :end_date
   end
 end
-

data/spec/season_spec.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Timely::Season, "in general" do
+describe Timely::Season, 'in general' do
   before do
     # 1st and 3rd Quarter
     @simple_low_season = Timely::Season.new
-    @simple_low_season.date_groups.build(:start_date => '2009-01-01'.to_date, :end_date => '2009-03-31'.to_date)
-    @simple_low_season.date_groups.build(:start_date => '2009-07-01'.to_date, :end_date => '2009-09-30'.to_date)
+    @simple_low_season.date_groups.build(start_date: '2009-01-01'.to_date, end_date: '2009-03-31'.to_date)
+    @simple_low_season.date_groups.build(start_date: '2009-07-01'.to_date, end_date: '2009-09-30'.to_date)
 
     # 2nd and 4th Quarter
     @simple_high_season = Timely::Season.new
-    @simple_high_season.date_groups.build(:start_date => '2009-04-01'.to_date, :end_date => '2009-06-30'.to_date)
-    @simple_high_season.date_groups.build(:start_date => '2009-10-01'.to_date, :end_date => '2009-12-31'.to_date)
+    @simple_high_season.date_groups.build(start_date: '2009-04-01'.to_date, end_date: '2009-06-30'.to_date)
+    @simple_high_season.date_groups.build(start_date: '2009-10-01'.to_date, end_date: '2009-12-31'.to_date)
   end
 
-  it "be able to tell if a date is in or out of its season" do
+  it 'be able to tell if a date is in or out of its season' do
     low_season_date = '2009-02-22'.to_date
     high_season_date = '2009-04-22'.to_date
 
@@ -24,35 +26,31 @@ describe Timely::Season, "in general" do
     expect(@simple_high_season.includes_date?(high_season_date)).to be true
   end
 
-  it "should be able to tell the boundary range (the range including the absolute first and last date) of itself" do
+  it 'should be able to tell the boundary range (the range including the absolute first and last date) of itself' do
     expect(@simple_low_season.boundary_range).to eq('2009-01-01'.to_date..'2009-09-30'.to_date)
     expect(@simple_high_season.boundary_range).to eq('2009-04-01'.to_date..'2009-12-31'.to_date)
   end
-end
-
-
-describe Timely::Season, 'when asked to build season for given dates' do
-  subject(:season) { Timely::Season.build_season_for(dates) }
 
-  context 'when three dates' do
-    let(:dates) { [Date.current + 1, Date.current + 4, Date.current + 5] }
-    its(:class) { should eq Timely::Season }
-    its('date_groups.size') { should eq 3 }
+  context 'creating with nested attributes' do
+    subject { Timely::Season.new(date_groups_attributes: attrs) }
 
-    it "should generate proper date groups" do
-      expect(season.date_groups.first.start_date).to eq (Date.current + 1)
-      expect(season.date_groups.last.start_date).to eq (Date.current + 5)
-      expect(season.date_groups.last.end_date).to eq (Date.current + 5)
+    context 'with valid attributes' do
+      let(:attrs) { [ { 'start_date' => '2019-11-26' } ] }
+      it 'accepts nested date groups' do
+        expect(subject.date_groups).not_to be_empty
+        expect(subject.date_groups.first.start_date).to eq('2019-11-26'.to_date)
+      end
     end
-  end
 
-  context 'when dates are empty' do
-    let(:dates) { [] }
-    its(:date_groups) { should be_empty }
+    context 'invalid nested date groups' do
+      let(:attrs) { [ { 'start_date' => '' } ] }
+      it 'rejects nested date groups with nil start date' do
+        expect(subject.date_groups).to be_empty
+      end
+    end
   end
 end
 
-
 # == Schema Information
 #
 # Table name: seasons
@@ -62,4 +60,3 @@ end
 #  created_at :datetime
 #  updated_at :datetime
 #
-

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # Require this file using `require "spec_helper.rb"` to ensure that it is only
@@ -21,7 +23,7 @@ DB_FILE = 'tmp/test_db'
 FileUtils.mkdir_p File.dirname(DB_FILE)
 FileUtils.rm_f DB_FILE
 
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => DB_FILE
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: DB_FILE
 
 load('spec/schema.rb')
 

data/spec/support/coverage_loader.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 require 'simplecov-rcov'
 require 'coveralls'
 require 'coverage/kit'
-Coverage::Kit.setup(minimum_coverage: 69.15)
+Coverage::Kit.setup(minimum_coverage: 70.15)

data/spec/temporal_patterns_spec.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Timely::TemporalPatterns do
-
   before(:all) do
     @from = Date.new(2012, 1, 1)
     @to   = Date.new(2013, 4, 1)
   end
 
-  it "should be able to create a basic 1st-of-the-month recurrence pattern" do
+  it 'should be able to create a basic 1st-of-the-month recurrence pattern' do
     pattern = Timely::TemporalPatterns::Pattern.new([@from..@to], 1.month)
-    expect(pattern.to_s).to eq "every 1st of the month from 2012-01-01T00:00:00+00:00 to 2013-04-01T00:00:00+00:00"
+    expect(pattern.to_s).to eq 'every 1st of the month from 2012-01-01T00:00:00+00:00 to 2013-04-01T00:00:00+00:00'
 
     expect(pattern.match?('01-05-2012'.to_date)).to be true
     expect(pattern.match?('01-08-2012'.to_date)).to be true
@@ -19,10 +20,9 @@ describe Timely::TemporalPatterns do
     expect(pattern.match?('01-06-2013'.to_date)).to be false
   end
 
-  it "should only allow a positive duration to be set as the frequency of the pattern" do
+  it 'should only allow a positive duration to be set as the frequency of the pattern' do
     expect { Timely::TemporalPatterns::Frequency.new(2) }.to raise_error(ArgumentError)
     expect { Timely::TemporalPatterns::Frequency.new(-5.months) }.to raise_error(ArgumentError)
     expect(Timely::TemporalPatterns::Frequency.new(3.months).to_s).to eq 'every 3 months'
   end
-
 end

data/spec/time_since_spec.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'timely/time_since'
 
 require 'timecop'
 
 describe Timely::TimeSince do
-  before {
+  before do
     Timecop.freeze(DateTime.new(2000, 1, 10, 12, 0, 42))
-  }
+  end
   after { Timecop.return }
 
   context '42 seconds ago' do
@@ -17,8 +19,8 @@ describe Timely::TimeSince do
 
   context 'a day ago' do
     subject(:time) { DateTime.new(2000, 1, 9, 12, 0, 42) }
-    its(:seconds_since) { should eq 24*60*60 }
-    its(:minutes_since) { should eq 24*60 }
+    its(:seconds_since) { should eq 24 * 60 * 60 }
+    its(:minutes_since) { should eq 24 * 60 }
     its(:hours_since) { should eq 24 }
   end
 end

data/spec/time_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 TestTime = Class.new(Time) do
@@ -7,7 +9,7 @@ end
 describe Time do
   it 'should be able to set date on a time' do
     xmas = Date.new(2012, 12, 25)
-    lunch_time = TestTime.parse("12:00")
+    lunch_time = TestTime.parse('12:00')
     xmas_lunch = lunch_time.on_date(xmas)
     expect(xmas_lunch.year).to eq 2012
     expect(xmas_lunch.month).to eq 12
@@ -17,9 +19,9 @@ describe Time do
     expect(xmas_lunch.sec).to eq 0
   end
 
-  it "should allow setting the date part given a date" do
-    time = TestTime.parse("2010-01-01 09:30:00")
-    expect(time.on_date(Date.parse("2012-12-31"))).to eq Time.parse("2012-12-31 09:30:00")
+  it 'should allow setting the date part given a date' do
+    time = TestTime.parse('2010-01-01 09:30:00')
+    expect(time.on_date(Date.parse('2012-12-31'))).to eq Time.parse('2012-12-31 09:30:00')
   end
 end
 

data/spec/trackable_date_set_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Timely::TrackableDateSet, ' tracking 7 days' do
@@ -6,45 +8,45 @@ describe Timely::TrackableDateSet, ' tracking 7 days' do
     @trackable_date_set = Timely::TrackableDateSet.new(@range)
   end
 
-  it "should start on the first date" do
+  it 'should start on the first date' do
     expect(@trackable_date_set.start_date).to eq Date.today
   end
 
-  it "should end on the last date" do
+  it 'should end on the last date' do
     expect(@trackable_date_set.end_date).to eq Date.today + 6
   end
 
-  it "should have the 7 days set" do
-    expect(get_dates).to eq @range.to_a
+  it 'should have the 7 days set' do
+    expect(dates).to eq @range.to_a
     expect(@trackable_date_set.duration).to eq 7
     expect(@trackable_date_set.number_of_nights).to eq 7
   end
 
-  it "should have all the 7 days to do" do
-    expect(get_dates_to_do).to eq @range.to_a
+  it 'should have all the 7 days to do' do
+    expect(dates_to_do).to eq @range.to_a
     should_not_have_done(@range.to_a)
   end
 
-  it "should have only the last 6 days to do when we set_done! the first one" do
+  it 'should have only the last 6 days to do when we set_done! the first one' do
     @trackable_date_set.set_date_done!(Date.today)
-    expect(get_dates_to_do).to eq ((Date.today + 1)..(Date.today + 6)).to_a
+    expect(dates_to_do).to eq(((Date.today + 1)..(Date.today + 6)).to_a)
 
     should_not_have_done(@range.to_a - [Date.today])
     should_have_done([Date.today])
   end
 
-  it "should have the first, and last three left to do if we set 2nd, 3rd & 4th to be done" do
+  it 'should have the first, and last three left to do if we set 2nd, 3rd & 4th to be done' do
     dates_to_be_done = [Date.today + 1, Date.today + 2, Date.today + 3]
     @trackable_date_set.set_dates_done!(dates_to_be_done)
 
-    expect(get_dates_to_do).to eq [Date.today, Date.today + 4, Date.today + 5, Date.today + 6]
+    expect(dates_to_do).to eq [Date.today, Date.today + 4, Date.today + 5, Date.today + 6]
     should_not_have_done(@range.to_a - dates_to_be_done)
     should_have_done(dates_to_be_done)
   end
 
-  it "should have none left to do when set_all_done!" do
+  it 'should have none left to do when set_all_done!' do
     @trackable_date_set.set_all_done!
-    expect(get_dates_to_do).to eq []
+    expect(dates_to_do).to eq []
     should_have_done(@range.to_a)
   end
 
@@ -59,22 +61,22 @@ describe Timely::TrackableDateSet, ' tracking 7 days' do
   end
 
   def should_have_done(dates)
-    dates.each{|date| expect(@trackable_date_set.has_done?(date)).to be true }
+    dates.each { |date| expect(@trackable_date_set.done_dates?(date)).to be true }
   end
 
   def should_not_have_done(dates)
-    dates.each{|date| expect(@trackable_date_set.has_done?(date)).to be false }
+    dates.each { |date| expect(@trackable_date_set.done_dates?(date)).to be false }
   end
 
-  def get_dates
+  def dates
     contained_dates = []
-    @trackable_date_set.each_date{|date| contained_dates << date}
+    @trackable_date_set.each_date { |date| contained_dates << date }
     contained_dates
   end
 
-  def get_dates_to_do
+  def dates_to_do
     contained_dates = []
-    @trackable_date_set.each_date_to_do{|date| contained_dates << date}
+    @trackable_date_set.each_date_to_do { |date| contained_dates << date }
     contained_dates
   end
 end