isodoc 1.7.5 → 1.8.0

data/lib/isodoc/presentation_function/terms.rb

@@ -0,0 +1,179 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def concept(docxml)
+      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: node["ital"] || "true",
+                                    ref: node["ref"] || "true",
+                                    linkref: node["linkref"] || "true",
+                                    linkmention: node["linkmention"] || "false")
+      if node.at(ns("//definitions//dt[@id = '#{xref}']"))
+        concept_render(node, ital: node["ital"] || "false",
+                             ref: node["ref"] || "false",
+                             linkref: node["linkref"] || "true",
+                             linkmention: node["linkmention"] || "false")
+      else concept_render(node, ital: node["ital"] || "true",
+                                ref: node["ref"] || "true",
+                                linkref: node["linkref"] || "true",
+                                linkmention: node["linkmention"] || "false")
+      end
+    end
+
+    def concept_render(node, opts)
+      node&.at(ns("./refterm"))&.remove
+      r = node.at(ns("./renderterm"))
+      ref = node.at(ns("./xref | ./eref | ./termref"))
+      ref && opts[:ref] != "false" and r&.next = " "
+      opts[:ital] == "true" and r&.name = "em"
+      if opts[:linkmention] == "true" && !r.nil? && !ref.nil?
+        ref2 = ref.clone
+        r2 = r.clone
+        r.replace(ref2).children = r2
+      end
+      concept1_ref(node, ref, opts)
+      if opts[:ital] == "false"
+        r = node.at(ns(".//renderterm"))
+        r&.replace(r&.children)
+      end
+      node.replace(node.children)
+    end
+
+    def concept1_ref(_node, ref, opts)
+      ref.nil? and return
+      return ref.remove if opts[:ref] == "false"
+
+      r = concept1_ref_content(ref)
+      ref = r.at("./descendant-or-self::xmlns:xref | "\
+                 "./descendant-or-self::xmlns:eref | "\
+                 "./descendant-or-self::xmlns:termref")
+      %w(xref eref).include? ref&.name and get_linkend(ref)
+      if opts[:linkref] == "false" && %w(xref eref).include?(ref&.name)
+        ref.replace(ref.children)
+      end
+    end
+
+    def concept1_ref_content(ref)
+      if non_locality_elems(ref).select do |c|
+           !c.text? || /\S/.match(c)
+         end.empty?
+        ref.replace(@i18n.term_defined_in.sub(/%/,
+                                              ref.to_xml))
+      else ref.replace("[#{ref.to_xml}]")
+      end
+    end
+
+    def related(docxml)
+      docxml.xpath(ns("//related")).each { |f| related1(f) }
+    end
+
+    def related1(node)
+      p = node.at(ns("./preferred"))
+      ref = node.at(ns("./xref | ./eref | ./termref"))
+      label = @i18n.relatedterms[node["type"]].upcase
+      node.replace(l10n("<p><strong>#{label}:</strong> "\
+                        "<em>#{p.to_xml}</em> (#{ref.to_xml})</p>"))
+    end
+
+    def designation(docxml)
+      docxml.xpath(ns("//preferred | //admitted | //deprecates")).each do |p|
+        designation1(p)
+      end
+      docxml.xpath(ns("//term")).each do |t|
+        merge_second_preferred(t)
+      end
+    end
+
+    def merge_second_preferred(term)
+      pref = nil
+      term.xpath(ns("./preferred")).each_with_index do |p, i|
+        if i.zero? then pref = p
+        else
+          pref << l10n("; #{p.children.to_xml}")
+          p.remove
+        end
+      end
+    end
+
+    def designation1(desgn)
+      s = desgn.at(ns("./termsource"))
+      name = desgn.at(ns("./expression/name | ./letter-symbol/name | "\
+                         "./graphical-symbol")) or return
+
+      g = desgn.at(ns("./expression/grammar")) and
+        name << " #{designation_grammar(g).join(', ')}"
+      desgn.children = name.children
+      s and desgn.next = s
+    end
+
+    def designation_grammar(grammar)
+      ret = []
+      grammar.xpath(ns("./gender")).each do |x|
+        ret << @i18n.grammar_abbrevs[x.text]
+      end
+      %w(isPreposition isParticiple isAdjective isVerb isAdverb isNoun)
+        .each do |x|
+        grammar.at(ns("./#{x}[text() = 'true']")) and
+          ret << @i18n.grammar_abbrevs[x]
+      end
+      ret
+    end
+
+        def definition1(elem)
+          nodes = Nokogiri::XML::NodeSet.new(elem.document)
+          v = elem&.at(ns("./verbaldefinition"))&.children and nodes += v
+          n = elem&.at(ns("./nonverbalrepresentation"))&.children and nodes += n
+          elem.children = nodes
+        end
+
+            def termexample(docxml)
+      docxml.xpath(ns("//termexample")).each do |f|
+        example1(f)
+      end
+    end
+
+                def termnote(docxml)
+      docxml.xpath(ns("//termnote")).each do |f|
+        termnote1(f)
+      end
+    end
+
+    # introduce name element
+    def termnote1(elem)
+      lbl = l10n(@xrefs.anchor(elem["id"], :label) || "???")
+      prefix_name(elem, "", lower2cap(lbl), "name")
+    end
+
+    def termdefinition(docxml)
+      docxml.xpath(ns("//term[definition]")).each do |f|
+        termdefinition1(f)
+      end
+    end
+
+    def termdefinition1(elem)
+      unwrap_definition(elem)
+      multidef(elem) if elem.xpath(ns("./definition")).size > 1
+      end
+
+    def multidef(elem)
+      d = elem.at(ns("./definition"))
+      d = d.replace("<ol><li>#{d.children.to_xml}</li></ol>").first
+      elem.xpath(ns("./definition")).each do |f|
+        f = f.replace("<li>#{f.children.to_xml}</li>").first
+        d << f
+      end
+      d.wrap("<definition></definition>")
+    end
+
+           def unwrap_definition(elem)
+             elem.xpath(ns("./definition")).each do |d|
+          nodes = Nokogiri::XML::NodeSet.new(elem.document)
+          v = d&.at(ns("./verbaldefinition"))&.children and nodes += v
+          n = d&.at(ns("./nonverbalrepresentation"))&.children and nodes += n
+          d.children = nodes
+             end
+        end
+  end
+end

data/lib/isodoc/presentation_xml_convert.rb

@@ -1,4 +1,5 @@
 require_relative "presentation_function/block"
+require_relative "presentation_function/terms"
 require_relative "presentation_function/inline"
 require_relative "presentation_function/math"
 require_relative "presentation_function/section"
@@ -25,6 +26,7 @@ module IsoDoc
       @xrefs.parse docxml
       section docxml
       block docxml
+      terms docxml
       inline docxml
     end
 
@@ -46,17 +48,13 @@ module IsoDoc
       sourcecode docxml
       formula docxml
       example docxml
-      termexample docxml
       note docxml
-      termnote docxml
-      termdefinition docxml
       permission docxml
       requirement docxml
       recommendation docxml
     end
 
     def inline(docxml)
-      concept docxml
       xref docxml
       eref docxml
       origin docxml
@@ -65,6 +63,15 @@ module IsoDoc
       variant docxml
     end
 
+    def terms(docxml)
+      termexample docxml
+      termnote docxml
+      termdefinition docxml
+      designation docxml
+      concept docxml
+      related docxml
+    end
+
     def postprocess(result, filename, _dir)
       toXML(result, filename)
       @files_to_delete.each { |f| FileUtils.rm_rf f }

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "1.7.5".freeze
+  VERSION = "1.8.0".freeze
 end

data/lib/isodoc/word_function/body.rb

@@ -1,231 +1,233 @@
 require_relative "./table"
 require_relative "./inline"
 
-module IsoDoc::WordFunction
-  module Body
-    def define_head(head, filename, _dir)
-      head.style do |style|
-        loc = File.join(File.dirname(__FILE__), "..", "base_style",
-                        "metanorma_word.scss")
-        stylesheet = File.read(loc, encoding: "utf-8")
-        style.comment "\n#{stylesheet}\n"
-      end
-      super
-    end
-
-    def body_attr
-      { lang: "EN-US", link: "blue", vlink: "#954F72" }
-    end
+module IsoDoc
+  module WordFunction
+    module Body
+      def define_head(head, filename, _dir)
+        head.style do |style|
+          loc = File.join(File.dirname(__FILE__), "..", "base_style",
+                          "metanorma_word.scss")
+          stylesheet = File.read(loc, encoding: "utf-8")
+          style.comment "\n#{stylesheet}\n"
+        end
+        super
+      end
 
-    def make_body1(body, _docxml)
-      body.div **{ class: "WordSection1" } do |div1|
-        div1.p { |p| p << "&nbsp;" } # placeholder
+      def body_attr
+        { lang: "EN-US", link: "blue", vlink: "#954F72" }
       end
-      section_break(body)
-    end
 
-    def make_body2(body, docxml)
-      body.div **{ class: "WordSection2" } do |div2|
-        boilerplate docxml, div2
-        preface_block docxml, div2
-        abstract docxml, div2
-        foreword docxml, div2
-        introduction docxml, div2
-        preface docxml, div2
-        acknowledgements docxml, div2
-        div2.p { |p| p << "&nbsp;" } # placeholder
-      end
-      section_break(body)
-    end
+      def make_body1(body, _docxml)
+        body.div **{ class: "WordSection1" } do |div1|
+          div1.p { |p| p << "&nbsp;" } # placeholder
+        end
+        section_break(body)
+      end
+
+      def make_body2(body, docxml)
+        body.div **{ class: "WordSection2" } do |div2|
+          boilerplate docxml, div2
+          preface_block docxml, div2
+          abstract docxml, div2
+          foreword docxml, div2
+          introduction docxml, div2
+          preface docxml, div2
+          acknowledgements docxml, div2
+          div2.p { |p| p << "&nbsp;" } # placeholder
+        end
+        section_break(body)
+      end
 
-    def make_body3(body, docxml)
-      body.div **{ class: "WordSection3" } do |div3|
-        middle docxml, div3
-        footnotes div3
-        comments div3
+      def make_body3(body, docxml)
+        body.div **{ class: "WordSection3" } do |div3|
+          middle docxml, div3
+          footnotes div3
+          comments div3
+        end
       end
-    end
 
-    def insert_tab(out, count)
-      out.span **attr_code(style: "mso-tab-count:#{count}") do |span|
-        [1..count].each { span << "&#xA0; " }
+      def insert_tab(out, count)
+        out.span **attr_code(style: "mso-tab-count:#{count}") do |span|
+          [1..count].each { span << "&#xA0; " }
+        end
       end
-    end
 
-    def para_class(_node)
-      classtype = nil
-      classtype = "Note" if @note
-      classtype = "MsoCommentText" if in_comment
-      classtype = "Sourcecode" if @annotation
-      classtype
-    end
+      def para_class(_node)
+        classtype = nil
+        classtype = "Note" if @note
+        classtype = "MsoCommentText" if in_comment
+        classtype = "Sourcecode" if @annotation
+        classtype
+      end
 
-    def para_parse(node, out)
-      out.p **attr_code(para_attrs(node)) do |p|
-        unless @termdomain.empty?
-          p << "&lt;#{@termdomain}&gt; "
-          @termdomain = ""
+      def para_parse(node, out)
+        out.p **attr_code(para_attrs(node)) do |p|
+          unless @termdomain.empty?
+            p << "&lt;#{@termdomain}&gt; "
+            @termdomain = ""
+          end
+          node.children.each { |n| parse(n, p) unless n.name == "note" }
         end
-        node.children.each { |n| parse(n, p) unless n.name == "note" }
+        node.xpath(ns("./note")).each { |n| parse(n, out) }
       end
-      node.xpath(ns("./note")).each { |n| parse(n, out) }
-    end
 
-    WORD_DT_ATTRS = { class: @note ? "Note" : nil, align: "left",
-                      style: "margin-left:0pt;text-align:left;" }.freeze
+      WORD_DT_ATTRS = { class: @note ? "Note" : nil, align: "left",
+                        style: "margin-left:0pt;text-align:left;" }.freeze
 
-    def dt_parse(dt, term)
-      term.p **attr_code(WORD_DT_ATTRS) do |p|
-        if dt.elements.empty?
-          p << dt.text
-        else
-          dt.children.each { |n| parse(n, p) }
+      def dt_parse(dterm, term)
+        term.p **attr_code(WORD_DT_ATTRS) do |p|
+          if dterm.elements.empty?
+            p << dterm.text
+          else
+            dterm.children.each { |n| parse(n, p) }
+          end
         end
       end
-    end
 
-    def dl_parse(node, out)
-      out.table **{ class: "dl" } do |v|
-        node.elements.select { |n| dt_dd? n }.each_slice(2) do |dt, dd|
-          v.tr do |tr|
-            tr.td **{ valign: "top", align: "left" } do |term|
-              dt_parse(dt, term)
-            end
-            tr.td **{ valign: "top" } do |listitem|
-              dd.children.each { |n| parse(n, listitem) }
+      def dl_parse(node, out)
+        out.table **{ class: "dl" } do |v|
+          node.elements.select { |n| dt_dd? n }.each_slice(2) do |dt, dd|
+            v.tr do |tr|
+              tr.td **{ valign: "top", align: "left" } do |term|
+                dt_parse(dt, term)
+              end
+              tr.td **{ valign: "top" } do |listitem|
+                dd.children.each { |n| parse(n, listitem) }
+              end
             end
           end
+          dl_parse_notes(node, v)
         end
-        dl_parse_notes(node, v)
       end
-    end
 
-    def dl_parse_notes(node, v)
-      return if node.elements.reject { |n| dt_dd? n }.empty?
+      def dl_parse_notes(node, out)
+        return if node.elements.reject { |n| dt_dd? n }.empty?
 
-      v.tr do |tr|
-        tr.td **{ colspan: 2 } do |td|
-          node.elements.reject { |n| dt_dd? n }.each { |n| parse(n, td) }
+        out.tr do |tr|
+          tr.td **{ colspan: 2 } do |td|
+            node.elements.reject { |n| dt_dd? n }.each { |n| parse(n, td) }
+          end
         end
       end
-    end
 
-    def figure_get_or_make_dl(node)
-      dl = node.at(".//table[@class = 'dl']")
-      if dl.nil?
-        node.add_child("<p><b>#{@i18n.key}</b></p><table class='dl'></table>")
+      def figure_get_or_make_dl(node)
         dl = node.at(".//table[@class = 'dl']")
+        if dl.nil?
+          node.add_child("<p><b>#{@i18n.key}</b></p><table class='dl'></table>")
+          dl = node.at(".//table[@class = 'dl']")
+        end
+        dl
+      end
+
+      def figure_aside_process(fig, aside, key)
+        # get rid of footnote link, it is in diagram
+        fig&.at("./a[@class='TableFootnoteRef']")&.remove
+        fnref = fig.at(".//span[@class='TableFootnoteRef']/..")
+        tr = key.add_child("<tr></tr>").first
+        dt = tr.add_child("<td valign='top' align='left'></td>").first
+        dd = tr.add_child("<td valign='top'></td>").first
+        fnref.parent = dt
+        aside.xpath(".//p").each do |a|
+          a.delete("class")
+          a.parent = dd
+        end
       end
-      dl
-    end
-
-    def figure_aside_process(fig, aside, key)
-      # get rid of footnote link, it is in diagram
-      fig&.at("./a[@class='TableFootnoteRef']")&.remove
-      fnref = fig.at(".//span[@class='TableFootnoteRef']/..")
-      tr = key.add_child("<tr></tr>").first
-      dt = tr.add_child("<td valign='top' align='left'></td>").first
-      dd = tr.add_child("<td valign='top'></td>").first
-      fnref.parent = dt
-      aside.xpath(".//p").each do |a|
-        a.delete("class")
-        a.parent = dd
-      end
-    end
 
-    def note_p_parse(node, div)
-      name = node&.at(ns("./name"))&.remove
-      div.p **{ class: "Note" } do |p|
-        p.span **{ class: "note_label" } do |s|
-          name&.children&.each { |n| parse(n, s) }
+      def note_p_parse(node, div)
+        name = node&.at(ns("./name"))&.remove
+        div.p **{ class: "Note" } do |p|
+          p.span **{ class: "note_label" } do |s|
+            name&.children&.each { |n| parse(n, s) }
+          end
+          insert_tab(p, 1)
+          node.first_element_child.children.each { |n| parse(n, p) }
         end
-        insert_tab(p, 1)
-        node.first_element_child.children.each { |n| parse(n, p) }
+        node.element_children[1..-1].each { |n| parse(n, div) }
       end
-      node.element_children[1..-1].each { |n| parse(n, div) }
-    end
 
-    def note_parse1(node, div)
-      name = node&.at(ns("./name"))&.remove
-      div.p **{ class: "Note" } do |p|
-        p.span **{ class: "note_label" } do |s|
-          name&.children&.each { |n| parse(n, s) }
+      def note_parse1(node, div)
+        name = node&.at(ns("./name"))&.remove
+        div.p **{ class: "Note" } do |p|
+          p.span **{ class: "note_label" } do |s|
+            name&.children&.each { |n| parse(n, s) }
+          end
+          insert_tab(p, 1)
         end
-        insert_tab(p, 1)
+        node.children.each { |n| parse(n, div) }
       end
-      node.children.each { |n| parse(n, div) }
-    end
 
-    def termnote_parse(node, out)
-      name = node&.at(ns("./name"))&.remove
-      out.div **note_attrs(node) do |div|
-        div.p **{ class: "Note" } do |p|
-          if name
-            name.children.each { |n| parse(n, p) }
-            p << l10n(": ")
+      def termnote_parse(node, out)
+        name = node&.at(ns("./name"))&.remove
+        out.div **note_attrs(node) do |div|
+          div.p **{ class: "Note" } do |p|
+            if name
+              name.children.each { |n| parse(n, p) }
+              p << l10n(": ")
+            end
+            para_then_remainder(node.first_element_child, node, p, div)
           end
-          para_then_remainder(node.first_element_child, node, p, div)
         end
       end
-    end
 
-    def para_attrs(node)
-      attrs = { class: para_class(node), id: node["id"], style: "" }
-      unless node["align"].nil?
-        attrs[:align] = node["align"] unless node["align"] == "justify"
-        attrs[:style] += "text-align:#{node['align']};"
+      def para_attrs(node)
+        attrs = { class: para_class(node), id: node["id"], style: "" }
+        unless node["align"].nil?
+          attrs[:align] = node["align"] unless node["align"] == "justify"
+          attrs[:style] += "text-align:#{node['align']};"
+        end
+        attrs[:style] += keep_style(node).to_s
+        attrs[:style] = nil if attrs[:style].empty?
+        attrs
       end
-      attrs[:style] += keep_style(node).to_s
-      attrs[:style] = nil if attrs[:style].empty?
-      attrs
-    end
 
-    def example_table_attr(node)
-      super.merge({
-                    style: "mso-table-lspace:15.0cm;margin-left:423.0pt;"\
-                    "mso-table-rspace:15.0cm;margin-right:423.0pt;"\
-                    "mso-table-anchor-horizontal:column;"\
-                    "mso-table-overlap:never;border-collapse:collapse;"\
-                    "#{keep_style(node)}",
-                  })
-    end
+      def example_table_attr(node)
+        super.merge(
+          style: "mso-table-lspace:15.0cm;margin-left:423.0pt;"\
+                 "mso-table-rspace:15.0cm;margin-right:423.0pt;"\
+                 "mso-table-anchor-horizontal:column;"\
+                 "mso-table-overlap:never;border-collapse:collapse;"\
+                 "#{keep_style(node)}",
+        )
+      end
 
-    def formula_where(deflist, out)
-      return unless deflist
+      def formula_where(deflist, out)
+        return unless deflist
 
-      out.p { |p| p << @i18n.where }
-      parse(deflist, out)
-      out.parent.at("./table")["class"] = "formula_dl"
-    end
+        out.p { |p| p << @i18n.where }
+        parse(deflist, out)
+        out.parent.at("./table")["class"] = "formula_dl"
+      end
 
-    def formula_parse1(node, out)
-      out.div **attr_code(class: "formula") do |div|
-        div.p do |_p|
-          parse(node.at(ns("./stem")), div)
-          insert_tab(div, 1)
-          if lbl = node&.at(ns("./name"))&.text
-            div << "(#{lbl})"
+      def formula_parse1(node, out)
+        out.div **attr_code(class: "formula") do |div|
+          div.p do |_p|
+            parse(node.at(ns("./stem")), div)
+            insert_tab(div, 1)
+            if lbl = node&.at(ns("./name"))&.text
+              div << "(#{lbl})"
+            end
           end
         end
       end
-    end
 
-    def li_parse(node, out)
-      out.li **attr_code(id: node["id"]) do |li|
-        if node["uncheckedcheckbox"] == "true"
-          li << '<span class="zzMoveToFollowing">&#x2610; </span>'
-        elsif node["checkedcheckbox"] == "true"
-          li << '<span class="zzMoveToFollowing">&#x2611; </span>'
+      def li_parse(node, out)
+        out.li **attr_code(id: node["id"]) do |li|
+          if node["uncheckedcheckbox"] == "true"
+            li << '<span class="zzMoveToFollowing">&#x2610; </span>'
+          elsif node["checkedcheckbox"] == "true"
+            li << '<span class="zzMoveToFollowing">&#x2611; </span>'
+          end
+          node.children.each { |n| parse(n, li) }
         end
-        node.children.each { |n| parse(n, li) }
       end
-    end
 
-    def suffix_url(url)
-      return url if %r{^https?://}.match?(url)
-      return url unless File.extname(url).empty?
+      def suffix_url(url)
+        return url if %r{^https?://}.match?(url)
+        return url unless File.extname(url).empty?
 
-      url.sub(/#{File.extname(url)}$/, ".doc")
+        url.sub(/#{File.extname(url)}$/, ".doc")
+      end
     end
   end
 end