Almirah 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b53b0b8a1c024c618e1fff5aac5288312b51b2a06f228527f06183b31f114ac
-  data.tar.gz: 41959a8eaba117737d913afd63bda6947301e3a5a84aac96b94030f43f6a4564
+  metadata.gz: e7ecb1c0f1633226eaccd34b70d7c45c6d00e6f8ec4b605231f71b7bea725dcd
+  data.tar.gz: a223709af5754031b0efef8c443fd158fad6c2c3fde08fbba83233e82075d82a
 SHA512:
-  metadata.gz: 66edfea3c57bb86b6cc5e63de0b63579ec756a12b2704db2c86d2956124e7a9a89fd6e1db86f5481c18840bb4378acbb11d1a5db250d14ccfc7a699c7e0f614e
-  data.tar.gz: ddbd78d3135822cf967a6fac7c2ae87986dbf79aa537b403dfc15c41ffbc36c7594c9460cb086b067d70b7492aee4f0bc81c48b40b07caf02ea70b22fffd915b
+  metadata.gz: 4d57afaec80f6e7370aec60e254f6650832ed2808a2b1550efc7a5271f69bd4e2bbce2e636eb2f7128b1a8ccee6e2bf978e0ca032ad275c399bbc334c12c57ab
+  data.tar.gz: a5e6de48b94a5de8a77ab8cb7e744116b3c9ecb5b92e3f81d1231c9436e412d9f1e53e97f2db9c2dc733f3dfdda6966e305b3b7faf9963453d1abff970358985

data/lib/almirah/doc_fabric.rb

@@ -10,7 +10,6 @@ require_relative 'doc_types/risk_record'
 require_relative 'doc_types/risk_registry_page'
 require_relative 'doc_types/risks_overview'
 require_relative 'doc_types/decisions_overview'
-require_relative 'doc_types/critical_chain_page'
 require_relative 'doc_parser'
 require_relative 'source_file_parser'
 require_relative 'dom/document'
@@ -72,7 +71,6 @@ class DocFabric
     doc.extract_target_date
     doc.extract_target_release_version
     doc.extract_owners
-    doc.extract_scope_table
     doc
   end
 
@@ -95,10 +93,6 @@ class DocFabric
     DecisionsOverview.new project
   end
 
-  def self.create_critical_chain_page(project)
-    CriticalChainPage.new project
-  end
-
   def self.create_source_file(repository_path, path, repository_name)
     doc = SourceFile.new repository_path, path, repository_name
     DocFabric.parse_source_file doc

data/lib/almirah/doc_items/scope_table.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
-require 'date'
 require_relative 'controlled_table'
-require_relative 'work_item'
+require_relative '../relative_url'
 
 # Purpose-built controlled table for a Decision Record's `# Scope` section
-# (ADR-194). It is modelled on ControlledTable but addresses its columns by
-# header text (not position) and has no fixed link column: it locates `#`,
-# `Item`, `Owner`, `Depends On`, and `Status` wherever the author placed them.
+# (ADR-210, slimmed to presentation only by ADR-222). It is modelled on
+# ControlledTable but addresses its columns by header text (not position): it
+# locates `#` and `Depends On` wherever the author placed them, along with the
+# date columns whose cells are kept on one line (ENH-214).
 #
-# Each data row becomes a WorkItem (the dependency-network node). The table also
-# keeps a plain header-addressed cell grid (`cells`) so the ADR-193 Scope
-# readers (owners / WIP / dates) keep working unchanged after the Scope section
-# stopped being a plain MarkdownTable.
+# Rendering is the table's whole job: the `#` column is an anchored row number
+# so individual Scope rows can be linked, and each Depends On reference renders
+# as a clickable link to the referenced record.
 class ScopeTable < ControlledTable
-  attr_reader :cells, :work_items
+  attr_reader :cells
 
   def initialize(doc, markdown_table)
     @parent_doc = doc
@@ -22,7 +21,7 @@ class ScopeTable < ControlledTable
     @column_names = markdown_table.column_names
     @is_separator_detected = markdown_table.is_separator_detected
     @cells = []
-    @work_items = []
+    @rows = []
     @col = locate_columns(@column_names)
     # The switch to ScopeTable happens on the first data row, so the source
     # MarkdownTable carries none yet; any it did are re-read for safety.
@@ -34,12 +33,6 @@ class ScopeTable < ControlledTable
     true
   end
 
-  # True when the table has a leading `#` step column, hence a per-row anchor a
-  # dependent record can deep-link to (ADR-194).
-  def step_column?
-    !@col[:step].nil?
-  end
-
   # Render as a controlled table: an anchored, centered step number in the `#`
   # column (so rows are linkable, like the protocol table) and formatted text
   # for every other cell.
@@ -52,7 +45,7 @@ class ScopeTable < ControlledTable
     s << "<table class=\"markdown_table\">\n\t<thead>"
     @column_names.each { |h| s << " <th>#{format_string(h.strip)}</th>" }
     s << " </thead>\n"
-    @cells.each_with_index { |cells, i| s << row_html(cells, @work_items[i]) }
+    @cells.each_with_index { |cells, i| s << row_html(cells, @rows[i]) }
     s << "</table>\n"
     s
   end
@@ -64,58 +57,14 @@ class ScopeTable < ControlledTable
       column_names.each_with_index { |h, i| return i if h.to_s.strip == name }
       nil
     end
-    { step: index_of.call('#'), item: index_of.call('Item'), owner: index_of.call('Owner'),
-      depends_on: index_of.call('Depends On'), status: index_of.call('Status'),
-      est_focused: index_of.call('Est (focused)'), est_safe: index_of.call('Est (safe)'),
+    { step: index_of.call('#'), depends_on: index_of.call('Depends On'),
       start_date: index_of.call('Start Date'), target_date: index_of.call('Target Date') }
   end
 
   def append_cells(cells)
     @cells << cells
-    @work_items << build_work_item(cells)
-  end
-
-  def build_work_item(cells)
-    WorkItem.new(
-      record_id: @parent_doc.id,
-      step: step_number(cells, @cells.length), # 1-based row order fallback
-      activity: cell(cells, @col[:item]),
-      owner: cell(cells, @col[:owner]),
-      status: cell(cells, @col[:status]),
-      depends_on_refs: parse_depends_on(cell(cells, @col[:depends_on])),
-      start_date: parse_date(cell(cells, @col[:start_date])),
-      target_date: parse_date(cell(cells, @col[:target_date])),
-      **estimate_attrs(cells)
-    )
-  end
-
-  # A Scope Start/Target Date cell as a Date (ADR-213), or nil when blank or not
-  # in the DD-MM-YYYY form the rest of the planning views read (ADR-205).
-  def parse_date(text)
-    match = /\A(\d{2})-(\d{2})-(\d{4})\z/.match(text.to_s.strip)
-    return nil unless match
-
-    Date.new(match[3].to_i, match[2].to_i, match[1].to_i)
-  rescue ArgumentError
-    nil
-  end
-
-  # The ADR-195 estimate-derived attributes: focused and safe working-day
-  # estimates (blank/unparseable -> 0) and the owning record's sequence number
-  # (the critical-chain priority tiebreak).
-  def estimate_attrs(cells)
-    {
-      focused_estimate: parse_estimate(cell(cells, @col[:est_focused])),
-      safe_estimate: parse_estimate(cell(cells, @col[:est_safe])),
-      record_sequence: @parent_doc.sequence_number.to_i
-    }
-  end
-
-  # A Scope estimate cell as a non-negative number of working days (decimals
-  # allowed); blank, unparseable, or negative values count as 0 (ADR-195).
-  def parse_estimate(text)
-    value = Float(text.to_s.strip, exception: false)
-    value&.positive? ? value : 0.0
+    @rows << { step: step_number(cells, @cells.length),
+               depends_on: parse_depends_on(cell(cells, @col[:depends_on])) }
   end
 
   # The `#` column's integer when present; otherwise the row's 1-based position,
@@ -137,52 +86,54 @@ class ScopeTable < ControlledTable
     cells[index].to_s.strip
   end
 
-  def row_html(cells, work_item)
+  def row_html(cells, row)
     s = +"\t<tr>\n"
-    cells.each_with_index { |value, index| s << cell_html(value, index, work_item) }
+    cells.each_with_index { |value, index| s << cell_html(value, index, row) }
     s << "\t</tr>\n"
     s
   end
 
-  def cell_html(value, index, work_item)
-    return depends_on_html(work_item) if index == @col[:depends_on]
-    return step_cell_html(value, work_item) if index == @col[:step]
+  def cell_html(value, index, row)
+    return depends_on_html(row) if index == @col[:depends_on]
+    return step_cell_html(value, row) if index == @col[:step]
     return date_cell_html(value) if [@col[:start_date], @col[:target_date]].include?(index)
 
     "\t\t<td>#{format_string(value.strip)}</td>\n"
   end
 
   # The Start/Target Date cells are kept on one line so a DD-MM-YYYY date never
-  # wraps at its hyphens in a narrow column (ADR-213).
+  # wraps at its hyphens in a narrow column (ENH-214).
   def date_cell_html(value)
     "\t\t<td class=\"scope_date\">#{format_string(value.strip)}</td>\n"
   end
 
   # The `#` cell is a named anchor (id + name), mirroring the test-step number
-  # column, so a dependent record's Depends On link can target this row.
-  def step_cell_html(value, work_item)
-    anchor = work_item.row_anchor
+  # column, so a Scope row can be deep-linked. Namespaced with `.scope.` so it
+  # never collides with the Affected Documents controlled table, whose rows
+  # anchor on the same `<record>.<step>` scheme on the same page.
+  def step_cell_html(value, row)
+    anchor = "#{@parent_doc.id}.scope.#{row[:step]}"
     "\t\t<td style=\"text-align: center;\">" \
       "<a name=\"#{anchor}\" id=\"#{anchor}\" href=\"##{anchor}\">#{format_string(value.strip)}</a></td>\n"
   end
 
-  # Render each authored Depends On reference as a link to the resolved target
-  # record. When the target record has a `#` step column, the link deep-jumps to
-  # the aligned activity row (its step anchor); otherwise it opens the record
-  # page (no such anchor exists). Unresolved references render as broken-link
-  # spans (ADR-194 also reports them on the console).
-  def depends_on_html(work_item)
-    return "\t\t<td></td>\n" if work_item.depends_on_refs.empty?
+  # Render each authored Depends On reference as a link to the referenced
+  # record's page, resolved against the project-wide link registry. Unresolved
+  # references render as broken-link spans.
+  def depends_on_html(row)
+    return "\t\t<td></td>\n" if row[:depends_on].empty?
 
-    links = work_item.depends_on_refs.map { |ref| dependency_ref_html(ref, work_item) }
+    links = row[:depends_on].map { |ref| dependency_ref_html(ref) }
     "\t\t<td>#{links.join(', ')}</td>\n"
   end
 
-  def dependency_ref_html(ref, work_item)
-    dep = work_item.resolved_dependencies[ref]
-    return "<span class=\"broken_link\" title=\"Unresolved Depends On\">#{ref}</span>" if dep.nil?
-
-    href = RelativeUrl.between(@parent_doc.output_rel_path, dep[:doc].output_rel_path, fragment: dep[:anchor])
-    "<a href=\"#{href}\" class=\"external\" title=\"Depends on #{dep[:label]}\">#{ref}</a>"
+  def dependency_ref_html(ref)
+    target = TextLine.link_registry&.find_by_id(ref)
+    if target.nil? || target.output_rel_path.nil?
+      "<span class=\"broken_link\" title=\"Unresolved Depends On\">#{ref}</span>"
+    else
+      href = RelativeUrl.between(@parent_doc.output_rel_path, target.output_rel_path)
+      "<a href=\"#{href}\" class=\"external\" title=\"Depends on #{target.id}\">#{ref}</a>"
+    end
   end
 end

data/lib/almirah/doc_types/base_document.rb

@@ -35,8 +35,6 @@ class BaseDocument
                           "#{@id}.html"
                         elsif instance_of? DecisionsOverview
                           'overview.html'
-                        elsif instance_of? CriticalChainPage
-                          'critical-chain.html'
                         elsif instance_of?(RiskRegistryPage) || instance_of?(RisksOverview)
                           'overview.html'
                         elsif is_a? Decision # RiskRecord included
@@ -70,10 +68,7 @@ class BaseDocument
         else
           file.puts index_link(rel_to('index.html'))
         end
-        if BaseDocument.show_decisions_link
-          file.puts decisions_link(rel_to('decisions/overview.html'))
-          file.puts critical_chain_link(rel_to('decisions/critical-chain.html'))
-        end
+        file.puts decisions_link(rel_to('decisions/overview.html')) if BaseDocument.show_decisions_link
         file.puts risks_link(rel_to('risks/overview.html')) if BaseDocument.show_risks_link
       elsif s.include?('{{GEM_VERSION}}')
         file.puts "(#{Gem.loaded_specs['Almirah'].version.version})"
@@ -89,11 +84,6 @@ class BaseDocument
     %(<a id="decisions_menu_item" href="#{href}">#{icon}&nbsp;Decision Records</a>)
   end
 
-  def critical_chain_link(href)
-    icon = '<span><i class="fa fa-link" aria-hidden="true"></i></span>'
-    %(<a id="critical_chain_menu_item" href="#{href}">#{icon}&nbsp;Critical Chain</a>)
-  end
-
   def risks_link(href)
     icon = '<span><i class="fa fa-exclamation-triangle" aria-hidden="true"></i></span>'
     %(<a id="risks_menu_item" href="#{href}">#{icon}&nbsp;Risks</a>)

data/lib/almirah/doc_types/decision.rb

@@ -9,7 +9,7 @@ require_relative '../doc_items/scope_table'
 class Decision < PersistentDocument
   attr_accessor :path, :sequence_number, :record_type, :html_rel_path, :root_prefix, :current_status,
                 :start_date, :target_date, :target_release_version, :specifications_path, :wrong_links_hash,
-                :owners, :scope_table
+                :owners
 
   def initialize(file_path)
     super
@@ -84,55 +84,6 @@ class Decision < PersistentDocument
     end
   end
 
-  # The parsed Scope ScopeTable (ADR-194), or nil when the record has no Scope
-  # section. Memoised so the work-item network and the readers share one table.
-  def extract_scope_table
-    table = find_section_table('Scope')
-    @scope_table = table.is_a?(ScopeTable) ? table : nil
-  end
-
-  # The Scope rows as WorkItem nodes (ADR-194); empty when there is no ScopeTable.
-  def scope_work_items
-    @scope_table ? @scope_table.work_items : []
-  end
-
-  # A record declares prerequisites when any of its rows carries a Depends On
-  # reference; the overview Kit column is empty otherwise.
-  def declared_dependencies?
-    scope_work_items.any? { |wi| wi.depends_on_refs.any? }
-  end
-
-  # Kitted when every one of its work items is (a record with no rows is kitted).
-  def fully_kitted?
-    scope_work_items.all?(&:fully_kitted?)
-  end
-
-  # A started row blocked by an unsatisfied cross-record predecessor — the
-  # overview emphasises such a record, matching the console warning.
-  def kit_started_violation?
-    scope_work_items.any?(&:cross_record_violation?)
-  end
-
-  # One entry per Scope row whose row Status is In-Progress, yielding that row's
-  # owner. Rows without an owner, or not In-Progress, contribute nothing. The
-  # per-row Status is read directly and is independent of the record's lifecycle
-  # status. Owner and Status columns are located by header text, not position.
-  def in_progress_owner_tally
-    table = find_section_table('Scope')
-    return [] if table.nil?
-
-    owner_idx = column_index(table, 'Owner')
-    status_idx = column_index(table, 'Status')
-    return [] if owner_idx.nil? || status_idx.nil?
-
-    table.cells.filter_map do |row|
-      owner = row[owner_idx].to_s.strip
-      next if owner.empty?
-
-      owner if row[status_idx].to_s.strip == 'In-Progress'
-    end
-  end
-
   def effective_status_on(date)
     table = find_section_table('Status')
     return nil if table.nil?
@@ -158,43 +109,6 @@ class Decision < PersistentDocument
     status.empty? ? nil : status
   end
 
-  # Total logged effort in hours across the # Effort table (ADR-196); 0 when the
-  # record has no Effort section. Undated and unparseable entries still count
-  # toward the record total.
-  def actual_hours
-    effort_entries.sum { |e| e[:hours] }
-  end
-
-  # Logged hours dated on or before `date` (ADR-196). Undated entries are
-  # excluded since they cannot be placed on the timeline.
-  def actual_hours_on(date)
-    effort_entries.sum { |e| e[:date] && e[:date] <= date ? e[:hours] : 0.0 }
-  end
-
-  # Logged hours dated on or before `date` for the Scope row whose Item matches
-  # `item` (case-insensitive) — the per-chain-row actual the fever chart credits
-  # (ADR-196). Entries with no Item credit no row and are excluded here.
-  def row_actual_hours_on(item, date)
-    key = item.to_s.strip.downcase
-    return 0.0 if key.empty?
-
-    effort_entries.sum do |e|
-      e[:item] == key && e[:date] && e[:date] <= date ? e[:hours] : 0.0
-    end
-  end
-
-  # The [earliest, latest] dated # Effort entry crediting the Scope row whose Item
-  # matches `item` (case-insensitive) — the real logged span the Gantt's tracking
-  # lane draws (ADR-213). nil when the row has no dated effort. Undated entries are
-  # excluded since they cannot be placed on the timeline.
-  def effort_date_range(item)
-    key = item.to_s.strip.downcase
-    return nil if key.empty?
-
-    dates = effort_entries.filter_map { |e| e[:date] if e[:item] == key }
-    dates.empty? ? nil : dates.minmax
-  end
-
   private
 
   def lookup_cell(section_name:, key_column:, value_column:, key:)
@@ -258,45 +172,6 @@ class Decision < PersistentDocument
     nil
   end
 
-  # Parsed # Effort rows (ADR-196): [{ date:, item:, hours: }, ...]. The section
-  # is located by heading text and its columns addressed by header (Date / Item /
-  # Hours), like Status and Scope. Hours parse as non-negative floats (blank,
-  # negative, or unparseable -> 0); Item is downcased for case-insensitive row
-  # matching, or nil when absent. Memoised so the readers share one parse.
-  def effort_entries
-    return @effort_entries if defined?(@effort_entries)
-
-    @effort_entries = parse_effort_entries
-  end
-
-  def parse_effort_entries
-    table = find_section_table('Effort')
-    return [] if table.nil?
-
-    date_idx = column_index(table, 'Date')
-    hours_idx = column_index(table, 'Hours')
-    return [] if date_idx.nil? || hours_idx.nil?
-
-    item_idx = column_index(table, 'Item')
-    table.cells.map { |row| effort_entry(row, date_idx, item_idx, hours_idx) }
-  end
-
-  def effort_entry(row, date_idx, item_idx, hours_idx)
-    { date: parse_dd_mm_yyyy(row[date_idx]),
-      item: item_idx ? normalize_item(row[item_idx]) : nil,
-      hours: parse_hours(row[hours_idx]) }
-  end
-
-  def normalize_item(value)
-    text = value.to_s.strip.downcase
-    text.empty? ? nil : text
-  end
-
-  def parse_hours(value)
-    hours = Float(value.to_s.strip, exception: false)
-    hours.nil? || hours.negative? ? 0.0 : hours
-  end
-
   def assign_id_parts(stem)
     match = stem.match(/\A([A-Za-z]+)-(\d+)/)
     if match