coradoc-adoc 2.0.22 → 2.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42db73896b69e9e5344105625afe528bd2b7b8f57a11822f61881e782be8b974
-  data.tar.gz: bc3e5e3073992f0d2b71e12ab62fa07d11cdf6ded25299d673f863522cd6291d
+  metadata.gz: 69bc04902f8020decc17928a5397de2876f060ed8ee36de95f0920ba6312e8b4
+  data.tar.gz: ca56574d1b78863a574551732397ff65944f2b012781def3bb4ea4bcf8b0aaf1
 SHA512:
-  metadata.gz: 334c5ae5f1860ccde94bb518e8bc7f91be7dcce338d863d93ec137acbfedce8f742be44336fde3e4cec7ea6709b3f309c484c716ceb8c485da2830312515d59e
-  data.tar.gz: 3f387aab6c8b6d8862319593b9c2b8c2304758c4c66f15aed0e5ac57209f2f35b4930d1d95a57b2cf4d940834599db35395546c81b8d7760384062d0a7a48d49
+  metadata.gz: 708cf53d7a9c6de58e15aac99a1e77343e004b7d014697335cd91f96143584b0701235e84030948a5ab6a09eba8612a361b215b1be9707ca07943d3f7179ad09
+  data.tar.gz: ff60d697d4fff0ec229ca5b597f1fe2f37d34129bff79f10276b72824ecd418f770d9229800dee6f143f95345af0c1432aceb100385b6c578fd08abb01a3767a

data/lib/coradoc/asciidoc/model/attribute_list.rb

@@ -87,6 +87,20 @@ module Coradoc
           )
         end
 
+        # Remove the first named attribute matching `name` and return its
+        # scalar value (or nil if absent). Used by promoters that lift a
+        # named attr out of the residual bag into a typed field.
+        # @param name [String, Symbol]
+        # @return [String, nil]
+        def delete_named(name)
+          name_str = name.to_s
+          idx = named.index { |n| n.name.to_s == name_str }
+          return nil unless idx
+
+          removed = @named.delete_at(idx)
+          removed.value.first&.to_s
+        end
+
         # Validate named attributes against validators
         #
         # @param validators [Hash] Hash of name => matcher pairs
@@ -209,12 +223,24 @@ module Coradoc
           positional.empty? && named.empty?
         end
 
-        # Get a named attribute value by name
+        # Get the scalar value of the first named attribute matching `name`.
+        # Returns the first element of the underlying multi-value array, or
+        # nil if the name is absent. Use {#fetch_all} to retrieve the full
+        # multi-value array.
         # @param name [String, Symbol] The attribute name
-        # @return [Object, nil] The attribute value or nil if not found
+        # @return [String, nil]
         def [](name)
           name_str = name.to_s
-          named.find { |n| n.name.to_s == name_str }&.value
+          named.find { |n| n.name.to_s == name_str }&.value&.first&.to_s
+        end
+
+        # Get the full multi-value array for a named attribute.
+        # @param name [String, Symbol]
+        # @return [Array<String>] (empty when absent)
+        def fetch_all(name)
+          name_str = name.to_s
+          found = named.find { |n| n.name.to_s == name_str }
+          found ? found.value : []
         end
 
         # Get a named attribute value with default
@@ -222,7 +248,8 @@ module Coradoc
         # @param default [Object] The default value if not found
         # @return [Object] The attribute value or default
         def fetch(name, default = nil)
-          self[name] || default
+          value = self[name]
+          value.nil? ? default : value
         end
       end
     end

data/lib/coradoc/asciidoc/model/image/attribute_extractor.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      module Image
+        # Pure-function promoter: lifts semantically meaningful slots out of
+        # a generic {Model::AttributeList} into the typed fields declared on
+        # an image class, and the inverse — composes a serialisable
+        # AttributeList from typed fields + residual.
+        #
+        # The promotion map is owned by the target class itself, via
+        # +promoted_positional+ and +promoted_named+. This module is the
+        # single place that consumes those declarations, so adding a new
+        # promoted field is a one-line class-level change (OCP).
+        #
+        # Positional slots are consumed by index; named slots are removed
+        # from the residual list so they don't appear twice. The residual
+        # list preserves order and identity for everything that wasn't
+        # promoted (e.g. +scaledwidth+, +pdfwidth+, +opts+).
+        #
+        # @example Extract for an inline image
+        #   list = Model::AttributeList.new
+        #   list.add_positional('Alt', 'Thumb')
+        #   list.add_named('width', '640')
+        #   extracted, residual = AttributeExtractor.call(list, InlineImage)
+        #   extracted  # => { alt: 'Alt', role: 'Thumb', width: '640' }
+        #   residual.positional   # => []
+        #   residual.named         # => []
+        #
+        # @example Compose for serialisation
+        #   AttributeExtractor.compose(image)
+        #   # => Model::AttributeList with positional [alt, role] + named
+        #   #    [width, height, link] + residual attrs, in declaration order
+        #
+        module AttributeExtractor
+          module_function
+
+          # @param attribute_list [Model::AttributeList, nil]
+          # @param target_class [Class] an Image::Core subclass
+          # @return [Array<(Hash{Symbol=>String}, Model::AttributeList)>]
+          #   a tuple of promoted typed values and the residual list
+          def call(attribute_list, target_class)
+            source = attribute_list || Model::AttributeList.new
+            residual = Model::AttributeList.new
+            extracted = {}
+
+            promote_positional(extracted, residual, source, target_class)
+            promote_named(extracted, residual, source, target_class)
+
+            [extracted, residual]
+          end
+
+          # Inverse of {call}: rebuild a serialisable AttributeList from a
+          # model's typed fields plus its residual list. Used by the AsciiDoc
+          # image serializer so round-trips reproduce the original syntax.
+          #
+          # A field that's declared in both +promoted_positional+ and
+          # +promoted_named+ (e.g. inline image +role+) is emitted only
+          # once — via its positional slot when filled, otherwise via named.
+          # @param model [Coradoc::AsciiDoc::Model::Image::Core]
+          # @return [Model::AttributeList]
+          def compose(model)
+            composed = Model::AttributeList.new
+            filled = compose_positional(composed, model)
+            compose_named(composed, model, filled)
+            append_residual(composed, model.attributes)
+            composed
+          end
+
+          def compose_positional(composed, model)
+            filled = []
+            model.class.promoted_positional.each do |attr_name|
+              value = model.public_send(attr_name)
+              next if value.nil? || value.to_s.empty?
+
+              composed.add_positional(value.to_s)
+              filled << attr_name
+            end
+            filled
+          end
+
+          def compose_named(composed, model, filled)
+            model.class.promoted_named.each do |attr_name|
+              next if filled.include?(attr_name)
+
+              value = model.public_send(attr_name)
+              next if value.nil? || value.to_s.empty?
+
+              composed.add_named(attr_name.to_s, value.to_s)
+            end
+          end
+
+          def promote_positional(extracted, residual, source, target_class)
+            promoted = target_class.promoted_positional
+            source.positional.each_with_index do |positional_attr, index|
+              attr_name = promoted[index]
+              value = positional_attr.value
+              if attr_name && !value.to_s.empty?
+                extracted[attr_name] = value.to_s
+              else
+                residual.add_positional(value)
+              end
+            end
+          end
+
+          def promote_named(extracted, residual, source, target_class)
+            promoted_names = target_class.promoted_named.to_set(&:to_s)
+            source.named.each do |named_attr|
+              promote_one_named(extracted, residual, named_attr, promoted_names)
+            end
+          end
+
+          def promote_one_named(extracted, residual, named_attr, promoted_names)
+            name_str = named_attr.name.to_s
+            unless promoted_names.include?(name_str)
+              residual.add_named(named_attr.name, named_attr.value)
+              return
+            end
+            # Positional promotion wins: a slot already filled positionally
+            # is not overwritten by a same-named entry (rare, but possible
+            # when both `[alt, role, role=X]` are supplied).
+            key = name_str.to_sym
+            return if extracted.key?(key)
+
+            value = named_attr.value.first&.to_s
+            return if value.nil? || value.empty?
+
+            extracted[key] = value
+          end
+
+          def append_residual(composed, residual)
+            return unless residual.is_a?(Model::AttributeList)
+
+            residual.positional.each { |p| composed.add_positional(p.value) }
+            residual.named.each { |n| composed.add_named(n.name, n.value) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/image/block_image.rb

@@ -18,6 +18,14 @@ module Coradoc
                     default: lambda {
                       ::Coradoc::AsciiDoc::Model::AttributeList.new
                     }
+
+          # Block images support the legacy positional form
+          # `image::target[alt, caption, role, ...]`, so the 2nd positional
+          # is promoted to `caption` (Asciidoctor image block macro shorthand).
+          # @return [Array<Symbol>]
+          def self.promoted_positional
+            %i[alt caption]
+          end
         end
       end
     end

data/lib/coradoc/asciidoc/model/image/core.rb

@@ -9,30 +9,21 @@ module Coradoc
         # Images can be block-level (standalone paragraphs) or inline (within text).
         # This base class provides common functionality for both types.
         #
-        # @!attribute [r] id
-        #   @return [String, nil] Optional identifier for the image
+        # Typed promotion of attribute-list slots
+        # ---------------------------------------
         #
-        # @!attribute [r] title
-        #   @return [String, nil] Optional image title/alt text
-        #
-        # @!attribute [r] src
-        #   @return [String] The image source URL or path
-        #
-        # @!attribute [r] attributes
-        #   @return [Coradoc::AsciiDoc::Model::Image::Core::AttributeList] Image-specific attributes
-        #
-        # @!attribute [r] annotate_missing
-        #   @return [String, nil] Annotation text for missing images
-        #
-        # @!attribute [r] line_break
-        #   @return [String] Line break character (default: "")
-        #
-        # @!attribute [r] colons
-        #   @return [String, nil] Colon positioning for attributes
-        #
-        # @see Coradoc::AsciiDoc::Model::Image::BlockImage Block-level images
-        # @see Coradoc::AsciiDoc::Model::Image::InlineImage Inline images
+        # Semantically meaningful image attributes (`alt`, `role`, `width`,
+        # `height`, `link`) are declared as typed lutaml-model fields on
+        # `Core` itself — not as validators on a generic bag. The class-level
+        # {promoted_positional} and {promoted_named} methods are the single
+        # source of truth for which slots get lifted into typed fields and in
+        # what order; subclasses override them to reflect syntax differences
+        # (e.g. inline images treat the 2nd positional as `role`, block images
+        # do not).
         #
+        # The lift itself is performed by {AttributeExtractor}, a pure function
+        # over (AttributeList, target_class) → (extracted_hash, residual_list).
+        # Anything not promoted stays in `attributes` for round-trip fidelity.
         class Core < Coradoc::AsciiDoc::Model::Base
           # Autoload nested AttributeList class
           autoload :AttributeList, 'coradoc/asciidoc/model/image/core/attribute_list'
@@ -42,6 +33,12 @@ module Coradoc
           attribute :id, :string
           attribute :title, :string
           attribute :src, :string
+          attribute :alt, :string
+          attribute :caption, :string
+          attribute :role, :string
+          attribute :width, :string
+          attribute :height, :string
+          attribute :link, :string
           attribute :attributes,
                     Coradoc::AsciiDoc::Model::Image::Core::AttributeList,
                     default: lambda {
@@ -51,17 +48,29 @@ module Coradoc
           attribute :line_break, :string, default: -> { '' }
           attribute :colons, :string
 
-          # Aliases for common attribute accessors
           alias path src
-          alias alt title
+
+          # Positional attribute-list slots that this image class promotes to
+          # typed fields, in order. Subclasses override to reflect their
+          # syntax. Index 0 → alt for all image kinds; index 1 → role for
+          # inline images only.
+          # @return [Array<Symbol>]
+          def self.promoted_positional
+            %i[alt]
+          end
+
+          # Named attribute-list keys that this image class promotes to typed
+          # fields. The same set applies to both inline and block images.
+          # @return [Array<Symbol>]
+          def self.promoted_named
+            %i[width height link role]
+          end
 
           # Custom to_adoc implementation that uses ElementRegistry directly
           # to avoid recursion issues with image serialization.
           #
           # @return [String] AsciiDoc representation of this image
           def to_adoc
-            # Use the registered serializer rather than Coradoc::AsciiDoc::Serializer.serialize
-            # to avoid recursion
             serializer_class = Coradoc::AsciiDoc::Serializer::ElementRegistry.lookup(self.class)
             serializer_class.new.to_adoc(self)
           end

data/lib/coradoc/asciidoc/model/image/inline_image.rb

@@ -10,6 +10,13 @@ module Coradoc
           end
 
           attribute :colons, :string, default: -> { ':' }
+
+          # Inline images use the 2nd positional slot for the role, per
+          # Asciidoctor: `image:target[alt, role, width=N, ...]`.
+          # @return [Array<Symbol>]
+          def self.promoted_positional
+            %i[alt role]
+          end
         end
       end
     end

data/lib/coradoc/asciidoc/model/image.rb

@@ -8,6 +8,7 @@ module Coradoc
         autoload :Core, 'coradoc/asciidoc/model/image/core'
         autoload :InlineImage, 'coradoc/asciidoc/model/image/inline_image'
         autoload :BlockImage, 'coradoc/asciidoc/model/image/block_image'
+        autoload :AttributeExtractor, 'coradoc/asciidoc/model/image/attribute_extractor'
       end
     end
   end

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

@@ -44,7 +44,10 @@ module Coradoc
         end
 
         def positional_value_unquoted
-          match('[^\],]').repeat(1)
+          # Exclude `=` so that `key=value` is matched by `named_attribute`
+          # rather than swallowed as a single positional token. A positional
+          # value that legitimately contains `=` must be quoted.
+          match('[^\],=]').repeat(1)
         end
 
         def positional_value_single_quote

data/lib/coradoc/asciidoc/serializer/serializers/image/core.rb

@@ -14,7 +14,8 @@ module Coradoc
                         end
               _anchor = model.anchor.nil? ? '' : "#{serialize_child(model.anchor)}\n"
               _title = model.title.to_s.empty? ? '' : ".#{model.title}\n"
-              attrs = serialize_child(model.attributes, options)
+              composed = Model::Image::AttributeExtractor.compose(model)
+              attrs = serialize_child(composed, options)
               [missing, _anchor, _title, 'image', model.colons, model.src, attrs,
                model.line_break].join
             end
@@ -24,6 +25,7 @@ module Coradoc
         # Self-register this serializer
         ElementRegistry.register(Coradoc::AsciiDoc::Model::Image::Core, Image::Core)
         ElementRegistry.register(Coradoc::AsciiDoc::Model::Image::BlockImage, Image::Core)
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Image::InlineImage, Image::Core)
       end
     end
   end

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

@@ -26,24 +26,22 @@ module Coradoc
             end
 
             def transform_image(image)
-              src = image.src.to_s
-              src = src[1..] if src.start_with?(':')
-              positional = image.attributes&.positional || []
-              positional_alt = positional.first&.value&.to_s || ''
-              caption = positional[1]&.value&.to_s
-              title = image.title&.to_s
-              # AsciiDoc block-title (`.Caption`) is semantically a caption,
-              # but for compatibility with the existing pipeline that treated
-              # it as alt when no positional alt was supplied, fall back to it.
-              alt = positional_alt.empty? ? title : positional_alt
-              Coradoc::CoreModel::Image.new(
-                src: src,
-                alt: alt,
-                caption: caption,
-                title: title,
-                width: image.attributes&.[]('width'),
-                height: image.attributes&.[]('height')
-              )
+              Coradoc::CoreModel::Image.new(**image_attributes(image))
+            end
+
+            def image_attributes(image)
+              {
+                src: normalize_image_src(image.src),
+                alt: image.alt, title: image.title, caption: image.caption,
+                width: image.width, height: image.height,
+                link: image.link, role: image.role,
+                inline: image.is_a?(Coradoc::AsciiDoc::Model::Image::InlineImage)
+              }
+            end
+
+            def normalize_image_src(src)
+              s = src.to_s
+              s.start_with?(':') ? s[1..] : s
             end
 
             def transform_bibliography(bib)

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

@@ -327,11 +327,17 @@ module Coradoc
           end
 
           def transform_image(image)
-            Coradoc::AsciiDoc::Model::Image::BlockImage.new(
-              src: image.src,
-              title: image.alt,
-              attributes: build_image_attributes(image)
-            )
+            target_class = image.inline ? Coradoc::AsciiDoc::Model::Image::InlineImage
+                                        : Coradoc::AsciiDoc::Model::Image::BlockImage
+            target_class.new(**image_attributes(image))
+          end
+
+          def image_attributes(image)
+            {
+              src: image.src, alt: image.alt, title: image.title,
+              caption: image.caption, width: image.width, height: image.height,
+              link: image.link, role: image.role
+            }
           end
 
           def transform_bibliography(bib)
@@ -530,6 +536,10 @@ module Coradoc
               content.map { |item| create_text_elements(item) }
             when Coradoc::CoreModel::InlineElement
               transform_inline(content)
+            when Coradoc::CoreModel::TextContent
+              Coradoc::AsciiDoc::Model::TextElement.new(content: content.text.to_s)
+            when Coradoc::CoreModel::Base
+              transform(content)
             when Coradoc::AsciiDoc::Model::Base
               content
             when Lutaml::Model::Serializable
@@ -555,13 +565,6 @@ module Coradoc
             attrs
           end
 
-          def build_image_attributes(image)
-            attrs = {}
-            attrs['width'] = image.width if image.width
-            attrs['height'] = image.height if image.height
-            attrs
-          end
-
           def default_marker(marker_type)
             case marker_type
             when 'ordered' then '.'

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

@@ -54,12 +54,16 @@ module Coradoc
               title = block_image[:title]
               path = block_image[:path]
               attrs = AttributeListNormalizer.coerce(block_image[:attribute_list_macro])
+              promoted, residual = Model::Image::AttributeExtractor.call(
+                attrs, Model::Image::BlockImage
+              )
               Model::Image::BlockImage.new(
                 title: title,
                 id: id,
                 src: path,
-                attributes: attrs,
-                line_break: "\n"
+                attributes: residual,
+                line_break: "\n",
+                **promoted
               )
             end
           end

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

@@ -37,9 +37,13 @@ module Coradoc
             # Inline image
             rule(inline_image: subtree(:inline_image)) do
               attrs = AttributeListNormalizer.coerce(inline_image[:attribute_list])
+              promoted, residual = Model::Image::AttributeExtractor.call(
+                attrs, Model::Image::InlineImage
+              )
               Model::Image::InlineImage.new(
                 src: inline_image[:path],
-                attributes: attrs
+                attributes: residual,
+                **promoted
               )
             end
 

data/lib/coradoc/asciidoc/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.22
+  version: 2.0.23
 platform: ruby
 authors:
 - Ribose Inc.
@@ -146,6 +146,7 @@ files:
 - lib/coradoc/asciidoc/model/header.rb
 - lib/coradoc/asciidoc/model/highlight.rb
 - lib/coradoc/asciidoc/model/image.rb
+- lib/coradoc/asciidoc/model/image/attribute_extractor.rb
 - lib/coradoc/asciidoc/model/image/block_image.rb
 - lib/coradoc/asciidoc/model/image/block_image/attribute_list.rb
 - lib/coradoc/asciidoc/model/image/core.rb