Almirah 0.4.4 → 0.4.6

data/lib/almirah/project/work_item_scheduler.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-# Lays the WorkItem network (ADR-194) on an abstract day axis for the overview
-# swimlane Gantt (ADR-198). It performs a deterministic forward pass over the
-# dependency edges and then levels each owner's lane so two work items of the
-# same owner never overlap. Levelling backfills: a row may be slotted into an
-# idle gap left between rows placed earlier, so a low-priority short row does
-# not queue behind the whole lane when a gap already fits it.
-#
-# Durations are a constant placeholder (3 days) while no per-row estimates
-# exist; `duration_for` is the single hook ADR-195 overrides to feed real
-# estimates without changing the scheduling logic.
-#
-# Days are 1-based. A work item starting on day `s` with duration `d` occupies
-# the inclusive day span `s .. s + d - 1`; its *finish* (the next free day,
-# returned in the ends map) is `s + d`, the earliest a successor or the same
-# owner's next item may start.
-class WorkItemScheduler
-  # Placeholder duration for every work item until ADR-195 supplies estimates.
-  DEFAULT_DURATION = 3
-
-  def initialize(work_items, duration: DEFAULT_DURATION)
-    @items = work_items
-    @duration = duration
-    @item_set = work_items.to_set
-  end
-
-  # { work_item => start_day }, day index 1-based. Empty when there are no items.
-  def start_days
-    schedule unless @starts
-    @starts
-  end
-
-  # The number of day columns the chart needs: the latest finish minus one
-  # (finishes are the exclusive next-free day). Zero when there are no items.
-  def day_count
-    schedule unless @ends
-    @ends.empty? ? 0 : (@ends.values.max - 1)
-  end
-
-  # The schedule length in working days (the latest finish, day 1 being the start).
-  def makespan
-    day_count
-  end
-
-  # The critical chain: the row with the latest finish, traced back through its
-  # binding predecessors (the dependency and resource hand-offs that set each
-  # row's start), returned in start order. Empty when nothing is scheduled.
-  def critical_chain
-    schedule unless @starts
-    return [] if @ends.empty?
-
-    max_end = @ends.values.max
-    node = @items.select { |wi| @ends[wi] == max_end }.min_by { |wi| [wi.record_id, wi.step] }
-    chain = []
-    while node
-      chain.unshift(node)
-      node = @binding[node]
-    end
-    chain
-  end
-
-  def duration_for(_work_item)
-    @duration
-  end
-
-  private
-
-  # Greedy list-scheduler. Items are processed in a deterministic priority order
-  # (resource-free earliest start, then activity rank, record id, step) so that
-  # every item's predecessors are placed before it. Each item starts at the
-  # earliest day at or after its dependency finish where its owner's lane has an
-  # idle gap wide enough for it (resource levelling with backfill).
-  def schedule
-    @starts = {}
-    @ends = {}
-    @binding = {}
-    @owner_rows = Hash.new { |hash, owner| hash[owner] = [] }
-    return if @items.empty?
-
-    priority_order.each { |wi| place(wi) }
-  end
-
-  # Assigns one work item its start day, records the predecessor that bound that
-  # start, then marks the span as occupied in its owner's lane.
-  def place(work_item)
-    preds = scoped_predecessors(work_item)
-    dep_finish = preds.map { |p| @ends[p] || 1 }.max || 1
-    start, lane_pred = earliest_fit(work_item.owner, dep_finish, duration_for(work_item))
-    @starts[work_item] = start
-    @ends[work_item] = start + duration_for(work_item)
-    @binding[work_item] = binding_predecessor(preds, start, lane_pred)
-    @owner_rows[work_item.owner] << work_item unless work_item.owner.empty?
-  end
-
-  # The earliest start at or after `from` where the owner's lane stays clear for
-  # `duration` days, plus the lane row whose finish that start had to wait behind
-  # (nil when the row starts at `from` itself). A blank owner holds no resource,
-  # so it never serialises.
-  def earliest_fit(owner, from, duration)
-    return [from, nil] if owner.empty?
-
-    start = from
-    lane_pred = nil
-    @owner_rows[owner].sort_by { |row| @starts[row] }.each do |row|
-      break if start + duration <= @starts[row]
-      next if @ends[row] <= start
-
-      start = @ends[row]
-      lane_pred = row
-    end
-    [start, lane_pred]
-  end
-
-  # The already-placed predecessor whose finish coincides with this row's start --
-  # the dependency or same-owner hand-off the critical chain is traced back
-  # through. nil when the row starts at the origin with no such predecessor.
-  def binding_predecessor(preds, start, lane_pred)
-    candidates = preds.select { |p| @ends[p] == start }
-    candidates << lane_pred if lane_pred
-    candidates.min_by { |c| [c.record_id, c.step] }
-  end
-
-  def priority_order
-    memo = {}
-    @items.sort_by { |wi| priority_key(wi, memo) }
-  end
-
-  # The deterministic scheduling priority for a row. Overridden by the critical-
-  # chain scheduler (ADR-195) to prioritise the longest downstream duration.
-  def priority_key(work_item, memo)
-    [dependency_start(work_item, memo, []), work_item.activity_rank, work_item.record_id, work_item.step]
-  end
-
-  # The earliest day this item could start ignoring resource contention: 1 when
-  # it has no predecessors, else one past the latest predecessor finish. Memoised
-  # and cycle-guarded — a back-edge (which the DAG-by-construction network should
-  # never have) is treated as start 1 so scheduling still completes.
-  def dependency_start(work_item, memo, stack)
-    return memo[work_item] if memo.key?(work_item)
-    return 1 if stack.include?(work_item)
-
-    preds = scoped_predecessors(work_item)
-    return memo[work_item] = 1 if preds.empty?
-
-    stack.push(work_item)
-    earliest = preds.map { |p| dependency_start(p, memo, stack) + duration_for(p) }.max
-    stack.pop
-    memo[work_item] = earliest
-  end
-
-  # Predecessors inside this scheduler's own item set. A predecessor scheduled in
-  # another scope (e.g. a different decision group, ADR-201) is treated as an
-  # already-available external input: it is dropped here and imposes no finish
-  # constraint, so the dependent simply starts at day 1 with respect to it.
-  def scoped_predecessors(work_item)
-    work_item.predecessor_items.select { |p| @item_set.include?(p) }
-  end
-
-  # Successors inside this scheduler's own item set (the mirror of
-  # scoped_predecessors), used by the critical-chain priority.
-  def scoped_successors(work_item)
-    work_item.successor_items.select { |s| @item_set.include?(s) }
-  end
-end

data/lib/almirah/project/working_calendar.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require 'date'
-require 'set'
-
-# Projects the working-day planning axis (ADR-198 / ADR-195) onto real calendar
-# dates (ADR-205). Working day 1 is the first working date on or after the anchor;
-# Saturdays, Sundays, and any configured holiday are non-working — skipped when
-# counting working days, but still occupying calendar columns. This is a pure
-# projection: it never changes the schedule, the chain, or the buffer.
-class WorkingCalendar
-  SATURDAY = 6
-  SUNDAY = 0
-  FRIDAY = 5
-
-  def initialize(anchor: Date.today, holidays: [])
-    @holidays = holidays.to_set
-    @start = first_working_on_or_after(anchor)
-  end
-
-  # The calendar date of the n-th working day (1-based) counted from the anchor.
-  def date_for(working_day)
-    return @start if working_day <= 1
-
-    date = @start
-    remaining = working_day - 1
-    while remaining.positive?
-      date += 1
-      remaining -= 1 if working?(date)
-    end
-    date
-  end
-
-  # Every calendar date from working day 1 through the working_day_count-th working
-  # day inclusive, including the non-working dates in between. Empty for a count
-  # below 1.
-  def columns(working_day_count)
-    return [] if working_day_count < 1
-
-    (@start..date_for(working_day_count)).to_a
-  end
-
-  # The 0-based calendar column index of the n-th working day within columns.
-  def column_index(working_day)
-    (date_for(working_day) - @start).to_i
-  end
-
-  # The compact business-day axis (ADR-206): weekday dates from working day 1
-  # through the working_day_count-th working day, excluding Saturdays and Sundays
-  # but including weekday holidays. Empty for a count below 1.
-  def business_columns(working_day_count)
-    return [] if working_day_count < 1
-
-    (@start..date_for(working_day_count)).reject { |date| weekend?(date) }
-  end
-
-  # The 0-based business-column index of the n-th working day: the count of
-  # weekdays (holidays included, weekends excluded) from the anchor through it.
-  def business_index(working_day)
-    (@start..date_for(working_day)).count { |date| !weekend?(date) } - 1
-  end
-
-  # The first `count` business-day (weekday) dates from the anchor, holidays
-  # included and weekends excluded — the calendar labels for an axis of `count`
-  # columns, even when it runs past the schedule to cover authored actuals
-  # (ADR-213). Empty for a count below 1.
-  def business_axis(count)
-    return [] if count < 1
-
-    dates = []
-    date = @start
-    while dates.length < count
-      dates << date unless weekend?(date)
-      date += 1
-    end
-    dates
-  end
-
-  # The 0-based business-column index of a real calendar date relative to the
-  # anchor (ADR-213): the count of weekdays from the anchor through the date, minus
-  # one. A weekend date snaps to the preceding weekday's column; a date on or
-  # before the anchor clamps to column 0. Used to place authored committed/logged
-  # dates on the same business-day axis as the schedule.
-  def business_column_for(date)
-    return 0 if date <= @start
-
-    (@start..date).count { |d| !weekend?(d) } - 1
-  end
-
-  def friday?(date)
-    date.wday == FRIDAY
-  end
-
-  def working?(date)
-    !non_working?(date)
-  end
-
-  def non_working?(date)
-    weekend?(date) || @holidays.include?(date)
-  end
-
-  def weekend?(date)
-    [SATURDAY, SUNDAY].include?(date.wday)
-  end
-
-  private
-
-  def first_working_on_or_after(date)
-    date += 1 while non_working?(date)
-    date
-  end
-end