isodoc 1.1.4 → 1.2.4

data/lib/isodoc/html_function/html.rb

@@ -4,7 +4,6 @@ require "base64"
 module IsoDoc::HtmlFunction
   module Html
     def convert1(docxml, filename, dir)
-      @xrefs.parse docxml
       noko do |xml|
         xml.html **{ lang: "#{@lang}" } do |html|
           info docxml, nil
@@ -32,6 +31,7 @@ module IsoDoc::HtmlFunction
     def make_body3(body, docxml)
       body.div **{ class: "main-section" } do |div3|
         boilerplate docxml, div3
+        preface_block docxml, div3
         abstract docxml, div3
         foreword docxml, div3
         introduction docxml, div3

data/lib/isodoc/{function/i18n.rb → i18n.rb}

@@ -1,29 +1,48 @@
 require "yaml"
 
-# TODO: Cleanup and generalize
-module IsoDoc::Function
-  module I18n
-    def load_yaml(lang, script)
-      if @i18nyaml then YAML.load_file(@i18nyaml)
-      elsif lang == "en"
+module IsoDoc
+  class I18n
+    def load_yaml(lang, script, i18nyaml = nil)
+      ret = load_yaml1(lang, script)
+      return ret.merge(YAML.load_file(i18nyaml)) if i18nyaml
+      ret
+    end
+
+    def load_yaml1(lang, script)
+      if lang == "en"
         YAML.load_file(File.join(File.dirname(__FILE__),
-                                 "../../isodoc-yaml/i18n-en.yaml"))
+                                 "../isodoc-yaml/i18n-en.yaml"))
       elsif lang == "fr"
         YAML.load_file(File.join(File.dirname(__FILE__),
-                                 "../../isodoc-yaml/i18n-fr.yaml"))
+                                 "../isodoc-yaml/i18n-fr.yaml"))
       elsif lang == "zh" && script == "Hans"
         YAML.load_file(File.join(File.dirname(__FILE__),
-                                 "../../isodoc-yaml/i18n-zh-Hans.yaml"))
+                                 "../isodoc-yaml/i18n-zh-Hans.yaml"))
       else
         YAML.load_file(File.join(File.dirname(__FILE__),
-                                 "../../isodoc-yaml/i18n-en.yaml"))
+                                 "../isodoc-yaml/i18n-en.yaml"))
       end
     end
 
-    def i18n_init(lang, script)
+    def get
+      @labels
+    end
+
+    def set(x, y)
+      @labels[x] = y
+    end
+
+    def initialize(lang, script, i18nyaml = nil)
       @lang = lang
       @script = script
-      y = load_yaml(lang, script)
+      y = load_yaml(lang, script, i18nyaml)
+      @labels = y
+      @labels["language"] = @lang
+      @labels["script"] = @script
+      @labels.each do |k, v|
+        self.class.send(:define_method, k.downcase) { v }
+      end
+=begin
       @term_def_boilerplate = y["term_def_boilerplate"]
       @scope_lbl = y["scope"]
       @symbols_lbl = y["symbols"]
@@ -71,30 +90,11 @@ module IsoDoc::Function
       @requirement_lbl = y["requirement"]
       @locality = y["locality"]
       @admonition = y["admonition"]
-      @labels = y
-      @labels["language"] = @lang
-      @labels["script"] = @script
+=end
     end
 
-    # TODO: move to localization file
-    def eref_localities1_zh(target, type, from, to, delim)
-      ret = "#{delim} 第#{from.text}" if from
-      ret += "–#{to}" if to
-      loc = (@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 = @locality[type] || type.sub(/^locality:/, "").capitalize
-      ret += " #{loc}"
-      ret += " #{from.text}" if from
-      ret += "–#{to.text}" if to
-      l10n(ret)
+    def self.l10n(x, lang = @lang, script = @script)
+      l10n(x, lang, script)
     end
 
     # TODO: move to localization file
@@ -106,8 +106,8 @@ module IsoDoc::Function
         xml.traverse do |n|
           next unless n.text?
           n.replace(n.text.gsub(/ /, "").gsub(/:/, "：").gsub(/,/, "、").
-            gsub(/\(/, "（").gsub(/\)/, "）").
-            gsub(/\[/, "【").gsub(/\]/, "】"))
+                    gsub(/\(/, "（").gsub(/\)/, "）").
+                    gsub(/\[/, "【").gsub(/\]/, "】"))
         end
         xml.to_xml.gsub(/<b>/, "").gsub("</b>", "").gsub(/<\?[^>]+>/, "")
       else
@@ -115,7 +115,7 @@ module IsoDoc::Function
       end
     end
 
-    module_function :l10n
+    #module_function :l10n
 
   end
 end

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,152 @@
+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
+
+    # we use this to eliminate the semantic amend blocks from rendering
+    def amend(docxml)
+      docxml.xpath(ns("//amend")).each do |f|
+        amend1(f)
+      end
+    end
+
+    def amend1(f)
+      f.xpath(ns("./autonumber")).each { |a| a.remove }
+      f.xpath(ns("./newcontent")).each { |a| a.name = "quote" }
+      f.xpath(ns("./description")).each { |a| a.replace(a.children) }
+      f.replace(f.children)
+    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