coradoc 1.1.0 → 1.1.1

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

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

data/lib/coradoc/version.rb

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

data/lib/coradoc.rb

@@ -3,11 +3,14 @@
 require "pathname"
 
 require "parslet"
-require_relative "coradoc/version"
-require_relative "coradoc/util"
-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

data/utils/parser_analyzer.rb

@@ -0,0 +1,66 @@
+require "rubocop"
+
+def ast_from(string)
+  RuboCop::ProcessedSource.new(string, RUBY_VERSION.to_f).ast
+end
+
+def is_def?(arr)
+  if Array === arr
+    if arr[0] == :def
+      $defs << arr
+    else
+      arr.each do |e|
+        is_def?(e)
+      end
+    end
+  end
+end
+
+path = "lib/coradoc/parser/asciidoc/"
+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)
+  next if a.nil?
+  sexp = a.to_sexp_array
+  $defs = []
+  is_def?(sexp)
+  $all_defs[cf] = $defs
+end;
+
+relevant_names = $all_defs.map{|fn, defs| defs.map{|d| d[1]}}.flatten;
+
+require 'graphviz'
+
+g = GraphViz.new( :G, :type => :digraph );
+
+g[:fontsize] = 8
+g[:rankdir] = "LR"
+g[:overlap] = false
+g[:splines] = false
+
+nodes = {}
+
+$all_defs.each do |file_name, defs|
+
+  defs.each do |ast_def|
+    calls = ast_def[2..-1].flatten & relevant_names
+    node_name = ast_def[1]
+    nodes[node_name] = g.add_nodes( "#{node_name}\n#{file_name}" )
+  end
+end;
+
+$all_defs.each do |file_name, defs|
+  defs.each do |ast_def|
+    calls = ast_def[2..-1].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;
+
+g.output( :png => "utils/parser_graph.png_#{Time.now.to_i}" );

data/utils/round_trip.rb

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift("../coradoc/lib")
+
+require "coradoc"
+require "coradoc/input/html"
+
+
+rice_path = "../mn-samples-iso/sources/international-standard/rice-2023/"
+
+if !Dir.exist?(rice_path)
+  puts "pleas set path to rice-2023"
+  exit
+end
+
+adoc_files = Dir.glob("#{rice_path}**/*adoc")
+
+adoc_files.each do |file_path|
+  puts file_path
+  file_path_rt = "#{file_path}.roundtrip"
+  file_path_diff = "#{file_path}.roundtrip.diff"
+  FileUtils.rm(file_path_rt) if File.exist?(file_path_rt)
+  FileUtils.rm(file_path_diff) if File.exist?(file_path_diff)
+  # begin
+    adoc_file = File.open(file_path).read
+    next if adoc_file.size == 0
+    puts "parsing..."
+    ast = Coradoc::Parser::Base.new.parse(adoc_file)
+    puts "transforming..."
+    doc = Coradoc::Transformer.transform(ast[:document])
+    puts "generating..."
+    generated_adoc = Coradoc::Generator.gen_adoc(doc)
+    cleaned_adoc = Coradoc::Input::HTML.cleaner.tidy(generated_adoc)
+    File.open("#{file_path}.roundtrip","w"){|f| f.write(cleaned_adoc)}
+    `diff -B #{file_path} #{file_path}.roundtrip > #{file_path}.roundtrip.diff`
+  # rescue
+    # puts "unsuccessful..."
+  # end
+end