isodoc 2.3.6 → 2.4.1

data/lib/isodoc/presentation_function/block.rb

@@ -1,4 +1,5 @@
 require_relative "./image"
+require "rouge"
 
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
@@ -25,24 +26,106 @@ module IsoDoc
       end
     end
 
+    def sourcehighlighter_theme
+      "igorpro"
+    end
+
+    def sourcehighlighter_css(docxml)
+      @sourcehighlighter or return
+      ins = docxml.at(ns("//misc-container")) ||
+        docxml.at(ns("//bibdata")).after("<misc-container/>").next_element
+      x = Rouge::Theme.find(sourcehighlighter_theme)
+        .render(scope: "sourcecode")
+      ins << "<source-highlighter-css>#{x}</source-highlighter-css>"
+    end
+
+    def sourcehighlighter
+      @sourcehighlighter or return
+      f = Rouge::Formatters::HTML.new
+      { formatter: f,
+        formatter_line: Rouge::Formatters::HTMLTable.new(f, {}) }
+    end
+
     def sourcecode(docxml)
+      sourcehighlighter_css(docxml)
+      @highlighter = sourcehighlighter
       docxml.xpath(ns("//sourcecode")).each do |f|
         sourcecode1(f)
       end
     end
 
     def sourcecode1(elem)
-      return if labelled_ancestor(elem)
+      source_highlight(elem)
+      source_label(elem)
+    end
+
+    def source_highlight(elem)
+      @highlighter or return
+      markup = source_remove_markup(elem)
+      p = source_lex(elem)
+      wrapper, code =
+        if elem["linenums"] == "true" then sourcecode_table_to_elem(elem, p)
+        else
+          r = Nokogiri::XML.fragment(@highlighter[:formatter].format(p))
+          [r, r]
+        end
+      elem.children = source_restore_markup(wrapper, code, markup)
+    end
+
+    def source_remove_markup(elem)
+      ret = {}
+      name = elem.at(ns("./name")) and ret[:name] = name.remove.to_xml
+      ret[:ann] = elem.xpath(ns("./annotation")).each(&:remove)
+      ret[:call] = elem.xpath(ns("./callout")).each_with_object([]) do |c, m|
+        m << { xml: c.remove.to_xml, line: c.line - elem.line }
+      end
+      ret
+    end
+
+    def source_restore_markup(wrapper, code, markup)
+      text = source_restore_callouts(code, markup[:call])
+      ret = if code == wrapper
+              text
+            else
+              code.replace(text)
+              to_xml(wrapper)
+            end
+      "#{markup[:name]}#{ret}#{markup[:ann]}"
+    end
+
+    def source_restore_callouts(code, callouts)
+      text = to_xml(code)
+      text.split(/[\n\r]/).each_with_index do |c, i|
+        while !callouts.empty? && callouts[0][:line] == i
+          c.sub!(/\s+$/, " #{callouts[0][:xml]} ")
+          callouts.shift
+        end
+      end.join("\n")
+    end
 
+    def sourcecode_table_to_elem(elem, tokens)
+      r = Nokogiri::XML(@highlighter[:formatter_line].format(tokens)).root
+      pre = r.at(".//td[@class = 'rouge-code']/pre")
+      %w(style).each { |n| elem[n] and pre[n] = elem[n] }
+      pre.name = "sourcecode"
+      [r, pre]
+    end
+
+    def source_lex(elem)
+      l = (Rouge::Lexer.find(elem["lang"] || "plaintext") ||
+       Rouge::Lexer.find("plaintext"))
+      l.lex(@c.decode(elem.children.to_xml))
+    end
+
+    def source_label(elem)
+      labelled_ancestor(elem) and return
       lbl = @xrefs.anchor(elem["id"], :label, false) or return
       prefix_name(elem, block_delim,
                   l10n("#{lower2cap @i18n.figure} #{lbl}"), "name")
     end
 
     def formula(docxml)
-      docxml.xpath(ns("//formula")).each do |f|
-        formula1(f)
-      end
+      docxml.xpath(ns("//formula")).each { |f| formula1(f) }
     end
 
     def formula1(elem)
@@ -51,48 +134,38 @@ module IsoDoc
     end
 
     def example(docxml)
-      docxml.xpath(ns("//example")).each do |f|
-        example1(f)
-      end
+      docxml.xpath(ns("//example")).each { |f| example1(f) }
     end
 
     def example1(elem)
       n = @xrefs.get[elem["id"]]
       lbl = if n.nil? || n[:label].nil? || n[:label].empty?
               @i18n.example
-            else
-              l10n("#{@i18n.example} #{n[:label]}")
+            else l10n("#{@i18n.example} #{n[:label]}")
             end
       prefix_name(elem, block_delim, lbl, "name")
     end
 
     def note(docxml)
-      docxml.xpath(ns("//note")).each do |f|
-        note1(f)
-      end
+      docxml.xpath(ns("//note")).each { |f| note1(f) }
     end
 
     def note1(elem)
-      return if elem.parent.name == "bibitem" || elem["notag"] == "true"
-
+      elem.parent.name == "bibitem" || elem["notag"] == "true" and return
       n = @xrefs.get[elem["id"]]
       lbl = if n.nil? || n[:label].nil? || n[:label].empty?
               @i18n.note
-            else
-              l10n("#{@i18n.note} #{n[:label]}")
+            else l10n("#{@i18n.note} #{n[:label]}")
             end
       prefix_name(elem, "", lbl, "name")
     end
 
     def admonition(docxml)
-      docxml.xpath(ns("//admonition")).each do |f|
-        admonition1(f)
-      end
+      docxml.xpath(ns("//admonition")).each { |f| admonition1(f) }
     end
 
     def admonition1(elem)
-      return if elem.at(ns("./name")) || elem["notag"] == "true"
-
+      elem.at(ns("./name")) || elem["notag"] == "true" and return
       prefix_name(elem, "", @i18n.admonition[elem["type"]]&.upcase, "name")
     end
 
@@ -121,15 +194,12 @@ module IsoDoc
     end
 
     def table(docxml)
-      docxml.xpath(ns("//table")).each do |f|
-        table1(f)
-      end
+      docxml.xpath(ns("//table")).each { |f| table1(f) }
     end
 
     def table1(elem)
-      return if labelled_ancestor(elem)
-      return if elem["unnumbered"] && !elem.at(ns("./name"))
-
+      labelled_ancestor(elem) and return
+      elem["unnumbered"] && !elem.at(ns("./name")) and return
       n = @xrefs.anchor(elem["id"], :label, false)
       prefix_name(elem, block_delim, l10n("#{lower2cap @i18n.table} #{n}"),
                   "name")
@@ -137,9 +207,7 @@ module IsoDoc
 
     # we use this to eliminate the semantic amend blocks from rendering
     def amend(docxml)
-      docxml.xpath(ns("//amend")).each do |f|
-        amend1(f)
-      end
+      docxml.xpath(ns("//amend")).each { |f| amend1(f) }
     end
 
     def amend1(elem)
@@ -150,9 +218,7 @@ module IsoDoc
     end
 
     def ol(docxml)
-      docxml.xpath(ns("//ol")).each do |f|
-        ol1(f)
-      end
+      docxml.xpath(ns("//ol")).each { |f| ol1(f) }
       @xrefs.list_anchor_names(docxml.xpath(ns(@xrefs.sections_xpath)))
     end
 

data/lib/isodoc/presentation_function/erefs.rb

@@ -9,7 +9,7 @@ module IsoDoc
 
     def erefstack1(elem)
       locs = elem.xpath(ns("./eref")).map do |e|
-        [e["connective"], e.to_xml]
+        [e["connective"], to_xml(e)]
       end.flatten
       ret = resolve_eref_connectives(locs)
       elem.replace(ret[1])
@@ -30,9 +30,9 @@ module IsoDoc
       ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
                                                           node))
       node.delete("droploc") unless droploc
-      eref_localities1(target,
-                       refs.first.at(ns("./locality/@type")).text,
-                       l10n(ret[1..-1].join), nil, node, @lang)
+      eref_localities1({ target: target, number: "pl",
+                         type: refs.first.at(ns("./locality/@type")).text,
+                         from: l10n(ret[1..-1].join), node: node, lang: @lang })
     end
 
     def can_conflate_eref_rendering?(refs)
@@ -61,19 +61,24 @@ module IsoDoc
       locs1 = []
       add = ""
       until locs.empty?
-        if [", ", " "].include?(locs[1])
-          add += locs[0..2].join
-          locs.shift(3)
-        else
-          locs1 << add unless add.empty?
-          add = ""
-          locs1 << locs.shift
-        end
+        locs, locs1, add = resolve_comma_connectives1(locs, locs1, add)
       end
       locs1 << add unless add.empty?
       locs1
     end
 
+    def resolve_comma_connectives1(locs, locs1, add)
+      if [", ", " "].include?(locs[1])
+        add += locs[0..2].join
+        locs.shift(3)
+      else
+        locs1 << add unless add.empty?
+        add = ""
+        locs1 << locs.shift
+      end
+      [locs, locs1, add]
+    end
+
     def resolve_to_connectives(locs)
       locs1 = []
       until locs.empty?
@@ -108,12 +113,7 @@ module IsoDoc
     def eref_locality_stack(ref, idx, target, node)
       ret = []
       if ref.name == "localityStack"
-        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 = eref_locality_stack1(ref, target, node, ret)
       else
         l = eref_localities0(ref, idx, target, node) and ret << l
       end
@@ -121,6 +121,15 @@ module IsoDoc
       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
@@ -128,38 +137,43 @@ module IsoDoc
     def eref_localities0(ref, _idx, target, node)
       if ref["type"] == "whole" then @i18n.wholeoftext
       else
-        eref_localities1(target, ref["type"],
-                         ref&.at(ns("./referenceFrom"))&.text,
-                         ref&.at(ns("./referenceTo"))&.text, node, @lang)
+        eref_localities1({ target: target, type: ref["type"], number: "sg",
+                           from: ref.at(ns("./referenceFrom"))&.text,
+                           upto: ref.at(ns("./referenceTo"))&.text, node: node,
+                           lang: @lang })
       end
     end
 
-    def eref_localities1_zh(_target, type, from, upto, node)
-      ret = "第#{from}" if from
-      ret += "&#x2013;#{upto}" if upto
-      loc = eref_locality_populate(type, node)
-      ret += " #{loc}" unless node["droploc"] == "true"
+    # def eref_localities1_zh(_target, type, from, upto, node)
+    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(target, type, from, upto, node, lang = "en")
-      return nil if type == "anchor"
+    # def eref_localities1(target, type, from, upto, node, lang = "en")
+    def eref_localities1(opt)
+      return nil if opt[:type] == "anchor"
 
-      lang == "zh" and
-        return l10n(eref_localities1_zh(target, type, from, upto, node))
-      ret = eref_locality_populate(type, node)
-      ret += " #{from}" if from
-      ret += "&#x2013;#{upto}" if upto
+      opt[:lang] == "zh" and
+        # return l10n(eref_localities1_zh(target, type, from, upto, node))
+        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)
+    def eref_locality_populate(type, node, number)
       return "" if node["droploc"] == "true"
 
       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 loc.downcase
+            when "lowercase" then ret.downcase
             else Metanorma::Utils.strict_capitalize_first(ret)
             end
       " #{ret}"

data/lib/isodoc/presentation_function/refs.rb

@@ -20,7 +20,7 @@ module IsoDoc
       d.remove_namespaces!
       refs = d.xpath("//references/bibitem").each_with_object([]) do |b, m|
         prep_for_rendering(b)
-        m << b.to_xml
+        m << to_xml(b)
       end.join
       bibrenderer.render_all("<references>#{refs}</references>",
                              type: citestyle)
@@ -49,8 +49,8 @@ module IsoDoc
     def bibrender_relaton(xml, renderings)
       f = renderings[xml["id"]][:formattedref]
       f &&= "<formattedref>#{f}</formattedref>"
-      xml.children =
-        "#{f}#{xml.xpath(ns('./docidentifier | ./uri | ./note')).to_xml}"
+      x = xml.xpath(ns("./docidentifier | ./uri | ./note | ./biblio-tag"))
+      xml.children = "#{f}#{x.to_xml}"
     end
 
     def bibrenderer
@@ -74,6 +74,7 @@ module IsoDoc
         i = bibliography_bibitem_number1(b, i)
       end
       @xrefs.references docxml
+      bibliography_bibitem_tag(docxml)
     end
 
     def bibliography_bibitem_number1(bibitem, idx)
@@ -99,8 +100,79 @@ module IsoDoc
 
     def docid_prefixes(docxml)
       docxml.xpath(ns("//references/bibitem/docidentifier")).each do |i|
-        i.children = @xrefs.klass.docid_prefix(i["type"], i.text)
+        i.children = @xrefs.klass.docid_prefix(i["type"], to_xml(i.children))
       end
     end
+
+    def bibliography_bibitem_tag(docxml)
+      [true, false].each do |norm|
+        i = 0
+        docxml.xpath(ns("//references[@normative = '#{norm}']")).each do |r|
+          i = bibliography_bibitem_tag1(r, i, norm)
+        end
+      end
+    end
+
+    def bibliography_bibitem_tag1(ref, idx, norm)
+      ref.xpath(ns("./bibitem")).each do |b|
+        @xrefs.klass.implicit_reference(b) and next
+        idx += 1 unless b["hidden"]
+        insert_biblio_tag(b, idx, !norm, @xrefs.klass.standard?(b))
+      end
+      idx
+    end
+
+    def insert_biblio_tag(bib, ordinal, biblio, standard)
+      datefn = date_note_process(bib)
+      ids = @xrefs.klass.bibitem_ref_code(bib)
+      idents = @xrefs.klass.render_identifier(ids)
+      ret = if biblio then biblio_ref_entry_code(ordinal, idents, ids,
+                                                 standard, datefn)
+            else norm_ref_entry_code(ordinal, idents, ids, standard, datefn)
+            end
+      bib << "<biblio-tag>#{ret}</biblio-tag>"
+    end
+
+    def norm_ref_entry_code(_ordinal, idents, _ids, _standard, datefn)
+      ret = (idents[:ordinal] || idents[:metanorma] || idents[:sdo]).to_s
+      (idents[:ordinal] || idents[:metanorma]) && idents[:sdo] and
+        ret += ", #{idents[:sdo]}"
+      ret += datefn
+      ret.empty? and return ret
+      idents[:sdo] and ret += ","
+      "#{ret} "
+    end
+
+    # if ids is just a number, only use that ([1] Non-Standard)
+    # else, use both ordinal, as prefix, and ids
+    def biblio_ref_entry_code(ordinal, ids, _id, standard, datefn)
+      standard and id = nil
+      ret = (ids[:ordinal] || ids[:metanorma] || "[#{ordinal}]")
+      if ids[:sdo]
+        ret = prefix_bracketed_ref(ret)
+        ret += "#{ids[:sdo]}#{datefn}, "
+      else
+        ret = prefix_bracketed_ref("#{ret}#{datefn}")
+      end
+      ret
+    end
+
+    def prefix_bracketed_ref(text)
+      "#{text}<tab/>"
+    end
+
+    # strip any fns in docidentifier before they are extracted for rendering
+    def date_note_process(bib)
+      ret = ident_fn(bib)
+      date_note = bib.at(ns("./note[@type = 'Unpublished-Status']"))
+      date_note.nil? and return ret
+      id = UUIDTools::UUID.random_create.to_s
+      "#{ret}<fn reference='#{id}'><p>#{date_note.content}</p></fn>"
+    end
+
+    def ident_fn(bib)
+      ret = bib.at(ns("./docidentifier//fn")) or return ""
+      to_xml(ret.remove)
+    end
   end
 end

data/lib/isodoc/presentation_function/section.rb

@@ -55,7 +55,7 @@ module IsoDoc
     def annex1(elem)
       lbl = @xrefs.anchor(elem["id"], :label)
       if t = elem.at(ns("./title"))
-        t.children = "<strong>#{t.children.to_xml}</strong>"
+        t.children = "<strong>#{to_xml(t.children)}</strong>"
       end
       prefix_name(elem, "<br/><br/>", lbl, "title")
     end

data/lib/isodoc/presentation_function/terms.rb

@@ -1,17 +1,19 @@
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
     def concept(docxml)
+      @definition_ids = docxml.xpath(ns("//definitions//dt"))
+        .each_with_object({}) { |x, m| m[x["id"]] = true }
       docxml.xpath(ns("//concept")).each { |f| concept1(f) }
     end
 
     def concept1(node)
       xref = node&.at(ns("./xref/@target"))&.text or
-        return concept_render(node, ital: "true", ref: "true",
+        return concept_render(node, ital: "true", ref: "true", bold: "false",
                                     linkref: "true", linkmention: "false")
-      if node.at(ns("//definitions//dt[@id = '#{xref}']"))
-        concept_render(node, ital: "false", ref: "false",
+      if @definition_ids[xref]
+        concept_render(node, ital: "false", ref: "false", bold: "false",
                              linkref: "true", linkmention: "false")
-      else concept_render(node, ital: "true", ref: "true",
+      else concept_render(node, ital: "true", ref: "true", bold: "false",
                                 linkref: "true", linkmention: "false")
       end
     end
@@ -20,21 +22,23 @@ module IsoDoc
       opts, render, ref = concept_render_init(node, defaults)
       node&.at(ns("./refterm"))&.remove
       ref && opts[:ref] != "false" and render&.next = " "
-      opts[:ital] == "true" and render&.name = "em"
       concept1_linkmention(ref, render, opts)
       concept1_ref(node, ref, opts)
-      concept1_nonital(node, opts)
-      node.replace(node.children.to_xml.strip)
+      concept1_style(node, opts)
+      node.replace(node.children)
     end
 
-    def concept1_nonital(node, opts)
-      opts[:ital] == "false" or return
-      r = node.at(ns(".//renderterm"))
-      r&.replace(r&.children)
+    def concept1_style(node, opts)
+      r = node.at(ns(".//renderterm")) or return
+      opts[:ital] == "true" and r.children = "<em>#{to_xml(r.children)}</em>"
+      opts[:bold] == "true" and
+        r.children = "<strong>#{to_xml(r.children)}</strong>"
+      r.replace(r.children)
     end
 
     def concept_render_init(node, defaults)
-      opts = %i(ital ref linkref linkmention).each_with_object({}) do |x, m|
+      opts = %i(bold ital ref linkref linkmention)
+        .each_with_object({}) do |x, m|
         m[x] = node[x.to_s] || defaults[x]
       end
       [opts, node.at(ns("./renderterm")),
@@ -42,7 +46,8 @@ module IsoDoc
     end
 
     def concept1_linkmention(ref, renderterm, opts)
-      return unless opts[:linkmention] == "true" && !renderterm.nil? && !ref.nil?
+      return unless opts[:linkmention] == "true" &&
+        !renderterm.nil? && !ref.nil?
 
       ref2 = ref.clone
       r2 = renderterm.clone
@@ -68,8 +73,8 @@ module IsoDoc
            !c.text? || /\S/.match(c)
          end.empty?
         ref.replace(@i18n.term_defined_in.sub(/%/,
-                                              ref.to_xml))
-      else ref.replace("[#{ref.to_xml}]")
+                                              to_xml(ref)))
+      else ref.replace("[#{to_xml(ref)}]")
       end
     end
 
@@ -83,7 +88,7 @@ module IsoDoc
       label = @i18n.relatedterms[node["type"]].upcase
       if p && ref
         node.replace(l10n("<p><strong>#{label}:</strong> " \
-                          "<em>#{p.to_xml}</em> (#{ref.to_xml})</p>"))
+                          "<em>#{to_xml(p)}</em> (#{Common::to_xml(ref)})</p>"))
       else
         node.replace(l10n("<p><strong>#{label}:</strong> " \
                           "<strong>**RELATED TERM NOT FOUND**</strong></p>"))
@@ -110,7 +115,7 @@ module IsoDoc
       if merge_preferred_eligible?(pref, second)
         n1 = pref.at(ns("./expression/name"))
         n2 = second.remove.at(ns("./expression/name"))
-        n1.children = l10n("#{n1.children.to_xml}; #{n2.children.to_xml}")
+        n1.children = l10n("#{to_xml(n1.children)}; #{Common::to_xml(n2.children)}")
       end
     end
 
@@ -150,7 +155,7 @@ module IsoDoc
 
     def designation_field(desgn, name)
       f = desgn.xpath(ns("./field-of-application | ./usage-info"))
-        &.map { |u| u.children.to_xml }&.join(", ")
+        &.map { |u| to_xml(u.children) }&.join(", ")
       return nil if f&.empty?
 
       name << ", &#x3c;#{f}&#x3e;"
@@ -181,7 +186,7 @@ module IsoDoc
     def designation_pronunciation(desgn, name)
       f = desgn.at(ns("./expression/pronunciation")) or return
 
-      name << ", /#{f.children.to_xml}/"
+      name << ", /#{to_xml(f.children)}/"
     end
 
     def termexample(docxml)
@@ -214,9 +219,9 @@ module IsoDoc
 
     def multidef(elem)
       d = elem.at(ns("./definition"))
-      d = d.replace("<ol><li>#{d.children.to_xml}</li></ol>").first
+      d = d.replace("<ol><li>#{to_xml(d.children)}</li></ol>").first
       elem.xpath(ns("./definition")).each do |f|
-        f = f.replace("<li>#{f.children.to_xml}</li>").first
+        f = f.replace("<li>#{to_xml(f.children)}</li>").first
         d << f
       end
       d.wrap("<definition></definition>")
@@ -242,9 +247,9 @@ module IsoDoc
 
     def termsource1(elem)
       while elem&.next_element&.name == "termsource"
-        elem << "; #{elem.next_element.remove.children.to_xml}"
+        elem << "; #{to_xml(elem.next_element.remove.children)}"
       end
-      elem.children = l10n("[#{@i18n.source}: #{elem.children.to_xml.strip}]")
+      elem.children = l10n("[#{@i18n.source}: #{to_xml(elem.children).strip}]")
     end
 
     def termsource_modification(mod)

data/lib/isodoc/presentation_function/xrefs.rb

@@ -38,14 +38,23 @@ module IsoDoc
     def anchor_xref(node, target)
       x = @xrefs.anchor(target, :xref)
       t = @xrefs.anchor(target, :title)
-      if node["style"] == "basic" && t then t
-      elsif node["style"] == "full" && t
-        l10n("#{x}, #{t}")
-      else x
-      end
+      ret = case node["style"]
+            when "basic" then t
+            when "full" then anchor_xref_full(x, t)
+            when "short", nil then x
+            else @xrefs.anchor(target, node[:style].to_sym)
+            end
+      ret || x
+    end
+
+    def anchor_xref_full(num, title)
+      (!title.nil? && !title.empty?) or return nil
+
+      l10n("#{num}, #{title}")
     end
 
     def prefix_container?(container, node)
+      node["style"] == "modspec" and return false # TODO: move to mn-requirements?
       type = @xrefs.anchor(node["target"], :type)
       container &&
         get_note_container_id(node, type) != container &&
@@ -66,8 +75,8 @@ module IsoDoc
     def combine_conflated_xref_locations(locs)
       out = locs.each { |l| l[:label] = anchor_value(l[:target]) }
       label = @i18n.inflect(locs.first[:elem], number: "pl")
-      ret = l10n("#{label} #{combine_conn(out)}")
-      combine_conflated_xref_locations_container(locs, ret)
+      out[0][:label] = l10n("#{label} #{out[0][:label]}")
+      combine_conflated_xref_locations_container(locs, l10n(combine_conn(out)))
     end
 
     def combine_conflated_xref_locations_container(locs, ret)

data/lib/isodoc/presentation_xml_convert.rb

@@ -85,11 +85,11 @@ module IsoDoc
     end
 
     def postprocess(result, filename, _dir)
-      to_xml(result, filename)
+      to_xml_file(result, filename)
       @files_to_delete.each { |f| FileUtils.rm_rf f }
     end
 
-    def to_xml(result, filename)
+    def to_xml_file(result, filename)
       File.open(filename, "w:UTF-8") { |f| f.write(result) }
     end
   end

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "2.3.6".freeze
+  VERSION = "2.4.1".freeze
 end