coradoc-adoc 2.0.7 → 2.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a29195095ab66adca7be3bdfcb331f71fdd69954c09ea3fc0cef33c4583b8d8c
-  data.tar.gz: 805db091f5043a01ce0b4ff1501c009814c4fdd079ca402a0232b2e3abf073dd
+  metadata.gz: ed044cb4af9fd1e18a9cb2c34ddc5c322d801fd24962058a5b6ec55e7a3a9c43
+  data.tar.gz: 751978667c8663723085bf0a79d5908cf4a3368e827366a1d703c2602671fcb3
 SHA512:
-  metadata.gz: a306bb17db95c5732e1a7e76f101c45a00363c356ebdc0b3d699961caa1a82c6ce2be1f69c531922cb83f53eb49c58735ca814e14a0559a431ee8c9a5ed56a00
-  data.tar.gz: 42c724be473f6bbdd0b9db339b0ac5a02590fa760f74178088536226380994ef52a812bb7730038e5fe66e25ad888a03b0a4b38c993dbdb5748a4f56e00923df
+  metadata.gz: caf485068682d2b714078ff0ec934601a35498fb546d5a97677cbae3b08aa237b598768ca7bafb3f1075868ae5524a01ab20a9fede25d2e4a374d8e67390baca
+  data.tar.gz: cf951b3c317c1a40ac4b2d170dba913b4a83d375aa60a8a7a8a16e47865d3ebe7609b61630436d90726fe682e3d78412beadac3ced3589bf642b865ad7250628

data/lib/coradoc/asciidoc/delimiter_mapping.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module DelimiterMapping
+      CHAR_TO_SEMANTIC = {
+        '-' => :source_code,
+        '=' => :example,
+        '_' => :quote,
+        '*' => :sidebar,
+        '.' => :literal,
+        '+' => :pass
+      }.freeze
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/list/definition_item.rb

@@ -32,6 +32,12 @@ module Coradoc
           attribute :id, :string
           attribute :terms, Coradoc::AsciiDoc::Model::Term, collection: true
           attribute :contents, Coradoc::AsciiDoc::Model::TextElement, collection: true
+          attribute :delimiter, :string, default: -> { '::' }
+          attribute :nested,
+                    Coradoc::AsciiDoc::Model::Base,
+                    polymorphic: [Coradoc::AsciiDoc::Model::List::Definition],
+                    collection: true,
+                    initialize_empty: true
 
           def to_adoc(delimiter: '')
             Coradoc::AsciiDoc::Serializer.serialize(self, delimiter: delimiter)

data/lib/coradoc/asciidoc/parser/list.rb

@@ -29,10 +29,10 @@ module Coradoc
           attrs >> r.repeat(1).as(:unordered)
         end
 
-        def definition_list(delimiter = '::')
+        def definition_list(_delimiter = nil)
           (attribute_list >> newline).maybe >>
-            dlist_item(delimiter).repeat(1).as(:definition_list) >>
-            dlist_item(delimiter).absent?
+            dlist_item.repeat(1).as(:definition_list) >>
+            dlist_item.absent?
         end
 
         def list_marker(nesting_level = 1)
@@ -98,27 +98,32 @@ module Coradoc
         end
 
         def dlist_delimiter
-          (str('::') | str(':::') | str('::::') | str(';;')
+          (
+            (str(':::::') >> match(':').absent?) |
+            (str('::::') >> match(':').absent?) |
+            (str(':::') >> match(':').absent?) |
+            (str('::') >> match(':').absent?) |
+            str(';;')
           ).as(:delimiter)
         end
 
-        def dlist_term(_delimiter)
-          (element_id_inline.maybe >>
-            match("[^\n:]").repeat(1)
-                           .as(:text)
-          ).as(:dlist_term) >> dlist_delimiter
+        def dlist_term(_delimiter = nil)
+          term_chars =
+            (dlist_delimiter.absent? >> match("[^\n]")).repeat(1)
+                                                       .as(:text)
+          (element_id_inline.maybe >> term_chars).as(:dlist_term) >> dlist_delimiter
         end
 
         def dlist_definition
-          text # >> empty_line.repeat(0)
+          text
             .as(:definition) >> line_ending >> empty_line.repeat(0)
         end
 
-        def dlist_item(delimiter)
-          (((dlist_term(delimiter).as(:terms).repeat(1) >> line_ending >>
+        def dlist_item(_delimiter = nil)
+          (((dlist_term.as(:terms).repeat(1) >> line_ending >>
             empty_line.repeat(0)).repeat(1) >>
             dlist_definition) |
-            (dlist_term(delimiter).repeat(1, 1).as(:terms) >> space >>
+            (dlist_term.repeat(1, 1).as(:terms) >> space >>
               dlist_definition)
           ).as(:definition_list_item)
         end

data/lib/coradoc/asciidoc/serializer/serializers/list/definition_item.rb

@@ -8,7 +8,8 @@ module Coradoc
           class DefinitionItem < Base
             def to_adoc(model, options_or_context = {})
               context = normalize_context(options_or_context)
-              delimiter = context.option(:delimiter, '')
+              delimiter = model.delimiter.to_s
+              delimiter = context.option(:delimiter, '::') if delimiter.empty?
               _anchor = model.anchor.nil? ? '' : serialize_child(model.anchor, context)
               content = +''
 
@@ -26,6 +27,25 @@ module Coradoc
 
               d = model.contents ? serialize_children(model.contents, context) : ''
               content << "#{d}\n"
+
+              nested_delimiter = "#{delimiter}:"
+              Array(model.nested).each do |nested_list|
+                next unless nested_list.is_a?(Coradoc::AsciiDoc::Model::List::Definition)
+
+                nested_list.items.each do |nested_item|
+                  content << serialize_with_options(nested_item, delimiter: nested_delimiter)
+                end
+              end
+
+              content
+            end
+
+            private
+
+            def serialize_with_options(child, options = {})
+              serializer_class = ElementRegistry.lookup(child.class)
+              serializer = serializer_class.new
+              serializer.to_adoc(child, options)
             end
           end
         end

data/lib/coradoc/asciidoc/transform/element_transformers/block_transformer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class BlockTransformer
+          class << self
+            def transform_paragraph(para)
+              children = ToCoreModel.transform_inline_content(para.content)
+
+              Coradoc::CoreModel::ParagraphBlock.new(
+                id: para.id,
+                content: ToCoreModel.extract_text_content(para.content),
+                children: children
+              )
+            end
+
+            def transform_source_block(block)
+              non_break_lines = Array(block.lines).reject do |line|
+                line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
+                  line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+              end
+              content_lines = non_break_lines.map do |line|
+                ToCoreModel.extract_text_content(line)
+              end.join("\n")
+
+              language = ToCoreModel.extract_block_language(block)
+
+              Coradoc::CoreModel::SourceBlock.new(
+                id: block.id,
+                title: ToCoreModel.extract_title_text(block.title),
+                content: content_lines,
+                language: language
+              )
+            end
+
+            def transform_block(block, semantic_type_or_delimiter)
+              content_lines = ToCoreModel.extract_block_lines(block)
+              semantic_type = if semantic_type_or_delimiter.is_a?(Symbol)
+                                semantic_type_or_delimiter
+                              else
+                                ToCoreModel.asciidoc_delimiter_to_semantic(semantic_type_or_delimiter)
+                              end
+
+              Coradoc::CoreModel::Block.new(
+                block_semantic_type: semantic_type,
+                delimiter_type: semantic_type_or_delimiter.is_a?(String) ? semantic_type_or_delimiter : nil,
+                id: block.id,
+                title: ToCoreModel.extract_title_text(block.title),
+                content: content_lines,
+                language: ToCoreModel.extract_block_language(block)
+              )
+            end
+
+            def transform_typed_block(block, klass, extra_attrs = {})
+              lines = Array(block.lines).reject do |line|
+                line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
+                  line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+              end
+
+              has_nested_blocks = lines.any?(Coradoc::AsciiDoc::Model::Block::Core)
+
+              if has_nested_blocks
+                children = lines.map { |line| ToCoreModel.transform(line) }
+                klass.new(
+                  id: block.id,
+                  title: ToCoreModel.extract_title_text(block.title),
+                  children: children,
+                  language: ToCoreModel.extract_block_language(block),
+                  **extra_attrs
+                )
+              else
+                content_lines = lines.map { |line| ToCoreModel.extract_text_content(line) }.join("\n")
+                klass.new(
+                  id: block.id,
+                  title: ToCoreModel.extract_title_text(block.title),
+                  content: content_lines,
+                  language: ToCoreModel.extract_block_language(block),
+                  **extra_attrs
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/document_transformer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class DocumentTransformer
+          class << self
+            def transform_document(doc)
+              title_text = ToCoreModel.extract_title_text(doc.header&.title)
+              attributes = ToCoreModel.extract_document_attributes(doc)
+              Coradoc::CoreModel::DocumentElement.new(
+                id: doc.id,
+                title: title_text,
+                attributes: attributes,
+                children: ToCoreModel.transform(doc.sections || doc.contents || [])
+              )
+            end
+
+            def transform_section(section, parent_id: nil)
+              title_text = ToCoreModel.extract_title_text(section.title)
+              section_id = section.id || Coradoc::CoreModel::IdGenerator.generate_from_title(
+                title_text, parent_id: parent_id
+              )
+
+              content_children = ToCoreModel.transform(section.contents || [])
+              nested_sections = (section.sections || []).map do |child|
+                transform_section(child, parent_id: section_id)
+              end
+
+              Coradoc::CoreModel::SectionElement.new(
+                id: section_id,
+                level: section.level,
+                title: title_text,
+                children: content_children + nested_sections
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/inline_transformer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class InlineTransformer
+          class << self
+            def transform_inline(inline, format_type)
+              klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
+              klass.new(
+                content: ToCoreModel.extract_text_content(inline.content)
+              )
+            end
+
+            def transform_inline_text(inline, format_type)
+              klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
+              klass.new(
+                content: inline.text.to_s
+              )
+            end
+
+            def transform_inline_footnote(footnote)
+              parsed_content = ToCoreModel.parse_and_transform_inline(footnote.text.to_s)
+              Coradoc::CoreModel::FootnoteElement.new(
+                target: footnote.id,
+                content: parsed_content
+              )
+            end
+
+            def transform_link(link)
+              Coradoc::CoreModel::LinkElement.new(
+                target: link.path,
+                content: link.name || link.path
+              )
+            end
+
+            def transform_cross_reference(xref)
+              Coradoc::CoreModel::CrossReferenceElement.new(
+                target: xref.href,
+                content: xref.args&.first || xref.href
+              )
+            end
+
+            def transform_stem(stem)
+              Coradoc::CoreModel::StemElement.new(
+                content: stem.content,
+                stem_type: stem.type || 'stem'
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/list_transformer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class ListTransformer
+          class << self
+            def transform_list(list, marker_type)
+              items = Array(list.items).map do |item|
+                if item.is_a?(Coradoc::AsciiDoc::Model::List::DefinitionItem)
+                  transform_definition_item(item)
+                else
+                  transform_list_item(item)
+                end
+              end
+
+              if marker_type == 'definition'
+                Coradoc::CoreModel::DefinitionList.new(items: items)
+              else
+                Coradoc::CoreModel::ListBlock.new(
+                  marker_type: marker_type,
+                  items: items
+                )
+              end
+            end
+
+            private
+
+            def transform_definition_item(item)
+              term_content = item.terms
+              def_content = item.contents
+
+              term_parts = term_content.is_a?(Array) ? term_content : [term_content]
+              parsed_terms = term_parts.flat_map do |part|
+                ToCoreModel.parse_inline_text(part)
+              end
+
+              parsed_defs = ToCoreModel.parse_inline_text(def_content)
+
+              term_children = ToCoreModel.transform_inline_content(parsed_terms)
+              def_children = ToCoreModel.transform_inline_content(parsed_defs)
+
+              di = Coradoc::CoreModel::DefinitionItem.new(
+                term: ToCoreModel.extract_text_content(term_children),
+                definitions: [ToCoreModel.extract_text_content(def_children)],
+                term_children: term_children,
+                definition_children: def_children
+              )
+              di.id = item.id if item.id
+
+              nested_adoc = Array(item.nested).find do |n|
+                n.is_a?(Coradoc::AsciiDoc::Model::List::Definition) && n.items.any?
+              end
+              di.nested = transform_list(nested_adoc, 'definition') if nested_adoc
+
+              di
+            end
+
+            def transform_list_item(item)
+              content_val = item.content
+              children = ToCoreModel.transform_inline_content(content_val)
+
+              li = Coradoc::CoreModel::ListItem.new(
+                content: ToCoreModel.extract_text_content(content_val),
+                marker: item.marker
+              )
+              li.children = children
+
+              if item.nested.is_a?(Coradoc::AsciiDoc::Model::List::Core)
+                nested_core = transform_list(item.nested, list_marker_type(item.nested))
+                li.children << nested_core
+              elsif item.nested.is_a?(Array)
+                item.nested.each do |n|
+                  next unless n.is_a?(Coradoc::AsciiDoc::Model::List::Core)
+
+                  li.children << transform_list(n, list_marker_type(n))
+                end
+              end
+
+              li
+            end
+
+            def list_marker_type(list)
+              case list
+              when Coradoc::AsciiDoc::Model::List::Ordered then 'ordered'
+              when Coradoc::AsciiDoc::Model::List::Definition then 'definition'
+              else 'unordered'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/other_transformer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class OtherTransformer
+          class << self
+            def transform_term(term)
+              Coradoc::CoreModel::Term.new(
+                text: term.term.to_s,
+                type: term.type&.to_s || 'preferred',
+                lang: term.lang&.to_s || 'en'
+              )
+            end
+
+            def transform_admonition(admonition)
+              children = ToCoreModel.transform_inline_content(admonition.content)
+              block = Coradoc::CoreModel::AnnotationBlock.new(
+                annotation_type: admonition.type,
+                content: ToCoreModel.extract_text_content(admonition.content)
+              )
+              block.children = children
+              block
+            end
+
+            def transform_image(image)
+              Coradoc::CoreModel::Image.new(
+                src: image.src,
+                alt: image.title&.to_s,
+                width: image.attributes&.[]('width'),
+                height: image.attributes&.[]('height')
+              )
+            end
+
+            def transform_bibliography(bib)
+              entries = Array(bib.entries).map do |entry|
+                transform_bibliography_entry(entry)
+              end
+
+              Coradoc::CoreModel::Bibliography.new(
+                id: bib.id,
+                title: bib.title.to_s,
+                level: nil,
+                entries: entries
+              )
+            end
+
+            def transform_bibliography_entry(entry)
+              Coradoc::CoreModel::BibliographyEntry.new(
+                anchor_name: entry.anchor_name,
+                document_id: entry.document_id,
+                ref_text: entry.ref_text.to_s
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/table_transformer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class TableTransformer
+          class << self
+            def transform_table(table)
+              rows = Array(table.rows).map do |row|
+                transform_table_row(row)
+              end
+
+              Coradoc::CoreModel::Table.new(
+                id: table.id,
+                title: table.title&.to_s,
+                rows: rows
+              )
+            end
+
+            def transform_table_row(row)
+              cells = Array(row.columns).map do |cell|
+                transform_table_cell(cell)
+              end
+              Coradoc::CoreModel::TableRow.new(
+                cells: cells,
+                header: row.header
+              )
+            end
+
+            def transform_table_cell(cell)
+              children = ToCoreModel.transform_inline_content(cell.content)
+
+              Coradoc::CoreModel::TableCell.new(
+                content: ToCoreModel.extract_text_content(cell.content),
+                alignment: cell.horizontal_alignment,
+                vertical_alignment: cell.vertical_alignment,
+                colspan: cell.colspan,
+                rowspan: cell.rowspan,
+                style: cell.style_name,
+                children: children
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        autoload :DocumentTransformer, "#{__dir__}/element_transformers/document_transformer"
+        autoload :BlockTransformer, "#{__dir__}/element_transformers/block_transformer"
+        autoload :ListTransformer, "#{__dir__}/element_transformers/list_transformer"
+        autoload :InlineTransformer, "#{__dir__}/element_transformers/inline_transformer"
+        autoload :TableTransformer, "#{__dir__}/element_transformers/table_transformer"
+        autoload :OtherTransformer, "#{__dir__}/element_transformers/other_transformer"
+      end
+    end
+  end
+end