isodoc 1.5.3 → 1.6.2

data/lib/isodoc/i18n.rb

@@ -5,44 +5,47 @@ module IsoDoc
     def load_yaml(lang, script, i18nyaml = nil)
       ret = load_yaml1(lang, script)
       return normalise_hash(ret.merge(YAML.load_file(i18nyaml))) if i18nyaml
+
       normalise_hash(ret)
     end
 
     def normalise_hash(ret)
-      if ret.is_a? Hash 
+      case ret
+      when Hash
         ret.each do |k, v|
           ret[k] = normalise_hash(v)
         end
         ret
-      elsif ret.is_a? Array then ret.map { |n| normalise_hash(n) }
-      elsif ret.is_a? String then ret.unicode_normalize(:nfc) 
-      else
-        ret
+      when Array then ret.map { |n| normalise_hash(n) }
+      when String then ret.unicode_normalize(:nfc)
+      else ret
       end
     end
 
     def load_yaml1(lang, script)
-      if lang == "en"
-        YAML.load_file(File.join(File.dirname(__FILE__),
-                                 "../isodoc-yaml/i18n-en.yaml"))
-      elsif lang == "fr"
-        YAML.load_file(File.join(File.dirname(__FILE__),
-                                 "../isodoc-yaml/i18n-fr.yaml"))
-      elsif lang == "zh" && script == "Hans"
-        YAML.load_file(File.join(File.dirname(__FILE__),
-                                 "../isodoc-yaml/i18n-zh-Hans.yaml"))
+      case lang
+      when "en", "fr", "ru", "de", "es", "ar"
+        load_yaml2(lang)
+      when "zh"
+        if script == "Hans" then load_yaml2("zh-Hans")
+        else load_yaml2("en")
+        end
       else
-        YAML.load_file(File.join(File.dirname(__FILE__),
-                                 "../isodoc-yaml/i18n-en.yaml"))
+        load_yaml2("en")
       end
     end
 
+    def load_yaml2(str)
+      YAML.load_file(File.join(File.dirname(__FILE__),
+                               "../isodoc-yaml/i18n-#{str}.yaml"))
+    end
+
     def get
       @labels
     end
 
-    def set(x, y)
-      @labels[x] = y
+    def set(key, val)
+      @labels[key] = val
     end
 
     def initialize(lang, script, i18nyaml = nil)
@@ -57,37 +60,36 @@ module IsoDoc
       end
     end
 
-    def self.l10n(x, lang = @lang, script = @script)
-      l10n(x, lang, script)
+    def self.l10n(text, lang = @lang, script = @script)
+      l10n(text, lang, script)
     end
 
     # TODO: move to localization file
     # function localising spaces and punctuation.
     # Not clear if period needs to be localised for zh
-    def l10n(x, lang = @lang, script = @script)
+    def l10n(text, lang = @lang, script = @script)
       if lang == "zh" && script == "Hans"
-        xml = Nokogiri::HTML::DocumentFragment.parse(x)
+        xml = Nokogiri::HTML::DocumentFragment.parse(text)
         xml.traverse do |n|
           next unless n.text?
-          n.replace(n.text.gsub(/ /, "").gsub(/:/, "：").gsub(/,/, "、").
-                    gsub(/\(/, "（").gsub(/\)/, "）").
-                    gsub(/\[/, "【").gsub(/\]/, "】"))
+
+          n.replace(n.text.gsub(/ /, "").gsub(/:/, "：").gsub(/,/, "、")
+            .gsub(/\(/, "（").gsub(/\)/, "）").gsub(/\[/, "【").gsub(/\]/, "】"))
         end
         xml.to_xml.gsub(/<b>/, "").gsub("</b>", "").gsub(/<\?[^>]+>/, "")
-      else
-        x
+      else text
       end
     end
 
     def multiple_and(names, andword)
-      return '' if names.empty?
+      return "" if names.empty?
       return names[0] if names.length == 1
+
       (names.length == 2) &&
         (return l10n("#{names[0]} #{andword} #{names[1]}", @lang, @script))
-      l10n(names[0..-2].join(', ') + " #{andword} #{names[-1]}", @lang, @script)
+      l10n(names[0..-2].join(", ") + " #{andword} #{names[-1]}", @lang, @script)
     end
 
-    #module_function :l10n
-
+    # module_function :l10n
   end
 end

data/lib/isodoc/pdf_convert.rb

@@ -42,9 +42,7 @@ module IsoDoc
     end
 
     def xref_parse(node, out)
-      target = /#/.match(node["target"]) ? node["target"].sub(/#/, ".pdf#") :
-        "##{node["target"]}"
-      out.a(**{ "href": target }) { |l| l << get_linkend(node) }
+      out.a(**{ "href": target_pdf(node) }) { |l| l << get_linkend(node) }
     end
   end
 end

data/lib/isodoc/presentation_function/block.rb

@@ -1,14 +1,16 @@
+require "base64"
+
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
     def lower2cap(s)
-      return s if /^[[:upper:]][[:upper:]]/.match(s)
+      return s if /^[[:upper:]][[:upper:]]/.match?(s)
+
       s.capitalize
     end
 
     def figure(docxml)
-      docxml.xpath(ns("//figure")).each do |f|
-        figure1(f)
-      end
+      docxml.xpath(ns("//image")).each { |f| svg_extract(f) }
+      docxml.xpath(ns("//figure")).each { |f| figure1(f) }
       docxml.xpath(ns("//svgmap")).each do |s|
         if f = s.at(ns("./figure")) then s.replace(f)
         else
@@ -17,17 +19,27 @@ module IsoDoc
       end
     end
 
+    def svg_extract(f)
+      return unless %r{^data:image/svg\+xml;base64,}.match?(f["src"])
+
+      svg = Base64.strict_decode64(f["src"]
+        .sub(%r{^data:image/svg\+xml;base64,}, ""))
+      f.replace(svg.sub(/<\?xml[^>]*>/, ""))
+    end
+
     def figure1(f)
-      return sourcecode1(f) if f["class"] == "pseudocode" ||
-        f["type"] == "pseudocode"
+      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("#{lower2cap @i18n.figure} #{lbl}"), "name")
+      prefix_name(f, "&nbsp;&mdash; ",
+                  l10n("#{lower2cap @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}>"
@@ -46,6 +58,7 @@ module IsoDoc
     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("#{lower2cap @i18n.figure} #{lbl}"), "name")
     end
@@ -90,6 +103,7 @@ module IsoDoc
     # 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]}")
@@ -104,7 +118,7 @@ module IsoDoc
 
     # introduce name element
     def termnote1(f)
-      lbl = l10n(@xrefs.anchor(f['id'], :label) || '???')
+      lbl = l10n(@xrefs.anchor(f["id"], :label) || "???")
       prefix_name(f, "", lower2cap(lbl), "name")
     end
 
@@ -128,7 +142,7 @@ module IsoDoc
 
     # introduce name element
     def recommendation1(f, type)
-      n = @xrefs.anchor(f['id'], :label, false)
+      n = @xrefs.anchor(f["id"], :label, false)
       lbl = (n.nil? ? type : l10n("#{type} #{n}"))
       prefix_name(f, "", lbl, "name")
     end
@@ -142,7 +156,8 @@ module IsoDoc
     def table1(f)
       return if labelled_ancestor(f)
       return if f["unnumbered"] && !f.at(ns("./name"))
-      n = @xrefs.anchor(f['id'], :label, false)
+
+      n = @xrefs.anchor(f["id"], :label, false)
       prefix_name(f, "&nbsp;&mdash; ", l10n("#{lower2cap @i18n.table} #{n}"), "name")
     end
 
@@ -154,7 +169,7 @@ module IsoDoc
     end
 
     def amend1(f)
-      f.xpath(ns("./autonumber")).each { |a| a.remove }
+      f.xpath(ns("./autonumber")).each(&:remove)
       f.xpath(ns("./newcontent")).each { |a| a.name = "quote" }
       f.xpath(ns("./description")).each { |a| a.replace(a.children) }
       f.replace(f.children)

data/lib/isodoc/presentation_function/inline.rb

@@ -1,14 +1,12 @@
-require "twitter_cldr"
-
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
     def prefix_container(container, linkend, _target)
-      l10n(@xrefs.anchor(container, :xref) + ", " + linkend)
+      l10n("#{@xrefs.anchor(container, :xref)}, #{linkend}")
     end
 
     def anchor_linkend(node, linkend)
       if node["citeas"].nil? && node["bibitemid"]
-        return @xrefs.anchor(node["bibitemid"] ,:xref) || "???"
+        return @xrefs.anchor(node["bibitemid"], :xref) || "???"
       elsif node["target"] && node["droploc"]
         return @xrefs.anchor(node["target"], :value) ||
           @xrefs.anchor(node["target"], :label) ||
@@ -16,6 +14,7 @@ module IsoDoc
       elsif node["target"] && !/.#./.match(node["target"])
         linkend = anchor_linkend1(node)
       end
+
       linkend || "???"
     end
 
@@ -23,8 +22,8 @@ module IsoDoc
       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"])
+       @xrefs.get[node["target"]]) and
+        linkend = prefix_container(container, linkend, node["target"])
       capitalise_xref(node, linkend)
     end
 
@@ -32,90 +31,108 @@ module IsoDoc
       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}/)
+      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
+      if prec.empty? || /(?!<[^.].)\.\s+$/.match(prec.map(&:text).join)
+        linkend&.capitalize
+      else linkend
+      end
     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
+      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
+      node.children.reject do |c|
+        %w{locality localityStack}.include? c.name
       end
     end
 
-    def get_linkend(n)
-      contents = non_locality_elems(n).select { |c| !c.text? || /\S/.match(c) }
-      return unless contents.empty?
-      link = anchor_linkend(n, docid_l10n(n["target"] || n["citeas"]))
-      link += eref_localities(n.xpath(ns("./locality | ./localityStack")), link)
-      non_locality_elems(n).each { |n| n.remove }
-      n.add_child(link)
+    def get_linkend(node)
+      c1 = non_locality_elems(node).select { |c| !c.text? || /\S/.match(c) }
+      return unless c1.empty?
+
+      link = anchor_linkend(node, docid_l10n(node["target"] || node["citeas"]))
+      link += eref_localities(node.xpath(ns("./locality | ./localityStack")),
+                              link, node)
+      non_locality_elems(node).each(&: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)
+    def eref_localities(refs, target, n)
       ret = ""
       refs.each_with_index do |r, i|
         delim = ","
-        delim = ";" if r.name == "localityStack" && i>0
-        ret = eref_locality_stack(r, i, target, delim, ret)
+        delim = ";" if r.name == "localityStack" && i.positive?
+        ret = eref_locality_stack(r, i, target, delim, ret, n)
       end
       ret
     end
 
-    def eref_locality_stack(r, i, target, delim, ret)
+    def eref_locality_stack(r, idx, target, delim, ret, n)
       if r.name == "localityStack"
         r.elements.each_with_index do |rr, j|
-          ret += eref_localities0(rr, j, target, delim)
+          ret += eref_localities0(rr, j, target, delim, n)
           delim = ","
         end
       else
-        ret += eref_localities0(r, i, target, delim)
+        ret += eref_localities0(r, idx, target, delim, n)
       end
       ret
     end
 
-    def eref_localities0(r, i, target, delim)
+    def eref_localities0(r, _i, target, delim, n)
       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)
+                         r.at(ns("./referenceTo")), delim, n, @lang)
       end
     end
 
     # TODO: move to localization file
-    def eref_localities1_zh(target, type, from, to, delim)
+    def eref_localities1_zh(_target, type, from, to, n, delim)
       ret = "#{delim} 第#{from.text}" if from
       ret += "&ndash;#{to.text}" if to
-      loc = (@i18n.locality[type] || type.sub(/^locality:/, "").capitalize )
-      ret += " #{loc}"
+      loc = (@i18n.locality[type] || type.sub(/^locality:/, "").capitalize)
+      ret += " #{loc}" unless n["droploc"] == "true"
       ret
     end
 
     # TODO: move to localization file
-    def eref_localities1(target, type, from, to, delim, lang = "en")
+    def eref_localities1(target, type, from, to, delim, n, lang = "en")
       return "" if type == "anchor"
+
       lang == "zh" and
-        return l10n(eref_localities1_zh(target, type, from, to, delim))
+        return l10n(eref_localities1_zh(target, type, from, to, n, delim))
       ret = delim
-      loc = @i18n.locality[type] || type.sub(/^locality:/, "").capitalize
-      ret += " #{loc}"
+      ret += eref_locality_populate(type, n)
       ret += " #{from.text}" if from
       ret += "&ndash;#{to.text}" if to
       l10n(ret)
     end
 
+    def eref_locality_populate(type, node)
+      return "" if node["droploc"] == "true"
+
+      loc = @i18n.locality[type] || type.sub(/^locality:/, "")
+      loc = case node["case"]
+            when "capital" then loc.capitalize
+            when "lowercase" then loc.downcase
+            else
+              loc.capitalize
+            end
+      " #{loc}"
+    end
+
     def xref(docxml)
       docxml.xpath(ns("//xref")).each { |f| xref1(f) }
     end
@@ -132,8 +149,8 @@ module IsoDoc
       docxml.xpath(ns("//quote/source")).each { |f| xref1(f) }
     end
 
-    def xref1(f)
-      get_linkend(f)
+    def xref1(node)
+      get_linkend(node)
     end
 
     def concept(docxml)
@@ -144,85 +161,17 @@ module IsoDoc
       content = node.first_element_child.children.select do |c|
         !%w{locality localityStack}.include? c.name
       end.select { |c| !c.text? || /\S/.match(c) }
-      node.replace content.empty? ? 
+      node.replace content.empty? ?
         @i18n.term_defined_in.sub(/%/, node.first_element_child.to_xml) :
         "<em>#{node.children.to_xml}</em>"
     end
 
-
-    MATHML = { "m" => "http://www.w3.org/1998/Math/MathML" }.freeze
-
-    def mathml(docxml)
-      locale = twitter_cldr_localiser()
-      docxml.xpath("//m:math", MATHML).each do |f|
-        mathml1(f, locale)
-      end
-    end
-
-    # symbols is merged into
-    # TwitterCldr::DataReaders::NumberDataReader.new(locale).symbols
-    def localize_maths(f, locale)
-      f.xpath(".//m:mn", MATHML).each do |x|
-        num = /\./.match(x.text) ? x.text.to_f : x.text.to_i
-        precision = /\./.match(x.text) ? x.text.sub(/^.*\./, "").size : 0
-        x.children = localized_number(num, locale, precision)
-      end
-    end
-
-    # By itself twiiter cldr does not support fraction part digits grouping
-    # and custom delimeter, will decorate fraction part manually
-    def localized_number(num, locale, precision)
-      localized = precision == 0 ? num.localize(locale).to_s :
-        num.localize(locale).to_decimal.to_s(:precision => precision)
-      twitter_cldr_reader_symbols = twitter_cldr_reader(locale)
-      return localized unless twitter_cldr_reader_symbols[:decimal]
-      integer, fraction = localized.split(twitter_cldr_reader_symbols[:decimal])
-      return localized if fraction.nil? || fraction.length.zero?
-      [integer, decorate_fraction_part(fraction, locale)].
-        join(twitter_cldr_reader_symbols[:decimal])
-    end
-
-    def decorate_fraction_part(fract, locale)
-      result = []
-      twitter_cldr_reader_symbols = twitter_cldr_reader(locale)
-      fract = fract.slice(0..(twitter_cldr_reader_symbols[:precision] || -1))
-      fr_group_digits = twitter_cldr_reader_symbols[:fraction_group_digits] || 1
-      until fract.empty?
-        result.push(fract.slice!(0, fr_group_digits))
-      end
-      result.join(twitter_cldr_reader_symbols[:fraction_group].to_s)
-    end
-
-    def twitter_cldr_localiser_symbols
-      {}
-    end
-
-    def twitter_cldr_reader(locale)
-      num = TwitterCldr::DataReaders::NumberDataReader.new(locale)
-      num.symbols.merge!(twitter_cldr_localiser_symbols)
-    end
-
-    def twitter_cldr_localiser()
-      locale = TwitterCldr.supported_locale?(@lang.to_sym) ? @lang.to_sym : :en
-      twitter_cldr_reader(locale)
-      locale
-    end
-
-    def mathml1(f, locale)
-      localize_maths(f, locale)
-      return unless f.elements.size == 1 && f.elements.first.name == "mn"
-      if f.parent.name == "stem"
-        f.parent.replace(f.at("./m:mn", MATHML).children)
-      else
-        f.replace(f.at("./m:mn", MATHML).children)
-      end
-    end
-
     def variant(docxml)
       docxml.xpath(ns("//variant")).each { |f| variant1(f) }
-      docxml.xpath(ns("//variant[@remove = 'true']")).each { |f| f.remove }
+      docxml.xpath(ns("//variant[@remove = 'true']")).each(&:remove)
       docxml.xpath(ns("//variant")).each do |v|
         next unless v&.next&.name == "variant"
+
         v.next = "/"
       end
       docxml.xpath(ns("//variant")).each { |f| f.replace(f.children) }
@@ -233,11 +182,11 @@ module IsoDoc
           (!node["script"] || node["script"] == @script)
       elsif found_matching_variant_sibling(node)
         node["remove"] = "true"
-      else
-        #return unless !node.at("./preceding-sibling::xmlns:variant")
       end
     end
 
+    private
+
     def found_matching_variant_sibling(node)
       prev = node.xpath("./preceding-sibling::xmlns:variant")
       foll = node.xpath("./following-sibling::xmlns:variant")