isodoc 1.7.3.1 → 1.7.6.1

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