etassia 0.1.0

data/lib/etassia/layout/gantt_duration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Etassia
+  module Layout
+    # Adds a Gantt duration such as "30d", "20h" or "1.5w" to a time the
+    # way mermaid does: h, m, s and ms are fixed lengths, d and w round
+    # to whole days, and M and y move the calendar by whole units. A bare
+    # number counts days for compatibility with direct model callers.
+    #
+    # Times are UTC, so a day is always 86400 seconds.
+    module GanttDuration
+      PATTERN = /\A(\d+(?:\.\d+)?)(ms|[Mdhmswy])?\z/
+      SECONDS = {
+        "ms" => 0.001, "s" => 1, "m" => 60, "h" => 3600,
+        nil => 86_400
+      }.freeze
+      DAYS = { "d" => 1, "w" => 7 }.freeze
+      MONTHS = { "M" => 1, "y" => 12 }.freeze
+
+      def self.add(time, text)
+        duration = parse(text)
+        return time unless duration
+
+        add_value(time, *duration)
+      end
+
+      def self.parse(text)
+        match = PATTERN.match(text.to_s.strip)
+        [match[1].to_f, match[2]] if match
+      end
+
+      def self.add_value(time, value, unit)
+        return add_months(time, value.to_i * MONTHS.fetch(unit)) if MONTHS[unit]
+        return time + ((value * DAYS.fetch(unit)).round * 86_400) if DAYS[unit]
+
+        time + (value * SECONDS.fetch(unit))
+      end
+
+      def self.add_months(time, months)
+        whole = months.to_i
+        shifted = (time.to_date >> whole).to_time.utc
+        shifted + (time - time.to_date.to_time.utc)
+      end
+      private_class_method :parse, :add_value, :add_months
+    end
+  end
+end

data/lib/etassia/layout/gantt_exclusions.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Etassia
+  module Layout
+    # Mermaid's `excludes` rule for a Gantt task end: every excluded day
+    # from the day after the start up to the end pushes the end one day
+    # later, so excluded days never count toward a duration.
+    #
+    # Handles `weekends` (Saturday and Sunday, or Friday and Saturday after
+    # `weekend friday`), weekday names and specific dates.
+    class GanttExclusions
+      DAY = 86_400
+      WEEKEND_START = { "friday" => 5, "saturday" => 6 }.freeze
+      DATE_TOKENS = {
+        "YYYY" => "%Y", "YY" => "%y", "MM" => "%m", "DD" => "%d",
+        "M" => "%-m", "D" => "%-d"
+      }.freeze
+      # Mermaid gives up after this many days of pushing.
+      MAX_PUSH_DAYS = 10_000
+
+      def initialize(entries, weekend, date_format)
+        @tokens = entries.flat_map { |line| line.downcase.split(/[\s,]+/) }
+        @weekend_start = WEEKEND_START.fetch(weekend.to_s.strip, 6)
+        @date_format = strftime_format(date_format.to_s.strip)
+      end
+
+      # @return [Array(Time, Time)] the pushed end, and the end to draw
+      #   the bar to (nil when the bar simply ends at the pushed end)
+      def settle(start, stop)
+        return [stop, nil] if @tokens.empty?
+
+        push(start + DAY, stop, stop + (MAX_PUSH_DAYS * DAY))
+      end
+
+      private
+
+      def push(day, stop, limit)
+        drawn = nil
+        pushed = false
+        while stop.between?(day, limit)
+          drawn = stop unless pushed
+          pushed = excluded?(day)
+          stop += DAY if pushed
+          day += DAY
+        end
+        [stop, drawn]
+      end
+
+      def excluded?(day)
+        return true if weekend?(day)
+
+        @tokens.include?(day.strftime("%A").downcase) || dated?(day)
+      end
+
+      def weekend?(day)
+        return false unless @tokens.include?("weekends")
+
+        iso = day.wday.zero? ? 7 : day.wday
+        [@weekend_start, @weekend_start + 1].include?(iso)
+      end
+
+      def dated?(day)
+        [day.strftime("%Y-%m-%d"), day.strftime(@date_format)]
+          .any? { |text| @tokens.include?(text.downcase) }
+      end
+
+      def strftime_format(format)
+        format.gsub(/YYYY|YY|MM|DD|M|D/, DATE_TOKENS)
+      end
+    end
+  end
+end

data/lib/etassia/layout/gantt_ticks.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../js_math"
+
+module Etassia
+  module Layout
+    # Picks the axis tick times of a Gantt chart the way mermaid does: d3's
+    # time-scale ladder aiming for about ten ticks, each interval aligned
+    # to the calendar (hours to midnight, weeks to Sunday, months to Jan,
+    # Apr, Jul, Oct for a 3-month step, years to a multiple of the step).
+    #
+    # Times are UTC so the result does not depend on the machine's zone.
+    class GanttTicks
+      TARGET_COUNT = 10
+      MINUTE = 60
+      HOUR = 3600
+      DAY = 24 * HOUR
+      # [unit, step, approximate seconds] as in d3-scale's tickIntervals.
+      LADDER = [
+        [:hour, 1, HOUR], [:hour, 3, 3 * HOUR], [:hour, 6, 6 * HOUR],
+        [:hour, 12, 12 * HOUR], [:day, 1, DAY], [:day, 2, 2 * DAY],
+        [:week, 1, 7 * DAY], [:month, 1, 30 * DAY], [:month, 3, 90 * DAY],
+        [:year, 1, 365 * DAY]
+      ].freeze
+      INTERVAL_PATTERN = /\A([1-9]\d*)(minute|hour|day|week|month)\z/
+      SUNDAY_OFFSET_DAYS = 4
+      # An explicit tickInterval that would draw more ticks than this over
+      # the range is ignored in favour of the automatic ladder, so a span of
+      # millennia cannot produce millions of labels.
+      MAX_TICKS = 2000
+      UNIT_SECONDS = {
+        minute: MINUTE, hour: HOUR, day: DAY, week: 7 * DAY, month: 30 * DAY
+      }.freeze
+
+      def self.times(start_time, stop_time, interval = nil)
+        new(start_time, stop_time, interval).times
+      end
+
+      def initialize(start_time, stop_time, interval)
+        @start = start_time
+        @stop = stop_time
+        @interval = affordable(parse(interval)) || pick_interval
+      end
+
+      def times
+        unit, step = @interval
+        candidates(unit).select do |time|
+          time.between?(@start, @stop) && aligned?(unit, step, time)
+        end
+      end
+
+      private
+
+      def parse(text)
+        match = INTERVAL_PATTERN.match(text.to_s.strip)
+        [match[2].to_sym, match[1].to_i] if match
+      end
+
+      def affordable(interval)
+        return unless interval
+
+        unit, step = interval
+        seconds = UNIT_SECONDS.fetch(unit) * step
+        interval if (@stop - @start).abs / seconds <= MAX_TICKS
+      end
+
+      def pick_interval
+        target = (@stop - @start).abs / TARGET_COUNT
+        index = LADDER.index { |entry| entry.last > target }
+        return year_interval unless index
+        return LADDER.first.first(2) if index.zero?
+
+        nearer_rung(index, target)
+      end
+
+      def nearer_rung(index, target)
+        below = LADDER[index - 1]
+        above = LADDER[index]
+        (target / below.last < above.last / target ? below : above).first(2)
+      end
+
+      def year_interval
+        years = (@stop - @start).abs / LADDER.last.last
+        [:year, nice_step(years / TARGET_COUNT)]
+      end
+
+      # d3.tickIncrement's 1, 2, 5, 10 ladder, never below one year.
+      def nice_step(raw)
+        power = JsMath.log10(raw).floor
+        error = raw / (10.0**power)
+        factor = [[Math.sqrt(50), 10], [Math.sqrt(10), 5],
+                  [Math.sqrt(2), 2]].find { |limit, _| error >= limit }
+        [((factor&.last || 1) * (10**power)).to_i, 1].max
+      end
+
+      def candidates(unit)
+        cursor = floor_to(unit, @start)
+        found = []
+        while cursor <= @stop
+          found << cursor
+          cursor = advance(unit, cursor)
+        end
+        found
+      end
+
+      def floor_to(unit, time)
+        case unit
+        when :minute then floor_minute(time)
+        when :hour then Time.utc(time.year, time.month, time.day, time.hour)
+        when :month then Time.utc(time.year, time.month)
+        when :year then Time.utc(time.year)
+        else floor_days(unit, time)
+        end
+      end
+
+      def floor_days(unit, time)
+        day = Time.utc(time.year, time.month, time.day)
+        unit == :week ? day - (day.wday * DAY) : day
+      end
+
+      def advance(unit, time)
+        case unit
+        when :minute then time + MINUTE
+        when :hour then time + HOUR
+        when :day then time + DAY
+        when :week then time + (7 * DAY)
+        when :month then next_month(time)
+        else Time.utc(time.year + 1)
+        end
+      end
+
+      def next_month(time)
+        Time.utc(time.year + (time.month / 12), (time.month % 12) + 1)
+      end
+
+      def aligned?(unit, step, time)
+        (index_of(unit, time) % step).zero?
+      end
+
+      def index_of(unit, time)
+        case unit
+        when :minute then time.min
+        when :hour then time.hour
+        when :day then time.day - 1
+        when :week then week_index(time)
+        when :month then month_index(time)
+        else time.year
+        end
+      end
+
+      def floor_minute(time)
+        Time.utc(time.year, time.month, time.day, time.hour, time.min)
+      end
+
+      def week_index(time)
+        ((time.to_i / DAY) + SUNDAY_OFFSET_DAYS) / 7
+      end
+
+      def month_index(time)
+        ((time.year - 1970) * 12) + time.month - 1
+      end
+    end
+  end
+end