isodoc 2.12.1 → 2.12.2

data/lib/isodoc/xref/xref_anchor.rb

@@ -1,4 +1,5 @@
 require "singleton"
+require_relative "xref_util"
 
 module IsoDoc
   module XrefGen
@@ -29,37 +30,51 @@ module IsoDoc
         @anchors
       end
 
-      def anchor_struct_label(lbl, elem)
+      def anchor_struct_label(lbl, node, elem)
         case elem
-        when @labels["appendix"] then "#{elem} #{lbl}"
+        when @labels["appendix"]
+          s = "<semx element='autonum' source='#{node['id'] || node[:id]}'>" \
+            "#{lbl}</semx>"
+          "<span class='fmt-element-name'>#{elem}</span> #{s}"
         else
-          lbl.to_s
+          anchor_struct_value(lbl, elem)
         end
       end
 
-      def anchor_struct_xref(lbl, elem)
-        l10n("#{elem} #{anchor_struct_value(lbl, elem)}")
+      def anchor_struct_xref(lbl, node, elem)
+        unless lbl.blank?
+          lbl = semx(node, lbl)
+          s = " #{anchor_struct_value(lbl, elem)}"
+        end
+        l10n("<span class='fmt-element-name'>#{elem}</span>#{s}")
+          .gsub(/ $/, "")
       end
 
       def anchor_struct_value(lbl, elem)
         case elem
-        when @labels["formula"], @labels["inequality"] then "(#{lbl})"
+          # TODO hardcoded ( ) ?
+        when @labels["formula"], @labels["inequality"] then <<~SPAN.strip
+          #{delim_wrap('(')}#{lbl}#{delim_wrap(')')}
+        SPAN
         else
-          lbl
+          lbl.to_s
         end
       end
 
-      def anchor_struct(lbl, container, elem, type, unnumb = false)
-        ret = {}
-        ret[:label] = unnumb == "true" ? nil : anchor_struct_label(lbl, elem)
-        ret[:xref] = anchor_struct_xref(unnumb == "true" ? "(??)" : lbl, elem)
-        ret[:xref].gsub!(/ $/, "")
-        ret[:container] = @klass.get_clause_id(container) unless container.nil?
-        ret[:type] = type
-        ret[:elem] = elem
-        ret[:value] = anchor_struct_value(lbl, elem)
+      # def anchor_struct(lbl, container, elem, type, unnumb = false)
+      def anchor_struct(lbl, node, elem_name, type, opt = {})
+        ret = { type: type, elem: elem_name, label: nil }
+        opt[:unnumb] != "true" and
+          ret[:label] = anchor_struct_label(lbl, node, elem_name)
+        ret[:xref] =
+          anchor_struct_xref(opt[:unnumb] == "true" ? "(??)" : lbl, node,
+                             elem_name)
+        ret[:container] = @klass.get_clause_id(node) if opt[:container]
+        ret[:value] = stripsemx(lbl)
         ret
       end
+
+      include ::IsoDoc::XrefGen::Util
     end
   end
 end

data/lib/isodoc/xref/xref_counter_types.rb

@@ -2,11 +2,12 @@ require_relative "xref_counter"
 
 module IsoDoc
   class Xref
-    def clause_counter(num = 0, opts = { numerals: :arabic })
+    def clause_counter(num = 0, opts = {})
+      opts[:numerals] ||= :arabic
       ::IsoDoc::XrefGen::Counter.new(num, opts)
     end
 
-    def list_counter(num = 0, opts = { numerals: :arabic })
+    def list_counter(num = 0, opts = {})
       ::IsoDoc::XrefGen::Counter.new(num, opts)
     end
   end

data/lib/isodoc/xref/xref_gen.rb

@@ -28,14 +28,18 @@ module IsoDoc
         autonum
       end
 
-      def termnote_label(note)
-        @labels["termnote"].gsub("%", note.to_s)
+      def termnote_label(node, label)
+        if label.blank?
+          @labels["termnote"].gsub(/%\s?/, "")
+        else
+          @labels["termnote"].gsub("%", semx(node, label.to_s))
+        end
       end
 
       def increment_label(elems, node, counter, increment: true)
         elems.size == 1 && !node["number"] and return ""
         counter.increment(node) if increment
-        " #{counter.print}"
+        counter.print
       end
 
       def termnote_anchor_names(docxml)
@@ -44,10 +48,10 @@ module IsoDoc
           t.xpath(ns("./termnote")).noblank.each do |n|
             c.increment(n)
             @anchors[n["id"]] =
-              { label: termnote_label(c.print), type: "termnote",
+              { label: termnote_label(n, c.print), type: "termnote",
                 value: c.print, elem: @labels["termnote"],
                 container: t["id"],
-                xref: "#{@labels['note_xref']} #{c.print}" }
+                xref: anchor_struct_xref(c.print, n, @labels["note_xref"]) }
           end
         end
       end
@@ -63,7 +67,7 @@ module IsoDoc
               { label: idx, type: "termexample",
                 value: idx, elem: @labels["example_xref"],
                 container: t["id"],
-                xref: "#{@labels['example_xref']} #{idx}" }
+                xref: anchor_struct_xref(idx, n, @labels["example_xref"]) }
           end
         end
       end
@@ -73,7 +77,7 @@ module IsoDoc
           notes = s.xpath(child_asset_path("note")) -
             s.xpath(ns(".//figure//note | .//table//note"))
           note_anchor_names1(notes, Counter.new)
-          note_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+          note_anchor_names(s.xpath(ns(child_sections)))
         end
       end
 
@@ -81,7 +85,8 @@ module IsoDoc
         notes.noblank.each do |n|
           @anchors[n["id"]] =
             anchor_struct(increment_label(notes, n, counter), n,
-                          @labels["note_xref"], "note", false)
+                          @labels["note_xref"], "note",
+                          { container: true, unnumb: false })
         end
       end
 
@@ -90,7 +95,7 @@ module IsoDoc
           s.at(ns(".//admonition[@type = 'box']")) or next
           notes = s.xpath(child_asset_path("admonition[@type = 'box']"))
           admonition_anchor_names1(notes, Counter.new)
-          admonition_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+          admonition_anchor_names(s.xpath(ns(child_sections)))
         end
       end
 
@@ -98,7 +103,8 @@ module IsoDoc
         notes.noblank.each do |n|
           @anchors[n["id"]] ||=
             anchor_struct(increment_label(notes, n, counter), n,
-                          @labels["box"], "admonition", n["unnumbered"])
+                          @labels["box"], "admonition",
+                          { container: true, unnumb: n["unnumbered"] })
         end
       end
 
@@ -106,7 +112,7 @@ module IsoDoc
         sections.each do |s|
           notes = s.xpath(child_asset_path("example"))
           example_anchor_names1(notes, Counter.new)
-          example_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+          example_anchor_names(s.xpath(ns(child_sections)))
         end
       end
 
@@ -114,7 +120,8 @@ module IsoDoc
         notes.noblank.each do |n|
           @anchors[n["id"]] ||=
             anchor_struct(increment_label(notes, n, counter), n,
-                          @labels["example_xref"], "example", n["unnumbered"])
+                          @labels["example_xref"], "example",
+                          { unnumb: n["unnumbered"], container: true })
         end
       end
 
@@ -122,27 +129,35 @@ module IsoDoc
         sections.each do |s|
           notes = s.xpath(ns(".//ol")) - s.xpath(ns(".//clause//ol")) -
             s.xpath(ns(".//appendix//ol")) - s.xpath(ns(".//ol//ol"))
-          c = list_counter
+          c = list_counter(0, {})
           notes.noblank.each do |n|
-            @anchors[n["id"]] = anchor_struct(increment_label(notes, n, c), n,
-                                              @labels["list"], "list", false)
+            @anchors[n["id"]] =
+              anchor_struct(increment_label(notes, n, c), n,
+                            @labels["list"], "list",
+                            { unnumb: false, container: true })
             list_item_anchor_names(n, @anchors[n["id"]], 1, "", notes.size != 1)
           end
-          list_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+          list_anchor_names(s.xpath(ns(child_sections)))
         end
       end
 
-      def list_item_anchor_names(list, list_anchor, depth, prev_label, refer_list)
-        c = list_counter(list["start"] ? list["start"].to_i - 1 : 0)
+      def list_item_delim
+        ")"
+      end
+
+      def list_item_anchor_names(list, list_anchor, depth, prev_label,
+refer_list)
+        c = list_counter(list["start"] ? list["start"].to_i - 1 : 0, {})
         list.xpath(ns("./li")).each do |li|
           bare_label, label =
-            list_item_value(li, c, depth, { list_anchor:, prev_label:,
-                                            refer_list: depth == 1 ? refer_list : nil })
-          li["id"] and @anchors[li["id"]] =
-                         { label: bare_label, bare_xref: "#{label})",
-                           xref: "#{label})",
-                           type: "listitem", refer_list:,
-                           container: list_anchor[:container] }
+            list_item_value(li, c, depth,
+                            { list_anchor:, prev_label:,
+                              refer_list: depth == 1 ? refer_list : nil })
+          li["id"] ||= "_#{UUIDTools::UUID.random_create}"
+          @anchors[li["id"]] =
+            { label: bare_label, bare_xref: "#{label})", type: "listitem",
+              xref: %[#{label}#{delim_wrap(list_item_delim)}], refer_list:,
+              container: list_anchor[:container] }
           (li.xpath(ns(".//ol")) - li.xpath(ns(".//ol//ol"))).each do |ol|
             list_item_anchor_names(ol, list_anchor, depth + 1, label,
                                    refer_list)
@@ -152,18 +167,21 @@ module IsoDoc
 
       def list_item_value(entry, counter, depth, opts)
         label = counter.increment(entry).listlabel(entry.parent, depth)
+        s = semx(entry, label)
         [label,
-         list_item_anchor_label(label, opts[:list_anchor], opts[:prev_label],
+         list_item_anchor_label(s, opts[:list_anchor], opts[:prev_label],
                                 opts[:refer_list])]
       end
 
       def list_item_anchor_label(label, list_anchor, prev_label, refer_list)
         prev_label.empty? or
-          label = @i18n.list_nested_xref.sub("%1", "#{prev_label})")
-            .sub("%2", label)
+          label = @klass.connectives_spans(@i18n.list_nested_xref
+            .sub("%1", %[#{prev_label}#{delim_wrap(list_item_delim)}])
+            .sub("%2", label))
         refer_list and
-          label = @i18n.list_nested_xref.sub("%1", list_anchor[:xref])
-            .sub("%2", label)
+          label = @klass.connectives_spans(@i18n.list_nested_xref
+            .sub("%1", list_anchor[:xref])
+            .sub("%2", label))
         label
       end
 
@@ -172,7 +190,7 @@ module IsoDoc
           notes = s.xpath(ns(".//dl")) - s.xpath(ns(".//clause//dl")) -
             s.xpath(ns(".//appendix//dl")) - s.xpath(ns(".//dl//dl"))
           deflist_anchor_names1(notes, Counter.new)
-          deflist_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+          deflist_anchor_names(s.xpath(ns(child_sections)))
         end
       end
 
@@ -180,14 +198,15 @@ module IsoDoc
         notes.noblank.each do |n|
           @anchors[n["id"]] =
             anchor_struct(increment_label(notes, n, counter), n,
-                          @labels["deflist"], "deflist", false)
+                          @labels["deflist"], "deflist",
+                          { unnumb: false, container: true })
           deflist_term_anchor_names(n, @anchors[n["id"]])
         end
       end
 
       def deflist_term_anchor_names(list, list_anchor)
         list.xpath(ns("./dt")).each do |li|
-          label = "#{list_anchor[:xref]}: #{dt2xreflabel(li)}"
+          label = deflist_term_anchor_lbl(li, list_anchor)
           li["id"] and @anchors[li["id"]] =
                          { xref: label, type: "deflistitem",
                            container: list_anchor[:container] }
@@ -197,6 +216,11 @@ module IsoDoc
         end
       end
 
+      def deflist_term_anchor_lbl(listitem, list_anchor)
+        s = semx(listitem, dt2xreflabel(listitem))
+        %(#{list_anchor[:xref]}#{delim_wrap(":")} #{s}</semx>)
+      end
+
       def dt2xreflabel(dterm)
         label = dterm.dup
         label.xpath(ns(".//p")).each { |x| x.replace(x.children) }

data/lib/isodoc/xref/xref_gen_seq.rb

@@ -11,6 +11,10 @@ module IsoDoc
         "-"
       end
 
+      def hierreqtsep
+        "-"
+      end
+
       def subfigure_increment(idx, counter, elem)
         if elem.parent.name == "figure" then idx += 1
         else
@@ -30,7 +34,8 @@ module IsoDoc
         clause.xpath(ns(self.class::FIGURE_NO_CLASS)).noblank.each do |t|
           # labelled_ancestor(t, %w(figure)) and next # disable nested figure labelling
           j = subfigure_increment(j, c, t)
-          sequential_figure_body(j, c, t, "figure", container:)
+          sublabel = subfigure_label(j)
+          figure_anchor(t, sublabel, c.print, "figure", container: container)
         end
         sequential_figure_class_names(clause, container:)
       end
@@ -43,24 +48,69 @@ module IsoDoc
           c[t["class"]] ||= Counter.new
           # labelled_ancestor(t, %w(figure)) and next
           j = subfigure_increment(j, c[t["class"]], t)
-          sequential_figure_body(j, c[t["class"]], t, t["class"],
-                                 container:)
+          sublabel = subfigure_label(j)
+          figure_anchor(t, sublabel, c[t["class"]].print, t["class"],
+                        container: container)
         end
       end
 
+      def hier_separator(markup: false)
+        h = hiersep
+        h.blank? || !markup or h = delim_wrap(h)
+        h
+      end
+
       def subfigure_label(subfignum)
-        subfignum.zero? and return ""
-        "#{hierfigsep}#{subfignum}"
+        subfignum.zero? and return
+        subfignum.to_s
+      end
+
+      def subfigure_separator(markup: false)
+        h = hierfigsep
+        h.blank? || !markup or h = delim_wrap(h)
+        h
+      end
+
+      def subreqt_separator(markup: false)
+        h = hierreqtsep
+        h.blank? || !markup or h = delim_wrap(h)
+        h
+      end
+
+      def subfigure_delim
+        ""
+      end
+
+      def figure_anchor(elem, sublabel, label, klass, container: false)
+        if sublabel
+          /<semx/.match?(label) or label = semx(elem.parent, label)
+          subfigure_anchor(elem, sublabel, label, klass, container: false)
+        else
+          @anchors[elem["id"]] = anchor_struct(
+            label, elem, @labels[klass] || klass.capitalize, klass,
+            { unnumb: elem["unnumbered"], container: }
+          )
+        end
+      end
+
+      def fig_subfig_label(label, sublabel)
+        "#{label}#{subfigure_separator}#{sublabel}"
       end
 
-      def sequential_figure_body(subfig, counter, elem, klass, container: false)
-        label = counter.print
-        label &&= label + subfigure_label(subfig)
+      def subfigure_anchor(elem, sublabel, label, klass, container: false)
+        figlabel = fig_subfig_label(label, sublabel)
         @anchors[elem["id"]] = anchor_struct(
-          label, container ? elem : nil,
-          @labels[klass] || klass.capitalize, klass,
-          elem["unnumbered"]
+          figlabel, elem, @labels[klass] || klass.capitalize, klass,
+          { unnumb: elem["unnumbered"] }
         )
+        if elem["unnumbered"] != "true"
+          x = "#{subfigure_separator(markup: true)}#{semx(elem, sublabel)}"
+          @anchors[elem["id"]][:label] = "#{label}#{x}" # "#{semx(elem.parent, label)}#{x}"
+          @anchors[elem["id"]][:xref] = @anchors[elem.parent["id"]][:xref] + x +
+            delim_wrap(subfigure_delim)
+          x = @anchors[elem.parent["id"]][:container] and
+          @anchors[elem["id"]][:container] = x
+        end
       end
 
       def sequential_table_names(clause, container: false)
@@ -68,8 +118,8 @@ module IsoDoc
         clause.xpath(ns(".//table")).noblank.each do |t|
           # labelled_ancestor(t) and next
           @anchors[t["id"]] = anchor_struct(
-            c.increment(t).print, container ? t : nil,
-            @labels["table"], "table", t["unnumbered"]
+            c.increment(t).print, t,
+            @labels["table"], "table", { unnumb: t["unnumbered"], container: container }
           )
         end
       end
@@ -80,7 +130,7 @@ module IsoDoc
           @anchors[t["id"]] = anchor_struct(
             c.increment(t).print, t,
             t["inequality"] ? @labels["inequality"] : @labels["formula"],
-            "formula", t["unnumbered"]
+            "formula", { unnumb: t["unnumbered"], container: true }
           )
         end
       end
@@ -95,39 +145,49 @@ module IsoDoc
         ./permission | ./requirement | ./recommendation
       XPATH
 
-      def sequential_permission_names(clause, container: false)
+      def sequential_permission_names(clause, container: true)
         c = ReqCounter.new
         clause.xpath(ns(FIRST_LVL_REQ)).noblank.each do |t|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_label(t, m)
           id = c.increment(label, t).print
-          sequential_permission_body(id, t, label, klass, m,
+          sequential_permission_body(id, nil, t, label, klass, m,
                                      container:)
-          sequential_permission_children(t, id, container:)
+          sequential_permission_children(t, id, klass, container:)
         end
       end
 
-      def sequential_permission_children(elem, lbl, container: false)
+      def sequential_permission_children(elem, lbl, klass, container: false)
         c = ReqCounter.new
         elem.xpath(ns(REQ_CHILDREN)).noblank.each do |t|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_nested_label(t, m)
-          id = "#{lbl}#{hierfigsep}#{c.increment(label, t).print}"
-          sequential_permission_body(id, t, label, klass, m,
+          ctr = c.increment(label, t).print
+          id = "#{lbl}#{subreqt_separator}#{ctr}"
+          sequential_permission_body(ctr, lbl, t, label, klass, m,
                                      container:)
-          sequential_permission_children(t, id, container:)
+          sequential_permission_children(t, id, klass, container:)
         end
       end
 
-      def sequential_permission_body(id, elem, label, klass, model,
+      def sequential_permission_body(id, parent_id, elem, label, klass, model,
 container: false)
+        lbl = parent_id ? "#{parent_id}#{subreqt_separator}#{id}" : id
         @anchors[elem["id"]] = model.postprocess_anchor_struct(
-          elem, anchor_struct(id, elem,
-                              label, klass, elem["unnumbered"])
+          elem, anchor_struct(lbl, elem,
+                              label, klass, { unnumb: elem["unnumbered"], container: })
         )
+        @anchors[elem["id"]][:semx] = semx(elem, lbl)
+        if parent_id
+          x = "#{subreqt_separator(markup: true)}#{semx(elem, id)}"
+          @anchors[elem["id"]][:semx] = @anchors[elem.parent["id"]][:semx] + x
+          @anchors[elem["id"]][:label] =
+            "<span class='fmt-element-name'>#{label}</span> #{@anchors[elem["id"]][:semx]}"
+          @anchors[elem["id"]][:xref] =  "<span class='fmt-element-name'>#{label}</span> #{@anchors[elem["id"]][:semx]}"
+        end
         model.permission_parts(elem, id, label, klass).each do |n|
           @anchors[n[:id]] = anchor_struct(n[:number], n[:elem], n[:label],
-                                           n[:klass], false)
+                                           n[:klass], { unnumb: false, container: })
         end
       end
 
@@ -156,44 +216,61 @@ container: false)
         sequential_permission_names(clause, container:)
       end
 
-      def hierarchical_figure_names(clause, num)
+      def nodeSet(clauses)
+        case clauses
+        when Nokogiri::XML::Node
+          [clauses]
+        when Nokogiri::XML::NodeSet
+          clauses
+        end
+      end
+
+      # these can take a NodeSet as argument; semx will point to members of the NodeSet,
+      # but numbering will be consecutive
+      def hierarchical_figure_names(clauses, num)
         c = Counter.new
         j = 0
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(self.class::FIGURE_NO_CLASS)).noblank.each do |t|
           # labelled_ancestor(t, %w(figure)) and next
           j = subfigure_increment(j, c, t)
-          hierarchical_figure_body(num, j, c, t, "figure")
+          sublabel = subfigure_label(j)
+          # hierarchical_figure_body(num, j, c, t, "figure")
+          #figure_anchor(t, sublabel, "#{num}#{hier_separator}#{c.print}", "figure")
+          #require "debug"; binding.b
+          figure_anchor(t, sublabel, hiersemx(clause, num, c, t), "figure")
         end
         hierarchical_figure_class_names(clause, num)
+        end
       end
 
-      def hierarchical_figure_class_names(clause, num)
+      def hierarchical_figure_class_names(clauses, num)
         c = {}
         j = 0
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(".//figure[@class][not(@class = 'pseudocode')]"))
           .noblank.each do |t|
           # labelled_ancestor(t, %w(figure)) and next
           c[t["class"]] ||= Counter.new
           j = subfigure_increment(j, c[t["class"]], t)
-          hierarchical_figure_body(num, j, c[t["class"]], t, t["class"])
+          sublabel = subfigure_label(j)
+          # hierarchical_figure_body(num, j, c[t["class"]], t, t["class"])
+          #figure_anchor(t, sublabel, "#{num}#{hier_separator}#{c[t['class']].print}", t["class"])
+          figure_anchor(t, sublabel, hiersemx(clause, num, c[t["class"]], t), t["class"])
+        end
         end
       end
 
-      def hierarchical_figure_body(num, subfignum, counter, block, klass)
-        label = "#{num}#{hiersep}#{counter.print}" +
-          subfigure_label(subfignum)
-        @anchors[block["id"]] =
-          anchor_struct(label, nil, @labels[klass] || klass.capitalize,
-                        klass, block["unnumbered"])
-      end
-
-      def hierarchical_table_names(clause, num)
+      def hierarchical_table_names(clauses, num)
         c = Counter.new
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(".//table")).noblank.each do |t|
           # labelled_ancestor(t) and next
           @anchors[t["id"]] =
-            anchor_struct("#{num}#{hiersep}#{c.increment(t).print}",
-                          nil, @labels["table"], "table", t["unnumbered"])
+            #anchor_struct("#{num}#{hier_separator}#{c.increment(t).print}",
+            anchor_struct(hiersemx(clause, num, c.increment(t), t),
+                          t, @labels["table"], "table", { unnumb: t["unnumbered"], container: false })
+        end
         end
       end
 
@@ -204,47 +281,59 @@ container: false)
         hierarchical_permission_names(clause, num)
       end
 
-      def hierarchical_formula_names(clause, num)
+      def hierarchical_formula_names(clauses, num)
         c = Counter.new
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(".//formula")).noblank.each do |t|
           @anchors[t["id"]] = anchor_struct(
-            "#{num}#{hiersep}#{c.increment(t).print}", nil,
+            #"#{num}#{hier_separator}#{c.increment(t).print}", t,
+                     hiersemx(clause, num, c.increment(t), t), t,
             t["inequality"] ? @labels["inequality"] : @labels["formula"],
-            "formula", t["unnumbered"]
+            "formula", { unnumb: t["unnumbered"], container: false }
           )
         end
+        end
       end
 
-      def hierarchical_permission_names(clause, num)
+      def hierarchical_permission_names(clauses, num)
         c = ReqCounter.new
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(FIRST_LVL_REQ)).noblank.each do |t|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_label(t, m)
-          id = "#{num}#{hiersep}#{c.increment(label, t).print}"
-          hierarchical_permission_body(id, t, label, klass, m)
-          hierarchical_permission_children(t, id)
+          #id = "#{num}#{hier_separator}#{c.increment(label, t).print}"
+          id = hiersemx(clause, num, c.increment(label, t), t)
+          sequential_permission_body(id, nil, t, label, klass, m, container: false)
+          sequential_permission_children(t, id, klass, container: false)
         end
+       end
       end
 
+      # TODO remove
       def hierarchical_permission_children(block, lbl)
         c = ReqCounter.new
         block.xpath(ns(REQ_CHILDREN)).noblank.each do |t|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_nested_label(t, m)
-          id = "#{lbl}#{hierfigsep}#{c.increment(label, t).print}"
-          hierarchical_permission_body(id, t, label, klass, m)
+          id = "#{lbl}#{subreqt_separator}#{c.increment(label, t).print}"
+          sequential_permission_body(c.print, lbl, t, label, klass, m)
           hierarchical_permission_children(t, id)
         end
       end
 
-      def hierarchical_permission_body(id, block, label, klass, model)
-        @anchors[block["id"]] = model.postprocess_anchor_struct(
-          block, anchor_struct(id, nil,
-                               label, klass, block["unnumbered"])
+      # TODO remove
+      def hierarchical_permission_body(id, parent_id, elem, label, klass, model)
+        @anchors[elem["id"]] = model.postprocess_anchor_struct(
+          elem, anchor_struct(id, elem,
+                              label, klass, { unnumb: elem["unnumbered"], container: false })
         )
-        model.permission_parts(block, id, label, klass).each do |n|
-          @anchors[n[:id]] = anchor_struct(n[:number], nil, n[:label],
-                                           n[:klass], false)
+        x = "#{subreqt_separator(markup: true)}#{semx(elem, id)}"
+        @anchors[elem["id"]][:label] = "#{semx(elem.parent, parent_id)}#{x}"
+        @anchors[elem["id"]][:xref] = @anchors[elem.parent["id"]][:xref] + x
+        model.permission_parts(elem, id, label, klass).each do |n|
+          # we don't have an n["id"], so we allow n[:id] in anchor_struct
+          @anchors[n[:id]] = anchor_struct(n[:number], n, n[:label],
+                                           n[:klass], { unnumb: false, container: false })
         end
       end
     end