reverse_adoc 0.2.3

data/lib/reverse_asciidoctor/converters/math.rb

@@ -0,0 +1,20 @@
+# Unless run with ReverseAsciidoctor.config.mathml2asciimath,
+# this is cheating: we're injecting MathML into Asciidoctor, but
+# Asciidoctor only understands AsciiMath or LaTeX
+
+require "mathml2asciimath"
+
+module ReverseAsciidoctor
+  module Converters
+    class Math < Base
+      def convert(node, state = {})
+        stem = node.to_s.gsub(/\n/, " ")
+        stem = MathML2AsciiMath.m2a(stem) if ReverseAsciidoctor.config.mathml2asciimath
+        stem = stem.gsub(/\[/, "\\[").gsub(/\]/, "\\]").gsub(/\(\(([^\)]+)\)\)/, "(\\1)") unless stem.nil?
+        " stem:[" << stem << "] "
+      end
+    end
+
+    register :math, Math.new
+  end
+end

data/lib/reverse_asciidoctor/converters/ol.rb

@@ -0,0 +1,46 @@
+module ReverseAsciidoctor
+  module Converters
+    class Ol < Base
+      def convert(node, state = {})
+        id = node['id']
+        anchor = id ? "[[#{id}]]\n" : ""
+        ol_count = state.fetch(:ol_count, 0) + 1
+        attrs = ol_attrs(node)
+        "\n#{anchor}#{attrs}" << treat_children(node, state.merge(ol_count: ol_count))
+      end
+
+      def number_style(node)
+        style = case node["style"]
+                when "1" then "arabic"
+                when "A" then "upperalpha"
+                when "a" then "loweralpha"
+                when "I" then "upperroman"
+                when "i" then "lowerroman"
+                else
+                  nil
+                end
+      end
+
+      def ol_attrs(node)
+        style = number_style(node)
+        reversed = "%reversed" if node["reversed"]
+        start = "start=#{node['start']}" if node["start"]
+        type = "type=#{node['type']}" if node["type"]
+        attrs = []
+        attrs << style if style
+        attrs << reversed if reversed
+        attrs << start if start
+        attrs << type if type
+        if attrs.empty?
+          ""
+        else
+          "[#{attrs.join(',')}]\n"
+        end
+      end
+    end
+
+    register :ol, Ol.new
+    register :ul, Ol.new
+    register :dir, Ol.new
+  end
+end

data/lib/reverse_asciidoctor/converters/p.rb

@@ -0,0 +1,17 @@
+module ReverseAsciidoctor
+  module Converters
+    class P < Base
+      def convert(node, state = {})
+        id = node['id']
+        anchor = id ? "[[#{id}]]\n" : ""
+        if state[:tdsinglepara]
+          "#{anchor}" << treat_children(node, state).strip
+        else
+          "\n\n#{anchor}" << treat_children(node, state).strip << "\n\n"
+        end
+      end
+    end
+
+    register :p, P.new
+  end
+end

data/lib/reverse_asciidoctor/converters/pass_through.rb

@@ -0,0 +1,9 @@
+module ReverseAsciidoctor
+  module Converters
+    class PassThrough < Base
+      def convert(node, state = {})
+        node.to_s
+      end
+    end
+  end
+end

data/lib/reverse_asciidoctor/converters/pre.rb

@@ -0,0 +1,38 @@
+module ReverseAsciidoctor
+  module Converters
+    class Pre < Base
+      def convert(node, state = {})
+        id = node['id']
+        anchor = id ? "[[#{id}]]\n" : ""
+        lang = language(node)
+        content = treat_children(node, state)
+        if lang
+          "\n\n#{anchor}[source,#{lang}]\n----\n" << content.lines.to_a.join("") << "\n----\n\n"
+        else
+          "\n\n#{anchor}....\n" << content.lines.to_a.join("") << "\n....\n\n"
+        end
+      end
+
+      private
+
+      def treat(node, state)
+        node.to_s
+      end
+
+      def language(node)
+        lang = language_from_highlight_class(node)
+        lang || language_from_confluence_class(node)
+      end
+
+      def language_from_highlight_class(node)
+        node.parent['class'].to_s[/highlight-([a-zA-Z0-9]+)/, 1]
+      end
+
+      def language_from_confluence_class(node)
+        node['class'].to_s[/brush:\s?(:?.*);/, 1]
+      end
+    end
+
+    register :pre, Pre.new
+  end
+end

data/lib/reverse_asciidoctor/converters/q.rb

@@ -0,0 +1,12 @@
+module ReverseAsciidoctor
+  module Converters
+    class Q < Base
+      def convert(node, state = {})
+        content = treat_children(node, state)
+        "#{content[/^\s*/]}\"#{content.strip}\"#{content[/\s*$/]}"
+      end
+    end
+
+    register :q, Q.new
+  end
+end

data/lib/reverse_asciidoctor/converters/strong.rb

@@ -0,0 +1,17 @@
+module ReverseAsciidoctor
+  module Converters
+    class Strong < Base
+      def convert(node, state = {})
+        content = treat_children(node, state.merge(already_strong: true))
+        if content.strip.empty? || state[:already_strong]
+          content
+        else
+          "#{content[/^\s*/]}*#{content.strip}*#{content[/\s*$/]}"
+        end
+      end
+    end
+
+    register :strong, Strong.new
+    register :b,      Strong.new
+  end
+end

data/lib/reverse_asciidoctor/converters/sub.rb

@@ -0,0 +1,12 @@
+module ReverseAsciidoctor
+  module Converters
+    class Sub < Base
+      def convert(node, state = {})
+        content = treat_children(node, state)
+        "#{content[/^\s*/]}~#{content.strip}~#{content[/\s*$/]}"
+      end
+    end
+
+    register :sub, Sub.new
+  end
+end

data/lib/reverse_asciidoctor/converters/sup.rb

@@ -0,0 +1,12 @@
+module ReverseAsciidoctor
+  module Converters
+    class Sup < Base
+      def convert(node, state = {})
+        content = treat_children(node, state)
+        "#{content[/^\s*/]}^#{content.strip}^#{content[/\s*$/]}"
+      end
+    end
+
+    register :sup, Sup.new
+  end
+end

data/lib/reverse_asciidoctor/converters/table.rb

@@ -0,0 +1,64 @@
+module ReverseAsciidoctor
+  module Converters
+    class Table < Base
+      def convert(node, state = {})
+        id = node['id']
+        anchor = id ? "[[#{id}]]\n" : ""
+        title = extract_title(node)
+        title = ".#{title}\n" unless title.empty?
+        attrs = style(node)
+        "\n\n#{anchor}#{attrs}#{title}|===\n" << treat_children(node, state) << "\n|===\n"
+      end
+
+      def extract_title(node)
+        title = node.at("./caption")
+        return "" if title.nil?
+        treat_children(title, {})
+      end
+
+      def frame(node)
+        case node["frame"]
+        when "void"
+          "frame=none"
+        when "hsides"
+          "frame=topbot"
+        when "vsides"
+          "frame=sides"
+        when "box", "border"
+          "frame=all"
+        else
+          nil
+        end
+      end
+
+      def rules(node)
+        case node["rules"]
+        when "all"
+          "rules=all"
+        when "rows"
+          "rules=rows"
+        when "cols"
+          "rules=cols"
+        when "none"
+          "rules=none"
+        else
+          nil
+        end
+      end
+
+      def style(node)
+        width = "width=#{node['width']}" if node['width']
+        attrs = []
+        frame_attr = frame(node)
+        rules_attr = rules(node)
+        attrs << width if width
+        attrs << frame_attr if frame_attr
+        attrs << rules_attr if rules_attr
+        return "" if attrs.empty?
+        "[#{attrs.join(',')}]\n"
+      end
+    end
+
+    register :table, Table.new
+  end
+end

data/lib/reverse_asciidoctor/converters/td.rb

@@ -0,0 +1,67 @@
+module ReverseAsciidoctor
+  module Converters
+    class Td < Base
+      def convert(node, state = {})
+        id = node['id']
+        anchor = id ? "[[#{id}]]" : ""
+        colrowattr = colrow(node['colspan'], node['rowspan'])
+        alignattr = alignstyle(node)
+        style = cellstyle(node)
+        singlepara = node.elements.size == 1 && node.elements.first.name == "p"
+        state[:tdsinglepara] = singlepara if singlepara
+        adoccell = node.at(".//ul | .//ol | .//pre | .//blockquote | .//br | .//hr") ||
+          node.at(".//p") && !singlepara
+        style = "a" if adoccell
+        delim = adoccell ? "\n" : " "
+        content = treat_children(node, state)
+        "#{colrowattr}#{alignattr}#{style}| #{anchor}#{content}#{delim}"
+      end
+
+      def cellstyle(node)
+        ""
+      end
+
+      def colrow(colspan, rowspan)
+        if colspan && rowspan
+          "#{colspan}.#{rowspan}+"
+        elsif colspan
+          "#{colspan}+"
+        elsif rowspan
+          ".#{rowspan}+"
+        else
+          ""
+        end
+      end
+
+      def alignstyle(node)
+        align = node["align"]
+        valign = node["valign"]
+        a = case align
+              when "left" then "<"
+              when "center" then "^"
+              when "right" then ">"
+            else
+              ""
+            end
+        v = case valign
+              when "top" then "<"
+              when "middle" then "^"
+              when "bottom" then ">"
+            else
+              ""
+            end
+        if align && valign
+          "#{a}.#{v}"
+        elsif align
+          a
+        elsif valign
+          ".#{v}"
+        else
+          ""
+        end
+      end
+    end
+
+    register :td, Td.new
+  end
+end

data/lib/reverse_asciidoctor/converters/text.rb

@@ -0,0 +1,65 @@
+module ReverseAsciidoctor
+  module Converters
+    class Text < Base
+      def convert(node, state = {})
+        if node.text.strip.empty?
+          treat_empty(node, state)
+        else
+          treat_text(node)
+        end
+      end
+
+      private
+
+      def treat_empty(node, state)
+        parent = node.parent.name.to_sym
+        if [:ol, :ul].include?(parent)  # Otherwise the identation is broken
+          ''
+        elsif state[:tdsinglepara]
+          ''
+        elsif node.text == ' '          # Regular whitespace text node
+          ' '
+        else
+          ''
+        end
+      end
+
+      def treat_text(node)
+        text = node.text
+        text = preserve_nbsp(text)
+        text = remove_border_newlines(text)
+        text = remove_inner_newlines(text)
+        text = escape_keychars(text)
+
+        text = preserve_keychars_within_backticks(text)
+        text = preserve_tags(text)
+
+        text
+      end
+
+      def preserve_nbsp(text)
+        text.gsub(/\u00A0/, "&nbsp;")
+      end
+
+      def preserve_tags(text)
+        text.gsub(/[<>]/, '>' => '\>', '<' => '\<')
+      end
+
+      def remove_border_newlines(text)
+        text.gsub(/\A\n+/, '').gsub(/\n+\z/, '')
+      end
+
+      def remove_inner_newlines(text)
+        text.tr("\n\t", ' ').squeeze(' ')
+      end
+
+      def preserve_keychars_within_backticks(text)
+        text.gsub(/`.*?`/) do |match|
+          match.gsub('\_', '_').gsub('\*', '*')
+        end
+      end
+    end
+
+    register :text, Text.new
+  end
+end

data/lib/reverse_asciidoctor/converters/th.rb

@@ -0,0 +1,16 @@
+module ReverseAsciidoctor
+  module Converters
+    class Th < Td
+      def cellstyle(node)
+        if node.parent.previous_element.nil?
+          # this is the header row
+          ""
+        else
+          "h"
+        end
+      end
+    end
+
+    register :th, Th.new
+  end
+end

data/lib/reverse_asciidoctor/converters/tr.rb

@@ -0,0 +1,22 @@
+module ReverseAsciidoctor
+  module Converters
+    class Tr < Base
+      def convert(node, state = {})
+        content = treat_children(node, state).rstrip
+        result  = "#{content}\n"
+        table_header_row?(node) ? result + underline_for(node) : result
+      end
+
+      def table_header_row?(node)
+        # node.element_children.all? {|child| child.name.to_sym == :th}
+        node.previous_element.nil?
+      end
+
+      def underline_for(node)
+        "\n"
+      end
+    end
+
+    register :tr, Tr.new
+  end
+end

data/lib/reverse_asciidoctor/converters/video.rb

@@ -0,0 +1,36 @@
+module ReverseAsciidoctor
+  module Converters
+    class Video < Base
+      def convert(node, state = {})
+        autoplay   = node['autoplay']
+        loop_attr   = node['loop']
+        controls   = node['controls']
+        src   = node['src']
+        id = node['id']
+        anchor = id ? "[[#{id}]]\n" : ""
+        title = extract_title(node)
+        title = ".#{title}\n" unless title.empty?
+        [anchor, title, "video::", src, "[", options(node), "]"].join("")
+      end
+
+      def options(node)
+        autoplay   = node['autoplay']
+        loop_attr   = node['loop']
+        controls   = node['controls']
+        width   = node['width']
+        ret = ""
+        if autoplay || loop_attr || controls
+          out = []
+          out << "autoplay" if autoplay
+          out << "loop" if loop_attr
+          out << "controls" if controls
+          out << "width=#{width}" if width
+          ret = %{options="#{out.join(',')}"}
+        end
+        ret
+      end
+    end
+
+    register :video, Video.new
+  end
+end