timeboss 0.3.0

data/lib/timeboss/calendars.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require_relative 'calendar'
+
+module TimeBoss
+  module Calendars
+    extend self
+    extend Enumerable
+    delegate :each, :length, to: :all
+
+    # Register a new calendar
+    # @return [Entry]
+    def register(name, klass)
+      Entry.new(name.to_sym, klass).tap do |entry|
+        (@entries ||= {})[name.to_sym] = entry
+      end
+    end
+
+    # Retrieve a list of all registered calendars.
+    # @return [Array<Entry>]
+    def all
+      return if @entries.nil?
+      @entries.values.sort_by { |e| e.name.to_s }
+    end
+
+    # Retrieve an instance of the specified named calendar.
+    # @param name [String, Symbol] the name of the calendar to retrieve.
+    # @return [Calendar]
+    def [](name)
+      return if @entries.nil?
+      @entries[name&.to_sym]&.calendar
+    end
+
+    private
+
+    Entry = Struct.new(:name, :klass) do
+      # @!method name
+      # Get the name of the calendar referenced in this entry.
+      # @return [Symbol]
+
+      # @!method klass
+      # The class implementing this calendar.
+      # @return [Class<Calendar>]
+
+      # Get an instance of the calendar referenced in this entry.
+      # @return [Calendar]
+      def calendar
+        @_calendar ||= klass.new
+      end
+    end
+  end
+end
+
+Dir[File.expand_path('../calendars/*.rb', __FILE__)].each { |f| require f }

data/lib/timeboss/calendars/broadcast.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require_relative '../calendar'
+
+module TimeBoss
+  module Calendars
+    class Broadcast < Calendar
+      register!
+
+      def initialize
+        super(basis: Basis)
+      end
+
+      private
+
+      class Basis < Calendar::Support::MonthBasis
+        def start_date
+          @_start_date ||= begin
+                             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
+        end
+      end
+    end
+  end
+end

data/lib/timeboss/calendars/gregorian.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require_relative '../calendar'
+
+module TimeBoss
+  module Calendars
+    class Gregorian < Calendar
+      register!
+
+      def initialize
+        super(basis: Basis)
+      end
+
+      def supports_weeks?
+        false
+      end
+
+      private
+
+      class Basis < Calendar::Support::MonthBasis
+        def start_date
+          @_start_date ||= Date.civil(year, month, 1)
+        end
+
+        def end_date
+          @_end_date ||= Date.civil(year, month, -1)
+        end
+      end
+    end
+  end
+end

data/lib/timeboss/support/shellable.rb

@@ -0,0 +1,17 @@
+module TimeBoss
+  module Support
+    module Shellable
+      def self.open(context)
+        context.extend(self).open_shell
+      end
+
+      def open_shell
+        require 'irb'
+        IRB.setup nil
+        IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+        require 'irb/ext/multi-irb'
+        IRB.irb nil, self
+      end
+    end
+  end
+end

data/lib/timeboss/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module TimeBoss
+  VERSION = "0.3.0"
+end

data/spec/calendar/day_spec.rb

@@ -0,0 +1,60 @@
+module TimeBoss
+  class Calendar
+    describe Day do
+      let(:calendar) { instance_double(TimeBoss::Calendar) }
+      let(:start_date) { Date.parse('2019-09-30') }
+      let(:subject) { described_class.new(calendar, start_date) }
+
+      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
+        expect(subject.name).to eq start_date.to_s
+      end
+
+      it 'knows its title' do
+        expect(subject.title).to eq 'September 30, 2019'
+      end
+
+      it 'can stringify itself' do
+        expect(subject.to_s).to eq subject.name
+      end
+
+      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
+          expect(subject.index).to eq 4
+        end
+      end
+
+      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
+          expect(subject).not_to be_current
+        end
+      end
+
+      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
+          result = subject.next
+          expect(result).to be_a described_class
+          expect(result.start_date).to eq start_date + 1.day
+        end
+      end
+    end
+  end
+end

data/spec/calendar/quarter_spec.rb

@@ -0,0 +1,32 @@
+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(:subject) { described_class.new(calendar, 2019, 4, start_date, end_date) }
+
+      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)
+      end
+
+      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
+          expect(subject).not_to be_current
+        end
+      end
+    end
+  end
+end

data/spec/calendar/support/monthly_unit_spec.rb

@@ -0,0 +1,85 @@
+module TimeBoss
+  class Calendar
+    module Support
+      describe MonthlyUnit do
+        class MonthBasedChunk < described_class
+          NUM_MONTHS = 2
+
+          def name
+            "#{year_index}C#{index}"
+          end
+        end
+        let(:described_class) { MonthBasedChunk }
+        let(:calendar) { double }
+        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(:base) { double(start_date: Date.parse('2018-01-01'), end_date: Date.parse('2018-12-30')) }
+          before(:each) { allow(calendar).to receive(:year).with(2018).and_return base }
+
+          it 'can get the relevant weeks for the period' do
+            allow(calendar).to receive(:supports_weeks?).and_return true
+            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-02',
+              '2018-07-09',
+              '2018-07-16',
+              '2018-07-23',
+              '2018-07-30',
+              '2018-08-06',
+              '2018-08-13',
+              '2018-08-20'
+            ]
+          end
+
+          it 'blows up when weeks are not supported' do
+            allow(calendar).to receive(:supports_weeks?).and_return false
+            expect { subject.weeks }.to raise_error TimeBoss::Calendar::Support::Unit::UnsupportedUnitError
+          end
+        end
+
+        context 'navigation' do
+          let(:result) { double }
+
+          describe '#previous' do
+            it 'moves easily within itself' do
+              expect(calendar).to receive(: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(: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(: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(: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/support/unit_spec.rb

@@ -0,0 +1,90 @@
+module TimeBoss
+  class Calendar
+    module Support
+      describe Unit do
+        class ChunkUnit < described_class
+        end
+        let(:described_class) { ChunkUnit }
+        let(:calendar) { double }
+        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
+          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
+            expect(subject).not_to be_current
+          end
+
+          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
+          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]
+            allow(calendar).to receive(:months_for).with(subject).and_return %w[M1 M2 M3]
+            allow(calendar).to receive(:quarters_for).with(subject).and_return %w[Q1 Q2]
+            allow(calendar).to receive(:halves_for).with(subject).and_return %w[H1]
+            allow(calendar).to receive(:years_for).with(subject).and_return %w[Y1]
+          end
+
+          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
+            expect(subject.weeks).to eq %w[W1 W2 W3 W4]
+            expect(subject.week).to be nil
+          end
+
+          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
+            expect(subject.quarters).to eq %w[Q1 Q2]
+            expect(subject.quarter).to be nil
+          end
+
+          it 'knows about its halves' do
+            expect(subject.halves).to eq %w[H1]
+            expect(subject.half).to eq 'H1'
+          end
+
+          it 'knows about its years' do
+            expect(subject.years).to eq %w[Y1]
+            expect(subject.year).to eq 'Y1'
+          end
+        end
+
+        context 'navigation' do
+          let(:result) { double }
+
+          describe '#offset' do
+          end
+
+          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
+            expect(subject).to receive(:offset).with(-23).and_return result
+            expect(subject - 23).to eq result
+          end
+        end
+      end
+    end
+  end
+end

data/spec/calendar/week_spec.rb

@@ -0,0 +1,80 @@
+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(:subject) { described_class.new(calendar, start_date, end_date) }
+
+      it "doesn't even exist if its calendar doesn't support weeks" do
+        allow(calendar).to receive(:supports_weeks?).and_return false
+        expect { subject }.to raise_error TimeBoss::Calendar::Support::Unit::UnsupportedUnitError
+      end
+
+      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
+        expect(subject.title).to eq "Week of April 6, 2048"
+      end
+
+      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
+          expect(subject).not_to be_current
+        end
+      end
+
+      context 'navigation' do
+        let(:calendar) { TimeBoss::Calendars::Broadcast.new }
+
+        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
+            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
+            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
+            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
+            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
+            expect(result).to be_a described_class
+            expect(result.to_s).to eq "2024W1: 2024-01-01 thru 2024-01-07"
+          end
+        end
+      end
+    end
+  end
+end