coradoc-adoc 2.0.21 → 2.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c4b5749f4fd1a691eb76fe9f7848b1d4bc2cd2e43cd2ee0a5f1afdcb697459c
-  data.tar.gz: 90e6bf66da9a7c4dba7c7eafbdabf378259e4b9792a93d4c88209d52bd991876
+  metadata.gz: 42db73896b69e9e5344105625afe528bd2b7b8f57a11822f61881e782be8b974
+  data.tar.gz: bc3e5e3073992f0d2b71e12ab62fa07d11cdf6ded25299d673f863522cd6291d
 SHA512:
-  metadata.gz: e421d05a3a2c43387471224818a5261229478c1539ddade33a30957be8d7fb0775c9b0bb95b59afa32cb4e84f0adab07b62164113a521635fd5e70cdbe66ecec
-  data.tar.gz: dd6c2ea15fcb4c3e521a929006ba2e7ebbff5f6548902a2d7947cdac04a9005a792a9ae4fb07d68f53e30c844de9cbd00bd62a0fa034fa9f9c298209fe50ec7e
+  metadata.gz: 334c5ae5f1860ccde94bb518e8bc7f91be7dcce338d863d93ec137acbfedce8f742be44336fde3e4cec7ea6709b3f309c484c716ceb8c485da2830312515d59e
+  data.tar.gz: 3f387aab6c8b6d8862319593b9c2b8c2304758c4c66f15aed0e5ac57209f2f35b4930d1d95a57b2cf4d940834599db35395546c81b8d7760384062d0a7a48d49

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

@@ -4,13 +4,22 @@ module Coradoc
   module AsciiDoc
     module Parser
       module Admonition
+        # Match a single style name case-insensitively. Each character
+        # class `[Xx]` lets the same alternation accept +note+, +Note+,
+        # and +NOTE+ without three separate str() branches per style.
+        def case_insensitive_str(s)
+          s.chars.reduce(nil) do |acc, ch|
+            node = match("[#{ch.upcase}#{ch.downcase}]")
+            acc.nil? ? node : (acc >> node)
+          end
+        end
+
         def admonition_type
-          str('NOTE') | str('TIP') | str('EDITOR') |
-            str('IMPORTANT') | str('WARNING') | str('CAUTION') |
-            str('TODO')
-          # requires atypical syntax for access?
-          # | str('DANGER')
-          # | str('SAFETY PRECAUTION')
+          styles = Coradoc::AsciiDoc::Transform::ElementTransformers::AdmonitionStyles.all_styles
+          styles.reduce(nil) do |acc, style|
+            matcher = case_insensitive_str(style)
+            acc.nil? ? matcher : (acc | matcher)
+          end
         end
 
         def admonition_line

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

@@ -120,20 +120,38 @@ module Coradoc
           (str('image:').present? >> str('image:') >>
             str(':').absent? >>
             match('[A-Za-z0-9_.\\-:/&?=+,%#~;]+').repeat(1).as(:path) >>
-            (str('[') >> match('[^\\]]').repeat(1).as(:text) >> str(']')).maybe
+            attribute_list(:attribute_list).maybe
           ).as(:inline_image)
         end
 
         # Triple-plus inline passthrough: `+++raw content+++`. The content
         # passes through all substitutions verbatim. Common use is to embed
         # raw HTML in AsciiDoc documents.
-        def inline_passthrough
+        def inline_passthrough_triple_plus
           (str('+++') >>
             (str('+++').absent? >> match('[^\n]')).repeat(1).as(:raw) >>
             str('+++')
           ).as(:inline_passthrough)
         end
 
+        # `pass:[raw]` macro form. Equivalent semantic to triple-plus:
+        # the bracket payload survives all substitutions verbatim. Common
+        # use is inside monospace spans to keep characters like `<` from
+        # being re-interpreted as xref markers. The optional `subs` segment
+        # (`pass:quotes[...]`) is consumed but currently ignored — the
+        # payload is always passed through raw.
+        def inline_passthrough_macro
+          (str('pass:').present? >> str('pass:') >>
+            match('[a-zA-Z,+]').repeat(0) >>
+            str('[') >> (str(']]').absent? >> match('[^\]\n]')).repeat(1).as(:raw) >>
+            str(']')
+          ).as(:inline_passthrough)
+        end
+
+        def inline_passthrough
+          inline_passthrough_triple_plus | inline_passthrough_macro
+        end
+
         def underline
           (attribute_list >> match('\\[.underline\\]').as(:role) >>
             str('#') >>
@@ -157,10 +175,26 @@ module Coradoc
             str('link:').present? |
             str('image:').present? |
             str('+++').present? |
+            str('pass:').present? |
             term_type.present? |
             str('footnote').present? |
             stem_type.present? |
-            str('\\<<').present?
+            str('\\<<').present? |
+            hard_line_break_marker?
+        end
+
+        # AsciiDoc hard line break: a space followed by `+` at end of line,
+        # or a backslash at end of line. Both forms render as `<br>` inside
+        # the enclosing paragraph/verse. Recognised ahead of `text_unformatted`
+        # so the marker isn't swallowed as plain text.
+        def hard_line_break_marker?
+          (str(' +') >> str("\n")).present? |
+            (str('\\') >> str("\n")).present?
+        end
+
+        def hard_line_break
+          ((str(' +') >> str("\n")) |
+             (str('\\') >> str("\n"))).as(:hard_line_break)
         end
 
         def inline
@@ -187,7 +221,8 @@ module Coradoc
             inline_image |
             inline_passthrough |
             underline |
-            small
+            small |
+            hard_line_break
         end
 
         def text_unformatted

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

@@ -149,8 +149,13 @@ module Coradoc
         end
 
         def dlist_definition
-          text
-            .as(:definition) >> line_ending >> empty_line.repeat(0)
+          # AsciiDoc convention: the definition body is indented relative
+          # to the term. That leading whitespace is structural (marks
+          # the line as a continuation of the dlist item), not content.
+          # Consume it without capturing so downstream CoreModel text
+          # doesn't carry the source indentation into HTML/Markdown.
+          (match('[ \t]').repeat(0) >> text.as(:definition)) >>
+            line_ending >> empty_line.repeat(0)
         end
 
         def dlist_item(_delimiter = nil)

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

@@ -26,6 +26,21 @@ module Coradoc
               BUILTIN.include?(name) || custom.include?(name)
             end
 
+            # Canonical uppercase form for +style+, or nil if unknown.
+            # Single source of truth for the canonical casing used in
+            # CoreModel::AnnotationBlock#annotation_type and AsciiDoc
+            # round-trip output.
+            def canonicalize(style)
+              return nil unless admonition?(style)
+
+              style.to_s.upcase
+            end
+
+            # All registered style names (BUILTIN + custom), lowercased.
+            def all_styles
+              (BUILTIN + custom).freeze
+            end
+
             # Register an additional admonition style. Open for extension.
             def register(style)
               name = style.to_s.downcase

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

@@ -71,16 +71,26 @@ module Coradoc
 
             # Dispatch entry point for any block whose AsciiDoc model carries
             # an attribute list (delimited blocks + open blocks). Per the
-            # AsciiDoc spec, every delimited block accepts admonition styles
-            # in its attribute line. Admonition style wins for example,
-            # sidebar, quote, and open blocks; verbatim blocks (source,
-            # listing) intentionally ignore it because their verbatim
-            # semantics are stronger than the annotation label.
+            # AsciiDoc spec, every delimited block accepts both admonition
+            # labels and verbatim/stem casts in its attribute line. The cast
+            # is resolved by +block_cast_semantic+ in MECE order:
+            # admonition > stem > verbatim > fallback.
             def transform_with_admonition_check(block, native_class)
-              style = first_positional_attr(block)
-              return transform_admonition_block(block, style) if AdmonitionStyles.admonition?(style)
-
-              transform_typed_block(block, native_class)
+              semantic = block_cast_semantic(block)
+              case semantic
+              when :admonition
+                transform_admonition_block(block, first_positional_attr(block))
+              when :stem
+                transform_stem_block(block, first_positional_attr(block))
+              when :source
+                transform_source_block(block)
+              when :listing
+                transform_listing_from_open(block)
+              when :literal
+                transform_literal_from_open(block)
+              else
+                transform_typed_block(block, native_class)
+              end
             end
 
             def transform_example_block(block)
@@ -98,36 +108,32 @@ module Coradoc
             # Open blocks (`--`) are generic containers. AsciiDoc allows
             # casting them to a different block type via positional
             # attributes: verbatim types (`[source]`, `[listing]`,
-            # `[literal]`) and admonition labels (`[NOTE]`, `[TIP]`,
+            # `[literal]`), STEM types (`[stem]`, `[latexmath]`,
+            # `[asciimath]`), and admonition labels (`[NOTE]`, `[TIP]`,
             # `[WARNING]`, `[CAUTION]`, `[IMPORTANT]`). When such a cast
             # is present, the block behaves like the corresponding
             # delimited block. Anything else stays an OpenBlock.
             def transform_open_block(block)
-              semantic = open_block_semantic(block)
-              case semantic
-              when :source
-                transform_source_block(block)
-              when :listing
-                transform_listing_from_open(block)
-              when :literal
-                transform_literal_from_open(block)
-              when :admonition
-                transform_admonition_block(block, first_positional_attr(block))
-              else
-                transform_typed_block(block, Coradoc::CoreModel::OpenBlock)
-              end
+              transform_with_admonition_check(block, Coradoc::CoreModel::OpenBlock)
             end
 
             VERBATILE_CAST_STYLES = %w[source listing literal].freeze
 
-            def open_block_semantic(block)
+            # Resolve a delimited block's cast from its first positional
+            # attribute. Single source of truth for the cast ladder used
+            # by every block-form transformer (example/sidebar/quote/open).
+            # Returns one of: :admonition, :stem, :source, :listing,
+            # :literal, or nil (no cast — use the block's native class).
+            def block_cast_semantic(block)
               style = first_positional_attr(block)
               return nil unless style
 
-              case style.to_s.downcase
-              when *VERBATILE_CAST_STYLES then :"#{style.downcase}"
-              else :admonition if AdmonitionStyles.admonition?(style)
-              end
+              style_str = style.to_s.downcase
+              return :admonition if AdmonitionStyles.admonition?(style)
+              return :stem if STEM_STYLES.key?(style_str)
+              return style_str.to_sym if VERBATILE_CAST_STYLES.include?(style_str)
+
+              nil
             end
 
             # Returns the first positional attribute on the block's
@@ -148,10 +154,14 @@ module Coradoc
             # (example / sidebar / quote / pass / open). Builds an
             # AnnotationBlock with annotation_type set from the style and
             # the block's body lines joined into a single content string.
+            # Type is canonicalised via AdmonitionStyles so every code path
+            # (line admonition, block admonition, attribute-cast admonition)
+            # produces the same uppercase key.
             def transform_admonition_block(block, type)
+              canonical = AdmonitionStyles.canonicalize(type) || type.to_s
               content_lines = Array(block.lines).map { |line| ToCoreModel.extract_text_content(line) }.join("\n")
               Coradoc::CoreModel::AnnotationBlock.new(
-                annotation_type: type.to_s.downcase,
+                annotation_type: canonical,
                 content: content_lines,
                 title: ToCoreModel.extract_title_text(block.title)
               )

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

@@ -13,6 +13,7 @@ module Coradoc
               children = CalloutMerger.call(children)
               children = prepend_frontmatter(children, doc.frontmatter)
               children = insert_title_heading_after_frontmatter(children, title_text)
+              children = resolve_attribute_references(children, attributes)
 
               Coradoc::CoreModel::DocumentElement.new(
                 id: doc.id,
@@ -58,6 +59,16 @@ module Coradoc
               children.insert(frontmatter_count, title_heading)
             end
 
+            # Resolve `{name}` attribute references in the body against the
+            # document's own declared attributes. Single source of truth:
+            # the resolver lives in core so other format gems can reuse it
+            # when they have equivalent reference macros.
+            def resolve_attribute_references(children, attributes)
+              return children if attributes.nil? || attributes.keys.empty?
+
+              Coradoc::CoreModel::AttributeReferenceResolver.call(children, attributes)
+            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(

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

@@ -67,20 +67,28 @@ module Coradoc
               )
               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
-
+              nested_lists = extract_nested_lists(item)
+              li.nested_list = nested_lists.first if nested_lists.size == 1
               li
             end
 
+            # Pull every nested List::Core off the AsciiDoc model item and
+            # transform each into a CoreModel::ListBlock. Returns [] when
+            # the item has no nested lists. Single source of truth for the
+            # nested-list shape so transform_list_item and any future caller
+            # share the same extraction logic.
+            def extract_nested_lists(item)
+              nested = item.nested
+              return [] if nested.nil?
+
+              candidates = nested.is_a?(Array) ? nested : [nested]
+              candidates.filter_map do |n|
+                next unless n.is_a?(Coradoc::AsciiDoc::Model::List::Core)
+
+                transform_list(n, list_marker_type(n))
+              end
+            end
+
             def list_marker_type(list)
               case list
               when Coradoc::AsciiDoc::Model::List::Ordered then 'ordered'

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

@@ -15,9 +15,10 @@ module Coradoc
             end
 
             def transform_admonition(admonition)
+              canonical = Coradoc::AsciiDoc::Transform::ElementTransformers::AdmonitionStyles.canonicalize(admonition.type) || admonition.type.to_s
               children = ToCoreModel.transform_inline_content(admonition.content)
               block = Coradoc::CoreModel::AnnotationBlock.new(
-                annotation_type: admonition.type,
+                annotation_type: canonical,
                 content: ToCoreModel.extract_text_content(admonition.content)
               )
               block.children = children

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

@@ -319,6 +319,8 @@ module Coradoc
               )
             when 'raw_inline'
               Coradoc::AsciiDoc::Model::Inline::Passthrough.new(content: inline.content)
+            when 'hard_line_break'
+              Coradoc::AsciiDoc::Model::Inline::HardLineBreak.new
             else
               Coradoc::AsciiDoc::Model::TextElement.new(content: inline.content)
             end

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

@@ -172,9 +172,11 @@ module Coradoc
             Registry.register(
               Coradoc::AsciiDoc::Model::Inline::AttributeReference,
               lambda { |model|
+                name = model.name.to_s
                 Coradoc::CoreModel::InlineElement.new(
                   format_type: 'attribute_reference',
-                  content: "{#{model.name}}"
+                  target: name,
+                  content: "{#{name}}"
                 )
               }
             )
@@ -246,6 +248,16 @@ module Coradoc
               ->(model) { Inc.transform_include(model) }
             )
 
+            # Inline hard line break — distinct from the structural
+            # Model::LineBreak (which represents paragraph-separator blank
+            # lines and is dropped at the CoreModel boundary). Hard breaks
+            # are semantic and round-trip as CoreModel::HardLineBreakElement
+            # so HTML/Markdown renderers can map them to <br>.
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Inline::HardLineBreak,
+              ->(_model) { Coradoc::CoreModel::HardLineBreakElement.new(content: '') }
+            )
+
             [
               Coradoc::AsciiDoc::Model::Audio,
               Coradoc::AsciiDoc::Model::Video,

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

@@ -37,12 +37,15 @@ module Coradoc
               Model::Block::Example.new(title: '', lines: example)
             end
 
-            # Admonition
+            # Admonition. Canonicalise the type to uppercase so round-trips
+            # through HTML/Markdown/DocBook all see the same key used by
+            # icon and CSS-class lookups.
             rule(
               admonition_type: simple(:admonition_type),
               content: sequence(:content)
             ) do
-              Model::Admonition.new(content: content, type: admonition_type.to_s)
+              canonical = Coradoc::AsciiDoc::Transform::ElementTransformers::AdmonitionStyles.canonicalize(admonition_type.to_s)
+              Model::Admonition.new(content: content, type: canonical)
             end
 
             # Block image

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

@@ -36,14 +36,17 @@ module Coradoc
 
             # Inline image
             rule(inline_image: subtree(:inline_image)) do
+              attrs = AttributeListNormalizer.coerce(inline_image[:attribute_list])
               Model::Image::InlineImage.new(
-                title: inline_image[:text],
                 src: inline_image[:path],
-                attributes: inline_image[:attribute_list]
+                attributes: attrs
               )
             end
 
-            # Inline passthrough (`+++raw content+++`)
+            # Inline passthrough (`+++raw content+++` or `pass:[raw]`).
+            # Both forms carry an opaque payload that survives all
+            # substitutions verbatim; `form` records which syntax was
+            # used so the AsciiDoc serializer can round-trip faithfully.
             rule(inline_passthrough: subtree(:passthrough)) do
               Model::Inline::Passthrough.new(
                 content: passthrough[:raw].to_s,
@@ -56,6 +59,15 @@ module Coradoc
               Model::Inline::AttributeReference.new(name:)
             end
 
+            # Hard line break (` +\n` or `\\n`). Emitted as a dedicated
+            # AsciiDoc model (Inline::HardLineBreak) distinct from
+            # Model::LineBreak, which only represents paragraph-separator
+            # blank lines. Hard breaks carry semantic meaning: HTML/Markdown
+            # renderers map them to <br>.
+            rule(hard_line_break: simple(:_)) do
+              Model::Inline::HardLineBreak.new
+            end
+
             # Term
             rule(
               term_type: simple(:term_type),

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

@@ -20,12 +20,24 @@ module Coradoc
           cell_opts = {}
           style = parse_format(format, cell_opts)
 
-          unescaped_content = content.to_s.gsub(/\\([|!,:;])/, '\1')
+          unescaped_content = cell_content_to_string(content).gsub(/\\([|!,:;])/, '\1')
           cell_opts[:content] = parse_inline_content(unescaped_content, style)
 
           Model::TableCell.new(**cell_opts)
         end
 
+        # Coerce the parser-supplied cell content into a plain String.
+        # The cell parser emits `text:` as either a single Parslet::Slice
+        # or an Array of slices (from `.repeat(0)`). An empty Array must
+        # map to "" — Ruby's `[].to_s` returns "[]", which previously
+        # leaked into TableCell content as a phantom "[]" cell.
+        def cell_content_to_string(content)
+          return '' if content.nil?
+          return content.map(&:to_s).join if content.is_a?(Array)
+
+          content.to_s
+        end
+
         # Coerce a raw parser cell value into a TableCell.
         # Used by TableLayout.group_cells_into_rows when it encounters
         # cells that the parser emitted as Hashes or plain strings.

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.21'
+    VERSION = '2.0.22'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.21
+  version: 2.0.22
 platform: ruby
 authors:
 - Ribose Inc.