coradoc 1.1.7 → 2.0.2

data/coradoc-adoc/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/coradoc-adoc/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/coradoc-adoc/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/coradoc-adoc/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

data/coradoc-adoc/lib/coradoc/asciidoc/transformer/list_rules.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Module containing list transformation rules
+      module ListRules
+        def self.apply(transformer_class)
+          transformer_class.class_eval do
+            # List item
+            rule(list_item: subtree(:list_item)) do
+              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]
+
+              # Convert nested array to proper List object if needed
+              if nested.is_a?(Array) && nested.any?
+                first_marker = nested.first.is_a?(Model::List::Item) ? nested.first.marker : marker
+                nested = if first_marker.to_s.start_with?('.', '1', 'a', 'A', 'i', 'I')
+                           Model::List::Ordered.new(items: nested)
+                         else
+                           Model::List::Unordered.new(items: nested)
+                         end
+              end
+
+              Model::List::Item.new(
+                content: text, id:, marker:, attached:, nested:, line_break:
+              )
+            end
+
+            # List passthrough
+            rule(list: simple(:list)) do
+              list
+            end
+
+            # Unordered list
+            rule(unordered: sequence(:list_items)) do
+              Model::List::Unordered.new(items: list_items)
+            end
+
+            rule(
+              attribute_list: simple(:attribute_list),
+              unordered: sequence(:list_items)
+            ) do
+              Model::List::Unordered.new(items: list_items, attrs: attribute_list)
+            end
+
+            # Ordered list
+            rule(ordered: sequence(:list_items)) do
+              Model::List::Ordered.new(items: list_items)
+            end
+
+            rule(
+              attribute_list: simple(:attribute_list),
+              ordered: sequence(:list_items)
+            ) do
+              Model::List::Ordered.new(items: list_items, attrs: attribute_list)
+            end
+
+            # Definition list term
+            rule(dlist_term: simple(:term), delimiter: simple(:_delim)) do
+              term.to_s
+            end
+
+            # Definition list item
+            rule(
+              definition_list_item: {
+                terms: sequence(:terms),
+                definition: simple(:contents)
+              }
+            ) do
+              Model::List::DefinitionItem.new(terms: terms, contents: contents)
+            end
+
+            # Definition list item with hash terms (single term case)
+            rule(
+              definition_list_item: subtree(:item_data)
+            ) do
+              terms_data = item_data[:terms]
+              definition = item_data[:definition]
+
+              # Extract terms
+              terms = if terms_data.is_a?(Array)
+                        terms_data.map do |t|
+                          if t.is_a?(Hash) && t[:dlist_term]
+                            t[:dlist_term].to_s
+                          else
+                            t.to_s
+                          end
+                        end
+                      else
+                        [terms_data.to_s]
+                      end
+
+              # Extract definition
+              if definition.is_a?(Parslet::Slice)
+              end
+              contents = definition.to_s
+
+              Model::List::DefinitionItem.new(terms: terms, contents: contents)
+            end
+
+            rule(definition_list: sequence(:list_items)) do
+              Model::List::Definition.new(items: list_items)
+            end
+
+            # Definition list with attribute_list (e.g., [%key])
+            rule(
+              attribute_list: simple(:attribute_list),
+              definition_list: sequence(:list_items)
+            ) do
+              Model::List::Definition.new(items: list_items, attrs: attribute_list)
+            end
+
+            # List containing definition_list
+            rule(
+              attribute_list: simple(:attribute_list),
+              definition_list: sequence(:list_items)
+            ) do
+              Model::List::Definition.new(items: list_items, attrs: attribute_list)
+            end
+          end
+        end
+      end
+    end
+  end
+end