coradoc 1.0.0 → 1.1.1

data/lib/coradoc/parser/base.rb

@@ -1,22 +1,55 @@
 require "parslet"
 require "parslet/convenience"
 
-require_relative "asciidoc/header"
+require_relative "asciidoc/attribute_list"
+require_relative "asciidoc/base"
+require_relative "asciidoc/block"
+require_relative "asciidoc/citation"
+require_relative "asciidoc/content"
 require_relative "asciidoc/document_attributes"
+require_relative "asciidoc/header"
+require_relative "asciidoc/inline"
+require_relative "asciidoc/list"
+require_relative "asciidoc/paragraph"
 require_relative "asciidoc/section"
+require_relative "asciidoc/table"
+require_relative "asciidoc/term"
 
 module Coradoc
   module Parser
     class Base < Parslet::Parser
-      include Coradoc::Parser::Asciidoc::Header
+      include Coradoc::Parser::Asciidoc::AttributeList
+      include Coradoc::Parser::Asciidoc::Base
+      include Coradoc::Parser::Asciidoc::Block
+      include Coradoc::Parser::Asciidoc::Citation
+      include Coradoc::Parser::Asciidoc::Content
       include Coradoc::Parser::Asciidoc::DocumentAttributes
+      include Coradoc::Parser::Asciidoc::Header
+      include Coradoc::Parser::Asciidoc::Inline
+      include Coradoc::Parser::Asciidoc::List
+      include Coradoc::Parser::Asciidoc::Paragraph
       include Coradoc::Parser::Asciidoc::Section
+      include Coradoc::Parser::Asciidoc::Table
+      include Coradoc::Parser::Asciidoc::Term
 
       root :document
       rule(:document) do
         (
-          document_attributess.as(:document_attributes) |
+          admonition_line |
+          bib_entry |
+          block_image |
+          term | term2 |
+          citation |
+          tag |
+          comment_block |
+          comment_line |
+          block.as(:block) |
           section.as(:section) |
+          include_directive |
+          document_attributes |
+          list |
+          table.as(:table) |
+          paragraph |
           header.as(:header) |
           empty_line.as(:line_break) |
           any.as(:unparsed)
@@ -25,7 +58,9 @@ module Coradoc
 
       def self.parse(filename)
         content = File.read(filename)
-        new.parse_with_debug(content)
+        new.parse(content)
+      rescue Parslet::ParseFailed => e
+        puts e.parse_failure_cause.ascii_tree
       end
     end
   end

data/lib/coradoc/transformer.rb

@@ -27,147 +27,413 @@ module Coradoc
       Element::Revision.new(number, date: date, remark: remark)
     end
 
+    # Comments
+    rule(comment_line: {comment_text: simple(:comment_text)}) {
+      Element::Comment::Line.new(comment_text)
+    }
+
+    rule(comment_block: {comment_text: simple(:comment_text)}) {
+      Element::Comment::Block.new(comment_text)
+    }
+
+    rule(tag: subtree(:tag)) {
+      opts = {}
+      opts[:prefix] = tag[:prefix]
+      opts[:attribute_list] = tag[:attribute_list]
+      opts[:line_break] = tag[:line_break]
+      Element::Tag.new(tag[:name], opts)
+    }
+
+    # AttributeList
+    class NamedAttribute < Struct.new(:key, :value); end
+
+    rule(:named => {named_key: simple(:key),
+      named_value: simple(:value)} ) {
+      NamedAttribute.new(key.to_s, value.to_s)
+    }
+
+    rule(positional: simple(:positional)){
+      positional.to_s
+    }
+
+    rule(attribute_array: nil){
+      Element::AttributeList.new
+    }
+
+    rule(attribute_array: sequence(:attributes)){
+      attr_list = Element::AttributeList.new
+      attributes.each do |a|
+        if a.is_a?(String)
+          attr_list.add_positional(a)
+        elsif a.is_a?(NamedAttribute)
+          attr_list.add_named(a[:key], a[:value])
+        end
+      end
+      attr_list
+    }
+
+    # Include
+    rule(include: {
+      path: simple(:path),
+      attribute_list: simple(:attribute_list),
+      line_break: simple(:line_break)}
+    ) {
+      Element::Include.new(
+        path.to_s,
+        attributes: attribute_list,
+        line_break: line_break)
+    }
+
+
     # Text Element
-    rule(text: simple(:text)) { Element::TextElement.new(text) }
+    rule(text: simple(:text)) {
+      Element::TextElement.new(text.to_s)
+    }
+
+    rule(text: simple(:text), line_break: simple(:line_break)) {
+      Element::TextElement.new(text.to_s, line_break: line_break)
+    }
+
     rule(id: simple(:id), text: simple(:text)) do
-      Element::TextElement.new(text, id: id)
+      Element::TextElement.new(text.to_s, id: id.to_s)
+    end
+
+    rule(text: sequence(:text)) {
+      Element::TextElement.new(text)
+    }
+
+    rule(
+      text: simple(:text),
+      line_break: simple(:line_break)
+    ) do
+      Element::TextElement.new(
+        text.to_s,
+        line_break: line_break)
+    end
+
+    rule(
+      id: simple(:id),
+      text: simple(:text),
+      line_break: simple(:line_break)
+    ) do
+      Element::TextElement.new(
+        text.to_s,
+        id: id,
+        line_break: line_break)
     end
 
-    rule(text: simple(:text), break: simple(:line_break)) do
-      Element::TextElement.new(text, line_break: line_break)
+    rule(
+      id: simple(:id),
+      text: sequence(:text),
+      line_break: simple(:line_break)
+    ) do
+      Element::TextElement.new(
+        text,
+        id: id,
+        line_break: line_break)
     end
 
-    rule(id: simple(:id), text: simple(:text), break: simple(:line_break)) do
-      Element::TextElement.new(text, id: id, line_break: line_break)
+    rule(text: sequence(:text),
+      line_break: simple(:line_break)
+    ) do
+      Element::TextElement.new(
+        text,
+        line_break: line_break)
     end
 
+    rule(href: simple(:href)){
+      Element::Inline::CrossReference.new(
+        href.to_s
+      )
+    }
+
+    rule(href: simple(:href),
+      name: simple(:name)
+    ){
+      Element::Inline::CrossReference.new(
+        href.to_s,
+        name.to_s
+      )
+    }
+
+    rule(bold_constrained: {
+      content: simple(:text)
+    }){
+      Element::Inline::Bold.new(text, unconstrained: false)
+    }
+
+    rule(bold_unconstrained: {content: simple(:text)}) {
+      Element::Inline::Bold.new(text, unconstrained: true)
+    }
+
+    rule(highlight_constrained: {content: simple(:text)}) {
+      Element::Inline::Highlight.new(text, unconstrained: false)
+    }
+    rule(highlight_unconstrained: {content: simple(:text)}) {
+      Element::Inline::Highlight.new(text, unconstrained: true)
+    }
+
+    rule(italic_constrained: {content: simple(:text)}) {
+      Element::Inline::Italic.new(text, unconstrained: false)
+    }
+    rule(italic_unconstrained: {content: simple(:text)}) {
+      Element::Inline::Italic.new(text, unconstrained: true)
+    }
+
+
     # Paragraph
-    rule(paragraph: simple(:paragraph)) { paragraph }
-    rule(lines: sequence(:lines)) { Element::Paragraph.new(lines) }
-    rule(meta: simple(:meta), lines: sequence(:lines)) do
-      Element::Paragraph.new(lines, meta: meta)
+    rule(paragraph: subtree(:paragraph)) do
+      Element::Paragraph.new(
+        paragraph[:lines],
+        id: paragraph[:id],
+        attributes: paragraph[:attribute_list],
+        title: paragraph[:title]
+        )
     end
 
+
+
     # Title Element
     rule(
       level: simple(:level),
       text: simple(:text),
-      break: simple(:line_break),
+      line_break: simple(:line_break),
     ) do
-      Element::Title.new(text, level, line_break: line_break)
+      Element::Title.new(text, level.size - 1, line_break: line_break)
     end
 
     rule(
       name: simple(:name),
       level: simple(:level),
       text: simple(:text),
-      break: simple(:line_break),
+      line_break: simple(:line_break),
     ) do
-      Element::Title.new(text, level, line_break: line_break, id: name)
+      Element::Title.new(text, level.size - 1, line_break: line_break, id: name)
     end
 
     # Section
-    # rule(title: simple(:title)) { Element::Section.new(title) }
-    #
-    # rule(id: simple(:id), title: simple(:title), content:)
-    rule(
-      id: simple(:id),
-      title: simple(:title),
-      sections: sequence(:sections),
-    ) do
-      Element::Section.new(title, id: id, sections: sections)
+    rule(section: subtree(:section)) do
+      id = section[:id] || nil
+      title = section[:title] || nil
+      attribute_list = section[:attribute_list] || nil
+      contents = section[:contents] || []
+      sections = section[:sections]
+      opts = {id:,attribute_list:,contents:,sections: }
+      Element::Section.new(title, opts)
     end
 
-    rule(
-      id: simple(:id),
-      title: simple(:title),
-      contents: sequence(:contents),
-      sections: simple(:sections),
-    ) do
-      Element::Section.new(title, id: id, contents: contents,
-                                  sections: sections)
+
+    rule(example: sequence(:example)) do
+      Element::Core.new("", type: "example", lines: example)
     end
 
+    rule(bibliography_entry: subtree(:bib_entry) ){
+      Element::BibliographyEntry.new(bib_entry)
+    }
+
     rule(
       id: simple(:id),
       title: simple(:title),
-      contents: sequence(:contents),
-      sections: sequence(:sections),
-    ) do
-      Element::Section.new(title, id: id, contents: contents,
-                                  sections: sections)
+      entries: sequence(:entries)
+    ){
+      Element::Bibliography.new(
+        id: id,
+        title: title,
+        entries: entries
+        )
+    }
+
+    rule(
+      key: simple(:key),
+      delimiter: simple(:delimiter),
+      value: simple(:value)
+      ){
+      Element::Inline::CrossReferenceArg.new(key, delimiter, value)
+    }
+
+    rule(href_arg: simple(:href_arg)){
+        href_arg.to_s
+    }
+
+    rule(citation: subtree(:citation)){
+      xref = citation[:cross_reference]
+      xref = Element::Inline::CrossReference.new(xref[0], xref[1..-1]) if xref
+      comment = citation[:comment]
+      opts = {}
+      opts[:cross_reference] = xref if xref
+      opts[:comment] = comment if comment
+      Element::Inline::Citation.new(opts)
+    }
+
+    rule(term_type: simple(:term_type),
+      term: simple(:term),
+      line_break: simple(:line_break)){
+      Coradoc::Element::Term.new(term, type: term_type, line_break: line_break, lang: :en)
+    }
+
+    rule(term_type: simple(:term_type),
+      term2: simple(:term2),
+      line_break: simple(:line_break)){
+      Coradoc::Element::Term.new(term2, type: term_type, line_break: line_break, lang: :fr)
+    }
+
+
+    rule(block: subtree(:block)
+    ) {
+
+      id = block[:id]
+      title = block[:title]
+      attribute_list = block[:attribute_list]
+      delimiter = block[:delimiter].to_s
+      delimiter_c = delimiter[0]
+      lines = block[:lines]
+      ordering = block.keys.select{|k|
+        [:id, :title, :attribute_list, :attribute_list2].include?(k)}
+
+      opts = {id: id,
+        title: title, 
+        delimiter_len: delimiter.size,
+        lines: lines,
+        ordering: ordering}
+      opts[:attributes] = attribute_list if attribute_list
+      if delimiter_c == "*"
+        if attribute_list
+          if (attribute_list.positional == [] &&
+           attribute_list.named.keys[0] == "reviewer")
+            Element::Block::ReviewerComment.new(
+              opts
+              )
+          elsif (attribute_list.positional[0] == "sidebar" &&
+            attribute_list.named == {})
+            Element::Block::Side.new(
+              opts
+            )
+          end
+        else
+        end
+      elsif delimiter_c == "="
+        Element::Block::Example.new(title, opts)
+      elsif delimiter_c == "+"
+        Element::Block::Pass.new(opts)
+      elsif delimiter_c == "-"
+        if (attribute_list.positional[0] == "quote")
+          Element::Block::Quote.new(title, opts)
+        end
+      elsif delimiter_c == "_"
+        Element::Block::Quote.new(title, opts)
+      end
+    }
+
+    # Admonition
+    rule(admonition_type: simple(:admonition_type),
+      content: sequence(:content),
+      ) do
+      Element::Admonition.new(content, admonition_type.to_s)
     end
 
-    rule(example: sequence(:example)) do
-      Element::Core.new("", type: "example", lines: example)
+    rule(block_image: subtree(:block_image)) do
+      id = block_image[:id]
+      title = block_image[:title]
+      path = block_image[:path]
+      opts = {
+        attributes: block_image[:attribute_list_macro],
+        line_break: block_image[:line_break]
+      }
+      Element::Image::BlockImage.new(title, id, path, opts)
     end
 
-    # rule(title: simple(:title), paragraphs: sequence(:paragraphs)) do
-    #   Element::Section.new(title, paragraphs: paragraphs)
-    # end
-    #
-    # rule(title: simple(:title), blocks: sequence(:blocks)) do
-    #   Element::Section.new(title, blocks: blocks)
-    # end
-    #
-    # # Admonition
-    # rule(admonition: simple(:admonition)) { admonition }
-    # rule(type: simple(:type), text: simple(:text), break: simple(:line_break)) do
-    #   Element::Admonition.new(text, type.to_s, line_break: line_break)
-    # end
-    #
-    # # Block
-    # rule(title: simple(:title), lines: sequence(:lines)) do
-    #   Element::Block.new(title, lines: lines)
-    # end
-    #
-    # rule(
-    #   title: simple(:title),
-    #   delimiter: simple(:delimiter),
-    #   lines: sequence(:lines)) do
-    #     Element::Block.new(title, lines: lines, delimiter: delimiter)
-    #   end
-    #
-    # rule(
-    #   type: simple(:type),
-    #   title: simple(:title),
-    #   delimiter: simple(:delimiter),
-    #   lines: sequence(:lines)) do
-    #     Element::Block.new(title, lines: lines, delimiter: delimiter, type: type)
-    #   end
-    #
-    # rule(attributes: simple(:attributes), lines: sequence(:lines)) do
-    #   Element::Block.new(nil, lines: lines, attributes: attributes)
-    # end
-    #
+
+
     # Attribute
     rule(key: simple(:key), value: simple(:value)) do
       Element::Attribute.new(key, value)
     end
 
     rule(key: simple(:key), value: simple(:value),
-         break: simple(:line_break)) do
+         line_break: simple(:line_break)) do
       Element::Attribute.new(key, value, line_break: line_break)
     end
 
-    rule(line_break: simple(:line_break)) { Element::LineBreak.new(line_break) }
+    rule(line_break: simple(:line_break)) {
+      Element::LineBreak.new(line_break)
+    }
 
     rule(document_attributes: sequence(:document_attributes)) do
       Element::DocumentAttributes.new(document_attributes)
     end
 
     # Table
-    rule(table: simple(:table)) { table }
-    rule(cols: sequence(:cols)) { Element::Table::Row.new(cols) }
-    rule(title: simple(:title), rows: sequence(:rows)) do
-      Element::Table.new(title, rows)
+
+    rule(cols: sequence(:cols)) {
+      cells = cols.map{|c| Element::Table::Cell.new(content: c)}
+      Element::Table::Row.new(cells)
+    }
+
+    rule(table: subtree(:table)) do
+      title = table[:title] || nil
+      rows = table[:rows] || []
+      opts = {
+        id: table[:id] || nil,
+        attributes: table[:attribute_list] || nil
+      }
+      Element::Table.new(title, rows, opts)
     end
 
+    rule(list_item: simple(:list_item),
+      marker: simple(:marker),
+      text: simple(:text),
+      line_break: simple(:line_break)) do
+      Element::ListItem.new(
+        text,
+        marker: marker.to_s,
+        line_break: line_break
+        )
+    end
+
+    rule(list_item: simple(:list_item),
+      marker: simple(:marker),
+      id: simple(:id),
+      text: simple(:text),
+      line_break: simple(:line_break)) do
+      Element::ListItem.new(
+        text,
+        id: id,
+        marker: marker.to_s,
+        line_break: line_break
+        )
+    end
+
+
     # List
     rule(list: simple(:list)) { list }
     rule(unordered: sequence(:list_items)) do
       Element::List::Unordered.new(list_items)
     end
+    rule(attribute_list: simple(:attribute_list),
+      unordered: sequence(:list_items)
+    ) do
+      Element::List::Unordered.new(list_items, attrs: attribute_list)
+    end
+
+    rule(ordered: sequence(:list_items)) do
+      Element::List::Ordered.new(list_items)
+    end
+
+    rule(attribute_list: simple(:attribute_list),
+      ordered: sequence(:list_items)
+    ) do
+      Element::List::Ordered.new(list_items, attrs: attribute_list)
+    end
+
+
+    rule(terms: simple(:terms), definition: simple(:definition)) do
+      Element::ListItemDefinition.new(terms, contents)
+    end
+
+    rule(definition_list: sequence(:definition_list)) do
+      Element::List::Definition.new(list_items)
+    end
+
 
     # Highlight
     rule(highlight: simple(:text)) { Element::Highlight.new(text) }
@@ -184,6 +450,11 @@ module Coradoc
       Document.from_ast(elements)
     end
 
+
+    # rule(unparsed: simple(:text)) do
+    #   text.to_s
+    # end
+
     def self.transform(syntax_tree)
       new.apply(syntax_tree)
     end

data/lib/coradoc/util.rb

@@ -0,0 +1,10 @@
+module Coradoc
+  def self.strip_unicode(str)
+    str.gsub(/\A[[:space:]]+|[[:space:]]+\z/, "")
+  end
+
+  def self.a_single?(obj, klass)
+    obj.is_a?(klass) ||
+      (obj.is_a?(Array) && obj.length == 1 && obj.first.is_a?(klass))
+  end
+end

data/lib/coradoc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coradoc
-  VERSION = "1.0.0"
+  VERSION = "1.1.1"
 end

data/lib/coradoc.rb

@@ -3,10 +3,14 @@
 require "pathname"
 
 require "parslet"
-require_relative "coradoc/version"
-require_relative "coradoc/parser"
-require_relative "coradoc/transformer"
-require_relative "coradoc/generator"
+require "coradoc/version"
+require "coradoc/util"
+require "coradoc/parser"
+require "coradoc/transformer"
+require "coradoc/generator"
+require "coradoc/converter"
+require "coradoc/input"
+require "coradoc/output"
 
 module Coradoc
   class Error < StandardError; end

data/lib/reverse_adoc.rb

@@ -1,9 +1,9 @@
-warn <<~END
+warn <<~WARN
   Deprecated: reverse_adoc has been merged into coradoc gem.
   | Please update your references from:
   |   require 'reverse_adoc'
   | To:
-  |   require 'coradoc/reverse_adoc'
+  |   require 'coradoc/input/html'
   |
   | You are referencing an old require here:
   |   #{caller.join("\n|   ")}
@@ -12,9 +12,9 @@ warn <<~END
   | reverse_adoc 2.0.0 will be kept with 'coradoc' as the only dependency.
   |
   | Please also ensure that you replace all references to ReverseAdoc in your code
-  | with Coradoc::ReverseAdoc.
-END
+  | with Coradoc::Input::HTML.
+WARN
 
-require "coradoc/reverse_adoc"
+require "coradoc/input/html"
 
-ReverseAdoc = Coradoc::ReverseAdoc
+ReverseAdoc = Coradoc::Input::HTML