timely 0.9.0 → 0.10.0

data/spec/date_group_spec.rb

@@ -1,124 +0,0 @@
-# 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]
-    )
-  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
-  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]
-    )
-    # 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
-    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-02'.to_date, '2012-01-02'.to_date))).to be false
-    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-03'.to_date, '2012-01-03'.to_date))).to be true
-    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,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Timely::DateRange 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
-    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
-    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
-  end
-
-  it 'should print a readable version of time between two dates' do
-    expect(Timely::DateRange.new('2000-01-04'.to_date, '2000-01-04'.to_date).to_s).to eq '2000-01-04'
-    expect(Timely::DateRange.new('2000-01-04'.to_date, '2000-01-06'.to_date).to_s).to eq '2000-01-04 to 2000-01-06 (inclusive)'
-    expect(Timely::DateRange.new('2000-01-01'.to_date, '2000-05-31'.to_date).to_s).to eq 'Jan 2000 to May 2000'
-    expect(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-31'.to_date).to_s).to eq 'Jan 2000'
-    expect(Timely::DateRange.new('2000-01-01'.to_date, '2001-01-31'.to_date).to_s).to eq 'Jan 2000 to Jan 2001'
-    Date::DATE_FORMATS[:short] = '%Y-%m-%d'
-    expect(Timely::DateRange.to_s('2000-01-01'.to_date, nil)).to eq 'on or after 2000-01-01'
-    expect(Timely::DateRange.to_s(nil, '2000-01-31'.to_date)).to eq 'on or before 2000-01-31'
-    expect(Timely::DateRange.to_s(nil, nil)).to eq 'no date range'
-  end
-
-  let(:fourth) { '2000-01-04'.to_date }
-  let(:fifth)  { '2000-01-05'.to_date }
-  let(:sixth)  { '2000-01-06'.to_date }
-
-  it 'should print a readable version of time between two times' do
-    expect(Timely::DateRange.to_s(fourth.at(9, 30), sixth.at(4, 20)))
-      .to eq '2000-01-04 09:30 to 2000-01-06 04:20'
-    expect(Timely::DateRange.to_s(fourth.at(9, 30)))
-      .to eq 'on or after 2000-01-04 09:30'
-  end
-
-  it 'should handle params' do
-    today = Timely::DateRange.from_params('2000-01-04')
-    expect(today.first).to eq '2000-01-04'.to_date
-    expect(today.last).to eq '2000-01-04'.to_date
-
-    today = Timely::DateRange.from_params('2000-01-04', '2')
-    expect(today.first).to eq '2000-01-04'.to_date
-    expect(today.last).to eq '2000-01-05'.to_date
-
-    today = Timely::DateRange.from_params('2000-01-04', 2)
-    expect(today.first).to eq '2000-01-04'.to_date
-    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)
-    {
-      ['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)
-    {
-      ['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,78 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Date do
-  it 'should determine if date between' do
-    expect(Date.today.between?(nil, nil)).to be true
-    expect(Date.today.between?(Date.today - 1, Date.today - 1)).to be false
-    expect(Date.today.between?(Date.today - 1, nil)).to be true
-  end
-end
-
-describe Date do
-  before :each do
-    @date = Date.today - 5
-
-    @hour   = 1
-    @minute = 2
-    @second = 3
-  end
-
-  it 'should give a time on that date' do
-    expect(@date).to respond_to(:at_time)
-  end
-
-  describe 'giving a time on that date' do
-    it 'should accept hour, minute, and second' do
-      expect { @date.at_time(@hour, @minute, @second) }.to_not raise_error
-    end
-
-    it 'should accept hour and minute' do
-      expect { @date.at_time(@hour, @minute) }.to_not raise_error
-    end
-
-    it 'should accept hour' do
-      expect { @date.at_time(@hour) }.to_not raise_error
-    end
-
-    it 'should accept no arguments' do
-      expect { @date.at_time }.to_not raise_error
-    end
-
-    it 'should return a time for the given hour, minute, and second if all three are specified' do
-      expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, @second)
-      expect(@date.at_time(@hour, @minute, @second)).to eq expected
-    end
-
-    it 'should default second to 0 if unspecified' do
-      expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, 0)
-      expect(@date.at_time(@hour, @minute)).to eq expected
-    end
-
-    it 'should default minute to 0 if unspecified' do
-      expected = Time.local(@date.year, @date.month, @date.day, @hour, 0, 0)
-      expect(@date.at_time(@hour)).to eq expected
-    end
-
-    it 'should default hour to 0 if unspecified' do
-      expected = Time.local(@date.year, @date.month, @date.day, 0, 0, 0)
-      expect(@date.at_time).to eq expected
-    end
-
-    it 'should accept a time' do
-      expect { @date.at_time(Time.now) }.to_not raise_error
-    end
-
-    it 'should return the passed-in time on the date' do
-      @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
-  end
-
-  it "should provide 'at' as an alias" do
-    expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, @second)
-    expect(@date.at(@hour, @minute, @second)).to eq expected
-  end
-end

data/spec/extensions_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'timely/rails/extensions'
-
-describe Timely::Extensions do
-  before do
-    class TimelyExtensionsTestSeasonal < ActiveRecord::Base
-      self.table_name = 'seasonals'
-      acts_as_seasonal
-    end
-  end
-
-  after { Object.send(:remove_const, 'TimelyExtensionsTestSeasonal') }
-
-  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.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
-  end
-end

data/spec/rails/date_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Date do
-  let(:date) { Date.parse('2010-01-01') }
-
-  before { Time.zone = ActiveSupport::TimeZone['Adelaide'] }
-
-  subject(:converted) { date.to_time_in_time_zone }
-
-  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
-    expect(converted.time_zone).to eq Time.zone
-  end
-end

data/spec/rails/date_time_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe DateTime do
-  let(:date_time) { parse_time('2010-01-01 00:00:00') }
-
-  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')
-  end
-
-  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')
-  end
-
-  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')
-  end
-
-  def parse_time(time)
-    # ActiveSupport 5.1+ returns end of day differently
-    # Returns with usec at 999999 vs 0
-    DateTime.parse(time).end_of_day
-  end
-end

data/spec/rails/period_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-require 'timely/rails/period'
-
-describe Timely::Period do
-  let(:time) { DateTime.new(2000, 1, 1, 12, 0, 0) }
-  let(:period_after_time) { DateTime.new(2000, 1, 1, 12, 2, 0) }
-  subject(:period) { Timely::Period.new(2, :minutes) }
-
-  it 'should work' do
-    expect(period.after(time)).to eq period_after_time
-  end
-
-  specify do
-    expect(period.to_s).to eq '2 minutes'
-  end
-end

data/spec/rails/time_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestRailsTime = Class.new(Time) do
-  include ::Timely::Rails::Time
-end
-
-describe TestRailsTime do
-  before { TestRailsTime.zone = 'Australia/Sydney' }
-
-  it 'should be able to set date on a time' do
-    xmas = Date.new(2012, 12, 25)
-    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
-    expect(xmas_lunch.day).to eq 25
-    expect(xmas_lunch.hour).to eq 12
-    expect(xmas_lunch.min).to eq 0
-    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')
-  end
-end
-
-describe Time do
-  before :each do
-    TestRailsTime.zone = 'Australia/Sydney'
-    @time = TestRailsTime.now
-
-    @year  = 2005
-    @month = 3
-    @day   = 15
-  end
-
-  it 'should give that time on a date' do
-    expect(@time).to respond_to(:on_date)
-  end
-
-  describe 'giving that time on a date' do
-    it 'should accept year, month and day' do
-      expect { @time.on_date(@year, @month, @day) }.to_not raise_error
-    end
-
-    it 'should require year, month, and day' do
-      expect { @time.on_date(@year, @month) }.to raise_error(ArgumentError)
-    end
-
-    it 'should return the same time on the specified year, month, and day' do
-      expected = TestRailsTime.zone.local(@year, @month, @day, @time.hour, @time.min, @time.sec)
-      expect(@time.on_date(@year, @month, @day)).to eq expected
-    end
-
-    it 'should accept a date' do
-      expect { @time.on_date(Date.today) }.to_not raise_error
-    end
-
-    it 'should return the same time on the specified date' do
-      @date = Date.today - 2345
-      expected = Time.zone.local(@date.year, @date.month, @date.day, @time.hour, @time.min, @time.sec)
-      expect(@time.on_date(@date)).to eq expected
-    end
-  end
-
-  it "should provide 'on' as an alias" do
-    expected = TestRailsTime.zone.local(@year, @month, @day, @time.hour, @time.min, @time.sec)
-    expect(@time.on(@year, @month, @day)).to eq expected
-  end
-end

data/spec/schema.rb

@@ -1,17 +0,0 @@
-# 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
-  end
-
-  create_table :seasons do |t|
-    t.string :name
-  end
-
-  create_table :date_groups do |t|
-    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,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-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)
-
-    # 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)
-  end
-
-  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
-
-    expect(@simple_low_season.includes_date?(low_season_date)).to be true
-    expect(@simple_high_season.includes_date?(low_season_date)).to_not be true
-
-    expect(@simple_low_season.includes_date?(high_season_date)).to_not be true
-    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
-    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
-
-  context 'creating with nested attributes' do
-    subject { Timely::Season.new(date_groups_attributes: attrs) }
-
-    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
-
-    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
-#
-#  id         :integer(4)      not null, primary key
-#  name       :string(255)
-#  created_at :datetime
-#  updated_at :datetime
-#

data/spec/spec_helper.rb

@@ -1,46 +0,0 @@
-# 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
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-
-require 'rubygems'
-require 'bundler/setup'
-require 'rspec/its'
-require 'active_record'
-require 'pry'
-require 'database_cleaner'
-
-require 'support/coverage_loader'
-
-I18n.enforce_available_locales = true if I18n.respond_to? :enforce_available_locales=
-
-require 'timely'
-require 'timely/rails'
-
-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
-
-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

data/spec/support/coverage_loader.rb

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

data/spec/temporal_patterns_spec.rb

@@ -1,28 +0,0 @@
-# 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
-    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.match?('01-05-2012'.to_date)).to be true
-    expect(pattern.match?('01-08-2012'.to_date)).to be true
-    expect(pattern.match?('01-04-2013'.to_date)).to be true
-
-    expect(pattern.match?('03-05-2012'.to_date)).to be false
-    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
-    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,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'timely/time_since'
-
-require 'timecop'
-
-describe Timely::TimeSince do
-  before do
-    Timecop.freeze(DateTime.new(2000, 1, 10, 12, 0, 42))
-  end
-  after { Timecop.return }
-
-  context '42 seconds ago' do
-    subject(:time) { DateTime.new(2000, 1, 10, 12, 0, 0) }
-    its(:seconds_since) { should eq 42 }
-    its(:minutes_since) { should eq 0 }
-    its(:hours_since) { should eq 0 }
-  end
-
-  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(:hours_since) { should eq 24 }
-  end
-end