blocks.rb in asciidoctor-iso-0.6.1

- old
+ new

@@ -2,18 +2,33 @@
 require "uri"
 
 module Asciidoctor
   module ISO
     module Blocks
+
       def id_attr(node = nil)
         { id: Utils::anchor_or_uuid(node) }
       end
 
+      def open(node)
+        # open block is a container of multiple blocks,
+        # treated as a single block.
+        # We append each contained block to its parent
+        result = []
+        if node.blocks?
+          node.blocks.each do |b|
+            result << send(b.context, b)
+          end
+        else
+          result = paragraph(node)
+        end
+        result
+      end
+
       def stem(node)
         # NOTE: html escaping is performed by Nokogiri
         stem_content = node.lines.join("\n")
-
         noko do |xml|
           xml.formula **id_attr(node) do |s|
             s.stem stem_content, **{ type: "AsciiMath" }
             style(node, stem_content)
           end
@@ -25,42 +40,38 @@
         date += "T0000" unless /T/.match? date
         { 
           reviewer: node.attr("reviewer") || node.attr("source") || "(Unknown)",
           id: Utils::anchor_or_uuid(node),
           date: date.gsub(/[:-]/, ""),
+          from: node.attr("from"),
+          to: node.attr("to") || node.attr("from"),
         }
       end
 
       def sidebar(node)
         return unless is_draft
         content = Utils::flatten_rawtext(node.content).join("\n")
         noko do |xml| 
           xml.review **attr_code(sidebar_attrs(node)) do |r|
-            r << content
+            wrap_in_para(node, r)
           end
         end
       end
 
       def termnote(n)
         noko do |xml|
           xml.termnote **id_attr(n) do |ex|
-            if n.blocks? then ex << n.content
-            else 
-              ex.p {|p| p << n.content }
-            end
+            wrap_in_para(n, ex)
             style(n, Utils::flatten_rawtext(n.content).join("\n"))
           end
         end.join("\n")
       end
 
       def note(n)
         noko do |xml|
           xml.note **id_attr(n) do |c|
-            if n.blocks? then c << n.content
-            else
-              c.p { |p| p << n.content }
-            end
+            wrap_in_para(n, c)
             text = Utils::flatten_rawtext(n.content).join("\n")
             note_style(n, text)
           end
         end.join("\n")
       end
@@ -77,26 +88,20 @@
       def admonition(node)
         return termnote(node) if in_terms
         return note(node) if node.attr("name") == "note"
         noko do |xml|
           xml.admonition **admonition_attrs(node) do |a|
-            if node.blocks? then a << node.content
-            else
-              a.p { |p| p << node.content }
-            end
+            wrap_in_para(node, a)
           end
         end.join("\n")
       end
 
       def term_example(node)
         noko do |xml|
           xml.termexample **id_attr(node) do |ex|
             c = node.content
-            if node.blocks? then ex << c 
-            else 
-              ex.p {|p| p << c }
-            end
+            wrap_in_para(node, ex)
             text = Utils::flatten_rawtext(c).join("\n")
             termexample_style(node, text)
           end
         end.join("\n")
       end
@@ -105,19 +110,17 @@
         return term_example(node) if in_terms
         noko do |xml|
           xml.example **id_attr(node) do |ex|
             content = node.content
             ex << content
-            text = Utils::flatten_rawtext(content).join("\n")
-            termexample_style(node, text)
           end
         end.join("\n")
       end
 
       def preamble(node)
         noko do |xml|
-          xml.content do |xml_abstract|
+          xml.foreword do |xml_abstract|
             xml_abstract.title { |t| t << "Foreword" }
             content = node.content
             xml_abstract << content
             text = Utils::flatten_rawtext(content).join("\n")
             foreword_style(node, text)
@@ -142,46 +145,51 @@
             f.image **attr_code(image_attributes(node))
           end
         end
       end
 
+      def paragraph(node)
+        return termsource(node) if node.role == "source"
+        attrs = { align: node.attr("align"),
+                  id: Utils::anchor_or_uuid(node) }
+        noko do |xml|
+          xml.p **attr_code(attrs) do |xml_t|
+            xml_t << node.content
+            style(node, Utils::flatten_rawtext(node).join(" "))
+          end
+        end.join("\n")
+      end
+
       def quote_attrs(node)
-        { 
-          id: Utils::anchor_or_uuid(node), 
-          align: node.attr("align"),
-        }
+        { id: Utils::anchor_or_uuid(node), align: node.attr("align") }
       end
 
       def quote_attribution(node, out)
-        if node.attr("attribution")
-          out.fullname do |f|
-            f.surname { |s| s << node.attr("attribution") }
-            # TODO: will break up into name components
-          end
-        end
         if node.attr("citetitle")
-          # TODO: eref
+          m = /^(?<cite>[^,]+)(,(?<text>.*$))?$/.match node.attr("citetitle")
+          out.source m[:text], 
+            **attr_code(target: m[:cite], type: "inline")
         end
+        if node.attr("attribution")
+          out.author { |a| a << node.attr("attribution") }
+        end
       end
 
       def quote(node)
         noko do |xml|
           xml.quote **attr_code(quote_attrs(node)) do |q|
-            quote_attribution(node, out)
-            if node.blocks? then q << node.content
-            else
-              q.p { |p| p << node.content }
-            end
+            quote_attribution(node, q)
+            wrap_in_para(node, q)
           end
         end
       end
 
       def listing(node)
         # NOTE: html escaping is performed by Nokogiri
         noko do |xml|
           if node.parent.context != :example
-            xml.figure do |xml_figure|
-              xml_figure.sourcecode **id_attr(node) do |s| 
+            xml.example **id_attr(node) do |e|
+              e.sourcecode **id_attr(node) do |s| 
                 s << node.content 
               end
             end
           else
             xml.sourcecode **id_attr(node) do |s|