metanorma-ieee 0.0.1 → 0.0.4

data/lib/isodoc/ieee/metadata.rb

@@ -6,11 +6,13 @@ module IsoDoc
     class Metadata < IsoDoc::Metadata
       def initialize(lang, script, i18n, fonts_options = {})
         super
-        @metadata[:confirmeddate] = "&lt;Date Approved&gt;"
+        @metadata[:issueddate] = "&lt;Date Approved&gt;"
       end
 
       def bibdate(isoxml, _out)
-        super
+        isoxml.xpath(ns("//bibdata/date[@format = 'ddMMMyyyy']")).each do |d|
+          set("#{d['type'].gsub(/-/, '_')}date".to_sym, Common::date_range(d))
+        end
         draft = isoxml.at(ns("//bibdata/date[@type = 'issued']")) ||
           isoxml.at(ns("//bibdata/date[@type = 'circulated']")) ||
           isoxml.at(ns("//bibdata/date[@type = 'created']")) ||
@@ -25,8 +27,10 @@ module IsoDoc
         b = isoxml.at(ns("//bibdata/ext/doctype"))&.text or return
         set(:doctype, b.split(/[- ]/).map(&:capitalize).join(" "))
         set(:doctype_abbrev, @labels["doctype_abbrev"][b])
-        s = isoxml.at(ns("//bibdata/ext/docsubtype"))&.text and
+        s = isoxml.at(ns("//bibdata/ext/subdoctype"))&.text and
           set(:docsubtype, s.split(/[- ]/).map(&:capitalize).join(" "))
+        s = isoxml.at(ns("//bibdata/ext/trial-use"))&.text and s == "true" and
+          set(:trial_use, true)
       end
 
       def author(xml, _out)
@@ -35,7 +39,6 @@ module IsoDoc
         tc(xml)
         wg(xml)
         bg(xml)
-        std_group(xml)
       end
 
       def society(xml)
@@ -46,63 +49,21 @@ module IsoDoc
 
       def tc(xml)
         tc = xml.at(ns("//bibdata/ext/editorialgroup/"\
-                       "technical-committee"))&.text || "&lt;Committee Name&gt;"
+                       "committee"))&.text || "&lt;Committee Name&gt;"
         set(:technical_committee, tc)
       end
 
-      def editor_names(xml, role)
-        xml.xpath(ns("//bibdata/contributor[role/@type = 'editor']"\
-                     "[role = '#{role}']/person/name/completename"))
-          &.each&.map(&:text)
-      end
-
-      def editor_name(xml, role)
-        editor_names(xml, role)&.first
-      end
-
       def wg(xml)
         wg = xml.at(ns("//bibdata/ext/editorialgroup/"\
                        "working-group")) or return nil
         set(:working_group, wg.text)
-        m = {}
-        ["Chair", "Vice-Chair", "Secretary"].each do |r|
-          a = editor_name(xml, "Working Group #{r}") and
-            m[r.downcase.gsub(/ /, "-")] = a
-        end
-        wg_members(xml, m)
-      end
-
-      def wg_members(xml, members)
-        a = editor_names(xml, "Working Group Member") and members["members"] = a
-        members["members"].empty? and (1..9).each do |i|
-          members["members"] << "Participant#{i}"
-        end
-        set(:wg_members, members)
       end
 
       def bg(xml)
         bg = xml.at(ns("//bibdata/ext/editorialgroup/"\
                        "balloting-group")) or return nil
         set(:balloting_group, bg.text)
-        m = {}
-        m["members"] = editor_names(xml, "Balloting Group Member")
-        m["members"].empty? and (1..9).each do |i|
-          m["members"] << "Balloter#{i}"
-        end
-        set(:balloting_group_members, m["members"])
-      end
-
-      def std_group(xml)
-        m = {}
-        ["Chair", "Vice-Chair", "Past Chair", "Secretary"].each do |r|
-          m[r.downcase.gsub(/ /, "-")] =
-            editor_name(xml, "Standards Board #{r}") || "&lt;Name&gt;"
-        end
-        m["members"] = editor_names(xml, "Standards Board Member")
-        m["members"].empty? and (1..9).each do |i|
-          m["members"] << "SBMember#{i}"
-        end
-        set(:std_board, m)
+        set(:balloting_group_type, bg["type"])
       end
 
       def otherid(isoxml, _out)
@@ -120,16 +81,39 @@ module IsoDoc
         set(:stdid_pdf, dn&.text || "STDXXXXX")
         dn = isoxml.at(ns("//#{id}[@scope = 'print']"))
         set(:stdid_print, dn&.text || "STDPDXXXXX")
+        dn = isoxml.at(ns("//bibdata/ext/structuredidentifier/amendment")) and
+          set(:amd, dn.text)
+        dn = isoxml.at(ns("//bibdata/ext/structuredidentifier/corrigendum")) and
+          set(:corr, dn.text)
       end
 
       def title(isoxml, _out)
         super
         draft = isoxml&.at(ns("//bibdata/version/draft"))
         doctype(isoxml, _out)
-        title = "#{@metadata[:doctype_abbrev] || '???'} for "\
-                "#{@metadata[:doctitle] || '???'}"
+        set(:full_doctitle, fulltitle(@metadata[:doctype], draft))
+        set(:abbrev_doctitle, fulltitle(@metadata[:doctype_abbrev], draft))
+        prov = isoxml&.at(ns("//bibdata/title[@type='provenance']")) and
+          set(:provenance_doctitle, prov.children.to_xml)
+      end
+
+      def fulltitle(type, draft)
+        title = "#{type || '???'} for #{@metadata[:doctitle] || '???'}"
         draft and title = "Draft #{title}"
-        set(:full_doctitle, title)
+        title
+      end
+
+      def ddMMMyyyy(isodate)
+        return nil if isodate.nil?
+
+        arr = isodate.split("-")
+        if arr.size == 1 && (/^\d+$/.match isodate)
+          Date.new(*arr.map(&:to_i)).strftime("%Y")
+        elsif arr.size == 2
+          Date.new(*arr.map(&:to_i)).strftime("%b %Y")
+        else
+          Date.parse(isodate).strftime("%d %b %Y")
+        end
       end
     end
   end

data/lib/isodoc/ieee/pdf_convert.rb

@@ -12,8 +12,8 @@ module IsoDoc
       end
 
       def pdf_stylesheet(docxml)
-        doctype = docxml&.at(ns("//bibdata/ext/doctype"))&.text
-        if doctype == "amendment"
+        doctype = docxml&.at(ns("//bibdata/ext/subdoctype"))&.text
+        if %w(amendment corrigendum erratum).include?(doctype)
           "ieee.amendment.xsl"
         else
           "ieee.standard.xsl"

data/lib/isodoc/ieee/presentation_ref.rb

@@ -0,0 +1,70 @@
+module IsoDoc
+  module IEEE
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      # Style manual 19
+      def anchor_linkend(node, linkend)
+        @bibanchors ||= biblio_ids_titles(node.document)
+        if node["citeas"] && i = @bibanchors[node["bibitemid"]]
+          biblio_anchor_linkend(node, i)
+        else super
+        end
+      end
+
+      def biblio_anchor_linkend(node, bib)
+        if %w(techreport standard).include?(bib[:type])
+          node["citeas"] + " #{bib[:ord]}"
+        else
+          "#{bib[:title]} " + node["citeas"]
+        end
+      end
+
+      def biblio_ids_titles(xmldoc)
+        xmldoc.xpath(ns("//references[@normative = 'false']/bibitem"))
+          .each_with_object({}) do |b, m|
+          m[b["id"]] =
+            { docid: pref_ref_code(b), type: b["type"],
+              title: (b.at(ns("./title")) ||
+                     b.at(ns("./formattedref")))&.text,
+              ord: b.at(ns("./docidentifier[@type = 'metanorma' or "\
+                           "@type = 'metanorma-ordinal']")).text }
+        end
+      end
+
+      def bibrenderer
+        ::Relaton::Render::IEEE::General.new(language: @lang,
+                                             i18nhash: @i18n.get)
+      end
+
+      def bibrender_relaton(xml)
+        bib = xml.dup
+        bib["suppress_identifier"] == true and
+          bib.xpath(ns("./docidentifier")).each(&:remove)
+        xml.children =
+          "#{bibrenderer.render(bib.to_xml)}"\
+          "#{xml.xpath(ns('./docidentifier | ./uri | ./note | ./title')).to_xml}"
+      end
+
+      def creatornames(bibitem)
+        ::Relaton::Render::IEEE::General
+          .new(language: @lang, i18nhash: @i18n.get,
+               template: { (bibitem["type"] || "misc").to_sym =>
+                           "{{ creatornames }}" })
+          .parse1(RelatonBib::XMLParser.from_xml(bibitem.to_xml))
+      end
+
+      def bibliography_bibitem_number1(bibitem, idx)
+        if mn = bibitem.at(ns(".//docidentifier[@type = 'metanorma']"))
+          /^\[?\d\]?$/.match?(mn&.text) and
+            idx = mn.text.sub(/^\[B?/, "").sub(/\]$/, "").to_i
+        end
+        unless bibliography_bibitem_number_skip(bibitem)
+
+          idx += 1
+          bibitem.at(ns(".//docidentifier")).previous =
+            "<docidentifier type='metanorma-ordinal'>[B#{idx}]</docidentifier>"
+        end
+        idx
+      end
+    end
+  end
+end

data/lib/isodoc/ieee/presentation_terms.rb

@@ -1,3 +1,5 @@
+require_relative "../../relaton/render/general"
+
 module IsoDoc
   module IEEE
     class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
@@ -10,7 +12,8 @@ module IsoDoc
         c = IsoDoc::XrefGen::Counter.new("@")
         elem.xpath(ns("./definition")).each do |d|
           c.increment(d)
-          d.elements.first.previous = "<strong>(#{c.print})</strong>&#xa0;"
+          d.elements.first.children.first.previous =
+            "<strong>(#{c.print})</strong>&#xa0;"
         end
       end
 
@@ -18,19 +21,29 @@ module IsoDoc
         ins = elem.at(ns("./definition")).previous_element
         coll = elem.xpath(ns("./definition"))
         coll.each(&:remove)
-        ins.next = "<definition>#{coll.map do |c|
-                                    c.children.to_xml
-                                  end }</definition>"
+        ins.next = "<definition>#{unwrap_multidef(coll)}</definition>"
+      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.elements.first.children.to_xml
+          end
+          return "<p>#{ret.join}</p>"
+        end
+        coll.map { |c| c.children.to_xml }.join
       end
 
       def unwrap_definition(docxml)
         docxml.xpath(ns("//definition/verbal-definition")).each do |v|
           next unless v.elements.all? { |e| %w(termsource p).include?(e.name) }
 
-          s = v.xpath(ns("./termsource"))
           p = v.xpath(ns("./p"))
           v.children =
-            "<p>#{p.map(&:children).map(&:to_xml).join("\n")}</p>#{s.to_xml}"
+            "<p>#{p.map(&:children).map(&:to_xml).join("\n")}</p>"\
+            "#{v.xpath(ns('./termsource')).to_xml}"
         end
         super
       end
@@ -47,21 +60,28 @@ module IsoDoc
       def term_related_collapse(coll)
         prev = 0
         coll[1..-1].each_with_index do |r, i|
-          if coll[prev]["type"] == r["type"]
-            coll[prev].at(ns("./preferred")) << "; #{r.at(ns('./preferred'))
-              .children.to_xml}"
-            r.remove
-          else prev = i
+          if coll[prev]["type"] != r["type"]
+            prev = i
+            next
           end
+          coll[prev].at(ns("./preferred")) << "; #{r.at(ns('./preferred'))
+              .children.to_xml}"
+          r.remove
         end
       end
 
       def sort_terms_key(term)
         d = term.at(ns("./preferred/expression/name | "\
-                       "./preferred/letter-designation/name | "\
+                       "./preferred/letter-symbol/name | "\
                        "./preferred/graphical-symbol/figure/name | "\
-                       "./preferred/graphical-symbol/figure/@id"))
-        d&.text&.downcase
+                       "./preferred/graphical-symbol/figure/@id | "\
+                       "./preferred"))
+        f = term.at(ns("./field-of-application")) || term.at(ns("./domain"))
+        HTMLEntities.new.decode("#{sort_terms_key1(d)} :: #{sort_terms_key1(f)}")
+      end
+
+      def sort_terms_key1(elem)
+        elem&.text&.strip&.downcase || "zzzz"
       end
 
       def term_related_reorder(coll)
@@ -96,22 +116,52 @@ module IsoDoc
       end
 
       def admitted_to_related(docxml)
-        docxml.xpath(ns("//term/admitted")).each do |a|
-          a["type"] = "equivalent"
-          a.name = "related"
-          a.children = "<preferred>#{a.children.to_xml}</preferred>"
+        docxml.xpath(ns("//term")).each do |t|
+          t.xpath(ns("./admitted | ./preferred")).each_with_index do |a, i|
+            (i.zero? ||
+             a.at(ns("./abbreviation-type | ./graphical-symbol"))) and next
+            admitted_to_related1(a, t.at(ns("./preferred")))
+          end
         end
+        term_reorder(docxml)
       end
 
-      def collapse_term(docxml)
-        docxml.xpath(ns("//term")).each do |t|
-          collapse_term1(t)
+      def admitted_to_related1(adm, pref)
+        new = adm.dup
+        adm["type"] = "equivalent"
+        adm.name = "related"
+        adm.children = "<preferred>#{adm.children.to_xml}</preferred>"
+        adm.parent.next = <<~TERM
+          <term><preferred>#{new.children.to_xml}</preferred>
+          <related type='see'><preferred>#{pref.children.to_xml}</preferred></related></term>
+        TERM
+      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)
         end
       end
 
+      def collapse_term(docxml)
+        docxml.xpath(ns("//term")).each { |t| collapse_term1(t) }
+      end
+
       def collapse_term1(term)
         ret = collapse_term_template(
-          pref: term.at(ns("./preferred")).remove,
+          pref: term.at(ns("./preferred"))&.remove,
           def: term.at(ns("./definition")),
           rels: term.xpath(ns("./related")).map(&:remove),
           source: term.at(ns("./termsource")),
@@ -122,8 +172,9 @@ module IsoDoc
 
       def collapse_term_related(rels)
         ret = rels.map do |r|
+          p = r.at(ns("./preferred"))
           "<em>#{@i18n.relatedterms[r['type']]}:</em> "\
-            "#{r.at(ns('./preferred')).children.to_xml}"
+            "#{p&.children&.to_xml || '**RELATED TERM NOT FOUND**'}"
         end.join(". ")
         ret += "." unless ret.empty?
         ret
@@ -131,11 +182,12 @@ module IsoDoc
 
       def collapse_term_template(opt)
         defn = collapse_unwrap_definition(opt[:def])
-        source = opt[:source] ? "(#{opt[:source].remove.children.to_xml})" : nil
+        src = nil
+        opt[:source] and src = "(#{opt[:source].remove.children.to_xml.strip})"
         <<~TERM
-          <p>#{opt[:pref].children.to_xml}: #{defn}
+          <p>#{opt[:pref]&.children&.to_xml || '**TERM NOT FOUND**'}: #{defn}
           #{collapse_term_related(opt[:rels])}
-          #{source}</p>
+          #{src}</p>
         TERM
       end
 
@@ -155,6 +207,14 @@ module IsoDoc
         while elem&.next_element&.name == "termsource"
           elem << "; #{elem.next_element.remove.children.to_xml}"
         end
+        adapt = termsource_adapt(elem["status"]) and
+          elem.children = l10n("#{adapt}#{elem.children.to_xml.strip}")
+      end
+
+      def termsource_adapt(status)
+        case status
+        when "adapted" then @i18n.adapted_from
+        end
       end
 
       def designation_field(desgn, name)
@@ -167,15 +227,28 @@ module IsoDoc
       end
 
       def merge_second_preferred(term)
-        super
-        term.xpath(ns("./preferred[expression/name]")).each_with_index do |p, i|
-          unless i.zero?
-            p.remove # whatever was eligible to display has already been merged
-          end
-        end
+        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|
+          p.remove.at(ns("./expression/name")).children.to_xml.strip
+        end.join(", ")
+        pref << " (#{tail})"
+      end
+
+      def termnote1(elem)
+        lbl = l10n(@xrefs.anchor(elem["id"], :label)&.strip || "???")
+        prefix_name(elem, block_delim, lower2cap(lbl), "name")
       end
 
       def term(docxml); end
+
+      def concept1(node)
+        concept_render(node, ital: "false", ref: "false",
+                             linkref: "false", linkmention: "false")
+      end
     end
   end
 end

data/lib/isodoc/ieee/presentation_xml_convert.rb

@@ -1,5 +1,6 @@
 require_relative "init"
 require_relative "presentation_terms"
+require_relative "presentation_ref"
 require "isodoc"
 
 module IsoDoc
@@ -69,6 +70,16 @@ module IsoDoc
         "—"
       end
 
+      def note1(elem)
+        return if elem.parent.name == "bibitem" || elem["notag"] == "true"
+
+        n = @xrefs.get[elem["id"]]
+        lbl = if n.nil? || n[:label].nil? || n[:label].empty? then @i18n.note
+              else l10n("#{@i18n.note} #{n[:label]}")
+              end
+        prefix_name(elem, block_delim, lbl, "name")
+      end
+
       def display_order(docxml)
         i = 0
         i = display_order_xpath(docxml, "//preface/*", i)
@@ -83,6 +94,131 @@ module IsoDoc
         display_order_xpath(docxml, "//indexsect", i)
       end
 
+      def annex1(elem)
+        lbl = @xrefs.anchor(elem["id"], :label)
+        if t = elem.at(ns("./title"))
+          t.children = "<strong>#{t.children.to_xml}</strong>"
+        end
+        prefix_name(elem, "<br/>", lbl, "title")
+      end
+
+      def bibdata_i18n(bib)
+        super
+        bibdata_dates(bib)
+      end
+
+      def bibdata_dates(bib)
+        bib.xpath(ns("./date")).each do |d|
+          d.next = d.dup
+          d.next["format"] = "ddMMMyyyy"
+          d.next.xpath(ns("./from | ./to | ./on")).each do |x|
+            x.children = ddMMMyyyy(x.text)
+          end
+        end
+      end
+
+      def ddMMMyyyy(isodate)
+        return nil if isodate.nil?
+
+        arr = isodate.split("-")
+        if arr.size == 1 && (/^\d+$/.match isodate)
+          Date.new(*arr.map(&:to_i)).strftime("%Y")
+        elsif arr.size == 2
+          Date.new(*arr.map(&:to_i)).strftime("%b %Y")
+        else
+          Date.parse(isodate).strftime("%d %b %Y")
+        end
+      end
+
+      def amend1(elem)
+        elem.xpath(ns("./description/p")).each do |p|
+          p.children = p.children.to_xml.strip
+          amend_format(p)
+        end
+        super
+      end
+
+      def amend_format(para)
+        2.times do
+          para.children.size == 1 &&
+            %(em strong).include?(para.children.first.name) and
+            para.children = para.elements.first.children
+        end
+        para.children = "<strong><em>#{para.children.to_xml}</em></strong>"
+      end
+
+      def section(docxml)
+        boilerplate(docxml)
+        super
+      end
+
+      def boilerplate(docxml)
+        docxml.xpath(ns("//clause[@id = 'boilerplate-participants']/"\
+                        "clause/title")).each(&:remove)
+        docxml.xpath(ns("//clause[@id = 'boilerplate-participants']/clause"))
+          .each do |clause|
+          participants(clause)
+        end
+      end
+
+      def participants(clause)
+        clause.xpath(ns(".//ul")).each_with_index do |ulist, idx|
+          ulist.xpath(ns("./li")).each { |list| participants1(list, idx) }
+          ulist.replace(ulist.children)
+        end
+        affiliation_header(clause)
+      end
+
+      def affiliation_header(clause)
+        clause.xpath(ns(".//p[@type = 'officeorgrepmember']")).each do |p|
+          prev = p.previous_element
+          prev && prev.name == "p" &&
+            prev["type"] == "officeorgrepmember" and next
+          p.previous = <<~HDR
+            <p type='officeorgrepmemberhdr'><em>Organization
+            Represented</em><tab/><em>Name of Representative</em></p>
+          HDR
+        end
+      end
+
+      def participants1(list, idx)
+        key = ""
+        map = list.xpath(ns(".//dt | .//dd")).each_with_object({}) do |dtd, m|
+          (dtd.name == "dt" and key = dtd.text) or
+            m[key] = @c.encode(dtd.text.strip, :hexadecimal)
+        end
+        list.replace(participant_para(map, idx))
+      end
+
+      def participant_para(map, idx)
+        name = participant_name(map)
+        if map["role"]&.casecmp("member")&.zero?
+          participant_member_para(map, name, idx)
+        else
+          participant_officeholder_para(map, name, idx)
+        end
+      end
+
+      def participant_member_para(map, name, _idx)
+        if map["company"] && (map["name"] || map["surname"])
+          pers = map["name"] || "#{map['given']} #{map['surname']}"
+          "<p type='officeorgrepmember'>#{name}<tab/>#{pers}</p>"
+        elsif map["company"] then "<p type='officeorgmember'>#{name}</p>"
+        else "<p type='officemember'>#{name}</p>"
+        end
+      end
+
+      def participant_officeholder_para(map, name, idx)
+        name = "<strong>#{name}</strong>" if idx.zero?
+        br = map["role"].size > 30 ? "<br/>" : ""
+        "<p type='officeholder' align='center'>#{name}, #{br}"\
+          "<em>#{map['role']}</em></p>"
+      end
+
+      def participant_name(map)
+        map["company"] || map["name"] || "#{map['given']} #{map['surname']}"
+      end
+
       include Init
     end
   end