coradoc 1.1.5 → 1.1.7

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

@@ -1,60 +1,65 @@
-module Coradoc::Input::HTML
-  module Converters
-    class Ol < Base
-      # FIXIT
-      def to_coradoc(node, state = {})
-        # convert(node, state)
-        id = node["id"]
-        ol_count = state.fetch(:ol_count, 0) + 1
-        attrs = ol_attrs(node)
-        items = treat_children_coradoc(node, state.merge(ol_count: ol_count))
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Ol < Base
+          # FIXIT
+          def to_coradoc(node, state = {})
+            # convert(node, state)
+            id = node["id"]
+            ol_count = state.fetch(:ol_count, 0) + 1
+            attrs = ol_attrs(node)
+            items = treat_children_coradoc(node,
+                                           state.merge(ol_count: ol_count))
 
-        options = {}.tap do |hash|
-          hash[:id] = id
-          hash[:ol_count] = ol_count
-          hash[:attrs] = attrs
-        end
+            options = {}.tap do |hash|
+              hash[:id] = id
+              hash[:ol_count] = ol_count
+              hash[:attrs] = attrs
+            end
 
-        case get_list_type(node, state)
-        when :ordered
-          Coradoc::Element::List::Ordered.new(items, options)
-        when :unordered
-          Coradoc::Element::List::Unordered.new(items, options)
-        end
-      end
+            case get_list_type(node, state)
+            when :ordered
+              Coradoc::Element::List::Ordered.new(items, options)
+            when :unordered
+              Coradoc::Element::List::Unordered.new(items, options)
+            end
+          end
 
-      def get_list_type(node, _state)
-        case node.name
-        when "ol"
-          :ordered
-        when "ul"
-          :unordered
-        end
-      end
+          def get_list_type(node, _state)
+            case node.name
+            when "ol"
+              :ordered
+            when "ul"
+              :unordered
+            end
+          end
+
+          def number_style(node)
+            case node["style"]
+            when "1" then "arabic"
+            when "A" then "upperalpha"
+            when "a" then "loweralpha"
+            when "I" then "upperroman"
+            when "i" then "lowerroman"
+            end
+          end
 
-      def number_style(node)
-        case node["style"]
-        when "1" then "arabic"
-        when "A" then "upperalpha"
-        when "a" then "loweralpha"
-        when "I" then "upperroman"
-        when "i" then "lowerroman"
+          def ol_attrs(node)
+            attrs = Coradoc::Element::AttributeList.new
+            style = number_style(node)
+            attrs.add_positional(style) if style
+            attrs.add_positional("%reversed") if node["reversed"]
+            attrs.add_named("start", node["start"]) if node["start"]
+            attrs.add_named("type", node["type"]) if node["type"]
+            attrs
+          end
         end
-      end
 
-      def ol_attrs(node)
-        attrs = Coradoc::Element::AttributeList.new
-        style = number_style(node)
-        attrs.add_positional(style) if style
-        attrs.add_positional("%reversed") if node["reversed"]
-        attrs.add_named("start", node["start"]) if node["start"]
-        attrs.add_named("type", node["type"]) if node["type"]
-        attrs
+        register :ol, Ol.new
+        register :ul, Ol.new
+        register :dir, Ol.new
       end
     end
-
-    register :ol, Ol.new
-    register :ul, Ol.new
-    register :dir, Ol.new
   end
 end

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

@@ -1,19 +1,23 @@
-module Coradoc::Input::HTML
-  module Converters
-    class P < Base
-      def to_coradoc(node, state = {})
-        id = node["id"]
-        content = treat_children_coradoc(node, state)
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class P < Base
+          def to_coradoc(node, state = {})
+            id = node["id"]
+            content = treat_children_coradoc(node, state)
 
-        options = {}.tap do |hash|
-          hash[:id] = id if id
-          hash[:tdsinglepara] = true if state[:tdsinglepara]
+            options = {}.tap do |hash|
+              hash[:id] = id if id
+              hash[:tdsinglepara] = true if state[:tdsinglepara]
+            end
+
+            Coradoc::Element::Paragraph.new(content, options)
+          end
         end
 
-        Coradoc::Element::Paragraph.new(content, options)
+        register :p, P.new
       end
     end
-
-    register :p, P.new
   end
 end

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

@@ -1,12 +1,16 @@
-module Coradoc::Input::HTML
-  module Converters
-    class PassThrough < Base
-      def to_coradoc(node, _state = {})
-        node.to_s
-      end
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class PassThrough < Base
+          def to_coradoc(node, _state = {})
+            node.to_s
+          end
 
-      def convert(node, state = {})
-        to_coradoc(node, state)
+          def convert(node, state = {})
+            to_coradoc(node, state)
+          end
+        end
       end
     end
   end

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

@@ -1,51 +1,55 @@
-module Coradoc::Input::HTML
-  module Converters
-    class Pre < Base
-      def to_coradoc(node, state = {})
-        id = node["id"]
-        lang = language(node)
-        content = treat_children(node, state)
-
-        unless lang
-          return Coradoc::Element::Block::Literal.new(
-            nil,
-            lines: content,
-            id: id,
-          )
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Pre < Base
+          def to_coradoc(node, state = {})
+            id = node["id"]
+            lang = language(node)
+            content = treat_children(node, state)
+
+            unless lang
+              return Coradoc::Element::Block::Literal.new(
+                nil,
+                lines: content,
+                id: id,
+              )
+            end
+
+            Coradoc::Element::Block::SourceCode.new(
+              nil,
+              lines: content,
+              lang: lang,
+              id: id,
+            )
+          end
+
+          private
+
+          def treat(node, _state)
+            return "\n" if node.name == "br"
+
+            prefix = postfix = "\n\n" if node.name == "p"
+
+            "#{prefix}#{node.text}#{postfix}"
+          end
+
+          def language(node)
+            lang = language_from_highlight_class(node)
+            lang || language_from_confluence_class(node)
+          end
+
+          def language_from_highlight_class(node)
+            node.parent["class"].to_s[/highlight-([a-zA-Z0-9]+)/, 1]
+          end
+
+          def language_from_confluence_class(node)
+            node["class"].to_s[/brush:\s?(:?.*);/, 1]
+          end
         end
 
-        Coradoc::Element::Block::SourceCode.new(
-          nil,
-          lines: content,
-          lang: lang,
-          id: id,
-        )
-      end
-
-      private
-
-      def treat(node, _state)
-        return "\n" if node.name == "br"
-
-        prefix = postfix = "\n\n" if node.name == "p"
-
-        "#{prefix}#{node.text}#{postfix}"
-      end
-
-      def language(node)
-        lang = language_from_highlight_class(node)
-        lang || language_from_confluence_class(node)
-      end
-
-      def language_from_highlight_class(node)
-        node.parent["class"].to_s[/highlight-([a-zA-Z0-9]+)/, 1]
-      end
-
-      def language_from_confluence_class(node)
-        node["class"].to_s[/brush:\s?(:?.*);/, 1]
+        register :pre, Pre.new
       end
     end
-
-    register :pre, Pre.new
   end
 end

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

@@ -1,12 +1,16 @@
-module Coradoc::Input::HTML
-  module Converters
-    class Q < Base
-      def to_coradoc(node, state = {})
-        content = treat_children(node, state)
-        Coradoc::Element::Inline::Quotation.new(content)
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Q < Base
+          def to_coradoc(node, state = {})
+            content = treat_children(node, state)
+            Coradoc::Element::Inline::Quotation.new(content)
+          end
+        end
+
+        register :q, Q.new
       end
     end
-
-    register :q, Q.new
   end
 end

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

@@ -1,16 +1,20 @@
-module Coradoc::Input::HTML
-  module Converters
-    class Strong < Markup
-      def coradoc_class
-        Coradoc::Element::Inline::Bold
-      end
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Strong < Markup
+          def coradoc_class
+            Coradoc::Element::Inline::Bold
+          end
+
+          def markup_ancestor_tag_names
+            %w[strong b]
+          end
+        end
 
-      def markup_ancestor_tag_names
-        %w[strong b]
+        register :strong, Strong.new
+        register :b,      Strong.new
       end
     end
-
-    register :strong, Strong.new
-    register :b,      Strong.new
   end
 end

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

@@ -1,18 +1,22 @@
-module Coradoc::Input::HTML
-  module Converters
-    class Sub < Base
-      def to_coradoc(node, state = {})
-        leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
+module Coradoc
+  module Input
+    module Html
+      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)
+            content = treat_children_coradoc(node, state)
 
-        return content if Coradoc::Generator.gen_adoc(content).strip.empty?
+            return content if Coradoc::Generator.gen_adoc(content).strip.empty?
 
-        e = Coradoc::Element::Inline::Subscript.new(content)
-        [leading_whitespace, e, trailing_whitespace]
+            e = Coradoc::Element::Inline::Subscript.new(content)
+            [leading_whitespace, e, trailing_whitespace]
+          end
+        end
+
+        register :sub, Sub.new
       end
     end
-
-    register :sub, Sub.new
   end
 end

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

@@ -1,18 +1,22 @@
-module Coradoc::Input::HTML
-  module Converters
-    class Sup < Base
-      def to_coradoc(node, state = {})
-        leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Sup < Base
+          def to_coradoc(node, state = {})
+            leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
 
-        content = treat_children_coradoc(node, state)
+            content = treat_children_coradoc(node, state)
 
-        return content if Coradoc::Generator.gen_adoc(content).strip.empty?
+            return content if Coradoc::Generator.gen_adoc(content).strip.empty?
 
-        e = Coradoc::Element::Inline::Superscript.new(content)
-        [leading_whitespace, e, trailing_whitespace]
+            e = Coradoc::Element::Inline::Superscript.new(content)
+            [leading_whitespace, e, trailing_whitespace]
+          end
+        end
+
+        register :sup, Sup.new
       end
     end
-
-    register :sup, Sup.new
   end
 end

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

@@ -1,4 +1,5 @@
-module Coradoc::Input::HTML
+module Coradoc::Input
+  module Html
   module Converters
     class Table < Base
       def to_coradoc(node, state = {})
@@ -61,7 +62,8 @@ module Coradoc::Input::HTML
 
           # 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"] }
+          unless header.xpath("./td | ./th").all? { |i|
+ [nil, "1", ""].include? i["rowspan"] }
             attrs.add_named("options", ["noheader"])
           end
         end
@@ -102,10 +104,10 @@ module Coradoc::Input::HTML
           return ensure_row_column_integrity_and_get_column_sizes(node)
         end
 
-        fits_in_cell_matrix = proc do |y,x,rowspan,colspan|
+        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)
+              !cell_matrix.dig(y + yy, x + xx)
             end
           end
         end
@@ -124,7 +126,8 @@ module Coradoc::Input::HTML
             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)
+            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
@@ -134,7 +137,7 @@ module Coradoc::Input::HTML
               cell_references[i + j] ||= []
               cell_matrix[i + j] ||= []
               colspan.times do |k|
-                cell_references[i + j] << [cell, k > 0]
+                cell_references[i + j] << [cell, k.positive?]
                 cell_matrix[i + j][column_id] = cell
                 column_id += 1
               end
@@ -225,7 +228,7 @@ module Coradoc::Input::HTML
           recompute.() if needs_recompute
 
           # But otherwise... we've got a really nasty table.
-          warn <<~WARNING.gsub("\n", " ")
+          warn <<~WARNING.tr("\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
@@ -236,7 +239,7 @@ module Coradoc::Input::HTML
         # Compute column sizes
         column_sizes = []
         cell_matrix.each do |row|
-          row.each_with_index do |(cell,_), i|
+          row.each_with_index do |(cell, _), i|
             next unless !cell || [nil, "", "1"].include?(cell["colspan"])
 
             column_sizes[i] ||= []
@@ -244,7 +247,7 @@ module Coradoc::Input::HTML
           end
         end
 
-        document_width = Coradoc::Input::HTML.config.doc_width.to_r
+        document_width = Coradoc::Input::Html.config.doc_width.to_r
 
         column_sizes += [nil] * (cpr.first - column_sizes.length)
 
@@ -271,8 +274,12 @@ module Coradoc::Input::HTML
         # 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
+          if i.zero?
+            document_width / 3 / sizes.length
+          else
+            i
+          end
+        }.sum > document_width
 
           sizes = sizes.map { |i| i * 4 / 5 }
         end
@@ -290,11 +297,11 @@ module Coradoc::Input::HTML
         end
 
         # Scale to integers
-        lcm = sizes.map(&:denominator).inject(1) { |i,j| i.lcm(j) }
+        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) }
+        gcd = sizes.inject(sizes.first) { |i, j| i.gcd(j) }
         sizes = sizes.map { |i| i / gcd }
 
         # Try to generate a shorter definition
@@ -308,4 +315,5 @@ module Coradoc::Input::HTML
 
     register :table, Table.new
   end
+  end
 end

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

@@ -1,77 +1,81 @@
-module Coradoc::Input::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)
+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
+            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
+            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
+            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
 
-      def cellstyle(_node)
-        ""
-      end
+            Coradoc::Element::Table::Cell.new(options)
+          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 cellstyle(_node)
+            ""
+          end
 
-      def alignstyle(node)
-        align = node["align"]
-        valign = node["valign"]
-        a = case align
-            when "left" then "<"
-            when "center" then "^"
-            when "right" then ">"
+          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
-        v = case valign
-            when "top" then "<"
-            when "middle" then "^"
-            when "bottom" then ">"
+          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
-        if align && valign
-          "#{a}.#{v}"
-        elsif align
-          a
-        elsif valign
-          ".#{v}"
-        else
-          ""
+          end
         end
+
+        register :td, Td.new
       end
     end
-
-    register :td, Td.new
   end
 end