metanorma-iso 2.0.8 → 2.1.1

data/lib/isodoc/iso/metadata.rb

@@ -21,8 +21,7 @@ module IsoDoc
           stage = "DTS" if stage == "DIS"
           stage = "FDTS" if stage == "FDIS"
         end
-        %w(PWI NWIP WD CD).include?(stage) && iter and
-          stage += iter
+        %w(PWI NWIP WD CD).include?(stage) && iter and stage += iter
         stage = "Pre#{stage}" if /^0\./.match?(draft)
         stage
       end
@@ -32,9 +31,7 @@ module IsoDoc
         set(:unpublished, false)
         revdate = isoxml.at(ns("//bibdata/version/revision-date"))
         set(:revdate, revdate&.text)
-        if docstatus
-          docstatus1(isoxml, docstatus)
-        end
+        docstatus and docstatus1(isoxml, docstatus)
       end
 
       def docstatus1(isoxml, docstatus)
@@ -97,25 +94,25 @@ module IsoDoc
         suffix = @c.encode(part.text, :hexadecimal)
         p = titlenums[:part]
         titlenums[:part] && titlenums[:subpart] and
-          p = "#{titlenums[:part]}–#{titlenums[:subpart]}"
+          p = "#{titlenums[:part]}–#{titlenums[:subpart]}"
         titlenums[:part] and
-          suffix = "#{part_label(lang)} #{p}: " + suffix
+          suffix = "#{part_label(lang)} #{p}: " + suffix
         suffix
       end
 
       def part_prefix(titlenums, lang)
         p = titlenums[:part]
         titlenums[:part] && titlenums[:subpart] and
-          p = "#{titlenums[:part]}–#{titlenums[:subpart]}"
-        "#{part_label(lang)} #{p}"
+          p = "#{titlenums[:part]}–#{titlenums[:subpart]}"
+        "#{part_label(lang)} #{p}"
       end
 
       def amd_prefix(titlenums, lang)
-        "#{amd_label(lang)} #{titlenums[:amd]}"
+        "#{amd_label(lang)} #{titlenums[:amd]}"
       end
 
       def corr_prefix(titlenums, lang)
-        "#{corr_label(lang)} #{titlenums[:corr]}"
+        "#{corr_label(lang)} #{titlenums[:corr]}"
       end
 
       def compose_title(tparts, tnums, lang)
@@ -124,10 +121,10 @@ module IsoDoc
           main = @c.encode(tparts[:main].text, :hexadecimal)
         tparts[:intro] &&
           main = "#{@c.encode(tparts[:intro].text,
-                              :hexadecimal)} — #{main}"
+                              :hexadecimal)} — #{main}"
         if tparts[:part]
           suffix = part_title(tparts[:part], tnums, lang)
-          main = "#{main} — #{suffix}"
+          main = "#{main} — #{suffix}"
         end
         main
       end
@@ -164,10 +161,9 @@ module IsoDoc
             @c.encode(tp[:main] ? tp[:main].text : "", :hexadecimal))
         main = compose_title(tp, tn, lang)
         set(:doctitle, main)
-        if tp[:intro]
+        tp[:intro] and
           set(:doctitleintro,
               @c.encode(tp[:intro] ? tp[:intro].text : "", :hexadecimal))
-        end
         set(:doctitlepartlabel, part_prefix(tn, lang))
         set(:doctitlepart, @c.encode(tp[:part].text, :hexadecimal)) if tp[:part]
         set(:doctitleamdlabel, amd_prefix(tn, lang)) if tn[:amd]
@@ -184,15 +180,13 @@ module IsoDoc
             @c.encode(tp[:main] ? tp[:main].text : "", :hexadecimal))
         main = compose_title(tp, tn, lang)
         set(:docsubtitle, main)
-        if tp[:intro]
+        tp[:intro] and
           set(:docsubtitleintro,
               @c.encode(tp[:intro] ? tp[:intro].text : "", :hexadecimal))
-        end
         set(:docsubtitlepartlabel, part_prefix(tn, lang))
-        if tp[:part]
+        tp[:part] and
           set(:docsubtitlepart,
               @c.encode(tp[:part].text, :hexadecimal))
-        end
         set(:docsubtitleamdlabel, amd_prefix(tn, lang)) if tn[:amd]
         set(:docsubtitleamd, @c.encode(tp[:amd].text, :hexadecimal)) if tp[:amd]
         set(:docsubtitlecorrlabel, corr_prefix(tn, lang)) if tn[:corr]

data/lib/isodoc/iso/presentation_inline.rb

@@ -0,0 +1,90 @@
+module IsoDoc
+  module Iso
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      def xref_init(lang, script, klass, labels, options)
+        @xrefs = Xref.new(lang, script, klass, labels, options)
+      end
+
+      def eref_delim(delim, type)
+        if delim == ";" then ";"
+        else type == "list" ? " " : delim
+        end
+      end
+
+      def can_conflate_eref_rendering?(refs)
+        super or return false
+
+        first = subclause?(nil, refs.first.at(ns("./locality/@type"))&.text,
+                           refs.first.at(ns("./locality/referenceFrom"))&.text)
+        refs.all? do |r|
+          subclause?(nil, r.at(ns("./locality/@type"))&.text,
+                     r.at(ns("./locality/referenceFrom"))&.text) == first
+        end
+      end
+
+      def locality_delimiter(loc)
+        loc&.next_element&.attribute("type")&.text == "list" and return " "
+        super
+      end
+
+      def eref_localities_conflated(refs, target, node)
+        droploc = node["droploc"]
+        node["droploc"] = true
+        ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
+                                                            node))
+        node["droploc"] = droploc
+        eref_localities1(target,
+                         prefix_clause(target, refs.first.at(ns("./locality"))),
+                         l10n(ret[1..-1].join), nil, node, @lang)
+      end
+
+      def prefix_clause(target, loc)
+        loc["type"] == "clause" or return loc["type"]
+
+        if subclause?(target, loc["type"],
+                      loc&.at(ns("./referenceFrom"))&.text)
+          ""
+        else
+          "clause"
+        end
+      end
+
+      def subclause?(target, type, from)
+        (from&.match?(/\./) && type == "clause") ||
+          type == "list" || target&.match(/^IEV$|^IEC 60050-/)
+      end
+
+      def eref_localities1_zh(target, type, from, upto, node)
+        ret = " 第#{from}" if from
+        ret += "&#x2013;#{upto}" if upto
+        if node["droploc"] != "true" && !subclause?(target, type, from)
+          ret += eref_locality_populate(type, node)
+        end
+        ret += ")" if type == "list"
+        ret
+      end
+
+      def eref_localities1(target, type, from, upto, node, lang = "en")
+        return nil if type == "anchor"
+
+        type = type.downcase
+        lang == "zh" and
+          return l10n(eref_localities1_zh(target, type, from, upto, node))
+        ret = if node["droploc"] != "true" && !subclause?(target, type,
+                                                          from)
+                eref_locality_populate(type, node)
+              else ""
+              end
+        ret += " #{from}" if from
+        ret += "&#x2013;#{upto}" if upto
+        ret += ")" if type == "list"
+        l10n(ret)
+      end
+
+      def prefix_container(container, linkend, target)
+        delim = @xrefs.anchor(target, :type) == "listitem" ? " " : ", "
+        l10n(@xrefs.anchor(container, :xref) + delim + linkend)
+      end
+    end
+  end
+end

data/lib/isodoc/iso/presentation_xml_convert.rb

@@ -1,11 +1,15 @@
 require_relative "init"
 require "isodoc"
 require_relative "index"
+require_relative "presentation_inline"
+require_relative "presentation_xref"
+require_relative "../../relaton/render/general"
 
 module IsoDoc
   module Iso
     class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
       def convert1(docxml, filename, dir)
+        @iso_class = instance_of?(IsoDoc::Iso::PresentationXMLConvert)
         if amd(docxml)
           @oldsuppressheadingnumbers = @suppressheadingnumbers
           @suppressheadingnumbers = true
@@ -22,104 +26,19 @@ module IsoDoc
         amd(isoxml) and @suppressheadingnumbers = true
       end
 
-      def xref_init(lang, script, klass, labels, options)
-        @xrefs = Xref.new(lang, script, klass, labels, options)
-      end
-
       def figure1(node)
         lbl = @xrefs.anchor(node["id"], :label, false) or return
         figname = node.parent.name == "figure" ? "" : "#{@i18n.figure} "
-        connective = node.parent.name == "figure" ? "&nbsp; " : "&nbsp;&mdash; "
+        connective = node.parent.name == "figure" ? "&#xa0; " : "&#xa0;&#x2014; "
         prefix_name(node, connective, l10n("#{figname}#{lbl}"), "name")
       end
 
       def example1(node)
         n = @xrefs.get[node["id"]]
-        lbl = if n.nil? || n[:label].nil? || n[:label].empty?
-                @i18n.example
-              else
-                l10n("#{@i18n.example} #{n[:label]}")
+        lbl = if n.nil? || blank?(n[:label]) then @i18n.example
+              else l10n("#{@i18n.example} #{n[:label]}")
               end
-        prefix_name(node, "&nbsp;&mdash; ", lbl, "name")
-      end
-
-      def eref_delim(delim, type)
-        if delim == ";" then ";"
-        else type == "list" ? " " : delim
-        end
-      end
-
-      def can_conflate_eref_rendering?(refs)
-        super or return false
-
-        first = subclause?(nil, refs.first.at(ns("./locality/@type"))&.text,
-                           refs.first.at(ns("./locality/referenceFrom"))&.text)
-        refs.all? do |r|
-          subclause?(nil, r.at(ns("./locality/@type"))&.text,
-                     r.at(ns("./locality/referenceFrom"))&.text) == first
-        end
-      end
-
-      def locality_delimiter(loc)
-        loc&.next_element&.attribute("type")&.text == "list" and return " "
-        super
-      end
-
-      def eref_localities_conflated(refs, target, node)
-        droploc = node["droploc"]
-        node["droploc"] = true
-        ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
-                                                            node))
-        node["droploc"] = droploc
-        eref_localities1(target,
-                         prefix_clause(target, refs.first.at(ns("./locality"))),
-                         l10n(ret[1..-1].join), nil, node, @lang)
-      end
-
-      def prefix_clause(target, loc)
-        loc["type"] == "clause" or return loc["type"]
-
-        if subclause?(target, loc["type"], loc&.at(ns("./referenceFrom"))&.text)
-          ""
-        else
-          "clause"
-        end
-      end
-
-      def subclause?(target, type, from)
-        (from&.match?(/\./) && type == "clause") ||
-          type == "list" || target&.match(/^IEV$|^IEC 60050-/)
-      end
-
-      def eref_localities1_zh(target, type, from, upto, node)
-        ret = " 第#{from}" if from
-        ret += "&ndash;#{upto}" if upto
-        if node["droploc"] != "true" && !subclause?(target, type, from)
-          ret += eref_locality_populate(type, node)
-        end
-        ret += ")" if type == "list"
-        ret
-      end
-
-      def eref_localities1(target, type, from, upto, node, lang = "en")
-        return nil if type == "anchor"
-
-        type = type.downcase
-        lang == "zh" and
-          return l10n(eref_localities1_zh(target, type, from, upto, node))
-        ret = if node["droploc"] != "true" && !subclause?(target, type, from)
-                eref_locality_populate(type, node)
-              else ""
-              end
-        ret += " #{from}" if from
-        ret += "&ndash;#{upto}" if upto
-        ret += ")" if type == "list"
-        l10n(ret)
-      end
-
-      def prefix_container(container, linkend, target)
-        delim = @xrefs.anchor(target, :type) == "listitem" ? " " : ", "
-        l10n(@xrefs.anchor(container, :xref) + delim + linkend)
+        prefix_name(node, "&#xa0;&#x2014; ", lbl, "name")
       end
 
       def example_span_label(_node, div, name)
@@ -141,8 +60,7 @@ module IsoDoc
       def clause(docxml)
         docxml.xpath(ns("//clause[not(ancestor::annex)] | "\
                         "//terms | //definitions | //references | "\
-                        "//preface/introduction[clause]"))
-          .each do |f|
+                        "//preface/introduction[clause]")).each do |f|
           clause1(f)
         end
       end
@@ -158,9 +76,7 @@ module IsoDoc
       def concept_term(docxml)
         docxml.xpath(ns("//term")).each do |f|
           m = {}
-          f.xpath(ns(".//concept")).each do |c|
-            concept_term1(c, m)
-          end
+          f.xpath(ns(".//concept")).each { |c| concept_term1(c, m) }
         end
       end
 
@@ -177,12 +93,11 @@ module IsoDoc
       end
 
       def concept1_ref_content(ref)
-        if ref.name == "termref"
-          ref.replace(@i18n.term_defined_in.sub(/%/,
-                                                ref.to_xml))
-        else
-          ref.replace("(#{ref.to_xml})")
-        end
+        repl = if ref.name == "termref"
+                 @i18n.term_defined_in.sub(/%/, ref.to_xml)
+               else "(#{ref.to_xml})"
+               end
+        ref.replace(repl)
       end
 
       def concept1(node)
@@ -244,6 +159,32 @@ module IsoDoc
         super
       end
 
+      def admonition1(elem)
+        super
+        return unless n = elem.at(ns("./name"))
+
+        p = n.next_element
+        return unless p.name == "p"
+
+        p.children.first.previous = admonition_name(n.remove.children.to_xml)
+      end
+
+      def admonition_name(xml)
+        "#{xml} &#x2014; "
+      end
+    
+      def bibrenderer
+        ::Relaton::Render::Iso::General.new(language: @lang, i18nhash: @i18n.get)
+      end
+
+      def bibrender(xml)
+        unless xml.at(ns("./formattedref"))
+          xml.children =
+            "#{bibrenderer.render(xml.to_xml)}"\
+            "#{xml.xpath(ns('./docidentifier | ./uri | ./note')).to_xml}"
+        end
+      end
+
       include Init
     end
   end

data/lib/isodoc/iso/presentation_xref.rb

@@ -0,0 +1,126 @@
+module IsoDoc
+  module Iso
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      def xref_init(lang, script, klass, labels, options)
+        @xrefs = Xref.new(lang, script, klass, labels, options)
+      end
+
+      def eref_delim(delim, type)
+        if delim == ";" then ";"
+        else type == "list" ? " " : delim
+        end
+      end
+
+      def can_conflate_eref_rendering?(refs)
+        super or return false
+
+        first = subclause?(nil, refs.first.at(ns("./locality/@type"))&.text,
+                           refs.first.at(ns("./locality/referenceFrom"))&.text)
+        refs.all? do |r|
+          subclause?(nil, r.at(ns("./locality/@type"))&.text,
+                     r.at(ns("./locality/referenceFrom"))&.text) == first
+        end
+      end
+
+      def locality_delimiter(loc)
+        loc&.next_element&.attribute("type")&.text == "list" and return " "
+        super
+      end
+
+      def eref_localities_conflated(refs, target, node)
+        droploc = node["droploc"]
+        node["droploc"] = true
+        ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
+                                                            node))
+        node["droploc"] = droploc
+        eref_localities1(target,
+                         prefix_clause(target, refs.first.at(ns("./locality"))),
+                         l10n(ret[1..-1].join), nil, node, @lang)
+      end
+
+      def prefix_clause(target, loc)
+        loc["type"] == "clause" or return loc["type"]
+
+        if subclause?(target, loc["type"],
+                      loc&.at(ns("./referenceFrom"))&.text)
+          ""
+        else "clause"
+        end
+      end
+
+      def subclause?(target, type, from)
+        (from&.match?(/\./) && type == "clause") ||
+          type == "list" ||
+          target&.gsub(/<[^>]+>/, "")&.match(/^IEV$|^IEC 60050-/)
+      end
+
+      LOCALITY2SPAN = {
+        annex: "citeapp",
+        dunno: "citebase",
+        dunno2: "citebib",
+        dunno3: "citebox",
+        dunno4: "citeen",
+        dunno5: "citeeq",
+        figure: "citefig",
+        dunno6: "citefn",
+        clause: "citesec",
+        dunno7: "citesection",
+        table: "citetbl",
+        dunno8: "citetfn",
+      }.freeze
+
+      def locality_span_wrap(ret, type)
+        type or return ret
+        m = /^(\s*)(.+?)(\s*)$/.match(ret) or return ret
+        ret = [m[1], m[2], m[3]]
+        spanclass = LOCALITY2SPAN[type.to_sym] and
+          ret[1] = "<span class='#{spanclass}'>#{ret[1]}</span>"
+        ret.join
+      end
+
+      def eref_localities1_zh(target, type, from, upto, node)
+        ret = " 第#{from}" if from
+        ret += "&#x2013;#{upto}" if upto
+        node["droploc"] != "true" && !subclause?(target, type, from) and
+          ret += eref_locality_populate(type, node)
+        ret += ")" if type == "list"
+        locality_span_wrap(ret, type)
+      end
+
+      def eref_localities1(target, type, from, upto, node, lang = "en")
+        return nil if type == "anchor"
+
+        type = type.downcase
+        lang == "zh" and
+          return l10n(eref_localities1_zh(target, type, from, upto, node))
+        ret = ""
+        node["droploc"] != "true" && !subclause?(target, type, from) and
+          ret = eref_locality_populate(type, node)
+        ret += " #{from}" if from
+        ret += "&#x2013;#{upto}" if upto
+        ret += ")" if type == "list"
+        ret = l10n(ret)
+        locality_span_wrap(ret, type)
+      end
+
+      def prefix_container(container, linkend, target)
+        delim = @xrefs.anchor(target, :type) == "listitem" ? " " : ", "
+        l10n(@xrefs.anchor(container, :xref) + delim + linkend)
+      end
+
+      def expand_citeas(text)
+        std_docid_semantic(super)
+      end
+
+      def anchor_value(id)
+        locality_span_wrap(super, @xrefs.anchor(id, :subtype) ||
+                            @xrefs.anchor(id, :type))
+      end
+
+      def anchor_linkend1(node)
+        locality_span_wrap(super, @xrefs.anchor(node["target"], :subtype) ||
+                           @xrefs.anchor(node["target"], :type))
+      end
+    end
+  end
+end

data/lib/isodoc/iso/sections.rb

@@ -9,9 +9,9 @@ module IsoDoc
       def middle_title_main(out)
         out.p(**{ class: "zzSTDTitle1" }) do |p|
           p << @meta.get[:doctitleintro]
-          p << " &mdash; " if @meta.get[:doctitleintro] && @meta.get[:doctitlemain]
+          p << " &#x2014; " if @meta.get[:doctitleintro] && @meta.get[:doctitlemain]
           p << @meta.get[:doctitlemain]
-          p << " &mdash; " if @meta.get[:doctitlemain] && @meta.get[:doctitlepart]
+          p << " &#x2014; " if @meta.get[:doctitlemain] && @meta.get[:doctitlepart]
         end
         a = @meta.get[:doctitlepart] and out.p(**{ class: "zzSTDTitle2" }) do |p|
           b = @meta.get[:doctitlepartlabel] and p << "#{b}: "

data/lib/isodoc/iso/word_cleanup.rb

@@ -65,7 +65,7 @@ module IsoDoc
         insert = docxml.at("//div[@id = 'boilerplate-license-destination']")
         auth = docxml&.at("//div[@class = 'boilerplate-license']")&.remove
         auth&.xpath(".//p[not(@class)]")&.each { |p| p["class"] = "zzWarning" }
-        auth and insert.children = auth
+        auth and insert and insert.children = auth
         insert = docxml.at("//div[@id = 'boilerplate-copyright-destination']")
         auth = docxml&.at("//div[@class = 'boilerplate-copyright']")&.remove
         auth&.xpath(".//p[not(@class)]")&.each do |p|
@@ -80,7 +80,8 @@ module IsoDoc
         auth&.xpath(".//p[@id = 'boilerplate-place']")&.each do |p|
           p["class"] = "zzCopyright1"
         end
-        auth and insert.children = auth
+        auth and insert and insert.children = auth
+        coverpage_note_cleanup(docxml)
       end
 
       def word_cleanup(docxml)
@@ -89,6 +90,19 @@ module IsoDoc
         style_cleanup(docxml)
         docxml
       end
+
+      # supply missing annex title
+      def make_WordToC(docxml, level)
+        toc = ""
+        xpath = (1..level).each.map { |i| "//h#{i}" }.join (" | ")
+        docxml.xpath(xpath).each do |h|
+          x = ""
+          x = @anchor[h.parent["id"]][:xref] if h["class"] == "ANNEX"
+          toc += word_toc_entry(h.name[1].to_i, x + header_strip(h))
+        end
+        toc.sub(/(<p class="MsoToc1">)/,
+                %{\\1#{word_toc_preface(level)}}) + WORD_TOC_SUFFIX1
+      end
     end
   end
 end

data/lib/isodoc/iso/word_convert.rb

@@ -2,6 +2,7 @@ require_relative "base_convert"
 require "isodoc"
 require_relative "init"
 require_relative "word_cleanup"
+require_relative "word_dis_convert"
 
 module IsoDoc
   module Iso
@@ -13,6 +14,11 @@ module IsoDoc
         @wordToClevels = 3 if @wordToClevels.zero?
         @htmlToClevels = options[:htmltoclevels].to_i
         @htmlToClevels = 3 if @htmlToClevels.zero?
+        init_dis
+      end
+
+      def init_dis
+        @dis = ::IsoDoc::Iso::WordDISConvert.new(options)
       end
 
       def font_choice(options)
@@ -45,16 +51,16 @@ module IsoDoc
           olstyle: "l2" }
       end
 
-      def convert1(docxml, filename, dir)
-        @dis = /^[45].$/.match?(docxml&.at(ns("//bibdata/status/stage"))&.text)
-        if @dis
-          @wordstylesheet_name = html_doc_path("wordstyle-dis.scss")
-          @standardstylesheet_name = html_doc_path("isodoc-dis.scss")
-          @wordcoverpage = html_doc_path("word_iso_titlepage-dis.html")
-          @wordintropage = html_doc_path("word_iso_intro-dis.html")
-          @header = html_doc_path("header-dis.html")
+      def convert(input_filename, file = nil, debug = false,
+                output_filename = nil)
+        file = File.read(input_filename, encoding: "utf-8") if file.nil?
+        docxml = Nokogiri::XML(file) { |config| config.huge }
+        if @dis &&
+            /^[45].$/.match?(docxml&.at(ns("//bibdata/status/stage"))&.text)
+          @dis.convert(input_filename, file, debug, output_filename)
+        else
+          super
         end
-        super
       end
 
       def make_body(xml, docxml)
@@ -82,8 +88,8 @@ module IsoDoc
           <span lang="EN-GB"><span
             style='mso-element:field-begin'></span><span
             style='mso-spacerun:yes'>&#xA0;</span>TOC
-            \\o &quot;1-#{level}&quot; \\h \\z \\t &quot;Heading
-            1;1;ANNEX;1;Biblio Title;1;Foreword Title;1;Intro Title;1&quot; <span
+            \\o "1-#{level}" \\h \\z \\t "Heading
+            1;1;ANNEX;1;Biblio Title;1;Foreword Title;1;Intro Title;1" <span
             style='mso-element:field-separator'></span></span>
         TOC
       end
@@ -171,11 +177,22 @@ module IsoDoc
 
         name&.at(ns("./strong"))&.remove # supplied by CSS list numbering
         div.h1 **{ class: "Annex" } do |t|
-          name.children.each { |c2| parse(c2, t) }
+          annex_name1(name, t)
           clause_parse_subtitle(name, t)
         end
       end
 
+      def annex_name1(name, out)
+        name.children.each do |c2|
+          if c2.name == "span" && c2["class"] == "obligation"
+            out.span **{ style: "font-weight:normal;" } do |s|
+              c2.children.each { |c3| parse(c3, s) }
+            end
+          else parse(c2, out)
+          end
+        end
+      end
+
       include BaseConvert
       include Init
     end