timeboss 0.0.5

data/lib/timeboss/calendar/period.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module TimeBoss
+  class Calendar
+    class Period
+      attr_reader :begin, :end
+      delegate :start_date, to: :begin
+      delegate :end_date, to: :end
+
+      %i[name title to_s].each do |message|
+        define_method(message) do
+          text = self.begin.send(message)
+          text = "#{text} #{Parser::RANGE_DELIMITER} #{self.end.send(message)}" unless self.end == self.begin
+          text
+        end
+      end
+
+      %w[week month quarter half year].each do |size|
+        define_method(size.pluralize) do
+          entry = calendar.send("#{size}_for", self.begin.start_date)
+          build_entries entry
+        end
+
+        define_method(size) do
+          entries = send(size.pluralize)
+          return nil unless entries.length == 1
+          entries.first
+        end
+      end
+
+      def current?
+        to_range.include?(Date.today)
+      end
+
+      def days
+        to_range.map { |d| Day.new(calendar, d) }
+      end
+
+      def day
+        entries = days
+        return nil unless entries.length == 1
+        entries.first
+      end
+
+      def to_range
+        @_to_range ||= start_date .. end_date
+      end
+
+      private
+
+      attr_reader :calendar
+
+      def initialize(calendar, begin_basis, end_basis = nil)
+        @calendar = calendar
+        @begin = begin_basis
+        @end = end_basis || @begin
+      end
+
+      def build_entries(entry)
+        return [] if entry.start_date > self.end.end_date
+        entries = [entry]
+        while entry.end_date < self.end.end_date
+          entry = entry.next
+          entries << entry
+        end
+        entries
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/quarter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require_relative './support/month_based'
+
+module TimeBoss
+  class Calendar
+    class Quarter < Support::MonthBased
+      NUM_MONTHS = 3
+
+      def name
+        "#{year_index}Q#{index}"
+      end
+
+      def title
+        "Q#{index} #{year_index}"
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/support/formatter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require_relative './shiftable'
+
+module TimeBoss
+  class Calendar
+    module Support
+      private
+
+      class Formatter
+        PERIODS = Shiftable::PERIODS.reverse.map(&:to_sym).drop(1)
+        attr_reader :unit, :periods
+
+        def initialize(unit, periods)
+          @unit = unit
+          @periods = PERIODS & periods.map(&:to_sym).push(unit.class.type.to_sym)
+        end
+
+        def to_s
+          base, text = 'year', unit.year.name
+          periods.each do |period|
+            sub = unit.send(period) or break
+            index = sub.send("in_#{base}")
+            text += "#{period[0].upcase}#{index}"
+            base = period
+          end
+          text
+        end
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/support/month_based.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require_relative './unit'
+
+module TimeBoss
+  class Calendar
+    module Support
+      class MonthBased < Unit
+        attr_reader :year_index, :index
+
+        def initialize(calendar, year_index, index, start_date, end_date)
+          super(calendar, start_date, end_date)
+          @year_index = year_index
+          @index = index
+        end
+
+        def next
+          if index == max_index
+            calendar.send(self.class.type, year_index + 1, 1)
+          else
+            calendar.send(self.class.type, year_index, index + 1)
+          end
+        end
+
+        def previous
+          if index == 1
+            calendar.send(self.class.type, year_index - 1, max_index)
+          else
+            calendar.send(self.class.type, year_index, index - 1)
+          end
+        end
+
+        def to_s
+          "#{name}: #{start_date} thru #{end_date}"
+        end
+
+        def weeks
+          base = calendar.year(year_index)
+          num_weeks = (((base.end_date - base.start_date) + 1) / 7.0).to_i
+          num_weeks.times.map { |i| Week.new(calendar, year_index, i + 1, base.start_date + (i * 7).days, base.start_date + ((i * 7) + 6).days) }
+                         .select { |w| w.start_date.between?(start_date, end_date) }
+        end
+
+        private
+
+        def max_index
+          12 / self.class::NUM_MONTHS
+        end
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/support/month_basis.rb

@@ -0,0 +1,18 @@
+module TimeBoss
+  class Calendar
+    module Support
+      class MonthBasis
+        attr_reader :year, :month
+
+        def initialize(year, month)
+          @year = year
+          @month = month
+        end
+
+        def to_range
+          @_to_range ||= start_date .. end_date
+        end
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/support/shiftable.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module TimeBoss
+  class Calendar
+    module Support
+      module Shiftable
+        PERIODS = %w[day week month quarter half year]
+
+        PERIODS.each do |period|
+          periods = period.pluralize
+
+          define_method periods do
+            calendar.send("#{periods}_for", self)
+          end
+
+          define_method period do
+            entries = send(periods)
+            return nil unless entries.length == 1
+            entries.first
+          end
+
+          define_method "in_#{period}" do
+            base = send(periods)
+            return unless base.length == 1
+            base.first.send(self.class.type.to_s.pluralize).find_index { |p| p == self } + 1
+          end
+
+          define_method "#{periods}_ago" do |offset|
+            base_offset = send("in_#{period}") or return
+            (calendar.send("this_#{period}") - offset).send(self.class.type.to_s.pluralize)[base_offset - 1]
+          end
+
+          define_method "last_#{period}" do
+            send("#{periods}_ago", 1)
+          end
+
+          define_method "this_#{period}" do
+            send("#{periods}_ago", 0)
+          end
+
+          define_method "#{periods}_hence" do |offset|
+            send("#{periods}_ago", offset * -1)
+          end
+
+          define_method "next_#{period}" do
+            send("#{periods}_hence", 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/support/unit.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require_relative './shiftable'
+require_relative './formatter'
+
+module TimeBoss
+  class Calendar
+    module Support
+      class Unit
+        include Shiftable
+        attr_reader :calendar, :start_date, :end_date
+
+        def self.type
+          self.name.demodulize.underscore
+        end
+
+        def initialize(calendar, start_date, end_date)
+          @calendar = calendar
+          @start_date = start_date
+          @end_date = end_date
+        end
+
+        def ==(entry)
+          self.class == entry.class && self.start_date == entry.start_date && self.end_date == entry.end_date
+        end
+
+        def format(*periods)
+          Formatter.new(self, periods.presence || Formatter::PERIODS).to_s
+        end
+
+        def thru(unit)
+          Period.new(calendar, self, unit)
+        end
+
+        def current?
+          Date.today.between?(start_date, end_date)
+        end
+
+        def offset(value)
+          method = value.negative? ? :previous : :next
+          base = self
+          value.abs.times { base = base.send(method) }
+          base
+        end
+
+        def +(value)
+          offset(value)
+        end
+
+        def -(value)
+          offset(-value)
+        end
+
+        def to_range
+          @_to_range ||= start_date .. end_date
+        end
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/waypoints.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+module TimeBoss
+  class Calendar
+    module Waypoints
+      %i[month quarter half year].each do |type|
+        klass = TimeBoss::Calendar.const_get(type.to_s.classify)
+        size = klass.const_get("NUM_MONTHS")
+
+        define_method type do |year_index, index = 1|
+          month = (index * size) - size + 1
+          months = (month .. month + size - 1).map { |i| basis.new(year_index, i) }
+          klass.new(self, year_index, index, months.first.start_date, months.last.end_date)
+        end
+
+        define_method "#{type}_for" do |date|
+          window = send(type, date.year - 1, 1)
+          while true
+            break window if window.to_range.include?(date)
+            window = window.next
+          end
+        end
+      end
+
+      %i[day week month quarter half year].each do |type|
+        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 "#{type.to_s.pluralize}_for" do |entry|
+          first = send("#{type}_for", entry.start_date)
+          constituents = [first]
+          until first.end_date >= entry.end_date
+            first = first.next
+            constituents << first
+          end
+          constituents
+        end
+
+        define_method "#{type.to_s.pluralize}_back" do |quantity|
+          windows = []
+          window = send("this_#{type}")
+          while quantity > 0
+            windows << window.dup
+            window = window.previous
+            quantity -= 1
+          end
+          windows.reverse
+        end
+
+        define_method "#{type.to_s.pluralize}_ago" do |quantity|
+          send("#{type.to_s.pluralize}_back", quantity + 1).first
+        end
+
+        define_method type.to_s.pluralize do |quantity|
+          windows = []
+          window = send("this_#{type}")
+          while quantity > 0
+            windows << window.dup
+            window = window.next
+            quantity -= 1
+          end
+          windows
+        end
+
+        define_method "#{type.to_s.pluralize}_hence" do |quantity|
+          send(type.to_s.pluralize, quantity + 1).last
+        end
+      end
+
+      %i[yesterday today tomorrow].each do |period|
+        define_method(period) { Day.new(self, Date.send(period)) }
+      end
+
+      def day(year_index, index)
+        year(year_index).days[index - 1]
+      end
+
+      def day_for(date)
+        Day.new(self, date)
+      end
+
+      def week_for(date)
+        year_for(date).weeks.find { |w| w.to_range.include?(date) }
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/week.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require_relative './support/unit'
+
+module TimeBoss
+  class Calendar
+    class Week < Support::Unit
+      attr_reader :year_index, :index
+
+      def initialize(calendar, year_index, index, start_date, end_date)
+        super(calendar, start_date, end_date)
+        @year_index = year_index
+        @index = index
+      end
+
+      def name
+        "#{year_index}W#{index}"
+      end
+
+      def title
+        "Week of #{start_date.strftime('%B %-d, %Y')}"
+      end
+
+      def to_s
+        "#{name}: #{start_date} thru #{end_date}"
+      end
+
+      def previous
+        if index == 1
+          (calendar.year_for(start_date) - 1).weeks.last
+        else
+          self.class.new(calendar, year_index, index - 1, start_date - 1.week, end_date - 1.week)
+        end
+      end
+
+      def next
+        weeks = calendar.year_for(start_date).weeks
+        if index == weeks.last.index
+          self.class.new(calendar, year_index + 1, 1, start_date + 1.week, end_date + 1.week)
+        else
+          weeks[index]
+        end
+      end
+    end
+  end
+end

data/lib/timeboss/calendar/year.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require_relative './support/month_based'
+
+module TimeBoss
+  class Calendar
+    class Year < Support::MonthBased
+      NUM_MONTHS = 12
+
+      def name
+        year_index.to_s
+      end
+
+      def title
+        name
+      end
+    end
+  end
+end