tech: add ancestors, parent, section and repetition to types de champ and champs

TypeDeChampBase#ancestors(revision) returns the sections and repetitions
above a type de champ, outermost first; parent, section and repetition
derive from it. Champ#ancestors projects them with the champ's row_id
inside the repetition, and exposes the same derived accessors.

Champ#parent changes semantics: it used to return the parent repetition
TypeDeChamp, it now returns the nearest container as a projected champ.
Existing callers wanted the repetition and now use Champ#repetition.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: tchak

app/components/dossiers/errors_full_messages_component.rb

@@ -36,7 +36,7 @@ def model_libelle(model)
   def parent_prefix(model)
     return "" if !model.child?
 
-    "#{[is_in_fieldset?(model) ? "[#{row_number(model)}]" : nil, model.parent.libelle].compact.join(" ")} - "
+    "#{[is_in_fieldset?(model) ? "[#{row_number(model)}]" : nil, model.repetition.libelle].compact.join(" ")} - "
   end
 
   def row_number_prefix(model)
@@ -48,13 +48,13 @@ def row_number_prefix(model)
   def row_number(model)
     return 1 if !model.child?
 
-    model.dossier.repetition_row_ids(model.parent).index(model.row_id) + 1
+    model.repetition.row_ids.index(model.row_id) + 1
   end
 
   def is_in_fieldset?(model)
     return 0 if !model.child?
 
-    model.dossier.revision.children_of(model.parent).size > 1
+    model.dossier.revision.children_of(model.repetition.type_de_champ).size > 1
   end
 
   def render?

app/components/editable_champ/editable_champ_component.rb

@@ -17,11 +17,11 @@ def champ_component
   end
 
   def parent_fieldset_legend_id
-    "#{@champ.parent.html_id}-legend"
+    "#{@champ.repetition.html_id}-legend"
   end
 
   def fieldset_legend_id
-    "#{@champ.parent.html_id(@champ.row_id)}-legend"
+    "#{@champ.repetition.type_de_champ.html_id(@champ.row_id)}-legend"
   end
 
   def aria_labelledby_prefix
@@ -33,17 +33,13 @@ def aria_labelledby_prefix
   def number_of_siblings_if_in_repetition
     return if !@champ.child?
 
-    @number_of_siblings_if_in_repetition ||= @champ.dossier.revision.children_of(@champ.parent).count
+    @number_of_siblings_if_in_repetition ||= @champ.dossier.revision.children_of(@champ.repetition.type_de_champ).count
   end
 
   def row_number_if_in_repetition
     return if !@champ.child? || number_of_siblings_if_in_repetition > 1
 
-    @row_number_if_in_repetition ||= begin
-      parent = @champ.parent
-      row_ids = @champ.dossier.repetition_row_ids(parent)
-      row_ids.find_index(@champ.row_id)&.+ 1
-    end
+    @row_number_if_in_repetition ||= @champ.repetition.row_ids.find_index(@champ.row_id)&.+ 1
   end
 
   private

app/models/champ.rb

@@ -131,12 +131,23 @@ def child?
     row_id.present? && !is_type?(TypeDeChamp.type_champs.fetch(:repetition))
   end
 
-  def parent
-    return nil if row_id.blank?
-
-    dossier.revision.parent_of(type_de_champ)
+  # Sections and repetitions above this champ in the tree, outermost first.
+  # Ancestors inside the repetition share the champ's row_id.
+  def ancestors
+    @ancestors ||= begin
+      row = nil
+      type_de_champ.ancestors(dossier.revision).map do |tdc|
+        ancestor = dossier.project_champ(tdc, row_id: row)
+        row = row_id if tdc.repetition?
+        ancestor
+      end
+    end
   end
 
+  def parent = ancestors.last
+  def section = ancestors.reverse.find(&:header_section?)
+  def repetition = ancestors.find(&:repetition?)
+
   def row?
     row_id.present? && is_type?(TypeDeChamp.type_champs.fetch(:repetition))
   end

app/models/concerns/champ_conditional_concern.rb

@@ -55,13 +55,7 @@ def parent_hidden?
     return false if !child?
 
     # otherwise maybe the champ has been moved outside a repetition
-    parent_tdc = dossier.revision.parent_of(type_de_champ)
-
-    return false if parent_tdc.nil?
-
-    parent = dossier.project_champs
-      .find { it.type_de_champ == parent_tdc }
-
-    !parent.visible?
+    parent = repetition
+    parent.present? && !parent.visible?
   end
 end

app/models/concerns/treeable_concern.rb

@@ -29,6 +29,35 @@ def tree_roots(nodes)
     nodes.map { it.is_a?(Array) ? it.first : it }
   end
 
+  # Subtree ([header, *children]) rooted at the section with the given
+  # stable_id, or nil when not found.
+  def find_subtree(tree, stable_id)
+    tree.each do |node|
+      next unless node.is_a?(Array)
+      return node if node.first.stable_id == stable_id
+
+      subtree = find_subtree(node, stable_id)
+      return subtree if subtree
+    end
+    nil
+  end
+
+  # Section headers above the node with the given stable_id, outermost first;
+  # [] when the node is at the top of the tree, nil when not found.
+  def find_section_ancestors(tree, stable_id)
+    tree.each do |node|
+      if node.is_a?(Array)
+        return [] if node.first.stable_id == stable_id
+
+        ancestors = find_section_ancestors(node.drop(1), stable_id)
+        return [node.first, *ancestors] if ancestors
+      elsif node.stable_id == stable_id
+        return []
+      end
+    end
+    nil
+  end
+
   def to_tree(types_de_champ:)
     rooted_tree = []
     walk = Array.new(MAX_DEPTH)

app/models/type_de_champ.rb

@@ -179,7 +179,7 @@ class TypeDeChamp < ApplicationRecord
 
   belongs_to :referentiel, optional: true, inverse_of: :types_de_champ
 
-  delegate :estimated_fill_duration, :estimated_read_duration, :tags_for_template, :libelles_for_export, :libelle_for_export, :primary_options, :secondary_options, :columns, :column, :canonical_column, :info_columns, :children, to: :dynamic_type
+  delegate :estimated_fill_duration, :estimated_read_duration, :tags_for_template, :libelles_for_export, :libelle_for_export, :primary_options, :secondary_options, :columns, :column, :canonical_column, :info_columns, :children, :ancestors, :parent, :section, :repetition, to: :dynamic_type
 
   class WithIndifferentAccess
     def self.load(options)

app/models/types_de_champ/header_section_type_de_champ.rb

@@ -1,41 +1,15 @@
 # frozen_string_literal: true
 
 class TypesDeChamp::HeaderSectionTypeDeChamp < TypesDeChamp::TypeDeChampBase
-  include TreeableConcern
-
   def tags_for_template = [].freeze
 
   # Direct children of the section: its own types de champ and the immediate subsections
   # (but not their content). Sections have no parent relationship in the database, so
   # children are reconstructed from the ordered list of siblings and header levels.
   def children(revision)
-    subtree = find_subtree(to_tree(types_de_champ: siblings(revision)))
+    subtree = find_subtree(to_tree(types_de_champ: siblings(revision)), stable_id)
     return [] if subtree.nil?
 
-    subtree.drop(1).map { it.is_a?(Array) ? it.first : it }
-  end
-
-  private
-
-  def siblings(revision)
-    parent = revision.parent_of(@type_de_champ)
-    if parent.present?
-      revision.children_of(parent)
-    elsif public?
-      revision.types_de_champ_public
-    else
-      revision.types_de_champ_private
-    end
-  end
-
-  def find_subtree(tree)
-    tree.each do |node|
-      next unless node.is_a?(Array)
-      return node if node.first.stable_id == stable_id
-
-      subtree = find_subtree(node)
-      return subtree if subtree.present?
-    end
-    nil
+    tree_roots(subtree.drop(1))
   end
 end

app/models/types_de_champ/repetition_type_de_champ.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 class TypesDeChamp::RepetitionTypeDeChamp < TypesDeChamp::TypeDeChampBase
-  include TreeableConcern
-
   # Direct children of the repetition: its own types de champ and top-level sections
   # (but not the content of those sections).
   def children(revision)

app/models/types_de_champ/type_de_champ_base.rb

@@ -2,6 +2,7 @@
 
 class TypesDeChamp::TypeDeChampBase
   include ActiveModel::Validations
+  include TreeableConcern
 
   delegate :description, :libelle, :mandatory, :mandatory?, :stable_id, :fillable?, :public?, :type_champ, :options_for_select, :drop_down_options, :drop_down_other?, :drop_down_advanced?, :referentiel, :rib?, :justificatif_domicile?, :avis_impot?, :titre_identite?, :ocr_compatible?, to: :@type_de_champ
 
@@ -18,6 +19,23 @@ def initialize(type_de_champ)
   # have children, other types are leaves.
   def children(revision) = []
 
+  # Sections and repetitions above this type de champ in the tree, outermost
+  # first.
+  def ancestors(revision)
+    repetition = revision.parent_of(@type_de_champ)
+    sections = find_section_ancestors(to_tree(types_de_champ: siblings(revision)), stable_id) || []
+
+    if repetition.present?
+      repetition.ancestors(revision) + [repetition] + sections
+    else
+      sections
+    end
+  end
+
+  def parent(revision) = ancestors(revision).last
+  def section(revision) = ancestors(revision).reverse.find(&:header_section?)
+  def repetition(revision) = ancestors(revision).find(&:repetition?)
+
   def tags_for_template
     type_de_champ = @type_de_champ
     conditional = type_de_champ.condition.present?
@@ -137,6 +155,17 @@ def column(column_id)
 
   private
 
+  def siblings(revision)
+    parent = revision.parent_of(@type_de_champ)
+    if parent.present?
+      revision.children_of(parent)
+    elsif public?
+      revision.types_de_champ_public
+    else
+      revision.types_de_champ_private
+    end
+  end
+
   def champ_text_value(champ)
     if champ.is_type?(TypeDeChamp.type_champs.fetch(:multiple_drop_down_list))
       values = TypesDeChamp::MultipleDropDownListTypeDeChamp.parse_selected_options(champ)

spec/models/champ_spec.rb

@@ -616,14 +616,44 @@
     end
   end
 
-  describe "#parent" do
-    let(:procedure) { create(:procedure, types_de_champ_public: [{ type: :repetition, mandatory: false, children: [{ type: :text }] }]) }
+  describe "#ancestors, #parent, #section and #repetition" do
+    let(:procedure) do
+      create(:procedure, types_de_champ_public: [
+        { type: :text, libelle: 't0' },
+        { type: :header_section, level: 1, libelle: 's1' },
+        { type: :header_section, level: 2, libelle: 's1.1' },
+        {
+          type: :repetition, mandatory: false, libelle: 'rep', children: [
+            { type: :header_section, level: 1, libelle: 'rs1' },
+            { type: :text, libelle: 'rt1' },
+          ],
+        },
+      ])
+    end
     let(:dossier) { create(:dossier, :with_populated_champs, procedure:) }
+    let(:champ) { dossier.filled_champs_public.find { _1.libelle == 'rt1' } }
+
+    it "returns the projected champs above, outermost first" do
+      expect(champ.ancestors.map(&:libelle)).to eq(['s1', 's1.1', 'rep', 'rs1'])
+      expect(champ.ancestors.map(&:row_id)).to eq([nil, nil, nil, champ.row_id])
+    end
+
+    it "memoizes ancestors" do
+      expect(champ.ancestors).to equal(champ.ancestors)
+    end
 
-    let(:champ) { dossier.champ_data.where(type: "Champs::TextChamp").first }
+    it "exposes parent, section and repetition" do
+      expect(champ.parent.libelle).to eq('rs1')
+      expect(champ.parent.row_id).to eq(champ.row_id)
+      expect(champ.section.libelle).to eq('rs1')
+      expect(champ.repetition.libelle).to eq('rep')
+      expect(champ.repetition.row_id).to be_nil
 
-    it "returns the parent" do
-      expect(champ.parent).to eq(TypeDeChamp.find_by(type_champ: "repetition"))
+      root_champ = dossier.project_champs_public.find { _1.libelle == 't0' }
+      expect(root_champ.ancestors).to eq([])
+      expect(root_champ.parent).to be_nil
+      expect(root_champ.section).to be_nil
+      expect(root_champ.repetition).to be_nil
     end
   end