timeboss 1.0.1 → 1.1.2

data/lib/timeboss/calendar/waypoints/relative.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module TimeBoss
   class Calendar
     module Waypoints
@@ -6,17 +7,17 @@ module TimeBoss
         %i[day week month quarter half year].each do |type|
           types = type.to_s.pluralize
 
-          define_method("this_#{type}") { send("#{type}_for", Date.today) }
-          define_method("last_#{type}") { send("this_#{type}").previous }
-          define_method("next_#{type}") { send("this_#{type}").next }
+          define_method("this_#{type}") { public_send("#{type}_for", Date.today) }
+          define_method("last_#{type}") { public_send("this_#{type}").previous }
+          define_method("next_#{type}") { public_send("this_#{type}").next }
 
-          define_method("#{types}_for") { |p| send("#{type}_for", p.start_date).until(p.end_date) }
+          define_method("#{types}_for") { |p| public_send("#{type}_for", p.start_date).until(p.end_date) }
 
-          define_method("#{types}_back") { |q| send("this_#{type}").previous(q) }
-          define_method("#{types}_ago") { |q| send("this_#{type}").ago(q) }
+          define_method("#{types}_back") { |q| public_send("this_#{type}").previous(q) }
+          define_method("#{types}_ago") { |q| public_send("this_#{type}").ago(q) }
 
-          define_method("#{types}_forward") { |q| send("this_#{type}").next(q) }
-          define_method("#{types}_ahead") { |q| send("this_#{type}").ahead(q) }
+          define_method("#{types}_forward") { |q| public_send("this_#{type}").next(q) }
+          define_method("#{types}_ahead") { |q| public_send("this_#{type}").ahead(q) }
           alias_method types.to_sym, "#{types}_forward".to_sym
         end
 
@@ -66,7 +67,7 @@ module TimeBoss
         # Get the day that occurred the specified number of days ahead.
         # @param quantity [Integer] the number of days after today
         # @return [Calendar::Day]
- 
+
         ### Weeks
 
         # @!method this_week
@@ -105,7 +106,7 @@ module TimeBoss
         # Get the week that occurred the specified number of weeks ahead.
         # @param quantity [Integer] the number of weeks after this week
         # @return [Calendar::Week]
- 
+
         ### Months
 
         # @!method this_month
@@ -144,7 +145,7 @@ module TimeBoss
         # Get the month that occurred the specified number of months ahead.
         # @param quantity [Integer] the number of months after this month
         # @return [Calendar::Month]
- 
+
         ### Quarters
 
         # @!method this_quarter
@@ -183,7 +184,7 @@ module TimeBoss
         # Get the quarter that occurred the specified number of days ahead.
         # @param quantity [Integer] the number of quarters after this quarter
         # @return [Calendar::Quarter]
- 
+
         ### Halves
 
         # @!method this_half
@@ -222,7 +223,7 @@ module TimeBoss
         # Get the half that occurred the specified number of halves ahead.
         # @param quantity [Integer] the number of halves after this half
         # @return [Calendar::Half]
- 
+
         ### Years
 
         # @!method this_year

data/lib/timeboss/calendar/week.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative './support/unit'
+
+require_relative "./support/unit"
 
 module TimeBoss
   class Calendar
@@ -18,7 +19,7 @@ module TimeBoss
       # Get a "pretty" representation of this week.
       # @return [String] (e.g. "Week of August 3, 2020")
       def title
-        "Week of #{start_date.strftime('%B %-d, %Y')}"
+        "Week of #{start_date.strftime("%B %-d, %Y")}"
       end
 
       # Get a stringified representation of this week.

data/lib/timeboss/calendar/year.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative './support/monthly_unit'
+
+require_relative "./support/monthly_unit"
 
 module TimeBoss
   class Calendar

data/lib/timeboss/calendar.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-require 'active_support/inflector'
-require 'active_support/core_ext/numeric/time'
+
+require "active_support/inflector"
+require "active_support/core_ext/numeric/time"
 
 %w[day week month quarter half year].each { |f| require_relative "./calendar/#{f}" }
 %w[waypoints period parser].each { |f| require_relative "./calendar/#{f}" }
-require_relative './calendar/support/month_basis'
+require_relative "./calendar/support/month_basis"
 
 module TimeBoss
   class Calendar
@@ -34,16 +35,16 @@ module TimeBoss
     end
 
     # Can this calendar support weeks?
-    # For custom calendars, this value can generally not be overridden.
-    # But for calendars like our Gregorian implementation, weeks are irrelevant, and should be suppressed.
+    # To support weeks, a calendar must implement a `#weeks_in(year:)` method that returns an array of
+    # `Calendar::Week` objects.
     # @return [Boolean]
     def supports_weeks?
-      true
+      respond_to?(:weeks_in)
     end
 
     def self.register!
       return unless TimeBoss::Calendars.method_defined?(:register)
-      TimeBoss::Calendars.register(self.name.to_s.demodulize.underscore, self)
+      TimeBoss::Calendars.register(name.to_s.demodulize.underscore, self)
     end
     private_class_method :register!
 

data/lib/timeboss/calendars/broadcast.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
-require_relative '../calendar'
+
+require_relative "../calendar"
+require_relative "../calendar/support/has_fiscal_weeks"
 
 module TimeBoss
   module Calendars
     class Broadcast < Calendar
+      include Support::HasFiscalWeeks
       register!
 
       def initialize
@@ -15,16 +18,16 @@ module TimeBoss
       class Basis < Calendar::Support::MonthBasis
         def start_date
           @_start_date ||= begin
-                             date = Date.civil(year, month, 1)
-                             date - (date.wday + 6) % 7
-                           end
+            date = Date.civil(year, month, 1)
+            date - (date.wday + 6) % 7
+          end
         end
 
         def end_date
           @_end_date ||= begin
-                           date = Date.civil(year, month, -1)
-                           date - date.wday
-                         end
+            date = Date.civil(year, month, -1)
+            date - date.wday
+          end
         end
       end
     end

data/lib/timeboss/calendars/gregorian.rb

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
-require_relative '../calendar'
+
+require_relative "../calendar"
+require_relative "../calendar/support/has_iso_weeks"
 
 module TimeBoss
   module Calendars
     class Gregorian < Calendar
+      include Support::HasIsoWeeks
       register!
 
       def initialize
         super(basis: Basis)
       end
 
-      def supports_weeks?
-        false
-      end
-
       private
 
       class Basis < Calendar::Support::MonthBasis

data/lib/timeboss/calendars.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative 'calendar'
+
+require_relative "calendar"
 
 module TimeBoss
   module Calendars
@@ -50,4 +51,4 @@ module TimeBoss
   end
 end
 
-Dir[File.expand_path('../calendars/*.rb', __FILE__)].each { |f| require f }
+Dir[File.expand_path("../calendars/*.rb", __FILE__)].each { |f| require f }

data/lib/timeboss/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module TimeBoss
-  VERSION = "1.0.1"
+  VERSION = "1.1.2"
 end

data/lib/timeboss.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+
+require "active_support"
 require "timeboss/version"
 
 # TimeBoss

data/spec/{calendar → lib/timeboss/calendar}/day_spec.rb

@@ -2,54 +2,54 @@ module TimeBoss
   class Calendar
     describe Day do
       let(:calendar) { instance_double(TimeBoss::Calendar) }
-      let(:start_date) { Date.parse('2019-09-30') }
+      let(:start_date) { Date.parse("2019-09-30") }
       let(:subject) { described_class.new(calendar, start_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 start_date
         expect(subject.to_range).to eq start_date..start_date
       end
 
-      it 'knows its name' do
+      it "knows its name" do
         expect(subject.name).to eq start_date.to_s
       end
 
-      it 'knows its title' do
-        expect(subject.title).to eq 'September 30, 2019'
+      it "knows its title" do
+        expect(subject.title).to eq "September 30, 2019"
       end
 
-      it 'can stringify itself' do
+      it "can stringify itself" do
         expect(subject.to_s).to eq subject.name
       end
 
-      describe '#index' do
+      describe "#index" do
         before(:each) { allow(subject).to receive(:year).and_return double(start_date: start_date - 3) }
 
-        it 'gets its index within the year' do
+        it "gets its index within the year" do
           expect(subject.index).to eq 4
         end
       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
-        it 'can get the previous date' do
+      context "navigation" do
+        it "can get the previous date" do
           result = subject.previous
           expect(result).to be_a described_class
           expect(result.start_date).to eq start_date - 1.day
         end
 
-        it 'can get the next date' do
+        it "can get the next date" do
           result = subject.next
           expect(result).to be_a described_class
           expect(result.start_date).to eq start_date + 1.day

data/spec/{calendar → lib/timeboss/calendar}/quarter_spec.rb

@@ -2,28 +2,28 @@ module TimeBoss
   class Calendar
     describe Quarter do
       let(:calendar) { instance_double(TimeBoss::Calendar) }
-      let(:start_date) { Date.parse('2019-09-30') }
-      let(:end_date) { Date.parse('2019-12-29') }
+      let(:start_date) { Date.parse("2019-09-30") }
+      let(:end_date) { Date.parse("2019-12-29") }
       let(:subject) { described_class.new(calendar, 2019, 4, start_date, end_date) }
 
-      it 'knows its stuff' do
-        expect(subject.name).to eq '2019Q4'
+      it "knows its stuff" do
+        expect(subject.name).to eq "2019Q4"
         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 'can stringify itself' do
-        expect(subject.to_s).to include('2019Q4', start_date.to_s, end_date.to_s)
+      it "can stringify itself" do
+        expect(subject.to_s).to include("2019Q4", start_date.to_s, end_date.to_s)
       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

data/spec/lib/timeboss/calendar/support/monthly_unit_spec.rb

@@ -0,0 +1,91 @@
+module TimeBoss
+  class Calendar
+    module Support
+      class TestMonthBasedChunk < MonthlyUnit
+        NUM_MONTHS = 2
+
+        def name
+          "#{year_index}C#{index}"
+        end
+      end
+
+      describe MonthlyUnit do
+        let(:described_class) { TestMonthBasedChunk }
+        let(:calendar) { double(supports_weeks?: false, weeks_in: nil) }
+        let(:start_date) { Date.parse("2018-06-25") }
+        let(:end_date) { Date.parse("2018-08-26") }
+        let(:subject) { described_class.new(calendar, 2018, 4, start_date, end_date) }
+
+        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 "can stringify itself" do
+          expect(subject.to_s).to eq "2018C4: 2018-06-25 thru 2018-08-26"
+        end
+
+        describe "#weeks" do
+          let(:supports_weeks) { false }
+          before(:each) { allow(calendar).to receive(:supports_weeks?).and_return supports_weeks }
+
+          context "unsupported" do
+            it "blows up when weeks are not supported" do
+              expect { subject.weeks }.to raise_error TimeBoss::Calendar::Support::Unit::UnsupportedUnitError
+            end
+          end
+
+          context "supported" do
+            let(:supports_weeks) { true }
+            let(:base) { double(start_date: Date.parse("2018-01-01"), end_date: Date.parse("2018-12-30")) }
+            let(:weeks) do
+              ["2018-04-19", "2018-06-25", "2018-07-16", "2018-08-20", "2018-09-30"].map do |date|
+                start_date = Date.parse(date)
+                TimeBoss::Calendar::Week.new(calendar, start_date, start_date + 6.days)
+              end
+            end
+            before(:each) do
+              allow(calendar).to receive(:year).with(2018).and_return base
+              allow(calendar).to receive(:weeks_in).with(year: base).and_return weeks
+            end
+
+            it "can get the relevant weeks for the period" do
+              result = subject.weeks
+              result.each { |w| expect(w).to be_instance_of TimeBoss::Calendar::Week }
+              expect(result.map { |w| w.start_date.to_s }).to eq ["2018-06-25", "2018-07-16", "2018-08-20"]
+            end
+          end
+        end
+
+        context "navigation" do
+          let(:result) { double }
+
+          describe "#previous" do
+            it "moves easily within itself" do
+              expect(calendar).to receive(:test_month_based_chunk).with(48, 3).and_return result
+              expect(described_class.new(calendar, 48, 4, nil, nil).previous).to eq result
+            end
+
+            it "flips to the previous container" do
+              expect(calendar).to receive(:test_month_based_chunk).with(47, 6).and_return result
+              expect(described_class.new(calendar, 48, 1, nil, nil).previous).to eq result
+            end
+          end
+
+          describe "#next" do
+            it "moves easily within itself" do
+              expect(calendar).to receive(:test_month_based_chunk).with(48, 3).and_return result
+              expect(described_class.new(calendar, 48, 2, nil, nil).next).to eq result
+            end
+
+            it "flips to the previous container" do
+              expect(calendar).to receive(:test_month_based_chunk).with(48, 1).and_return result
+              expect(described_class.new(calendar, 47, 6, nil, nil).next).to eq result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/{calendar → lib/timeboss/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 → lib/timeboss/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