isodoc 1.7.2 → 1.7.5

data/lib/isodoc/function/inline.rb

@@ -1,147 +1,149 @@
 require_relative "inline_simple"
 
-module IsoDoc::Function
-  module Inline
-    def link_parse(node, out)
-      url = node["target"]
-      node["updatetype"] == "true" and url = suffix_url(url)
-      out.a **attr_code(href: url, title: node["alt"]) do |l|
-        if node.text.empty?
-          l << node["target"].sub(/^mailto:/, "")
-        else node.children.each { |n| parse(n, l) }
+module IsoDoc
+  module Function
+    module Inline
+      def link_parse(node, out)
+        url = node["target"]
+        node["updatetype"] == "true" and url = suffix_url(url)
+        out.a **attr_code(href: url, title: node["alt"]) do |l|
+          if node.text.empty?
+            l << node["target"].sub(/^mailto:/, "")
+          else node.children.each { |n| parse(n, l) }
+          end
         end
       end
-    end
 
-    def callout_parse(node, out)
-      out << " &lt;#{node.text}&gt;"
-    end
+      def callout_parse(node, out)
+        out << " &lt;#{node.text}&gt;"
+      end
 
-    def no_locality_parse(node, out)
-      node.children.each do |n|
-        parse(n, out) unless %w{locality localityStack}.include? n.name
+      def no_locality_parse(node, out)
+        node.children.each do |n|
+          parse(n, out) unless %w{locality localityStack}.include? n.name
+        end
       end
-    end
 
-    def xref_parse(node, out)
-      target = if /#/.match?(node["target"])
-                 node["target"].sub(/#/, ".html#")
-               else
-                 "##{node['target']}"
-               end
-      out.a(**{ "href": target }) { |l| no_locality_parse(node, l) }
-    end
+      def xref_parse(node, out)
+        target = if /#/.match?(node["target"])
+                   node["target"].sub(/#/, ".html#")
+                 else
+                   "##{node['target']}"
+                 end
+        out.a(**{ href: target }) { |l| no_locality_parse(node, l) }
+      end
 
-    def suffix_url(url)
-      return url if %r{^https?://}.match?(url)
-      return url unless File.extname(url).empty?
+      def suffix_url(url)
+        return url if %r{^https?://}.match?(url)
+        return url unless File.extname(url).empty?
 
-      url.sub(/#{File.extname(url)}$/, ".html")
-    end
+        url.sub(/#{File.extname(url)}$/, ".html")
+      end
 
-    def eref_target(node)
-      href = "##{node['bibitemid']}"
-      url = node.at(ns("//bibitem[@id = '#{node['bibitemid']}']/"\
-                       "uri[@type = 'citation']"))
-      return href unless url
+      def eref_target(node)
+        href = "##{node['bibitemid']}"
+        url = node.at(ns("//bibitem[@id = '#{node['bibitemid']}']/"\
+                         "uri[@type = 'citation']"))
+        return href unless url
 
-      href = suffix_url(url.text)
-      anchor = node&.at(ns(".//locality[@type = 'anchor']"))&.text&.strip
-      anchor and href += "##{anchor}"
-      href
-    end
+        href = suffix_url(url.text)
+        anchor = node&.at(ns(".//locality[@type = 'anchor']"))&.text&.strip
+        anchor and href += "##{anchor}"
+        href
+      end
 
-    def eref_parse(node, out)
-      href = eref_target(node)
-      if node["type"] == "footnote"
-        out.sup do |s|
-          s.a(**{ "href": href }) { |l| no_locality_parse(node, l) }
+      def eref_parse(node, out)
+        href = eref_target(node)
+        if node["type"] == "footnote"
+          out.sup do |s|
+            s.a(**{ href: href }) { |l| no_locality_parse(node, l) }
+          end
+        else
+          out.a(**{ href: href }) { |l| no_locality_parse(node, l) }
         end
-      else
-        out.a(**{ "href": href }) { |l| no_locality_parse(node, l) }
       end
-    end
 
-    def origin_parse(node, out)
-      if t = node.at(ns("./termref"))
-        termrefelem_parse(t, out)
-      else
-        eref_parse(node, out)
+      def origin_parse(node, out)
+        if t = node.at(ns("./termref"))
+          termrefelem_parse(t, out)
+        else
+          eref_parse(node, out)
+        end
       end
-    end
 
-    def termrefelem_parse(node, out)
-      if node.text.strip.empty?
-        out << "Termbase #{node['base']}, term ID #{node['target']}"
-      else
-        node.children.each { |n| parse(n, out) }
+      def termrefelem_parse(node, out)
+        if node.text.strip.empty?
+          out << "Termbase #{node['base']}, term ID #{node['target']}"
+        else
+          node.children.each { |n| parse(n, out) }
+        end
       end
-    end
 
-    def stem_parse(node, out)
-      ooml = case node["type"]
-             when "AsciiMath"
-               "#{@openmathdelim}#{HTMLEntities.new.encode(node.text)}"\
+      def stem_parse(node, out)
+        ooml = case node["type"]
+               when "AsciiMath"
+                 "#{@openmathdelim}#{HTMLEntities.new.encode(node.text)}"\
                  "#{@closemathdelim}"
-             when "MathML" then node.first_element_child.to_s
-             else HTMLEntities.new.encode(node.text)
-             end
-      out.span **{ class: "stem" } do |span|
-        span.parent.add_child ooml
+               when "MathML" then node.first_element_child.to_s
+               else HTMLEntities.new.encode(node.text)
+               end
+        out.span **{ class: "stem" } do |span|
+          span.parent.add_child ooml
+        end
       end
-    end
 
-    def image_title_parse(out, caption)
-      unless caption.nil?
-        out.p **{ class: "FigureTitle", style: "text-align:center;" } do |p|
-          p.b { |b| b << caption.to_s }
+      def image_title_parse(out, caption)
+        unless caption.nil?
+          out.p **{ class: "FigureTitle", style: "text-align:center;" } do |p|
+            p.b { |b| b << caption.to_s }
+          end
         end
       end
-    end
 
-    def image_parse(node, out, caption)
-      attrs = { src: node["src"],
-                height: node["height"] || "auto",
-                width: node["width"] || "auto",
-                title: node["title"],
-                alt: node["alt"] }
-      out.img **attr_code(attrs)
-      image_title_parse(out, caption)
-    end
+      def image_parse(node, out, caption)
+        attrs = { src: node["src"],
+                  height: node["height"] || "auto",
+                  width: node["width"] || "auto",
+                  title: node["title"],
+                  alt: node["alt"] }
+        out.img **attr_code(attrs)
+        image_title_parse(out, caption)
+      end
 
-    def smallcap_parse(node, xml)
-      xml.span **{ style: "font-variant:small-caps;" } do |s|
-        node.children.each { |n| parse(n, s) }
+      def smallcap_parse(node, xml)
+        xml.span **{ style: "font-variant:small-caps;" } do |s|
+          node.children.each { |n| parse(n, s) }
+        end
       end
-    end
 
-    def text_parse(node, out)
-      return if node.nil? || node.text.nil?
+      def text_parse(node, out)
+        return if node.nil? || node.text.nil?
 
-      text = node.to_s
-      if in_sourcecode
-        text = text.gsub("\n", "<br/>").gsub("<br/> ", "<br/>&nbsp;")
-          .gsub(/ (?= )/, "&nbsp;")
+        text = node.to_s
+        if in_sourcecode
+          text = text.gsub("\n", "<br/>").gsub("<br/> ", "<br/>&nbsp;")
+            .gsub(/ (?= )/, "&nbsp;")
+        end
+        out << text
       end
-      out << text
-    end
 
-    def add_parse(node, out)
-      out.span **{ class: "addition" } do |e|
-        node.children.each { |n| parse(n, e) }
+      def add_parse(node, out)
+        out.span **{ class: "addition" } do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def del_parse(node, out)
-      out.span **{ class: "deletion" } do |e|
-        node.children.each { |n| parse(n, e) }
+      def del_parse(node, out)
+        out.span **{ class: "deletion" } do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def error_parse(node, out)
-      text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
-      out.para do |p|
-        p.b(**{ role: "strong" }) { |e| e << text }
+      def error_parse(node, out)
+        text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+        out.para do |p|
+          p.b(**{ role: "strong" }) { |e| e << text }
+        end
       end
     end
   end

data/lib/isodoc/function/inline_simple.rb

@@ -1,80 +1,80 @@
-module IsoDoc::Function
-  module Inline
-    def section_break(body)
-      body.br
-    end
+module IsoDoc
+  module Function
+    module Inline
+      def section_break(body)
+        body.br
+      end
 
-    def page_break(out)
-      out.br
-    end
+      def page_break(out)
+        out.br
+      end
 
-    def pagebreak_parse(_node, out)
-      out.br
-    end
+      def pagebreak_parse(_node, out)
+        out.br
+      end
 
-    def hr_parse(node, out)
-      out.hr
-    end
+      def hr_parse(_node, out)
+        out.hr
+      end
 
-    def br_parse(node, out)
-      out.br
-    end
+      def br_parse(_node, out)
+        out.br
+      end
 
-    def index_parse(node, out)
-    end
+      def index_parse(node, out); end
 
-    def index_xref_parse(node, out)
-    end
+      def index_xref_parse(node, out); end
 
-    def bookmark_parse(node, out)
-      out.a **attr_code(id: node["id"])
-    end
+      def bookmark_parse(node, out)
+        out.a **attr_code(id: node["id"])
+      end
 
-    def keyword_parse(node, out)
-      out.span **{ class: "keyword" } do |s|
-        node.children.each { |n| parse(n, s) }
+      def keyword_parse(node, out)
+        out.span **{ class: "keyword" } do |s|
+          node.children.each { |n| parse(n, s) }
+        end
       end
-    end
 
-    def em_parse(node, out)
-      out.i do |e|
-        node.children.each { |n| parse(n, e) }
+      def em_parse(node, out)
+        out.i do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def strong_parse(node, out)
-      out.b do |e|
-        node.children.each { |n| parse(n, e) }
+      def strong_parse(node, out)
+        out.b do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def sup_parse(node, out)
-      out.sup do |e|
-        node.children.each { |n| parse(n, e) }
+      def sup_parse(node, out)
+        out.sup do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def sub_parse(node, out)
-      out.sub do |e|
-        node.children.each { |n| parse(n, e) }
+      def sub_parse(node, out)
+        out.sub do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def tt_parse(node, out)
-      out.tt do |e|
-        node.children.each { |n| parse(n, e) }
+      def tt_parse(node, out)
+        out.tt do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def strike_parse(node, out)
-      out.s do |e|
-        node.children.each { |n| parse(n, e) }
+      def strike_parse(node, out)
+        out.s do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def underline_parse(node, out)
-      out.u do |e|
-        node.children.each { |n| parse(n, e) }
+      def underline_parse(node, out)
+        out.u do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
     end
   end

data/lib/isodoc/function/lists.rb

@@ -1,95 +1,99 @@
-module IsoDoc::Function
-  module Lists
-    def ul_attrs(node)
-      { id: node["id"], style: keep_style(node) }
-    end
+module IsoDoc
+  module Function
+    module Lists
+      def ul_attrs(node)
+        { id: node["id"], style: keep_style(node) }
+      end
 
-    def ul_parse(node, out)
-      out.ul **attr_code(ul_attrs(node)) do |ul|
-        node.children.each { |n| parse(n, ul) }
+      def ul_parse(node, out)
+        out.ul **attr_code(ul_attrs(node)) do |ul|
+          node.children.each { |n| parse(n, ul) }
+        end
       end
-    end
 
-    OL_STYLE = {
-      arabic: "1",
-      roman: "i",
-      alphabet: "a",
-      roman_upper: "I",
-      alphabet_upper: "A",
-    }.freeze
+      OL_STYLE = {
+        arabic: "1",
+        roman: "i",
+        alphabet: "a",
+        roman_upper: "I",
+        alphabet_upper: "A",
+      }.freeze
 
-    def ol_style(type)
-      type = :alphabet unless type
-      OL_STYLE[type.to_sym]
-    end
+      def ol_style(type)
+        type ||= :alphabet
+        OL_STYLE[type.to_sym]
+      end
 
-    # We don't really want users to specify type of ordered list;
-    # we will use a fixed hierarchy as practiced by ISO (though not
-    # fully spelled out): a) 1) i) A) I)
+      # We don't really want users to specify type of ordered list;
+      # we will use a fixed hierarchy as practiced by ISO (though not
+      # fully spelled out): a) 1) i) A) I)
 
-    def ol_depth(node)
-      depth = node.ancestors("ul, ol").size + 1
-      type = :alphabet
-      type = :arabic if [2, 7].include? depth
-      type = :roman if [3, 8].include? depth
-      type = :alphabet_upper if [4, 9].include? depth
-      type = :roman_upper if [5, 10].include? depth
-      ol_style(type)
-    end
+      def ol_depth(node)
+        depth = node.ancestors("ul, ol").size + 1
+        type = :alphabet
+        type = :arabic if [2, 7].include? depth
+        type = :roman if [3, 8].include? depth
+        type = :alphabet_upper if [4, 9].include? depth
+        type = :roman_upper if [5, 10].include? depth
+        ol_style(type)
+      end
 
-    def ol_attrs(node)
-      { type: node["type"] ? ol_style(node["type"].to_sym) : ol_depth(node),
-        id: node["id"], style: keep_style(node) }
-    end
+      def ol_attrs(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)
-      out.ol **attr_code(ol_attrs(node)) do |ol|
-        node.children.each { |n| parse(n, ol) }
+      def ol_parse(node, out)
+        out.ol **attr_code(ol_attrs(node)) do |ol|
+          node.children.each { |n| parse(n, ol) }
+        end
       end
-    end
 
-    def li_parse(node, out)
-      out.li  **attr_code(id: node["id"]) do |li|
-        if node["uncheckedcheckbox"] == "true"
-          li << '<span class="zzMoveToFollowing"><input type="checkbox" checked="checked"/></span>'
-        elsif node["checkedcheckbox"] == "true"
-          li << '<span class="zzMoveToFollowing"><input type="checkbox"/></span>'
+      def li_parse(node, out)
+        out.li **attr_code(id: node["id"]) do |li|
+          if node["uncheckedcheckbox"] == "true"
+            li << '<span class="zzMoveToFollowing">'\
+                  '<input type="checkbox" checked="checked"/></span>'
+          elsif node["checkedcheckbox"] == "true"
+            li << '<span class="zzMoveToFollowing">'\
+                  '<input type="checkbox"/></span>'
+          end
+          node.children.each { |n| parse(n, li) }
         end
-        node.children.each { |n| parse(n, li) }
       end
-    end
 
-    def dt_parse(dt, term)
-      if dt.elements.empty?
-        #term.p **attr_code(class: note? ? "Note" : nil) do |p|
-        term.p do |p|
-          p << dt.text
+      def dt_parse(dterm, term)
+        if dterm.elements.empty?
+          # term.p **attr_code(class: note? ? "Note" : nil) do |p|
+          term.p do |p|
+            p << dterm.text
+          end
+        else
+          dterm.children.each { |n| parse(n, term) }
         end
-      else
-        dt.children.each { |n| parse(n, term) }
       end
-    end
 
-    def dt_dd?(n)
-      %w{dt dd}.include? n.name
-    end
+      def dt_dd?(node)
+        %w{dt dd}.include? node.name
+      end
 
-    def dl_attrs(node)
-      attr_code(id: node["id"], style: keep_style(node))
-    end
+      def dl_attrs(node)
+        attr_code(id: node["id"], style: keep_style(node))
+      end
 
-    def dl_parse(node, out)
-      out.dl  **dl_attrs(node) do |v|
-        node.elements.select { |n| dt_dd? n }.each_slice(2) do |dt, dd|
-          v.dt **attr_code(id: dt["id"]) do |term|
-            dt_parse(dt, term) 
-          end
-          v.dd  **attr_code(id: dd["id"]) do |listitem|
-            dd.children.each { |n| parse(n, listitem) }
+      def dl_parse(node, out)
+        out.dl **dl_attrs(node) do |v|
+          node.elements.select { |n| dt_dd? n }.each_slice(2) do |dt, dd|
+            v.dt **attr_code(id: dt["id"]) do |term|
+              dt_parse(dt, term)
+            end
+            v.dd **attr_code(id: dd["id"]) do |listitem|
+              dd.children.each { |n| parse(n, listitem) }
+            end
           end
         end
+        node.elements.reject { |n| dt_dd? n }.each { |n| parse(n, out) }
       end
-      node.elements.reject { |n| dt_dd? n }.each { |n| parse(n, out) }
     end
   end
 end