coradoc 0.2.0 → 1.0.0

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

@@ -0,0 +1,27 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Markup < Base
+      def to_coradoc(node, state = {})
+        u_before = unconstrained_before?(node)
+        u_after = unconstrained_after?(node)
+
+        leading_whitespace, trailing_whitespace =
+          extract_leading_trailing_whitespace(node)
+
+        content = treat_children_coradoc(node, state)
+
+        if node_has_ancestor?(node, markup_ancestor_tag_names)
+          content
+        elsif node.children.empty?
+          leading_whitespace.to_s
+        else
+          u = (u_before && leading_whitespace.nil?) ||
+            (u_after && trailing_whitespace.nil?)
+
+          e = coradoc_class.new(content, unconstrained: u)
+          [leading_whitespace, e, trailing_whitespace]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# Unless run with Coradoc::ReverseAdoc.config.mathml2asciimath,
+# this is cheating: we're injecting MathML into Asciidoctor, but
+# Asciidoctor only understands AsciiMath or LaTeX
+
+require "mathml2asciimath"
+
+module Coradoc::ReverseAdoc
+  module Converters
+    class Math < Base
+      # 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 Coradoc::ReverseAdoc.config.mathml2asciimath
+        unless stem.nil?
+          stem = stem.gsub(/\[/, "\\[").gsub(/\]/, "\\]").gsub(
+            /\(\(([^\)]+)\)\)/, "(\\1)"
+          )
+        end
+
+        # TODO: This is to be done in Coradoc
+        " stem:[" << stem << "] "
+      end
+    end
+
+    register :math, Math.new
+  end
+end

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

@@ -0,0 +1,60 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Ol < Base
+      # FIXIT
+      def to_coradoc(node, state = {})
+        # convert(node, state)
+        id = node["id"]
+        ol_count = state.fetch(:ol_count, 0) + 1
+        attrs = ol_attrs(node)
+        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 get_list_type(node, _state)
+        case node.name
+        when "ol"
+          :ordered
+        when "ul"
+          :unordered
+        end
+      end
+
+      def number_style(node)
+        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)
+        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
+
+    register :ol, Ol.new
+    register :ul, Ol.new
+    register :dir, Ol.new
+  end
+end

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

@@ -0,0 +1,19 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class P < Base
+      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
+    end
+
+    register :p, P.new
+  end
+end

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

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

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

@@ -0,0 +1,51 @@
+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
+
+      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,12 @@
+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
+    end
+
+    register :q, Q.new
+  end
+end

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

@@ -0,0 +1,16 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Strong < Markup
+      def coradoc_class
+        Coradoc::Element::Inline::Bold
+      end
+
+      def markup_ancestor_tag_names
+        %w[strong b]
+      end
+    end
+
+    register :strong, Strong.new
+    register :b,      Strong.new
+  end
+end

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

@@ -0,0 +1,18 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Sub < Base
+      def to_coradoc(node, state = {})
+        leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
+
+        content = treat_children_coradoc(node, state)
+
+        return content if Coradoc::Generator.gen_adoc(content).strip.empty?
+
+        e = Coradoc::Element::Inline::Subscript.new(content)
+        [leading_whitespace, e, trailing_whitespace]
+      end
+    end
+
+    register :sub, Sub.new
+  end
+end

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

@@ -0,0 +1,18 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Sup < Base
+      def to_coradoc(node, state = {})
+        leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
+
+        content = treat_children_coradoc(node, state)
+
+        return content if Coradoc::Generator.gen_adoc(content).strip.empty?
+
+        e = Coradoc::Element::Inline::Superscript.new(content)
+        [leading_whitespace, e, trailing_whitespace]
+      end
+    end
+
+    register :sup, Sup.new
+  end
+end

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

@@ -0,0 +1,280 @@
+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 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
+
+        cols = ensure_row_column_integrity_and_get_column_sizes(node)
+        attrs.add_named("cols", cols)
+
+        # Header first rows can't span multiple riws - drop header if they do.
+        header = node.at_xpath(".//tr")
+        unless header.xpath("./td | ./th").all? { |i| [nil, "1", ""].include? i["rowspan"] }
+          attrs.add_named("options", ["noheader"])
+        end
+
+        # This line should be removed.
+        return "" if attrs.empty?
+
+        attrs
+      end
+
+      def ensure_row_column_integrity_and_get_column_sizes(node)
+        rows = node.xpath(".//tr")
+        num_rows = rows.length
+        computed_columns_per_row = [0] * num_rows
+        # Both those variables may seem the same, but they have a crucial
+        # difference.
+        #
+        # cell_references don't necessarily contain an image of created
+        # table. New cells are pushed to it as needed, so if we have a
+        # one cell with colspan and rowspan of 2 on the previous row,
+        # those will always be first in the row, regardless of their
+        # position. This array is only used to warrant the table
+        # integrity.
+        #
+        # cell_matrix, on the other hand, can't be constructed outright.
+        # It will be incorrect as long as the table isn't fixed. So we
+        # can't use it to correct colspans/rowspans/missing rows. Once
+        # we have it constructed, only then we can calculate the correct
+        # column widths.
+        cell_references = [nil] * num_rows
+        cell_matrix = [nil] * num_rows
+
+        recompute = proc do
+          return ensure_row_column_integrity_and_get_column_sizes(node)
+        end
+
+        fits_in_cell_matrix = proc do |y,x,rowspan,colspan|
+          rowspan.times.all? do |yy|
+            colspan.times.all? do |xx|
+              !cell_matrix.dig(y+yy, x+xx)
+            end
+          end
+        end
+
+        rows.each_with_index do |row, i|
+          columns = row.xpath("./td | ./th")
+          column_id = 0
+
+          columns.each do |cell|
+            colspan = cell["colspan"]&.to_i || 1
+            rowspan = cell["rowspan"]&.to_i || 1
+
+            column_id += 1 until fits_in_cell_matrix.(i,column_id,rowspan,colspan)
+
+            rowspan.times do |j|
+              # Let's increase the table for particularly bad documents
+              computed_columns_per_row[i + j] ||= 0
+              computed_columns_per_row[i + j] += colspan
+
+              cell_references[i + j] ||= []
+              cell_matrix[i + j] ||= []
+              colspan.times do |k|
+                cell_references[i + j] << [cell, k > 0]
+                cell_matrix[i + j][column_id] = cell
+                column_id += 1
+              end
+              column_id -= colspan
+            end
+            column_id += colspan
+          end
+        end
+
+        ##### Fixups
+        cpr = computed_columns_per_row
+
+        # Some cell has too high colspan
+        if cpr.length > num_rows
+          cell_references[num_rows].each do |cell,|
+            next unless cell
+
+            cell["rowspan"] = cell["rowspan"].to_i - 1
+          end
+
+          # Let's recompute the numbers
+          recompute.()
+        end
+
+        if [cpr.first] * num_rows != cpr
+          # Colspan inconsistencies
+          modified = false
+          cpr_max = cpr.max
+          max_rows = cell_references.sort_by(&:length).reverse
+          max_rows.each do |row|
+            break if row.length != cpr_max
+
+            cell, spanning = row.last
+
+            if spanning
+              modified = true
+              cell["colspan"] = cell["colspan"].to_i - 1
+            end
+          end
+
+          recompute.() if modified
+
+          # We are out of colspans to fix. If we are at this point, this
+          # means there is an inconsistent number of TH/TDs simply.
+          # Here, the solution is to add empty TDs.
+          min_rows = cell_references.sort_by(&:length)
+          cpr_min = cpr.min
+          min_rows.each do |row|
+            break if row.length != cpr_min
+
+            row_obj = row.last.first.parent
+            doc = row_obj.document
+            row_obj.add_child(Nokogiri::XML::Node.new("td", doc))
+
+            modified = true
+          end
+
+          recompute.() if modified
+
+          ### We should have a correct document now and we should never
+          ### end up here.
+          warn "**** Couldn't fix table sizes for table on line #{node.line}"
+        end
+
+        # For column size computation, we must have an integral cell_matrix.
+        # Let's verify that all columns and rows are populated.
+        cell_matrix_correct = cell_matrix.length.times.all? do |y|
+          cell_matrix[y].length.times.all? do |x|
+            cell_matrix[y][x]
+          end
+        end
+
+        unless cell_matrix_correct
+          warn <<~WARNING.gsub("\n", " ")
+            **** Couldn't construct a valid image of a table on line
+            #{node.line}. We need that to reliably compute column
+            widths of that table. Please report a bug to metanorma/coradoc
+            repository.
+          WARNING
+        end
+
+        # Compute column sizes
+        column_sizes = []
+        cell_matrix.each do |row|
+          row.each_with_index do |(cell,_), i|
+            next unless !cell || [nil, "", "1"].include?(cell["colspan"])
+
+            column_sizes[i] ||= []
+            column_sizes[i] << cell["width"]
+          end
+        end
+
+        document_width = Coradoc::ReverseAdoc.config.doc_width.to_r
+
+        column_sizes += [nil] * (cpr.first - column_sizes.length)
+
+        sizes = column_sizes.map do |col|
+          col = [] if col.nil?
+
+          max = col.map do |i|
+            if i.nil?
+              0r
+            elsif i.end_with?("%")
+              document_width * i.to_i / 100
+            else
+              i.to_r
+            end
+          end.max
+
+          if max.nil? || max.negative?
+            0r
+          else
+            max
+          end
+        end
+
+        # The table seems bigger than the document... let's scale all
+        # values.
+        while sizes.map { |i|
+                          i.zero? ? document_width / 3 / sizes.length : i
+                        }.sum > document_width
+
+          sizes = sizes.map { |i| i * 4 / 5 }
+        end
+
+        rest = document_width - sizes.sum
+        unset = sizes.count(&:zero?)
+
+        # Fill in zeros with remainder space
+        sizes = sizes.map do |i|
+          if i.zero?
+            rest / unset
+          else
+            i
+          end
+        end
+
+        # Scale to integers
+        lcm = sizes.map(&:denominator).inject(1) { |i,j| i.lcm(j) }
+        sizes = sizes.map { |i| i * lcm }.map(&:to_i)
+
+        # Scale down by gcd
+        gcd = sizes.inject(sizes.first) { |i,j| i.gcd(j) }
+        sizes = sizes.map { |i| i / gcd }
+
+        # Try to generate a shorter definition
+        if [sizes.first] * sizes.length == sizes
+          sizes.length
+        else
+          sizes.join(",")
+        end
+      end
+    end
+
+    register :table, Table.new
+  end
+end

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

@@ -0,0 +1,77 @@
+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 | .//img[@src]") ||
+          node.at(".//p") && !singlepara
+
+        style = "a" if adoccell
+        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
+        end
+
+        Coradoc::Element::Table::Cell.new(options)
+      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,28 @@
+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(node.text)
+      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
+    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,18 @@
+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 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