metanorma-standoc 1.9.0 → 1.10.0

data/lib/asciidoctor/standoc/cleanup_block.rb

@@ -37,14 +37,15 @@ module Asciidoctor
         end
       end
 
-      def insert_thead(s)
-        thead = s.at("./thead")
+      def insert_thead(table)
+        thead = table.at("./thead")
         return thead unless thead.nil?
-        if tname = s.at("./name")
+
+        if tname = table.at("./name")
           thead = tname.add_next_sibling("<thead/>").first
           return thead
         end
-        s.children.first.add_previous_sibling("<thead/>").first
+        table.children.first.add_previous_sibling("<thead/>").first
       end
 
       def header_rows_cleanup(xmldoc)
@@ -80,21 +81,21 @@ module Asciidoctor
       end
 
       # include where definition list inside stem block
-      def formula_cleanup(x)
-        formula_cleanup_where1(x)
-        formula_cleanup_where2(x)
+      def formula_cleanup(formula)
+        formula_cleanup_where1(formula)
+        formula_cleanup_where2(formula)
       end
 
-      def formula_cleanup_where1(x)
+      def formula_cleanup_where1(formula)
         q = "//formula/following-sibling::*[1][self::dl]"
-        x.xpath(q).each do |s|
+        formula.xpath(q).each do |s|
           s["key"] == "true" and s.previous_element << s.remove
         end
       end
 
-      def formula_cleanup_where2(x)
+      def formula_cleanup_where2(formula)
         q = "//formula/following-sibling::*[1][self::p]"
-        x.xpath(q).each do |s|
+        formula.xpath(q).each do |s|
           if s.text =~ /^\s*where[^a-z]*$/i && s&.next_element&.name == "dl"
             s.next_element["key"] = "true"
             s.previous_element << s.next_element.remove
@@ -125,9 +126,10 @@ module Asciidoctor
       # examples containing only figures become subfigures of figures
       def subfigure_cleanup(xmldoc)
         xmldoc.xpath("//example[figure]").each do |e|
-          next unless e.elements.map { |m| m.name }.reject do |m|
+          next unless e.elements.map(&:name).reject do |m|
             %w(name figure).include? m
           end.empty?
+
           e.name = "figure"
         end
       end
@@ -142,7 +144,7 @@ module Asciidoctor
       ELEMS_ALLOW_NOTES = %w[p formula ul ol dl figure].freeze
 
       # if a note is at the end of a section, it is left alone
-      # if a note is followed by a non-note block, 
+      # if a note is followed by a non-note block,
       # it is moved inside its preceding block if it is not delimited
       # (so there was no way of making that block include the note)
       def note_cleanup(xmldoc)
@@ -150,6 +152,7 @@ module Asciidoctor
         xmldoc.xpath(q).each do |n|
           next if n["keep-separate"] == "true"
           next unless n.ancestors("table").empty?
+
           prev = n.previous_element || next
           n.parent = prev if ELEMS_ALLOW_NOTES.include? prev.name
         end
@@ -159,100 +162,75 @@ module Asciidoctor
         end
       end
 
-      def requirement_cleanup(x)
-        requirement_descriptions(x)
-        requirement_inherit(x)
-      end
-
-      def requirement_inherit(x)
-        x.xpath("//requirement | //recommendation | //permission").each do |r|
-          ins = r.at("./classification") ||
-            r.at("./description | ./measurementtarget | ./specification | "\
-                 "./verification | ./import | ./description | ./requirement | "\
-                 "./recommendation | ./permission")
-          r.xpath("./*//inherit").each { |i| ins.previous = i }
+      def link_callouts_to_annotations(callouts, annotations)
+        callouts.each_with_index do |c, i|
+          c["target"] = "_#{UUIDTools::UUID.random_create}"
+          annotations[i]["id"] = c["target"]
         end
       end
 
-      def requirement_descriptions(x)
-        x.xpath("//requirement | //recommendation | //permission").each do |r|
-          r.children.each do |e|
-            unless e.element? && (reqt_subpart(e.name) ||
-                %w(requirement recommendation permission).include?(e.name))
-              t = Nokogiri::XML::Element.new("description", x)
-              e.before(t)
-              t.children = e.remove
-            end
-          end
-          requirement_cleanup1(r)
+      def align_callouts_to_annotations(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          callouts = x.elements.select { |e| e.name == "callout" }
+          annotations = x.elements.select { |e| e.name == "annotation" }
+          callouts.size == annotations.size and
+            link_callouts_to_annotations(callouts, annotations)
         end
       end
 
-      def requirement_cleanup1(r)
-        while d = r.at("./description[following-sibling::*[1]"\
-            "[self::description]]")
-          n = d.next.remove
-          d << n.children
-        end
-        r.xpath("./description[normalize-space(.)='']").each do |d|
-          d.replace("\n")
+      def merge_annotations_into_sourcecode(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          while x&.next_element&.name == "annotation"
+            x.next_element.parent = x
+          end
         end
       end
 
-      def svgmap_cleanup(xmldoc)
-        svgmap_moveattrs(xmldoc)
-        svgmap_populate(xmldoc)
-        Metanorma::Utils::svgmap_rewrite(xmldoc, @localdir)
+      def callout_cleanup(xmldoc)
+        merge_annotations_into_sourcecode(xmldoc)
+        align_callouts_to_annotations(xmldoc)
       end
 
-      def guid?(x)
-        /^_[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i.
-          match(x)
-      end
+      def sourcecode_cleanup(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          x.traverse do |n|
+            next unless n.text?
+            next unless /#{Regexp.escape(@sourcecode_markup_start)}/
+              .match?(n.text)
 
-      def svgmap_moveattrs(xmldoc)
-        xmldoc.xpath("//svgmap").each do |s|
-          f = s.at(".//figure") or next
-          if t = s.at("./name") and !f.at("./name")
-            f.children.first.previous = t.remove
+            n.replace(sourcecode_markup(n))
           end
-          if s["id"] && guid?(f["id"])
-            f["id"] = s["id"]
-            s.delete("id")
-          end
-          svgmap_moveattrs1(s, f)
         end
       end
 
-      def svgmap_moveattrs1(s, f)
-        %w(unnumbered number subsequence keep-with-next
-          keep-lines-together).each do |a|
-            next if f[a] || !s[a]
-            f[a] = s[a]
-            s.delete(a)
-          end
+      def safe_noko(text, doc)
+        Nokogiri::XML::Text.new(text, doc).to_xml(
+          encoding: "US-ASCII",
+          save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+        )
       end
 
-      def svgmap_populate(xmldoc)
-        xmldoc.xpath("//svgmap").each do |s|
-          s1 = s.dup
-          s.children.remove
-          f = s1.at(".//figure") and s << f
-          s1.xpath(".//li").each do |li|
-            t = li&.at(".//eref | .//link | .//xref") or next
-            href = t.xpath("./following-sibling::node()")
-            href.empty? or
-              s << %[<target href="#{svgmap_target(href)}">#{t.to_xml}</target>]
-          end
+      def sourcecode_markup(node)
+        acc = []
+        node.text.split(/(#{Regexp.escape(@sourcecode_markup_start)}|
+                          #{Regexp.escape(@sourcecode_markup_end)})/x)
+          .each_slice(4).map do |a|
+          acc << safe_noko(a[0], node.document)
+          next unless a.size == 4
+
+          acc << Asciidoctor.convert(
+            a[2], doctype: :inline, backend: (self&.backend&.to_sym || :standoc)
+          )
         end
+        acc.join
       end
 
-      def svgmap_target(nodeset)
-        nodeset.each do |n|
-          next unless n.name == "link"
-          n.children = n["target"]
+      def form_cleanup(xmldoc)
+        xmldoc.xpath("//select").each do |s|
+          while s&.next_element&.name == "option"
+            s << s.next_element
+          end
         end
-        nodeset.text.sub(/^[,; ]/, "").strip
       end
     end
   end

data/lib/asciidoctor/standoc/cleanup_boilerplate.rb

@@ -38,17 +38,23 @@ module Asciidoctor
         end
       end
 
-      def norm_ref_preface(f)
-        refs = f.elements.select do |e|
-          ["reference", "bibitem"].include? e.name
+      def norm_ref_preface(ref)
+        if ref.at("./note[@type = 'boilerplate']")
+          unwrap_boilerplate_clauses(ref, ".")
+        else
+          refs = ref.elements.select do |e|
+            %w(references bibitem).include? e.name
+          end
+          pref = refs.empty? ? @i18n.norm_empty_pref : @i18n.norm_with_refs_pref
+          ref.at("./title").next = "<p>#{pref}</p>"
         end
-        f.at("./title").next =
-          "<p>#{(refs.empty? ? @i18n.norm_empty_pref : @i18n.norm_with_refs_pref)}</p>"
       end
 
-      TERM_CLAUSE = "//sections/terms | //sections/clause[descendant::terms]".freeze
+      TERM_CLAUSE = "//sections/terms | "\
+        "//sections/clause[descendant::terms]".freeze
 
-      NORM_REF = "//bibliography/references[@normative = 'true']".freeze
+      NORM_REF = "//bibliography/references[@normative = 'true'] | "\
+        "//bibliography/clause[.//references[@normative = 'true']]".freeze
 
       def boilerplate_isodoc(xmldoc)
         x = xmldoc.dup
@@ -67,25 +73,32 @@ module Asciidoctor
         xmldoc.xpath("//terms/p | //terms/ul").each(&:remove)
       end
 
-      def termdef_unwrap_boilerplate_clauses(xmldoc)
-        xmldoc.xpath(self.class::TERM_CLAUSE).each do |f|
-          f.xpath(".//clause[@type = 'boilerplate']").each do |c|
+      def unwrap_boilerplate_clauses(xmldoc, xpath)
+        xmldoc.xpath(xpath).each do |f|
+          f.xpath(".//clause[@type = 'boilerplate'] | "\
+                  ".//note[@type = 'boilerplate']").each do |c|
             c&.at("./title")&.remove
             c.replace(c.children)
           end
         end
       end
 
-      def boilerplate_cleanup(xmldoc)
-        isodoc = boilerplate_isodoc(xmldoc)
-        termdef_boilerplate_cleanup(xmldoc)
+      def termdef_boilerplate_insert(xmldoc, isodoc, once = false)
         xmldoc.xpath(self.class::TERM_CLAUSE).each do |f|
           next if f.at("./clause[@type = 'boilerplate']")
 
-          term_defs_boilerplate(f.at("./title"), xmldoc.xpath(".//termdocsource"),
+          term_defs_boilerplate(f.at("./title"),
+                                xmldoc.xpath(".//termdocsource"),
                                 f.at(".//term"), f.at(".//p"), isodoc)
+          break if once
         end
-        termdef_unwrap_boilerplate_clauses(xmldoc)
+      end
+
+      def boilerplate_cleanup(xmldoc)
+        isodoc = boilerplate_isodoc(xmldoc)
+        termdef_boilerplate_cleanup(xmldoc)
+        termdef_boilerplate_insert(xmldoc, isodoc)
+        unwrap_boilerplate_clauses(xmldoc, self.class::TERM_CLAUSE)
         f = xmldoc.at(self.class::NORM_REF) and norm_ref_preface(f)
         initial_boilerplate(xmldoc, isodoc)
       end

data/lib/asciidoctor/standoc/cleanup_footnotes.rb

@@ -20,6 +20,7 @@ module Asciidoctor
           nomatches = true
           xmldoc.xpath(q).each do |s|
             next if s.children.map { |c| c.text? && /[[:alpha:]]/.match(c.text) }.any?
+
             s.previous_element << s.first_element_child.remove
             s.remove
             nomatches = false

data/lib/asciidoctor/standoc/cleanup_image.rb

@@ -0,0 +1,71 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def svgmap_cleanup(xmldoc)
+        svgmap_moveattrs(xmldoc)
+        svgmap_populate(xmldoc)
+        Metanorma::Utils::svgmap_rewrite(xmldoc, @localdir)
+      end
+
+      def guid?(str)
+        /^_[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i
+          .match(str)
+      end
+
+      def svgmap_moveattrs(xmldoc)
+        xmldoc.xpath("//svgmap").each do |s|
+          f = s.at(".//figure") or next
+          if (t = s.at("./name")) && !f.at("./name")
+            f.children.first.previous = t.remove
+          end
+          if s["id"] && guid?(f["id"])
+            f["id"] = s["id"]
+            s.delete("id")
+          end
+          svgmap_moveattrs1(s, f)
+        end
+      end
+
+      def svgmap_moveattrs1(s, f)
+        %w(unnumbered number subsequence keep-with-next
+           keep-lines-together).each do |a|
+          next if f[a] || !s[a]
+
+          f[a] = s[a]
+          s.delete(a)
+        end
+      end
+
+      def svgmap_populate(xmldoc)
+        xmldoc.xpath("//svgmap").each do |s|
+          s1 = s.dup
+          s.children.remove
+          f = s1.at(".//figure") and s << f
+          s1.xpath(".//li").each do |li|
+            t = li&.at(".//eref | .//link | .//xref") or next
+            href = t.xpath("./following-sibling::node()")
+            href.empty? or
+              s << %[<target href="#{svgmap_target(href)}">#{t.to_xml}</target>]
+          end
+        end
+      end
+
+      def svgmap_target(nodeset)
+        nodeset.each do |n|
+          next unless n.name == "link"
+
+          n.children = n["target"]
+        end
+        nodeset.text.sub(/^[,; ]/, "").strip
+      end
+
+      def img_cleanup(xmldoc)
+        return xmldoc unless @datauriimage
+
+        xmldoc.xpath("//image").each do |i|
+          i["src"] = Metanorma::Utils::datauri(i["src"], @localdir)
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup_inline.rb

@@ -3,32 +3,54 @@ require "metanorma-utils"
 module Asciidoctor
   module Standoc
     module Cleanup
-      def empty_text_before_first_element(x)
-        x.children.each do |c|
-          return false if c.text? and /\S/.match(c.text)
+      def empty_text_before_first_element(elem)
+        elem.children.each do |c|
+          return false if c.text? && /\S/.match(c.text)
           return true if c.element?
         end
         true
       end
 
-      def strip_initial_space(x)
-        if x.children[0].text?
-          if !/\S/.match(x.children[0].text)
-            x.children[0].remove
-          else
-            x.children[0].content = x.children[0].text.gsub(/^ /, "")
-          end
+      def strip_initial_space(elem)
+        return unless elem.children[0].text?
+
+        if /\S/.match?(elem.children[0].text)
+          elem.children[0].content = elem.children[0].text.gsub(/^ /, "")
+        else
+          elem.children[0].remove
         end
       end
 
       def bookmark_cleanup(xmldoc)
+        li_bookmark_cleanup(xmldoc)
+        dt_bookmark_cleanup(xmldoc)
+      end
+
+      def bookmark_to_id(elem, bookmark)
+        parent = bookmark.parent
+        elem["id"] = bookmark.remove["id"]
+        strip_initial_space(parent)
+      end
+
+      def li_bookmark_cleanup(xmldoc)
         xmldoc.xpath("//li[descendant::bookmark]").each do |x|
-          if x&.elements&.first&.name == "p" &&
-              x&.elements&.first&.elements&.first&.name == "bookmark"
-            if empty_text_before_first_element(x.elements[0])
-              x["id"] = x.elements[0].elements[0].remove["id"]
-              strip_initial_space(x.elements[0])
-            end
+          if x.at("./*[1][local-name() = 'p']/"\
+                  "*[1][local-name() = 'bookmark']") &&
+              empty_text_before_first_element(x.elements[0])
+            bookmark_to_id(x, x.elements[0].elements[0])
+          end
+        end
+      end
+
+      def dt_bookmark_cleanup(xmldoc)
+        xmldoc.xpath("//dt[descendant::bookmark]").each do |x|
+          if x.at("./*[1][local-name() = 'p']/"\
+                  "*[1][local-name() = 'bookmark']") &&
+              empty_text_before_first_element(x.elements[0])
+            bookmark_to_id(x, x.elements[0].elements[0])
+          elsif x.at("./*[1][local-name() = 'bookmark']") &&
+              empty_text_before_first_element(x)
+            bookmark_to_id(x, x.elements[0])
           end
         end
       end
@@ -46,65 +68,67 @@ module Asciidoctor
       LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
                                Regexp::IGNORECASE | Regexp::MULTILINE)
 
-      def tq(x)
-        x.sub(/^"/, "").sub(/"$/, "")
+      def tq(text)
+        text.sub(/^"/, "").sub(/"$/, "")
       end
 
-      def extract_localities(x)
-        f = x&.children&.first or return
+      def extract_localities(elem)
+        f = elem&.children&.first or return
         f.text? or return
         head = f.remove.text
-        tail = x&.children&.remove
-        extract_localities1(x, head)
-        tail and x << tail
+        tail = elem&.children&.remove
+        extract_localities1(elem, head)
+        tail and elem << tail
       end
 
-      def extract_localities1(x, text)
-        b = x.add_child("<localityStack/>").first if LOCALITY_RE.match text
+      def extract_localities1(elem, text)
+        b = elem.add_child("<localityStack/>").first if LOCALITY_RE.match text
         while (m = LOCALITY_RE.match text)
           ref = m[:ref] ? "<referenceFrom>#{tq m[:ref]}</referenceFrom>" : ""
           refto = m[:to] ? "<referenceTo>#{tq m[:to]}</referenceTo>" : ""
           loc = m[:locality]&.downcase || m[:locality2]&.downcase
           b.add_child("<locality type='#{loc}'>#{ref}#{refto}</locality>")
           text = m[:text]
-          b = x.add_child("<localityStack/>").first if m[:punct] == ";"
+          b = elem.add_child("<localityStack/>").first if m[:punct] == ";"
         end
-        x.add_child(text) if text
+        elem.add_child(text) if text
       end
 
-      def xref_to_eref(x)
-        x["bibitemid"] = x["target"]
-        unless x["citeas"] = @anchors&.dig(x["target"], :xref)
-          @internal_eref_namespaces.include?(x["type"]) or
-          @log.add("Crossreferences", x,
-                   "#{x['target']} does not have a corresponding anchor ID in the bibliography!")
+      def xref_to_eref(elem)
+        elem["bibitemid"] = elem["target"]
+        unless elem["citeas"] = @anchors&.dig(elem["target"], :xref)
+          @internal_eref_namespaces.include?(elem["type"]) or
+            @log.add("Crossreferences", elem,
+                     "#{elem['target']} does not have a corresponding "\
+                     "anchor ID in the bibliography!")
         end
-        x.delete("target")
-        extract_localities(x) unless x.children.empty?
+        elem.delete("target")
+        extract_localities(elem) unless elem.children.empty?
       end
 
       def xref_cleanup(xmldoc)
         xmldoc.xpath("//xref").each do |x|
           /:/.match(x["target"]) and xref_to_internal_eref(x)
           next unless x.name == "xref"
+
           if refid? x["target"]
             x.name = "eref"
             xref_to_eref(x)
-          else
-            x.delete("type")
+          else x.delete("type")
           end
         end
       end
 
-      def xref_to_internal_eref(x)
-        a = x["target"].split(":", 3)
-        unless  a.size < 2 || a[0].empty? || a[1].empty?
-          x["target"] = "#{a[0]}_#{a[1]}"
-          a.size > 2 and x.children = %{anchor="#{a[2..-1].join("")}",#{x&.children&.text}}
-          x["type"] = a[0]
+      def xref_to_internal_eref(elem)
+        a = elem["target"].split(":", 3)
+        unless a.size < 2 || a[0].empty? || a[1].empty?
+          elem["target"] = "#{a[0]}_#{a[1]}"
+          a.size > 2 and
+            elem.children = %{anchor="#{a[2..-1].join}",#{elem&.children&.text}}
+          elem["type"] = a[0]
           @internal_eref_namespaces << a[0]
-          x.name = "eref"
-          xref_to_eref(x)
+          elem.name = "eref"
+          xref_to_eref(elem)
         end
       end
 
@@ -116,10 +140,11 @@ module Asciidoctor
 
       def origin_cleanup(xmldoc)
         xmldoc.xpath("//origin/concept[termref]").each do |x|
-          x.replace(x.children)
+          t = x.at("./termref")
+          x.replace(t)
         end
         xmldoc.xpath("//origin").each do |x|
-          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) ||
+          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) or
             @log.add("Crossreferences", x,
                      "#{x['bibitemid']} does not have a corresponding anchor "\
                      "ID in the bibliography!")
@@ -128,68 +153,83 @@ module Asciidoctor
       end
 
       def concept_cleanup(xmldoc)
-        xmldoc.xpath("//concept").each do |x|
-          x.delete("term") if x["term"].empty?
-          if /:/.match(x["key"]) then concept_termbase_cleanup(x)
+        xmldoc.xpath("//concept[not(termxref)]").each do |x|
+          term = x.at("./refterm")
+          term&.remove if term&.text&.empty?
+          x.children.remove if x&.children&.text&.strip&.empty?
+          key_extract_locality(x)
+          if /:/.match?(x["key"]) then concept_termbase_cleanup(x)
           elsif refid? x["key"] then concept_eref_cleanup(x)
-          else
-            concept_xref_cleanup(x)
+          else concept_xref_cleanup(x)
           end
           x.delete("key")
         end
       end
 
-      def concept_termbase_cleanup(x)
-        text = x&.children&.first&.remove&.text
-        termbase, key = x["key"].split(/:/, 2)
-        x.add_child(%(<termref base="#{termbase}" target="#{key}">) +
-                    "#{text}</termref>")
+      def key_extract_locality(elem)
+        return unless /,/.match?(elem["key"])
+
+        elem.add_child("<locality>#{elem['key'].sub(/^[^,]+,/, '')}</locality>")
+        elem["key"] = elem["key"].sub(/,.*$/, "")
+      end
+
+      def concept_termbase_cleanup(elem)
+        t = elem&.at("./xrefrender")&.remove&.children
+        termbase, key = elem["key"].split(/:/, 2)
+        elem.add_child(%(<termref base="#{termbase}" target="#{key}">) +
+                       "#{t&.to_xml}</termref>")
       end
 
-      def concept_xref_cleanup(x)
-        text = x&.children&.first&.remove&.text
-        x.add_child(%(<xref target="#{x['key']}">#{text}</xref>))
+      def concept_xref_cleanup(elem)
+        t = elem&.at("./xrefrender")&.remove&.children
+        elem.add_child(%(<xref target="#{elem['key']}">#{t&.to_xml}</xref>))
       end
 
-      def concept_eref_cleanup(x)
-        x.children = "<eref>#{x.children.to_xml}</eref>"
-        extract_localities(x.first_element_child)
+      def concept_eref_cleanup(elem)
+        t = elem&.at("./xrefrender")&.remove&.children&.to_xml
+        l = elem&.at("./locality")&.remove&.children&.to_xml
+        elem.add_child "<eref bibitemid='#{elem['key']}'>#{l}</eref>"
+        extract_localities(elem.elements[-1])
+        elem.elements[-1].add_child(t) if t
       end
 
-      def to_xreftarget(s)
-        return Metanorma::Utils::to_ncname(s) unless /^[^#]+#.+$/.match(s)
-          /^(?<pref>[^#]+)#(?<suff>.+)$/ =~ s
-        pref = pref.gsub(%r([#{Metanorma::Utils::NAMECHAR}]), "_")
-        suff = suff.gsub(%r([#{Metanorma::Utils::NAMECHAR}]), "_")
+      def to_xreftarget(str)
+        return Metanorma::Utils::to_ncname(str) unless /^[^#]+#.+$/.match?(str)
+
+        /^(?<pref>[^#]+)#(?<suff>.+)$/ =~ str
+        pref = pref.gsub(%r([#{Metanorma::Utils::NAMECHAR}])o, "_")
+        suff = suff.gsub(%r([#{Metanorma::Utils::NAMECHAR}])o, "_")
         "#{pref}##{suff}"
       end
 
       IDREF = "//*/@id | //review/@from | //review/@to | "\
         "//callout/@target | //citation/@bibitemid | //eref/@bibitemid".freeze
 
-      def anchor_cleanup(x)
-        anchor_cleanup1(x)
-        xreftarget_cleanup(x)
+      def anchor_cleanup(elem)
+        anchor_cleanup1(elem)
+        xreftarget_cleanup(elem)
       end
 
-      def anchor_cleanup1(x)
-        x.xpath(IDREF).each do |s|
+      def anchor_cleanup1(elem)
+        elem.xpath(IDREF).each do |s|
           if (ret = Metanorma::Utils::to_ncname(s.value)) != (orig = s.value)
             s.value = ret
             output = s.parent.dup
             output.children.remove
-            @log.add("Anchors", s.parent, "normalised identifier in #{output} from #{orig}")
+            @log.add("Anchors", s.parent,
+                     "normalised identifier in #{output} from #{orig}")
           end
         end
       end
 
-      def xreftarget_cleanup(x)
-        x.xpath("//xref/@target").each do |s|
+      def xreftarget_cleanup(elem)
+        elem.xpath("//xref/@target").each do |s|
           if (ret = to_xreftarget(s.value)) != (orig = s.value)
             s.value = ret
             output = s.parent.dup
             output.children.remove
-            @log.add("Anchors", s.parent, "normalised identifier in #{output} from #{orig}")
+            @log.add("Anchors", s.parent,
+                     "normalised identifier in #{output} from #{orig}")
           end
         end
       end