coradoc 1.1.8 → 2.0.12

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

@@ -1,81 +0,0 @@
-module Coradoc
-  module Input
-    module Html
-      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
-  end
-end

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

@@ -1,32 +0,0 @@
-module Coradoc
-  module Input
-    module 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, html_cleanup: true)
-          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
-  end
-end

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

@@ -1,18 +0,0 @@
-module Coradoc
-  module Input
-    module Html
-      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
-  end
-end

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

@@ -1,22 +0,0 @@
-module Coradoc
-  module Input
-    module Html
-      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
-  end
-end

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

@@ -1,29 +0,0 @@
-module Coradoc
-  module Input
-    module Html
-      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 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
-  end
-end

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

@@ -1,59 +0,0 @@
-module Coradoc
-  module Input
-    module 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
-end

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

@@ -1,14 +0,0 @@
-module Coradoc
-  module Input
-    module Html
-      class Error < StandardError
-      end
-
-      class UnknownTagError < Error
-      end
-
-      class InvalidConfigurationError < Error
-      end
-    end
-  end
-end

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

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "converters/markup"
-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/dl"
-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
-  module Input
-    module Html
-      class HtmlConverter
-        def self.to_coradoc(input, options = {})
-          Input::Html.config.with(options) do
-            plugin_instances = prepare_plugin_instances(options)
-
-            root = track_time "Loading input HTML document" do
-              case input
-              when String
-                Nokogiri::HTML(input).root
-              when Nokogiri::XML::Document
-                input.root
-              when Nokogiri::XML::Node
-                input
-              end
-            end
-
-            return "" unless root
-
-            plugin_instances.each do |plugin|
-              plugin.html_tree = root
-              if plugin.respond_to?(:preprocess_html_tree)
-                track_time "Preprocessing document with #{plugin.name} plugin" do
-                  plugin.preprocess_html_tree
-                end
-              end
-              root = plugin.html_tree
-            end
-
-            coradoc = track_time "Converting input document tree to Coradoc tree" do
-              Converters.process_coradoc(root,
-                                         plugin_instances: plugin_instances)
-            end
-
-            coradoc = track_time "Post-process Coradoc tree" do
-              Postprocessor.process(coradoc)
-            end
-
-            plugin_instances.each do |plugin|
-              if plugin.respond_to?(:postprocess_coradoc_tree)
-                plugin.coradoc_tree = coradoc
-                track_time "Postprocessing Coradoc tree with #{plugin.name} plugin" do
-                  plugin.postprocess_coradoc_tree
-                end
-                coradoc = plugin.coradoc_tree
-              end
-            end
-
-            options[:plugin_instances] = plugin_instances unless options.frozen?
-
-            coradoc
-          end
-        end
-
-        def self.convert(input, options = {})
-          Input::Html.config.with(options) do
-            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, options)]
-                end
-              end
-            else
-              convert_single_coradoc_to_adoc(nil, coradoc, options)
-            end
-          end
-        end
-
-        def self.convert_single_coradoc_to_adoc(_file, coradoc, options)
-          prepare_plugin_instances(options)
-
-          result = track_time "Converting Coradoc tree into Asciidoc" do
-            Coradoc::Generator.gen_adoc(coradoc)
-          end
-          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
-            end
-
-            result
-          end
-        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 Input::Html.config.track_time
-            warn "  " * @track_time_indentation +
-              "* #{task} is starting..."
-            @track_time_indentation += 1
-            t0 = Time.now
-            ret = yield
-            time_elapsed = Time.now - t0
-            @track_time_indentation -= 1
-            warn "  " * @track_time_indentation +
-              "* #{task} took #{time_elapsed.round(3)} seconds"
-            ret
-          else
-            yield
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-module Coradoc
-  module Input
-    module Html
-      class Plugin
-        #### Plugin system general
-
-        # Allow building plugins with a shorthand syntax:
-        # plugin = Coradoc::Input::Html::Plugin.new do
-        #   def name = "Test"
-        # end
-
-        def self.new(&)
-          if self == Plugin
-            Class.new(Plugin, &)
-          else
-            super
-          end
-        end
-
-        def initialize
-          @html_tree_hooks_pre = {}
-          @html_tree_hooks_post = {}
-        end
-
-        # define name to name a Plugin
-        def name
-          self.class.name
-        end
-
-        #### HTML Tree functionalities
-
-        attr_accessor :html_tree, :coradoc_tree, :asciidoc_string
-
-        def html_tree_change_tag_name_by_css(css, new_name)
-          html_tree.css(css).each do |e|
-            e.name = new_name
-          end
-        end
-
-        def html_tree_change_properties_by_css(css, properties)
-          html_tree.css(css).each do |e|
-            properties.each do |k, v|
-              e[k.to_s] = v
-            end
-          end
-        end
-
-        def html_tree_remove_by_css(css)
-          html_tree.css(css).each(&:remove)
-        end
-
-        def html_tree_replace_with_children_by_css(css)
-          html_tree.css(css).each do |e|
-            e.replace(e.children)
-          end
-        end
-
-        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::Input::Html::Converters.process(tree, state)
-        end
-
-        def html_tree_preview
-          Tempfile.open(%w"coradoc .html") do |i|
-            i << html_tree.to_html
-            system "chromium-browser", "--no-sandbox", i.path
-          end
-        end
-
-        # define preprocess_html_tree to process HTML trees
-
-        # Creates a hook to be called instead of converting an element
-        # to a Coradoc node.
-        #
-        # proc |html_node, state|
-        #   coradoc_node
-        # end
-        def html_tree_add_hook_pre(element, &block)
-          @html_tree_hooks_pre[element] = block
-        end
-
-        def html_tree_add_hook_pre_by_css(css, &block)
-          html_tree.css(css).each do |e|
-            html_tree_add_hook_pre(e, &block)
-          end
-        end
-
-        # Creates a hook to be called after converting an element
-        # to a Coradoc node.
-        #
-        # proc |html_node, coradoc_node, state|
-        #   coradoc_node
-        # end
-        def html_tree_add_hook_post(element, &block)
-          @html_tree_hooks_post[element] = block
-        end
-
-        def html_tree_add_hook_post_by_css(css, &block)
-          html_tree.css(css).each do |e|
-            html_tree_add_hook_post(e, &block)
-          end
-        end
-
-        def html_tree_run_hooks(node, state, &_block)
-          hook_pre = @html_tree_hooks_pre[node]
-          hook_post = @html_tree_hooks_post[node]
-
-          coradoc = hook_pre.(node, state) if hook_pre
-          coradoc ||= yield node, state
-
-          if hook_post
-            coradoc = hook_post.(node, coradoc, state)
-          end
-
-          coradoc
-        end
-
-        #### Coradoc tree functionalities
-
-        # define postprocess_coradoc_tree to change coradoc tree
-
-        #### AsciiDoc string functionalities
-
-        # define postprocess_asciidoc_string to change the coradoc string
-      end
-    end
-  end
-end