coradoc 0.1.0 → 0.3.0

data/lib/coradoc/reverse_adoc/converters/pre.rb

@@ -0,0 +1,55 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Pre < Base
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        lang = language(node)
+        content = treat_children(node, state)
+
+        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)
+        return "\n" if node.name == "br"
+
+        prefix = postfix = "\n\n" if node.name == "p"
+
+        "#{prefix}#{node.text}#{postfix}"
+      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/coradoc/reverse_adoc/converters/q.rb

@@ -0,0 +1,16 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Q < Base
+      def to_coradoc(node, state = {})
+        content = treat_children(node, state)
+        Coradoc::Element::Inline::Quotation.new(content)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      end
+    end
+
+    register :q, Q.new
+  end
+end

data/lib/coradoc/reverse_adoc/converters/strong.rb

@@ -0,0 +1,52 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Strong < Base
+      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
+
+    register :strong, Strong.new
+    register :b,      Strong.new
+  end
+end

data/lib/coradoc/reverse_adoc/converters/sub.rb

@@ -0,0 +1,16 @@
+module Coradoc::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 = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      end
+    end
+
+    register :sub, Sub.new
+  end
+end

data/lib/coradoc/reverse_adoc/converters/sup.rb

@@ -0,0 +1,16 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Sup < Base
+      def to_coradoc(node, state = {})
+        content = treat_children(node, state)
+        Coradoc::Element::Inline::Superscript.new(content)
+      end
+
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      end
+    end
+
+    register :sup, Sup.new
+  end
+end

data/lib/coradoc/reverse_adoc/converters/table.rb

@@ -0,0 +1,69 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Table < Base
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        title = extract_title(node)
+        attrs = style(node)
+        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"
+          "none"
+        when "hsides"
+          "topbot"
+        when "vsides"
+          "sides"
+        when "box", "border"
+          "all"
+        end
+      end
+
+      def rules(node)
+        case node["rules"]
+        when "all"
+          "all"
+        when "rows"
+          "rows"
+        when "cols"
+          "cols"
+        when "none"
+          "none"
+        end
+      end
+
+      def style(node)
+        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.add_named("rules", rules_attr) if rules_attr
+
+        # This line should be removed.
+        return "" if attrs.empty?
+
+        attrs
+      end
+    end
+
+    register :table, Table.new
+  end
+end

data/lib/coradoc/reverse_adoc/converters/td.rb

@@ -0,0 +1,83 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Td < Base
+      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_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)
+        ""
+      end
+
+      def colrow(colspan, rowspan)
+        if colspan && rowspan && colspan != "1" && rowspan != "1"
+          "#{colspan}.#{rowspan}+"
+        elsif colspan && colspan != "1"
+          "#{colspan}+"
+        elsif rowspan && rowspan != "1"
+          ".#{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/coradoc/reverse_adoc/converters/text.rb

@@ -0,0 +1,65 @@
+module Coradoc::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 = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      end
+
+      private
+
+      def treat_empty(node, state)
+        parent = node.parent.name.to_sym
+        if %i[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)
+        escape_links(text)
+      end
+
+      def preserve_nbsp(text)
+        text.gsub(/\u00A0/, "&nbsp;")
+      end
+
+      def escape_links(text)
+        text.gsub(/<<([^>]*)>>/, "\\<<\\1>>")
+      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/coradoc/reverse_adoc/converters/th.rb

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

data/lib/coradoc/reverse_adoc/converters/tr.rb

@@ -0,0 +1,22 @@
+module Coradoc::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 = {})
+        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
+    end
+
+    register :tr, Tr.new
+  end
+end

data/lib/coradoc/reverse_adoc/converters/video.rb

@@ -0,0 +1,29 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Video < Base
+      def to_coradoc(node, _state = {})
+        src = node["src"]
+        id = node["id"]
+        title = extract_title(node)
+        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"]
+        [autoplay, loop_attr, controls].compact
+      end
+    end
+
+    register :video, Video.new
+  end
+end

data/lib/coradoc/reverse_adoc/converters.rb

@@ -0,0 +1,32 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    def self.register(tag_name, converter)
+      @@converters ||= {}
+      @@converters[tag_name.to_sym] = converter
+    end
+
+    def self.unregister(tag_name)
+      @@converters.delete(tag_name.to_sym)
+    end
+
+    def self.lookup(tag_name)
+      @@converters[tag_name.to_sym] or default_converter(tag_name)
+    end
+
+    def self.default_converter(tag_name)
+      case Coradoc::ReverseAdoc.config.unknown_tags.to_sym
+      when :pass_through
+        Coradoc::ReverseAdoc::Converters::PassThrough.new
+      when :drop
+        Coradoc::ReverseAdoc::Converters::Drop.new
+      when :bypass
+        Coradoc::ReverseAdoc::Converters::Bypass.new
+      when :raise
+        raise UnknownTagError, "unknown tag: #{tag_name}"
+      else
+        raise InvalidConfigurationError,
+              "unknown value #{Coradoc::ReverseAdoc.config.unknown_tags.inspect} for Coradoc::ReverseAdoc.config.unknown_tags"
+      end
+    end
+  end
+end

data/lib/coradoc/reverse_adoc/errors.rb

@@ -0,0 +1,10 @@
+module Coradoc::ReverseAdoc
+  class Error < StandardError
+  end
+
+  class UnknownTagError < Error
+  end
+
+  class InvalidConfigurationError < Error
+  end
+end

data/lib/coradoc/reverse_adoc/html_converter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+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 Coradoc::ReverseAdoc
+  class HtmlConverter
+    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
+
+      return "" unless root
+
+      Coradoc::ReverseAdoc.config.with(options) do
+        Coradoc::ReverseAdoc::Converters.lookup(root.name).to_coradoc(root)
+      end
+    end
+
+    def self.convert(input, options = {})
+      result = Coradoc::Generator.gen_adoc(to_coradoc(input, options))
+      Coradoc::ReverseAdoc.cleaner.tidy(result)
+    end
+  end
+end

data/lib/coradoc/reverse_adoc.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "digest"
+require "nokogiri"
+require_relative "../coradoc"
+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 Coradoc::ReverseAdoc
+  def self.convert(input, options = {})
+    Coradoc::ReverseAdoc::HtmlConverter.convert(input, options)
+  end
+
+  def self.config
+    @config ||= Config.new
+    yield @config if block_given?
+    @config
+  end
+
+  def self.cleaner
+    @cleaner ||= Cleaner.new
+  end
+end