coradoc 1.1.5 → 1.1.7

data/lib/coradoc/parser/base.rb

@@ -7,15 +7,12 @@ require_relative "asciidoc/base"
 module Coradoc
   module Parser
     class Base < Coradoc::Parser::Asciidoc::Base
-
       root :document
       rule(:document) do
         (
           admonition_line |
           bib_entry |
           block_image |
-          term | term2 |
-          citation |
           tag |
           comment_block |
           comment_line |

data/lib/coradoc/reverse_adoc.rb

@@ -12,7 +12,7 @@ warn <<~WARN
   | in your code with Coradoc::Input::HTML.
 WARN
 
-require 'coradoc'
-require 'coradoc/input/html'
+require "coradoc"
+require "coradoc/input/html"
 
-Coradoc::ReverseAdoc = Coradoc::Input::HTML
+Coradoc::ReverseAdoc = Coradoc::Input::Html

data/lib/coradoc/transformer.rb

@@ -28,39 +28,39 @@ module Coradoc
     end
 
     # Comments
-    rule(comment_line: {comment_text: simple(:comment_text)}) {
+    rule(comment_line: { comment_text: simple(:comment_text) }) do
       Element::Comment::Line.new(comment_text)
-    }
+    end
 
-    rule(comment_block: {comment_text: simple(:comment_text)}) {
+    rule(comment_block: { comment_text: simple(:comment_text) }) do
       Element::Comment::Block.new(comment_text)
-    }
+    end
 
-    rule(tag: subtree(:tag)) {
+    rule(tag: subtree(:tag)) do
       opts = {}
       opts[:prefix] = tag[:prefix]
       opts[:attribute_list] = tag[:attribute_list]
       opts[:line_break] = tag[:line_break]
       Element::Tag.new(tag[:name], opts)
-    }
+    end
 
     # AttributeList
-    class NamedAttribute < Struct.new(:key, :value); end
+    NamedAttribute = Struct.new(:key, :value)
 
-    rule(:named => {named_key: simple(:key),
-      named_value: simple(:value)} ) {
+    rule(named: { named_key: simple(:key),
+                  named_value: simple(:value) }) do
       NamedAttribute.new(key.to_s, value.to_s)
-    }
+    end
 
-    rule(positional: simple(:positional)){
+    rule(positional: simple(:positional)) do
       positional.to_s
-    }
+    end
 
-    rule(attribute_array: nil){
+    rule(attribute_array: nil) do
       Element::AttributeList.new
-    }
+    end
 
-    rule(attribute_array: sequence(:attributes)){
+    rule(attribute_array: sequence(:attributes)) do
       attr_list = Element::AttributeList.new
       attributes.each do |a|
         if a.is_a?(String)
@@ -70,114 +70,149 @@ module Coradoc
         end
       end
       attr_list
-    }
+    end
 
     # Include
     rule(include: {
-      path: simple(:path),
-      attribute_list: simple(:attribute_list),
-      line_break: simple(:line_break)}
-    ) {
+           path: simple(:path),
+           attribute_list: simple(:attribute_list),
+           line_break: simple(:line_break),
+         }) do
       Element::Include.new(
         path.to_s,
         attributes: attribute_list,
-        line_break: line_break)
-    }
-
+        line_break: line_break,
+      )
+    end
 
     # Text Element
-    rule(text: simple(:text)) {
+    rule(text: simple(:text)) do
       Element::TextElement.new(text.to_s)
-    }
+    end
 
-    rule(text: simple(:text), line_break: simple(:line_break)) {
+    rule(text_string: subtree(:text_string)) do
+      text_string.to_s
+    end
+
+    rule(text: simple(:text), line_break: simple(:line_break)) do
       Element::TextElement.new(text.to_s, line_break: line_break)
-    }
+    end
+
+    rule(text: sequence(:text), line_break: simple(:line_break)) do
+      Element::TextElement.new(text, line_break: line_break)
+    end
 
     rule(id: simple(:id), text: simple(:text)) do
       Element::TextElement.new(text.to_s, id: id.to_s)
     end
 
-    rule(text: sequence(:text)) {
+    rule(text: sequence(:text)) do
       Element::TextElement.new(text)
-    }
+    end
 
     rule(
       text: simple(:text),
-      line_break: simple(:line_break)
+      line_break: simple(:line_break),
     ) do
       Element::TextElement.new(
         text.to_s,
-        line_break: line_break)
+        line_break: line_break,
+      )
     end
 
     rule(
       id: simple(:id),
       text: simple(:text),
-      line_break: simple(:line_break)
+      line_break: simple(:line_break),
     ) do
       Element::TextElement.new(
         text.to_s,
-        id: id,
-        line_break: line_break)
+        id: id.to_s,
+        line_break: line_break,
+      )
     end
 
     rule(
       id: simple(:id),
       text: sequence(:text),
-      line_break: simple(:line_break)
+      line_break: simple(:line_break),
     ) do
       Element::TextElement.new(
         text,
-        id: id,
-        line_break: line_break)
+        id: id.to_s,
+        line_break: line_break,
+      )
     end
 
     rule(text: sequence(:text),
-      line_break: simple(:line_break)
-    ) do
+         line_break: simple(:line_break)) do
       Element::TextElement.new(
         text,
-        line_break: line_break)
+        line_break: line_break,
+      )
     end
 
-    rule(href: simple(:href)){
+    # Inlines
+    rule(href: simple(:href)) do
       Element::Inline::CrossReference.new(
-        href.to_s
+        href.to_s,
       )
-    }
+    end
 
     rule(href: simple(:href),
-      name: simple(:name)
-    ){
+         name: simple(:name)) do
       Element::Inline::CrossReference.new(
         href.to_s,
-        name.to_s
+        name.to_s,
       )
-    }
+    end
 
-    rule(bold_constrained: sequence(:text)){
+    rule(bold_constrained: sequence(:text)) do
       Element::Inline::Bold.new(text, unconstrained: false)
-    }
+    end
 
-    rule(bold_unconstrained: sequence(:text)) {
+    rule(bold_unconstrained: sequence(:text)) do
       Element::Inline::Bold.new(text, unconstrained: true)
-    }
+    end
 
-    rule(highlight_constrained: sequence(:text)) {
-      Element::Inline::Highlight.new(text, unconstrained: false)
-    }
-    rule(highlight_unconstrained: sequence(:text)) {
-      Element::Inline::Highlight.new(text, unconstrained: true)
-    }
+    rule(span_constrained: subtree(:span_constrained)) do
+      Element::Inline::Span.new(span_constrained[:text],
+                                unconstrained: false,
+                                attributes: span_constrained[:attribute_list])
+    end
+    rule(span_unconstrained: subtree(:span_unconstrained)) do
+      Element::Inline::Span.new(span_unconstrained[:text], unconstrained: true,
+                                                           attributes: span_unconstrained[:attribute_list])
+    end
 
-    rule(italic_constrained: sequence(:text)) {
+    rule(italic_constrained: sequence(:text)) do
       Element::Inline::Italic.new(text, unconstrained: false)
-    }
-    rule(italic_unconstrained: sequence(:text)) {
+    end
+    rule(italic_unconstrained: sequence(:text)) do
       Element::Inline::Italic.new(text, unconstrained: true)
-    }
+    end
+
+    rule(highlight_constrained: sequence(:text)) do
+      Element::Inline::Highlight.new(text, unconstrained: false)
+    end
+    rule(highlight_unconstrained: sequence(:text)) do
+      Element::Inline::Highlight.new(text, unconstrained: true)
+    end
 
+    rule(monospace_constrained: sequence(:text)) do
+      Element::Inline::Monospace.new(text, unconstrained: false)
+    end
+    rule(monospace_unconstrained: sequence(:text)) do
+      Element::Inline::Monospace.new(text, unconstrained: true)
+    end
+
+    rule(superscript: sequence(:content)) do
+      Element::Inline::Superscript.new(content)
+    end
+
+    rule(subscript: sequence(:content)) do
+      Element::Inline::Subscript.new(content)
+    end
 
     # Paragraph
     rule(paragraph: subtree(:paragraph)) do
@@ -185,12 +220,10 @@ module Coradoc
         paragraph[:lines],
         id: paragraph[:id],
         attributes: paragraph[:attribute_list],
-        title: paragraph[:title]
-        )
+        title: paragraph[:title],
+      )
     end
 
-
-
     # Title Element
     rule(
       level: simple(:level),
@@ -216,91 +249,88 @@ module Coradoc
       attribute_list = section[:attribute_list] || nil
       contents = section[:contents] || []
       sections = section[:sections]
-      opts = {id:,attribute_list:,contents:,sections: }
+      opts = { id:, attribute_list:, contents:, sections: }
       Element::Section.new(title, opts)
     end
 
-
     rule(example: sequence(:example)) do
       Element::Core.new("", type: "example", lines: example)
     end
 
-    rule(bibliography_entry: subtree(:bib_entry) ){
+    rule(bibliography_entry: subtree(:bib_entry)) do
       Element::BibliographyEntry.new(bib_entry)
-    }
+    end
 
     rule(
       id: simple(:id),
       title: simple(:title),
-      entries: sequence(:entries)
-    ){
+      entries: sequence(:entries),
+    ) do
       Element::Bibliography.new(
         id: id,
         title: title,
-        entries: entries
-        )
-    }
+        entries: entries,
+      )
+    end
 
     rule(
       key: simple(:key),
       delimiter: simple(:delimiter),
-      value: simple(:value)
-      ){
+      value: simple(:value),
+    ) do
       Element::Inline::CrossReferenceArg.new(key, delimiter, value)
-    }
+    end
 
-    rule(href_arg: simple(:href_arg)){
-        href_arg.to_s
-    }
+    rule(href_arg: simple(:href_arg)) do
+      href_arg.to_s
+    end
 
-    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(cross_reference: sequence(:xref)) do
+      args = xref.size > 1 ? xref[1..-1] : []
+      Element::Inline::CrossReference.new(xref[0], args)
+    end
 
-    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(attribute_reference: simple(:name)) do
+      Element::Inline::AttributeReference.new(name)
+    end
 
     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)
-    }
+         term: simple(:term)) do
+      Coradoc::Element::Term.new(term, type: term_type, lang: :en)
+    end
 
+    rule(footnote: simple(:footnote)) do
+      Coradoc::Element::Inline::Footnote.new(footnote)
+    end
 
-    rule(block: subtree(:block)
-    ) {
+    rule(footnote: simple(:footnote), id: simple(:id)) do
+      Coradoc::Element::Inline::Footnote.new(footnote, id)
+    end
 
+    rule(block: subtree(:block)) do
       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}
+      ordering = block.keys.select do |k|
+        %i[id title attribute_list attribute_list2].include?(k)
+      end
+
+      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")
+          if attribute_list.positional == [] &&
+              attribute_list.named.keys[0] == "reviewer"
             Element::Block::ReviewerComment.new(opts)
-          elsif (attribute_list.positional[0] == "sidebar" &&
-            attribute_list.named == {})
+          elsif attribute_list.positional[0] == "sidebar" &&
+              attribute_list.named == {}
             Element::Block::Side.new(opts)
           else
             Element::Block::Side.new(opts)
@@ -314,17 +344,16 @@ module Coradoc
         Element::Block::Pass.new(opts)
       elsif delimiter_c == "-" && delimiter.size == 2
         Element::Block::Open.new(title, opts)
-      elsif delimiter_c == "-"&& delimiter.size >= 4
+      elsif delimiter_c == "-" && delimiter.size >= 4
         Element::Block::SourceCode.new(title, opts)
       elsif delimiter_c == "_"
         Element::Block::Quote.new(title, opts)
       end
-    }
+    end
 
     # Admonition
     rule(admonition_type: simple(:admonition_type),
-      content: sequence(:content),
-      ) do
+         content: sequence(:content)) do
       Element::Admonition.new(content, admonition_type.to_s)
     end
 
@@ -334,26 +363,24 @@ module Coradoc
       path = block_image[:path]
       opts = {
         attributes: block_image[:attribute_list_macro],
-        line_break: block_image[:line_break]
+        line_break: block_image[:line_break],
       }
       Element::Image::BlockImage.new(title, id, path, opts)
     end
 
-
-
     # Attribute
     rule(key: simple(:key), value: simple(:value)) do
-      Element::Attribute.new(key, value)
+      Element::Attribute.new(key.to_s, value.to_s)
     end
 
     rule(key: simple(:key), value: simple(:value),
          line_break: simple(:line_break)) do
-      Element::Attribute.new(key, value, line_break: line_break)
+      Element::Attribute.new(key.to_s, value.to_s, line_break: line_break.to_s)
     end
 
-    rule(line_break: simple(:line_break)) {
+    rule(line_break: simple(:line_break)) do
       Element::LineBreak.new(line_break)
-    }
+    end
 
     rule(document_attributes: sequence(:document_attributes)) do
       Element::DocumentAttributes.new(document_attributes)
@@ -361,17 +388,17 @@ module Coradoc
 
     # Table
 
-    rule(cols: sequence(:cols)) {
-      cells = cols.map{|c| Element::Table::Cell.new(content: c)}
+    rule(cols: sequence(:cols)) do
+      cells = cols.map { |c| Element::Table::Cell.new(content: c) }
       Element::Table::Row.new(cells)
-    }
+    end
 
     rule(table: subtree(:table)) do
       title = table[:title] || nil
       rows = table[:rows] || []
       opts = {
         id: table[:id] || nil,
-        attributes: table[:attribute_list] || nil
+        attributes: table[:attribute_list] || nil,
       }
       Element::Table.new(title, rows, opts)
     end
@@ -380,22 +407,22 @@ module Coradoc
       marker = list_item[:marker]
       id = list_item[:id]
       text = list_item[:text]
+      text = list_item[:text].to_s if list_item[:text].instance_of?(Parslet::Slice)
       attached = list_item[:attached]
       nested = list_item[:nested]
       line_break = list_item[:line_break]
       Element::ListItem.new(
-        text, id:, marker:, attached:, nested:, line_break: )
+        text, id:, marker:, attached:, nested:, 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
+         unordered: sequence(:list_items)) do
       Element::List::Unordered.new(list_items, attrs: attribute_list)
     end
 
@@ -404,21 +431,25 @@ module Coradoc
     end
 
     rule(attribute_list: simple(:attribute_list),
-      ordered: sequence(:list_items)
-    ) do
+         ordered: sequence(:list_items)) do
       Element::List::Ordered.new(list_items, attrs: attribute_list)
     end
 
+    rule(dlist_term: simple(:t),
+         delimiter: simple(:d)) do
+      # DefinitionListTerm.new(t.to_s, d.to_s)
+      t.to_s
+    end
 
-    rule(terms: simple(:terms), definition: simple(:definition)) do
+    rule(definition_list_item: { terms: sequence(:terms),
+                                 definition: simple(:contents) }) do
       Element::ListItemDefinition.new(terms, contents)
     end
 
-    rule(definition_list: sequence(:definition_list)) do
+    rule(definition_list: sequence(:list_items)) do
       Element::List::Definition.new(list_items)
     end
 
-
     # Highlight
     rule(highlight: simple(:text)) { Element::Highlight.new(text) }
 
@@ -434,7 +465,6 @@ module Coradoc
       Document.from_ast(elements)
     end
 
-
     # rule(unparsed: simple(:text)) do
     #   text.to_s
     # end

data/lib/coradoc/version.rb

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

data/lib/reverse_adoc.rb

@@ -17,4 +17,4 @@ WARN
 
 require "coradoc/input/html"
 
-ReverseAdoc = Coradoc::Input::HTML
+ReverseAdoc = Coradoc::Input::Html

data/utils/inspect_asciidoc.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift("../coradoc/lib")
+require "coradoc"
+require "pp"
+
+def pretty_print_obj(obj)
+  sio = StringIO.new
+  PP.pp(obj, sio, 69)
+  puts sio.string
+end
+
+def print_parsed(str)
+  parse = Coradoc::Parser::Base.new.parse(str)
+  puts str
+  puts ""
+  pretty_print_obj parse[:document]
+  puts ""
+  doc = Coradoc::Transformer.transform(parse[:document])
+  pp doc
+  puts Coradoc::Generator.gen_adoc(doc)
+end
+
+content = <<~END
+  [a='quoted named']
+  ****
+  block
+  ****
+END
+
+print_parsed(content)

data/utils/parser_analyzer.rb

@@ -17,24 +17,25 @@ def is_def?(arr)
 end
 
 path = "lib/coradoc/parser/asciidoc/"
-class_files = Dir.entries(path).select{|x| File.file?(path+x)}
+class_files = Dir.entries(path).select { |x| File.file?(path + x) }
 
 $all_defs = {}
 
 class_files.each do |cf|
-  a = ast_from(File.open(path+cf).read)
+  a = ast_from(File.open(path + cf).read)
   next if a.nil?
+
   sexp = a.to_sexp_array
   $defs = []
   is_def?(sexp)
   $all_defs[cf] = $defs
-end;
+end
 
-relevant_names = $all_defs.map{|fn, defs| defs.map{|d| d[1]}}.flatten;
+relevant_names = $all_defs.map { |_fn, defs| defs.map { |d| d[1] } }.flatten
 
-require 'graphviz'
+require "graphviz"
 
-g = GraphViz.new( :G, :type => :digraph );
+g = GraphViz.new(:G, type: :digraph)
 
 g[:fontsize] = 8
 g[:rankdir] = "LR"
@@ -44,23 +45,22 @@ g[:splines] = false
 nodes = {}
 
 $all_defs.each do |file_name, defs|
-
   defs.each do |ast_def|
-    calls = ast_def[2..-1].flatten & relevant_names
+    ast_def[2..].flatten & relevant_names
     node_name = ast_def[1]
-    nodes[node_name] = g.add_nodes( "#{node_name}\n#{file_name}" )
+    nodes[node_name] = g.add_nodes("#{node_name}\n#{file_name}")
   end
-end;
+end
 
-$all_defs.each do |file_name, defs|
+$all_defs.each_value do |defs|
   defs.each do |ast_def|
-    calls = ast_def[2..-1].flatten & relevant_names
+    calls = ast_def[2..].flatten & relevant_names
     node_name = ast_def[1]
     calls.each do |cl|
       w = g.add_edges(nodes[node_name], nodes[cl])
       w[:weight] = 1.5
     end
   end
-end;
+end
 
-g.output( :png => "utils/parser_graph.png_#{Time.now.to_i}" );
+g.output(png: "utils/parser_graph.png_#{Time.now.to_i}")