coradoc 1.1.0 → 1.1.1

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)
@@ -238,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

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

@@ -1,10 +1,10 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   class Plugin
     # This plugin enhances documents from the PLATEAU project
     # to extract more data.
     #
     # Usage:
-    # reverse_adoc -rcoradoc/reverse_adoc/plugins/plateau
+    # reverse_adoc -rcoradoc/input/html/plugins/plateau
     #   --external-images -u raise --output _out/index.adoc index.html
     class Plateau < Plugin
       def name
@@ -203,4 +203,4 @@ module Coradoc::ReverseAdoc
   end
 end
 
-Coradoc::ReverseAdoc.config.plugins << Coradoc::ReverseAdoc::Plugin::Plateau
+Coradoc::Input::HTML.config.plugins << Coradoc::Input::HTML::Plugin::Plateau

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

@@ -1,4 +1,4 @@
-module Coradoc::ReverseAdoc
+module Coradoc::Input::HTML
   # Postprocessor's aim is to convert a Coradoc tree from
   # a mess that has been created from HTML into a tree that
   # is compatible with what we would get out of Coradoc, if
@@ -73,7 +73,7 @@ module Coradoc::ReverseAdoc
     end
 
     def split_sections
-      max_level = Coradoc::ReverseAdoc.config.split_sections
+      max_level = Coradoc::Input::HTML.config.split_sections
 
       return unless max_level
 
@@ -111,7 +111,7 @@ module Coradoc::ReverseAdoc
             # we can compute numbers
             previous_sections[elem] = parent_sections[title.level_int]
             parent_sections[title.level_int] = elem
-            parent_sections[(title.level_int+1)..nil] = nil
+            parent_sections[(title.level_int + 1)..nil] = nil
 
             elem
           else

data/lib/coradoc/input/html.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "digest"
+require "nokogiri"
+require "coradoc/input"
+require_relative "html/errors"
+require_relative "html/cleaner"
+require_relative "html/config"
+require_relative "html/converters"
+require_relative "html/converters/base"
+require_relative "html/html_converter"
+require_relative "html/plugin"
+require_relative "html/postprocessor"
+
+module Coradoc
+  module Input::HTML
+    def self.convert(input, options = {})
+      Coradoc::Input::HTML::HtmlConverter.convert(input, options)
+    end
+
+    def self.to_coradoc(input, options = {})
+      Input::HTML::HtmlConverter.to_coradoc(input, options)
+    end
+
+    def self.config
+      @config ||= Config.new
+      yield @config if block_given?
+      @config
+    end
+
+    def self.cleaner
+      @cleaner ||= Cleaner.new
+    end
+
+    def self.processor_id
+      :html
+    end
+
+    def self.processor_match?(filename)
+      %w[.html .htm].any? { |i| filename.downcase.end_with?(i) }
+    end
+
+    def self.processor_execute(input, options = {})
+      to_coradoc(input, options)
+    end
+
+    def self.processor_postprocess(data, options)
+      if options[:output_processor] == :adoc
+        data.transform_values do |v|
+          Input::HTML::HtmlConverter.cleanup_result(v, options)
+        end
+      else
+        data
+      end
+    end
+
+    Coradoc::Input.define(self)
+  end
+end

data/lib/coradoc/input.rb

@@ -0,0 +1,12 @@
+require "coradoc"
+
+module Coradoc
+  module Input
+    @processors = {}
+    extend Converter::CommonInputOutputMethods
+  end
+end
+
+require "coradoc/input/adoc"
+require "coradoc/input/docx"
+require "coradoc/input/html"

data/lib/coradoc/output/adoc.rb

@@ -0,0 +1,17 @@
+module Coradoc
+  module Output::Adoc
+    def self.processor_id
+      :adoc
+    end
+
+    def self.processor_match?(filename)
+      %w[.adoc].any? { |i| filename.downcase.end_with?(i) }
+    end
+
+    def self.processor_execute(input, _options = {})
+      input.transform_values { |i| Coradoc::Generator.gen_adoc(i) }
+    end
+
+    Coradoc::Output.define(self)
+  end
+end

data/lib/coradoc/output/coradoc_tree_debug.rb

@@ -0,0 +1,19 @@
+module Coradoc
+  module Output::CoradocTreeDebug
+    def self.processor_id
+      :coradoc_tree_debug
+    end
+
+    def self.processor_match?(filename)
+      false
+    end
+
+    def self.processor_execute(input, _options = {})
+      out = StringIO.new
+      PP.pp(input, out)
+      { nil => out.string }
+    end
+
+    Coradoc::Output.define(self)
+  end
+end

data/lib/coradoc/output.rb

@@ -0,0 +1,11 @@
+require "coradoc"
+
+module Coradoc
+  module Output
+    @processors = {}
+    extend Converter::CommonInputOutputMethods
+  end
+end
+
+require "coradoc/output/adoc"
+require "coradoc/output/coradoc_tree_debug"

data/lib/coradoc/parser/asciidoc/admonition.rb

@@ -0,0 +1,24 @@
+module Coradoc
+  module Parser
+    module Asciidoc
+      module Admonition
+        def admonition_type
+          str('NOTE') | str('TIP') | str('EDITOR') |
+          str('IMPORTANT') | str('WARNING') | str('CAUTION') |
+          str('TODO') 
+          # requires atypical syntax for access?
+          # | str('DANGER')
+          # | str('SAFETY PRECAUTION')
+        end
+        def admonition_line
+          admonition_type.as(:admonition_type) >> str(': ') >>
+          (
+            (text.as(:text) >>
+            line_ending.as(:line_break)
+            ).repeat(1)
+            ).as(:content)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/parser/asciidoc/attribute_list.rb

@@ -0,0 +1,67 @@
+module Coradoc
+  module Parser
+    module Asciidoc
+      module AttributeList
+
+        def named_attribute_name
+          attribute_name
+        end
+
+        def named_attribute_value
+          match('[^\],]').repeat(1)
+        end
+
+        def named_attribute
+          (match('[a-zA-Z0-9_-]').repeat(1).as(:named_key) >>
+            str(' ').maybe >> str("=") >> str(' ').maybe >>
+            match['a-zA-Z0-9_\- \"'].repeat(1).as(:named_value) >>
+            str(' ').maybe
+            ).as(:named)
+        end
+
+        def positional_attribute
+          (match['a-zA-Z0-9_\-%'].repeat(1) >>
+            str("=").absent?
+            ).as(:positional)
+        end
+
+        def named_many
+          (named_attribute.repeat(1,1) >>
+              (str(",") >> space.maybe >> named_attribute).repeat(0))
+        end
+
+        def positional_one_named_many
+          (positional_attribute.repeat(1,1) >>
+            (str(",") >> space.maybe >> named_attribute).repeat(1))
+        end
+
+        def positional_many_named_many
+          (positional_attribute.repeat(1,1) >>
+            (str(",") >> space.maybe >> positional_attribute).repeat(1) >>
+            (str(",") >> space.maybe>> named_attribute).repeat(1))
+        end
+
+        def positional_many
+          (positional_attribute.repeat(1,1) >>
+            (str(",") >> space.maybe >> positional_attribute).repeat(0))
+        end
+
+        def positional_zero_or_one
+          positional_attribute.repeat(0,1)
+        end
+
+        def attribute_list(name = :attribute_list)
+          str('[') >> str("[").absent? >> 
+          ( named_many |
+            positional_one_named_many |
+            positional_many_named_many |
+            positional_many |
+            positional_zero_or_one
+          ).as(:attribute_array).as(name) >>
+          str("]")
+        end
+
+      end
+    end
+  end
+end