timely 0.4.2 → 0.9.0

data/spec/date_group_spec.rb

@@ -1,21 +1,29 @@
-require "spec_helper"
-describe Timely::DateGroup do
+# 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
@@ -24,3 +32,93 @@ describe Timely::DateGroup do
     expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-01'.to_date, '2012-01-03'.to_date))).to be true
   end
 end
+
+RSpec.describe Timely::DateGroup, 'Timely::DateGroup.applying_for_duration' do
+  let!(:date_group_a) { Timely::DateGroup.create!(
+    start_date: '2020-01-01', end_date: '2020-04-04', weekdays: %w[1 1 1 1 1 1 1]
+  ) }
+
+  let!(:date_group_b) { Timely::DateGroup.create!(
+    start_date: '2020-04-02', end_date: '2020-04-09', weekdays: %w[1 1 1 1 1 1 1]
+  ) }
+
+  subject {
+    Timely::DateGroup.applying_for_duration(Timely::DateRange.new(start_date, end_date)).to_a
+  }
+
+  context 'intersecting dates (inside first)' do
+    let(:start_date) { '2020-03-29'.to_date }
+    let(:end_date) { '2020-04-13'.to_date }
+    it { is_expected.to eq([date_group_a, date_group_b]) }
+  end
+
+  context 'intersecting dates full range' do
+    let(:start_date) { '2020-01-01'.to_date }
+    let(:end_date) { '2020-04-09'.to_date }
+    it { is_expected.to eq([date_group_a, date_group_b]) }
+  end
+
+  context 'touching end of range' do
+    let(:start_date) { '2020-04-09'.to_date }
+    let(:end_date) { '2020-04-09'.to_date }
+    it { is_expected.to eq([date_group_b]) }
+  end
+
+  context 'touching start of range' do
+    let(:start_date) { '2020-04-01'.to_date }
+    let(:end_date) { '2020-04-01'.to_date }
+    it { is_expected.to eq([date_group_a]) }
+  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!(: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 }),
+  ] }
+
+  RSpec.shared_examples 'finds expected date groups' do
+    it 'finds expected date groups' do
+      includes_date_groups.each do |date_group|
+        expect(date_group.includes_date?(date_range.first)).to eq(true)
+      end
+      expected_groups.each do |date_group|
+        expect(scoped_result).to include(date_group)
+      end
+      absent_groups.each do |date_group|
+        expect(date_group.includes_date?(date_range.first)).to eq(false)
+        expect(scoped_result).not_to include(date_group)
+      end
+    end
+  end
+
+  context '#within_range' do
+    let(:scoped_result) { Timely::DateGroup.within_range(date_range).to_a }
+    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]] }
+  let(:absent_groups) { [date_groups[1]] }
+
+  context '#for_any_weekdays' do
+    let(:scoped_result) { Timely::DateGroup.for_any_weekdays(weekdays_int).to_a }
+    it_behaves_like 'finds expected date groups'
+  end
+
+  context '#applying_for_duration' do
+    let(:scoped_result) { Timely::DateGroup.applying_for_duration(date_range).to_a }
+    it_behaves_like 'finds expected date groups'
+  end
+end

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
@@ -9,6 +11,8 @@ require 'rubygems'
 require 'bundler/setup'
 require 'rspec/its'
 require 'active_record'
+require 'pry'
+require 'database_cleaner'
 
 require 'support/coverage_loader'
 
@@ -21,11 +25,22 @@ 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')
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation, except: %w(ar_internal_metadata))
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
 end