coradoc-adoc 2.0.0

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      # Registers all default AsciiDoc -> CoreModel transformers
+      module ToCoreModelRegistrations
+        class << self
+          def register_all!
+            register_document_transformers!
+            register_block_transformers!
+            register_list_transformers!
+            register_inline_transformers!
+            register_table_transformers!
+            register_other_transformers!
+          end
+
+          private
+
+          def register_document_transformers!
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Document,
+              method_wrapper(:transform_document)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Section,
+              method_wrapper(:transform_section)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Paragraph,
+              method_wrapper(:transform_paragraph)
+            )
+          end
+
+          def register_block_transformers!
+            Registry.register_with_priority(
+              Coradoc::AsciiDoc::Model::Block::SourceCode,
+              METHOD_DISPATCH[:transform_source_block],
+              priority: 10
+            )
+
+            {
+              Coradoc::AsciiDoc::Model::Block::Quote => Coradoc::CoreModel::QuoteBlock,
+              Coradoc::AsciiDoc::Model::Block::Example => Coradoc::CoreModel::ExampleBlock,
+              Coradoc::AsciiDoc::Model::Block::Side => Coradoc::CoreModel::SidebarBlock,
+              Coradoc::AsciiDoc::Model::Block::Literal => Coradoc::CoreModel::LiteralBlock,
+              Coradoc::AsciiDoc::Model::Block::Open => Coradoc::CoreModel::OpenBlock,
+              Coradoc::AsciiDoc::Model::Block::Pass => Coradoc::CoreModel::PassBlock
+            }.each do |block_class, core_model_class|
+              Registry.register_with_priority(
+                block_class,
+                typed_block_wrapper(core_model_class),
+                priority: 10
+              )
+            end
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Block::Core,
+              block_model_wrapper
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::CommentBlock,
+              lambda { |model|
+                Coradoc::CoreModel::Block.new(
+                  element_type: 'comment',
+                  content: model.text.to_s
+                )
+              }
+            )
+          end
+
+          def register_list_transformers!
+            Registry.register(
+              Coradoc::AsciiDoc::Model::List::Unordered,
+              list_wrapper('unordered')
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::List::Ordered,
+              list_wrapper('ordered')
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::List::Definition,
+              list_wrapper('definition')
+            )
+          end
+
+          def register_inline_transformers!
+            [
+              [Coradoc::AsciiDoc::Model::Inline::Bold, 'bold'],
+              [Coradoc::AsciiDoc::Model::Inline::Italic, 'italic'],
+              [Coradoc::AsciiDoc::Model::Inline::Monospace, 'monospace'],
+              [Coradoc::AsciiDoc::Model::Inline::Highlight, 'highlight'],
+              [Coradoc::AsciiDoc::Model::Inline::Strikethrough, 'strikethrough'],
+              [Coradoc::AsciiDoc::Model::Inline::Subscript, 'subscript'],
+              [Coradoc::AsciiDoc::Model::Inline::Superscript, 'superscript']
+            ].each do |inline_class, format_type|
+              Registry.register(
+                inline_class,
+                inline_wrapper(format_type)
+              )
+            end
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Inline::Underline,
+              inline_text_wrapper('underline')
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Inline::Link,
+              method_wrapper(:transform_link)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Inline::CrossReference,
+              method_wrapper(:transform_cross_reference)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Inline::Footnote,
+              method_wrapper(:transform_inline_footnote)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Inline::Stem,
+              method_wrapper(:transform_stem)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Inline::AttributeReference,
+              lambda { |model|
+                Coradoc::CoreModel::InlineElement.new(
+                  format_type: 'attribute_reference',
+                  content: "{#{model.name}}"
+                )
+              }
+            )
+          end
+
+          def register_table_transformers!
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Table,
+              method_wrapper(:transform_table)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::TableRow,
+              method_wrapper(:transform_table_row)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::TableCell,
+              method_wrapper(:transform_table_cell)
+            )
+          end
+
+          def register_other_transformers!
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Term,
+              method_wrapper(:transform_term)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Admonition,
+              method_wrapper(:transform_admonition)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Image::BlockImage,
+              method_wrapper(:transform_image)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Bibliography,
+              method_wrapper(:transform_bibliography)
+            )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::BibliographyEntry,
+              method_wrapper(:transform_bibliography_entry)
+            )
+
+            # Passthrough types (no CoreModel equivalent)
+            [
+              Coradoc::AsciiDoc::Model::TextElement,
+              Coradoc::AsciiDoc::Model::Include,
+              Coradoc::AsciiDoc::Model::Audio,
+              Coradoc::AsciiDoc::Model::Video,
+              Coradoc::AsciiDoc::Model::ContentList,
+              Coradoc::AsciiDoc::Model::Tag
+            ].each do |klass|
+              Registry.register(klass, ->(model) { model })
+            end
+
+            # Filtered types (layout-only, no CoreModel representation)
+            [
+              Coradoc::AsciiDoc::Model::LineBreak,
+              Coradoc::AsciiDoc::Model::Break::PageBreak
+            ].each do |klass|
+              Registry.register(klass, ->(_model) { nil })
+            end
+          end
+
+          METHOD_DISPATCH = {
+            transform_document: ->(model) { ToCoreModel.transform_document(model) },
+            transform_section: ->(model) { ToCoreModel.transform_section(model) },
+            transform_paragraph: ->(model) { ToCoreModel.transform_paragraph(model) },
+            transform_source_block: ->(model) { ToCoreModel.transform_source_block(model) },
+            transform_link: ->(model) { ToCoreModel.transform_link(model) },
+            transform_cross_reference: ->(model) { ToCoreModel.transform_cross_reference(model) },
+            transform_inline_footnote: ->(model) { ToCoreModel.transform_inline_footnote(model) },
+            transform_stem: ->(model) { ToCoreModel.transform_stem(model) },
+            transform_table: ->(model) { ToCoreModel.transform_table(model) },
+            transform_table_row: ->(model) { ToCoreModel.transform_table_row(model) },
+            transform_table_cell: ->(model) { ToCoreModel.transform_table_cell(model) },
+            transform_term: ->(model) { ToCoreModel.transform_term(model) },
+            transform_admonition: ->(model) { ToCoreModel.transform_admonition(model) },
+            transform_image: ->(model) { ToCoreModel.transform_image(model) },
+            transform_bibliography: ->(model) { ToCoreModel.transform_bibliography(model) },
+            transform_bibliography_entry: ->(model) { ToCoreModel.transform_bibliography_entry(model) }
+          }.freeze
+
+          def method_wrapper(method_name)
+            METHOD_DISPATCH.fetch(method_name)
+          end
+
+          def typed_block_wrapper(klass)
+            ->(model) { ToCoreModel.transform_typed_block(model, klass) }
+          end
+
+          def block_model_wrapper
+            ->(model) { ToCoreModel.transform_block(model, model.delimiter.to_s) }
+          end
+
+          def list_wrapper(marker_type)
+            ->(model) { ToCoreModel.transform_list(model, marker_type) }
+          end
+
+          def inline_wrapper(format_type)
+            ->(model) { ToCoreModel.transform_inline(model, format_type) }
+          end
+
+          def inline_text_wrapper(format_type)
+            ->(model) { ToCoreModel.transform_inline_text(model, format_type) }
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-register when this file is loaded
+Coradoc::AsciiDoc::Transform::ToCoreModelRegistrations.register_all!

data/lib/coradoc/asciidoc/transform.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      autoload :Registry, "#{__dir__}/transform/registry"
+      autoload :ToCoreModel, "#{__dir__}/transform/to_core_model"
+      autoload :ToCoreModelRegistrations, "#{__dir__}/transform/to_core_model_registrations"
+      autoload :FromCoreModel, "#{__dir__}/transform/from_core_model"
+      autoload :FromCoreModelRegistrations, "#{__dir__}/transform/from_core_model_registrations"
+    end
+  end
+end

data/lib/coradoc/asciidoc/transformer/block_rules.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Module containing block element transformation rules
+      module BlockRules
+        def self.apply(transformer_class)
+          transformer_class.class_eval do
+            # Generic block
+            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 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
+              delimiter_len = opts[:delimiter_len]
+
+              if delimiter_c == '*'
+                if attribute_list
+                  if attribute_list.positional == [] &&
+                     attribute_list.named.first&.name == 'reviewer'
+                    Model::Block::ReviewerComment.new(
+                      id:,
+                      title:,
+                      lines:,
+                      delimiter_len:,
+                      attributes: attribute_list
+                    )
+                  else
+                    Model::Block::Side.new(id:, title:, lines:, delimiter_len:,
+                                           attributes: attribute_list)
+                  end
+                else
+                  Model::Block::Side.new(id:, title:, lines:, delimiter_len:,
+                                         attributes: attribute_list)
+                end
+              elsif delimiter_c == '='
+                Model::Block::Example.new(id:, title:, lines:, delimiter_len:,
+                                          attributes: attribute_list)
+              elsif delimiter_c == '+'
+                Model::Block::Pass.new(id:, title:, lines:, delimiter_len:,
+                                       attributes: attribute_list)
+              elsif delimiter_c == '-' && delimiter.size == 2
+                Model::Block::Open.new(id:, title:, lines:, delimiter_len:,
+                                       attributes: attribute_list)
+              elsif delimiter_c == '-' && delimiter.size >= 4
+                Model::Block::SourceCode.new(id:, title:, lines:, delimiter_len:,
+                                             attributes: attribute_list)
+              elsif delimiter_c == '_'
+                Model::Block::Quote.new(id:, title:, lines:, delimiter_len:,
+                                        attributes: attribute_list)
+              end
+            end
+
+            # Example
+            rule(example: sequence(:example)) do
+              Model::Block::Example.new(title: '', lines: example)
+            end
+
+            # Admonition
+            rule(
+              admonition_type: simple(:admonition_type),
+              content: sequence(:content)
+            ) do
+              Model::Admonition.new(content: content, type: admonition_type.to_s)
+            end
+
+            # Block image
+            rule(block_image: subtree(:block_image)) do
+              id = block_image[:id]
+              title = block_image[:title]
+              path = block_image[:path]
+              attrs = block_image[:attribute_list]
+              Model::Image::BlockImage.new(
+                title: title,
+                id: id,
+                src: path,
+                attributes: attrs,
+                line_break: "\n"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transformer/header_rules.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Module containing header transformation rules
+      module HeaderRules
+        def self.apply(transformer_class)
+          transformer_class.class_eval do
+            # Header with author and revision
+            rule(
+              title: simple(:title),
+              author: simple(:author),
+              revision: simple(:revision)
+            ) do
+              id = title.is_a?(Model::Title) ? title.id : nil
+              Model::Header.new(id:, title:, author:, revision:)
+            end
+
+            # Header with author only
+            rule(
+              title: simple(:title),
+              author: simple(:author)
+            ) do
+              id = title.is_a?(Model::Title) ? title.id : nil
+              Model::Header.new(id:, title:, author:, revision: nil)
+            end
+
+            # Header with revision only
+            rule(
+              title: simple(:title),
+              revision: simple(:revision)
+            ) do
+              id = title.is_a?(Model::Title) ? title.id : nil
+              Model::Header.new(id:, title:, author: nil, revision:)
+            end
+
+            # Header with title only
+            rule(
+              title: simple(:title)
+            ) do
+              id = title.is_a?(Model::Title) ? title.id : nil
+              Model::Header.new(id:, title:, author: nil, revision: nil)
+            end
+
+            # Author
+            rule(
+              first_name: simple(:first_name),
+              last_name: simple(:last_name),
+              email: simple(:email)
+            ) do
+              Model::Author.new(first_name:, last_name:, email:, middle_name: nil)
+            end
+
+            # Revision
+            rule(
+              number: simple(:number),
+              date: simple(:date),
+              remark: simple(:remark)
+            ) do
+              Model::Revision.new(number:, date:, remark:)
+            end
+
+            # Unwrap header hash - handles cases where header wasn't transformed yet
+            rule(header: subtree(:header)) do
+              if header.is_a?(Hash) && header.key?(:title)
+                id = header[:id]
+                id = id.to_s unless id.nil?
+                id = nil if id && id.empty?
+
+                title = header[:title]
+                author = header[:author]
+                revision = header[:revision]
+
+                id = title.id if title.is_a?(Model::Title) && title.id && !id
+
+                Model::Header.new(id:, title:, author:, revision:)
+              else
+                header
+              end
+            end
+
+            rule(header: simple(:header)) do
+              header
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transformer/inline_rules.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Module containing inline element transformation rules
+      module InlineRules
+        def self.apply(transformer_class)
+          transformer_class.class_eval do
+            # Link
+            rule(link: subtree(:link)) do
+              Model::Inline::Link.new(
+                path: link[:path].to_s,
+                name: link[:text]&.to_s
+              )
+            end
+
+            # Cross reference
+            rule(href: simple(:href)) do
+              Model::Inline::CrossReference.new(href: href.to_s)
+            end
+
+            rule(
+              href: simple(:href),
+              name: simple(:name)
+            ) do
+              Model::Inline::CrossReference.new(href: href.to_s, args: [name.to_s])
+            end
+
+            rule(cross_reference: sequence(:xref)) do
+              args = xref.size > 1 ? xref[1..] : []
+              Model::Inline::CrossReference.new(href: xref[0], args:)
+            end
+
+            # Inline image
+            rule(inline_image: subtree(:inline_image)) do
+              Model::Image::InlineImage.new(
+                title: inline_image[:text],
+                src: inline_image[:path],
+                attributes: inline_image[:attribute_list]
+              )
+            end
+
+            # Attribute reference
+            rule(attribute_reference: simple(:name)) do
+              Model::Inline::AttributeReference.new(name:)
+            end
+
+            # Term
+            rule(
+              term_type: simple(:term_type),
+              term: simple(:term)
+            ) do
+              Coradoc::AsciiDoc::Model::Term.new(term:, type: term_type, lang: :en)
+            end
+
+            # Footnote
+            rule(footnote: simple(:footnote)) do
+              text_str = footnote.to_s
+              Coradoc::AsciiDoc::Model::Inline::Footnote.new(text: text_str)
+            end
+
+            rule(footnote: simple(:footnote), id: simple(:id)) do
+              text_str = footnote.to_s
+              Coradoc::AsciiDoc::Model::Inline::Footnote.new(text: text_str, id: id.to_s)
+            end
+
+            # Footnote with empty content (reference to named footnote)
+            rule(footnote: sequence(:footnote), id: simple(:id)) do
+              text_str = footnote.map(&:to_s).join
+              Coradoc::AsciiDoc::Model::Inline::Footnote.new(text: text_str, id: id.to_s)
+            end
+
+            # Footnote with empty content and no id
+            rule(footnote: sequence(:footnote)) do
+              text_str = footnote.map(&:to_s).join
+              Coradoc::AsciiDoc::Model::Inline::Footnote.new(text: text_str)
+            end
+
+            # Href arg
+            rule(href_arg: simple(:href_arg)) do
+              href_arg.to_s
+            end
+
+            # Bold (constrained)
+            rule(bold_constrained: subtree(:bold)) do
+              content = Transformer.extract_inline_content(bold)
+              Model::Inline::Bold.new(content: content, unconstrained: false)
+            end
+
+            # Bold (unconstrained)
+            rule(bold_unconstrained: subtree(:bold)) do
+              content = Transformer.extract_inline_content(bold)
+              Model::Inline::Bold.new(content: content, unconstrained: true)
+            end
+
+            # Italic (constrained)
+            rule(italic_constrained: subtree(:italic)) do
+              content = Transformer.extract_inline_content(italic)
+              Model::Inline::Italic.new(content: content, unconstrained: false)
+            end
+
+            # Italic (unconstrained)
+            rule(italic_unconstrained: subtree(:italic)) do
+              content = Transformer.extract_inline_content(italic)
+              Model::Inline::Italic.new(content: content, unconstrained: true)
+            end
+
+            # Highlight (constrained)
+            rule(highlight_constrained: subtree(:highlight)) do
+              content = Transformer.extract_inline_content(highlight)
+              Model::Inline::Highlight.new(content: content, unconstrained: false)
+            end
+
+            # Highlight (unconstrained)
+            rule(highlight_unconstrained: subtree(:highlight)) do
+              content = Transformer.extract_inline_content(highlight)
+              Model::Inline::Highlight.new(content: content, unconstrained: true)
+            end
+
+            # Monospace (constrained)
+            rule(monospace_constrained: subtree(:monospace)) do
+              content = Transformer.extract_inline_content(monospace)
+              Model::Inline::Monospace.new(content: content, unconstrained: false)
+            end
+
+            # Monospace (unconstrained)
+            rule(monospace_unconstrained: subtree(:monospace)) do
+              content = Transformer.extract_inline_content(monospace)
+              Model::Inline::Monospace.new(content: content, unconstrained: true)
+            end
+
+            # Superscript
+            rule(superscript: subtree(:superscript)) do
+              content = Transformer.extract_simple_inline_content(superscript)
+              Model::Inline::Superscript.new(content:)
+            end
+
+            # Subscript
+            rule(subscript: subtree(:subscript)) do
+              content = Transformer.extract_simple_inline_content(subscript)
+              Model::Inline::Subscript.new(content:)
+            end
+
+            # Span (constrained)
+            rule(span_constrained: subtree(:span_constrained)) do
+              Model::Inline::Span.new(
+                text: span_constrained[:text],
+                unconstrained: false,
+                attributes: span_constrained[:attribute_list]
+              )
+            end
+
+            # Span (unconstrained)
+            rule(span_unconstrained: subtree(:span_unconstrained)) do
+              Model::Inline::Span.new(
+                text: span_unconstrained[:text],
+                unconstrained: true,
+                attributes: span_unconstrained[:attribute_list]
+              )
+            end
+
+            # Highlight (simple)
+            rule(highlight: simple(:text)) do
+              Model::Highlight.new(content: text)
+            end
+            # Stem
+            rule(stem: subtree(:stem)) do
+              Coradoc::AsciiDoc::Model::Inline::Stem.new(
+                type: stem[:stem_type],
+                content: stem[:content]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end