isodoc 3.2.7 → 3.3.1

data/lib/isodoc/presentation_function/erefs.rb

@@ -1,4 +1,5 @@
 require "metanorma-utils"
+require_relative "erefs_locality"
 
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
@@ -15,6 +16,7 @@ module IsoDoc
     end
 
     def citeas_cleanup(ref)
+      ref.nil? and return nil
       if ref.include?("<")
         xml = Nokogiri::XML("<root>#{ref}</root>")
         xml.xpath("//semx").each { |x| x.replace(x.children) }
@@ -33,39 +35,11 @@ module IsoDoc
         [e["connective"], to_xml(e.parent.remove)]
       end.flatten
       ret = resolve_eref_connectives(locs)
-      elem.next = "<semx element='erefstack' source='#{elem['id']}'>#{ret[1]}</semx>"
-    end
-
-    def eref_localities(refs, target, node)
-      if can_conflate_eref_rendering?(refs)
-        l10n(", #{eref_localities_conflated(refs, target, node)}"
-          .gsub(/\s+/, " "))
-      else
-        ret = resolve_eref_connectives(eref_locality_stacks(refs, target, node))
-        l10n(ret.join.gsub(/\s+/, " "))
-      end
-    end
-
-    def eref_localities_conflated(refs, target, node)
-      droploc = node["droploc"]
-      node["droploc"] = true
-      ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
-                                                          node))
-      node.delete("droploc") unless droploc
-      eref_localities1({ target:, number: "pl",
-                         type: refs.first.at(ns("./locality/@type")).text,
-                         from: l10n(ret[1..].join), node:, lang: @lang })
-    end
-
-    def can_conflate_eref_rendering?(refs)
-      (refs.size > 1 &&
-        refs.all? { |r| r.name == "localityStack" } &&
-        refs.all? { |r| r.xpath(ns("./locality")).size == 1 }) or return false
-      first = refs.first.at(ns("./locality/@type")).text
-      refs.all? { |r| r.at(ns("./locality/@type")).text == first }
+      elem.next = "<semx element='erefstack' source='#{elem['id']}'>#{l10n ret[1]}</semx>"
     end
 
     def resolve_eref_connectives(locs)
+      locs = escape_l10n(locs)
       locs = resolve_comma_connectives(locs)
       locs = resolve_to_connectives(locs)
       locs.size < 3 and return locs
@@ -75,6 +49,18 @@ module IsoDoc
       [", ", combine_conn(locs)]
     end
 
+    XREF_CONNECTIVES = %w(from to or and).freeze
+
+    def escape_l10n(locs)
+      locs.map do |x|
+        if XREF_CONNECTIVES.include?(x) || [", ", " ", ""].include?(x)
+          x
+        else
+          "<esc>#{x}</esc>"
+        end
+      end
+    end
+
     def resolve_comma_connectives(locs)
       locs1 = []
       add = ""
@@ -110,88 +96,6 @@ module IsoDoc
       locs1
     end
 
-    def eref_locality_stacks(refs, target, node)
-      ret = refs.each_with_index.with_object([]) do |(r, i), m|
-        added = eref_locality_stack(r, i, target, node)
-        added.empty? and next
-        added.each { |a| m << a }
-        i == refs.size - 1 and next
-        m << eref_locality_delimiter(r)
-      end
-      ret.empty? ? ret : [", "] + ret
-    end
-
-    def eref_locality_delimiter(ref)
-      if ref&.next_element&.name == "localityStack"
-        ref.next_element["connective"]
-      else locality_delimiter(ref)
-      end
-    end
-
-    def eref_locality_stack(ref, idx, target, node)
-      ret = []
-      if ref.name == "localityStack"
-        ret = eref_locality_stack1(ref, target, node, ret)
-      else
-        l = eref_localities0(ref, idx, target, node) and ret << l
-      end
-      ret[-1] == ", " and ret.pop
-      ret
-    end
-
-    def eref_locality_stack1(ref, target, node, ret)
-      ref.elements.each_with_index do |rr, j|
-        l = eref_localities0(rr, j, target, node) or next
-        ret << l
-        ret << locality_delimiter(rr) unless j == ref.elements.size - 1
-      end
-      ret
-    end
-
-    def locality_delimiter(_loc)
-      ", "
-    end
-
-    def eref_localities0(ref, _idx, target, node)
-      if ref["type"] == "whole" then @i18n.wholeoftext
-      else
-        eref_localities1({ target:, type: ref["type"], number: "sg",
-                           from: ref.at(ns("./referenceFrom"))&.text,
-                           upto: ref.at(ns("./referenceTo"))&.text, node:,
-                           lang: @lang })
-      end
-    end
-
-    def eref_localities1_zh(opt)
-      ret = "第#{opt[:from]}" if opt[:from]
-      ret += "&#x2013;#{opt[:upto]}" if opt[:upto]
-      loc = eref_locality_populate(opt[:type], opt[:node], "sg")
-      ret += " #{loc}" unless opt[:node]["droploc"] == "true"
-      ret
-    end
-
-    def eref_localities1(opt)
-      opt[:type] == "anchor" and return nil
-      opt[:lang] == "zh" and
-        return l10n(eref_localities1_zh(opt))
-      ret = eref_locality_populate(opt[:type], opt[:node], opt[:number])
-      ret += " #{opt[:from]}" if opt[:from]
-      ret += "&#x2013;#{opt[:upto]}" if opt[:upto]
-      l10n(ret)
-    end
-
-    def eref_locality_populate(type, node, number)
-      node["droploc"] == "true" and return ""
-      loc = type.sub(/^locality:/, "")
-      ret = @i18n.locality[loc] || loc
-      number == "pl" and ret = @i18n.inflect(ret, number: "pl")
-      ret = case node["case"]
-            when "lowercase" then ret.downcase
-            else Metanorma::Utils.strict_capitalize_first(ret)
-            end
-      " #{ret}"
-    end
-
     def eref2link(docxml)
       docxml.xpath(ns("//display-text")).each { |f| f.replace(f.children) }
       docxml.xpath(ns("//fmt-eref | //fmt-origin[not(.//termref)]"))
@@ -216,7 +120,7 @@ module IsoDoc
     def eref2link1(node, href)
       url = href[:link]
       att = href[:type] == :attachment ? "attachment='true'" : ""
-      repl = "<fmt-link #{att} target='#{url}'>#{node.children}</link>"
+      repl = "<fmt-link #{att} target='#{url}'>#{to_xml(node.children)}</link>"
       node["type"] == "footnote" and repl = "<sup>#{repl}</sup>"
       node.replace(repl)
     end

data/lib/isodoc/presentation_function/erefs_locality.rb

@@ -0,0 +1,113 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def eref_localities(refs, target, node)
+      if can_conflate_eref_rendering?(refs)
+        l10n(", <esc>#{eref_localities_conflated(refs, target, node)}</esc>"
+          .gsub(/\s+/, " "), @lang, @script, { prev: target })
+      else
+        ret = resolve_eref_connectives(eref_locality_stacks(refs, target, node))
+        l10n(ret.join.gsub(/\s+/, " "), @lang, @script, { prev: target })
+      end
+    end
+
+    def eref_localities_conflated(refs, target, node)
+      droploc = node["droploc"]
+      node["droploc"] = true
+      ret = resolve_eref_connectives(eref_locality_stacks(refs, target, node))
+      node.delete("droploc") unless droploc
+      eref_localities1({ target:, number: "pl",
+                         type: refs.first.at(ns("./locality/@type")).text,
+                         from: l10n(ret[1..].join), node:, lang: @lang })
+    end
+
+    def can_conflate_eref_rendering?(refs)
+      (refs.size > 1 &&
+        refs.all? { |r| r.name == "localityStack" } &&
+        refs.all? { |r| r.xpath(ns("./locality")).size == 1 }) or return false
+      first = refs.first.at(ns("./locality/@type")).text
+      refs.all? { |r| r.at(ns("./locality/@type")).text == first }
+    end
+
+    def eref_locality_stacks(refs, target, node)
+      ret = refs.each_with_index.with_object([]) do |(r, i), m|
+        added = eref_locality_stack(r, i, target, node)
+        added.empty? and next
+        added.each { |a| m << a }
+        i == refs.size - 1 and next
+        m << eref_locality_delimiter(r)
+      end
+      ret.empty? ? ret : [", "] + ret
+    end
+
+    def eref_locality_delimiter(ref)
+      if ref&.next_element&.name == "localityStack"
+        ref.next_element["connective"]
+      else locality_delimiter(ref)
+      end
+    end
+
+    def eref_locality_stack(ref, idx, target, node)
+      ret = []
+      if ref.name == "localityStack"
+        ret = eref_locality_stack1(ref, target, node, ret)
+      else
+        l = eref_localities0(ref, idx, target, node) and ret << l
+      end
+      ret[-1] == ", " and ret.pop
+      ret
+    end
+
+    def eref_locality_stack1(ref, target, node, ret)
+      ref.elements.each_with_index do |rr, j|
+        l = eref_localities0(rr, j, target, node) or next
+        ret << l
+        ret << locality_delimiter(rr) unless j == ref.elements.size - 1
+      end
+      ret
+    end
+
+    def locality_delimiter(_loc)
+      ", "
+    end
+
+    def eref_localities0(ref, _idx, target, node)
+      if ref["type"] == "whole" then @i18n.wholeoftext
+      else
+        eref_localities1({ target:, type: ref["type"], number: "sg",
+                           from: ref.at(ns("./referenceFrom"))&.text,
+                           upto: ref.at(ns("./referenceTo"))&.text, node:,
+                           lang: @lang })
+      end
+    end
+
+    def eref_localities1_zh(opt)
+      ret = "第<esc>#{opt[:from]}</esc>" if opt[:from]
+      ret += "&#x2013;<esc>#{opt[:upto]}</esc>" if opt[:upto]
+      loc = eref_locality_populate(opt[:type], opt[:node], "sg")
+      ret += " #{loc}" unless opt[:node]["droploc"] == "true"
+      ret
+    end
+
+    def eref_localities1(opt)
+      opt[:type] == "anchor" and return nil
+      %(zh ja ko).include?(opt[:lang]) and
+        return l10n(eref_localities1_zh(opt))
+      ret = eref_locality_populate(opt[:type], opt[:node], opt[:number])
+      ret += " #{opt[:from]}" if opt[:from]
+      ret += "&#x2013;#{opt[:upto]}" if opt[:upto]
+      l10n(ret)
+    end
+
+    def eref_locality_populate(type, node, number)
+      node["droploc"] == "true" and return ""
+      loc = type.sub(/^locality:/, "")
+      ret = @i18n.locality[loc] || loc
+      number == "pl" and ret = @i18n.inflect(ret, number: "pl")
+      ret = case node["case"]
+            when "lowercase" then ret.downcase
+            else Metanorma::Utils.strict_capitalize_first(ret)
+            end
+      " #{ret}"
+    end
+  end
+end

data/lib/isodoc/presentation_function/image.rb

@@ -70,7 +70,7 @@ module IsoDoc
       lbl = @xrefs.anchor(elem["id"], :label, false)
       lbl and a = autonum(elem["id"], lbl)
       figname = figure_name(elem)
-      (elem.parent.name == "figure") && a and
+      elem.at("./ancestor::xmlns:figure") && a and
         a += subfigure_delim
       lbl && figure_label?(elem) and s = "#{figname}#{a}"
       prefix_name(elem, { caption: figure_delim(elem) }, l10n(s&.strip), "name")

data/lib/isodoc/presentation_function/list.rb

@@ -20,11 +20,24 @@ module IsoDoc
     end
 
     def ol(docxml)
+      ol_prep(docxml)
       docxml.xpath(ns("//ol")).each { |f| ol1(f) }
-      @xrefs.list_anchor_names(docxml.xpath(ns(@xrefs.sections_xpath)))
       docxml.xpath(ns("//ol/li")).each { |f| ol_label(f) }
     end
 
+    def ol_numbering(docxml)
+      docxml.xpath(ns("//ol")).each do |elem|
+        elem["type"] ||= ol_depth(elem).to_s # feeds ol_label_format
+      end
+    end
+
+    def ol_prep(docxml)
+      ol_numbering(docxml)
+      @xrefs.list_anchor_names(docxml.xpath(ns(@xrefs.sections_xpath)))
+      @xrefs.localise_anchors("list")
+      @xrefs.localise_anchors("listitem")
+    end
+
     def ol_depth(node)
       depth = node.ancestors("ul, ol").size + 1
       @counter.ol_type(node, depth) # defined in Xref::Counter

data/lib/isodoc/presentation_function/refs.rb

@@ -184,6 +184,7 @@ module IsoDoc
       ret += datefn
       ret.empty? and return ret
       idents[:sdo] and ret += ","
+      ret.sub(",", "").strip.empty? and return ""
       "#{ret} "
     end
 
@@ -192,7 +193,7 @@ module IsoDoc
     def biblio_ref_entry_code(ordinal, ids, _id, _standard, datefn, _bib)
       # standard and id = nil
       ret = ids[:ordinal] || ids[:metanorma] || "[#{ordinal}]"
-      if ids[:sdo]
+      if ids[:sdo] && !ids[:sdo].empty?
         ret = prefix_bracketed_ref(ret)
         ret += "#{ids[:sdo]}#{datefn}, "
       else

data/lib/isodoc/presentation_function/reqt.rb

@@ -24,7 +24,7 @@ module IsoDoc
     def recommendation1(elem, type)
       lbl = @reqt_models.model(elem["model"])
         .recommendation_label(elem, type, xrefs)
-      prefix_name(elem, {}, l10n(lbl), "name")
+      prefix_name(elem, {}, lbl, "name")
     end
 
     def requirement_render_preprocessing(docxml); end

data/lib/isodoc/presentation_function/terms.rb

@@ -37,13 +37,14 @@ module IsoDoc
       docxml.xpath(ns("//termnote")).each { |f| termnote1(f) }
     end
 
-    def termnote_delim(_elem)
-      l10n(": ")
+    def termnote_delim(_elem, lbl)
+      l10n(": ", { prev: lbl })
     end
 
     def termnote1(elem)
       lbl = termnote_label(elem)
-      prefix_name(elem, { label: termnote_delim(elem) }, lower2cap(lbl), "name")
+      prefix_name(elem, { label: termnote_delim(elem, lbl) },
+                  lower2cap(lbl), "name")
     end
 
     def termnote_label(elem)
@@ -147,23 +148,33 @@ module IsoDoc
       m1.replace("<modification>#{to_xml(new_m1)}</modification>")
     end
 
+    # concatenate sources. localise the concatenation, escaping the concatenands
+    # from punctuation localisation: l10n(<esc>A</esc>, <esc>B</esc>)
+    # pass the result to termsource_label, where it will be appended after
+    # "SOURCE: ", and therefore again needs to be escaped
     def termsource1(elem)
       ret = [semx_fmt_dup(elem)]
-      while elem&.next_element&.name == "source"
+      while elem.next_element&.name == "source"
         ret << semx_fmt_dup(elem.next_element.remove)
       end
-      s = ret.map { |x| to_xml(x) }.map(&:strip).join("; ")
-      termsource_label(elem, s)
+      s = ret.map { |x| to_xml(x) }.map(&:strip).map { |x| "<esc>#{x}</esc>" }
+        .join(termsource_join_delim(elem))
+      termsource_label(elem, "<esc>#{@i18n.l10n s}</esc>")
+    end
+
+    def termsource_join_delim(_elem)
+      "; "
     end
 
     def termsource_label(elem, sources)
-      elem.replace(l10n("[#{@i18n.source}: #{sources}]"))
+      elem.replace(l10n("[#{@i18n.source}: <esc>#{sources}</esc>]"))
     end
 
     def termsource_modification(elem)
       elem.xpath(".//text()[normalize-space() = '']").each(&:remove)
       origin = elem.at(ns("./origin"))
-      s = termsource_status(elem["status"]) and origin.next = l10n(", #{s}")
+      s = termsource_status(elem["status"]) and
+        origin.next = l10n(", #{s}", @lang, @script, { prev: origin.text })
       mod = elem.at(ns("./modification")) or return
       termsource_add_modification_text(mod)
     end

data/lib/isodoc/presentation_function/xrefs.rb

@@ -21,8 +21,8 @@ module IsoDoc
                          anchor_xref(node, container, container: true),
                          node, target)
       l10n(connectives_spans(@i18n.nested_xref
-        .sub("%1", "<span class='fmt-xref-container'>#{container_label}</span>")
-        .sub("%2", linkend)))
+        .sub("%1", "<span class='fmt-xref-container'><esc>#{container_label}</esc></span>")
+        .sub("%2", "<esc>#{linkend}</esc>")))
     end
 
     def anchor_value(id)
@@ -70,7 +70,7 @@ module IsoDoc
     def anchor_xref_short(node, target, container)
       if (l = node["label"]) && !container
         v = anchor_value(target)
-        @i18n.l10n(%[<span class="fmt-element-name">#{l}</span> #{v}])
+        @i18n.l10n(%[<span class="fmt-element-name">#{l}</span> <esc>#{v}</esc>])
       else @xrefs.anchor(target, :xref)
       end
     end
@@ -93,7 +93,9 @@ module IsoDoc
       linkend = if can_conflate_xref_rendering?(locs)
                   combine_conflated_xref_locations(locs)
                 else
-                  out = locs.each { |l| l[:label] = anchor_linkend1(l[:node]) }
+                  out = locs.each do |l|
+                    l[:label] = "<esc>#{anchor_linkend1(l[:node])}</esc>"
+                  end
                   l10n(combine_conn(out))
                 end
       capitalise_xref(node, linkend, anchor_value(node["target"]))
@@ -114,7 +116,7 @@ module IsoDoc
     def conflate_xref_locations(locs)
       out = locs.each { |l| l[:label] = anchor_value(l[:target]) }
       label = @i18n.inflect(locs.first[:elem], number: "pl")
-      out[0][:label] = l10n("#{label} #{out[0][:label]}").strip
+      out[0][:label] = l10n("#{label} <esc>#{out[0][:label]}</esc>").strip
       out
     end
 
@@ -139,7 +141,9 @@ module IsoDoc
 
     def loc2xref(entry)
       if entry[:target]
-        "<fmt-xref nested='true' target='#{entry[:target]}'>#{entry[:label]}</fmt-xref>"
+        <<~XML
+          <fmt-xref nested='true' target='#{entry[:target]}'>#{entry[:label]}</fmt-xref>
+        XML
       else
         entry[:label]
       end

data/lib/isodoc/presentation_xml_convert.rb

@@ -2,6 +2,7 @@ require_relative "presentation_function/block"
 require_relative "presentation_function/list"
 require_relative "presentation_function/reqt"
 require_relative "presentation_function/concepts"
+require_relative "presentation_function/designations"
 require_relative "presentation_function/terms"
 require_relative "presentation_function/xrefs"
 require_relative "presentation_function/erefs"

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "3.2.7".freeze
+  VERSION = "3.3.1".freeze
 end

data/lib/isodoc/xref/xref_anchor.rb

@@ -46,8 +46,7 @@ module IsoDoc
           lbl = semx(node, lbl)
           s = " #{anchor_struct_value(lbl, elem)}"
         end
-        l10n("<span class='fmt-element-name'>#{elem}</span>#{s}")
-          .gsub(/ $/, "")
+        "<span class='fmt-element-name'>#{elem}</span>#{s}".gsub(/ $/, "")
       end
 
       def anchor_struct_value(lbl, elem)

data/lib/isodoc/xref/xref_gen.rb

@@ -147,7 +147,6 @@ refer_list)
             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:,

data/lib/isodoc/xref/xref_gen_seq.rb

@@ -5,7 +5,7 @@ module IsoDoc
   module XrefGen
     module Blocks
       def subfigure_increment(idx, counter, elem)
-        if elem.parent.name == "figure" then idx += 1
+        if elem.ancestors.map(&:name).include?("figure") then idx += 1
         else
           idx = 0
           counter.increment(elem)
@@ -18,9 +18,9 @@ module IsoDoc
       XPATH
 
       def sequential_figure_names(clause, container: false)
-        c = Counter.new
         j = 0
-        clause.xpath(ns(self.class::FIGURE_NO_CLASS)).noblank.each do |t|
+        clause.xpath(ns(self.class::FIGURE_NO_CLASS)).noblank
+          .each_with_object(Counter.new) do |t, c|
           # labelled_ancestor(t, %w(figure)) and next # disable nested figure labelling
           j = subfigure_increment(j, c, t)
           sublabel = subfigure_label(j)
@@ -34,7 +34,6 @@ module IsoDoc
         clause.xpath(ns(".//figure[@class][not(@class = 'pseudocode')]"))
           .each_with_object({}) do |t, c|
           c[t["class"]] ||= Counter.new
-          # labelled_ancestor(t, %w(figure)) and next
           j = subfigure_increment(j, c[t["class"]], t)
           sublabel = subfigure_label(j)
           figure_anchor(t, sublabel, c[t["class"]].print, t["class"],
@@ -71,19 +70,19 @@ module IsoDoc
           { unnumb: elem["unnumbered"] }
         )
         if elem["unnumbered"] != "true"
+          p = elem.at("./ancestor::xmlns:figure")
           x = "#{subfigure_separator(markup: true)}#{semx(elem, sublabel)}"
           @anchors[elem["id"]][:label] = "#{label}#{x}"
-          @anchors[elem["id"]][:xref] = @anchors[elem.parent["id"]][:xref] + x +
+          @anchors[elem["id"]][:xref] = @anchors[p["id"]][:xref] + x +
             delim_wrap(subfigure_delim)
-          x = @anchors[elem.parent["id"]][:container] and
+          x = @anchors[p["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
+        clause.xpath(ns(".//table")).noblank
+          .each_with_object(Counter.new) do |t, c|
           @anchors[t["id"]] = anchor_struct(
             c.increment(t).print, t, @labels["table"], "table",
             { unnumb: t["unnumbered"], container: container }
@@ -92,8 +91,8 @@ module IsoDoc
       end
 
       def sequential_formula_names(clause, container: false)
-        c = Counter.new
-        clause.xpath(ns(".//formula")).noblank.each do |t|
+        clause.xpath(ns(".//formula")).noblank
+          .each_with_object(Counter.new) do |t, c|
           @anchors[t["id"]] = anchor_struct(
             c.increment(t).print, t,
             t["inequality"] ? @labels["inequality"] : @labels["formula"],
@@ -104,8 +103,8 @@ module IsoDoc
       end
 
       def sequential_permission_names(clause, container: true)
-        c = ReqCounter.new
-        clause.xpath(ns(first_lvl_req)).noblank.each do |t|
+        clause.xpath(ns(first_lvl_req)).noblank
+          .each_with_object(ReqCounter.new) do |t, c|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_label(t, m)
           id = c.increment(label, t).print
@@ -115,9 +114,14 @@ module IsoDoc
         end
       end
 
+      def delim_wrap(delim, klass = "fmt-autonum-delim")
+        delim.blank? and return ""
+        "<span class='#{klass}'><esc>#{delim}</esc></span>"
+      end
+
       def sequential_permission_children(elem, lbl, klass, container: false)
-        c = ReqCounter.new
-        elem.xpath(ns(req_children)).noblank.each do |t|
+        elem.xpath(ns(req_children)).noblank
+          .each_with_object(ReqCounter.new) do |t, c|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_nested_label(t, m)
           ctr = c.increment(label, t).print
@@ -131,7 +135,7 @@ module IsoDoc
       def sequential_permission_body(id, parent_id, elem, label, klass, model,
 container: false)
         lbl = parent_id ? "#{parent_id}#{subreqt_separator}#{id}" : id
-        e = elem["id"]
+        e = elem["id"] || elem["original-id"]
         @anchors[e] = model.postprocess_anchor_struct(
           elem, anchor_struct(lbl, elem,
                               label, klass, { unnumb: elem["unnumbered"], container: })
@@ -142,8 +146,7 @@ container: false)
           @anchors[e][:semx] = @anchors[elem.parent["id"]][:semx] + x
           @anchors[e][:label] =
             "<span class='fmt-element-name'>#{label}</span> #{@anchors[e][:semx]}"
-          @anchors[e][:xref] =
-            "<span class='fmt-element-name'>#{label}</span> #{@anchors[e][:semx]}"
+          @anchors[e][:xref] = @anchors[e][:label]
         end
         model.permission_parts(elem, id, label, klass).each do |n|
           @anchors[n[:id]] = anchor_struct(n[:number], n[:elem], n[:label],
@@ -168,12 +171,11 @@ container: false)
         [nil, nil]
       end
 
-      # these can take a NodeSet as argument; semx will point to members of the NodeSet,
-      # but numbering will be consecutive
+      # 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|
+        nodeSet(clauses).each_with_object(Counter.new) do |clause, c|
           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)
@@ -189,7 +191,6 @@ container: false)
         nodeSet(clauses).each_with_object({}) do |clause, c|
           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)
             sublabel = subfigure_label(j)
@@ -200,10 +201,8 @@ container: false)
       end
 
       def hierarchical_table_names(clauses, num)
-        c = Counter.new
-        nodeSet(clauses).each do |clause|
+        nodeSet(clauses).each_with_object(Counter.new) do |clause, c|
           clause.xpath(ns(".//table")).noblank.each do |t|
-            # labelled_ancestor(t) and next
             @anchors[t["id"]] =
               anchor_struct(hiersemx(clause, num, c.increment(t), t),
                             t, @labels["table"], "table",
@@ -213,8 +212,7 @@ container: false)
       end
 
       def hierarchical_formula_names(clauses, num)
-        c = Counter.new
-        nodeSet(clauses).each do |clause|
+        nodeSet(clauses).each_with_object(Counter.new) do |clause, c|
           clause.xpath(ns(".//formula")).noblank.each do |t|
             @anchors[t["id"]] = anchor_struct(
               hiersemx(clause, num, c.increment(t), t), t,
@@ -227,8 +225,7 @@ container: false)
       end
 
       def hierarchical_permission_names(clauses, num)
-        c = ReqCounter.new
-        nodeSet(clauses).each do |clause|
+        nodeSet(clauses).each_with_object(ReqCounter.new) do |clause, c|
           clause.xpath(ns(first_lvl_req)).noblank.each do |t|
             m = @reqt_models.model(t["model"])
             klass, label = reqt2class_label(t, m)