isodoc 1.0.27 → 1.1.2

data/lib/isodoc/pdf_convert.rb

@@ -24,19 +24,21 @@ module IsoDoc
 
     def initialize(options)
       @format = :pdf
+      @suffix = "pdf"
       super
     end
 
-    def convert(filename, file = nil, debug = false)
-      file = File.read(filename, encoding: "utf-8") if file.nil?
+    def convert(input_filename, file = nil, debug = false, output_filename = nil)
+      file = File.read(input_filename, encoding: "utf-8") if file.nil?
       @openmathdelim, @closemathdelim = extract_delims(file)
-      docxml, outname_html, dir = convert_init(file, filename, debug)
+      docxml, filename, dir = convert_init(file, input_filename, debug)
       result = convert1(docxml, filename, dir)
       return result if debug
-      postprocess(result, filename, dir)
+      postprocess(result, filename + ".tmp.html", dir)
       FileUtils.rm_rf dir
-      ::Metanorma::Output::Pdf.new.convert("#{filename}.html", outname_html + ".pdf")
-      FileUtils.rm_rf ["#{filename}.html", tmpimagedir]
+      ::Metanorma::Output::Pdf.new.convert("#{filename}.tmp.html",
+                                           output_filename || "#{filename}.#{@suffix}")
+      FileUtils.rm_rf ["#{filename}.tmp.html", tmpimagedir]
     end
 
     def xref_parse(node, out)

data/lib/isodoc/presentation_xml_convert.rb

@@ -0,0 +1,29 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def initialize(options)
+      @format = :presentation
+      @suffix = "presentation.xml"
+      super
+    end
+
+    def convert1(docxml, filename, dir)
+      @xrefs.parse docxml
+      info docxml, nil
+      docxml.to_xml
+    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/sassc_importer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'sassc'
+
+class SasscImporter < SassC::Importer
+  def imports(path, _parent_path)
+    unless path.match?(/(css|scss)$/)
+      Import.new("#{path}.scss")
+    end
+  end
+end

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "1.0.27".freeze
+  VERSION = "1.1.2".freeze
 end

data/lib/isodoc/word_convert.rb

@@ -32,10 +32,11 @@ module IsoDoc
 
     def initialize(options)
       @format = :doc
+      @suffix = "doc"
       super
     end
 
-    def convert(filename, file = nil, debug = false)
+    def convert(filename, file = nil, debug = false, output_filename = nil)
       ret = super
       FileUtils.rm_rf tmpimagedir
       ret

data/lib/isodoc/word_function/body.rb

@@ -1,4 +1,5 @@
 require_relative "./table.rb"
+require_relative "./inline.rb"
 
 module IsoDoc::WordFunction
   module Body
@@ -69,28 +70,6 @@ module IsoDoc::WordFunction
       node.xpath(ns("./note")).each { |n| parse(n, out) }
     end
 
-    def section_break(body)
-      body.p do |p|
-        p.br **{ clear: "all", class: "section" }
-      end
-    end
-
-    def page_break(out)
-      out.p do |p|
-        p.br **{ clear: "all",
-                 style: "mso-special-character:line-break;"\
-                 "page-break-before:always" }
-      end
-    end
-
-    def pagebreak_parse(node, out)
-      return page_break(out) if node["orientation"].nil?
-      out.p do |p|
-        p.br **{clear: "all", class: "section", 
-                orientation: node["orientation"] }
-      end
-    end
-
     WORD_DT_ATTRS = {class: @note ? "Note" : nil, align: "left",
                      style: "margin-left:0pt;text-align:left;"}.freeze
 
@@ -174,10 +153,10 @@ module IsoDoc::WordFunction
     end
 
     def termnote_parse(node, out)
-      out.div **{ class: "Note" } do |div|
+      out.div **note_attrs(node) do |div|
         first = node.first_element_child
         div.p **{ class: "Note" } do |p|
-          anchor = get_anchors[node['id']]
+          anchor = @xrefs.get[node['id']]
           p << "#{anchor&.dig(:label) || '???'}: "
           para_then_remainder(first, node, p, div)
         end
@@ -185,41 +164,23 @@ module IsoDoc::WordFunction
     end
 
     def para_attrs(node)
-      attrs = { class: para_class(node), id: node["id"] }
+      attrs = { class: para_class(node), id: node["id"], style: "" }
       unless node["align"].nil?
         attrs[:align] = node["align"] unless node["align"] == "justify"
-        attrs[:style] = "text-align:#{node['align']}"
+        attrs[:style] += "text-align:#{node['align']};"
       end
+      attrs[:style] += "#{keep_style(node)}"
+      attrs[:style] = nil if attrs[:style].empty?
       attrs
     end
 
-    def imgsrc(uri)
-      return uri unless %r{^data:image/}.match uri
-      save_dataimage(uri)
-    end
-
-    def image_parse(node, out, caption)
-      attrs = { src: imgsrc(node["src"]),
-                height: node["height"],
-                alt: node["alt"],
-                title: node["title"],
-                width: node["width"] }
-      out.img **attr_code(attrs)
-      image_title_parse(out, caption)
-    end
-
-    def xref_parse(node, out)
-      target = /#/.match(node["target"]) ? node["target"].sub(/#/, ".doc#") :
-        "##{node["target"]}"
-        out.a(**{ "href": target }) { |l| l << get_linkend(node) }
-    end
-
     def example_table_attr(node)
       super.merge({
         style: "mso-table-lspace:15.0cm;margin-left:423.0pt;"\
         "mso-table-rspace:15.0cm;margin-right:423.0pt;"\
         "mso-table-anchor-horizontal:column;"\
-        "mso-table-overlap:never;border-collapse:collapse;"
+        "mso-table-overlap:never;border-collapse:collapse;"\
+        "#{keep_style(node)}"
       })
     end
 
@@ -240,5 +201,10 @@ module IsoDoc::WordFunction
         node.children.each { |n| parse(n, li) }
       end
     end
+
+    def suffix_url(url)
+      return url if %r{^http[s]?://}.match(url)
+      url.sub(/#{File.extname(url)}$/, ".doc")
+    end
   end
 end

data/lib/isodoc/word_function/footnotes.rb

@@ -84,7 +84,7 @@ module IsoDoc::WordFunction
       return seen_footnote_parse(node, out, fn) if @seen_footnote.include?(fn)
       @fn_bookmarks[fn] = bookmarkid
       out.span **{style: "mso-bookmark:_Ref#{@fn_bookmarks[fn]}"} do |s|
-        s.a **{ "epub:type": "footnote", href: "#ftn#{fn}" } do |a|
+        s.a **{ "class": "FootnoteRef", "epub:type": "footnote", href: "#ftn#{fn}" } do |a|
           a.sup { |sup| sup << fn }
         end
       end

data/lib/isodoc/word_function/inline.rb

@@ -0,0 +1,75 @@
+module IsoDoc::WordFunction
+  module Body
+    def section_break(body)
+      body.p do |p|
+        p.br **{ clear: "all", class: "section" }
+      end
+    end
+
+    def page_break(out)
+      out.p do |p|
+        p.br **{ clear: "all",
+                 style: "mso-special-character:line-break;"\
+                 "page-break-before:always" }
+      end
+    end
+
+    def pagebreak_parse(node, out)
+      return page_break(out) if node["orientation"].nil?
+      out.p do |p|
+        p.br **{clear: "all", class: "section",
+                orientation: node["orientation"] }
+      end
+    end
+
+    def imgsrc(node)
+      ret = svg_to_emf(node) and return ret
+      return node["src"] unless %r{^data:image/}.match node["src"]
+      save_dataimage(node["src"])
+    end
+
+    def image_parse(node, out, caption)
+      attrs = { src: imgsrc(node),
+                height: node["height"],
+                alt: node["alt"],
+                title: node["title"],
+                width: node["width"] }
+      out.img **attr_code(attrs)
+      image_title_parse(out, caption)
+    end
+
+    def svg_to_emf_filename(uri)
+      File.join(File.dirname(uri), File.basename(uri, ".*")) + ".emf"
+    end
+
+    def svg_to_emf(node)
+      return unless node["mimetype"] == "image/svg+xml"
+      uri = node["src"]
+      %r{^data:image/}.match(uri) and uri = save_dataimage(uri)
+      ret = svg_to_emf_filename(uri)
+      File.exists?(ret) and return ret
+      exe = inkscape_installed? or return nil
+      system %(#{exe} --export-type="emf" #{uri}) and
+        return ret
+      nil
+    end
+
+    def inkscape_installed?
+      cmd = "inkscape"
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+      nil
+    end
+
+    def xref_parse(node, out)
+      target = /#/.match(node["target"]) ? node["target"].sub(/#/, ".doc#") :
+        "##{node["target"]}"
+        out.a(**{ "href": target }) { |l| l << get_linkend(node) }
+    end
+  end
+end

data/lib/isodoc/word_function/postprocess.rb

@@ -32,6 +32,7 @@ xmlns:m="http://schemas.microsoft.com/office/2004/12/omml">
     end
 
     def postprocess(result, filename, dir)
+      filename = filename.sub(/\.doc$/, "")
       header = generate_header(filename, dir)
       result = from_xhtml(cleanup(to_xhtml(textcleanup(result))))
       toWord(result, filename, dir, header)

data/lib/isodoc/word_function/table.rb

@@ -33,12 +33,12 @@ module IsoDoc::WordFunction
         align: td["align"], style: style.gsub(/\n/, "") }
     end
 
-    def make_table_attr(node)
+    def table_attrs(node)
       super.merge(attr_code({
         summary: node["summary"],
         width: node["width"],
         style: "mso-table-anchor-horizontal:column;"\
-        "mso-table-overlap:never;border-spacing:0;border-width:1px;"
+        "mso-table-overlap:never;border-spacing:0;border-width:1px;#{keep_style(node)}"
       }))
     end
 
@@ -46,7 +46,7 @@ module IsoDoc::WordFunction
       @in_table = true
       table_title_parse(node, out)
       out.div **{ align: "center", class: "table_container" } do |div|
-        div.table **make_table_attr(node) do |t|
+        div.table **table_attrs(node) do |t|
           thead_parse(node, t)
           tbody_parse(node, t)
           tfoot_parse(node, t)

data/lib/isodoc/xref.rb

@@ -0,0 +1,59 @@
+require_relative "xref/xref_anchor"
+require_relative "xref/xref_counter"
+require_relative "xref/xref_gen_seq"
+require_relative "xref/xref_gen"
+require_relative "xref/xref_sect_gen"
+require_relative "class_utils"
+
+module IsoDoc
+  class Xref
+    include XrefGen::Anchor
+    include XrefGen::Blocks
+    include XrefGen::Sections
+
+     def initialize(lang, script, klass, labels, options = {})
+      @anchors = {}
+      @lang = lang
+      @script = script
+      @klass = klass
+      @labels = labels
+      @options = options
+    end
+
+    def get
+      @anchors
+    end
+
+    def anchor(id, lbl, warning = true)
+      return nil if id.nil? || id.empty?
+      unless @anchors[id]
+        if warning
+          @seen ||= Seen_Anchor.instance
+          @seen.seen(id) or warn "No label has been processed for ID #{id}"
+          @seen.add(id)
+          return "[#{id}]"
+        end
+      end
+      @anchors.dig(id, lbl)
+    end
+
+    # extract names for all anchors, xref and label
+    def parse(docxml)
+      initial_anchor_names(docxml)
+      back_anchor_names(docxml)
+      # preempt clause notes with all other types of note (ISO default)
+      note_anchor_names(docxml.xpath(ns("//table | //figure")))
+      note_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
+      example_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
+      list_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
+    end
+
+    def ns(xpath)
+      Common::ns(xpath)
+    end
+
+    def l10n(a, lang = @lang, script = @script)
+      IsoDoc::Function::I18n::l10n(a, lang, script)
+    end
+  end
+end

data/lib/isodoc/{function → xref}/xref_anchor.rb

@@ -1,7 +1,7 @@
 require "singleton"
 
-module IsoDoc::Function
-  module XrefGen
+module IsoDoc::XrefGen
+  module Anchor
     class Seen_Anchor
       include Singleton
 
@@ -12,34 +12,23 @@ module IsoDoc::Function
       def seen(x)
         @seen.has_key?(x)
       end
-      
+
       def add(x)
         @seen[x] = true
       end
     end
 
-    @anchors = {}
+    def initialize()
+      @anchors = {}
+    end
 
     def get_anchors
       @anchors
     end
 
-    def anchor(id, lbl, warning = true)
-      return nil if id.nil? || id.empty?
-      unless @anchors[id]
-        if warning
-          @seen ||= Seen_Anchor.instance
-          @seen.seen(id) or warn "No label has been processed for ID #{id}"
-          @seen.add(id)
-          return "[#{id}]"
-        end
-      end
-      @anchors.dig(id, lbl)
-    end
-
     def anchor_struct_label(lbl, elem)
       case elem
-      when @appendix_lbl then l10n("#{elem} #{lbl}")
+      when @labels["appendix"] then l10n("#{elem} #{lbl}")
       else
         lbl.to_s
       end
@@ -47,8 +36,8 @@ module IsoDoc::Function
 
     def anchor_struct_xref(lbl, elem)
       case elem
-      when @formula_lbl then l10n("#{elem} (#{lbl})")
-      when @inequality_lbl then l10n("#{elem} (#{lbl})")
+      when @labels["formula"] then l10n("#{elem} (#{lbl})")
+      when @labels["inequality"] then l10n("#{elem} (#{lbl})")
       else
         l10n("#{elem} #{lbl}")
       end
@@ -59,7 +48,7 @@ module IsoDoc::Function
       ret[:label] = unnumbered == "true" ? nil : anchor_struct_label(lbl, elem)
       ret[:xref] = anchor_struct_xref(unnumbered == "true" ? "(??)" : lbl, elem)
       ret[:xref].gsub!(/ $/, "")
-      ret[:container] = get_clause_id(container) unless container.nil?
+      ret[:container] = @klass.get_clause_id(container) unless container.nil?
       ret[:type] = type
       ret
     end

data/lib/isodoc/xref/xref_counter.rb

@@ -0,0 +1,74 @@
+require "roman-numerals"
+
+module IsoDoc::XrefGen
+  class Counter
+    def initialize
+      @num = 0
+      @letter = ""
+      @subseq = ""
+      @letter_override = nil
+      @number_override = nil
+    end
+
+    def new_subseq_increment(node)
+      @subseq = node["subsequence"]
+      @num += 1
+      @letter = node["subsequence"] ? "a" : ""
+      if node["number"]
+        /^(?<n>\d*)(?<a>[a-z]*)$/ =~ node["number"]
+        if n || a
+          @letter_override = @letter = a if a
+          @number_override = @num = n.to_i if n
+        else
+          @letter_override = node["number"]
+          @letter = @letter_override if /^[a-z]$/.match(@letter_override)
+        end
+      end
+    end
+
+    def sequence_increment(node)
+      if node["number"]
+        @number_override = node["number"]
+        @num = @number_override.to_i if /^\d+$/.match(@number_override)
+      else
+        @num += 1
+      end
+    end
+
+    def subsequence_increment(node)
+      if node["number"]
+        @letter_override = node["number"]
+        @letter = @letter_override if /^[a-z]$/.match(@letter_override)
+      else
+        @letter = (@letter.ord + 1).chr.to_s
+      end
+    end
+
+    def increment(node)
+      return self if node["unnumbered"]
+      @letter_override = nil
+      @number_override = nil
+      if node["subsequence"] != @subseq
+        new_subseq_increment(node)
+      elsif @letter.empty?
+        sequence_increment(node)
+      else
+        subsequence_increment(node)
+      end
+      self
+    end
+
+    def print
+      "#{@number_override || @num}#{@letter_override || @letter}"
+    end
+
+    def listlabel(depth)
+      return @num.to_s if [2, 7].include? depth
+      return (96 + @num).chr.to_s if [1, 6].include? depth
+      return (64 + @num).chr.to_s if [4, 9].include? depth
+      return RomanNumerals.to_roman(@num).downcase if [3, 8].include? depth
+      return RomanNumerals.to_roman(@num).upcase if [5, 10].include? depth
+      return @num.to_s
+    end
+  end
+end