coradoc 0.2.0 → 1.0.0

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

@@ -0,0 +1,47 @@
+require "coradoc"
+
+module Coradoc::ReverseAdoc
+  module Converters
+    class A < Base
+      def to_coradoc(node, state = {})
+        name  = treat_children(node, state)
+
+        href  = node["href"]
+        title = extract_title(node)
+        id = node["id"] || node["name"]
+
+        id = id&.gsub(/\s/, "")&.gsub(/__+/, "_")
+        id = nil if id&.empty?
+
+        return "" if /^_Toc\d+$|^_GoBack$/.match?(id)
+
+        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
+
+        return name if href.to_s.empty?
+
+        ambigous_characters = /[\w.?&#=%;\[\u{ff}-\u{10ffff}]/
+        if name&.strip == href
+          name = ""
+          right_constrain = textnode_after_start_with?(node, ambigous_characters)
+        end
+
+        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
+
+    register :a, A.new
+  end
+end

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

@@ -0,0 +1,12 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Aside < Base
+      def to_coradoc(node, state = {})
+        content = treat_children(node, state)
+        Coradoc::Element::Block::Side.new(lines: content.lines)
+      end
+    end
+
+    register :aside, Aside.new
+  end
+end

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

@@ -0,0 +1,25 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Audio < 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::Audio.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 :audio, Audio.new
+  end
+end

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

@@ -0,0 +1,104 @@
+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)
+        end
+      end
+
+      def treat(node, state)
+        Converters.process(node, state)
+      end
+
+      def treat_children_coradoc(node, state)
+        node.children.inject([]) do |memo, child|
+          memo << treat_coradoc(child, state)
+        end.flatten.reject { |x| x == "" || x.nil? }
+      end
+
+      def treat_coradoc(node, state)
+        Converters.process_coradoc(node, state)
+      end
+
+      def extract_title(node)
+        title = Coradoc::Element::TextElement.escape_keychars(
+          node["title"].to_s,
+        )
+        title.empty? ? "" : %[ #{title}]
+      end
+
+      def node_has_ancestor?(node, name)
+        case name
+        when String
+          node.ancestors.map(&:name).include?(name)
+        when Array
+          (node.ancestors.map(&:name) & name).any?
+        end
+      end
+
+      def textnode_before_end_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 = /(?:#{str})\z/
+
+        node2 = node.at_xpath("preceding-sibling::node()[1]")
+        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)
+        before = node.at_xpath("preceding::node()[1]")
+
+        before &&
+          !before.text.strip.empty? &&
+          before.text[-1]&.match?(/\w/)
+      end
+
+      def unconstrained_after?(node)
+        after = node.at_xpath("following::node()[1]")
+
+        after && !after.text.strip.empty? &&
+          after.text[0]&.match?(/\w|,|;|"|\.\?!/)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Blockquote < Base
+      def to_coradoc(node, state = {})
+        node["id"]
+        cite = node["cite"]
+        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
+    end
+
+    register :blockquote, Blockquote.new
+  end
+end

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

@@ -0,0 +1,11 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Br < Base
+      def to_coradoc(_node, _state = {})
+        Coradoc::Element::Inline::HardLineBreak.new
+      end
+    end
+
+    register :br, Br.new
+  end
+end

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

@@ -0,0 +1,77 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Bypass < Base
+      def to_coradoc(node, state = {})
+        treat_children_coradoc(node, state)
+      end
+    end
+
+    register :document, Bypass.new
+    register :html,     Bypass.new
+    register :body,     Bypass.new
+    register :span,     Bypass.new
+    register :thead,    Bypass.new
+    register :tbody,    Bypass.new
+    register :tfoot,    Bypass.new
+    register :abbr, Bypass.new
+    register :acronym,    Bypass.new
+    register :address,    Bypass.new
+    register :applet, Bypass.new
+    register :map, Bypass.new
+    register :area, Bypass.new
+    register :bdi,    Bypass.new
+    register :bdo,    Bypass.new
+    register :big,    Bypass.new
+    register :button,    Bypass.new
+    register :canvas,    Bypass.new
+    register :data, Bypass.new
+    register :datalist, Bypass.new
+    register :del,    Bypass.new
+    register :ins,    Bypass.new
+    register :dfn,    Bypass.new
+    register :dialog, Bypass.new
+    register :embed, Bypass.new
+    register :fieldset, Bypass.new
+    register :font, Bypass.new
+    register :footer, Bypass.new
+    register :form, Bypass.new
+    register :frame, Bypass.new
+    register :frameset, Bypass.new
+    register :header,    Bypass.new
+    register :iframe,    Bypass.new
+    register :input,    Bypass.new
+    register :label,    Bypass.new
+    register :legend, Bypass.new
+    register :main,    Bypass.new
+    register :menu,    Bypass.new
+    register :menulist, Bypass.new
+    register :meter, Bypass.new
+    register :nav, Bypass.new
+    register :noframes,    Bypass.new
+    register :noscript,    Bypass.new
+    register :object, Bypass.new
+    register :optgroup, Bypass.new
+    register :option,    Bypass.new
+    register :output,    Bypass.new
+    register :param, Bypass.new
+    register :picture, Bypass.new
+    register :progress, Bypass.new
+    register :ruby, Bypass.new
+    register :rt,    Bypass.new
+    register :rp,    Bypass.new
+    register :s, Bypass.new
+    register :select, Bypass.new
+    register :small, Bypass.new
+    register :span, Bypass.new
+    register :strike, Bypass.new
+    register :details,    Bypass.new
+    register :section,    Bypass.new
+    register :summary,    Bypass.new
+    register :svg, Bypass.new
+    register :template,    Bypass.new
+    register :textarea,    Bypass.new
+    register :track, Bypass.new
+    register :u, Bypass.new
+    register :wbr, Bypass.new
+  end
+end

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

@@ -0,0 +1,19 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Code < Markup
+      def coradoc_class
+        Coradoc::Element::Inline::Monospace
+      end
+
+      def markup_ancestor_tag_names
+        %w[code tt kbd samp var]
+      end
+    end
+
+    register :code, Code.new
+    register :tt, Code.new
+    register :kbd, Code.new
+    register :samp, Code.new
+    register :var, Code.new
+  end
+end

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

@@ -0,0 +1,14 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Div < Base
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        contents = treat_children_coradoc(node, state)
+        Coradoc::Element::Section.new(nil, id: id, contents: contents)
+      end
+    end
+
+    register :div,     Div.new
+    register :article, Div.new
+  end
+end

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/drop.rb

@@ -0,0 +1,22 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Drop < Base
+      def to_coradoc(node, state = {})
+        convert(node, state)
+      end
+
+      def convert(_node, _state = {})
+        ""
+      end
+    end
+
+    register :caption, Drop.new
+    register :figcaption, Drop.new
+    register :title, Drop.new
+    register :link, Drop.new
+    register :style, Drop.new
+    register :meta, Drop.new
+    register :script, Drop.new
+    register :comment, Drop.new
+  end
+end

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

@@ -0,0 +1,17 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Em < Markup
+      def coradoc_class
+        Coradoc::Element::Inline::Italic
+      end
+
+      def markup_ancestor_tag_names
+        %w[em i cite]
+      end
+    end
+
+    register :em, Em.new
+    register :i,  Em.new
+    register :cite, Em.new
+  end
+end

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

@@ -0,0 +1,21 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Figure < Base
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        title = extract_title(node)
+        content = treat_children_coradoc(node, state)
+        Coradoc::Element::Block::Example.new(title, lines: content, id: id)
+      end
+
+      def extract_title(node)
+        title = node.at("./figcaption")
+        return "" if title.nil?
+
+        treat_children_coradoc(title, {})
+      end
+    end
+
+    register :figure, Figure.new
+  end
+end

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

@@ -0,0 +1,38 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class H < Base
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        internal_anchor = treat_children_anchors(node, state)
+
+        if id.to_s.empty? && internal_anchor.size.positive?
+          id = internal_anchor.first.id
+        end
+
+        level = node.name[/\d/].to_i
+        content = treat_children_no_anchors(node, state)
+
+        Coradoc::Element::Title.new(content, level, id: id)
+      end
+
+      def treat_children_no_anchors(node, state)
+        node.children.reject { |a| a.name == "a" }.inject([]) do |memo, child|
+          memo << treat_coradoc(child, state)
+        end
+      end
+
+      def treat_children_anchors(node, state)
+        node.children.select { |a| a.name == "a" }.inject([]) do |memo, child|
+          memo << treat_coradoc(child, state)
+        end
+      end
+    end
+
+    register :h1, H.new
+    register :h2, H.new
+    register :h3, H.new
+    register :h4, H.new
+    register :h5, H.new
+    register :h6, H.new
+  end
+end

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

@@ -0,0 +1,19 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Head < Base
+      def to_coradoc(node, _state = {})
+        title = extract_title(node)
+        Coradoc::Element::Header.new(title)
+      end
+
+      def extract_title(node)
+        title = node.at("./title")
+        return "(???)" if title.nil?
+
+        title.text
+      end
+    end
+
+    register :head, Head.new
+  end
+end

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

@@ -0,0 +1,11 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Hr < Base
+      def to_coradoc(_node, _state = {})
+        Coradoc::Element::Break::ThematicBreak.new
+      end
+    end
+
+    register :hr, Hr.new
+  end
+end

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

@@ -0,0 +1,16 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Ignore < Base
+      def to_coradoc(node, state = {})
+        convert(node, state)
+      end
+
+      def convert(_node, _state = {})
+        "" # noop
+      end
+    end
+
+    register :colgroup, Ignore.new
+    register :col,      Ignore.new
+  end
+end

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

@@ -0,0 +1,98 @@
+require "fileutils"
+require "pathname"
+require "tempfile"
+require "base64"
+require "marcel"
+
+module Coradoc::ReverseAdoc
+  module Converters
+    class Img < Base
+      def image_number
+        sprintf(
+          Coradoc::ReverseAdoc.config.image_counter_pattern,
+          Coradoc::ReverseAdoc.config.image_counter,
+        )
+      end
+
+      def image_number_increment
+        Coradoc::ReverseAdoc.config.image_counter += 1
+      end
+
+      def datauri2file(src)
+        return unless src
+
+        %r{^data:image/(?:[^;]+);base64,(?<imgdata>.+)$} =~ src
+
+        dest_dir = Pathname.new(Coradoc::ReverseAdoc.config.destination).dirname
+        images_dir = dest_dir.join("images")
+        FileUtils.mkdir_p(images_dir)
+
+        ext, image_src_path, tempfile = determine_image_src_path(src, imgdata)
+        image_dest_path = images_dir + "#{image_number}.#{ext}"
+
+        # puts "image_dest_path: #{image_dest_path.to_s}"
+        # puts "image_src_path: #{image_src_path.to_s}"
+
+        FileUtils.cp(image_src_path, image_dest_path)
+        image_number_increment
+
+        image_dest_path.relative_path_from(dest_dir)
+      ensure
+        tempfile&.close!
+      end
+
+      def determine_image_src_path(src, imgdata)
+        return copy_temp_file(imgdata) if imgdata
+
+        ext = File.extname(src).strip.downcase[1..-1]
+        [ext, Pathname.new(Coradoc::ReverseAdoc.config.sourcedir).join(src)]
+      end
+
+      def copy_temp_file(imgdata)
+        f = Tempfile.open(["radoc", ".jpg"])
+        f.binmode
+        f.write(Base64.strict_decode64(imgdata))
+        f.rewind
+        ext = Marcel::MimeType.for(f).sub(%r{^[^/]+/}, "")
+        ext = "svg" if ext == "svg+xml"
+        [ext, f.path, f]
+      end
+
+      def to_coradoc(node, _state = {})
+        id = node["id"]
+        alt   = node["alt"]
+        src   = node["src"]
+        width = node["width"]
+        height = node["height"]
+
+        width = width.to_i if width&.match?(/\A\d+\z/)
+        height = height.to_i if height&.match?(/\A\d+\z/)
+
+        title = extract_title(node)
+
+        if Coradoc::ReverseAdoc.config.external_images
+          # puts "external image conversion #{id}, #{src}"
+          src = datauri2file(src)
+        end
+
+        attributes = Coradoc::Element::AttributeList.new
+        # attributes.add_named("id", id) if id
+        if alt # && !alt.to_s.empty?
+          attributes.add_positional(alt)
+        elsif width || height
+          attributes.add_positional(nil)
+        end
+        attributes.add_named("title", title) if title && !title.empty?
+        attributes.add_positional(width) if width
+        attributes.add_positional(height) if height
+
+        if src
+          Coradoc::Element::Image::BlockImage.new(title, id, src,
+                                                  attributes: attributes)
+        end
+      end
+    end
+
+    register :img, Img.new
+  end
+end

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

@@ -0,0 +1,13 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Li < Base
+      def to_coradoc(node, state = {})
+        id = node["id"]
+        content = treat_children_coradoc(node, state)
+        Coradoc::Element::ListItem.new(content, id: id)
+      end
+    end
+
+    register :li, Li.new
+  end
+end

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

@@ -0,0 +1,15 @@
+module Coradoc::ReverseAdoc
+  module Converters
+    class Mark < Markup
+      def coradoc_class
+        Coradoc::Element::Inline::Highlight
+      end
+
+      def markup_ancestor_tag_names
+        %w[mark]
+      end
+    end
+
+    register :mark, Mark.new
+  end
+end