isodoc 1.1.4 → 1.2.0

data/lib/isodoc/metadata.rb

@@ -16,16 +16,17 @@ module IsoDoc
     end
 
     def l10n(a, b, c)
-      IsoDoc::Function::I18n::l10n(a, b, c)
+      @i18n.l10n(a, b, c)
     end
 
-    def initialize(lang, script, labels, fonts_options = {})
+    def initialize(lang, script, i18n, fonts_options = {})
       @metadata = {}
       DATETYPES.each { |w| @metadata["#{w.gsub(/-/, '_')}date".to_sym] = 'XXX' }
       @lang = lang
       @script = script
       @c = HTMLEntities.new
-      @labels = labels
+      @i18n = i18n
+      @labels = @i18n.get
       @fonts_options = fonts_options
     end
 

data/lib/isodoc/metadata_date.rb

@@ -20,7 +20,7 @@ module IsoDoc
     def monthyr(isodate)
       m = /(?<yr>\d\d\d\d)-(?<mo>\d\d)/.match isodate
       return isodate unless m && m[:yr] && m[:mo]
-      IsoDoc::Function::I18n::l10n("#{months[m[:mo].to_sym]} #{m[:yr]}",
+      l10n("#{months[m[:mo].to_sym]} #{m[:yr]}",
                                    @lang, @script)
     end
 

data/lib/isodoc/presentation_function/block.rb

@@ -0,0 +1,138 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def figure(docxml)
+      docxml.xpath(ns("//figure")).each do |f|
+        figure1(f)
+      end
+    end
+
+    def figure1(f)
+      return sourcecode1(f) if f["class"] == "pseudocode" ||
+        f["type"] == "pseudocode"
+      return if labelled_ancestor(f) && f.ancestors("figure").empty?
+      return if f.at(ns("./figure")) and !f.at(ns("./name"))
+      lbl = @xrefs.anchor(f['id'], :label, false) or return
+      prefix_name(f, "&nbsp;&mdash; ", l10n("#{@i18n.figure} #{lbl}"), "name")
+    end
+
+    def prefix_name(f, delim, number, elem)
+      return if number.nil? || number.empty?
+      unless name = f.at(ns("./#{elem}"))
+        f.children.empty? and f.add_child("<#{elem}></#{elem}>") or
+          f.children.first.previous = "<#{elem}></#{elem}>"
+          name = f.children.first
+      end
+      name.children.empty? ? name.add_child(number) :
+        ( name.children.first.previous = "#{number}#{delim}" )
+    end
+
+    def sourcecode(docxml)
+      docxml.xpath(ns("//sourcecode")).each do |f|
+        sourcecode1(f)
+      end
+    end
+
+    def sourcecode1(f)
+      return if labelled_ancestor(f)
+      return unless f.ancestors("example").empty?
+      lbl = @xrefs.anchor(f['id'], :label, false) or return
+      prefix_name(f, "&nbsp;&mdash; ", l10n("#{@i18n.figure} #{lbl}"), "name")
+    end
+
+    def formula(docxml)
+      docxml.xpath(ns("//formula")).each do |f|
+        formula1(f)
+      end
+    end
+
+    # introduce name element
+    def formula1(f)
+      lbl = @xrefs.anchor(f['id'], :label, false)
+      prefix_name(f, "", lbl, "name")
+    end
+
+    def example(docxml)
+      docxml.xpath(ns("//example")).each do |f|
+        example1(f)
+      end
+    end
+
+    def termexample(docxml)
+      docxml.xpath(ns("//termexample")).each do |f|
+        example1(f)
+      end
+    end
+
+    def example1(f)
+      n = @xrefs.get[f["id"]]
+      lbl = (n.nil? || n[:label].nil? || n[:label].empty?) ? @i18n.example :
+        l10n("#{@i18n.example} #{n[:label]}")
+      prefix_name(f, "&nbsp;&mdash; ", lbl, "name")
+    end
+
+    def note(docxml)
+      docxml.xpath(ns("//note")).each do |f|
+        note1(f)
+      end
+    end
+
+    # introduce name element
+    def note1(f)
+      return if f.parent.name == "bibitem"
+      n = @xrefs.get[f["id"]]
+      lbl = (@i18n.note if n.nil? || n[:label].nil? || n[:label].empty?) ?
+        @i18n.note : l10n("#{@i18n.note} #{n[:label]}")
+      prefix_name(f, "", lbl, "name")
+    end
+
+    def termnote(docxml)
+      docxml.xpath(ns("//termnote")).each do |f|
+        termnote1(f)
+      end
+    end
+
+    # introduce name element
+    def termnote1(f)
+      lbl = l10n(@xrefs.anchor(f['id'], :label) || '???')
+      prefix_name(f, "", lbl, "name")
+    end
+
+    def recommendation(docxml)
+      docxml.xpath(ns("//recommendation")).each do |f|
+        recommendation1(f, @i18n.recommendation)
+      end
+    end
+
+    def requirement(docxml)
+      docxml.xpath(ns("//requirement")).each do |f|
+        recommendation1(f, @i18n.requirement)
+      end
+    end
+
+    def permission(docxml)
+      docxml.xpath(ns("//permission")).each do |f|
+        recommendation1(f, @i18n.permission)
+      end
+    end
+
+    # introduce name element
+    def recommendation1(f, type)
+      n = @xrefs.anchor(f['id'], :label, false)
+      lbl = (n.nil? ? type : l10n("#{type} #{n}"))
+      prefix_name(f, "", lbl, "name")
+    end
+
+    def table(docxml)
+      docxml.xpath(ns("//table")).each do |f|
+        table1(f)
+      end
+    end
+
+    def table1(f)
+      return if labelled_ancestor(f)
+      return if f["unnumbered"] && !f.at(ns("./name"))
+      n = @xrefs.anchor(f['id'], :label, false)
+      prefix_name(f, "&nbsp;&mdash; ", l10n("#{@i18n.table} #{n}"), "name")
+    end
+  end
+end

data/lib/isodoc/presentation_function/inline.rb

@@ -0,0 +1,131 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def prefix_container(container, linkend, _target)
+      l10n(@xrefs.anchor(container, :xref) + ", " + linkend)
+    end
+
+    def anchor_linkend(node, linkend)
+      if node["citeas"].nil? && node["bibitemid"]
+        return @xrefs.anchor(node["bibitemid"] ,:xref) || "???"
+      elsif node["target"] && !/.#./.match(node["target"])
+        linkend = @xrefs.anchor(node["target"], :xref)
+        container = @xrefs.anchor(node["target"], :container, false)
+        (container && get_note_container_id(node) != container &&
+         @xrefs.get[node["target"]]) &&
+        linkend = prefix_container(container, linkend, node["target"])
+        linkend = capitalise_xref(node, linkend)
+      end
+      linkend || "???"
+    end
+
+    def capitalise_xref(node, linkend)
+      return linkend unless %w(Latn Cyrl Grek).include? @script
+      return linkend&.capitalize if node["case"] == "capital"
+      return linkend&.downcase if node["case"] == "lowercase"
+      return linkend if linkend[0,1].match(/\p{Upper}/)
+      prec = nearest_block_parent(node).xpath("./descendant-or-self::text()") &
+        node.xpath("./preceding::text()")
+      (prec.empty? || /(?!<[^.].)\.\s+$/.match(prec.map { |p| p.text }.join)) ?
+        linkend&.capitalize : linkend
+    end
+
+    def nearest_block_parent(node)
+      until %w(p title td th name formula 
+        li dt dd sourcecode pre).include?(node.name)
+        node = node.parent
+      end
+      node
+    end
+
+    def non_locality_elems(node)
+      node.children.select do |c|
+        !%w{locality localityStack}.include? c.name
+      end
+    end
+
+    def get_linkend(node)
+      contents = non_locality_elems(node).select { |c| !c.text? || /\S/.match(c) }
+      return unless contents.empty?
+      link = anchor_linkend(node, docid_l10n(node["target"] || node["citeas"]))
+      link += eref_localities(node.xpath(ns("./locality | ./localityStack")), link)
+      non_locality_elems(node).each { |n| n.remove }
+      node.add_child(link)
+    end
+    # so not <origin bibitemid="ISO7301" citeas="ISO 7301">
+    # <locality type="section"><reference>3.1</reference></locality></origin>
+
+    def eref_localities(refs, target)
+      ret = ""
+      refs.each_with_index do |r, i|
+        delim = ","
+        delim = ";" if r.name == "localityStack" && i>0
+        if r.name == "localityStack"
+          r.elements.each_with_index do |rr, j|
+            ret += eref_localities0(rr, j, target, delim)
+            delim = ","
+          end
+        else
+          ret += eref_localities0(r, i, target, delim)
+        end
+      end
+      ret
+    end
+
+    def eref_localities0(r, i, target, delim)
+      if r["type"] == "whole" then l10n("#{delim} #{@i18n.wholeoftext}")
+      else
+        eref_localities1(target, r["type"], r.at(ns("./referenceFrom")),
+                         r.at(ns("./referenceTo")), delim, @lang)
+      end
+    end
+
+     # TODO: move to localization file
+    def eref_localities1_zh(target, type, from, to, delim)
+      ret = "#{delim} 第#{from.text}" if from
+      ret += "&ndash;#{to.text}" if to
+      loc = (@i18n.locality[type] || type.sub(/^locality:/, "").capitalize )
+      ret += " #{loc}"
+      ret
+    end
+
+    # TODO: move to localization file
+    def eref_localities1(target, type, from, to, delim, lang = "en")
+      return "" if type == "anchor"
+      return l10n(eref_localities1_zh(target, type, from, to, delim)) if lang == "zh"
+      ret = delim
+      loc = @i18n.locality[type] || type.sub(/^locality:/, "").capitalize
+      ret += " #{loc}"
+      ret += " #{from.text}" if from
+      ret += "&ndash;#{to.text}" if to
+      l10n(ret)
+    end
+
+    def xref(docxml)
+      docxml.xpath(ns("//xref")).each do |f|
+        xref1(f)
+      end
+    end
+
+    def eref(docxml)
+      docxml.xpath(ns("//eref")).each do |f|
+        xref1(f)
+      end
+    end
+
+    def origin(docxml)
+      docxml.xpath(ns("//origin[not(termref)]")).each do |f|
+        xref1(f)
+      end
+    end
+
+    def quotesource(docxml)
+      docxml.xpath(ns("//quote/source")).each do |f|
+        xref1(f)
+      end
+    end
+
+    def xref1(f)
+      get_linkend(f)
+    end
+  end
+end

data/lib/isodoc/presentation_function/section.rb

@@ -0,0 +1,46 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def clause(docxml)
+      docxml.xpath(ns("//clause | "\
+                      "//terms | //definitions | //references")).
+                     each do |f|
+        clause1(f)
+      end
+    end
+
+    def clause1(f)
+      level = @xrefs.anchor(f['id'], :level, false) || "1"
+      t = f.at(ns("./title")) and t["depth"] = level
+      return if !f.ancestors("boilerplate").empty?
+      return if @suppressheadingnumbers || f["unnumbered"]
+      lbl = @xrefs.anchor(f['id'], :label,
+                          f.parent.name != "sections") or return
+      prefix_name(f, "<tab/>", "#{lbl}#{clausedelim}", "title")
+    end
+
+    def annex(docxml)
+      docxml.xpath(ns("//annex")).each do |f|
+        annex1(f)
+      end
+    end
+
+    def annex1(f)
+      lbl = @xrefs.anchor(f['id'], :label)
+      if t = f.at(ns("./title"))
+        t.children = "<strong>#{t.children.to_xml}</strong>"
+      end
+      prefix_name(f, "<br/><br/>", lbl, "title")
+    end
+
+    def term(docxml)
+      docxml.xpath(ns("//term")).each do |f|
+        term1(f)
+      end
+    end
+
+    def term1(f)
+      lbl = @xrefs.get[f["id"]][:label] or return
+      prefix_name(f, "", "#{lbl}#{clausedelim}", "name")
+    end
+  end
+end

data/lib/isodoc/presentation_xml_convert.rb

@@ -1,3 +1,7 @@
+require_relative "presentation_function/block"
+require_relative "presentation_function/inline"
+require_relative "presentation_function/section"
+
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
     def initialize(options)
@@ -9,21 +13,50 @@ module IsoDoc
     def convert1(docxml, filename, dir)
       @xrefs.parse docxml
       info docxml, nil
+      conversions(docxml)
       docxml.to_xml
     end
 
+    def conversions(docxml)
+      section docxml
+      block docxml
+      inline docxml
+    end
+
+    def section(docxml)
+      clause docxml
+      annex docxml
+      term docxml
+    end
+
+    def block(docxml)
+      table docxml
+      figure docxml
+      sourcecode docxml
+      formula docxml
+      example docxml
+      termexample docxml
+      note docxml
+      termnote docxml
+      permission docxml
+      requirement docxml
+      recommendation docxml
+    end
+
+    def inline(docxml)
+      xref docxml
+      eref docxml
+      origin docxml
+      quotesource docxml
+    end
+
     def postprocess(result, filename, dir)
-      #result = from_xhtml(cleanup(to_xhtml(textcleanup(result))))
       toXML(result, filename)
       @files_to_delete.each { |f| FileUtils.rm_rf f }
     end
 
     def toXML(result, filename)
-      #result = (from_xhtml(html_cleanup(to_xhtml(result))))
-      #result = from_xhtml(move_images(to_xhtml(result)))
-      #result = html5(script_cdata(inject_script(result)))
       File.open(filename, "w:UTF-8") { |f| f.write(result) }
     end
   end
 end
-

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "1.1.4".freeze
+  VERSION = "1.2.0".freeze
 end

data/lib/isodoc/word_function/body.rb

@@ -111,7 +111,7 @@ module IsoDoc::WordFunction
     def figure_get_or_make_dl(t)
       dl = t.at(".//table[@class = 'dl']")
       if dl.nil?
-        t.add_child("<p><b>#{@key_lbl}</b></p><table class='dl'></table>")
+        t.add_child("<p><b>#{@i18n.key}</b></p><table class='dl'></table>")
         dl = t.at(".//table[@class = 'dl']")
       end
       dl
@@ -132,9 +132,10 @@ module IsoDoc::WordFunction
     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|
-          s << note_label(node)
+          name and name.children.each { |n| parse(n, s) }
         end
         insert_tab(p, 1)
         node.first_element_child.children.each { |n| parse(n, p) }
@@ -143,9 +144,10 @@ module IsoDoc::WordFunction
     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|
-          s << note_label(node)
+          name and name.children.each { |n| parse(n, s) }
         end
         insert_tab(p, 1)
       end
@@ -153,12 +155,14 @@ module IsoDoc::WordFunction
     end
 
     def termnote_parse(node, out)
+      name = node&.at(ns("./name"))&.remove
       out.div **note_attrs(node) do |div|
-        first = node.first_element_child
         div.p **{ class: "Note" } do |p|
-          anchor = @xrefs.get[node['id']]
-          p << "#{anchor&.dig(:label) || '???'}: "
-          para_then_remainder(first, node, p, div)
+          if name
+            name.children.each { |n| parse(n, p) }
+            p << l10n(": ")
+          end
+          para_then_remainder(node.first_element_child, node, p, div)
         end
       end
     end
@@ -186,7 +190,7 @@ module IsoDoc::WordFunction
 
     def formula_where(dl, out)
       return unless dl
-      out.p { |p| p << @where_lbl }
+      out.p { |p| p << @i18n.where }
       parse(dl, out)
       out.parent.at("./table")["class"] = "formula_dl"
     end