coradoc 1.1.5 → 1.1.7

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

@@ -1,28 +1,32 @@
-module Coradoc::Input::HTML
-  module Converters
-    class Text < Base
-      def to_coradoc(node, state = {})
-        return treat_empty(node, state) if node.text.strip.empty?
+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
+            Coradoc::Element::TextElement.new(node.text, html_cleanup: true)
+          end
 
-      private
+          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
-          ""
+          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
-
-    register :text, Text.new
   end
 end

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

@@ -1,14 +1,18 @@
-module Coradoc::Input::HTML
-  module Converters
-    class Th < Td
-      def cellstyle(node)
-        # this is the header row
-        return "" if node.parent.previous_element.nil?
+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"
+            "h"
+          end
+        end
+
+        register :th, Th.new
       end
     end
-
-    register :th, Th.new
   end
 end

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

@@ -1,18 +1,22 @@
-module Coradoc::Input::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
+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
 
-      def table_header_row?(node)
-        # node.element_children.all? {|child| child.name.to_sym == :th}
-        node.previous_element.nil?
+        register :tr, Tr.new
       end
     end
-
-    register :tr, Tr.new
   end
 end

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

@@ -1,25 +1,29 @@
-module Coradoc::Input::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
+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
 
-      def options(node)
-        autoplay = node["autoplay"]
-        loop_attr = node["loop"]
-        controls = node["controls"]
-        [autoplay, loop_attr, controls].compact
+        register :video, Video.new
       end
     end
-
-    register :video, Video.new
   end
 end

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

@@ -1,55 +1,57 @@
 module Coradoc
-  module Input::HTML
-    module Converters
-      def self.register(tag_name, converter)
-        @@converters ||= {}
-        @@converters[tag_name.to_sym] = converter
-      end
+  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.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
+        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
+        # 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
+          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
+        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) }
+          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
-        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"
+        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

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

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

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

@@ -37,127 +37,130 @@ require_relative "converters/video"
 require_relative "converters/math"
 
 module Coradoc
-  module Input::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
+  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
-          end
 
-          return "" unless root
+            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
+            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
-            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 "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
+            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
+            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
-              coradoc = plugin.coradoc_tree
             end
-          end
 
-          options[:plugin_instances] = plugin_instances unless options.frozen?
+            options[:plugin_instances] = plugin_instances unless options.frozen?
 
-          coradoc
+            coradoc
+          end
         end
-      end
 
-      def self.convert(input, options = {})
-        Input::HTML.config.with(options) do
-          plugin_instances = prepare_plugin_instances(options)
+        def self.convert(input, options = {})
+          Input::Html.config.with(options) do
+            prepare_plugin_instances(options)
 
-          coradoc = to_coradoc(input, 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)]
+            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
-          else
-            convert_single_coradoc_to_adoc(nil, coradoc, options)
           end
         end
-      end
 
-      def self.convert_single_coradoc_to_adoc(_file, coradoc, options)
-        plugin_instances = prepare_plugin_instances(options)
+        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)
+          result = track_time "Converting Coradoc tree into Asciidoc" do
+            Coradoc::Generator.gen_adoc(coradoc)
+          end
+          cleanup_result(result, options)
         end
-        cleanup_result(result, options)
-      end
 
-      def self.cleanup_result(result, options)
-        Input::HTML.config.with(options) do
-          plugin_instances = prepare_plugin_instances(options)
+        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
+            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
-          end
 
-          result
+            result
+          end
         end
-      end
 
-      def self.prepare_plugin_instances(options)
-        options[:plugin_instances] || Coradoc::Input::HTML.config.plugins.map(&:new)
-      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
+        @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