reverse_adoc 0.3.7 → 1.0.1

data/lib/reverse_adoc/converters/bypass.rb

@@ -1,8 +1,12 @@
 module ReverseAdoc
   module Converters
     class Bypass < Base
+      def to_coradoc(node, state = {})
+        treat_children_coradoc(node, state)
+      end
+
       def convert(node, state = {})
-        treat_children(node, state)
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 
@@ -13,65 +17,65 @@ module ReverseAdoc
     register :thead,    Bypass.new
     register :tbody,    Bypass.new
     register :tfoot,    Bypass.new
-    register :abbr,    Bypass.new
+    register :abbr, Bypass.new
     register :acronym,    Bypass.new
     register :address,    Bypass.new
-    register :applet,    Bypass.new
-    register :map,    Bypass.new
-    register :area,    Bypass.new
+    register :applet, Bypass.new
+    register :map, Bypass.new
+    register :area, Bypass.new
     register :bdi,    Bypass.new
     register :bdo,    Bypass.new
     register :big,    Bypass.new
     register :button,    Bypass.new
     register :canvas,    Bypass.new
-    register :data,    Bypass.new
-    register :datalist,    Bypass.new
+    register :data, Bypass.new
+    register :datalist, Bypass.new
     register :del,    Bypass.new
     register :ins,    Bypass.new
     register :dfn,    Bypass.new
-    register :dialog,    Bypass.new
-    register :embed,    Bypass.new
-    register :fieldset,    Bypass.new
-    register :font,    Bypass.new
-    register :footer,    Bypass.new
-    register :form,    Bypass.new
-    register :frame,    Bypass.new
-    register :frameset,    Bypass.new
+    register :dialog, Bypass.new
+    register :embed, Bypass.new
+    register :fieldset, Bypass.new
+    register :font, Bypass.new
+    register :footer, Bypass.new
+    register :form, Bypass.new
+    register :frame, Bypass.new
+    register :frameset, Bypass.new
     register :header,    Bypass.new
     register :iframe,    Bypass.new
     register :input,    Bypass.new
     register :label,    Bypass.new
-    register :legend,    Bypass.new
+    register :legend, Bypass.new
     register :main,    Bypass.new
     register :menu,    Bypass.new
-    register :menulist,    Bypass.new
-    register :meter,    Bypass.new
-    register :nav,    Bypass.new
+    register :menulist, Bypass.new
+    register :meter, Bypass.new
+    register :nav, Bypass.new
     register :noframes,    Bypass.new
     register :noscript,    Bypass.new
-    register :object,    Bypass.new
-    register :optgroup,    Bypass.new
+    register :object, Bypass.new
+    register :optgroup, Bypass.new
     register :option,    Bypass.new
     register :output,    Bypass.new
-    register :param,    Bypass.new
-    register :picture,    Bypass.new
-    register :progress,    Bypass.new
-    register :ruby,    Bypass.new
+    register :param, Bypass.new
+    register :picture, Bypass.new
+    register :progress, Bypass.new
+    register :ruby, Bypass.new
     register :rt,    Bypass.new
     register :rp,    Bypass.new
-    register :s,    Bypass.new
-    register :select,    Bypass.new
-    register :small,    Bypass.new
-    register :span,    Bypass.new
-    register :strike,    Bypass.new
+    register :s, Bypass.new
+    register :select, Bypass.new
+    register :small, Bypass.new
+    register :span, Bypass.new
+    register :strike, Bypass.new
     register :details,    Bypass.new
     register :section,    Bypass.new
     register :summary,    Bypass.new
-    register :svg,    Bypass.new
+    register :svg, Bypass.new
     register :template,    Bypass.new
     register :textarea,    Bypass.new
-    register :track,    Bypass.new
-    register :u,    Bypass.new
-    register :wbr,    Bypass.new
+    register :track, Bypass.new
+    register :u, Bypass.new
+    register :wbr, Bypass.new
   end
 end

data/lib/reverse_adoc/converters/code.rb

@@ -1,8 +1,49 @@
 module ReverseAdoc
   module Converters
     class Code < Base
+      def to_coradoc(node, state = {})
+        content = treat_children_coradoc(node, state)
+
+        if Coradoc::Generator.gen_adoc(content).strip.empty?
+          return ""
+        end
+
+        if node_has_ancestor?(node, ["code", "tt", "kbd", "samp", "var"])
+          return content
+        end
+
+        node.text =~ /^(\s+)/
+        leading_whitespace = $1
+        has_leading_whitespace = !leading_whitespace.nil?
+
+        if has_leading_whitespace
+          first_text = node.at_xpath("./text()[1]")
+          first_text.replace(first_text.text.lstrip)
+          leading_whitespace = " "
+        end
+
+        node.text =~ /(\s+)$/
+        trailing_whitespace = $1
+        has_trailing_whitespace = !trailing_whitespace.nil?
+
+        if has_trailing_whitespace
+          last_text = node.at_xpath("./text()[last()]")
+          last_text.replace(last_text.text.rstrip)
+          trailing_whitespace = " "
+        end
+
+        u_before = unconstrained_before?(node)
+        u_after = unconstrained_after?(node)
+        u = !((!u_before || has_leading_whitespace) && (!u_after || has_trailing_whitespace))
+        e = Coradoc::Element::Inline::Monospace.new(
+          Coradoc::Element::TextElement.new(content), u
+        )
+
+        [leading_whitespace, e, trailing_whitespace]
+      end
+
       def convert(node, state = {})
-        "`#{node.text}`"
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/div.rb

@@ -1,10 +1,14 @@
 module ReverseAdoc
   module Converters
     class Div < Base
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        contents = treat_children_coradoc(node, state)
+        Coradoc::Element::Section.new(nil, id: id, contents: contents)
+      end
+
       def convert(node, state = {})
-        id = node['id']
-        anchor = id ? "[[#{id}]]\n" : ""
-        "\n#{anchor}" << treat_children(node, state) << "\n"
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/drop.rb

@@ -1,8 +1,12 @@
 module ReverseAdoc
   module Converters
     class Drop < Base
-      def convert(node, state = {})
-        ''
+      def to_coradoc(node, state = {})
+        convert(node, state)
+      end
+
+      def convert(_node, _state = {})
+        ""
       end
     end
 

data/lib/reverse_adoc/converters/em.rb

@@ -1,18 +1,55 @@
 module ReverseAdoc
   module Converters
     class Em < Base
-      def convert(node, state = {})
-        content = treat_children(node, state.merge(already_italic: true))
-        if content.strip.empty? || state[:already_italic]
-          content
-        else
-          "#{content[/^\s*/]}_#{content.strip}_#{content[/\s*$/]}"
+      def to_coradoc(node, state = {})
+        content = treat_children_coradoc(node,
+                                         state.merge(already_italic: true))
+
+        if Coradoc::Generator.gen_adoc(content).strip.empty?
+          return ""
+        end
+
+        if node_has_ancestor?(node, ["em", "i", "cite"])
+          return content
         end
+
+        node.text =~ /^(\s+)/
+        leading_whitespace = $1
+        has_leading_whitespace = !leading_whitespace.nil?
+
+        if has_leading_whitespace
+          first_text = node.at_xpath("./text()[1]")
+          first_text.replace(first_text.text.lstrip)
+          leading_whitespace = " "
+        end
+
+        node.text =~ /(\s+)$/
+        trailing_whitespace = $1
+        has_trailing_whitespace = !trailing_whitespace.nil?
+
+        if has_trailing_whitespace
+          last_text = node.at_xpath("./text()[last()]")
+          last_text.replace(last_text.text.rstrip)
+          trailing_whitespace = " "
+        end
+
+        u_before = unconstrained_before?(node)
+        u_after = unconstrained_after?(node)
+        u = !((!u_before || has_leading_whitespace) && (!u_after || has_trailing_whitespace))
+        e = Coradoc::Element::Inline::Italic.new(
+          Coradoc::Element::TextElement.new(content), u
+        )
+
+        [leading_whitespace, e, trailing_whitespace]
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 
     register :em, Em.new
     register :i,  Em.new
-    register :cite,  Em.new
+    register :cite, Em.new
   end
 end

data/lib/reverse_adoc/converters/figure.rb

@@ -1,18 +1,22 @@
 module ReverseAdoc
   module Converters
     class Figure < Base
-      def convert(node, state = {})
-        id = node['id']
-        anchor = id ? "[[#{id}]]\n" : ""
+      def to_coradoc(node, state = {})
+        id = node["id"]
         title = extract_title(node)
-        title = ".#{title}\n" unless title.empty?
-        "\n\n#{anchor}#{title}====\n" << treat_children(node, state).strip << "\n====\n\n"
+        content = treat_children_coradoc(node, state)
+        Coradoc::Element::Block::Example.new(title, lines: content, id: id)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
 
       def extract_title(node)
         title = node.at("./figcaption")
         return "" if title.nil?
-        treat_children(title, {})
+
+        treat_children_coradoc(title, {})
       end
     end
 

data/lib/reverse_adoc/converters/h.rb

@@ -1,25 +1,33 @@
 module ReverseAdoc
   module Converters
     class H < Base
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        internal_anchor = treat_children_anchors(node, state)
+
+        if id.to_s.empty? && internal_anchor.size.positive?
+          id = internal_anchor.first.id
+        end
+
+        level = node.name[/\d/].to_i
+        content = treat_children_no_anchors(node, state)
+
+        Coradoc::Element::Title.new(content, level, id: id)
+      end
+
       def convert(node, state = {})
-        id = node['id']
-        anchor = id ? "[[#{id}]]" : ""
-        internal_anchor = treat_children_anchors(node, state) || ""
-        anchor.empty? and anchor = internal_anchor
-        anchor.empty? or anchor += "\n"
-        prefix = '=' * (node.name[/\d/].to_i + 1)
-        ["\n", anchor, prefix, ' ', treat_children_no_anchors(node, state), "\n"].join
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
 
       def treat_children_no_anchors(node, state)
-        node.children.reject { |a| a.name == "a" }.inject('') do |memo, child|
-          memo << treat(child, state)
+        node.children.reject { |a| a.name == "a" }.inject([]) do |memo, child|
+          memo << treat_coradoc(child, state)
         end
       end
 
       def treat_children_anchors(node, state)
-        node.children.select { |a| a.name == "a" }.inject('') do |memo, child|
-          memo << treat(child, state)
+        node.children.select { |a| a.name == "a" }.inject([]) do |memo, child|
+          memo << treat_coradoc(child, state)
         end
       end
     end

data/lib/reverse_adoc/converters/head.rb

@@ -1,14 +1,19 @@
 module ReverseAdoc
   module Converters
     class Head < Base
-      def convert(node, state = {})
+      def to_coradoc(node, _state = {})
         title = extract_title(node)
-        "= #{title}\n:stem:\n\n"
+        Coradoc::Element::Header.new(title)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
 
       def extract_title(node)
         title = node.at("./title")
         return "(???)" if title.nil?
+
         title.text
       end
     end

data/lib/reverse_adoc/converters/hr.rb

@@ -1,8 +1,12 @@
 module ReverseAdoc
   module Converters
     class Hr < Base
+      def to_coradoc(_node, _state = {})
+        Coradoc::Element::Break::ThematicBreak.new
+      end
+
       def convert(node, state = {})
-        "\n* * *\n"
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/ignore.rb

@@ -1,8 +1,12 @@
 module ReverseAdoc
   module Converters
     class Ignore < Base
-      def convert(node, state = {})
-        '' # noop
+      def to_coradoc(node, state = {})
+        convert(node, state)
+      end
+
+      def convert(_node, _state = {})
+        "" # noop
       end
     end
 

data/lib/reverse_adoc/converters/img.rb

@@ -7,11 +7,10 @@ require "marcel"
 module ReverseAdoc
   module Converters
     class Img < Base
-
       def image_number
         sprintf(
           ReverseAdoc.config.image_counter_pattern,
-          ReverseAdoc.config.image_counter
+          ReverseAdoc.config.image_counter,
         )
       end
 
@@ -20,10 +19,10 @@ module ReverseAdoc
       end
 
       def datauri2file(src)
-        %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ src
+        %r{^data:image/(?:[^;]+);base64,(?<imgdata>.+)$} =~ src
 
         dest_dir = Pathname.new(ReverseAdoc.config.destination).dirname
-        images_dir = dest_dir + 'images'
+        images_dir = dest_dir.join("images")
         FileUtils.mkdir_p(images_dir)
 
         ext, image_src_path = determine_image_src_path(src, imgdata)
@@ -42,11 +41,11 @@ module ReverseAdoc
         return copy_temp_file(imgdata) if imgdata
 
         ext = File.extname(src).strip.downcase[1..-1]
-        [ext, Pathname.new(ReverseAdoc.config.sourcedir) + src]
+        [ext, Pathname.new(ReverseAdoc.config.sourcedir).join(src)]
       end
 
       def copy_temp_file(imgdata)
-        Tempfile.open(['radoc', '.jpg']) do |f|
+        Tempfile.open(["radoc", ".jpg"]) do |f|
           f.binmode
           f.write(Base64.strict_decode64(imgdata))
           f.rewind
@@ -55,13 +54,13 @@ module ReverseAdoc
         end
       end
 
-      def convert(node, state = {})
-        alt   = node['alt']
-        src   = node['src']
-        id = node['id']
-        width = node['width']
-        height = node['height']
-        anchor = id ? "[[#{id}]]\n" : ""
+      def to_coradoc(node, _state = {})
+        id = node["id"]
+        alt   = node["alt"]
+        src   = node["src"]
+        width = node["width"]
+        height = node["height"]
+
         title = extract_title(node)
 
         if ReverseAdoc.config.external_images
@@ -69,12 +68,23 @@ module ReverseAdoc
           src = datauri2file(src)
         end
 
-        title = ".#{title}\n" unless title.empty?
-        attrs = alt
-        attrs = "\"\"" if (width || height) && alt.nil?
-        attrs += ",#{width}" if width
-        attrs += ",#{height}" if width && height
-        [anchor, title, "image::", src, "[", attrs, "]"].join("")
+        attributes = Coradoc::Element::AttributeList.new
+        # attributes.add_named("id", id) if id
+        if alt # && !alt.to_s.empty?
+          attributes.add_positional(alt)
+        elsif width || height
+          attributes.add_positional("\"\"")
+        end
+        # attributes.add_named("title", title) if title
+        attributes.add_positional(width) if width
+        attributes.add_positional(height) if height
+
+        Coradoc::Element::Image::BlockImage.new(title, id, src,
+                                                attributes: attributes)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/li.rb

@@ -1,21 +1,14 @@
 module ReverseAdoc
   module Converters
     class Li < Base
-      def convert(node, state = {})
-        id = node['id']
-        anchor = id ? "[[#{id}]]" : ""
-        content     = treat_children(node, state)
-        prefix      = prefix_for(node, state)
-        "#{prefix} #{anchor}#{content.chomp}\n"
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        content = treat_children_coradoc(node, state)
+        Coradoc::Element::ListItem.new(content, id: id)
       end
 
-      def prefix_for(node, state)
-        length = state.fetch(:ol_count, 0)
-        if node.parent.name == 'ol'
-          "." * [length, 0].max
-        else
-          "*" * [length, 0].max
-        end
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/mark.rb

@@ -1,9 +1,18 @@
 module ReverseAdoc
   module Converters
     class Mark < Base
+      def to_coradoc(node, state = {})
+        content = treat_children(node, state.merge(already_strong: true))
+
+        if content.strip.empty? || state[:already_strong]
+          return content
+        end
+
+        Coradoc::Element::Inline::Highlight.new(content, constrained?(node))
+      end
+
       def convert(node, state = {})
-        content = treat_children(node, state)
-          "#{content[/^\s*/]}##{content.strip}##{content[/\s*$/]}"
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/math.rb

@@ -7,10 +7,21 @@ require "mathml2asciimath"
 module ReverseAdoc
   module Converters
     class Math < Base
-      def convert(node, state = {})
+      # FIXIT
+      def to_coradoc(node, state = {})
+        convert(node, state)
+      end
+
+      def convert(node, _state = {})
         stem = node.to_s.gsub(/\n/, " ")
         stem = MathML2AsciiMath.m2a(stem) if ReverseAdoc.config.mathml2asciimath
-        stem = stem.gsub(/\[/, "\\[").gsub(/\]/, "\\]").gsub(/\(\(([^\)]+)\)\)/, "(\\1)") unless stem.nil?
+        unless stem.nil?
+          stem = stem.gsub(/\[/, "\\[").gsub(/\]/, "\\]").gsub(
+            /\(\(([^\)]+)\)\)/, "(\\1)"
+          )
+        end
+
+        # TODO: This is to be done in Coradoc
         " stem:[" << stem << "] "
       end
     end

data/lib/reverse_adoc/converters/ol.rb

@@ -1,41 +1,59 @@
 module ReverseAdoc
   module Converters
     class Ol < Base
-      def convert(node, state = {})
-        id = node['id']
-        anchor = id ? "[[#{id}]]\n" : ""
+      # FIXIT
+      def to_coradoc(node, state = {})
+        # convert(node, state)
+        id = node["id"]
         ol_count = state.fetch(:ol_count, 0) + 1
         attrs = ol_attrs(node)
-        "\n#{anchor}#{attrs}" << treat_children(node, state.merge(ol_count: ol_count))
+        items = treat_children_coradoc(node, state.merge(ol_count: ol_count))
+
+        options = {}.tap do |hash|
+          hash[:id] = id
+          hash[:ol_count] = ol_count
+          hash[:attrs] = attrs
+        end
+
+        case get_list_type(node, state)
+        when :ordered
+          Coradoc::Element::List::Ordered.new(items, options)
+        when :unordered
+          Coradoc::Element::List::Unordered.new(items, options)
+        end
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      end
+
+      def get_list_type(node, _state)
+        case node.name
+        when "ol"
+          :ordered
+        when "ul"
+          :unordered
+        end
       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
+        case node["style"]
+        when "1" then "arabic"
+        when "A" then "upperalpha"
+        when "a" then "loweralpha"
+        when "I" then "upperroman"
+        when "i" then "lowerroman"
+        end
       end
 
       def ol_attrs(node)
+        attrs = Coradoc::Element::AttributeList.new
         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
+        attrs.add_positional(style) if style
+        attrs.add_positional("%reversed") if node["reversed"]
+        attrs.add_named("start", node["start"]) if node["start"]
+        attrs.add_named("type", node["type"]) if node["type"]
+        attrs
       end
     end
 

data/lib/reverse_adoc/converters/p.rb

@@ -1,14 +1,20 @@
 module ReverseAdoc
   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"
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        content = treat_children_coradoc(node, state)
+
+        options = {}.tap do |hash|
+          hash[:id] = id if id
+          hash[:tdsinglepara] = true if state[:tdsinglepara]
         end
+
+        Coradoc::Element::Paragraph.new(content, options)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end