isodoc 1.7.5 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b42d786cf8fa0f78ac01afba8de3e886b35eddd191551b6ce20ec680d7441d39
-  data.tar.gz: 5db56071fb06162e738b7eff5c5726bf0eae2acc80dbcbfaf1c589ba04729a55
+  metadata.gz: e798df14fbf858fd0540d3fb2837774ec6a1924d5590ad4a628699888eff8425
+  data.tar.gz: 8f3e143a4c3cbcba0c4c349c315c6bf7b067164cd4cc22bd06a85dce71268e73
 SHA512:
-  metadata.gz: 546f673176c4c6757567e43c3221c9e019d7f88f515636e9287e3e8016625a0741277b02d4b3de02cb09e301a76ac39dd8a7b7a62aa90a272c94b9f93529e84f
-  data.tar.gz: 6f1db97d1acb6c413bc84265e6e9182b46a645509780457074584d4d37bf1f958e2220eac71958f0167438ed99da7ff12029a1beeda010f23229c47ec5976b50
+  metadata.gz: 6a0fbbabc25df62e19eeefecbf3369188194e28348ac6758f59024b58c0e4e23695440e41263c049455a12b1ce210e602c58e6142e9b8b95ac79d2fa8a64d341
+  data.tar.gz: 888429742fbf4ee0ab902b1a34d5edb8d7657b2fb561ecf3fe872fe48de14267e0e7edcae1e27c86ed5b36dc8d0becccd0ca6f96f6f1239936fb1bd287dc0130

data/isodoc.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["open.source@ribose.com"]
 
   spec.summary       = "Convert documents in IsoDoc into Word and HTML "\
-    "in AsciiDoc."
+                       "in AsciiDoc."
   spec.description   = <<~DESCRIPTION
     isodoc converts documents in the IsoDoc document model into
     Microsoft Word and HTML.
@@ -29,29 +29,30 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
   spec.add_dependency "asciimath"
-  spec.add_dependency "html2doc", "~> 1.1.1"
+  spec.add_dependency "html2doc", "~> 1.2.0"
   spec.add_dependency "htmlentities", "~> 4.3.4"
   spec.add_dependency "liquid", "~> 4"
-  #spec.add_dependency "metanorma", ">= 1.2.0"
-  spec.add_dependency "nokogiri", "~> 1.11.0"
+  # spec.add_dependency "metanorma", ">= 1.2.0"
+  spec.add_dependency "emf2svg", "~> 1"
+  spec.add_dependency "mathml2asciimath"
+  spec.add_dependency "metanorma-utils"
+  spec.add_dependency "nokogiri", "~> 1.12.0"
   spec.add_dependency "relaton-cli"
   spec.add_dependency "roman-numerals"
   spec.add_dependency "thread_safe"
   spec.add_dependency "twitter_cldr", ">= 6.6.0"
   spec.add_dependency "uuidtools"
-  spec.add_dependency "mathml2asciimath"
-  spec.add_dependency "metanorma-utils"
 
   spec.add_development_dependency "byebug", "~> 9.1"
   spec.add_development_dependency "equivalent-xml", "~> 0.6"
   spec.add_development_dependency "guard", "~> 2.14"
   spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "metanorma-iso"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rexml"
   spec.add_development_dependency "rspec", "~> 3.6"
   spec.add_development_dependency "rubocop", "~> 1.5.2"
   spec.add_development_dependency "sassc", "~> 2.4.0"
   spec.add_development_dependency "simplecov", "~> 0.15"
-  spec.add_development_dependency "metanorma-iso"
   spec.add_development_dependency "timecop", "~> 0.9"
 end

data/lib/isodoc/class_utils.rb

@@ -23,9 +23,32 @@ module IsoDoc
       # unescape HTML escapes in doc
       doc = doc.split(%r<(\{%|%\})>).each_slice(4).map do |a|
         a[2] = a[2].gsub("&lt;", "<").gsub("&gt;", ">") if a.size > 2
-        a.join("")
-      end.join("")
+        a.join
+      end.join
       Liquid::Template.parse(doc)
     end
+
+    def case_strict(text, casing, script)
+      return text unless %w(Latn Cyrl Grek Armn).include?(script)
+
+      letters = text.chars
+      case casing
+      when "capital" then letters.first.upcase!
+      when "lowercase" then letters.first.downcase!
+      end
+      letters.join
+    end
+
+    def case_with_markup(linkend, casing, script)
+      seen = false
+      xml = Nokogiri::XML("<root>#{linkend}</root>")
+      xml.traverse do |b|
+        next unless b.text? && !seen
+
+        b.replace(Common::case_strict(b.text, casing, script))
+        seen = true
+      end
+      xml.root.children.to_xml
+    end
   end
 end

data/lib/isodoc/convert.rb

@@ -101,6 +101,8 @@ module IsoDoc
       @htmlToClevels = 2 if @htmlToClevels.zero?
       @bookmarks_allocated = { "X" => true }
       @fn_bookmarks = {}
+      @baseassetpath = options[:baseassetpath]
+      @aligncrosselements = options[:aligncrosselements]
     end
 
     def tmpimagedir_suffix

data/lib/isodoc/function/cleanup.rb

@@ -165,6 +165,10 @@ module IsoDoc
             t << a.remove
           end
         end
+        table_footnote_cleanup_propagate(docxml)
+      end
+
+      def table_footnote_cleanup_propagate(docxml)
         docxml.xpath("//p[not(self::*[@class])]"\
                      "[ancestor::*[@class = 'TableFootnote']]").each do |p|
           p["class"] = "TableFootnote"

data/lib/isodoc/function/to_word_html.rb

@@ -21,7 +21,8 @@ module IsoDoc
         filename = filepath.sub_ext("").sub(/\.presentation$/, "").to_s
         dir = init_dir(filename, debug)
         @filename = filename
-        @localdir = "#{filepath.parent}/"
+        @localdir = @baseassetpath || filepath.parent.to_s
+        @localdir += "/"
         @sourcedir = @localdir
         @sourcefilename and
           @sourcedir = "#{Pathname.new(@sourcefilename).parent}/"

data/lib/isodoc/function/utils.rb

@@ -37,14 +37,14 @@ module IsoDoc
       end
 
       def attr_code(attributes)
-        attributes = attributes.reject { |_, val| val.nil? }.map
+        attributes = attributes.compact.map
         attributes.map do |k, v|
           [k, v.is_a?(String) ? HTMLEntities.new.decode(v) : v]
         end.to_h
       end
 
       DOCTYPE_HDR = "<!DOCTYPE html SYSTEM "\
-        '"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
+                    '"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
 
       def to_xhtml(xml)
         xml = to_xhtml_prep(xml)
@@ -55,7 +55,7 @@ module IsoDoc
             f.write xml
           end
           abort "Malformed Output XML for #{@format}: #{e} "\
-            "(see #{@filename}.#{@format}.err)"
+                "(see #{@filename}.#{@format}.err)"
         end
       end
 
@@ -67,7 +67,7 @@ module IsoDoc
             HTMLEntities.new.encode(HTMLEntities.new.decode(t), :hexadecimal)
           else t
           end
-        end.join("")
+        end.join
       end
 
       def to_xhtml_fragment(xml)
@@ -148,18 +148,12 @@ module IsoDoc
           elem.name == "span" && /mso-bookmark/.match(elem["style"])
       end
 
-=begin
-      def liquid(doc)
-        self.class.liquid(doc)
-      end
-=end
-
       def liquid(doc)
         # unescape HTML escapes in doc
         doc = doc.split(%r<(\{%|%\})>).each_slice(4).map do |a|
           a[2] = a[2].gsub(/&lt;/, "<").gsub(/&gt;/, ">") if a.size > 2
-          a.join("")
-        end.join("")
+          a.join
+        end.join
         Liquid::Template.parse(doc)
       end
 
@@ -181,8 +175,9 @@ module IsoDoc
       end
 
       def save_dataimage(uri, _relative_dir = true)
-        %r{^data:(image|application)/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ uri
-        imgtype.sub!(/\+[a-z0-9]+$/, "") # svg+xml
+        %r{^data:(?<imgclass>image|application)/(?<imgtype>[^;]+);(charset=[^;]+;)?base64,(?<imgdata>.+)$} =~ uri
+        imgtype = "emf" if emf?("#{imgclass}/#{imgtype}")
+        imgtype = imgtype.sub(/\+[a-z0-9]+$/, "") # svg+xml
         imgtype = "png" unless /^[a-z0-9]+$/.match? imgtype
         Tempfile.open(["image", ".#{imgtype}"]) do |f|
           f.binmode
@@ -206,6 +201,31 @@ module IsoDoc
         !node.ancestors("example, requirement, recommendation, permission, "\
                         "note, table, figure, sourcecode").empty?
       end
+
+      def emf?(type)
+        %w(application/emf application/x-emf image/x-emf image/x-mgx-emf
+           application/x-msmetafile image/x-xbitmap).include? type
+      end
+
+      def cleanup_entities(text)
+        c = HTMLEntities.new
+        text.split(/([<>])/).each_slice(4).map do |a|
+          a[0] = c.encode(c.decode(a[0]), :hexadecimal)
+          a[2] = c.encode(c.decode(a[2]), :hexadecimal) if a.size >= 3
+          a
+        end.join
+      end
+
+      def external_path(path)
+        win = !!((RUBY_PLATFORM =~ /(win|w)(32|64)$/) ||
+                 (RUBY_PLATFORM =~ /mswin|mingw/))
+        if win
+          path.gsub!(%{/}, "\\")
+          path[/\s/] ? "\"#{path}\"" : path
+        else
+          path
+        end
+      end
     end
   end
 end

data/lib/isodoc/html_function/comments.rb

@@ -1,146 +1,142 @@
-module IsoDoc::HtmlFunction
-  module Comments
-
-    def in_comment
-      @in_comment
-    end
+module IsoDoc
+  module HtmlFunction
+    module Comments
+      def in_comment
+        @in_comment
+      end
 
-    def comments(div)
-=begin
-      return if @comments.empty?
-      div.div **{ style: "mso-element:comment-list" } do |div1|
-        @comments.each { |fn| div1.parent << fn }
+      def comments(div)
+        #       return if @comments.empty?
+        #       div.div **{ style: "mso-element:comment-list" } do |div1|
+        #         @comments.each { |fn| div1.parent << fn }
+        #       end
       end
-=end
-    end
 
-    def review_note_parse(node, out)
-=begin
-      fn = @comments.length + 1
-      make_comment_link(out, fn, node)
-      @in_comment = true
-      @comments << make_comment_text(node, fn)
-      @in_comment = false
-=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 comment_link_attrs(fnote, node)
-      { style: "MsoCommentReference", target: fnote,
-        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, fnote, node)
-      out.span(**comment_link_attrs(fnote, node)) do |s1|
+      # 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.a **{ style: "mso-comment-reference:SMC_#{fnote};"\
-                   "mso-comment-date:#{node['date'].gsub(/[-:Z]/, '')}" }
+                          "mso-comment-date:#{node['date'].gsub(/[-:Z]/,
+                                                                '')}" }
         end
-    end
+      end
 
-    def make_comment_target(out)
-      out.span **{ style: "MsoCommentReference" } do |s1|
+      def make_comment_target(out)
+        out.span **{ style: "MsoCommentReference" } do |s1|
           s1.span **{ style: "mso-special-character:comment" }
         end
-    end
+      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 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)
-=begin
-      move_comment_link_to_from(docxml)
-      reorder_comments_by_comment_link(docxml)
-      embed_comment_in_comment_list(docxml)
-=end
-    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_LIST =
-      '//div[@style="mso-element:comment-list"]//'\
-      'span[@style="MsoCommentReference"]'.freeze
+      COMMENT_IN_COMMENT_LIST =
+        '//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|
-        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|
+          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(x, fromlink)
+        x.remove
+        link = x.at(".//a")
+        fromlink.replace(x)
+        link.children = fromlink
+      end
 
-    def comment_attributes(docxml, x)
-      fromlink = docxml.at("//*[@id='#{x['from']}']")
-      return(nil) if fromlink.nil?
+      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
+        tolink = docxml.at("//*[@id='#{x['to']}']") || fromlink
+        target = docxml.at("//*[@id='#{x['target']}']")
+        { from: fromlink, to: tolink, target: target }
+      end
 
-    def wrap_comment_cont(from, target)
-      s = from.replace("<span style='mso-comment-continuation:#{target}'>")
-      s.first.children = from
-    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 skip_comment_wrap(from)
+        from["style"] != "mso-special-character:comment"
+      end
 
-    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)
+      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?
+      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"] }
+          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_XREFS =
-      "//span[@style='mso-special-character:comment']/@target".freeze
+      COMMENT_TARGET_XREFS =
+        "//span[@style='mso-special-character:comment']/@target".freeze
 
-    def reorder_comments_by_comment_link(docxml)
-      link_order = {}
-      docxml.xpath(COMMENT_TARGET_XREFS).each_with_index do |target, i|
-        link_order[target.value] = i
+      def reorder_comments_by_comment_link(docxml)
+        link_order = {}
+        docxml.xpath(COMMENT_TARGET_XREFS).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/html_function/footnotes.rb

@@ -1,90 +1,91 @@
-module IsoDoc::HtmlFunction
-  module Footnotes
+module IsoDoc
+  module HtmlFunction
+    module Footnotes
+      def footnotes(div)
+        return if @footnotes.empty?
 
-    def footnotes(div)
-      return if @footnotes.empty?
-
-      @footnotes.each { |fn| div.parent << fn }
-    end
-
-    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: "fn:#{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: "fn:#{fnid}", class: "footnote" } do |div|
-          node.children.each { |n| parse(n, div) }
-        end
-      end.join("\n")
-    end
+      def make_table_footnote_text(node, fnid, fnref)
+        attrs = { id: "fn:#{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: "fn:#{fnid}", class: "footnote" } 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?
 
-    # @seen_footnote:
-    # do not output footnote text if we have already seen it for this table
+        table.last["id"]
+      end
 
-    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)
-      return if @seen_footnote.include?(tid + fn)
+      # @seen_footnote:
+      # do not output footnote text if we have already seen it for this table
 
-      @in_footnote = true
-      out.aside **{ class: "footnote" } do |a|
-        a << make_table_footnote_text(node, tid + fn, fn)
+      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)
+        return if @seen_footnote.include?(tid + fn)
+
+        @in_footnote = true
+        out.aside **{ class: "footnote" } do |a|
+          a << make_table_footnote_text(node, tid + fn, fn)
+        end
+        @in_footnote = false
+        @seen_footnote << (tid + fn)
       end
-      @in_footnote = false
-      @seen_footnote << (tid + fn)
-    end
 
-    def footnote_parse(node, out)
-      return table_footnote_parse(node, out) if (@in_table || @in_figure) &&
-        !node.ancestors.map(&:name).include?("name")
+      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
-      attrs = { class: "FootnoteRef", href: "#fn:#{fn}" }
-      out.a **attrs do |a|
-        a.sup { |sup| sup << fn }
+        fn = node["reference"] || UUIDTools::UUID.random_create.to_s
+        attrs = { class: "FootnoteRef", href: "#fn:#{fn}" }
+        out.a **attrs do |a|
+          a.sup { |sup| sup << fn }
+        end
+        make_footnote(node, fn)
       end
-      make_footnote(node, fn)
-    end
 
-    def make_footnote(node, fnote)
-      return if @seen_footnote.include?(fnote)
+      def make_footnote(node, fnote)
+        return if @seen_footnote.include?(fnote)
 
-      @in_footnote = true
-      @footnotes << make_generic_footnote_text(node, fnote)
-      @in_footnote = false
-      @seen_footnote << fnote
+        @in_footnote = true
+        @footnotes << make_generic_footnote_text(node, fnote)
+        @in_footnote = false
+        @seen_footnote << fnote
+      end
     end
   end
 end