coradoc 0.3.0 → 1.1.0

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

@@ -8,10 +8,6 @@ module Coradoc::ReverseAdoc
         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?

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

@@ -15,10 +15,6 @@ module Coradoc::ReverseAdoc
         Coradoc::Element::Title.new(content, level, id: id)
       end
 
-      def convert(node, state = {})
-        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_coradoc(child, state)

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

@@ -6,10 +6,6 @@ module Coradoc::ReverseAdoc
         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?

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

@@ -4,10 +4,6 @@ module Coradoc::ReverseAdoc
       def to_coradoc(_node, _state = {})
         Coradoc::Element::Break::ThematicBreak.new
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :hr, Hr.new

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

@@ -19,22 +19,32 @@ module Coradoc::ReverseAdoc
       end
 
       def datauri2file(src)
+        return unless src
+
         %r{^data:image/(?:[^;]+);base64,(?<imgdata>.+)$} =~ src
 
         dest_dir = Pathname.new(Coradoc::ReverseAdoc.config.destination).dirname
         images_dir = dest_dir.join("images")
         FileUtils.mkdir_p(images_dir)
 
-        ext, image_src_path = determine_image_src_path(src, imgdata)
+        ext, image_src_path, tempfile = determine_image_src_path(src, imgdata)
         image_dest_path = images_dir + "#{image_number}.#{ext}"
 
         # puts "image_dest_path: #{image_dest_path.to_s}"
         # puts "image_src_path: #{image_src_path.to_s}"
 
-        FileUtils.cp(image_src_path, image_dest_path)
+        if File.exist?(image_src_path)
+          FileUtils.cp(image_src_path, image_dest_path)
+        else
+          @annotate_missing = image_src_path
+          Kernel.warn "Image #{image_src_path} does not exist"
+        end
+
         image_number_increment
 
         image_dest_path.relative_path_from(dest_dir)
+      ensure
+        tempfile&.close!
       end
 
       def determine_image_src_path(src, imgdata)
@@ -45,13 +55,13 @@ module Coradoc::ReverseAdoc
       end
 
       def copy_temp_file(imgdata)
-        Tempfile.open(["radoc", ".jpg"]) do |f|
-          f.binmode
-          f.write(Base64.strict_decode64(imgdata))
-          f.rewind
-          ext = Marcel::MimeType.for(f).sub(%r{^[^/]+/}, "")
-          [ext, f.path]
-        end
+        f = Tempfile.open(["radoc", ".jpg"])
+        f.binmode
+        f.write(Base64.strict_decode64(imgdata))
+        f.rewind
+        ext = Marcel::MimeType.for(f).sub(%r{^[^/]+/}, "")
+        ext = "svg" if ext == "svg+xml"
+        [ext, f.path, f]
       end
 
       def to_coradoc(node, _state = {})
@@ -61,6 +71,9 @@ module Coradoc::ReverseAdoc
         width = node["width"]
         height = node["height"]
 
+        width = width.to_i if width&.match?(/\A\d+\z/)
+        height = height.to_i if height&.match?(/\A\d+\z/)
+
         title = extract_title(node)
 
         if Coradoc::ReverseAdoc.config.external_images
@@ -73,21 +86,20 @@ module Coradoc::ReverseAdoc
         if alt # && !alt.to_s.empty?
           attributes.add_positional(alt)
         elsif width || height
-          attributes.add_positional("\"\"")
+          attributes.add_positional(nil)
         end
-        # attributes.add_named("title", title) if title
+        attributes.add_named("title", title) if title && !title.empty?
         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))
+        if src
+          Coradoc::Element::Image::BlockImage.new(title, id, src,
+                                                  attributes: attributes,
+                                                  annotate_missing: @annotate_missing)
+        end
       end
     end
 
-    register :img, Img.new
+    register :img, Img
   end
 end

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

@@ -6,10 +6,6 @@ module Coradoc::ReverseAdoc
         content = treat_children_coradoc(node, state)
         Coradoc::Element::ListItem.new(content, id: id)
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :li, Li.new

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

@@ -1,18 +1,12 @@
 module Coradoc::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))
+    class Mark < Markup
+      def coradoc_class
+        Coradoc::Element::Inline::Highlight
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      def markup_ancestor_tag_names
+        %w[mark]
       end
     end
 

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/ol.rb

@@ -23,10 +23,6 @@ module Coradoc::ReverseAdoc
         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"

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

@@ -12,10 +12,6 @@ module Coradoc::ReverseAdoc
 
         Coradoc::Element::Paragraph.new(content, options)
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :p, P.new

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

@@ -22,10 +22,6 @@ module Coradoc::ReverseAdoc
         )
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
-
       private
 
       def treat(node, _state)

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

@@ -5,10 +5,6 @@ module Coradoc::ReverseAdoc
         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

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

@@ -1,48 +1,12 @@
 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]
+    class Strong < Markup
+      def coradoc_class
+        Coradoc::Element::Inline::Bold
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      def markup_ancestor_tag_names
+        %w[strong b]
       end
     end
 

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

@@ -2,12 +2,14 @@ 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)
-        Coradoc::Element::Inline::Subscript.new(content)
-      end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_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
 

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

@@ -2,12 +2,14 @@ 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
+        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?
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+        e = Coradoc::Element::Inline::Superscript.new(content)
+        [leading_whitespace, e, trailing_whitespace]
       end
     end
 

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

@@ -9,10 +9,6 @@ module Coradoc::ReverseAdoc
         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?
@@ -57,11 +53,251 @@ module Coradoc::ReverseAdoc
         rules_attr = rules(node)
         attrs.add_named("rules", rules_attr) if rules_attr
 
+        # We can't, and shouldn't do those calculation if the table we are
+        # processing is empty.
+        unless empty?(node)
+          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
+        end
+
         # This line should be removed.
         return "" if attrs.empty?
 
         attrs
       end
+
+      def empty?(node)
+        !node.at_xpath(".//td | .//th")
+      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
+            added_node = Nokogiri::XML::Node.new("td", doc)
+            added_node["x-added"] = "x-added"
+            row_obj.add_child(added_node)
+
+            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
+          # It may be a special case that we need to add virtual cells at the
+          # beginning not the end of a row.
+          needs_recompute = false
+          cell_matrix.each do |row|
+            if row.compact.length != row.length
+              last_cell = row.last
+              if last_cell["x-added"]
+                last_cell.parent.prepend_child(last_cell)
+                needs_recompute = true
+              end
+            end
+          end
+          recompute.() if needs_recompute
+
+          # But otherwise... we've got a really nasty table.
+          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

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

@@ -11,11 +11,10 @@ module Coradoc::ReverseAdoc
         singlepara = node.elements.size == 1 && node.elements.first.name == "p"
         state[:tdsinglepara] = singlepara if singlepara
 
-        adoccell = node.at(".//ul | .//ol | .//pre | .//blockquote | .//br | .//hr") ||
+        adoccell = node.at(".//ul | .//ol | .//pre | .//blockquote | .//br | .//hr | .//img[@src]") ||
           node.at(".//p") && !singlepara
 
         style = "a" if adoccell
-        delim = adoccell ? "\n" : " "
         content = treat_children_coradoc(node, state)
         options = {}.tap do |hash|
           hash[:id] = id
@@ -23,16 +22,11 @@ module Coradoc::ReverseAdoc
           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