isodoc 3.4.2 → 3.4.3

data/lib/isodoc/presentation_function/section_refs.rb

@@ -0,0 +1,55 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def references(docxml)
+      @ref_renderings = references_render(docxml)
+      docxml.xpath(ns("//references/bibitem")).each do |x|
+        bibitem(x, @ref_renderings)
+        reference_name(x)
+      end
+      bibliography_bibitem_number(docxml)
+      hidden_items(docxml)
+      move_norm_ref_to_sections(docxml)
+    end
+
+    def reference_names(docxml)
+      docxml.xpath(ns("//bibitem[not(ancestor::bibitem)]")).each do |ref|
+        reference_name(ref)
+      end
+    end
+
+    def reference_name(ref)
+      identifiers = render_identifier(bibitem_ref_code(ref))
+      reference = docid_l10n(identifiers[:content] || identifiers[:metanorma] ||
+                             identifiers[:sdo] || identifiers[:ordinal] ||
+                             identifiers[:doi])
+      @xrefs.get[ref["id"]] = { xref: esc(reference), type: "bibitem" }
+    end
+
+    def move_norm_ref_to_sections(docxml)
+      docxml.at(ns(@xrefs.klass.norm_ref_xpath)) or return
+      s = move_norm_ref_to_sections_insert_pt(docxml) or return
+      docxml.xpath(ns(@xrefs.klass.norm_ref_xpath)).each do |r|
+        r.at("./ancestor::xmlns:bibliography") or next
+        s << r.remove
+      end
+    end
+
+    def move_norm_ref_to_sections_insert_pt(docxml)
+      s = docxml.at(ns("//sections")) and return s
+      s = docxml.at(ns("//preface")) and
+        return s.after("<sections/>").next_element
+      docxml.at(ns("//annex | //bibliography"))&.before("<sections/>")
+        &.previous_element
+    end
+
+    def hidden_items(docxml)
+      docxml.xpath(ns("//references[bibitem/@hidden = 'true']")).each do |x|
+        x.at(ns("./bibitem[not(@hidden = 'true')]")) and next
+        x.elements.map(&:name).any? do |n|
+          !%w(title bibitem).include?(n)
+        end and next
+        x["hidden"] = "true"
+      end
+    end
+  end
+end

data/lib/isodoc/presentation_function/source.rb

@@ -0,0 +1,73 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    # TODO will go back to just one source/modification, preserving it
+    def source(docxml)
+      fmt_source(docxml)
+      docxml.xpath(ns("//fmt-source/source/modification")).each do |f|
+        source_modification(f)
+      end
+      source_types(docxml)
+      docxml.xpath(ns("//fmt-source/source")).each do |f|
+        f.replace(semx_fmt_dup(f))
+      end
+    end
+
+    def source_types(docxml)
+      docxml.xpath(ns("//table/fmt-source")).each { |f| tablesource(f) }
+      docxml.xpath(ns("//figure/fmt-source")).each { |f| figuresource(f) }
+    end
+
+    def fmt_source(docxml)
+      n = docxml.xpath(ns("//source")) - docxml.xpath(ns("//term//source")) -
+        docxml.xpath(ns("//quote/source"))
+      n.each do |s|
+        dup = s.clone
+        modification_dup_align(s, dup)
+        s.next = "<fmt-source>#{to_xml(dup)}</fmt-source>"
+      end
+    end
+
+    def tablesource(elem)
+      source1(elem, :table)
+    end
+
+    def figuresource(elem)
+      source1(elem, :figure)
+    end
+
+    def source_join_delim(_elem)
+      "; "
+    end
+
+    def source1(elem, ancestor)
+      esc_origin(elem)
+      source_elems = source1_gather(elem)
+      source_elems.each do |e|
+        esc_origin(e)
+        elem << "#{source_join_delim(elem)}#{to_xml(e.remove.children).strip}"
+      end
+      source1_label(elem, @i18n.l10n(to_xml(elem.children).strip), ancestor)
+    end
+
+    def source1_gather(elem)
+      source_elems = []
+      while elem = elem&.next_element
+        case elem.name
+        when "source"
+        when "fmt-source"
+          source_elems << elem
+        else break
+        end
+      end
+      source_elems
+    end
+
+    def source1_label(elem, sources, _ancestor)
+      elem.children = l10n("[#{@i18n.source}: #{esc sources}]")
+    end
+
+    def source_modification(mod)
+      termsource_modification(mod.parent)
+    end
+  end
+end

data/lib/isodoc/presentation_function/terms.rb

@@ -148,6 +148,12 @@ module IsoDoc
       m1.replace("<modification>#{to_xml(new_m1)}</modification>")
     end
 
+    def esc_origin(element)
+      element.xpath(ns(".//origin")).each do |origin|
+        origin.wrap("<esc></esc>")
+      end
+    end
+
     # concatenate sources. localise the concatenation, escaping the docids
     # within the concatenands
     # from punctuation localisation: l10n(<esc>A</esc>, <esc>B</esc>)
@@ -158,11 +164,7 @@ module IsoDoc
       while elem.next_element&.name == "source"
         ret << semx_fmt_dup(elem.next_element.remove)
       end
-      ret.each do |element|
-        element.xpath(ns(".//origin")).each do |origin|
-          origin.wrap("<esc></esc>")
-        end
-      end
+      ret.each { |element| esc_origin(element) }
       s = ret.map { |x| to_xml(x) }.map(&:strip)
         .join(termsource_join_delim(elem))
       termsource_label(elem, @i18n.l10n(s))

data/lib/isodoc/presentation_function/xrefs.rb

@@ -15,13 +15,13 @@ module IsoDoc
 
     def prefix_container(container, linkend, node, target)
       prefix_container?(container, node) or return linkend
-      container_container = @xrefs.anchor(container, :container, false)
-      container_label =
+      container_container = prefix_container_container(container)
+      cntnr_label =
         prefix_container(container_container,
                          anchor_xref(node, container, container: true),
                          node, target)
       l10n(connectives_spans(@i18n.nested_xref
-        .sub("%1", "<span class='fmt-xref-container'>#{esc container_label}</span>")
+        .sub("%1", "<span class='fmt-xref-container'>#{esc cntnr_label}</span>")
         .sub("%2", esc(linkend))))
     end
 
@@ -135,7 +135,8 @@ module IsoDoc
     def gather_xref_locations(node)
       node.xpath(ns("./location")).each_with_object([]) do |l, m|
         type = @xrefs.anchor(l["target"], :type)
-        m << { conn: l["connective"], target: l["target"],
+        m << { conn: l["connective"], custom: l["custom-connective"],
+               target: l["target"],
                type:, node: l, elem: @xrefs.anchor(l["target"], :elem),
                container: @xrefs.anchor(l["target"], :container, false) ||
                  %w(termnote).include?(type) }
@@ -165,14 +166,24 @@ module IsoDoc
       else
         ret = loc2xref(list[0])
         list[1..].each { |l| ret = i18n_chain_boolean(ret, l) }
+        if list[0][:conn] == "from" && list[0][:custom]
+          # TODO: languages with mandatory from, include from in chain_to
+          ret = connectives_spans("<conn>#{list[0][:custom]}</conn> ") + ret
+        end
         ret
       end
     end
 
+    def conn_sub(str, conn)
+      str.sub(%r{<conn>[^<]+</conn>}, "<conn>#{conn}</conn>")
+    end
+
     def i18n_chain_boolean(value, entry)
-      connectives_spans(@i18n.send("chain_#{entry[:conn]}")
+      ret = @i18n.send("chain_#{entry[:conn]}")
         .sub("%1", value)
-        .sub("%2", loc2xref(entry)))
+        .sub("%2", loc2xref(entry))
+      c = entry[:custom] and ret = conn_sub(ret, c)
+      connectives_spans(ret)
     end
 
     def can_conflate_xref_rendering?(locs)

data/lib/isodoc/presentation_xml_convert.rb

@@ -1,4 +1,5 @@
 require_relative "presentation_function/block"
+require_relative "presentation_function/source"
 require_relative "presentation_function/list"
 require_relative "presentation_function/reqt"
 require_relative "presentation_function/concepts"
@@ -9,6 +10,10 @@ require_relative "presentation_function/erefs"
 require_relative "presentation_function/inline"
 require_relative "presentation_function/math"
 require_relative "presentation_function/section"
+require_relative "presentation_function/section_refs"
+require_relative "presentation_function/title"
+require_relative "presentation_function/refs"
+require_relative "presentation_function/docid"
 require_relative "presentation_function/index"
 require_relative "presentation_function/bibdata"
 require_relative "presentation_function/metadata"
@@ -42,6 +47,7 @@ module IsoDoc
       @outputfile = Pathname.new(filename).basename.to_s
       docid_prefixes(docxml) # feeds @xrefs.parse citation processing
       provide_ids docxml # feeds @xrefs.parse
+      bibitem_lookup(docxml) # feeds citeas
       @xrefs.parse docxml
       @xrefs.klass.meta = @meta
       counter_init
@@ -54,7 +60,7 @@ module IsoDoc
     def bibitem_lookup(docxml)
       @bibitem_lookup ||= docxml.xpath(ns("//references/bibitem"))
         .each_with_object({}) do |b, m|
-        m[b["id"]] = b
+          m[b["id"]] = b
       end
     end
 
@@ -90,6 +96,7 @@ module IsoDoc
     end
 
     def block(docxml)
+      amend docxml # feeds all other blocks
       table docxml
       figure docxml
       sourcecode docxml
@@ -106,13 +113,11 @@ module IsoDoc
       requirement docxml
       recommendation docxml
       requirement_render docxml
-      amend docxml
     end
 
     def inline(docxml)
       document_footnotes docxml
       comments docxml
-      bibitem_lookup(docxml) # feeds citeas
       fmt_ref docxml # feeds citeas, xref, eref, origin, concept
       citeas docxml # feeds xref, eref, origin, concept
       xref docxml

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "3.4.2".freeze
+  VERSION = "3.4.3".freeze
 end

data/lib/isodoc/word_function/lists.rb

@@ -62,9 +62,11 @@ module IsoDoc
       end
 
       def dl_table_attrs(node)
+        key = node.parent.name == "key" && node.parent["class"] == "formula_dl"
+        klass = key ? node.parent["class"] : nil
         { id: node["id"],
-          style: node["class"] == "formula_dl" ? "text-align:left;" : nil,
-          class: node["class"] || "dl" }
+          style: key ? "text-align:left;" : nil,
+          class: klass || node["class"] || "dl" }
       end
 
       def dl_parse_table(node, out)

data/lib/isodoc/word_function/postprocess_table.rb

@@ -44,7 +44,9 @@ module IsoDoc
 
       def word_nested_tables(docxml)
         docxml.xpath("//table").each do |t|
-          t.xpath(".//table").reverse_each do |tt|
+          nested_tables = t.xpath(".//table") - t.xpath(".//td//table") -
+            t.xpath(".//th//table")
+          nested_tables.reverse_each do |tt|
             t.next = tt.remove
           end
         end

data/lib/isodoc/xref/xref_gen.rb

@@ -1,6 +1,3 @@
-require_relative "xref_gen_seq"
-require_relative "xref_util"
-
 module IsoDoc
   module XrefGen
     module Blocks
@@ -10,13 +7,17 @@ module IsoDoc
 
       def amend_preprocess(xmldoc)
         xmldoc.xpath(ns("//amend[newcontent]")).each do |a|
-          autonum = amend_autonums(a)
-          NUMBERED_BLOCKS.each do |b|
-            a.xpath(ns("./newcontent//#{b}")).each_with_index do |e, i|
-              autonum[b] && i.zero? and e["number"] = autonum[b]
-              !autonum[b] and e["unnumbered"] = "true"
-            end
-          end
+          amend_preprocess1(a)
+        end
+      end
+
+      def amend_preprocess1(amend, subclause: false)
+        autonum = amend_autonums(amend)
+        NUMBERED_BLOCKS.each do |b|
+          amend_blocks(amend, autonum, b, subclause)
+        end
+        amend.xpath(ns(".#{amend_newcontent(subclause)}/clause")).each do |c|
+          amend_preprocess1(c, subclause: true)
         end
       end
 
@@ -28,6 +29,20 @@ module IsoDoc
         autonum
       end
 
+      def amend_blocks(amend, autonum, blocktype, subclause)
+        newc = amend_newcontent(subclause)
+        (amend.xpath(ns(".#{newc}//#{blocktype}")) -
+         amend.xpath(ns(".#{newc}/clause//#{blocktype}")))
+          .each_with_index do |e, i|
+            autonum[blocktype] && i.zero? and e["number"] = autonum[blocktype]
+            !autonum[blocktype] and e["unnumbered"] = "true"
+        end
+      end
+
+      def amend_newcontent(subclause)
+        subclause ? "" : "/newcontent"
+      end
+
       def termnote_label(node, label)
         if label.blank?
           @labels["termnote"].gsub(/%\s?/, "")
@@ -50,17 +65,42 @@ module IsoDoc
         end
       end
 
+      # processed from Presentation XML notes_inside_bibitem(),
+      # after notes moved: need docid from references processing
+      def bibitem_note_names(bib)
+        notes = bib.xpath(ns("./formattedref/note"))
+        counter = Counter.new
+        notes.noblank.each do |n|
+          lbl = increment_label(notes, n, counter)
+          @anchors[n["id"]] =
+            { label: lbl, value: lbl, container: bib["id"],
+              xref: anchor_struct_xref(lbl, n, @labels["note_xref"]),
+              elem: @labels["note_xref"], type: "note" }
+        end
+      end
+
+      # note within an asset: table, figure, provision
+      def nested_notes(asset, container: true)
+        notes = asset.xpath(ns(".//note"))
+        counter = Counter.new
+        notes.noblank.each do |n|
+          lbl = increment_label(notes, n, counter)
+          @anchors[n["id"]] =
+            { label: lbl, value: lbl, container: container ? asset["id"] : nil,
+              xref: anchor_struct_xref(lbl, n, @labels["note_xref"]),
+              elem: @labels["note_xref"], type: "note" }.compact
+        end
+      end
+
       def termexample_anchor_names(docxml)
         docxml.xpath(ns("//*[termexample]")).each do |t|
           examples = t.xpath(ns("./termexample"))
-          c = Counter.new
-          examples.noblank.each do |n|
+          examples.noblank.each_with_object(Counter.new) do |n, c|
             c.increment(n)
             idx = increment_label(examples, n, c, increment: false)
             @anchors[n["id"]] =
-              { label: idx, type: "termexample",
-                value: idx, elem: @labels["example_xref"],
-                container: t["id"],
+              { label: idx, type: "termexample", value: idx,
+                elem: @labels["example_xref"], container: t["id"],
                 xref: anchor_struct_xref(idx, n, @labels["example_xref"]) }
           end
         end
@@ -69,7 +109,8 @@ module IsoDoc
       def note_anchor_names(sections)
         sections.each do |s|
           notes = s.xpath(child_asset_path("note")) -
-            s.xpath(ns(".//figure//note | .//table//note"))
+            s.xpath(ns(".//figure//note | .//table//note | //permission//note | " \
+              "//recommendation//note | //requirement//note"))
           note_anchor_names1(notes, Counter.new)
           note_anchor_names(s.xpath(ns(child_sections)))
         end
@@ -102,9 +143,23 @@ module IsoDoc
         end
       end
 
+      # note within an asset: provision
+      def nested_examples(asset, container: true)
+        notes = asset.xpath(ns(".//example"))
+        notes.noblank.each_with_object(Counter.new) do |n, counter|
+          @anchors[n["id"]] ||=
+            anchor_struct(increment_label(notes, n, counter), n,
+                          @labels["example_xref"], "example",
+                          { unnumb: n["unnumbered"] })
+          @anchors[n["id"]][:container] = container ? asset["id"] : nil
+        end
+      end
+
       def example_anchor_names(sections)
         sections.each do |s|
-          notes = s.xpath(child_asset_path("example"))
+          notes = s.xpath(child_asset_path("example")) -
+            s.xpath(ns("//permission//note | " \
+              "//recommendation//note | //requirement//note"))
           example_anchor_names1(notes, Counter.new)
           example_anchor_names(s.xpath(ns(child_sections)))
         end
@@ -119,108 +174,6 @@ module IsoDoc
         end
       end
 
-      def list_anchor_names(sections)
-        sections.each do |s|
-          notes = s.xpath(ns(".//ol")) - s.xpath(ns(".//clause//ol")) -
-            s.xpath(ns(".//appendix//ol")) - s.xpath(ns(".//ol//ol"))
-          c = list_counter(0, {})
-          notes.noblank.each do |n|
-            @anchors[n["id"]] =
-              anchor_struct(increment_label(notes, n, c), n,
-                            @labels["list"], "list",
-                            { unnumb: false, container: true })
-            list_item_anchor_names(n, @anchors[n["id"]], 1, "", notes.size != 1)
-          end
-          list_anchor_names(s.xpath(ns(child_sections)))
-        end
-      end
-
-      def list_item_delim
-        ")"
-      end
-
-      def list_item_anchor_names(list, list_anchor, depth, prev_label,
-refer_list)
-        c = list_counter(list["start"] ? list["start"].to_i - 1 : 0, {})
-        list.xpath(ns("./li")).each do |li|
-          bare_label, label =
-            list_item_value(li, c, depth,
-                            { list_anchor:, prev_label:,
-                              refer_list: depth == 1 ? refer_list : nil })
-          @anchors[li["id"]] =
-            { label: bare_label, bare_xref: "#{label})", type: "listitem",
-              xref: %[#{label}#{delim_wrap(list_item_delim)}], refer_list:,
-              container: list_anchor[:container] }
-          (li.xpath(ns(".//ol")) - li.xpath(ns(".//ol//ol"))).each do |ol|
-            list_item_anchor_names(ol, list_anchor, depth + 1, label,
-                                   refer_list)
-          end
-        end
-      end
-
-      def list_item_value(entry, counter, depth, opts)
-        label = counter.increment(entry).listlabel(entry.parent, depth)
-        s = semx(entry, label)
-        [label,
-         list_item_anchor_label(s, opts[:list_anchor], opts[:prev_label],
-                                opts[:refer_list])]
-      end
-
-      def list_item_anchor_label(label, list_anchor, prev_label, refer_list)
-        prev_label.empty? or
-          label = @klass.connectives_spans(@i18n.list_nested_xref
-            .sub("%1", %[#{prev_label}#{delim_wrap(list_item_delim)}])
-            .sub("%2", label))
-        refer_list and
-          label = @klass.connectives_spans(@i18n.list_nested_xref
-            .sub("%1", list_anchor[:xref])
-            .sub("%2", label))
-        label
-      end
-
-      def deflist_anchor_names(sections)
-        sections.each do |s|
-          notes = s.xpath(ns(".//dl")) - s.xpath(ns(".//clause//dl")) -
-            s.xpath(ns(".//appendix//dl")) - s.xpath(ns(".//dl//dl"))
-          deflist_anchor_names1(notes, Counter.new)
-          deflist_anchor_names(s.xpath(ns(child_sections)))
-        end
-      end
-
-      def deflist_anchor_names1(notes, counter)
-        notes.noblank.each do |n|
-          @anchors[n["id"]] =
-            anchor_struct(increment_label(notes, n, counter), n,
-                          @labels["deflist"], "deflist",
-                          { unnumb: false, container: true })
-          deflist_term_anchor_names(n, @anchors[n["id"]])
-        end
-      end
-
-      def deflist_term_anchor_names(list, list_anchor)
-        list.xpath(ns("./dt")).each do |li|
-          label = deflist_term_anchor_lbl(li, list_anchor)
-          li["id"] and @anchors[li["id"]] =
-                         { xref: label, type: "deflistitem",
-                           container: list_anchor[:container] }
-          li.xpath(ns("./dl")).each do |dl|
-            deflist_term_anchor_names(dl, list_anchor)
-          end
-        end
-      end
-
-      def deflist_term_anchor_lbl(listitem, list_anchor)
-        s = semx(listitem, dt2xreflabel(listitem))
-        %(#{list_anchor[:xref]}#{delim_wrap(":")} #{s}</semx>)
-      end
-
-      def dt2xreflabel(dterm)
-        label = dterm.dup
-        label.xpath(ns(".//p")).each { |x| x.replace(x.children) }
-        label.xpath(ns(".//index")).each(&:remove)
-        Common::to_xml(label.children)
-      end
-
       def id_ancestor(node)
         parent = nil
         node.ancestors.each do |a|

data/lib/isodoc/xref/xref_gen_seq.rb

@@ -56,6 +56,7 @@ module IsoDoc
             { unnumb: elem["unnumbered"], container: }
           )
         end
+        nested_notes(elem)
       end
 
       def fig_subfig_label(label, sublabel)
@@ -87,6 +88,7 @@ module IsoDoc
             c.increment(t).print, t, @labels["table"], "table",
             { unnumb: t["unnumbered"], container: container }
           )
+          nested_notes(t)
         end
       end
 
@@ -114,11 +116,6 @@ module IsoDoc
         end
       end
 
-      def delim_wrap(delim, klass = "fmt-autonum-delim")
-        delim.blank? and return ""
-        "<span class='#{klass}'><esc>#{delim}</esc></span>"
-      end
-
       def sequential_permission_children(elem, lbl, klass, container: false)
         elem.xpath(ns(req_children)).noblank
           .each_with_object(ReqCounter.new) do |t, c|
@@ -137,23 +134,29 @@ container: false)
         lbl = parent_id ? "#{parent_id}#{subreqt_separator}#{id}" : id
         e = elem["id"] || elem["original-id"]
         @anchors[e] = model.postprocess_anchor_struct(
-          elem, anchor_struct(lbl, elem,
-                              label, klass, { unnumb: elem["unnumbered"], container: })
+          elem, anchor_struct(lbl, elem, label, klass,
+                              { unnumb: elem["unnumbered"], container: })
         )
+        nested_notes(elem)
+        nested_examples(elem)
         @anchors[e][:semx] = semx(elem, lbl)
-        if parent_id
-          x = "#{subreqt_separator(markup: true)}#{semx(elem, id)}"
-          @anchors[e][:semx] = @anchors[elem.parent["id"] || elem.parent["original-id"]][:semx] + x
-          @anchors[e][:label] =
-            "<span class='fmt-element-name'>#{label}</span> #{@anchors[e][:semx]}"
-          @anchors[e][:xref] = @anchors[e][:label]
-        end
+        sequential_permission_body_parent_id(id, parent_id, elem, label, e)
         model.permission_parts(elem, id, label, klass).each do |n|
           @anchors[n[:id]] = anchor_struct(n[:number], n[:elem], n[:label],
                                            n[:klass], { unnumb: false, container: })
         end
       end
 
+      def sequential_permission_body_parent_id(id, parent_id, elem, label, e)
+        parent_id or return
+        x = "#{subreqt_separator(markup: true)}#{semx(elem, id)}"
+        @anchors[e][:semx] =
+          @anchors[elem.parent["id"] || elem.parent["original-id"]][:semx] + x
+        @anchors[e][:label] =
+          "<span class='fmt-element-name'>#{label}</span> #{@anchors[e][:semx]}"
+        @anchors[e][:xref] = @anchors[e][:label]
+      end
+
       def reqt2class_label(elem, model)
         elem["class"] and return [elem["class"], elem["class"]]
         model.req_class_paths.each do |n|
@@ -207,6 +210,7 @@ container: false)
               anchor_struct(hiersemx(clause, num, c.increment(t), t),
                             t, @labels["table"], "table",
                             { unnumb: t["unnumbered"], container: false })
+            nested_notes(t)
           end
         end
       end