metanorma-ieee 1.4.3 → 1.4.4

data/lib/isodoc/ieee/presentation_terms.rb

@@ -1,7 +1,7 @@
 module IsoDoc
   module Ieee
     class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
-      def multidef(elem, defn, fmt_defn)
+      def multidef(_elem, defn, fmt_defn)
         ctr = IsoDoc::XrefGen::Counter.new("@")
         coll = defn.each_with_object([]) do |d, m|
           ctr.increment(d)
@@ -10,73 +10,21 @@ module IsoDoc
             .first.add_first_child("<strong>(#{ctr.print})</strong>&#xa0;")
           m << ret
         end
-        #require "debug"; binding.b
         fmt_defn << coll.map { |c| to_xml(c) }.join(" ")
-        #coll.each { |x| unwrap_definition1(x) }
-        #fmt_defn << unwrap_multidef(coll)
       end
 
       def unwrap_multidef(coll)
         if coll.all? do |c|
           c.elements.size == 1 && c.elements.first.name == "p"
         end
-        ret = coll.map do |c|
-          c.children = c.elements.first.children
-        end
-        return "<p>#{ret.map { |x| to_xml(x) }.join}</p>"
+          ret = coll.map do |c|
+            c.children = c.elements.first.children
+          end
+          return "<p>#{ret.map { |x| to_xml(x) }.join}</p>"
         end
         coll.map { |c| to_xml(c.children) }.join(" ")
       end
 
-=begin
-    def unwrap_definition(elem)
-      elem.xpath(ns("./definition")).each do |d|
-        %w(verbal-definition non-verbal-representation).each do |e|
-          v = d&.at(ns("./#{e}"))
-          v&.replace(v.children)
-        end
-      end
-    end
-
-    to
-
-      def unwrap_definition(_elem, fmt_defn)
-      fmt_defn.xpath(ns(".//semx[@element = 'definition']")).each do |d|
-        %w(verbal-definition non-verbal-representation).each do |e|
-          v = d&.at(ns("./#{e}"))
-          v&.replace(v.children)
-        end
-      end
-    en
-
-=end
-
-def designation(docxml)
-  super
-end
-
-def deprecates(desgn)
-  desgn.remove
-end
-
-    def designation_boldface(desgn)
-      #desgn["element"] == "preferred" or return
-      name = desgn.at(ns("./expression/name | ./letter-symbol/name")) or return
-      name.children = "<strong>#{name.children}</strong>"
-    end
-
-      def unwrap_definition(docxml)
-        docxml.xpath(ns(".//definition/verbal-definition")).each do |v|
-          v.elements.all? { |e| %w(termsource p).include?(e.name) } or next
-          p = v.xpath(ns("./p"))
-          s = v.xpath(ns('./termsource'))
-          s.empty? or s = " (#{s.map { |x| to_xml(x) }.join("\n")})"
-          v.children =
-            "<p>#{p.map(&:children).map { |x| to_xml(x) }.join("\n")}#{s}</p>"
-        end
-        super
-      end
-
       def unwrap_definition(_elem, fmt_defn)
         fmt_defn.xpath(ns(".//semx[@element = 'definition']")).each do |d|
           unwrap_definition1(d)
@@ -84,201 +32,32 @@ end
       end
 
       def unwrap_definition1(d)
-          %w(verbal-definition non-verbal-representation).each do |e|
-            v = d.at(ns("./#{e}")) or next
-            if v.elements.all? { |e| %w(termsource p).include?(e.name) }
-              p = v.xpath(ns("./p"))
-              s = v.xpath(ns('./termsource'))
-              s.empty? or s = " (#{s.map { |x| to_xml(x) }.join()})"
-              v.children =
-                "#{p.map(&:children).map { |x| to_xml(x) }.join("\n")}#{s}"
-            else
-              s = v.xpath(ns('./termsource'))
-              unless s.empty?
-                s[0].previous = " ("
-                s[-1].next = ")"
-              end
+        %w(verbal-definition non-verbal-representation).each do |e|
+          v = d.at(ns("./#{e}")) or next
+          if v.elements.all? { |n| %w(termsource p).include?(n.name) }
+            p = v.xpath(ns("./p"))
+            s = v.xpath(ns("./termsource"))
+            s.empty? or s = " (#{s.map { |x| to_xml(x) }.join})"
+            v.children =
+              "#{p.map(&:children).map { |x| to_xml(x) }.join("\n")}#{s}"
+          else
+            s = v.xpath(ns("./termsource"))
+            unless s.empty?
+              s[0].previous = " ("
+              s[-1].next = ")"
             end
-            v.replace(v.children)
           end
-      end
-
-      def related_designation1(desgn)
-        super
-      end
-
-      def related(docxml)
-        insert_related_type(docxml)
-        admitted_to_related docxml
-        term_reorder(docxml)
-        docxml.xpath(ns("//term[fmt-related/semx]")).each { |f| related_term(f) }
-      end
-
-      # temporarily insert related/@type to fmt-related/semx, for sorting
-      def insert_related_type(docxml)
-        docxml.xpath(ns("//fmt-related/semx")).each do |r|
-          orig = semx_orig(r)
-          r["type"] = orig["type"]
-        end
-      end
-
-      def related_term(term)
-        #require "debug"; binding.b
-        #coll = term_related_reorder(term.xpath(ns("./fmt-related/semx")))
-        r = term.at(ns("./fmt-related"))
-        r.xpath(ns(".//xref | .//eref | .//termref")).each(&:remove)
-        coll = sort_related(r.xpath(ns("./semx")))
-        r.children = term_related_collapse(coll)
-      end
-
-      def term_related_collapse(coll)
-        prev = 0
-        coll[0].wrap("<p></p>")
-        coll[1..-1].each_with_index do |r, i|
-          if coll[prev]["type"] != r["type"]
-            prev = i
-            r.wrap("<p></p>")
-            next
-          end
-
-          #coll[prev].at(ns("./preferred")) << "; #{to_xml(r.at(ns('./preferred'))
-          #.children)}"
-          coll[prev] << "; #{to_xml(r)}"
-          r.remove
-        end
-      end
-
-      def term_related_collapse(coll)
-        prev = 0
-        ret = [[coll[0]]]
-        coll[1..-1].each do |r|
-        if ret[-1][0]["type"] != r["type"]
-            ret << [r]
-            next
-          end
-          ret[-1] << r
-        end
-        ret.map { |x| x.map { |y| to_xml(y) }.join("; ") }.map { |x| "<p>#{x}</p>" }.join("\n")
-      end
-
-      def sort_terms_key(term)
-        d = term.at(ns("./preferred/expression/name | " \
-                       "./preferred/letter-symbol/name | " \
-                       "./preferred/graphical-symbol/figure/name | " \
-                       "./preferred/graphical-symbol/figure/@id | " \
-                       "./preferred | ./fmt-preferred//semx"))
-        f = term.at(ns("./field-of-application")) || term.at(ns("./domain"))
-        @c.decode("#{sort_terms_key1(d)} :: #{sort_terms_key1(f)}")
-      end
-
-      def sort_terms_key1(elem)
-        elem.nil? and return "zzzz"
-        dup = elem.dup
-        dup.xpath(ns(".//asciimath | .//latexmath")).each(&:remove)
-        dup.text&.strip&.downcase || "zzzz"
-      end
-
-      #KILL
-      def term_related_reorder(coll)
-        ins = coll.first.previous_element
-        ret = sort_related(coll)
-        coll.each(&:remove)
-        ret.reverse_each { |t| ins.next = t }
-        ins.parent.xpath(ns("./related"))
-      end
-
-      def sort_related(coll)
-        coll.sort do |a, b|
-          sort_related_key(a) <=> sort_related_key(b)
+          v.replace(v.children)
         end
       end
 
-      def sort_related_key(related)
-        type = case related["type"]
-               when "contrast" then 1
-               when "equivalent" then 2
-               when "see" then 3
-               when "seealso" then 4
-               else "5-#{related['type']}"
-               end
-        "#{type} :: #{sort_terms_key(related)}"
-      end
-
       def termcleanup(docxml)
         collapse_term docxml
-        docxml.xpath(ns("//term//semx[@type]")).each { |x| x.delete("type") } # temp attribute from insert_related_type
-        super
-      end
-
-      def admitted_to_related(docxml)
-        docxml.xpath(ns("//term")).each do |t|
-          t.xpath(ns("./fmt-admitted/semx | ./fmt-preferred/semx")).each_with_index do |a, i|
-            orig = semx_orig(a)
-            (i.zero? ||
-             orig.at(ns("./abbreviation-type | ./graphical-symbol"))) and next
-            out = t.at(ns("./fmt-related")) || t.at(ns("./definition")).before("<fmt-related/>").previous
-            admitted_to_related1(a, t.at(ns("./fmt-preferred/semx")), out)
-            a.parent.name == "fmt-preferred" and a.remove
-          end
-          t.at(ns("./fmt-admitted"))&.remove
-        end
-        #term_reorder(docxml)
-      end
-
-      def admitted_to_related1(adm, pref, out)
-        new = adm.dup
-        adm["type"] = "equivalent"
-        adm.name = "related"
-        adm.children = "<preferred>#{to_xml(adm.children)}</preferred>"
-        adm.parent.next = <<~TERM
-          <term><preferred>#{to_xml(new.children)}</preferred>
-          <related type='see'><preferred>#{to_xml(pref.children)}</preferred></related></term>
-        TERM
-      end
-
-      def admitted_to_related1(adm, pref, out)
-      out << <<~TERM
-<semx element='related' source='#{adm['source']}' type='equivalent'><fmt-preferred>#{to_xml(adm)}</p></semx></fmt-preferred>
-TERM
-        out.parent.next = <<~TERM
-          <term><fmt-preferred>#{to_xml(adm)}</fmt-preferred>
-          <fmt-related>
-            <semx element="related" source="#{pref['source']}" type="see"><fmt-preferred>#{to_xml(pref)}</fmt-preferred></semx>
-          </fmt-related>
-          <fmt-definition></fmt-definition></term>
-        TERM
-      end
-
-      #KILL
-      def related1(node)
-       require "debug"; binding.b
-      p, ref, orig = related1_prep(node)
-      label = @i18n.relatedterms[orig["type"]].upcase
-      if p
-        node.children =(l10n("<p><strong>#{label}:</strong> " \
-                          "<em>#{to_xml(p)}</em></p>"))
-      else
-        node.children = (l10n("<p><strong>#{label}:</strong> " \
-                          "<strong>**RELATED TERM NOT FOUND**</strong></p>"))
-      end
-    end
-
-      def term_reorder(xmldoc)
-        xmldoc.xpath(ns("//terms")).each { |t| term_reorder1(t) }
-      end
-
-      def term_reorder1(terms)
-        ins = terms.at(ns("./term"))&.previous_element or return
-        coll = terms.xpath(ns("./term"))
-        ret = sort_terms(coll)
-        coll.each(&:remove)
-        ret.reverse_each { |t| ins.next = t }
-      end
-
-      def sort_terms(terms)
-        terms.sort do |a, b|
-          sort_terms_key(a) <=> sort_terms_key(b)
+        # temp attribute from insert_related_type
+        docxml.xpath(ns("//term//semx[@type]")).each do |x|
+          x.delete("type")
         end
+        super
       end
 
       def termcontainers(docxml)
@@ -293,13 +72,6 @@ TERM
       end
 
       def collapse_term1(term)
-        #pref = term.xpath(ns("./fmt-preferred//semx")).each_with_index.with_object([]) do |(a, i), m|
-            #orig = semx_orig(a, term)
-#if i.zero? || orig.at(ns("./abbreviation-type | ./graphical-symbol"))
-  #m << a
-#end
-        #end
-
         ret = collapse_term_template(
           pref: term.at(ns("./fmt-preferred")),
           def: term.at(ns("./fmt-definition")),
@@ -312,20 +84,9 @@ TERM
           ins.children = ret
       end
 
-      def collapse_term_related(rels)
-        ret = rels.map do |r|
-          p = r.at(ns("./preferred"))
-          rel = p ? to_xml(p.children) : "**RELATED TERM NOT FOUND**"
-          "<em>#{@i18n.relatedterms[r['type']]}:</em> #{rel}"
-        end.join(". ")
-        ret += "." unless ret.empty?
-        ret
-      end
-
       def collapse_term_related(rels)
         rels or return
         rels.xpath(ns("./p")).each do |p|
-          #require "debug"; binding.b
           orig = p.at(ns(".//semx[@element = 'related']"))
           reln = "<em>#{@i18n.relatedterms[orig['type']]}:</em> "
           p.add_first_child reln
@@ -333,29 +94,23 @@ TERM
             r.at(ns("./fmt-preferred")) or r.add_first_child "**RELATED TERM NOT FOUND**"
           end
         end
-        ret = rels.xpath(ns("./p")).map { |x| to_xml(x.children).strip }.join(". ")
+        ret = rels.xpath(ns("./p")).map do |x|
+          to_xml(x.children).strip
+        end.join(". ")
         ret += "." unless ret.empty?
         ret
       end
 
       def collapse_term_template(opt)
         defn, multiblock = collapse_unwrap_definition(opt[:def])
-        #require "debug"; binding.b
-        src = nil
+        #src = nil
         opt[:source] and src = "(#{to_xml(opt[:source].remove.children).strip})"
         t = collapse_term_pref(opt)
-        #require "debug"; opt[:pref].nil? and binding.b
-        #require "debug"; opt[:rels].empty? or binding.b
         tail = "#{collapse_term_related(opt[:rels])} #{src}"
         if multiblock
           tail = tail.strip.empty? ? "" : "<p>#{tail}</p>"
-        <<~TERM
-          <p>#{t}:</p> #{defn}#{tail}
-        TERM
-        else
-        <<~TERM
-          <p>#{t}: #{defn} #{tail}</p>
-        TERM
+          "<p>#{t}:</p> #{defn}#{tail}"
+        else "<p>#{t}: #{defn} #{tail}</p>"
         end
       end
 
@@ -369,11 +124,9 @@ TERM
         end
         p.xpath(ns(".//fmt-termsource")).each { |x| x.replace(x.children) }
         to_xml(p.children).strip
-
       end
 
       def collapse_unwrap_definition(defn)
-        #require "debug"; binding.b
         defn.nil? and return nil, nil
         s = defn.xpath(ns(".//fmt-termsource"))
         p = defn.at(ns(".//p"))
@@ -381,25 +134,17 @@ TERM
           .map { |x| to_xml(x) }.join
         # fmt-definition/semx/p
         elems = defn.at(ns("./semx")) || defn
-        multiblock = elems.at(ns("./table | ./formula | ./dl | ./ol | ./ul")) || elems.xpath(ns("./p")).size > 1
+        multiblock = elems.at(ns("./table | ./formula | ./dl | ./ol | ./ul")) ||
+          elems.xpath(ns("./p")).size > 1
         [defn.elements, multiblock]
       end
 
-      # KILL
-      def termsource1xx(elem)
-        while elem&.next_element&.name == "termsource"
-          elem << "; #{to_xml(elem.next_element.remove.children)}"
-        end
+      def termsource_label(elem, sources)
         adapt = termsource_adapt(elem["status"]) and
-          elem.children = l10n("#{adapt}#{to_xml(elem.children).strip}")
+          sources = "#{adapt}#{sources}"
+        elem.replace(l10n(sources))
       end
 
-      def termsource_label(elem, sources)
-      adapt = termsource_adapt(elem["status"]) and
-        sources = "#{adapt}#{sources}"
-      elem.replace(l10n(sources))
-    end
-
       def termsource_adapt(status)
         case status
         when "adapted" then @i18n.adapted_from
@@ -407,53 +152,7 @@ TERM
       end
 
       # domain is rendered in designation_field instead
-      def termdomain(elem, domain)
-        #d = elem.at(ns(".//domain")) or return
-        #d["hidden"] = "true"
-      end
-
-      def designation_field(desgn, name, orig)
-        if desgn["element"] == "preferred"
-          f = orig.parent.xpath(ns("./domain | ./subject"))
-            .map { |u| to_xml(semx_fmt_dup(u)) }.join(", ")
-          #require 'debug'; binding.b
-          name << "<span class='fmt-designation-field'>, &#x3c;#{f}&#x3e;</span>" unless f.empty?
-        end
-        super
-      end
-
-      def merge_second_preferred(term)
-        pref =
-          term.at(ns("./preferred[not(abbreviation-type)]/expression/name"))
-        x = term.xpath(ns("./preferred[expression/name][abbreviation-type] | " \
-                          "./admitted[expression/name][abbreviation-type]"))
-        (pref && !x.empty?) or return
-        tail = x.map do |p|
-          to_xml(p.remove.at(ns("./expression/name")).children).strip
-        end.join(", ")
-        pref << " (#{tail})"
-      end
-
-      def merge_second_preferred(term)
-        term.name == "fmt-admitted" and return
-        pref =
-          term.parent.at(ns("./preferred[not(abbreviation-type)][expression/name]"))
-        x = term.parent.xpath(ns("./preferred[expression/name][abbreviation-type] | " \
-                          "./admitted[expression/name][abbreviation-type]"))
-        (pref && !x.empty?) or return
-fmt_pref = term.parent.at(ns(".//semx[@source = '#{pref['id']}']"))
-fdf = fmt_pref.at(ns(".//span[@class = 'fmt-designation-field']"))&.text
-        out = to_xml(fmt_pref)
-        tail = x.map do |p|
-          #require "debug"; binding.b
-          ret = term.parent.at(ns(".//semx[@source = '#{p['id']}']")).remove
-          fdf1 = ret.at(ns(".//span[@class = 'fmt-designation-field']"))
-          fdf1 && (fdf1&.text == fdf) and fdf1.remove # repetition of domain suppressed
-          to_xml(ret).strip
-        end.join(", ")
-        out += " (#{tail})"
-        term.children = out
-      end
+      def termdomain(elem, domain); end
 
       def termnote1(elem)
         lbl = termnote_label(elem)
@@ -466,11 +165,6 @@ fdf = fmt_pref.at(ns(".//span[@class = 'fmt-designation-field']"))&.text
       end
 
       def term(docxml); end
-
-      def concept1(node)
-        concept_render(node, ital: "false", ref: "false", bold: "false",
-                       linkref: "false", linkmention: "false")
-      end
     end
   end
 end

data/lib/isodoc/ieee/presentation_xml_convert.rb

@@ -1,6 +1,7 @@
 require_relative "init"
 require_relative "presentation_bibdata"
 require_relative "presentation_terms"
+require_relative "presentation_concepts"
 require_relative "presentation_ref"
 require "isodoc"
 
@@ -35,7 +36,7 @@ module IsoDoc
       end
 
       def subclause?(target, type, from)
-        (from&.match?(/\./) && type == "clause") ||
+        (from&.include?(".") && type == "clause") ||
           target&.gsub(/<[^<>]+>/, "")&.match?(/^IEV$|^IEC 60050-/)
       end
 
@@ -104,16 +105,7 @@ module IsoDoc
       end
 
       def annex_delim(_elem)
-      "<br/>"
-    end
-
-      # KILL
-      def annex1_default(elem)
-        lbl = @xrefs.anchor(elem["id"], :label)
-        if t = elem.at(ns("./title"))
-          t.children = "<strong>#{to_xml(t.children)}</strong>"
-        end
-        prefix_name(elem, { caption: "<br/>" }, lbl, "title")
+        "<br/>"
       end
 
       def amend1(elem)
@@ -184,6 +176,8 @@ module IsoDoc
         end
       end
 
+      # overrides IsoDoc:: XrefGen::OlTypeProvider: we trigger
+      # @xrefs.list_anchor_names after this is called, with elem["type"] set
       def ol_depth_rotate(node, idx)
         depth = node.ancestors("ol").size + idx
         type = :alphabet
@@ -192,6 +186,15 @@ module IsoDoc
         type
       end
 
+      def ul_label_list(_elem)
+        if @doctype == "whitepaper" ||
+            %w(icap industry-connection-report).include?(@subdoctype)
+          %w(&#x25aa; &#x2014;)
+        else
+          %w(&#x2013;)
+        end
+      end
+
       def middle_title(docxml)
         s = middle_title_insert(docxml) or return
         s.previous = middle_title_body

data/lib/isodoc/ieee/xref.rb

@@ -50,13 +50,14 @@ module IsoDoc
           "#{@klass.norm_ref_xpath} | //sections/terms | " \
           "//sections/definitions | //clause[parent::sections]"
         if @hierarchical_assets
-          hierarchical_asset_names(doc.xpath("//xmlns:preface/child::*"), "Preface")
+          hierarchical_asset_names(doc.xpath("//xmlns:preface/child::*"),
+                                   "Preface")
           doc.xpath(ns(middle_sections)).each do |c|
             hierarchical_asset_names(c, @anchors[c["id"]][:label])
           end
         else
-          sequential_asset_names(doc.xpath(ns("//preface/* | " + middle_sections)))
-          #sequential_asset_names(doc.xpath(ns(middle_sections)))
+          sequential_asset_names(doc.xpath(ns("//preface/* | #{middle_sections}")))
+          # sequential_asset_names(doc.xpath(ns(middle_sections)))
         end
       end
 
@@ -77,20 +78,12 @@ module IsoDoc
           sequence = UUIDTools::UUID.random_create.to_s
           notes = t.xpath(ns("./termnote"))
           notes.noblank.each do |n|
-              @anchors[n["id"]] =
-              { label: termnote_label(n, increment_label(notes, n, c)), type: "termnote",
+            @anchors[n["id"]] =
+              { label: termnote_label(n, increment_label(notes, n, c)),
                 value: c.print, elem: @labels["termnote"],
-                container: t["id"],
+                container: t["id"], type: "termnote",
                 xref: anchor_struct_xref(c.print, n, @labels["note_xref"]) }
-            .merge(sequence: sequence)
-=begin
-              anchor_struct(
-                termnote_label(n, increment_label(notes, n, c)),
-                #labelled_autonum(@labels["termnote"], increment_label(notes, n, c)),
-                #"#{@labels['termnote']} #{increment_label(notes, n, c)}",
-                            n, @labels["note_xref"], "termnote", { container: true })
                 .merge(sequence: sequence)
-=end
           end
         end
       end
@@ -111,7 +104,7 @@ module IsoDoc
         if @doctype == "whitepaper"
           title = Common::case_with_markup(@labels["annex"], "capital",
                                            @script)
-           l10n(labelled_autonum(title, num))
+          l10n(labelled_autonum(title, num))
         else super
         end
       end

data/lib/metanorma/ieee/basicdoc.rng

@@ -1701,16 +1701,22 @@ which can be bookmarks as well as block or section references</a:documentation>
     <a:documentation>Inline reference to a paragraph or paragraphs, appearing as a footnote.
 The target of a footnote is the location it is embedded in within the text</a:documentation>
     <element name="fn">
-      <attribute name="reference">
-        <a:documentation>The number of the footnote, used to identify it visually</a:documentation>
-      </attribute>
-      <oneOrMore>
-        <ref name="paragraph">
-          <a:documentation>The content of the footnote</a:documentation>
-        </ref>
-      </oneOrMore>
+      <ref name="FnAttributes"/>
+      <ref name="FnBody"/>
     </element>
   </define>
+  <define name="FnBody">
+    <oneOrMore>
+      <ref name="paragraph">
+        <a:documentation>The content of the footnote</a:documentation>
+      </ref>
+    </oneOrMore>
+  </define>
+  <define name="FnAttributes">
+    <attribute name="reference">
+      <a:documentation>The number of the footnote, used to identify it visually</a:documentation>
+    </attribute>
+  </define>
   <define name="callout">
     <a:documentation>Inline reference to a paragraph or paragraphs, appearing as annotation of source code</a:documentation>
     <element name="callout">