isodoc 1.6.1 → 1.6.2

data/lib/isodoc/function/table.rb

@@ -51,6 +51,7 @@ module IsoDoc::Function
 
     def tcaption(node, t)
       return unless node["summary"]
+
       t.caption do |c|
         c.span **{ style: "display:none" } do |s|
           s << node["summary"]

data/lib/isodoc/function/to_word_html.rb

@@ -18,19 +18,19 @@ module IsoDoc::Function
 
     def init_file(filename, debug)
       filepath = Pathname.new(filename)
-      filename = filepath.sub_ext('').sub(/\.presentation$/, "").to_s
+      filename = filepath.sub_ext("").sub(/\.presentation$/, "").to_s
       dir = init_dir(filename, debug)
       @filename = filename
-      @localdir = filepath.parent.to_s + '/'
+      @localdir = filepath.parent.to_s + "/"
       @sourcedir = @localdir
-      @sourcefilename and @sourcedir = Pathname.new(@sourcefilename).parent.to_s + '/'
+      @sourcefilename and @sourcedir = Pathname.new(@sourcefilename).parent.to_s + "/"
       [filename, dir]
     end
 
     def init_dir(filename, debug)
       dir = "#{filename}_files"
       unless debug
-        Dir.mkdir(dir, 0777) unless File.exists?(dir)
+        Dir.mkdir(dir, 0o777) unless File.exists?(dir)
         FileUtils.rm_rf "#{dir}/*"
       end
       dir
@@ -51,9 +51,7 @@ module IsoDoc::Function
       if @standardstylesheet
         head.style do |style|
           @standardstylesheet.open
-          stylesheet = @standardstylesheet.read.gsub(
-            "FILENAME", File.basename(filename).sub(/\.presentation$/, "")
-          )
+          stylesheet = @standardstylesheet.read
           style.comment "\n#{stylesheet}\n"
         end
       end
@@ -78,7 +76,7 @@ module IsoDoc::Function
       section_break(body)
     end
 
-    def make_body2(body, docxml)
+    def make_body2(body, _docxml)
       body.div **{ class: "prefatory-section" } do |div2|
         div2.p { |p| p << "&nbsp;" } # placeholder
       end
@@ -117,16 +115,6 @@ module IsoDoc::Function
       @meta.get
     end
 
-    def middle_title(_isoxml, out)
-      out.p(**{ class: "zzSTDTitle1" }) { |p| p << @meta.get[:doctitle] }
-    end
-
-    def middle_admonitions(isoxml, out)
-      isoxml.xpath(ns("//sections/note | //sections/admonition")).each do |x|
-        parse(x, out)
-      end
-    end
-
     def middle(isoxml, out)
       middle_title(isoxml, out)
       middle_admonitions(isoxml, out)
@@ -147,16 +135,14 @@ module IsoDoc::Function
             s.h1 do |h|
               n.children.each { |nn| parse(nn, h) }
             end
-          else
-            parse(n, s)
+          else parse(n, s)
           end
         end
       end
     end
 
     def parse(node, out)
-      if node.text?
-        text_parse(node, out)
+      if node.text? then text_parse(node, out)
       else
         case node.name
         when "em" then em_parse(node, out)
@@ -236,8 +222,13 @@ module IsoDoc::Function
         when "svg" then svg_parse(node, out) # in Presentation XML only
         when "add" then add_parse(node, out)
         when "del" then del_parse(node, out)
-        else
-          error_parse(node, out)
+        when "form" then form_parse(node, out)
+        when "input" then input_parse(node, out)
+        when "select" then select_parse(node, out)
+        when "label" then label_parse(node, out)
+        when "option" then option_parse(node, out)
+        when "textarea" then textarea_parse(node, out)
+        else error_parse(node, out)
         end
       end
     end

data/lib/isodoc/html_convert.rb

@@ -1,6 +1,7 @@
 require_relative "html_function/comments"
 require_relative "html_function/footnotes"
 require_relative "html_function/html"
+require_relative "html_function/form"
 require_relative "html_function/postprocess"
 
 module IsoDoc
@@ -8,6 +9,7 @@ module IsoDoc
 
     include HtmlFunction::Comments
     include HtmlFunction::Footnotes
+    include HtmlFunction::Form
     include HtmlFunction::Html
 
     def tmpimagedir_suffix

data/lib/isodoc/html_function/form.rb

@@ -0,0 +1,62 @@
+module IsoDoc::HtmlFunction
+  module Form
+    def form_parse(node, out)
+      out.form **attr_code(id: node["id"], name: node["name"],
+                           action: node["action"]) do |div|
+        node.children.each do |n|
+          parse(n, div)
+        end
+      end
+    end
+
+    def input_parse(node, out)
+      out.input nil, **attr_code(
+        id: node["id"], name: node["name"], type: node["type"],
+        value: node["value"], disabled: node["disabled"],
+        readonly: node["readonly"], checked: node["checked"],
+        maxlength: node["maxlength"], minlength: node["minlength"]
+      )
+    end
+
+    def select_parse(node, out)
+      selected = node.at(ns("./option[@value = '#{node['value']}']"))
+      selected and selected["selected"] = true
+      out.select **attr_code(
+        id: node["id"], name: node["name"], size: node["size"],
+        disabled: node["disabled"], multiple: node["multiple"]
+      ) do |div|
+        node.children.each do |n|
+          parse(n, div)
+        end
+      end
+    end
+
+    def label_parse(node, out)
+      out.label **attr_code(for: node["for"]) do |div|
+        node.children.each do |n|
+          parse(n, div)
+        end
+      end
+    end
+
+    def option_parse(node, out)
+      out.option **attr_code(
+        disabled: node["disabled"], selected: node["selected"],
+        value: node["value"]
+      ) do |o|
+        node.children.each do |n|
+          parse(n, o)
+        end
+      end
+    end
+
+    def textarea_parse(node, out)
+      out.textarea **attr_code(
+        id: node["id"], name: node["name"], rows: node["rows"],
+        cols: node["cols"]
+      ) do |div|
+        node["value"] and div << node["value"]
+      end
+    end
+  end
+end

data/lib/isodoc/i18n.rb

@@ -23,21 +23,23 @@ module IsoDoc
     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

data/lib/isodoc/presentation_function/inline.rb

@@ -1,28 +1,28 @@
-require "twitter_cldr"
-require "bigdecimal"
-
 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) ||
+        return @xrefs.anchor(node["target"], :value) ||
+          @xrefs.anchor(node["target"], :label) ||
           @xrefs.anchor(node["target"], :xref) || "???"
       elsif node["target"] && !/.#./.match(node["target"])
         linkend = anchor_linkend1(node)
       end
+
       linkend || "???"
     end
 
     def anchor_linkend1(node)
       linkend = @xrefs.anchor(node["target"], :xref)
       container = @xrefs.anchor(node["target"], :container, false)
-      (container && get_note_container_id(node) != container && @xrefs.get[node["target"]]) &&
+      (container && get_note_container_id(node) != container &&
+       @xrefs.get[node["target"]]) and
         linkend = prefix_container(container, linkend, node["target"])
       capitalise_xref(node, linkend)
     end
@@ -31,31 +31,38 @@ 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(node)
-      contents = non_locality_elems(node).select { |c| !c.text? || /\S/.match(c) }
-      return unless contents.empty?
+      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 { |n| n.remove }
+      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">
@@ -65,25 +72,25 @@ module IsoDoc
       ret = ""
       refs.each_with_index do |r, i|
         delim = ","
-        delim = ";" if r.name == "localityStack" && i>0
+        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, n)
+    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, n)
           delim = ","
         end
       else
-        ret += eref_localities0(r, i, target, delim, n)
+        ret += eref_localities0(r, idx, target, delim, n)
       end
       ret
     end
 
-    def eref_localities0(r, i, target, delim, n)
+    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")),
@@ -92,10 +99,10 @@ module IsoDoc
     end
 
     # TODO: move to localization file
-    def eref_localities1_zh(target, type, from, to, n, 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 )
+      loc = (@i18n.locality[type] || type.sub(/^locality:/, "").capitalize)
       ret += " #{loc}" unless n["droploc"] == "true"
       ret
     end
@@ -103,7 +110,9 @@ module IsoDoc
     # TODO: move to localization file
     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, n, delim))
+
+      lang == "zh" and
+        return l10n(eref_localities1_zh(target, type, from, to, n, delim))
       ret = delim
       ret += eref_locality_populate(type, n)
       ret += " #{from.text}" if from
@@ -111,10 +120,11 @@ module IsoDoc
       l10n(ret)
     end
 
-    def eref_locality_populate(type, n)
-      return "" if n["droploc"] == "true"
+    def eref_locality_populate(type, node)
+      return "" if node["droploc"] == "true"
+
       loc = @i18n.locality[type] || type.sub(/^locality:/, "")
-      loc = case n["case"]
+      loc = case node["case"]
             when "capital" then loc.capitalize
             when "lowercase" then loc.downcase
             else
@@ -139,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)
@@ -151,95 +161,27 @@ 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 = BigDecimal(x.text)
-        precision = /\./.match(x.text) ? x.text.sub(/^.*\./, "").size : 0
-        x.children = localized_number(num, locale, precision)
-      end
-    end
-
-    # By itself twitter-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) }
     end
 
     def variant1(node)
-      if (!node["lang"] || node["lang"] == @lang) && (!node["script"] || node["script"] == @script)
+      if (!node["lang"] || node["lang"] == @lang) &&
+          (!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
 
@@ -250,7 +192,8 @@ module IsoDoc
       foll = node.xpath("./following-sibling::xmlns:variant")
       found = false
       (prev + foll).each do |n|
-        found = true if n["lang"] == @lang && (!n["script"] || n["script"] == @script)
+        found = true if n["lang"] == @lang &&
+          (!n["script"] || n["script"] == @script)
       end
       found
     end