metanorma-standoc 2.1.5 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9487b5701cc86946c27e560e244cc4f84fceb61b0a93dd271068875654eb49a0
-  data.tar.gz: c647cf6fb530aba3bc96c9087e7a9d49408ce239a6c6aa3a4a46a0e8cf1a5763
+  metadata.gz: 837bde4e0b1dcb3e1eeb5ffa7c56d063456f4a4cb3666eb00c18aaf6cae7d164
+  data.tar.gz: 69dcdc35a59b471bb2c6ac3cfd52a84b15625a45402c66f83c9e1ec70296b4f3
 SHA512:
-  metadata.gz: c8356539be6d28f5dc6d4d148cfcabb8ed7dbc033392544d382d36e1e392e33da6b29a64b535f6c24cdab85a4d17d1dc5698367f0edff8f45eb02b1f8ed97330
-  data.tar.gz: 13c49550edea0d6169fef67357a5030e146cdf62fec3cb41900db7490d95c09f9dbb1c4f4b55bea4836651ba11fcaf0714b20f37fc3a96a48dd31596cf564549
+  metadata.gz: 88ff22adce3bd32d0c2875acf926520a4950beb6e36e3b7e70cd7ffce68c75869fac1e6449ea0b975d2c87a2cce1b2d0e2898f7d7c29d30065abf6708df863f8
+  data.tar.gz: 86493fb18c13786a09a019a9a184684d90c19957c4154f01f13acd4d4b5cb1e7999cc8f0d0413f0b10ea870e676ab2bbe3e78cacc848a9799e0f9b5189d1efe3

data/lib/metanorma/standoc/base.rb

@@ -9,6 +9,7 @@ require "fileutils"
 require "metanorma-utils"
 require "isodoc/xslfo_convert"
 require_relative "render"
+require "mn-requirements"
 
 module Metanorma
   module Standoc
@@ -29,6 +30,7 @@ module Metanorma
         init_vars
         init_misc(node)
         init_processing(node)
+        init_reqt(node)
         init_toc(node)
         init_output(node)
         init_i18n(node)
@@ -42,7 +44,10 @@ module Metanorma
         @anchors = {}
         @internal_eref_namespaces = []
         @seen_headers = []
+        @seen_headers_canonical = []
         @embed_hdr = []
+        @reqt_model = nil
+        @preface = true
       end
 
       def init_misc(node)
@@ -50,6 +55,7 @@ module Metanorma
         @index_terms = node.attr("index-terms")
         @boilerplateauthority = node.attr("boilerplate-authority")
         @embed_hdr = node.attr("embed_hdr")
+        @document_scheme = node.attr("document-scheme")
       end
 
       def init_processing(node)
@@ -62,6 +68,13 @@ module Metanorma
         @datauriimage = node.attr("data-uri-image") != "false"
       end
 
+      def init_reqt(node)
+        @default_requirement_model = (node.attr("requirements-model") ||
+                                        default_requirement_model)
+        @reqt_models = Metanorma::Requirements
+          .new({ default: @default_requirement_model })
+      end
+
       def init_toc(node)
         @htmltoclevels = node.attr("htmltoclevels")
         @doctoclevels = node.attr("doctoclevels")

data/lib/metanorma/standoc/blocks.rb

@@ -34,7 +34,7 @@ module Metanorma
       # We append each contained block to its parent
       def open(node)
         role = node.role || node.attr("style")
-        reqt_subpart(role) and return requirement_subpart(node)
+        reqt_subpart?(role) and return requirement_subpart(node)
         role == "form" and return form(node)
         role == "definition" and return termdefinition(node)
         result = []
@@ -88,26 +88,37 @@ module Metanorma
       end
 
       def example(node)
-        return term_example(node) if in_terms? || node.option?("termexample")
-
+        (in_terms? || node.option?("termexample")) and return term_example(node)
         role = node.role || node.attr("style")
-        %w(recommendation requirement permission).include?(role) and
-          return requirement(node, role)
-        return pseudocode_example(node) if role == "pseudocode"
-        return svgmap_example(node) if role == "svgmap"
-        return form(node) if role == "form"
-        return termdefinition(node) if role == "definition"
-        return figure_example(node) if role == "figure"
-
-        reqt_subpart(role) and return requirement_subpart(node)
+        ret = example_to_requirement(node, role) ||
+          example_by_role(node, role) and return ret
+        reqt_subpart?(role) and return requirement_subpart(node)
         example_proper(node)
       end
 
+      def example_by_role(node, role)
+        case role
+        when "pseudocode" then pseudocode_example(node)
+        when "svgmap" then svgmap_example(node)
+        when "form" then form(node)
+        when "definition" then termdefinition(node)
+        when "figure" then figure_example(node)
+        end
+      end
+
+      def example_to_requirement(node, role)
+        return unless @reqt_models.requirement_roles.key?(role&.to_sym)
+
+        # need to call here for proper recursion ordering
+        select_requirement_model(node)
+        requirement(node,
+                    @reqt_models.requirement_roles[role.to_sym], role)
+      end
+
       def svgmap_attrs(node)
         attr_code(id_attr(node)
-          .merge(id: node.id,
+          .merge(id: node.id, number: node.attr("number"),
                  unnumbered: node.option?("unnumbered") ? "true" : nil,
-                 number: node.attr("number"),
                  subsequence: node.attr("subsequence"))
         .merge(keep_attrs(node)))
       end
@@ -225,7 +236,6 @@ module Metanorma
                          filename: node.attr("filename"))))
       end
 
-      # NOTE: html escaping is performed by Nokogiri
       def listing(node)
         fragment = ::Nokogiri::XML::Builder.new do |xml|
           xml.sourcecode **listing_attrs(node) do |s|
@@ -238,11 +248,10 @@ module Metanorma
       end
 
       def pass(node)
-        c = HTMLEntities.new
         noko do |xml|
           xml.passthrough **attr_code(formats:
                                       node.attr("format") || "metanorma") do |p|
-            p << c.encode(c.decode(node.content), :basic, :hexadecimal)
+            p << @c.encode(@c.decode(node.content), :basic, :hexadecimal)
           end
         end
       end

data/lib/metanorma/standoc/cleanup.rb

@@ -5,7 +5,7 @@ require_relative "./cleanup_block"
 require_relative "./cleanup_table"
 require_relative "./cleanup_footnotes"
 require_relative "./cleanup_ref"
-require_relative "./cleanup_ref_dl"
+require_relative "./cleanup_biblio"
 require_relative "./cleanup_boilerplate"
 require_relative "./cleanup_section"
 require_relative "./cleanup_terms"

data/lib/metanorma/standoc/cleanup_biblio.rb

@@ -0,0 +1,210 @@
+require "set"
+require "relaton_bib"
+
+module Metanorma
+  module Standoc
+    module Cleanup
+      def ref_dl_cleanup(xmldoc)
+        xmldoc.xpath("//clause[@bibitem = 'true']").each do |c|
+          bib = dl_bib_extract(c) or next
+          validate_ref_dl(bib, c)
+          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)
+        end
+      end
+
+      # do not accept implicit id
+      def validate_ref_dl(bib, clause)
+        id = bib["id"]
+        id ||= clause["id"] unless /^_/.match?(clause["id"])
+        unless id
+          @log.add("Anchors", clause,
+                   "The following reference is missing an anchor:\n"\
+                   "#{clause.to_xml}")
+          return
+        end
+        @refids << id
+        validate_ref_dl1(bib, id, clause)
+      end
+
+      def validate_ref_dl1(bib, id, clause)
+        bib["title"] or
+          @log.add("Bibliography", clause, "Reference #{id} is missing a title")
+        bib["docid"] or
+          @log.add("Bibliography", clause,
+                   "Reference #{id} is missing a document identifier (docid)")
+      end
+
+      def extract_from_p(tag, bib, key)
+        return unless bib[tag]
+
+        "<#{key}>#{bib[tag].at('p').children}</#{key}>"
+      end
+
+      # if the content is a single paragraph, replace it with its children
+      # single links replaced with uri
+      def p_unwrap(para)
+        elems = para.elements
+        if elems.size == 1 && elems[0].name == "p"
+          link_unwrap(elems[0]).children.to_xml.strip
+        else
+          para.to_xml.strip
+        end
+      end
+
+      def link_unwrap(para)
+        elems = para.elements
+        if elems.size == 1 && elems[0].name == "link"
+          para.at("./link").replace(elems[0]["target"].strip)
+        end
+        para
+      end
+
+      def dd_bib_extract(dtd)
+        return nil if dtd.children.empty?
+
+        dtd.at("./dl") and return dl_bib_extract(dtd)
+        elems = dtd.remove.elements
+        return p_unwrap(dtd) unless elems.size == 1 &&
+          %w(ol ul).include?(elems[0].name)
+
+        elems[0].xpath("./li").each_with_object([]) do |li, ret|
+          ret << p_unwrap(li)
+        end
+      end
+
+      def add_to_hash(bib, key, val)
+        Metanorma::Utils::set_nested_value(bib, key.split("."), val)
+      end
+
+      # definition list, with at most one level of unordered lists
+      def dl_bib_extract(clause, nested = false)
+        dl = clause.at("./dl") or return
+        key = ""
+        bib = dl.xpath("./dt | ./dd").each_with_object({}) do |dtd, m|
+          (dtd.name == "dt" and key = dtd.text.sub(/:+$/, "")) or
+            add_to_hash(m, key, dd_bib_extract(dtd))
+        end
+        clause.xpath("./clause").each do |c1|
+          key = c1&.at("./title")&.text&.downcase&.strip
+          next unless %w(contributor relation series).include? key
+
+          add_to_hash(bib, key, dl_bib_extract(c1, true))
+        end
+        dl_bib_extract_title(bib, clause, nested)
+      end
+
+      def dl_bib_extract_title(bib, clause, nested)
+        (!nested && clause.at("./title")) or return bib
+        title = clause.at("./title").remove.children.to_xml
+        bib["title"] = [bib["title"]] if bib["title"].is_a?(Hash) ||
+          bib["title"].is_a?(String)
+        bib["title"] ||= []
+        bib["title"] << title if !title.empty?
+        bib
+      end
+
+      # ---
+
+      def formattedref_spans(xmldoc)
+        xmldoc.xpath("//bibitem[formattedref//span]").each do |b|
+          spans_to_bibitem(b, spans_preprocess(extract_content(b)))
+        end
+      end
+
+      def extract_content(bib)
+        extract_docid(bib) + extract_spans(bib)
+      end
+
+      def extract_spans(bib)
+        bib.xpath("./formattedref//span").each_with_object([]) do |s, m|
+          keys = s["class"].split(".", 2)
+          m << { key: keys[0], type: keys[1],
+                 val: s.children.to_xml }
+          (s["class"] == "type" and s.remove) or s.replace(s.children)
+        end
+      end
+
+      def extract_docid(bib)
+        bib.xpath("./docidentifier").each_with_object([]) do |d, m|
+          m << { key: "docid", type: d["type"], val: d.text }
+          d.remove
+        end
+      end
+
+      def spans_preprocess(spans)
+        ret = { contributor: [], docid: [], uri: [], date: [] }
+        spans.each do |s|
+          case s[:key]
+          when "uri", "docid"
+            ret[s[:key].to_sym] << { type: s[:type], val: s[:val] }
+          when "pubyear" then ret[:date] << { type: "published", val: s[:val] }
+          when "pubplace", "title", "type" then ret[s[:key].to_sym] = s[:val]
+          when "publisher"
+            ret[:contributor] << { role: "publisher", entity: "organization",
+                                   name: s[:val] }
+          when "surname", "initials", "givenname", "formatted-initials"
+            ret[:contributor] = spans_preprocess_contrib(s, ret[:contributor])
+          end
+        end
+        ret
+      end
+
+      def spans_preprocess_contrib(span, contrib)
+        span[:key] = "formatted-initials" if span[:key] == "initials"
+
+        spans_preprocess_new_contrib?(span, contrib) and
+          contrib << { role: span[:type] || "author", entity: "person" }
+        contrib[-1][span[:key].to_sym] = span[:val]
+        contrib
+      end
+
+      def spans_preprocess_new_contrib?(span, contrib)
+        contrib.empty? ||
+          (if span[:key] == "surname" then contrib[-1][:surname]
+           else (contrib[-1][:"formatted-initials"] || contrib[-1][:givenname])
+           end) ||
+          contrib[-1][:role] != (span[:type] || "author")
+      end
+
+      def spans_to_bibitem(bib, spans)
+        ret = ""
+        spans[:title] and ret += "<title>#{spans[:title]}</title>"
+        spans[:uri].each { |s| ret += span_to_docid(s, "uri") }
+        spans[:docid].each { |s| ret += span_to_docid(s, "docidentifier") }
+        spans[:date].each { |s| ret += span_to_docid(s, "date") }
+        spans[:contributor].each { |s| ret += span_to_contrib(s) }
+        spans[:pubplace] and ret += "<place>#{spans[:place]}</place>"
+        spans[:type] and bib["type"] = spans[:type]
+        bib << ret
+      end
+
+      def span_to_docid(span, key)
+        if span[:type]
+          "<#{key} type='#{span[:type]}'>#{span[:val]}</#{key}>"
+        else
+          "<#{key}>#{span[:val]}</#{key}>"
+        end
+      end
+
+      def span_to_contrib(span)
+        e = if span[:entity] == "organization"
+              "<organization><name>#{span[:name]}</name></organization>"
+            else span_to_person(span)
+            end
+        "<contributor><role type='#{span[:role]}'/>#{e}</contributor>"
+      end
+
+      def span_to_person(span)
+        pre = (span[:"formatted-initials"] and
+                     "<formatted-initials>"\
+                     "#{span[:"formatted-initials"]}</formatted-initials>") ||
+          "<forename>#{span[:givenname]}</forename>"
+        "<person><name>#{pre}<surname>#{span[:surname]}</surname></name>"\
+          "</person>"
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/cleanup_block.rb

@@ -45,7 +45,8 @@ module Metanorma
 
       def figure_dl_cleanup1(xmldoc)
         q = "//figure/following-sibling::*[self::dl]"
-        xmldoc.xpath(q).each do |s|
+        q1 = "//figure/figure/following-sibling::*[self::dl]"
+        (xmldoc.xpath(q) - xmldoc.xpath(q1)).each do |s|
           s["key"] == "true" and s.previous_element << s.remove
         end
       end
@@ -65,8 +66,9 @@ module Metanorma
       # examples containing only figures become subfigures of figures
       def subfigure_cleanup(xmldoc)
         xmldoc.xpath("//example[figure]").each do |e|
-          next unless e.elements.map(&:name).reject do |m|
-            %w(name figure index).include? m
+          next unless e.elements.reject do |m|
+            %w(name figure index note).include?(m.name) ||
+              (m.name == "dl" && m["key"] == "true")
           end.empty?
 
           e.name = "figure"
@@ -84,9 +86,9 @@ module Metanorma
 
       def figure_cleanup(xmldoc)
         figure_footnote_cleanup(xmldoc)
+        subfigure_cleanup(xmldoc)
         figure_dl_cleanup1(xmldoc)
         figure_dl_cleanup2(xmldoc)
-        subfigure_cleanup(xmldoc)
         single_subfigure_cleanup(xmldoc)
       end
 

data/lib/metanorma/standoc/cleanup_maths.rb

@@ -1,24 +1,11 @@
-require "nokogiri"
-require "pathname"
-require "html2doc"
 require "asciimath2unitsml"
-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 Metanorma
   module Standoc
     module Cleanup
       def asciimath2mathml(text)
         text = text.gsub(%r{<stem type="AsciiMath">(.+?)</stem>}m) do
-          "<amathstem>#{HTMLEntities.new.decode($1)}</amathstem>"
+          "<amathstem>#{@c.decode($1)}</amathstem>"
         end
         text = Html2Doc.new({})
           .asciimath_to_mathml(text, ["<amathstem>", "</amathstem>"])
@@ -60,7 +47,7 @@ module Metanorma
       def mathml_italicise(xml)
         xml.xpath(".//m:mi[not(ancestor::*[@mathvariant])]",
                   "m" => MATHML_NS).each do |i|
-          char = HTMLEntities.new.decode(i.text)
+          char = @c.decode(i.text)
           i["mathvariant"] = "normal" if mi_italicise?(char)
         end
       end

data/lib/metanorma/standoc/cleanup_ref.rb

@@ -153,29 +153,28 @@ module Metanorma
 
       def reference_names(xmldoc)
         xmldoc.xpath("//bibitem[not(ancestor::bibitem)]").each do |ref|
-          docid = ref.at("./docidentifier[@type = 'metanorma']") ||
-            ref.at("./docidentifier[@primary = 'true'][@language = '#{@lang}']") ||
-            ref.at("./docidentifier[@primary = 'true'][not(@language)]") ||
-            ref.at("./docidentifier[@primary = 'true']") ||
-            ref.at("./docidentifier[not(@type = 'DOI')][@language = '#{@lang}']") ||
-            ref.at("./docidentifier[not(@type = 'DOI')][not(@language)]") ||
-            ref.at("./docidentifier[not(@type = 'DOI')]") or next
+          docid = select_docid(ref) or next
           reference = format_ref(docid.children.to_xml, docid["type"])
           @anchors[ref["id"]] = { xref: reference }
         end
       end
 
+      def select_docid(ref)
+        ref.at("./docidentifier[@type = 'metanorma']") ||
+          ref.at("./docidentifier[@primary = 'true'][@language = '#{@lang}']") ||
+          ref.at("./docidentifier[@primary = 'true'][not(@language)]") ||
+          ref.at("./docidentifier[@primary = 'true']") ||
+          ref.at("./docidentifier[not(@type = 'DOI')][@language = '#{@lang}']") ||
+          ref.at("./docidentifier[not(@type = 'DOI')][not(@language)]") ||
+          ref.at("./docidentifier[not(@type = 'DOI')]")
+      end
+
       def fetch_termbase(_termbase, _id)
         ""
       end
 
       def read_local_bibitem(uri)
-        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"))
+        xml = read_local_bibitem_file(uri) or return nil
         ret = xml.at("//*[local-name() = 'bibdata']") or return nil
         ret = Nokogiri::XML(ret.to_xml
           .sub(%r{(<bibdata[^>]*?) xmlns=("[^"]+"|'[^']+')}, "\\1")).root
@@ -186,6 +185,15 @@ module Metanorma
         ret
       end
 
+      def read_local_bibitem_file(uri)
+        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
+        Nokogiri::XML(File.read(file, encoding: "utf-8"))
+      end
+
       # if citation uri points to local file, get bibitem from it
       def fetch_local_bibitem(xmldoc)
         xmldoc.xpath("//bibitem[formattedref][uri[@type = 'citation']]")
@@ -206,6 +214,7 @@ module Metanorma
       def bibitem_cleanup(xmldoc)
         bibitem_nested_id(xmldoc)
         ref_dl_cleanup(xmldoc)
+        formattedref_spans(xmldoc)
         fetch_local_bibitem(xmldoc)
       end
     end

data/lib/metanorma/standoc/cleanup_reqt.rb

@@ -2,109 +2,9 @@ module Metanorma
   module Standoc
     module Cleanup
       def requirement_cleanup(xmldoc)
-        requirement_metadata(xmldoc)
-        requirement_inherit(xmldoc)
-        requirement_descriptions(xmldoc)
-      end
-
-      REQRECPER = "//requirement | //recommendation | //permission".freeze
-
-      def requirement_inherit(xmldoc)
-        xmldoc.xpath(REQRECPER).each do |r|
-          ins = requirement_inherit_insert(r)
-          r.xpath("./*//inherit").each { |i| ins.previous = i }
-        end
-      end
-
-      def requirement_inherit_insert(reqt)
-        ins = reqt.at("./classification") || reqt.at(
-          "./description | ./measurementtarget | ./specification | "\
-          "./verification | ./import | ./description | ./component | "\
-          "./requirement | ./recommendation | ./permission",
-        ) and return ins
-        requirement_inherit_insert1(reqt)
-      end
-
-      def requirement_inherit_insert1(reqt)
-        if t = reqt.at("./title")
-          t.next = " "
-          t.next
-        else
-          if reqt.children.empty? then reqt.add_child(" ")
-          else reqt.children.first.previous = " "
-          end
-          reqt.children.first
-        end
-      end
-
-      def requirement_descriptions(xmldoc)
-        xmldoc.xpath(REQRECPER).each do |r|
-          r.xpath(".//p[not(./*)][normalize-space(.)='']").each(&:remove)
-          r.children.each do |e|
-            requirement_description_wrap(r, e)
-          end
-          requirement_description_cleanup1(r)
-        end
-      end
-
-      def requirement_description_wrap(reqt, text)
-        return if (text.element? && (reqt_subpart(text.name) ||
-                %w(requirement recommendation
-                   permission).include?(text.name))) ||
-          (text.text.strip.empty? && !text.at(".//xref | .//eref | .//link"))
-
-        t = Nokogiri::XML::Element.new("description", reqt.document)
-        text.before(t)
-        t.children = text.remove
-      end
-
-      def requirement_description_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
-
-      def requirement_metadata(xmldoc)
-        xmldoc.xpath(REQRECPER).each do |r|
-          dl = r&.at("./dl[@metadata = 'true']")&.remove or next
-          requirement_metadata1(r, dl, r.at("./title"))
-        end
-      end
-
-      def requirement_metadata1_tags
-        %w(label subject inherit)
-      end
-
-      def requirement_metadata1(reqt, dlist, ins)
-        unless ins
-          reqt.children.first.previous = " "
-          ins = reqt.children.first
-        end
-        %w(obligation model type).each do |a|
-          dl_to_attrs(reqt, dlist, a)
-        end
-        requirement_metadata1_tags.each do |a|
-          ins = dl_to_elems(ins, reqt, dlist, a)
-        end
-        reqt_dl_to_classif(ins, reqt, dlist)
-      end
-
-      def reqt_dl_to_classif(ins, reqt, dlist)
-        if a = reqt.at("./classification[last()]") then ins = a end
-        dlist.xpath("./dt[text()='classification']").each do |e|
-          val = e.at("./following::dd/p") || e.at("./following::dd")
-          req_classif_parse(val.text).each do |r|
-            ins.next = "<classification><tag>#{r[0]}</tag>"\
-                       "<value>#{r[1]}</value></classification>"
-            ins = ins.next
-          end
-        end
-        ins
+        @reqt_models ||=
+          Metanorma::Requirements.new({ default: @default_requirement_model })
+        @reqt_models.requirement_cleanup(xmldoc)
       end
     end
   end

data/lib/metanorma/standoc/cleanup_symbols.rb

@@ -11,7 +11,7 @@ module Metanorma
             n.replace(grkletters(MathML2AsciiMath.m2a(n.to_xml)))
         end
         ret = Nokogiri::XML(key.to_xml)
-        HTMLEntities.new.decode(ret.text.downcase)
+        @c.decode(ret.text.downcase)
           .gsub(/[\[\]{}<>()]/, "").gsub(/\s/m, "")
           .gsub(/[[:punct:]]|[_^]/, ":\\0").gsub(/`/, "")
           .gsub(/[0-9]+/, "þ\\0")

data/lib/metanorma/standoc/cleanup_text.rb

@@ -7,7 +7,7 @@ module Metanorma
         text = text.gsub(/\s+<fn /, "<fn ")
         %w(passthrough passthrough-inline).each do |v|
           text.gsub!(%r{<#{v}\s+formats="metanorma">([^<]*)
-                    </#{v}>}mx) { HTMLEntities.new.decode($1) }
+                    </#{v}>}mx) { @c.decode($1) }
         end
         text
       end
@@ -34,11 +34,13 @@ module Metanorma
         end
       end
 
+      IGNORE_QUOTES_ELEMENTS =
+        %w(pre tt sourcecode stem figure bibdata passthrough identifier).freeze
+
       def uninterrupt_quotes_around_xml_skip(elem)
         !(/\A['"]/.match?(elem.text) &&
-          elem.previous.ancestors("pre, tt, sourcecode, stem, figure, bibdata,
-                                  passthrough, identifer")
-          .empty? &&
+          elem.previous.path.split(%r{/})[1..-2]
+          .intersection(IGNORE_QUOTES_ELEMENTS).empty? &&
           ((elem.previous.text.strip.empty? &&
             !empty_tag_with_text_content?(elem.previous)) ||
            elem.previous.name == "index"))
@@ -49,7 +51,7 @@ module Metanorma
         /\S\Z/.match?(prev.text) or return
         foll = elem.at(".//following::text()[1]")
         m = /\A(["'][[:punct:]]*)(\s|\Z)/
-          .match(HTMLEntities.new.decode(foll&.text)) or return
+          .match(@c.decode(foll&.text)) or return
         foll.content = foll.text.sub(/\A(["'][[:punct:]]*)/, "")
         prev.content = "#{prev.text}#{m[1]}"
       end
@@ -74,10 +76,10 @@ module Metanorma
           empty_tag_with_text_content?(x) and prev = "dummy"
           next unless x.text?
 
-          x.ancestors("pre, tt, sourcecode, stem, figure, bibdata, passthrough,
-                      identifier").empty? and
+          ancestors = x.path.split(%r{/})[1..-2]
+          ancestors.intersection(IGNORE_QUOTES_ELEMENTS).empty? and
             dumb2smart_quotes1(x, prev)
-          prev = x.text if x.ancestors("index").empty?
+          prev = x.text unless ancestors.include?("index")
         end
       end
 

data/lib/metanorma/standoc/cleanup_xref.rb

@@ -68,10 +68,9 @@ module Metanorma
       end
 
       def xref_to_eref(elem)
-        c = HTMLEntities.new
         elem["bibitemid"] = elem["target"]
         if ref = @anchors&.dig(elem["target"], :xref)
-          elem["citeas"] = c.decode(ref)
+          elem["citeas"] = @c.decode(ref)
         else
           elem["citeas"] = ""
           xref_to_eref1(elem)