isodoc 2.10.0 → 3.0.0

data/lib/isodoc/xref/xref_gen.rb

@@ -28,15 +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)
-        return "" if elems.size == 1 && !node["number"]
-
+        elems.size == 1 && !node["number"] and return ""
         counter.increment(node) if increment
-        " #{counter.print}"
+        counter.print
       end
 
       def termnote_anchor_names(docxml)
@@ -45,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: l10n("#{@labels['note_xref']} #{c.print}") }
+                xref: anchor_struct_xref(c.print, n, @labels["note_xref"]) }
           end
         end
       end
@@ -64,7 +67,7 @@ module IsoDoc
               { label: idx, type: "termexample",
                 value: idx, elem: @labels["example_xref"],
                 container: t["id"],
-                xref: l10n("#{@labels['example_xref']} #{idx}") }
+                xref: anchor_struct_xref(idx, n, @labels["example_xref"]) }
           end
         end
       end
@@ -74,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
 
@@ -82,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
 
@@ -91,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
 
@@ -99,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
 
@@ -107,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
 
@@ -115,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
 
@@ -123,47 +129,59 @@ 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 = Counter.new
+          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 = Counter.new(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: list_anchor, prev_label: 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: 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)
+            list_item_anchor_names(ol, list_anchor, depth + 1, label,
+                                   refer_list)
           end
         end
       end
 
       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 = l10n("#{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) }
@@ -227,7 +251,7 @@ module IsoDoc
       def bookmark_anchor_names(xml)
         xml.xpath(ns(".//bookmark")).noblank.each do |n|
           _parent, id = id_ancestor(n)
-          #container = bookmark_container(parent)
+          # container = bookmark_container(parent)
           @anchors[n["id"]] = { type: "bookmark", label: nil, value: nil,
                                 xref: @anchors.dig(id, :xref) || "???",
                                 container: @anchors.dig(id, :container) }

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
@@ -27,11 +31,13 @@ module IsoDoc
       def sequential_figure_names(clause, container: false)
         c = Counter.new
         j = 0
-        clause.xpath(ns(FIGURE_NO_CLASS)).noblank.each do |t|
+        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: container)
+          sublabel = subfigure_label(j)
+          figure_anchor(t, sublabel, c.print, "figure", container: container)
         end
-        sequential_figure_class_names(clause, container: container)
+        sequential_figure_class_names(clause, container:)
       end
 
       def sequential_figure_class_names(clause, container: false)
@@ -40,34 +46,81 @@ module IsoDoc
         clause.xpath(ns(".//figure[@class][not(@class = 'pseudocode')]"))
           .each do |t|
           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: 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 ""
-        "-#{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 && sublabel or return
+        "#{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)
         c = Counter.new
         clause.xpath(ns(".//table")).noblank.each do |t|
-          labelled_ancestor(t) and next
+          # 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
@@ -78,7 +131,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
@@ -93,42 +146,54 @@ 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,
-                                     container: container)
-          sequential_permission_children(t, id, container: container)
+          sequential_permission_body(id, nil, t, label, klass, m,
+                                     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,
-                                     container: container)
-          sequential_permission_children(t, id, container: container)
+          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, klass, container:)
         end
       end
 
-      def sequential_permission_body(id, elem, label, klass, model, container: false)
+      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
 
       def reqt2class_label(elem, model)
+        elem["class"] and return [elem["class"], elem["class"]]
         model.req_class_paths.each do |n|
           v1 = ns("/#{n[:xpath]}").sub(%r{^/}, "")
           elem.at("./self::#{v1}") and return [n[:klass], n[:label]]
@@ -146,49 +211,67 @@ module IsoDoc
 
       # container makes numbering be prefixed with the parent clause reference
       def sequential_asset_names(clause, container: false)
-        sequential_table_names(clause, container: container)
-        sequential_figure_names(clause, container: container)
-        sequential_formula_names(clause, container: container)
-        sequential_permission_names(clause, container: container)
+        sequential_table_names(clause, container:)
+        sequential_figure_names(clause, container:)
+        sequential_formula_names(clause, container:)
+        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
-        clause.xpath(ns(FIGURE_NO_CLASS)).noblank.each do |t|
-          # next if labelled_ancestor(t) && t.ancestors("figure").empty?
+        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
+          # 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
 
@@ -199,48 +282,32 @@ module IsoDoc
         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)
-        end
-      end
-
-      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)
-          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"])
-        )
-        model.permission_parts(block, id, label, klass).each do |n|
-          @anchors[n[:id]] = anchor_struct(n[:number], nil, n[:label],
-                                           n[:klass], false)
+          #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
     end
   end