reverse_adoc 0.3.7 → 1.0.0

data/lib/reverse_adoc/converters/pass_through.rb

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

data/lib/reverse_adoc/converters/pre.rb

@@ -1,21 +1,34 @@
 module ReverseAdoc
   module Converters
     class Pre < Base
-      def convert(node, state = {})
-        id = node['id']
-        anchor = id ? "[[#{id}]]\n" : ""
+      def to_coradoc(node, state = {})
+        id = node["id"]
         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"
+
+        unless lang
+          return Coradoc::Element::Block::Literal.new(
+            nil,
+            lines: content,
+            id: id,
+          )
         end
+
+        Coradoc::Element::Block::SourceCode.new(
+          nil,
+          lines: content,
+          lang: lang,
+          id: id,
+        )
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
 
       private
 
-      def treat(node, state)
+      def treat(node, _state)
         return "\n" if node.name == "br"
 
         prefix = postfix = "\n\n" if node.name == "p"
@@ -29,11 +42,11 @@ module ReverseAdoc
       end
 
       def language_from_highlight_class(node)
-        node.parent['class'].to_s[/highlight-([a-zA-Z0-9]+)/, 1]
+        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]
+        node["class"].to_s[/brush:\s?(:?.*);/, 1]
       end
     end
 

data/lib/reverse_adoc/converters/q.rb

@@ -1,9 +1,13 @@
 module ReverseAdoc
   module Converters
     class Q < Base
-      def convert(node, state = {})
+      def to_coradoc(node, state = {})
         content = treat_children(node, state)
-        "#{content[/^\s*/]}\"#{content.strip}\"#{content[/\s*$/]}"
+        Coradoc::Element::Inline::Quotation.new(content)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/strong.rb

@@ -1,13 +1,48 @@
 module ReverseAdoc
   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*$/]}"
+      def to_coradoc(node, state = {})
+        content = treat_children_coradoc(node,
+                                         state.merge(already_strong: true))
+
+        if Coradoc::Generator.gen_adoc(content).strip.empty?
+          return ""
+        end
+
+        if node_has_ancestor?(node, ["strong", "b"])
+          return content
         end
+
+        u_before = unconstrained_before?(node)
+        u_after = unconstrained_after?(node)
+        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 = u_before ? " " : " " # ########################33   somethings wrong in here
+        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 = u_after ? "" : "" ###############################
+        end
+
+        u = !((!u_before || has_leading_whitespace) && (!u_after || has_trailing_whitespace))
+        e = Coradoc::Element::Inline::Bold.new(content, u)
+
+        [leading_whitespace, e, trailing_whitespace]
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/sub.rb

@@ -1,9 +1,13 @@
 module ReverseAdoc
   module Converters
     class Sub < Base
+      def to_coradoc(node, state = {})
+        content = treat_children_coradoc(node, state)
+        Coradoc::Element::Inline::Subscript.new(content)
+      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/sup.rb

@@ -1,9 +1,13 @@
 module ReverseAdoc
   module Converters
     class Sup < Base
-      def convert(node, state = {})
+      def to_coradoc(node, state = {})
         content = treat_children(node, state)
-        "#{content[/^\s*/]}^#{content.strip}^#{content[/\s*$/]}"
+        Coradoc::Element::Inline::Superscript.new(content)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
     end
 

data/lib/reverse_adoc/converters/table.rb

@@ -1,61 +1,66 @@
 module ReverseAdoc
   module Converters
     class Table < 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?
         attrs = style(node)
-        "\n\n#{anchor}#{attrs}#{title}|===\n" << treat_children(node, state) << "\n|===\n"
+        content = treat_children_coradoc(node, state)
+        Coradoc::Element::Table.new(title, content, { id: id, attrs: attrs })
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       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"
+          "none"
         when "hsides"
-          "frame=topbot"
+          "topbot"
         when "vsides"
-          "frame=sides"
+          "sides"
         when "box", "border"
-          "frame=all"
-        else
-          nil
+          "all"
         end
       end
 
       def rules(node)
         case node["rules"]
         when "all"
-          "rules=all"
+          "all"
         when "rows"
-          "rules=rows"
+          "rows"
         when "cols"
-          "rules=cols"
+          "cols"
         when "none"
-          "rules=none"
-        else
-          nil
+          "none"
         end
       end
 
       def style(node)
-        width = "width=#{node['width']}" if node['width']
-        attrs = []
+        attrs = Coradoc::Element::AttributeList.new
+        # Width is disabled on tables for now. (From #88)
+        # attrs.add_named("width", node["width"]) if node["width"]
+
         frame_attr = frame(node)
+        attrs.add_named("frame", frame_attr) if frame_attr
+
         rules_attr = rules(node)
-        attrs << width if width
-        attrs << frame_attr if frame_attr
-        attrs << rules_attr if rules_attr
+        attrs.add_named("rules", rules_attr) if rules_attr
+
+        # This line should be removed.
         return "" if attrs.empty?
-        "[#{attrs.join(',')}]\n"
+
+        attrs
       end
     end
 

data/lib/reverse_adoc/converters/td.rb

@@ -1,32 +1,48 @@
 module ReverseAdoc
   module Converters
     class Td < Base
-      def convert(node, state = {})
-        id = node['id']
-        anchor = id ? "[[#{id}]]" : ""
-        colrowattr = colrow(node['colspan'], node['rowspan'])
+      def to_coradoc(node, state = {})
+        # convert(node, state)
+        id = node["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}"
+        content = treat_children_coradoc(node, state)
+        options = {}.tap do |hash|
+          hash[:id] = id
+          hash[:colrowattr] = colrowattr
+          hash[:alignattr] = alignattr
+          hash[:style] = style
+          hash[:content] = content
+          hash[:delim] = delim
+        end
+
+        Coradoc::Element::Table::Cell.new(options)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
 
-      def cellstyle(node)
+      def cellstyle(_node)
         ""
       end
 
       def colrow(colspan, rowspan)
-        if colspan && rowspan
+        if colspan && rowspan && colspan != "1" && rowspan != "1"
           "#{colspan}.#{rowspan}+"
-        elsif colspan
+        elsif colspan && colspan != "1"
           "#{colspan}+"
-        elsif rowspan
+        elsif rowspan && rowspan != "1"
           ".#{rowspan}+"
         else
           ""
@@ -37,16 +53,16 @@ module ReverseAdoc
         align = node["align"]
         valign = node["valign"]
         a = case align
-              when "left" then "<"
-              when "center" then "^"
-              when "right" then ">"
+            when "left" then "<"
+            when "center" then "^"
+            when "right" then ">"
             else
               ""
             end
         v = case valign
-              when "top" then "<"
-              when "middle" then "^"
-              when "bottom" then ">"
+            when "top" then "<"
+            when "middle" then "^"
+            when "bottom" then ">"
             else
               ""
             end

data/lib/reverse_adoc/converters/text.rb

@@ -1,26 +1,28 @@
 module ReverseAdoc
   module Converters
     class Text < Base
+      def to_coradoc(node, state = {})
+        return treat_empty(node, state) if node.text.strip.empty?
+
+        Coradoc::Element::TextElement.new(treat_text(node))
+      end
+
       def convert(node, state = {})
-        if node.text.strip.empty?
-          treat_empty(node, state)
-        else
-          treat_text(node)
-        end
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       end
 
       private
 
       def treat_empty(node, state)
         parent = node.parent.name.to_sym
-        if [:ol, :ul].include?(parent)  # Otherwise the identation is broken
-          ''
+        if %i[ol ul].include?(parent) # Otherwise the identation is broken
+          ""
         elsif state[:tdsinglepara]
-          ''
-        elsif node.text == ' '          # Regular whitespace text node
-          ' '
+          ""
+        elsif node.text == " " # Regular whitespace text node
+          " "
         else
-          ''
+          ""
         end
       end
 
@@ -44,16 +46,16 @@ module ReverseAdoc
       end
 
       def remove_border_newlines(text)
-        text.gsub(/\A\n+/, '').gsub(/\n+\z/, '')
+        text.gsub(/\A\n+/, "").gsub(/\n+\z/, "")
       end
 
       def remove_inner_newlines(text)
-        text.tr("\n\t", ' ').squeeze(' ')
+        text.tr("\n\t", " ").squeeze(" ")
       end
 
       def preserve_keychars_within_backticks(text)
         text.gsub(/`.*?`/) do |match|
-          match.gsub('\_', '_').gsub('\*', '*')
+          match.gsub('\_', "_").gsub('\*', "*")
         end
       end
     end

data/lib/reverse_adoc/converters/th.rb

@@ -2,12 +2,10 @@ module ReverseAdoc
   module Converters
     class Th < Td
       def cellstyle(node)
-        if node.parent.previous_element.nil?
-          # this is the header row
-          ""
-        else
-          "h"
-        end
+        # this is the header row
+        return "" if node.parent.previous_element.nil?
+
+        "h"
       end
     end
 

data/lib/reverse_adoc/converters/tr.rb

@@ -1,20 +1,20 @@
 module ReverseAdoc
   module Converters
     class Tr < Base
+      def to_coradoc(node, state = {})
+        content = treat_children_coradoc(node, state)
+        header = table_header_row?(node)
+        Coradoc::Element::Table::Row.new(content, header)
+      end
+
       def convert(node, state = {})
-        content = treat_children(node, state).rstrip
-        result  = "#{content}\n"
-        table_header_row?(node) ? result + underline_for(node) : result
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       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

data/lib/reverse_adoc/converters/video.rb

@@ -1,33 +1,26 @@
 module ReverseAdoc
   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" : ""
+      def to_coradoc(node, _state = {})
+        src = node["src"]
+        id = node["id"]
         title = extract_title(node)
-        title = ".#{title}\n" unless title.empty?
-        [anchor, title, "video::", src, "[", options(node), "]"].join("")
+        attributes = Coradoc::Element::AttributeList.new
+        options = options(node)
+        attributes.add_named("options", options) if options.any?
+        Coradoc::Element::Video.new(title, id: id, src: src,
+                                           attributes: attributes)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
       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
+        autoplay = node["autoplay"]
+        loop_attr = node["loop"]
+        controls = node["controls"]
+        [autoplay, loop_attr, controls].compact
       end
     end
 

data/lib/reverse_adoc/converters.rb

@@ -13,8 +13,6 @@ module ReverseAdoc
       @@converters[tag_name.to_sym] or default_converter(tag_name)
     end
 
-    private
-
     def self.default_converter(tag_name)
       case ReverseAdoc.config.unknown_tags.to_sym
       when :pass_through
@@ -26,7 +24,8 @@ module ReverseAdoc
       when :raise
         raise UnknownTagError, "unknown tag: #{tag_name}"
       else
-        raise InvalidConfigurationError, "unknown value #{ReverseAdoc.config.unknown_tags.inspect} for ReverseAdoc.config.unknown_tags"
+        raise InvalidConfigurationError,
+              "unknown value #{ReverseAdoc.config.unknown_tags.inspect} for ReverseAdoc.config.unknown_tags"
       end
     end
   end

data/lib/reverse_adoc/html_converter.rb

@@ -1,56 +1,61 @@
 # frozen_string_literal: true
 
-require "reverse_adoc/converters/a"
-require "reverse_adoc/converters/aside"
-require "reverse_adoc/converters/audio"
-require "reverse_adoc/converters/blockquote"
-require "reverse_adoc/converters/br"
-require "reverse_adoc/converters/bypass"
-require "reverse_adoc/converters/code"
-require "reverse_adoc/converters/div"
-require "reverse_adoc/converters/drop"
-require "reverse_adoc/converters/em"
-require "reverse_adoc/converters/figure"
-require "reverse_adoc/converters/h"
-require "reverse_adoc/converters/head"
-require "reverse_adoc/converters/hr"
-require "reverse_adoc/converters/ignore"
-require "reverse_adoc/converters/img"
-require "reverse_adoc/converters/mark"
-require "reverse_adoc/converters/li"
-require "reverse_adoc/converters/ol"
-require "reverse_adoc/converters/p"
-require "reverse_adoc/converters/pass_through"
-require "reverse_adoc/converters/pre"
-require "reverse_adoc/converters/q"
-require "reverse_adoc/converters/strong"
-require "reverse_adoc/converters/sup"
-require "reverse_adoc/converters/sub"
-require "reverse_adoc/converters/table"
-require "reverse_adoc/converters/td"
-require "reverse_adoc/converters/th"
-require "reverse_adoc/converters/text"
-require "reverse_adoc/converters/tr"
-require "reverse_adoc/converters/video"
-require "reverse_adoc/converters/math"
+require_relative "converters/a"
+require_relative "converters/aside"
+require_relative "converters/audio"
+require_relative "converters/blockquote"
+require_relative "converters/br"
+require_relative "converters/bypass"
+require_relative "converters/code"
+require_relative "converters/div"
+require_relative "converters/drop"
+require_relative "converters/em"
+require_relative "converters/figure"
+require_relative "converters/h"
+require_relative "converters/head"
+require_relative "converters/hr"
+require_relative "converters/ignore"
+require_relative "converters/img"
+require_relative "converters/mark"
+require_relative "converters/li"
+require_relative "converters/ol"
+require_relative "converters/p"
+require_relative "converters/pass_through"
+require_relative "converters/pre"
+require_relative "converters/q"
+require_relative "converters/strong"
+require_relative "converters/sup"
+require_relative "converters/sub"
+require_relative "converters/table"
+require_relative "converters/td"
+require_relative "converters/th"
+require_relative "converters/text"
+require_relative "converters/tr"
+require_relative "converters/video"
+require_relative "converters/math"
 
 module ReverseAdoc
   class HtmlConverter
-    def self.convert(input, options = {})
-      root = if input.is_a?(String)
-              then Nokogiri::HTML(input).root
-             elsif input.is_a?(Nokogiri::XML::Document)
-              then input.root
-             elsif input.is_a?(Nokogiri::XML::Node)
-              then input
+    def self.to_coradoc(input, options = {})
+      root = case input
+             when String
+               Nokogiri::HTML(input).root
+             when Nokogiri::XML::Document
+               input.root
+             when Nokogiri::XML::Node
+               input
              end
 
-      root || (return "")
+      return "" unless root
 
       ReverseAdoc.config.with(options) do
-        result = ReverseAdoc::Converters.lookup(root.name).convert(root)
-        ReverseAdoc.cleaner.tidy(result)
+        ReverseAdoc::Converters.lookup(root.name).to_coradoc(root)
       end
     end
+
+    def self.convert(input, options = {})
+      result = Coradoc::Generator.gen_adoc(to_coradoc(input, options))
+      ReverseAdoc.cleaner.tidy(result)
+    end
   end
 end

data/lib/reverse_adoc/version.rb

@@ -1,3 +1,3 @@
 module ReverseAdoc
-  VERSION = "0.3.7".freeze
+  VERSION = "1.0.0".freeze
 end

data/lib/reverse_adoc.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'digest'
-require 'nokogiri'
-require 'reverse_adoc/version'
-require 'reverse_adoc/errors'
-require 'reverse_adoc/cleaner'
-require 'reverse_adoc/config'
-require 'reverse_adoc/converters'
-require 'reverse_adoc/converters/base'
-require "reverse_adoc/html_converter"
+require "digest"
+require "nokogiri"
+require_relative "reverse_adoc/version"
+require_relative "reverse_adoc/errors"
+require_relative "reverse_adoc/cleaner"
+require_relative "reverse_adoc/config"
+require_relative "reverse_adoc/converters"
+require_relative "reverse_adoc/converters/base"
+require_relative "reverse_adoc/html_converter"
 
 module ReverseAdoc
   def self.convert(input, options = {})