coradoc 0.3.0 → 1.0.0

data/lib/coradoc/reverse_adoc/README.adoc

@@ -1,17 +1,13 @@
 = AsciiDoc from HTML and Microsoft Word: reverse_adoc
 
-https://github.com/metanorma/reverse_adoc[reverse_adoc] image:https://img.shields.io/gem/v/reverse_adoc.svg["Gem Version", link="https://rubygems.org/gems/reverse_adoc"]::
-image:https://github.com/metanorma/reverse_adoc/workflows/rake/badge.svg["Build Status", link="https://github.com/metanorma/reverse_adoc/actions?workflow=rake"]
-image:https://codeclimate.com/github/metanorma/reverse_adoc/badges/gpa.svg["Code Climate", link="https://codeclimate.com/github/metanorma/reverse_adoc"]
-image:https://img.shields.io/github/issues-pr-raw/metanorma/reverse_adoc.svg["Pull Requests", link="https://github.com/metanorma/reverse_adoc/pulls"]
-image:https://img.shields.io/github/commits-since/metanorma/reverse_adoc/latest.svg["Commits since latest",link="https://github.com/metanorma/reverse_adoc/releases"]
-
 == Purpose
 
 Transforms HTML and Microsoft Word into AsciiDoc.
 
 Based on https://github.com/xijo/reverse_markdown
 
+reverse_adoc used to be a separate Gem, but now it's part of Coradoc.
+
 
 == Installation
 
@@ -19,14 +15,14 @@ Install the gem:
 
 [source,console]
 ----
-[sudo] gem install reverse_adoc
+[sudo] gem install coradoc
 ----
 
 or add it to your `Gemfile`:
 
 [source,ruby]
 ----
-gem 'reverse_adoc'
+gem 'coradoc'
 ----
 
 
@@ -290,6 +286,16 @@ Coradoc::ReverseAdoc.config do |config|
 end
 ----
 
+=== Convert HTML to a Coradoc AST
+
+[source,ruby]
+----
+require 'coradoc/reverse_adoc'
+
+# Options can be supplied as keyword arguments
+Coradoc::ReverseAdoc::HtmlConverter.to_coradoc("<b><i>Some input</i></b>")
+----
+
 
 == Related stuff
 

data/lib/coradoc/reverse_adoc/cleaner.rb

@@ -1,11 +1,21 @@
 module Coradoc::ReverseAdoc
   class Cleaner
     def tidy(string)
-      result = remove_inner_whitespaces(String.new(string))
-      result = remove_newlines(result)
-      result = remove_leading_newlines(result)
-      result = clean_tag_borders(result)
-      clean_punctuation_characters(result)
+      result = HtmlConverter.track_time "Removing inner whitespace" do
+        remove_inner_whitespaces(String.new(string))
+      end
+      result = HtmlConverter.track_time "Removing newlines" do
+        remove_newlines(result)
+      end
+      result = HtmlConverter.track_time "Removing leading newlines" do
+        remove_leading_newlines(result)
+      end
+      result = HtmlConverter.track_time "Cleaning tag borders" do
+        clean_tag_borders(result)
+      end
+      result = HtmlConverter.track_time "Cleaning punctuation characters" do
+        clean_punctuation_characters(result)
+      end
     end
 
     def remove_newlines(string)
@@ -22,11 +32,13 @@ module Coradoc::ReverseAdoc
         string.gsub!(/(stem:\[([^\]]|\\\])*\])\n(?=\S)/, "\\1 ")
         string.gsub!(/(stem:\[([^\]]|\\\])*\])\s+(?=[\^-])/, "\\1")
       end
-      string.each_line.inject("") do |memo, line|
-        memo + preserve_border_whitespaces(line) do
+      result = +""
+      string.each_line do |line|
+        result << preserve_border_whitespaces(line) do
           line.strip.gsub(/[ \t]{2,}/, " ")
         end
       end
+      result
     end
 
     # Find non-asterisk content that is enclosed by two or
@@ -61,7 +73,7 @@ module Coradoc::ReverseAdoc
     end
 
     def clean_punctuation_characters(string)
-      string.gsub(/(\*\*|~~|__)\s([.!?'"])/, "#{'\\1'.strip}\\2")
+      string.gsub(/(\*\*|~~|__)\s([.!?'"])/, "\\1\\2")
     end
 
     # preprocesses HTML, rather than postprocessing it

data/lib/coradoc/reverse_adoc/config.rb

@@ -2,9 +2,6 @@ require "tmpdir"
 
 module Coradoc::ReverseAdoc
   class Config
-    attr_accessor :unknown_tags, :tag_border, :mathml2asciimath, :external_images,
-                  :destination, :sourcedir, :image_counter, :image_counter_pattern, :input_format
-
     def initialize
       @unknown_tags     = :pass_through
       @input_format     = :html
@@ -26,29 +23,51 @@ module Coradoc::ReverseAdoc
       @strong_delimiter = "*".freeze
       @inline_options   = {}
       @tag_border       = " ".freeze
+
+      @split_sections   = nil
+
+      # Document width - used to compute table sizes.
+      # This is an assumption for screen size in input document.
+      # If column widths are specified in absolute values, then we
+      # have to convert them to relative values, as AsciiDoc only
+      # supports those.
+      @doc_width        = 1000
+
+      # Plugin system
+      @plugins          = []
+
+      # Debugging options
+      @track_time       = false
     end
 
     def with(options = {})
+      old_options = @inline_options
       @inline_options = options
       result = yield
-      @inline_options = {}
+      @inline_options = old_options
       result
     end
 
-    def unknown_tags
-      @inline_options[:unknown_tags] || @unknown_tags
-    end
-
-    def mathml2asciimath
-      @inline_options[:mathml2asciimath] || @mathml2asciimath
-    end
+    def self.declare_option(option)
+      define_method(option) do
+        @inline_options[option] || instance_variable_get(:"@#{option}")
+      end
 
-    def external_images
-      @inline_options[:external_images] || @external_images
+      attr_writer option
     end
 
-    def tag_border
-      @inline_options[:tag_border] || @tag_border
-    end
+    declare_option :unknown_tags
+    declare_option :tag_border
+    declare_option :mathml2asciimath
+    declare_option :external_images
+    declare_option :destination
+    declare_option :sourcedir
+    declare_option :image_counter
+    declare_option :image_counter_pattern
+    declare_option :input_format
+    declare_option :split_sections
+    declare_option :doc_width
+    declare_option :plugins
+    declare_option :track_time
   end
 end

data/lib/coradoc/reverse_adoc/converters/a.rb

@@ -11,29 +11,34 @@ module Coradoc::ReverseAdoc
         id = node["id"] || node["name"]
 
         id = id&.gsub(/\s/, "")&.gsub(/__+/, "_")
+        id = nil if id&.empty?
 
         return "" if /^_Toc\d+$|^_GoBack$/.match?(id)
 
-        if !id.nil? && !id.empty?
-          return Coradoc::Element::Inline::Anchor.new(id)
-        end
+        return Coradoc::Element::Inline::Anchor.new(id) if id
 
         if href.to_s.start_with?("#")
           href = href.sub(/^#/, "").gsub(/\s/, "").gsub(/__+/, "_")
           return Coradoc::Element::Inline::CrossReference.new(href, name)
         end
 
-        if href.to_s.empty?
-          return name
-        end
+        return name if href.to_s.empty?
 
-        Coradoc::Element::Inline::Link.new(path: href,
-                                           name: name,
-                                           title: title)
-      end
+        ambigous_characters = /[\w.?&#=%;\[\u{ff}-\u{10ffff}]/
+        if name&.strip == href
+          name = ""
+          right_constrain = textnode_after_start_with?(node, ambigous_characters)
+        end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+        out = []
+        out << " " if textnode_before_end_with?(node, ambigous_characters)
+        out << Coradoc::Element::Inline::Link.new(
+          path: href,
+          name: name.strip,
+          title: title.strip,
+          right_constrain: right_constrain,
+        )
+        out
       end
     end
 

data/lib/coradoc/reverse_adoc/converters/aside.rb

@@ -5,10 +5,6 @@ module Coradoc::ReverseAdoc
         content = treat_children(node, state)
         Coradoc::Element::Block::Side.new(lines: content.lines)
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :aside, Aside.new

data/lib/coradoc/reverse_adoc/converters/audio.rb

@@ -12,10 +12,6 @@ module Coradoc::ReverseAdoc
                                            attributes: attributes)
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
-
       def options(node)
         autoplay = node["autoplay"]
         loop_attr = node["loop"]

data/lib/coradoc/reverse_adoc/converters/base.rb

@@ -1,6 +1,14 @@
 module Coradoc::ReverseAdoc
   module Converters
     class Base
+      # Default implementation to convert a given Nokogiri node
+      # to an AsciiDoc script.
+      # Can be overriden by subclasses.
+      def convert(node, state = {})
+        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      end
+
+      # Note: treat_children won't run plugin hooks
       def treat_children(node, state)
         node.children.inject("") do |memo, child|
           memo << treat(child, state)
@@ -8,7 +16,7 @@ module Coradoc::ReverseAdoc
       end
 
       def treat(node, state)
-        Coradoc::ReverseAdoc::Converters.lookup(node.name).convert(node, state)
+        Converters.process(node, state)
       end
 
       def treat_children_coradoc(node, state)
@@ -18,21 +26,13 @@ module Coradoc::ReverseAdoc
       end
 
       def treat_coradoc(node, state)
-        Coradoc::ReverseAdoc::Converters.lookup(node.name).to_coradoc(node, state)
-      end
-
-      def escape_keychars(string)
-        subs = { "*" => '\*', "_" => '\_' }
-        string
-          .gsub(/((?<=\s)[\*_]+)|[\*_]+(?=\s)/) do |n|
-          n.chars.map do |char|
-            subs[char]
-          end.join
-        end
+        Converters.process_coradoc(node, state)
       end
 
       def extract_title(node)
-        title = escape_keychars(node["title"].to_s)
+        title = Coradoc::Element::TextElement.escape_keychars(
+          node["title"].to_s,
+        )
         title.empty? ? "" : %[ #{title}]
       end
 
@@ -46,10 +46,43 @@ module Coradoc::ReverseAdoc
       end
 
       def textnode_before_end_with?(node, str)
-        return nil if !str.is_a?(String) || str.empty?
+        return nil unless [String, Regexp].include?(str.class)
+        return nil if str.is_a?(String) && str.empty?
+
+        str = /#{Regexp.escape(str)}/ if str.is_a?(String)
+        str = /(?:#{str})\z/
 
         node2 = node.at_xpath("preceding-sibling::node()[1]")
-        node2.respond_to?(:text) && node2.text.end_with?(str)
+        node2.respond_to?(:text) && node2.text.match?(str)
+      end
+
+      def textnode_after_start_with?(node, str)
+        return nil unless [String, Regexp].include?(str.class)
+        return nil if str.is_a?(String) && str.empty?
+
+        str = /#{Regexp.escape(str)}/ if str.is_a?(String)
+        str = /\A(?:#{str})/
+
+        node2 = node.at_xpath("following-sibling::node()[1]")
+        node2.respond_to?(:text) && node2.text.match?(str)
+      end
+
+      def extract_leading_trailing_whitespace(node)
+        node.text =~ /^(\s+)/
+        leading_whitespace = $1
+        if !leading_whitespace.nil?
+          first_text = node.at_xpath("./text()[1]")
+          first_text.replace(first_text.text.lstrip)
+          leading_whitespace = " "
+        end
+        node.text =~ /(\s+)$/
+        trailing_whitespace = $1
+        if !trailing_whitespace.nil?
+          last_text = node.at_xpath("./text()[last()]")
+          last_text.replace(last_text.text.rstrip)
+          trailing_whitespace = " "
+        end
+        [leading_whitespace, trailing_whitespace]
       end
 
       def unconstrained_before?(node)
@@ -60,41 +93,12 @@ module Coradoc::ReverseAdoc
           before.text[-1]&.match?(/\w/)
       end
 
-      # TODO: This logic ought to be cleaned up.
       def unconstrained_after?(node)
         after = node.at_xpath("following::node()[1]")
 
         after && !after.text.strip.empty? &&
           after.text[0]&.match?(/\w|,|;|"|\.\?!/)
       end
-
-      # def trailing_whitespace?(node)
-
-      # TODO: This logic ought to be cleaned up.
-      def constrained?(node)
-        before = node.at_xpath("preceding::node()[1]").to_s[-1]
-        before = if before
-                   before&.match?(/\s/) ? true : false
-                 else
-                   true
-                 end
-
-        if !before && (node.to_s[0] =~ /\s/)
-          before = true
-        end
-
-        after = node.at_xpath("following::node()[1]").to_s[0]
-        after = if after
-                  after&.match?(/\s|,|;|"|\.\?!/) ? true : false
-                else
-                  true
-                end
-        if !after && (node.to_s[-1] =~ /\s/)
-          after = true
-        end
-
-        before && after
-      end
     end
   end
 end

data/lib/coradoc/reverse_adoc/converters/blockquote.rb

@@ -4,22 +4,13 @@ module Coradoc::ReverseAdoc
       def to_coradoc(node, state = {})
         node["id"]
         cite = node["cite"]
-        attributes = if cite.nil?
-                       nil
-                     else
-                       Coradoc::Element::AttributeList.new(
-                         "quote", cite
-                       )
-                     end
+        attributes = Coradoc::Element::AttributeList.new
+        attributes.add_positional("quote", cite) if !cite.nil?
         content = treat_children(node, state).strip
         content = Coradoc::ReverseAdoc.cleaner.remove_newlines(content)
         Coradoc::Element::Block::Quote.new(nil, lines: content,
                                                 attributes: attributes)
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :blockquote, Blockquote.new

data/lib/coradoc/reverse_adoc/converters/br.rb

@@ -4,10 +4,6 @@ module Coradoc::ReverseAdoc
       def to_coradoc(_node, _state = {})
         Coradoc::Element::Inline::HardLineBreak.new
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :br, Br.new

data/lib/coradoc/reverse_adoc/converters/bypass.rb

@@ -4,10 +4,6 @@ module Coradoc::ReverseAdoc
       def to_coradoc(node, state = {})
         treat_children_coradoc(node, state)
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :document, Bypass.new

data/lib/coradoc/reverse_adoc/converters/code.rb

@@ -1,49 +1,12 @@
 module Coradoc::ReverseAdoc
   module Converters
-    class Code < Base
-      def to_coradoc(node, state = {})
-        content = treat_children_coradoc(node, state)
-
-        if Coradoc::Generator.gen_adoc(content).strip.empty?
-          return ""
-        end
-
-        if node_has_ancestor?(node, ["code", "tt", "kbd", "samp", "var"])
-          return content
-        end
-
-        node.text =~ /^(\s+)/
-        leading_whitespace = $1
-        has_leading_whitespace = !leading_whitespace.nil?
-
-        if has_leading_whitespace
-          first_text = node.at_xpath("./text()[1]")
-          first_text.replace(first_text.text.lstrip)
-          leading_whitespace = " "
-        end
-
-        node.text =~ /(\s+)$/
-        trailing_whitespace = $1
-        has_trailing_whitespace = !trailing_whitespace.nil?
-
-        if has_trailing_whitespace
-          last_text = node.at_xpath("./text()[last()]")
-          last_text.replace(last_text.text.rstrip)
-          trailing_whitespace = " "
-        end
-
-        u_before = unconstrained_before?(node)
-        u_after = unconstrained_after?(node)
-        u = !((!u_before || has_leading_whitespace) && (!u_after || has_trailing_whitespace))
-        e = Coradoc::Element::Inline::Monospace.new(
-          Coradoc::Element::TextElement.new(content), u
-        )
-
-        [leading_whitespace, e, trailing_whitespace]
+    class Code < Markup
+      def coradoc_class
+        Coradoc::Element::Inline::Monospace
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      def markup_ancestor_tag_names
+        %w[code tt kbd samp var]
       end
     end
 

data/lib/coradoc/reverse_adoc/converters/div.rb

@@ -6,10 +6,6 @@ module Coradoc::ReverseAdoc
         contents = treat_children_coradoc(node, state)
         Coradoc::Element::Section.new(nil, id: id, contents: contents)
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :div,     Div.new

data/lib/coradoc/reverse_adoc/converters/dl.rb

@@ -0,0 +1,55 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Dl < Base
+      def to_coradoc(node, state = {})
+        items = process_dl(node, state)
+        items2 = items.map do |item|
+          Coradoc::Element::ListItemDefinition.new(item[:name], item[:value])
+        end
+        Coradoc::Element::List::Definition.new(items2, delimiter: "::")
+      end
+
+      def process_dl(node, state = {})
+        groups = []
+        current = {name: [], value: []}
+
+        seen_dd = false
+        child = node.at_xpath("*[1]")
+        grandchild = nil
+        while !child.nil?
+          if child.name == "div"
+            grandchild = child.at_xpath("*[1]")
+            while !grandchild.nil?
+              groups, current, seen_dd = process_dt_or_dd(groups, current, seen_dd, grandchild, state)
+              grandchild = grandchild.at_xpath("following-sibling::*[1]")
+            end
+          elsif ["dt", "dd"].include?(child.name)
+            groups, current, seen_dd = process_dt_or_dd(groups, current, seen_dd, child, state)
+          end
+          child = child.at_xpath("following-sibling::*[1]")
+          if current[:name].any? && current[:value].any?
+            groups << current
+          end
+        end
+        groups
+      end
+
+      def process_dt_or_dd(groups, current, seen_dd, subnode, state = {})
+        if subnode.name == "dt"
+          if seen_dd
+            # groups << current
+            current = {name: [], value: []}
+            seen_dd = false
+          end
+          current[:name] += treat_children_coradoc(subnode, state)
+        elsif subnode.name == "dd"
+          current[:value] += treat_children_coradoc(subnode, state)
+          seen_dd = true
+        end
+        [groups, current, seen_dd]
+      end
+    end
+
+    register :dl, Dl.new
+  end
+end

data/lib/coradoc/reverse_adoc/converters/em.rb

@@ -1,50 +1,12 @@
 module Coradoc::ReverseAdoc
   module Converters
-    class Em < Base
-      def to_coradoc(node, state = {})
-        content = treat_children_coradoc(node,
-                                         state.merge(already_italic: true))
-
-        if Coradoc::Generator.gen_adoc(content).strip.empty?
-          return ""
-        end
-
-        if node_has_ancestor?(node, ["em", "i", "cite"])
-          return content
-        end
-
-        node.text =~ /^(\s+)/
-        leading_whitespace = $1
-        has_leading_whitespace = !leading_whitespace.nil?
-
-        if has_leading_whitespace
-          first_text = node.at_xpath("./text()[1]")
-          first_text.replace(first_text.text.lstrip)
-          leading_whitespace = " "
-        end
-
-        node.text =~ /(\s+)$/
-        trailing_whitespace = $1
-        has_trailing_whitespace = !trailing_whitespace.nil?
-
-        if has_trailing_whitespace
-          last_text = node.at_xpath("./text()[last()]")
-          last_text.replace(last_text.text.rstrip)
-          trailing_whitespace = " "
-        end
-
-        u_before = unconstrained_before?(node)
-        u_after = unconstrained_after?(node)
-        u = !((!u_before || has_leading_whitespace) && (!u_after || has_trailing_whitespace))
-        e = Coradoc::Element::Inline::Italic.new(
-          Coradoc::Element::TextElement.new(content), u
-        )
-
-        [leading_whitespace, e, trailing_whitespace]
+    class Em < Markup
+      def coradoc_class
+        Coradoc::Element::Inline::Italic
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
+      def markup_ancestor_tag_names
+        %w[em i cite]
       end
     end
 

data/lib/coradoc/reverse_adoc/converters/figure.rb

@@ -8,10 +8,6 @@ module Coradoc::ReverseAdoc
         Coradoc::Element::Block::Example.new(title, lines: content, id: id)
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
-
       def extract_title(node)
         title = node.at("./figcaption")
         return "" if title.nil?

data/lib/coradoc/reverse_adoc/converters/h.rb

@@ -15,10 +15,6 @@ module Coradoc::ReverseAdoc
         Coradoc::Element::Title.new(content, level, id: id)
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
-
       def treat_children_no_anchors(node, state)
         node.children.reject { |a| a.name == "a" }.inject([]) do |memo, child|
           memo << treat_coradoc(child, state)

data/lib/coradoc/reverse_adoc/converters/head.rb

@@ -6,10 +6,6 @@ module Coradoc::ReverseAdoc
         Coradoc::Element::Header.new(title)
       end
 
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
-
       def extract_title(node)
         title = node.at("./title")
         return "(???)" if title.nil?

data/lib/coradoc/reverse_adoc/converters/hr.rb

@@ -4,10 +4,6 @@ module Coradoc::ReverseAdoc
       def to_coradoc(_node, _state = {})
         Coradoc::Element::Break::ThematicBreak.new
       end
-
-      def convert(node, state = {})
-        Coradoc::Generator.gen_adoc(to_coradoc(node, state))
-      end
     end
 
     register :hr, Hr.new