coradoc 1.0.0 → 1.1.1

data/lib/coradoc/{reverse_adoc → input/html}/converters/img.rb

@@ -4,18 +4,18 @@ require "tempfile"
 require "base64"
 require "marcel"
 
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Img < Base
       def image_number
         sprintf(
-          Coradoc::ReverseAdoc.config.image_counter_pattern,
-          Coradoc::ReverseAdoc.config.image_counter,
+          Coradoc::Input::HTML.config.image_counter_pattern,
+          Coradoc::Input::HTML.config.image_counter,
         )
       end
 
       def image_number_increment
-        Coradoc::ReverseAdoc.config.image_counter += 1
+        Coradoc::Input::HTML.config.image_counter += 1
       end
 
       def datauri2file(src)
@@ -23,7 +23,7 @@ module Coradoc::ReverseAdoc
 
         %r{^data:image/(?:[^;]+);base64,(?<imgdata>.+)$} =~ src
 
-        dest_dir = Pathname.new(Coradoc::ReverseAdoc.config.destination).dirname
+        dest_dir = Pathname.new(Coradoc::Input::HTML.config.destination).dirname
         images_dir = dest_dir.join("images")
         FileUtils.mkdir_p(images_dir)
 
@@ -33,7 +33,13 @@ module Coradoc::ReverseAdoc
         # 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)
@@ -45,7 +51,7 @@ module Coradoc::ReverseAdoc
         return copy_temp_file(imgdata) if imgdata
 
         ext = File.extname(src).strip.downcase[1..-1]
-        [ext, Pathname.new(Coradoc::ReverseAdoc.config.sourcedir).join(src)]
+        [ext, Pathname.new(Coradoc::Input::HTML.config.sourcedir).join(src)]
       end
 
       def copy_temp_file(imgdata)
@@ -70,7 +76,7 @@ module Coradoc::ReverseAdoc
 
         title = extract_title(node)
 
-        if Coradoc::ReverseAdoc.config.external_images
+        if Coradoc::Input::HTML.config.external_images
           # puts "external image conversion #{id}, #{src}"
           src = datauri2file(src)
         end
@@ -88,11 +94,12 @@ module Coradoc::ReverseAdoc
 
         if src
           Coradoc::Element::Image::BlockImage.new(title, id, src,
-                                                  attributes: attributes)
+                                                  attributes: attributes,
+                                                  annotate_missing: @annotate_missing)
         end
       end
     end
 
-    register :img, Img.new
+    register :img, Img
   end
 end

data/lib/coradoc/{reverse_adoc → input/html}/converters/li.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Li < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/mark.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Mark < Markup
       def coradoc_class

data/lib/coradoc/{reverse_adoc → input/html}/converters/markup.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Markup < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/math.rb

@@ -1,10 +1,10 @@
-# Unless run with Coradoc::ReverseAdoc.config.mathml2asciimath,
+# Unless run with Coradoc::Input::HTML.config.mathml2asciimath,
 # this is cheating: we're injecting MathML into Asciidoctor, but
 # Asciidoctor only understands AsciiMath or LaTeX
 
 require "mathml2asciimath"
 
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Math < Base
       # FIXIT
@@ -14,7 +14,7 @@ module Coradoc::ReverseAdoc
 
       def convert(node, _state = {})
         stem = node.to_s.gsub(/\n/, " ")
-        stem = MathML2AsciiMath.m2a(stem) if Coradoc::ReverseAdoc.config.mathml2asciimath
+        stem = MathML2AsciiMath.m2a(stem) if Coradoc::Input::HTML.config.mathml2asciimath
         unless stem.nil?
           stem = stem.gsub(/\[/, "\\[").gsub(/\]/, "\\]").gsub(
             /\(\(([^\)]+)\)\)/, "(\\1)"

data/lib/coradoc/{reverse_adoc → input/html}/converters/ol.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Ol < Base
       # FIXIT

data/lib/coradoc/{reverse_adoc → input/html}/converters/p.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class P < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/pass_through.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class PassThrough < Base
       def to_coradoc(node, _state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/pre.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Pre < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/q.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Q < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/strong.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Strong < Markup
       def coradoc_class

data/lib/coradoc/{reverse_adoc → input/html}/converters/sub.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Sub < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/sup.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Sup < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/table.rb

@@ -1,12 +1,12 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Table < Base
       def to_coradoc(node, state = {})
         id = node["id"]
         title = extract_title(node)
-        attrs = style(node)
+        attributes = style(node)
         content = treat_children_coradoc(node, state)
-        Coradoc::Element::Table.new(title, content, { id: id, attrs: attrs })
+        Coradoc::Element::Table.new(title, content, { id: id, attributes: attributes })
       end
 
       def extract_title(node)
@@ -53,13 +53,17 @@ module Coradoc::ReverseAdoc
         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)
+        # 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"])
+          # 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.
@@ -68,6 +72,10 @@ module Coradoc::ReverseAdoc
         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
@@ -173,7 +181,9 @@ module Coradoc::ReverseAdoc
 
             row_obj = row.last.first.parent
             doc = row_obj.document
-            row_obj.add_child(Nokogiri::XML::Node.new("td", doc))
+            added_node = Nokogiri::XML::Node.new("td", doc)
+            added_node["x-added"] = "x-added"
+            row_obj.add_child(added_node)
 
             modified = true
           end
@@ -194,6 +204,21 @@ module Coradoc::ReverseAdoc
         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
@@ -213,7 +238,7 @@ module Coradoc::ReverseAdoc
           end
         end
 
-        document_width = Coradoc::ReverseAdoc.config.doc_width.to_r
+        document_width = Coradoc::Input::HTML.config.doc_width.to_r
 
         column_sizes += [nil] * (cpr.first - column_sizes.length)
 

data/lib/coradoc/{reverse_adoc → input/html}/converters/td.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Td < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/text.rb

@@ -1,10 +1,10 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   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)
+        Coradoc::Element::TextElement.new(node.text, html_cleanup: true)
       end
 
       private

data/lib/coradoc/{reverse_adoc → input/html}/converters/th.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Th < Td
       def cellstyle(node)

data/lib/coradoc/{reverse_adoc → input/html}/converters/tr.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Tr < Base
       def to_coradoc(node, state = {})

data/lib/coradoc/{reverse_adoc → input/html}/converters/video.rb

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   module Converters
     class Video < Base
       def to_coradoc(node, _state = {})

data/lib/coradoc/input/html/converters.rb

@@ -0,0 +1,57 @@
+module Coradoc
+  module Input::HTML
+    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)
+        converter = @@converters[tag_name.to_sym] || default_converter(tag_name)
+        converter = converter.new if converter.respond_to? :new
+        converter
+      end
+
+      # Note: process won't run plugin hooks
+      def self.process(node, state)
+        node = node.to_a if node.is_a? Nokogiri::XML::NodeSet
+        return node.map { |i| process(i, state) }.join if node.is_a? Array
+
+        lookup(node.name).convert(node, state)
+      end
+
+      def self.process_coradoc(node, state)
+        node = node.to_a if node.is_a? Nokogiri::XML::NodeSet
+        return node.map { |i| process_coradoc(i, state) } if node.is_a? Array
+
+        plugins = state[:plugin_instances] || {}
+        process = proc { lookup(node.name).to_coradoc(node, state) }
+        plugins.each do |i|
+          prev_process = process
+          process = proc { i.html_tree_run_hooks(node, state, &prev_process) }
+        end
+        process.(node, state)
+      end
+
+      def self.default_converter(tag_name)
+        case Coradoc::Input::HTML.config.unknown_tags.to_sym
+        when :pass_through
+          Coradoc::Input::HTML::Converters::PassThrough.new
+        when :drop
+          Coradoc::Input::HTML::Converters::Drop.new
+        when :bypass
+          Coradoc::Input::HTML::Converters::Bypass.new
+        when :raise
+          raise UnknownTagError, "unknown tag: #{tag_name}"
+        else
+          raise InvalidConfigurationError,
+                "unknown value #{Coradoc::Input::HTML.config.unknown_tags.inspect} for Coradoc::Input::HTML.config.unknown_tags"
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/input/html/errors.rb

@@ -0,0 +1,12 @@
+module Coradoc
+  module Input::HTML
+    class Error < StandardError
+    end
+
+    class UnknownTagError < Error
+    end
+
+    class InvalidConfigurationError < Error
+    end
+  end
+end

data/lib/coradoc/{reverse_adoc → input/html}/html_converter.rb

@@ -37,12 +37,11 @@ require_relative "converters/video"
 require_relative "converters/math"
 
 module Coradoc
-  module ReverseAdoc
+  module Input::HTML
     class HtmlConverter
       def self.to_coradoc(input, options = {})
-        plugin_instances = options.delete(:plugin_instances)
-        ReverseAdoc.config.with(options) do
-          plugin_instances ||= Coradoc::ReverseAdoc.config.plugins.map(&:new)
+        Input::HTML.config.with(options) do
+          plugin_instances = prepare_plugin_instances(options)
 
           root = track_time "Loading input HTML document" do
             case input
@@ -85,52 +84,68 @@ module Coradoc
             end
           end
 
+          options[:plugin_instances] = plugin_instances unless options.frozen?
+
           coradoc
         end
       end
 
       def self.convert(input, options = {})
-        ReverseAdoc.config.with(options) do
-          plugin_instances = Coradoc::ReverseAdoc.config.plugins.map(&:new)
-
-          options = options.merge(plugin_instances: plugin_instances)
+        Input::HTML.config.with(options) do
+          plugin_instances = prepare_plugin_instances(options)
 
           coradoc = to_coradoc(input, options)
 
           if coradoc.is_a?(Hash)
             coradoc.to_h do |file, tree|
               track_time "Converting file #{file || 'main'}" do
-                [file, convert_single_coradoc_to_adoc(file, tree, plugin_instances)]
+                [file,
+                 convert_single_coradoc_to_adoc(file, tree, options)]
               end
             end
           else
-            convert_single_coradoc_to_adoc(nil, coradoc, plugin_instances)
+            convert_single_coradoc_to_adoc(nil, coradoc, options)
           end
         end
       end
 
-      def self.convert_single_coradoc_to_adoc(_file, coradoc, plugin_instances)
+      def self.convert_single_coradoc_to_adoc(_file, coradoc, options)
+        plugin_instances = prepare_plugin_instances(options)
+
         result = track_time "Converting Coradoc tree into Asciidoc" do
           Coradoc::Generator.gen_adoc(coradoc)
         end
-        result = track_time "Cleaning up the result" do
-          ReverseAdoc.cleaner.tidy(result)
-        end
-        plugin_instances.each do |plugin|
-          if plugin.respond_to?(:postprocess_asciidoc_string)
-            plugin.asciidoc_string = result
-            track_time "Postprocessing AsciiDoc string with #{plugin.name} plugin" do
-              plugin.postprocess_asciidoc_string
+        cleanup_result(result, options)
+      end
+
+      def self.cleanup_result(result, options)
+        Input::HTML.config.with(options) do
+          plugin_instances = prepare_plugin_instances(options)
+
+          result = track_time "Cleaning up the result" do
+            Input::HTML.cleaner.tidy(result)
+          end
+          plugin_instances.each do |plugin|
+            if plugin.respond_to?(:postprocess_asciidoc_string)
+              plugin.asciidoc_string = result
+              track_time "Postprocessing AsciiDoc string with #{plugin.name} plugin" do
+                plugin.postprocess_asciidoc_string
+              end
+              result = plugin.asciidoc_string
             end
-            result = plugin.asciidoc_string
           end
+
+          result
         end
-        result
+      end
+
+      def self.prepare_plugin_instances(options)
+        options[:plugin_instances] || Coradoc::Input::HTML.config.plugins.map(&:new)
       end
 
       @track_time_indentation = 0
       def self.track_time(task)
-        if ReverseAdoc.config.track_time
+        if Input::HTML.config.track_time
           warn "  " * @track_time_indentation +
             "* #{task} is starting..."
           @track_time_indentation += 1

data/lib/coradoc/{reverse_adoc → input/html}/plugin.rb

@@ -1,9 +1,9 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   class Plugin
     #### Plugin system general
 
     # Allow building plugins with a shorthand syntax:
-    # plugin = Coradoc::ReverseAdoc::Plugin.new do
+    # plugin = Coradoc::Input::HTML::Plugin.new do
     #   def name = "Test"
     # end
 
@@ -53,12 +53,12 @@ module Coradoc::ReverseAdoc
       end
     end
 
-    def html_tree_process_to_coradoc(tree, state={})
-      Coradoc::ReverseAdoc::Converters.process_coradoc(tree, state)
+    def html_tree_process_to_coradoc(tree, state = {})
+      Coradoc::Input::HTML::Converters.process_coradoc(tree, state)
     end
 
-    def html_tree_process_to_adoc(tree, state={})
-      Coradoc::ReverseAdoc::Converters.process(tree, state)
+    def html_tree_process_to_adoc(tree, state = {})
+      Coradoc::Input::HTML::Converters.process(tree, state)
     end
 
     def html_tree_preview