metanorma-standoc 1.9.0 → 1.10.0

data/lib/asciidoctor/standoc/cleanup_maths.rb

@@ -3,36 +3,39 @@ require "pathname"
 require "open-uri"
 require "html2doc"
 require "asciimath2unitsml"
-require_relative "./cleanup_block.rb"
-require_relative "./cleanup_footnotes.rb"
-require_relative "./cleanup_ref.rb"
-require_relative "./cleanup_ref_dl.rb"
-require_relative "./cleanup_boilerplate.rb"
-require_relative "./cleanup_section.rb"
-require_relative "./cleanup_terms.rb"
-require_relative "./cleanup_inline.rb"
-require_relative "./cleanup_amend.rb"
+require_relative "./cleanup_block"
+require_relative "./cleanup_footnotes"
+require_relative "./cleanup_ref"
+require_relative "./cleanup_ref_dl"
+require_relative "./cleanup_boilerplate"
+require_relative "./cleanup_section"
+require_relative "./cleanup_terms"
+require_relative "./cleanup_inline"
+require_relative "./cleanup_amend"
 require "relaton_iev"
 
 module Asciidoctor
   module Standoc
     module Cleanup
       def asciimath2mathml(text)
-        text = text.gsub(%r{<stem type="AsciiMath">(.+?)</stem>}m) do |m|
-            "<amathstem>#{HTMLEntities.new.decode($1)}</amathstem>"
-          end
-          text = Html2Doc.asciimath_to_mathml(text, ["<amathstem>", "</amathstem>"])
-          x =  Nokogiri::XML(text)
-          x.xpath("//*[local-name() = 'math'][not(parent::stem)]").each do |y|
-            y.wrap("<stem type='MathML'></stem>")
-          end
-          x.to_xml
+        text = text.gsub(%r{<stem type="AsciiMath">(.+?)</stem>}m) do
+          "<amathstem>#{HTMLEntities.new.decode($1)}</amathstem>"
+        end
+        text = Html2Doc.asciimath_to_mathml(text,
+                                            ["<amathstem>", "</amathstem>"])
+        x =  Nokogiri::XML(text)
+        x.xpath("//*[local-name() = 'math'][not(parent::stem)]").each do |y|
+          y.wrap("<stem type='MathML'></stem>")
+        end
+        x.to_xml
       end
 
       def xml_unescape_mathml(x)
         return if x.children.any? { |y| y.element? }
-        math = x.text.gsub(/&lt;/, "<").gsub(/&gt;/, ">").gsub(/&quot;/, '"').gsub(/&apos;/, "'").gsub(/&amp;/, "&").
-          gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
+
+        math = x.text.gsub(/&lt;/, "<").gsub(/&gt;/, ">")
+          .gsub(/&quot;/, '"').gsub(/&apos;/, "'").gsub(/&amp;/, "&")
+          .gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
         x.children = math
       end
 
@@ -40,12 +43,13 @@ module Asciidoctor
 
       def mathml_preserve_space(m)
         m.xpath(".//m:mtext", "m" => MATHML_NS).each do |x|
-          x.children = x.children.to_xml.gsub(/^\s/, "&#xA0;").gsub(/\s$/, "&#xA0;")
+          x.children = x.children.to_xml
+            .gsub(/^\s/, "&#xA0;").gsub(/\s$/, "&#xA0;")
         end
       end
 
       def mathml_namespace(stem)
-        stem.xpath("./math", ).each { |x| x.default_namespace = MATHML_NS }
+        stem.xpath("./math").each { |x| x.default_namespace = MATHML_NS }
       end
 
       def mathml_mi_italics
@@ -55,7 +59,8 @@ module Asciidoctor
 
       # presuppose multichar mi upright, singlechar mi MathML default italic
       def mathml_italicise(x)
-        x.xpath(".//m:mi[not(ancestor::*[@mathvariant])]", "m" => MATHML_NS).each do |i|
+        x.xpath(".//m:mi[not(ancestor::*[@mathvariant])]",
+                "m" => MATHML_NS).each do |i|
           char = HTMLEntities.new.decode(i.text)
           i["mathvariant"] = "normal" if mi_italicise?(char)
         end
@@ -63,10 +68,11 @@ module Asciidoctor
 
       def mi_italicise?(c)
         return false if c.length > 1
-        if /\p{Greek}/.match(c)
+
+        if /\p{Greek}/.match?(c)
           /\p{Lower}/.match(c) && !mathml_mi_italics[:lowergreek] ||
             /\p{Upper}/.match(c) && !mathml_mi_italics[:uppergreek]
-        elsif /\p{Latin}/.match(c)
+        elsif /\p{Latin}/.match?(c)
           /\p{Lower}/.match(c) && !mathml_mi_italics[:lowerroman] ||
             /\p{Upper}/.match(c) && !mathml_mi_italics[:upperroman]
         else
@@ -87,6 +93,7 @@ module Asciidoctor
 
       def mathml_unitsML(xmldoc)
         return unless xmldoc.at(".//m:*", "m" => UNITSML_NS)
+
         misc = add_misc_container(xmldoc)
         unitsml = misc.add_child("<UnitsML xmlns='#{UNITSML_NS}'/>").first
         %w(Unit CountedItem Quantity Dimension Prefix).each do |t|
@@ -95,12 +102,14 @@ module Asciidoctor
       end
 
       def gather_unitsml(unitsml, xmldoc, t)
-        tags = xmldoc.xpath(".//m:#{t}", "m" => UNITSML_NS).each_with_object({}) do |x, m|
+        tags = xmldoc.xpath(".//m:#{t}", "m" => UNITSML_NS)
+          .each_with_object({}) do |x, m|
           m[x["id"]] = x.remove
         end
         return if tags.empty?
+
         set = unitsml.add_child("<#{t}Set/>").first
-        tags.values.each { |v| set << v }
+        tags.each_value { |v| set << v }
       end
 
       def asciimath2unitsml_options

data/lib/asciidoctor/standoc/cleanup_ref.rb

@@ -14,9 +14,10 @@ module Asciidoctor
         fold_notes_into_biblio(refs)
         bib = sort_biblio(refs.xpath("./bibitem"))
         insert = refs&.at("./bibitem")&.previous_element
-        refs.xpath("./bibitem").each { |b| b.remove }
+        refs.xpath("./bibitem").each(&:remove)
         bib.reverse.each do |b|
-          insert and insert.next = b.to_xml or refs.children.first.add_previous_sibling b.to_xml
+          insert and insert.next = b.to_xml or
+            refs.children.first.add_previous_sibling b.to_xml
         end
         extract_notes_from_biblio(refs)
         refs.xpath("./references").each { |r| biblio_reorder1(r) }
@@ -24,7 +25,7 @@ module Asciidoctor
 
       def fold_notes_into_biblio(refs)
         refs.xpath("./bibitem").each do |r|
-          while r&.next_element&.name == "note" do
+          while r&.next_element&.name == "note"
             r.next_element["appended"] = true
             r << r.next_element.remove
           end
@@ -49,12 +50,15 @@ module Asciidoctor
       # only numeric references are renumbered
       def biblio_renumber(xmldoc)
         i = 0
-        xmldoc.xpath("//bibliography//references | //clause//references | //annex//references").each do |r|
+        xmldoc.xpath("//bibliography//references | //clause//references | "\
+                     "//annex//references").each do |r|
           next if r["normative"] == "true"
+
           r.xpath("./bibitem").each do |b|
             i += 1
             next unless docid = b.at("./docidentifier[@type = 'metanorma']")
-            next unless  /^\[\d+\]$/.match(docid.text)
+            next unless /^\[\d+\]$/.match?(docid.text)
+
             docid.children = "[#{i}]"
           end
         end
@@ -70,9 +74,10 @@ module Asciidoctor
 
       def normref_cleanup(xmldoc)
         r = xmldoc.at(self.class::NORM_REF) || return
-        preface = r.xpath("./title/following-sibling::*") & # intersection
-          r.xpath("./bibitem[1]/preceding-sibling::*")
-        preface.each { |n| n.remove }
+        preface = ((r.xpath("./title/following-sibling::*") & # intersection
+                    r.xpath("./bibitem[1]/preceding-sibling::*")) -
+        r.xpath("./note[@type = 'boilerplate']/descendant-or-self::*"))
+        preface.each(&:remove)
       end
 
       def biblio_cleanup(xmldoc)
@@ -92,6 +97,7 @@ module Asciidoctor
       def format_ref(ref, type)
         return @isodoc.docid_prefix(type, ref) if type != "metanorma"
         return "[#{ref}]" if /^\d+$/.match(ref) && !/^\[.*\]$/.match(ref)
+
         ref
       end
 
@@ -103,7 +109,7 @@ module Asciidoctor
 
       def reference_names(xmldoc)
         xmldoc.xpath("//bibitem[not(ancestor::bibitem)]").each do |ref|
-          isopub = ref.at(ISO_PUBLISHER_XPATH)
+          # isopub = ref.at(ISO_PUBLISHER_XPATH)
           docid = ref.at("./docidentifier[@type = 'metanorma']") ||
             ref.at("./docidentifier[not(@type = 'DOI')]") or next
           reference = format_ref(docid.text, docid["type"])
@@ -111,18 +117,20 @@ module Asciidoctor
         end
       end
 
-      def fetch_termbase(termbase, id)
+      def fetch_termbase(_termbase, _id)
         ""
       end
 
       def read_local_bibitem(uri)
-        return nil if %r{^http[s]?://}.match(uri)
-        file = @localdir + uri + ".rxl"
-        File.file?(file) or file = @localdir + uri + ".xml"
+        return nil if %r{^https?://}.match?(uri)
+
+        file = "#{@localdir}#{uri}.rxl"
+        File.file?(file) or file = "#{@localdir}#{uri}.xml"
         File.file?(file) or return nil
         xml = Nokogiri::XML(File.read(file, encoding: "utf-8"))
         ret = xml.at("//*[local-name() = 'bibdata']") or return nil
-        ret = Nokogiri::XML(ret.to_xml.sub(%r{(<bibdata[^>]*?) xmlns=("[^"]+"|'[^']+')}, "\\1")).root
+        ret = Nokogiri::XML(ret.to_xml
+          .sub(%r{(<bibdata[^>]*?) xmlns=("[^"]+"|'[^']+')}, "\\1")).root
         ret.name = "bibitem"
         ins = ret.at("./*[local-name() = 'docidentifier']") or return nil
         ins.previous = %{<uri type="citation">#{uri}</uri>}
@@ -132,7 +140,8 @@ module Asciidoctor
 
       # if citation uri points to local file, get bibitem from it
       def fetch_local_bibitem(xmldoc)
-        xmldoc.xpath("//bibitem[formattedref][uri[@type = 'citation']]").each do |b|
+        xmldoc.xpath("//bibitem[formattedref][uri[@type = 'citation']]")
+          .each do |b|
           uri = b&.at("./uri[@type = 'citation']")&.text
           bibitem = read_local_bibitem(uri) or next
           bibitem["id"] = b["id"]
@@ -140,7 +149,14 @@ module Asciidoctor
         end
       end
 
+      def bibitem_nested_id(xmldoc)
+        xmldoc.xpath("//bibitem//bibitem").each do |b|
+          b.delete("id")
+        end
+      end
+
       def bibitem_cleanup(xmldoc)
+        bibitem_nested_id(xmldoc)
         ref_dl_cleanup(xmldoc)
         fetch_local_bibitem(xmldoc)
       end

data/lib/asciidoctor/standoc/cleanup_ref_dl.rb

@@ -8,7 +8,7 @@ module Asciidoctor
         xmldoc.xpath("//clause[@bibitem = 'true']").each do |c|
           bib = dl_bib_extract(c) or next
           validate_ref_dl(bib, c)
-          bibitemxml = RelatonBib::BibliographicItem.new(RelatonBib::HashConverter::hash_to_bib(bib)).to_xml or next
+          bibitemxml = RelatonBib::BibliographicItem.from_hash(bib).to_xml or next
           bibitem = Nokogiri::XML(bibitemxml)
           bibitem.root["id"] = c["id"] if c["id"] && !/^_/.match(c["id"])
           c.replace(bibitem.root)

data/lib/asciidoctor/standoc/cleanup_reqt.rb

@@ -0,0 +1,47 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def requirement_cleanup(reqt)
+        requirement_descriptions(reqt)
+        requirement_inherit(reqt)
+      end
+
+      def requirement_inherit(reqt)
+        reqt.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 }
+        end
+      end
+
+      def requirement_descriptions(reqt)
+        reqt.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", reqt)
+              e.before(t)
+              t.children = e.remove
+            end
+          end
+          requirement_cleanup1(r)
+        end
+      end
+
+      def requirement_cleanup1(reqt)
+        while d = reqt.at("./description[following-sibling::*[1]"\
+            "[self::description]]")
+          n = d.next.remove
+          d << n.children
+        end
+        reqt.xpath("./description[normalize-space(.)='']").each do |r|
+          r.replace("\n")
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup_section.rb

@@ -3,36 +3,37 @@ require "htmlentities"
 require "json"
 require "open-uri"
 require "mathml2asciimath"
+require_relative "cleanup_section_names"
 
 module Asciidoctor
   module Standoc
     module Cleanup
-      def make_preface(x, s)
-        if x.at("//foreword | //introduction | //acknowledgements | "\
+      def make_preface(xml, sect)
+        if xml.at("//foreword | //introduction | //acknowledgements | "\
             "//*[@preface]")
-          preface = s.add_previous_sibling("<preface/>").first
-          f = x.at("//foreword") and preface.add_child f.remove
-          f = x.at("//introduction") and preface.add_child f.remove
-          move_clauses_into_preface(x, preface)
-          f = x.at("//acknowledgements") and preface.add_child f.remove
+          preface = sect.add_previous_sibling("<preface/>").first
+          f = xml.at("//foreword") and preface.add_child f.remove
+          f = xml.at("//introduction") and preface.add_child f.remove
+          move_clauses_into_preface(xml, preface)
+          f = xml.at("//acknowledgements") and preface.add_child f.remove
         end
-        make_abstract(x, s)
+        make_abstract(xml, sect)
       end
 
-      def move_clauses_into_preface(x, preface)
-        x.xpath("//*[@preface]").each do |c|
+      def move_clauses_into_preface(xml, preface)
+        xml.xpath("//*[@preface]").each do |c|
           c.delete("preface")
           preface.add_child c.remove
         end
       end
 
-      def make_abstract(x, s)
-        if x.at("//abstract[not(ancestor::bibitem)]")
-          preface = s.at("//preface") ||
-            s.add_previous_sibling("<preface/>").first
-          abstract = x.at("//abstract[not(ancestor::bibitem)]").remove
+      def make_abstract(xml, sect)
+        if xml.at("//abstract[not(ancestor::bibitem)]")
+          preface = sect.at("//preface") ||
+            sect.add_previous_sibling("<preface/>").first
+          abstract = xml.at("//abstract[not(ancestor::bibitem)]").remove
           preface.prepend_child abstract.remove
-          bibabstract = bibabstract_location(x)
+          bibabstract = bibabstract_location(xml)
           dupabstract = abstract.dup
           dupabstract.traverse { |n| n.remove_attribute("id") }
           dupabstract.remove_attribute("language")
@@ -42,42 +43,46 @@ module Asciidoctor
         end
       end
 
-      def bibabstract_location(x)
-        x.at("//bibdata/script") || x.at("//bibdata/language") ||
-          x.at("//bibdata/contributor[not(following-sibling::contributor)]") ||
-          x.at("//bibdata/date[not(following-sibling::date)]") ||
-          x.at("//docnumber") ||
-          x.at("//bibdata/docidentifier"\
-               "[not(following-sibling::docidentifier)]") ||
-        x.at("//bibdata/uri[not(following-sibling::uri)]") ||
-        x.at("//bibdata/title[not(following-sibling::title)]")
+      def bibabstract_location(xml)
+        xml.at("//bibdata/script") || xml.at("//bibdata/language") ||
+          xml.at("//bibdata/contributor[not(following-sibling::contributor)]") ||
+          xml.at("//bibdata/date[not(following-sibling::date)]") ||
+          xml.at("//docnumber") ||
+          xml.at("//bibdata/docidentifier"\
+                 "[not(following-sibling::docidentifier)]") ||
+          xml.at("//bibdata/uri[not(following-sibling::uri)]") ||
+          xml.at("//bibdata/title[not(following-sibling::title)]")
       end
 
-      def make_bibliography(x, s)
-        if x.at("//sections/references")
-          biblio = s.add_next_sibling("<bibliography/>").first
-          x.xpath("//sections/references").each do |r|
+      def make_bibliography(xml, sect)
+        if xml.at("//sections/references")
+          biblio = sect.add_next_sibling("<bibliography/>").first
+          xml.xpath("//sections/references").each do |r|
             biblio.add_child r.remove
           end
         end
       end
 
-      def make_indexsect(x, s)
-        x.xpath("//sections/indexsect").reverse_each { |r| s.next = r.remove }
+      def make_indexsect(xml, sect)
+        xml.xpath("//sections/indexsect").reverse_each do |r|
+          sect.next = r.remove
+        end
       end
 
-      def sections_order_cleanup(x)
-        s = x.at("//sections")
-        make_preface(x, s)
-        make_annexes(x)
-        make_indexsect(x, s)
-        make_bibliography(x, s)
-        x.xpath("//sections/annex").reverse_each { |r| s.next = r.remove }
+      def sections_order_cleanup(xml)
+        s = xml.at("//sections")
+        make_preface(xml, s)
+        make_annexes(xml)
+        make_indexsect(xml, s)
+        make_bibliography(xml, s)
+        xml.xpath("//sections/annex").reverse_each { |r| s.next = r.remove }
       end
-      def make_annexes(x)
-        x.xpath("//*[@annex]").each do |y|
+
+      def make_annexes(xml)
+        xml.xpath("//*[@annex]").each do |y|
           y.delete("annex")
           next if y.name == "annex" || !y.ancestors("annex").empty?
+
           y.wrap("<annex/>")
           y.parent["id"] = "_#{UUIDTools::UUID.random_create}"
           y.parent["obligation"] = y["obligation"]
@@ -86,59 +91,61 @@ module Asciidoctor
         end
       end
 
-      def maxlevel(x)
+      def maxlevel(xml)
         max = 5
-        x.xpath("//clause[@level]").each do |c|
+        xml.xpath("//clause[@level]").each do |c|
           max = c["level"].to_i if max < c["level"].to_i
         end
         max
       end
 
-      def sections_level_cleanup(x)
-        m = maxlevel(x)
+      def sections_level_cleanup(xml)
+        m = maxlevel(xml)
         return if m < 6
+
         m.downto(6).each do |l|
-          x.xpath("//clause[@level = '#{l}']").each do |c|
+          xml.xpath("//clause[@level = '#{l}']").each do |c|
             c.delete("level")
             c.previous_element << c.remove
           end
         end
       end
 
-      def sections_cleanup(x)
-        sections_order_cleanup(x)
-        sections_level_cleanup(x)
-        sections_names_cleanup(x)
-        change_clauses(x)
+      def sections_cleanup(xml)
+        sections_order_cleanup(xml)
+        sections_level_cleanup(xml)
+        sections_names_cleanup(xml)
+        change_clauses(xml)
       end
 
-      def obligations_cleanup(x)
-        obligations_cleanup_info(x)
-        obligations_cleanup_norm(x)
-        obligations_cleanup_inherit(x)
+      def obligations_cleanup(xml)
+        obligations_cleanup_info(xml)
+        obligations_cleanup_norm(xml)
+        obligations_cleanup_inherit(xml)
       end
 
-      def obligations_cleanup_info(x)
-        (s = x.at("//foreword")) && s["obligation"] = "informative"
-        (s = x.at("//introduction")) && s["obligation"] = "informative"
-        (s = x.at("//acknowledgements")) && s["obligation"] = "informative"
-        x.xpath("//references").each { |r| r["obligation"] = "informative" }
-        x.xpath("//preface//clause").each do |r|
+      def obligations_cleanup_info(xml)
+        s = xml.at("//foreword") and s["obligation"] = "informative"
+        s = xml.at("//introduction") and s["obligation"] = "informative"
+        s = xml.at("//acknowledgements") and s["obligation"] = "informative"
+        xml.xpath("//references").each { |r| r["obligation"] = "informative" }
+        xml.xpath("//preface//clause").each do |r|
           r["obligation"] = "informative"
         end
       end
 
-      def obligations_cleanup_norm(x)
-        (s = x.at("//clause[@type = 'scope']")) && s["obligation"] = "normative"
-        x.xpath("//terms").each { |r| r["obligation"] = "normative" }
-        x.xpath("//definitions").each { |r| r["obligation"] = "normative" }
+      def obligations_cleanup_norm(xml)
+        s = xml.at("//clause[@type = 'scope']") and
+          s["obligation"] = "normative"
+        xml.xpath("//terms").each { |r| r["obligation"] = "normative" }
+        xml.xpath("//definitions").each { |r| r["obligation"] = "normative" }
       end
 
-      def obligations_cleanup_inherit(x)
-        x.xpath("//annex | //clause[not(ancestor::boilerplate)]").each do |r|
+      def obligations_cleanup_inherit(xml)
+        xml.xpath("//annex | //clause[not(ancestor::boilerplate)]").each do |r|
           r["obligation"] = "normative" unless r["obligation"]
         end
-        x.xpath(Utils::SUBCLAUSE_XPATH).each do |r|
+        xml.xpath(Utils::SUBCLAUSE_XPATH).each do |r|
           o = r&.at("./ancestor::*/@obligation")&.text and r["obligation"] = o
         end
       end
@@ -148,8 +155,9 @@ module Asciidoctor
         sections_clausebefore_cleanup(xmldoc)
       end
 
-       def preface_clausebefore_cleanup(xmldoc)
+      def preface_clausebefore_cleanup(xmldoc)
         return unless xmldoc.at("//preface")
+
         unless ins = xmldoc.at("//preface").children.first
           xmldoc.at("//preface") << " "
           ins = xmldoc.at("//preface").children.first
@@ -162,6 +170,7 @@ module Asciidoctor
 
       def sections_clausebefore_cleanup(xmldoc)
         return unless xmldoc.at("//sections")
+
         unless ins = xmldoc.at("//sections").children.first
           xmldoc.at("//sections") << " "
           ins = xmldoc.at("//sections").children.first
@@ -171,73 +180,6 @@ module Asciidoctor
           ins.previous = x.remove
         end
       end
-
-      def get_or_make_title(node)
-          unless node.at("./title")
-            if node.children.empty?
-              node << "<title/>"
-            else
-              node.children.first.previous = "<title/>"
-            end
-          end
-          node.at("./title")
-      end
-
-      def replace_title(doc, xpath, text, first = false)
-        return unless text
-
-        doc.xpath(xpath).each_with_index do |node, i|
-          next if first && !i.zero?
-          title = get_or_make_title(node)
-          fn = title.xpath("./fn")
-          fn.each { |n| n.remove }
-          title.content = text
-          fn.each { |n| title << n }
-        end
-      end
-
-      def sections_names_cleanup(xml)
-        replace_title(xml, "//clause[@type = 'scope']", @i18n&.scope)
-        replace_title(xml, "//preface//abstract", @i18n&.abstract)
-        replace_title(xml, "//foreword", @i18n&.foreword)
-        replace_title(xml, "//introduction", @i18n&.introduction)
-        replace_title(xml, "//acknowledgements", @i18n&.acknowledgements)
-        section_names_refs_cleanup(xml)
-        section_names_terms_cleanup(xml)
-      end
-
-      def section_names_refs_cleanup(xml)
-        replace_title(xml, "//references[@normative = 'true']",
-                      @i18n&.normref, true)
-        replace_title(xml, "//references[@normative = 'false']",
-                      @i18n&.bibliography, true)
-      end
-
-      NO_SYMABBR = "[.//definitions[not(@type)]]".freeze
-      SYMABBR = "[.//definitions[@type = 'symbols']"\
-        "[@type = 'abbreviated_terms']]".freeze
-      SYMnoABBR = "[.//definitions[@type = 'symbols']"\
-        "[not(@type = 'abbreviated_terms')]]".freeze
-      ABBRnoSYM = "[.//definitions[not(@type = 'symbols')]"\
-        "[@type = 'abbreviated_terms']]".freeze
-
-      def section_names_terms_cleanup(x)
-        replace_title(x, "//definitions[@type = 'symbols']", @i18n&.symbols)
-        replace_title(x, "//definitions[@type = 'abbreviated_terms']",
-                      @i18n&.abbrev)
-        replace_title(x, "//definitions[not(@type)]", @i18n&.symbolsabbrev)
-        replace_title(x, "//terms#{SYMnoABBR} | //clause[.//terms]#{SYMnoABBR}",
-                      @i18n&.termsdefsymbols, true)
-        replace_title(x, "//terms#{ABBRnoSYM} | //clause[.//terms]#{ABBRnoSYM}",
-                      @i18n&.termsdefabbrev, true)
-        replace_title(x, "//terms#{SYMABBR} | //clause[.//terms]#{SYMABBR}",
-                      @i18n&.termsdefsymbolsabbrev, true)
-        replace_title(x, "//terms#{NO_SYMABBR} | //clause[.//terms]#{NO_SYMABBR}",
-                      @i18n&.termsdefsymbolsabbrev, true)
-        replace_title(
-          x, "//terms[not(.//definitions)] | //clause[.//terms][not(.//definitions)]",
-          @i18n&.termsdef, true)
-      end
     end
   end
 end