isodoc 1.7.5 → 1.8.0

data/lib/isodoc/word_function/comments.rb

@@ -1,145 +1,150 @@
-module IsoDoc::WordFunction
-  module Comments
+module IsoDoc
+  module WordFunction
+    module Comments
+      def in_comment
+        @in_comment
+      end
 
-    def in_comment
-      @in_comment
-    end
+      def comments(div)
+        return if @comments.empty?
 
-    def comments(div)
-      return if @comments.empty?
-      div.div **{ style: "mso-element:comment-list" } do |div1|
-        @comments.each { |fn| div1.parent << fn }
+        div.div **{ style: "mso-element:comment-list" } do |div1|
+          @comments.each { |fn| div1.parent << fn }
+        end
       end
-    end
 
-    def review_note_parse(node, out)
-      fn = @comments.length + 1
-      make_comment_link(out, fn, node)
-      @in_comment = true
-      @comments << make_comment_text(node, fn)
-      @in_comment = false
-    end
+      def review_note_parse(node, out)
+        fn = @comments.length + 1
+        make_comment_link(out, fn, node)
+        @in_comment = true
+        @comments << make_comment_text(node, fn)
+        @in_comment = false
+      end
 
-    def comment_link_attrs(fn, node)
-      { style: "MsoCommentReference", target: fn,
-        class: "commentLink", from: node["from"],
-        to: node["to"] }
-    end
+      def comment_link_attrs(fnote, node)
+        { style: "MsoCommentReference", target: fnote,
+          class: "commentLink", from: node["from"],
+          to: node["to"] }
+      end
 
-    # add in from and to links to move the comment into place
-    def make_comment_link(out, fn, node)
-      out.span(**comment_link_attrs(fn, node)) do |s1|
-        s1.span **{ lang: "EN-GB", style: "font-size:9.0pt" } do |s2|
-          s2.a **{ style: "mso-comment-reference:SMC_#{fn};"\
-                   "mso-comment-date:#{node['date'].gsub(/[:-]+/, '')}" }
-          s2.span **{ style: "mso-special-character:comment",
-                      target: fn } # do |s|
+      # add in from and to links to move the comment into place
+      def make_comment_link(out, fnote, node)
+        out.span(**comment_link_attrs(fnote, node)) do |s1|
+          s1.span **{ lang: "EN-GB", style: "font-size:9.0pt" } do |s2|
+            s2.a **{ style: "mso-comment-reference:SMC_#{fnote};"\
+                            "mso-comment-date:#{node['date'].gsub(/[:-]+/,
+                                                                  '')}" }
+            s2.span **{ style: "mso-special-character:comment",
+                        target: fnote } # do |s|
+          end
         end
       end
-    end
 
-    def make_comment_target(out)
-      out.span **{ style: "MsoCommentReference" } do |s1|
-        s1.span **{ lang: "EN-GB", style: "font-size:9.0pt" } do |s2|
-          s2.span **{ style: "mso-special-character:comment" }
+      def make_comment_target(out)
+        out.span **{ style: "MsoCommentReference" } do |s1|
+          s1.span **{ lang: "EN-GB", style: "font-size:9.0pt" } do |s2|
+            s2.span **{ style: "mso-special-character:comment" }
+          end
         end
       end
-    end
 
-    def make_comment_text(node, fn)
-      noko do |xml|
-        xml.div **{ style: "mso-element:comment", id: fn } do |div|
-          div.span **{ style: %{mso-comment-author:"#{node['reviewer']}"} }
-          make_comment_target(div)
-          node.children.each { |n| parse(n, div) }
-        end
-      end.join("\n")
-    end
+      def make_comment_text(node, fnote)
+        noko do |xml|
+          xml.div **{ style: "mso-element:comment", id: fnote } do |div|
+            div.span **{ style: %{mso-comment-author:"#{node['reviewer']}"} }
+            make_comment_target(div)
+            node.children.each { |n| parse(n, div) }
+          end
+        end.join("\n")
+      end
 
-    def comment_cleanup(docxml)
-      move_comment_link_to_from(docxml)
-      reorder_comments_by_comment_link(docxml)
-      embed_comment_in_comment_list(docxml)
-    end
+      def comment_cleanup(docxml)
+        move_comment_link_to_from(docxml)
+        reorder_comments_by_comment_link(docxml)
+        embed_comment_in_comment_list(docxml)
+      end
 
-    COMMENT_IN_COMMENT_LIST1 =
-      '//div[@style="mso-element:comment-list"]//'\
-      'span[@style="MsoCommentReference"]'.freeze
+      COMMENT_IN_COMMENT_LIST1 =
+        '//div[@style="mso-element:comment-list"]//'\
+        'span[@style="MsoCommentReference"]'.freeze
 
-    def embed_comment_in_comment_list(docxml)
-      #docxml.xpath(COMMENT_IN_COMMENT_LIST).each do |x|
-      docxml.xpath(COMMENT_IN_COMMENT_LIST1).each do |x|
-        n = x.next_element
-        n&.children&.first&.add_previous_sibling(x.remove)
+      def embed_comment_in_comment_list(docxml)
+        # docxml.xpath(COMMENT_IN_COMMENT_LIST).each do |x|
+        docxml.xpath(COMMENT_IN_COMMENT_LIST1).each do |x|
+          n = x.next_element
+          n&.children&.first&.add_previous_sibling(x.remove)
+        end
+        docxml
       end
-      docxml
-    end
 
-    def move_comment_link_to_from1(x, fromlink)
-      x.remove
-      link = x.at(".//a")
-      fromlink.replace(x)
-      link.children = fromlink
-    end
+      def move_comment_link_to_from1(tolink, fromlink)
+        tolink.remove
+        link = tolink.at(".//a")
+        fromlink.replace(tolink)
+        link.children = fromlink
+      end
 
-    def comment_attributes(docxml, x)
-      fromlink = docxml.at("//*[@id='#{x['from']}']")
-      return(nil) if fromlink.nil?
-      tolink = docxml.at("//*[@id='#{x['to']}']") || fromlink
-      target = docxml.at("//*[@id='#{x['target']}']")
-      { from: fromlink, to: tolink, target: target }
-    end
+      def comment_attributes(docxml, x)
+        fromlink = docxml.at("//*[@id='#{x['from']}']")
+        return(nil) if fromlink.nil?
 
-    def wrap_comment_cont(from, target)
-      s = from.replace("<span style='mso-comment-continuation:#{target}'>")
-      s.first.children = from
-    end
+        tolink = docxml.at("//*[@id='#{x['to']}']") || fromlink
+        target = docxml.at("//*[@id='#{x['target']}']")
+        { from: fromlink, to: tolink, target: target }
+      end
 
-    def skip_comment_wrap(from)
-      from["style"] != "mso-special-character:comment"
-    end
+      def wrap_comment_cont(from, target)
+        s = from.replace("<span style='mso-comment-continuation:#{target}'>")
+        s.first.children = from
+      end
+
+      def skip_comment_wrap(from)
+        from["style"] != "mso-special-character:comment"
+      end
 
-    def insert_comment_cont(from, to, target)
-      # includes_to = from.at(".//*[@id='#{to}']")
-      while !from.nil? && from["id"] != to
-        following = from.xpath("./following::*")
-        (from = following.shift) && incl_to = from.at(".//*[@id='#{to}']")
-        while !incl_to.nil? && !from.nil? && skip_comment_wrap(from)
-          (from = following.shift) && incl_to = from.at(".//*[@id='#{to}']")
+      def insert_comment_cont(from, upto, target)
+        # includes_to = from.at(".//*[@id='#{upto}']")
+        while !from.nil? && from["id"] != upto
+          following = from.xpath("./following::*")
+          (from = following.shift) && incl_to = from.at(".//*[@id='#{upto}']")
+          while !incl_to.nil? && !from.nil? && skip_comment_wrap(from)
+            (from = following.shift) && incl_to = from.at(".//*[@id='#{upto}']")
+          end
+          wrap_comment_cont(from, target) if !from.nil?
         end
-        wrap_comment_cont(from, target) if !from.nil?
       end
-    end
 
-    def move_comment_link_to_from(docxml)
-      docxml.xpath('//span[@style="MsoCommentReference"][@from]').each do |x|
-        attrs = comment_attributes(docxml, x) || next
-        move_comment_link_to_from1(x, attrs[:from])
-        insert_comment_cont(attrs[:from], x["to"], x["target"])
+      def move_comment_link_to_from(docxml)
+        docxml.xpath('//span[@style="MsoCommentReference"][@from]').each do |x|
+          attrs = comment_attributes(docxml, x) || next
+          move_comment_link_to_from1(x, attrs[:from])
+          insert_comment_cont(attrs[:from], x["to"], x["target"])
+        end
       end
-    end
 
-    def get_comments_from_text(docxml, link_order)
-      comments = []
-      docxml.xpath("//div[@style='mso-element:comment']").each do |c|
-        next unless c["id"] && !link_order[c["id"]].nil?
-        comments << { text: c.remove.to_s, id: c["id"] }
+      def get_comments_from_text(docxml, link_order)
+        comments = []
+        docxml.xpath("//div[@style='mso-element:comment']").each do |c|
+          next unless c["id"] && !link_order[c["id"]].nil?
+
+          comments << { text: c.remove.to_s, id: c["id"] }
+        end
+        comments.sort! { |a, b| link_order[a[:id]] <=> link_order[b[:id]] }
+        # comments
       end
-      comments.sort! { |a, b| link_order[a[:id]] <=> link_order[b[:id]] }
-      # comments
-    end
 
-    COMMENT_TARGET_XREFS1 =
-      "//span[@style='mso-special-character:comment']/@target".freeze
+      COMMENT_TARGET_XREFS1 =
+        "//span[@style='mso-special-character:comment']/@target".freeze
 
-    def reorder_comments_by_comment_link(docxml)
-      link_order = {}
-      docxml.xpath(COMMENT_TARGET_XREFS1).each_with_index do |target, i|
-        link_order[target.value] = i
+      def reorder_comments_by_comment_link(docxml)
+        link_order = {}
+        docxml.xpath(COMMENT_TARGET_XREFS1).each_with_index do |target, i|
+          link_order[target.value] = i
+        end
+        comments = get_comments_from_text(docxml, link_order)
+        list = docxml.at("//*[@style='mso-element:comment-list']") || return
+        list.children = comments.map { |c| c[:text] }.join("\n")
       end
-      comments = get_comments_from_text(docxml, link_order)
-      list = docxml.at("//*[@style='mso-element:comment-list']") || return
-      list.children = comments.map { |c| c[:text] }.join("\n")
     end
   end
 end

data/lib/isodoc/word_function/footnotes.rb

@@ -1,112 +1,114 @@
-module IsoDoc::WordFunction
-  module Footnotes
-    def bookmarkid
-      ret = "X"
-      until !@bookmarks_allocated[ret]
-        ret = Random.rand(1000000000)
+module IsoDoc
+  module WordFunction
+    module Footnotes
+      def bookmarkid
+        ret = "X"
+        until !@bookmarks_allocated[ret]
+          ret = Random.rand(1000000000)
+        end
+        @bookmarks_allocated[ret] = true
+        sprintf "%09d", ret
       end
-      @bookmarks_allocated[ret] = true
-      sprintf "%09d", ret
-    end
-
-    def footnotes(div)
-      return if @footnotes.empty?
 
-      @footnotes.each { |fn| div.parent << fn }
-    end
+      def footnotes(div)
+        return if @footnotes.empty?
 
-    def make_table_footnote_link(out, fnid, fnref)
-      attrs = { href: "##{fnid}", class: "TableFootnoteRef" }
-      out.a **attrs do |a|
-        a << fnref
+        @footnotes.each { |fn| div.parent << fn }
       end
-    end
 
-    def make_table_footnote_target(out, fnid, fnref)
-      attrs = { id: fnid, class: "TableFootnoteRef" }
-      out.span do |s|
-        out.span **attrs do |a|
+      def make_table_footnote_link(out, fnid, fnref)
+        attrs = { href: "##{fnid}", class: "TableFootnoteRef" }
+        out.a **attrs do |a|
           a << fnref
         end
-        insert_tab(s, 1)
       end
-    end
 
-    def make_table_footnote_text(node, fnid, fnref)
-      attrs = { id: "ftn#{fnid}" }
-      noko do |xml|
-        xml.div **attr_code(attrs) do |div|
-          make_table_footnote_target(div, fnid, fnref)
-          node.children.each { |n| parse(n, div) }
+      def make_table_footnote_target(out, fnid, fnref)
+        attrs = { id: fnid, class: "TableFootnoteRef" }
+        out.span do |s|
+          out.span **attrs do |a|
+            a << fnref
+          end
+          insert_tab(s, 1)
         end
-      end.join("\n")
-    end
+      end
 
-    def make_generic_footnote_text(node, fnid)
-      noko do |xml|
-        xml.aside **{ id: "ftn#{fnid}" } do |div|
-          node.children.each { |n| parse(n, div) }
-        end
-      end.join("\n")
-    end
+      def make_table_footnote_text(node, fnid, fnref)
+        attrs = { id: "ftn#{fnid}" }
+        noko do |xml|
+          xml.div **attr_code(attrs) do |div|
+            make_table_footnote_target(div, fnid, fnref)
+            node.children.each { |n| parse(n, div) }
+          end
+        end.join("\n")
+      end
 
-    def get_table_ancestor_id(node)
-      table = node.ancestors("table") || node.ancestors("figure")
-      return UUIDTools::UUID.random_create.to_s if table.empty?
+      def make_generic_footnote_text(node, fnid)
+        noko do |xml|
+          xml.aside **{ id: "ftn#{fnid}" } do |div|
+            node.children.each { |n| parse(n, div) }
+          end
+        end.join("\n")
+      end
 
-      table.last["id"]
-    end
+      def get_table_ancestor_id(node)
+        table = node.ancestors("table") || node.ancestors("figure")
+        return UUIDTools::UUID.random_create.to_s if table.empty?
 
-    def table_footnote_parse(node, out)
-      fn = node["reference"] || UUIDTools::UUID.random_create.to_s
-      tid = get_table_ancestor_id(node)
-      make_table_footnote_link(out, tid + fn, fn)
-      # do not output footnote text if we have already seen it for this table
-      return if @seen_footnote.include?(tid + fn)
-
-      @in_footnote = true
-      out.aside { |a| a << make_table_footnote_text(node, tid + fn, fn) }
-      @in_footnote = false
-      @seen_footnote << (tid + fn)
-    end
+        table.last["id"]
+      end
 
-    def seen_footnote_parse(_node, out, footnote)
-      out.span **{ style: "mso-element:field-begin" }
-      out << " NOTEREF _Ref#{@fn_bookmarks[footnote]} \\f \\h"
-      out.span **{ style: "mso-element:field-separator" }
-      out.span **{ class: "MsoFootnoteReference" } do |s|
-        s << footnote
+      def table_footnote_parse(node, out)
+        fn = node["reference"] || UUIDTools::UUID.random_create.to_s
+        tid = get_table_ancestor_id(node)
+        make_table_footnote_link(out, tid + fn, fn)
+        # do not output footnote text if we have already seen it for this table
+        return if @seen_footnote.include?(tid + fn)
+
+        @in_footnote = true
+        out.aside { |a| a << make_table_footnote_text(node, tid + fn, fn) }
+        @in_footnote = false
+        @seen_footnote << (tid + fn)
       end
-      out.span **{ style: "mso-element:field-end" }
-    end
 
-    def footnote_parse(node, out)
-      return table_footnote_parse(node, out) if (@in_table || @in_figure) &&
-        !node.ancestors.map { |m| m.name }.include?("name")
+      def seen_footnote_parse(_node, out, footnote)
+        out.span **{ style: "mso-element:field-begin" }
+        out << " NOTEREF _Ref#{@fn_bookmarks[footnote]} \\f \\h"
+        out.span **{ style: "mso-element:field-separator" }
+        out.span **{ class: "MsoFootnoteReference" } do |s|
+          s << footnote
+        end
+        out.span **{ style: "mso-element:field-end" }
+      end
+
+      def footnote_parse(node, out)
+        return table_footnote_parse(node, out) if (@in_table || @in_figure) &&
+          !node.ancestors.map(&:name).include?("name")
 
-      fn = node["reference"] || UUIDTools::UUID.random_create.to_s
-      return seen_footnote_parse(node, out, fn) if @seen_footnote.include?(fn)
+        fn = node["reference"] || UUIDTools::UUID.random_create.to_s
+        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 **{ "class": "FootnoteRef", "epub:type": "footnote",
-                href: "#ftn#{fn}" } do |a|
-          a.sup { |sup| sup << fn }
+        @fn_bookmarks[fn] = bookmarkid
+        out.span **{ style: "mso-bookmark:_Ref#{@fn_bookmarks[fn]}" } do |s|
+          s.a **{ class: "FootnoteRef", "epub:type": "footnote",
+                  href: "#ftn#{fn}" } do |a|
+            a.sup { |sup| sup << fn }
+          end
         end
+        @in_footnote = true
+        @footnotes << make_generic_footnote_text(node, fn)
+        @in_footnote = false
+        @seen_footnote << fn
       end
-      @in_footnote = true
-      @footnotes << make_generic_footnote_text(node, fn)
-      @in_footnote = false
-      @seen_footnote << fn
-    end
 
-    def make_footnote(node, footnote)
-      return if @seen_footnote.include?(footnote)
+      def make_footnote(node, footnote)
+        return if @seen_footnote.include?(footnote)
 
-      @in_footnote = true
-      @footnotes << make_generic_footnote_text(node, footnote)
-      @in_footnote = false
-      @seen_footnote << footnote
+        @in_footnote = true
+        @footnotes << make_generic_footnote_text(node, footnote)
+        @in_footnote = false
+        @seen_footnote << footnote
+      end
     end
   end
 end

data/lib/isodoc/word_function/inline.rb

@@ -1,83 +1,58 @@
-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" }
+module IsoDoc
+  module WordFunction
+    module Body
+      def section_break(body)
+        body.p do |p|
+          p.br **{ clear: "all", class: "section" }
+        end
       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"] }
+      def page_break(out)
+        out.p do |p|
+          p.br **{ clear: "all",
+                   style: "mso-special-character:line-break;"\
+                          "page-break-before:always" }
+        end
       end
-    end
-
-    def svg_parse(node, out)
-      svg = Base64.strict_encode64(node.to_xml)
-      r = node.replace("<img src='data:image/svg+xml;base64,#{svg}' mimetype='image/svg+xml'/>").first
-      image_parse(r, out, nil)
-    end
 
-    def imgsrc(node)
-      ret = svg_to_emf(node) and return ret
-      return node["src"] unless %r{^data:}.match node["src"]
-      save_dataimage(node["src"])
-    end
+      def pagebreak_parse(node, out)
+        return page_break(out) if node["orientation"].nil?
 
-    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
+        out.p do |p|
+          p.br **{ clear: "all", class: "section",
+                   orientation: node["orientation"] }
+        end
+      end
 
-    def svg_to_emf_filename(uri)
-      File.join(File.dirname(uri), File.basename(uri, ".*")) + ".emf"
-    end
+      def imgsrc(node)
+        return node["src"] unless %r{^data:}.match? node["src"]
 
-    def svg_to_emf(node)
-      return unless node["mimetype"] == "image/svg+xml"
-      uri = node["src"]
-      %r{^data:}.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
+        save_dataimage(node["src"])
+      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)
+      def image_parse(node, out, caption)
+        if emf = node.at(ns("./emf"))
+          node["src"] = emf["src"]
+          node["mimetype"] = "image/x-emf"
+          node.children.remove
         end
+        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
-      nil
-    end
 
-    def xref_parse(node, out)
-      target = /#/.match(node["target"]) ? node["target"].sub(/#/, ".doc#") :
-        "##{node["target"]}"
-        out.a(**{ "href": target }) do |l|
+      def xref_parse(node, out)
+        target = if /#/.match?(node["target"])
+                   node["target"].sub(/#/, ".doc#")
+                 else
+                   "##{node['target']}"
+                 end
+        out.a(**{ href: target }) do |l|
           node.children.each { |n| parse(n, l) }
         end
+      end
     end
   end
 end