isodoc 1.2.6 → 1.4.0

data/lib/isodoc/css.rb

@@ -0,0 +1,95 @@
+module IsoDoc
+  class Convert < ::IsoDoc::Common
+    # Check if already compiled version(.css) exists,
+    #   if not, return original scss file. During release
+    #   we compile scss into css files in order to not depend on scss
+    def precompiled_style_or_original(stylesheet_path)
+      # Already have compiled stylesheet, use it
+      return stylesheet_path if stylesheet_path.nil? ||
+        File.extname(stylesheet_path) == '.css'
+      basename = File.basename(stylesheet_path, '.*')
+      compiled_path = File.join(File.dirname(stylesheet_path),
+                                "#{basename}.css")
+      return stylesheet_path unless File.file?(compiled_path)
+      compiled_path
+    end
+
+    # run this after @meta is populated
+    def populate_css
+      @htmlstylesheet = generate_css(@htmlstylesheet_name, true)
+      @wordstylesheet = generate_css(@wordstylesheet_name, false)
+      @standardstylesheet = generate_css(@standardstylesheet_name, false)
+    end
+
+    def default_fonts(_options)
+      {
+        bodyfont: 'Arial',
+        headerfont: 'Arial',
+        monospacefont: 'Courier',
+      }
+    end
+
+    # none for this parent gem, but will be populated in child gems
+    # which have access to stylesheets &c
+    def default_file_locations(_options)
+      {}
+    end
+
+    def fonts_options
+      {
+        'bodyfont' => options[:bodyfont] || 'Arial',
+        'headerfont' => options[:headerfont] || 'Arial',
+        'monospacefont' => options[:monospacefont] || 'Courier',
+        "normalfontsize" => options[:normalfontsize],
+        "monospacefontsize" => options[:monospacefontsize],
+        "smallerfontsize" => options[:smallerfontsize],
+        "footnotefontsize" => options[:footnotefontsize] 
+      }
+    end
+
+    def scss_fontheader(is_html_css)
+      b = options[:bodyfont] || 'Arial'
+      h = options[:headerfont] || 'Arial'
+      m = options[:monospacefont] || 'Courier'
+      ns = options[:normalfontsize] || (is_html_css ? "1.0em" : '12.0pt')
+      ms = options[:monospacefontsize] || (is_html_css ? "0.8em" : '11.0pt')
+      ss = options[:smallerfontsize] || (is_html_css ? "0.9em" : '10.0pt')
+      fs = options[:footnotefontsize] || (is_html_css ? "0.9em" : '9.0pt')
+      "$bodyfont: #{b};\n$headerfont: #{h};\n$monospacefont: #{m};\n"\
+        "$normalfontsize: #{ns};\n$monospacefontsize: #{ms};\n"\
+        "$smallerfontsize: #{ss};\n$footnotefontsize: #{fs};\n"
+    end
+
+    def convert_scss(filename, stylesheet, stripwordcss)
+      require 'sassc'
+      require 'isodoc/sassc_importer'
+
+      [File.join(Gem.loaded_specs['isodoc'].full_gem_path,
+                 'lib', 'isodoc'),
+                 File.dirname(filename)].each do |name|
+                   SassC.load_paths << name
+                 end
+                 SassC::Engine.new(scss_fontheader(stripwordcss) + stylesheet,
+                                   syntax: :scss, importer: SasscImporter)
+                   .render
+    end
+
+    # stripwordcss if HTML stylesheet, !stripwordcss if DOC stylesheet
+    def generate_css(filename, stripwordcss)
+      return nil if filename.nil?
+
+      filename = precompiled_style_or_original(filename)
+      stylesheet = File.read(filename, encoding: 'UTF-8')
+      stylesheet = populate_template(stylesheet, :word)
+      stylesheet.gsub!(/(\s|\{)mso-[^:]+:[^;]+;/m, '\\1') if stripwordcss
+      if File.extname(filename) == '.scss'
+        stylesheet = convert_scss(filename, stylesheet, stripwordcss)
+      end
+      Tempfile.open([File.basename(filename, '.*'), 'css'],
+                    encoding: 'utf-8') do |f|
+        f.write(stylesheet)
+        f
+      end
+    end
+  end
+end

data/lib/isodoc/function/inline.rb

@@ -67,19 +67,6 @@ module IsoDoc::Function
       out << "Termbase #{node['base']}, term ID #{node['target']}"
     end
 
-    def concept_parse(node, out)
-      content = node.first_element_child.children.select do |c|
-        !%w{locality localityStack}.include? c.name 
-      end.select { |c| !c.text? || /\S/.match(c) }
-      if content.empty?
-        out << "[Term defined in "
-        parse(node.first_element_child, out)
-        out << "]"
-      else
-        content.each { |n| parse(n, out) }
-      end
-    end
-
     def stem_parse(node, out)
       ooml = if node["type"] == "AsciiMath"
                "#{@openmathdelim}#{HTMLEntities.new.encode(node.text)}"\
@@ -131,25 +118,5 @@ module IsoDoc::Function
         p.b(**{ role: "strong" }) { |e| e << text }
       end
     end
-
-    def variant_parse(node, out)
-      if node["lang"] == @lang && node["script"] == @script
-        node.children.each { |n| parse(n, out) }
-      else
-        return if found_matching_variant_sibling(node)
-        return unless !node.at("./preceding-sibling::xmlns:variant")
-        node.children.each { |n| parse(n, out) }
-      end
-    end
-
-    def found_matching_variant_sibling(node)
-      prev = node.xpath("./preceding-sibling::xmlns:variant")
-      foll = node.xpath("./following-sibling::xmlns:variant")
-      found = false
-      (prev + foll).each do |n|
-        found = true if n["lang"] == @lang && n["script"] == @script
-      end
-      found
-    end
   end
 end

data/lib/isodoc/function/inline_simple.rb

@@ -23,7 +23,10 @@ module IsoDoc::Function
     def index_parse(node, out)
     end
 
-        def bookmark_parse(node, out)
+    def index_xref_parse(node, out)
+    end
+
+    def bookmark_parse(node, out)
       out.a **attr_code(id: node["id"])
     end
 

data/lib/isodoc/function/lists.rb

@@ -38,7 +38,8 @@ module IsoDoc::Function
     end
 
     def ol_attrs(node)
-      { type: ol_depth(node), id: node["id"], style: keep_style(node) }
+      { type: node["type"] ? ol_style(node["type"].to_sym) : ol_depth(node),
+        id: node["id"], style: keep_style(node) }
     end
 
     def ol_parse(node, out)

data/lib/isodoc/function/references.rb

@@ -80,7 +80,8 @@ module IsoDoc::Function
     end
 
     def docid_prefix(prefix, docid)
-      docid = "#{prefix} #{docid}" if prefix && !omit_docid_prefix(prefix)
+      docid = "#{prefix} #{docid}" if prefix && !omit_docid_prefix(prefix) &&
+        !/^#{prefix}\b/.match(docid)
       docid_l10n(docid)
     end
 
@@ -90,7 +91,7 @@ module IsoDoc::Function
     end
 
     def date_note_process(b, ref)
-      date_note = b.at(ns("./note[@type = 'ISO DATE']"))
+      date_note = b.at(ns("./note[@type = 'Unpublished-Status']"))
       return if date_note.nil?
       date_note.children.first.replace("<p>#{date_note.content}</p>")
       footnote_parse(date_note, ref)
@@ -111,7 +112,7 @@ module IsoDoc::Function
     # reference not to be rendered because it is deemed implicit
     # in the standards environment
     def implicit_reference(b)
-      false
+      b["hidden"] == "true"
     end
 
     def prefix_bracketed_ref(ref, text)
@@ -160,7 +161,7 @@ module IsoDoc::Function
     end
 
     def norm_ref(isoxml, out, num)
-      f = isoxml.at(ns(norm_ref_xpath)) or return num
+      f = isoxml.at(ns(norm_ref_xpath)) and f["hidden"] != "true" or return num
       out.div do |div|
         num = num + 1
         clause_name(num, f.at(ns("./title")), div, nil)
@@ -180,10 +181,9 @@ module IsoDoc::Function
     end
 
     def bibliography(isoxml, out)
-      f = isoxml.at(ns(bibliography_xpath)) || return
+      f = isoxml.at(ns(bibliography_xpath)) and f["hidden"] != "true" or return
       page_break(out)
       out.div do |div|
-        #div.h1 @bibliography_lbl, **{ class: "Section3" }
         div.h1 **{class: "Section3"} do |h1|
           f&.at(ns("./title"))&.children&.each { |c2| parse(c2, h1) }
         end
@@ -192,6 +192,7 @@ module IsoDoc::Function
     end
 
     def bibliography_parse(node, out)
+      node["hidden"] != true or return
       title = node&.at(ns("./title"))&.text || ""
       out.div do |div|
         clause_parse_title(node, div, node.at(ns("./title")), out,
@@ -202,15 +203,9 @@ module IsoDoc::Function
 
     def format_ref(ref, prefix, isopub, date, allparts)
       ref = docid_prefix(prefix, ref)
-      return "[#{ref}]" if /^\d+$/.match(ref) && !prefix &&
+      return "[#{ref}]" if ref && /^\d+$/.match(ref) && !prefix &&
         !/^\[.*\]$/.match(ref)
         ref
     end
-
-    # def ref_names(ref)
-    #  linkend = ref.text
-    # linkend.gsub!(/[\[\]]/, "") unless /^\[\d+\]$/.match linkend
-    # @anchors[ref["id"]] = { xref: linkend }
-    # end
   end
 end

data/lib/isodoc/function/section.rb

@@ -56,7 +56,7 @@ module IsoDoc::Function
     end
 
     def clause(isoxml, out)
-      isoxml.xpath(ns(middle_clause)).each do |c|
+      isoxml.xpath(ns(middle_clause(isoxml))).each do |c|
         out.div **attr_code(clause_attrs(c)) do |s|
           clause_name(nil, c&.at(ns("./title")), s, nil)
           c.elements.reject { |c1| c1.name == "title" }.each do |c1|

data/lib/isodoc/function/table.rb

@@ -58,11 +58,21 @@ module IsoDoc::Function
       end
     end
 
+    def colgroup(node, t)
+      colgroup = node.at(ns("./colgroup")) or return
+      t.colgroup do |cg|
+        colgroup.xpath(ns("./col")).each do |c|
+          cg.col **{ style: "width: #{c['width']};" }
+        end
+      end
+    end
+
     def table_parse(node, out)
       @in_table = true
       table_title_parse(node, out)
       out.table **table_attrs(node) do |t|
         tcaption(node, t)
+        colgroup(node, t)
         thead_parse(node, t)
         tbody_parse(node, t)
         tfoot_parse(node, t)

data/lib/isodoc/function/to_word_html.rb

@@ -96,6 +96,7 @@ module IsoDoc::Function
       @meta.subtitle isoxml, out
       @meta.docstatus isoxml, out
       @meta.docid isoxml, out
+      @meta.otherid isoxml, out
       @meta.docnumeric isoxml, out
       @meta.doctype isoxml, out
       @meta.author isoxml, out
@@ -214,14 +215,13 @@ module IsoDoc::Function
         when "verification" then requirement_component_parse(node, out)
         when "import" then requirement_component_parse(node, out)
         when "index" then index_parse(node, out)
-        when "concept" then concept_parse(node, out)
+        when "index-xref" then index_xref_parse(node, out)
         when "termref" then termrefelem_parse(node, out)
         when "copyright-statement" then copyright_parse(node, out)
         when "license-statement" then license_parse(node, out)
         when "legal-statement" then legal_parse(node, out)
         when "feedback-statement" then feedback_parse(node, out)
         when "passthrough" then passthrough_parse(node, out)
-        when "variant" then variant_parse(node, out)
         when "amend" then amend_parse(node, out)
         when "tab" then clausedelimspace(out) # in Presentation XML only
         else

data/lib/isodoc/gem_tasks.rb

@@ -97,6 +97,10 @@ module IsoDoc
         $bodyfont: '{{bodyfont}}';
         $headerfont: '{{headerfont}}';
         $monospacefont: '{{monospacefont}}';
+        $normalfontsize: '{{normalfontsize}}';
+        $smallerfontsize: '{{smallerfontsize}}';
+        $footnotefontsize: '{{footnotefontsize}}';
+        $monospacefontsize: '{{monospacefontsize}}';
       TEXT
     end
 

data/lib/isodoc/html_function/html.rb

@@ -60,6 +60,7 @@ module IsoDoc::HtmlFunction
     <script type="text/javascript">#{toclevel}</script>
 
     <!--Google fonts-->
+      <link rel="preconnect" href="https://fonts.gstatic.com"> 
       #{googlefonts}
     <!--Font awesome import for the link icon-->
     <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.0.8/css/solid.css" integrity="sha384-v2Tw72dyUXeU3y4aM2Y0tBJQkGfplr39mxZqlTBDUZAb9BGoC40+rdFCG0m10lXk" crossorigin="anonymous">

data/lib/isodoc/html_function/mathvariant_to_plain.rb

@@ -0,0 +1,82 @@
+module IsoDoc
+  module HtmlFunction
+    # Class for recursively converting mathvariant text into plain text symbols
+    class MathvariantToPlain
+      MATHML = { "m" => "http://www.w3.org/1998/Math/MathML" }.freeze
+      MATHVARIANT_SPECIAL_CASE_MAPPINGS_1 = %w[bold italic sans-serif]
+        .permutation
+        .each_with_object(:sansbolditalic)
+        .map { |n, y| [n, y] }
+        .to_h
+        .freeze
+      MATHVARIANT_SPECIAL_CASE_MAPPINGS_2 = {
+        %w[bold fraktur] => :frakturbold,
+        %w[bold script] => :scriptbold,
+        %w[sans-serif bold] => :sansbold,
+        %w[sans-serif italic] => :sansitalic,
+        %w[sans-serif bold-italic] => :sansbolditalic,
+        %w[bold-sans-serif italic] => :sansbolditalic,
+        %w[sans-serif-italic bold] => :sansbolditalic,
+      }.freeze
+      MATHVARIANT_TO_PLANE_MAPPINGS = {
+        %w[double-struck] => :doublestruck,
+        %w[bold-fraktur] => :frakturbold,
+        %w[script] => :script,
+        %w[bold-script] => :scriptbold,
+        %w[fraktur] => :fraktur,
+        %w[sans-serif] => :sans,
+        %w[bold-sans-serif] => :sansbold,
+        %w[sans-serif-italic] => :sansitalic,
+        %w[sans-serif-bold-italic] => :sansbolditalic,
+        %w[monospace] => :monospace,
+      }.freeze
+
+      attr_reader :docxml
+
+      # @param [Nokogiri::Document] docxml
+      def initialize(docxml)
+        @docxml = docxml
+      end
+
+      def convert
+        docxml.xpath("//m:math", MATHML).each do |elem|
+          next if nothing_to_style(elem)
+          mathml1(elem)
+        end
+        docxml
+      end
+
+      private
+
+      def nothing_to_style(elem)
+        !elem.at("./*[@mathvariant][not(@mathvariant = 'normal')][not(@mathvariant = 'italic')]")
+      end
+
+      def mathml1(base_elem)
+        MATHVARIANT_SPECIAL_CASE_MAPPINGS_1
+          .merge(MATHVARIANT_SPECIAL_CASE_MAPPINGS_2)
+          .merge(MATHVARIANT_TO_PLANE_MAPPINGS)
+          .each_pair do |mathvariant_list, plain_font|
+            base_elem.xpath(mathvariant_xpath(mathvariant_list)).each do |elem|
+              toPlane(elem, plain_font)
+            end
+          end
+      end
+
+      def mathvariant_xpath(list)
+        list
+          .map { |variant| "//*[@mathvariant = '#{variant}']" }
+          .join
+      end
+
+      def toPlane(elem, font)
+        elem.traverse do |n|
+          next unless n.text?
+
+          n.replace(Plane1Converter.conv(HTMLEntities.new.decode(n.text), font))
+        end
+        elem
+      end
+    end
+  end
+end

data/lib/isodoc/html_function/postprocess.rb

@@ -1,35 +1,47 @@
+require "isodoc/html_function/mathvariant_to_plain"
+
 module IsoDoc::HtmlFunction
   module Html
-    def postprocess(result, filename, dir)
+    def postprocess(result, filename, _dir)
       result = from_xhtml(cleanup(to_xhtml(textcleanup(result))))
       toHTML(result, filename)
       @files_to_delete.each { |f| FileUtils.rm_rf f }
     end
 
     def script_cdata(result)
-      result.gsub(%r{<script([^>]*)>\s*<!\[CDATA\[}m, "<script\\1>").
-        gsub(%r{\]\]>\s*</script>}, "</script>").
-        gsub(%r{<!\[CDATA\[\s*<script([^>]*)>}m, "<script\\1>").
-        gsub(%r{</script>\s*\]\]>}, "</script>")
+      result.gsub(%r{<script([^>]*)>\s*<!\[CDATA\[}m, "<script\\1>")
+        .gsub(%r{\]\]>\s*</script>}, "</script>")
+        .gsub(%r{<!\[CDATA\[\s*<script([^>]*)>}m, "<script\\1>")
+        .gsub(%r{</script>\s*\]\]>}, "</script>")
     end
 
     def toHTML(result, filename)
-      result = (from_xhtml(html_cleanup(to_xhtml(result))))
-      #result = populate_template(result, :html)
+      result = from_xhtml(html_cleanup(to_xhtml(result)))
+      # result = populate_template(result, :html)
       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
 
     def html5(doc)
-      doc.sub(%r{<!DOCTYPE html [^>]+>}, "<!DOCTYPE html>").
-        sub(%r{<\?xml[^>]+>}, "")
+      doc.sub(%r{<!DOCTYPE html [^>]+>}, "<!DOCTYPE html>")
+        .sub(%r{<\?xml[^>]+>}, "")
     end
 
     def html_cleanup(x)
-      footnote_format(footnote_backlinks(html_toc(
-        term_header((html_footnote_filter(html_preface(htmlstyle(x))))))
-                        ))
+      mathml(
+        footnote_format(
+          footnote_backlinks(
+            html_toc(
+              term_header(html_footnote_filter(html_preface(htmlstyle(x))))
+            )
+          )
+        )
+      )
+    end
+
+    def mathml(docxml)
+      IsoDoc::HtmlFunction::MathvariantToPlain.new(docxml).convert
     end
 
     def htmlstylesheet
@@ -76,14 +88,14 @@ module IsoDoc::HtmlFunction
     def html_cover(docxml)
       doc = to_xhtml_fragment(File.read(@htmlcoverpage, encoding: "UTF-8"))
       d = docxml.at('//div[@class="title-section"]')
-      #d.children.first.add_previous_sibling doc.to_xml(encoding: "US-ASCII")
+      # d.children.first.add_previous_sibling doc.to_xml(encoding: "US-ASCII")
       d.children.first.add_previous_sibling populate_template(doc.to_xml(encoding: "US-ASCII"), :html)
     end
 
     def html_intro(docxml)
       doc = to_xhtml_fragment(File.read(@htmlintropage, encoding: "UTF-8"))
       d = docxml.at('//div[@class="prefatory-section"]')
-      #d.children.first.add_previous_sibling doc.to_xml(encoding: "US-ASCII")
+      # d.children.first.add_previous_sibling doc.to_xml(encoding: "US-ASCII")
       d.children.first.add_previous_sibling populate_template(doc.to_xml(encoding: "US-ASCII"), :html)
     end
 
@@ -93,19 +105,19 @@ module IsoDoc::HtmlFunction
     end
 
     def toclevel_classes
-      (1..@htmlToClevels).inject([]) { |m, i| m << "h#{i}" }
+      (1..@htmlToClevels).reduce([]) { |m, i| m << "h#{i}" }
     end
 
     def toclevel
       ret = toclevel_classes.map { |l| "#{l}:not(:empty):not(.TermNum):not(.noTOC)" }
       <<~HEAD.freeze
-    function toclevel() { return "#{ret.join(',')}";}
+        function toclevel() { return "#{ret.join(',')}";}
       HEAD
     end
 
     # needs to be same output as toclevel
     def html_toc(docxml)
-      idx = docxml.at("//div[@id = 'toc']") or return docxml
+      (idx = docxml.at("//div[@id = 'toc']")) or (return docxml)
       toc = "<ul>"
       path = toclevel_classes.map do |l|
         "//main//#{l}[not(@class = 'TermNum')][not(@class = 'noTOC')][text()]"
@@ -186,14 +198,22 @@ module IsoDoc::HtmlFunction
       docxml
     end
 
+    def footnote_backlinks1(x, fn)
+      xdup = x.dup
+      xdup.remove["id"]
+      if fn.elements.empty?
+        fn.children.first.previous = xdup
+      else
+        fn.elements.first.children.first.previous = xdup
+      end
+    end
+
     def footnote_backlinks(docxml)
       seen = {}
       docxml.xpath('//a[@class = "FootnoteRef"]').each_with_index do |x, i|
         seen[x["href"]] and next or seen[x["href"]] = true
         fn = docxml.at(%<//*[@id = '#{x['href'].sub(/^#/, '')}']>) || next
-        xdup = x.dup
-        xdup.remove["id"]
-        fn.elements.first.children.first.previous = xdup
+        footnote_backlinks1(x, fn)
         x["id"] ||= "fnref:#{i + 1}"
         fn.add_child "<a href='##{x['id']}'>&#x21A9;</a>"
       end
@@ -221,6 +241,7 @@ module IsoDoc::HtmlFunction
     MATHJAX = <<~"MATHJAX".freeze
       <script type="text/x-mathjax-config">
         MathJax.Hub.Config({
+          "HTML-CSS": { preferredFont: "STIX" },
           asciimath2jax: { delimiters: [['OPEN', 'CLOSE']] }
        });
       </script>