timeboss 0.3.1 → 1.1.0

data/spec/calendar/support/unit_spec.rb

@@ -1,33 +1,34 @@
 module TimeBoss
   class Calendar
     module Support
+      class TestChunkUnit < Unit
+      end
+
       describe Unit do
-        class ChunkUnit < described_class
-        end
-        let(:described_class) { ChunkUnit }
+        let(:described_class) { TestChunkUnit }
         let(:calendar) { double }
-        let(:start_date) { Date.parse('2018-06-25') }
-        let(:end_date) { Date.parse('2018-08-26') }
+        let(:start_date) { Date.parse("2018-06-25") }
+        let(:end_date) { Date.parse("2018-08-26") }
         let(:subject) { described_class.new(calendar, start_date, end_date) }
 
-        it 'knows its stuff' do
+        it "knows its stuff" do
           expect(subject.start_date).to eq start_date
           expect(subject.end_date).to eq end_date
           expect(subject.to_range).to eq start_date..end_date
         end
 
-        describe '#current?' do
-          it 'is not current right now' do
+        describe "#current?" do
+          it "is not current right now" do
             expect(subject).not_to be_current
           end
 
-          it 'is current when today falls in the middle' do
+          it "is current when today falls in the middle" do
             allow(Date).to receive(:today).and_return start_date + 3.days
             expect(subject).to be_current
           end
         end
 
-        context 'periods' do
+        context "periods" do
           before(:each) do
             allow(calendar).to receive(:days_for).with(subject).and_return %w[D1 D2 D3 D4 D5 D6 D7 D8]
             allow(calendar).to receive(:weeks_for).with(subject).and_return %w[W1 W2 W3 W4]
@@ -37,49 +38,49 @@ module TimeBoss
             allow(calendar).to receive(:years_for).with(subject).and_return %w[Y1]
           end
 
-          it 'knows about its days' do
+          it "knows about its days" do
             expect(subject.days).to eq %w[D1 D2 D3 D4 D5 D6 D7 D8]
             expect(subject.day).to be nil
           end
 
-          it 'knows about its weeks' do
+          it "knows about its weeks" do
             expect(subject.weeks).to eq %w[W1 W2 W3 W4]
             expect(subject.week).to be nil
           end
 
-          it 'knows about its months' do
+          it "knows about its months" do
             expect(subject.months).to eq %w[M1 M2 M3]
             expect(subject.month).to be nil
           end
 
-          it 'knows about its quarters' do
+          it "knows about its quarters" do
             expect(subject.quarters).to eq %w[Q1 Q2]
             expect(subject.quarter).to be nil
           end
 
-          it 'knows about its halves' do
+          it "knows about its halves" do
             expect(subject.halves).to eq %w[H1]
-            expect(subject.half).to eq 'H1'
+            expect(subject.half).to eq "H1"
           end
 
-          it 'knows about its years' do
+          it "knows about its years" do
             expect(subject.years).to eq %w[Y1]
-            expect(subject.year).to eq 'Y1'
+            expect(subject.year).to eq "Y1"
           end
         end
 
-        context 'navigation' do
+        context "navigation" do
           let(:result) { double }
 
-          describe '#offset' do
+          describe "#offset" do
           end
 
-          it 'can increment' do
+          it "can increment" do
             expect(subject).to receive(:offset).with(7).and_return result
             expect(subject + 7).to eq result
           end
 
-          it 'can decrement' do
+          it "can decrement" do
             expect(subject).to receive(:offset).with(-23).and_return result
             expect(subject - 23).to eq result
           end

data/spec/calendar/week_spec.rb

@@ -2,8 +2,8 @@ module TimeBoss
   class Calendar
     describe Week do
       let(:calendar) { instance_double(TimeBoss::Calendar, supports_weeks?: true) }
-      let(:start_date) { Date.parse('2048-04-06') }
-      let(:end_date) { Date.parse('2048-04-12') }
+      let(:start_date) { Date.parse("2048-04-06") }
+      let(:end_date) { Date.parse("2048-04-12") }
       let(:subject) { described_class.new(calendar, start_date, end_date) }
 
       it "doesn't even exist if its calendar doesn't support weeks" do
@@ -11,65 +11,65 @@ module TimeBoss
         expect { subject }.to raise_error TimeBoss::Calendar::Support::Unit::UnsupportedUnitError
       end
 
-      it 'knows its stuff' do
+      it "knows its stuff" do
         expect(subject.start_date).to eq start_date
         expect(subject.end_date).to eq end_date
         expect(subject.to_range).to eq start_date..end_date
       end
 
-      it 'knows its title' do
+      it "knows its title" do
         expect(subject.title).to eq "Week of April 6, 2048"
       end
 
-      describe '#current?' do
-        it 'knows when it is' do
+      describe "#current?" do
+        it "knows when it is" do
           allow(Date).to receive(:today).and_return start_date
           expect(subject).to be_current
         end
 
-        it 'knows when it is not' do
+        it "knows when it is not" do
           expect(subject).not_to be_current
         end
       end
 
-      context 'navigation' do
+      context "navigation" do
         let(:calendar) { TimeBoss::Calendars::Broadcast.new }
 
-        describe '#previous' do
-          it 'can back up simply' do
+        describe "#previous" do
+          it "can back up simply" do
             result = subject.previous
             expect(result).to be_a described_class
             expect(result.to_s).to eq "2048W14: 2048-03-30 thru 2048-04-05"
           end
 
-          it 'can wrap to the previous 52-week year' do
-            result = described_class.new(calendar, Date.parse('2021-12-27'), Date.parse('2022-01-02')).previous
+          it "can wrap to the previous 52-week year" do
+            result = described_class.new(calendar, Date.parse("2021-12-27"), Date.parse("2022-01-02")).previous
             expect(result).to be_a described_class
             expect(result.to_s).to eq "2021W52: 2021-12-20 thru 2021-12-26"
           end
 
-          it 'can wrap to the previous 53-week year' do
-            result = described_class.new(calendar, Date.parse('2024-01-01'), Date.parse('2024-01-07')).previous
+          it "can wrap to the previous 53-week year" do
+            result = described_class.new(calendar, Date.parse("2024-01-01"), Date.parse("2024-01-07")).previous
             expect(result).to be_a described_class
             expect(result.to_s).to eq "2023W53: 2023-12-25 thru 2023-12-31"
           end
         end
 
-        describe '#next' do
-          it 'can move forward simply' do
+        describe "#next" do
+          it "can move forward simply" do
             result = subject.next
             expect(result).to be_a described_class
             expect(result.to_s).to eq "2048W16: 2048-04-13 thru 2048-04-19"
           end
 
-          it 'can wrap from week 52 to the next year' do
-            result = described_class.new(calendar, Date.parse('2021-12-20'), Date.parse('2021-12-26')).next
+          it "can wrap from week 52 to the next year" do
+            result = described_class.new(calendar, Date.parse("2021-12-20"), Date.parse("2021-12-26")).next
             expect(result).to be_a described_class
             expect(result.to_s).to eq "2022W1: 2021-12-27 thru 2022-01-02"
           end
 
-          it 'can wrap from week 53 to the next year' do
-            result = described_class.new(calendar, Date.parse('2023-12-25'), Date.parse('2023-12-31')).next
+          it "can wrap from week 53 to the next year" do
+            result = described_class.new(calendar, Date.parse("2023-12-25"), Date.parse("2023-12-31")).next
             expect(result).to be_a described_class
             expect(result.to_s).to eq "2024W1: 2024-01-01 thru 2024-01-07"
           end