coradoc-markdown 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e985a5efd633ee5e945c01d6f9465316f36ed682e8a65fa1c6c33304f8af453c
-  data.tar.gz: ece9f3be5276f6ef0c1c325fa59a3f43452472b8aa5e2350ad690381b5b7a173
+  metadata.gz: 2f645b393312f1c1dac03f7986da00e8165c28a08fa10e656284dfd0fa8b024e
+  data.tar.gz: f90f52be5816d785860b14615ed5aff2588f6a061ed8006753adc030111f5c05
 SHA512:
-  metadata.gz: 531bc6952f8a55ccbd3b86190ced905b60242bebe6dd65873fee5cc0715fcdaa802147473fb897fb818bdec611937e48eb3b995db4844cd4c7c08a4f575bdbf7
-  data.tar.gz: 022055b32982e6a661bcbcca4e6044e8ccb4f36d265d7f4bbe1575c07e9a424acb711d8dc532a8ba49bc4afd2d56423f0c9be127bb9a996d1cdd5c9e1e738d26
+  metadata.gz: 29d1fa6b132ff28425d7ccfd7eeacfc782f9d648a07802fdbfb434134e13a2a0ee40489e207ca6ea4d1f92358feb0c94097dc168024339b833cf558e7e6bcab3
+  data.tar.gz: 92960c95e653cc2c0c16ccfb1e23563db3d1ebe7a931b4c3a28f88c8be87d922e604b6448c53d493661e42c1bbcdeb8b2b08ce0847300cee624948accebacc92

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

@@ -16,7 +16,7 @@ module Coradoc
     class AttributeList < Base
       attribute :id, :string
       attribute :classes, :string, collection: true, default: []
-      attribute :attributes, :hash, default: {}
+      attribute :attributes, NamedValue, collection: true, default: []
       attribute :name, :string # For ALD - the reference name
 
       # Parse an IAL string into an AttributeList
@@ -50,7 +50,9 @@ module Coradoc
 
         self.id = other.id if other.id
         self.classes = (classes + other.classes).uniq
-        self.attributes = attributes.merge(other.attributes)
+        merged = {}
+        (attributes + other.attributes).each { |nv| merged[nv.name] = nv }
+        self.attributes = merged.values
         self
       end
 
@@ -67,19 +69,6 @@ module Coradoc
         id.nil? && classes.empty? && attributes.empty?
       end
 
-      # Convert to Markdown IAL syntax
-      # @return [String]
-      def to_md
-        return '' if empty?
-
-        parts = []
-        parts << "##{id}" if id
-        parts += classes.map { |c| ".#{c}" }
-        parts += attributes.map { |k, v| %(#{k}="#{v}") }
-
-        "{:#{parts.join(' ')}}"
-      end
-
       def self.parse_attributes(content, attr_list)
         # Use shared IalParser for consistent parsing
         ParserUtil::IalParser.tokenize(content).each do |token|
@@ -89,7 +78,7 @@ module Coradoc
           when :id
             attr_list.id = token[:value]
           when :attribute
-            attr_list.attributes[token[:key]] = token[:value]
+            attr_list.attributes << NamedValue.new(name: token[:key], value: token[:value])
           end
         end
       end

data/lib/coradoc/markdown/model/base.rb

@@ -18,8 +18,8 @@ module Coradoc
       # Classes from IAL (for convenience)
       attribute :classes, :string, collection: true
 
-      # Additional attributes from IAL
-      attribute :attributes, :hash, default: {}
+      # Additional attributes from IAL (typed key-value pairs)
+      attribute :attributes, NamedValue, collection: true, default: []
 
       # Visit pattern for traversing the document tree
       def self.visit(element, &block)
@@ -49,38 +49,6 @@ module Coradoc
         end
         self
       end
-
-      # Serialize polymorphic content to Markdown string
-      def serialize_content(content)
-        case content
-        when Array
-          content.map { |elem| serialize_content(elem) }.join
-        when String
-          content
-        when nil
-          ''
-        else
-          if content.is_a?(Base)
-            content.to_md
-          else
-            raise ArgumentError,
-                  "Cannot serialize #{content.class.name} to Markdown. " \
-                  'Expected String or Base subclass.'
-          end
-        end
-      end
-
-      # Does a shallow attribute dump of the object
-      def to_h
-        self.class.attributes.keys.each_with_object({}) do |attribute, acc|
-          acc[attribute] = public_send(attribute)
-        end
-      end
-
-      # Serialize this model element to Markdown
-      def to_md
-        Coradoc::Markdown::Serializer.serialize(self)
-      end
     end
   end
 end

data/lib/coradoc/markdown/model/cross_reference.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    class CrossReference < Base
+      attribute :text, :string
+      attribute :target, :string
+    end
+  end
+end

data/lib/coradoc/markdown/model/definition_list.rb

@@ -30,18 +30,6 @@ module Coradoc
     class DefinitionList < Base
       # Terms with their definitions
       attribute :items, Coradoc::Markdown::DefinitionTerm, collection: true
-
-      # Serialize to Markdown
-      def to_md
-        items.map do |term|
-          term_text = term.text.to_s
-          defs = term.definitions.map do |defn|
-            content = defn.content.to_s
-            ": #{content}"
-          end.join("\n")
-          "#{term_text}\n#{defs}"
-        end.join("\n\n")
-      end
     end
   end
 end

data/lib/coradoc/markdown/model/extension.rb

@@ -13,7 +13,7 @@ module Coradoc
     #
     class Extension < Base
       attribute :name, :string
-      attribute :options, :hash, default: {}
+      attribute :options, NamedValue, collection: true, default: []
       attribute :content, :string  # For block extensions with content
       attribute :body, :string     # Alias for content
 
@@ -32,14 +32,14 @@ module Coradoc
       # @param options [Hash] TOC options (levels, etc.)
       # @return [Extension]
       def self.toc(options = {})
-        new(name: :toc, options: options)
+        new(name: :toc, options: hash_to_named(options))
       end
 
       # Create an options extension
       # @param options [Hash] Parser options
       # @return [Extension]
       def self.options(options = {})
-        new(name: :options, options: options)
+        new(name: :options, options: hash_to_named(options))
       end
 
       # Create a comment extension
@@ -69,23 +69,14 @@ module Coradoc
         content.nil? || content.empty?
       end
 
-      # Convert to Markdown
-      # @return [String]
-      def to_md
-        opts = options.empty? ? '' : " #{options_to_s}"
-        if self_closing?
-          "{::#{name}#{opts} /}"
-        else
-          "{::#{name}#{opts}}#{content}{:/}"
-        end
-      end
+      class << self
+        private
 
-      private
+        def hash_to_named(hash)
+          return [] if hash.nil? || hash.empty?
 
-      def options_to_s
-        options.map do |k, v|
-          %(#{k}="#{v}")
-        end.join(' ')
+          hash.map { |k, v| NamedValue.new(name: k.to_s, value: v.to_s) }
+        end
       end
     end
   end

data/lib/coradoc/markdown/model/footnote_reference.rb

@@ -12,11 +12,6 @@ module Coradoc
     class FootnoteReference < Base
       # The footnote identifier
       attribute :id, :string
-
-      # Serialize to Markdown
-      def to_md
-        "[^#{id}]"
-      end
     end
   end
 end

data/lib/coradoc/markdown/model/highlight.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Coradoc
   module Markdown
     # Represents highlighted text using == syntax (extended Markdown).
@@ -9,10 +8,6 @@ module Coradoc
     #
     class Highlight < Base
       attribute :text, :string
-
-      def to_md
-        "==#{text}=="
-      end
     end
   end
 end

data/lib/coradoc/markdown/model/math.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Coradoc
   module Markdown
     # Represents a math block (block or inline)
@@ -29,22 +28,9 @@ module Coradoc
         new(content: content, inline: true)
       end
 
-      # Create a block math element
-      # @param content [String] The math content
-      # @return [Math]
       def self.block(content)
         new(content: content, inline: false)
       end
-
-      # Convert to Markdown
-      # @return [String]
-      def to_md
-        if inline?
-          "$$#{content}$$"
-        else
-          "$$\n#{content}\n$$"
-        end
-      end
     end
   end
 end

data/lib/coradoc/markdown/model/named_value.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    # A typed key-value pair used wherever Markdown models need arbitrary
+    # attributes (IAL key="value" pairs, extension options, etc.).
+    #
+    # Replaces raw Hash attributes so that every attribute on a model is
+    # a typed lutaml-model declaration.
+    #
+    # @example
+    #   NamedValue.new(name: "data-role", value: "main")
+    class NamedValue < Base
+      attribute :name, :string
+      attribute :value, :string
+    end
+  end
+end

data/lib/coradoc/markdown/model/strikethrough.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Coradoc
   module Markdown
     # Represents strikethrough text using GFM ~~ syntax.
@@ -9,10 +8,6 @@ module Coradoc
     #
     class Strikethrough < Base
       attribute :text, :string
-
-      def to_md
-        "~~#{text}~~"
-      end
     end
   end
 end

data/lib/coradoc/markdown/model/subscript.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    class Subscript < Base
+      attribute :text, :string
+    end
+  end
+end

data/lib/coradoc/markdown/model/superscript.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    class Superscript < Base
+      attribute :text, :string
+    end
+  end
+end

data/lib/coradoc/markdown/model/underline.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    class Underline < Base
+      attribute :text, :string
+    end
+  end
+end

data/lib/coradoc/markdown/serializer.rb

@@ -59,15 +59,23 @@ module Coradoc
         when Abbreviation
           serialize_abbreviation(element)
         when Strikethrough
-          element.to_md
+          serialize_strikethrough(element)
         when Highlight
-          element.to_md
+          serialize_highlight(element)
+        when Subscript
+          serialize_subscript(element)
+        when Superscript
+          serialize_superscript(element)
+        when Underline
+          serialize_underline(element)
+        when CrossReference
+          serialize_cross_reference(element)
         when AttributeList
-          element.to_md
+          serialize_attribute_list(element)
         when Math
-          element.to_md
+          serialize_math(element)
         when Extension
-          element.to_md
+          serialize_extension(element)
         when String
           element
         else
@@ -99,16 +107,16 @@ module Coradoc
         case element
         when String
           element
-        when Emphasis, Strong, Code, Link, Image, FootnoteReference, Math, Extension, Strikethrough, Highlight
+        when Emphasis, Strong, Code, Link, Image, FootnoteReference, Math, Extension,
+             Strikethrough, Highlight, Subscript, Superscript, Underline, CrossReference,
+             AttributeList, DefinitionList
+          serialize(element)
+        when Base
           serialize(element)
         else
-          if element.is_a?(Base)
-            element.to_md
-          else
-            raise ArgumentError,
-                  "Cannot serialize inline content of type #{element.class}. " \
-                  'Expected String, known inline model, or Base subclass.'
-          end
+          raise ArgumentError,
+                "Cannot serialize inline content of type #{element.class}. " \
+                'Expected String, known inline model, or Base subclass.'
         end
       end
 
@@ -194,6 +202,61 @@ module Coradoc
       def serialize_abbreviation(abbr)
         "*[#{abbr.term}]: #{abbr.definition}"
       end
+
+      def serialize_strikethrough(elem)
+        "~~#{elem.text}~~"
+      end
+
+      def serialize_highlight(elem)
+        "==#{elem.text}=="
+      end
+
+      def serialize_subscript(elem)
+        "<sub>#{elem.text}</sub>"
+      end
+
+      def serialize_superscript(elem)
+        "<sup>#{elem.text}</sup>"
+      end
+
+      def serialize_underline(elem)
+        "<u>#{elem.text}</u>"
+      end
+
+      def serialize_cross_reference(elem)
+        "[#{elem.text}](##{elem.target})"
+      end
+
+      def serialize_attribute_list(elem)
+        return '' if elem.empty?
+
+        parts = []
+        parts << "##{elem.id}" if elem.id
+        parts += elem.classes.map { |c| ".#{c}" }
+        parts += elem.attributes.map { |nv| %(#{nv.name}="#{nv.value}") }
+        "{:#{parts.join(' ')}}"
+      end
+
+      def serialize_math(elem)
+        if elem.inline?
+          "$$#{elem.content}$$"
+        else
+          "$$\n#{elem.content}\n$$"
+        end
+      end
+
+      def serialize_extension(elem)
+        opts = elem.options.empty? ? '' : " #{extension_options_to_s(elem.options)}"
+        if elem.self_closing?
+          "{::#{elem.name}#{opts} /}"
+        else
+          "{::#{elem.name}#{opts}}#{elem.content}{:/}"
+        end
+      end
+
+      def extension_options_to_s(options)
+        options.map { |nv| %(#{nv.name}="#{nv.value}") }.join(' ')
+      end
     end
   end
 end

data/lib/coradoc/markdown/toc_generator.rb

@@ -2,12 +2,6 @@
 
 module Coradoc
   module Markdown
-    module Model
-      autoload :Base, "#{__dir__}/model/base"
-      autoload :Heading, "#{__dir__}/model/heading"
-      autoload :Document, "#{__dir__}/model/document"
-    end
-
     # Table of Contents Generator
     #
     # Generates a table of contents from document headings.

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

@@ -58,10 +58,10 @@ module Coradoc
           private
 
           def transform_structural_element(element)
-            case element.element_type
-            when 'document'
+            case element
+            when CoreModel::DocumentElement
               transform_document(element)
-            when 'section'
+            when CoreModel::SectionElement
               transform_section(element)
             else
               transform_generic_element(element)
@@ -94,10 +94,11 @@ module Coradoc
           end
 
           def transform_block(block)
-            case block.element_type
-            when 'paragraph'
+            semantic = block.resolve_semantic_type
+            case semantic
+            when :paragraph
               transform_paragraph(block)
-            when 'comment'
+            when :comment
               Coradoc::Markdown::Extension.comment(block.content.to_s)
             else
               transform_delimited_block(block)
@@ -106,8 +107,8 @@ module Coradoc
 
           def transform_paragraph(block)
             content = block.renderable_content
-            if content.is_a?(Array) && content.any? { |c| !c.is_a?(String) }
-              # Mixed content with inline elements
+            has_structured = content.is_a?(Array) && content.any? { |c| !c.is_a?(CoreModel::TextContent) }
+            if has_structured
               children = content.map { |c| transform_inline_content(c) }
               Coradoc::Markdown::Paragraph.new(text: block.flat_text, children: children)
             else
@@ -119,6 +120,8 @@ module Coradoc
             case element
             when Coradoc::CoreModel::InlineElement
               transform_inline(element)
+            when CoreModel::TextContent
+              element.text
             when String
               element
             else
@@ -160,7 +163,6 @@ module Coradoc
             when '>' then :quote
             when '---', '***', '___' then :horizontal_rule
             when '++++' then :pass
-            else nil
             end
           end
 
@@ -184,7 +186,8 @@ module Coradoc
           def transform_list(list)
             items = Array(list.items).map do |item|
               content = item.renderable_content
-              if content.is_a?(Array) && content.any? { |c| !c.is_a?(String) }
+              has_structured = content.is_a?(Array) && content.any? { |c| !c.is_a?(CoreModel::TextContent) }
+              if has_structured
                 children = content.map { |c| transform_inline_content(c) }
                 Coradoc::Markdown::ListItem.new(text: item.flat_text, children: children)
               else
@@ -234,7 +237,7 @@ module Coradoc
           end
 
           def transform_inline(element)
-            case element.format_type
+            case element.resolve_format_type
             when 'bold'
               Coradoc::Markdown::Strong.new(text: element.content.to_s)
             when 'italic'
@@ -255,13 +258,16 @@ module Coradoc
             when 'strikethrough'
               Coradoc::Markdown::Strikethrough.new(text: element.content.to_s)
             when 'subscript'
-              "<sub>#{element.content}</sub>"
+              Coradoc::Markdown::Subscript.new(text: element.content.to_s)
             when 'superscript'
-              "<sup>#{element.content}</sup>"
+              Coradoc::Markdown::Superscript.new(text: element.content.to_s)
             when 'underline'
-              "<u>#{element.content}</u>"
+              Coradoc::Markdown::Underline.new(text: element.content.to_s)
             when 'xref'
-              "[#{element.content}](##{element.target})"
+              Coradoc::Markdown::CrossReference.new(
+                text: element.content.to_s,
+                target: element.target.to_s
+              )
             else
               element.content.to_s
             end

data/lib/coradoc/markdown/transform/to_core_model.rb

@@ -76,8 +76,7 @@ module Coradoc
           def transform_document(doc)
             children = Array(doc.blocks).map { |block| transform(block) }
 
-            Coradoc::CoreModel::StructuralElement.new(
-              element_type: 'document',
+            Coradoc::CoreModel::DocumentElement.new(
               id: doc.id,
               title: extract_title(doc),
               children: children
@@ -85,8 +84,7 @@ module Coradoc
           end
 
           def transform_heading(heading)
-            Coradoc::CoreModel::StructuralElement.new(
-              element_type: 'section',
+            Coradoc::CoreModel::SectionElement.new(
               level: heading.level,
               title: extract_text(heading.text),
               children: []
@@ -96,15 +94,13 @@ module Coradoc
           def transform_paragraph(para)
             content = extract_text(para.text)
 
-            Coradoc::CoreModel::Block.new(
-              element_type: 'paragraph',
+            Coradoc::CoreModel::ParagraphBlock.new(
               content: content
             )
           end
 
           def transform_code_block(block)
             Coradoc::CoreModel::SourceBlock.new(
-              element_type: 'block',
               content: block.code.to_s,
               language: block.language
             )
@@ -112,7 +108,6 @@ module Coradoc
 
           def transform_blockquote(blockquote)
             Coradoc::CoreModel::QuoteBlock.new(
-              element_type: 'block',
               content: blockquote.content.to_s
             )
           end
@@ -165,25 +160,21 @@ module Coradoc
           end
 
           def transform_link(link)
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: 'link',
+            Coradoc::CoreModel::LinkElement.new(
               target: link.url,
               content: extract_text(link.text)
             )
           end
 
           def transform_inline(inline, format_type)
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: format_type,
+            klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
+            klass.new(
               content: extract_text(inline.text)
             )
           end
 
           def transform_horizontal_rule(_rule)
-            Coradoc::CoreModel::Block.new(
-              element_type: 'block',
-              block_semantic_type: :horizontal_rule
-            )
+            Coradoc::CoreModel::HorizontalRuleBlock.new
           end
 
           def transform_definition_list(dl)
@@ -221,13 +212,11 @@ module Coradoc
 
           def transform_math(math)
             if math.inline?
-              Coradoc::CoreModel::InlineElement.new(
-                format_type: 'stem',
+              Coradoc::CoreModel::StemElement.new(
                 content: math.content.to_s
               )
             else
               Coradoc::CoreModel::PassBlock.new(
-                element_type: 'block',
                 content: math.content.to_s,
                 language: 'latexmath'
               )
@@ -239,19 +228,16 @@ module Coradoc
             when :toc
               Coradoc::CoreModel::Toc.new
             when :comment
-              Coradoc::CoreModel::Block.new(
-                element_type: 'comment',
+              Coradoc::CoreModel::CommentBlock.new(
                 content: ext.content.to_s
               )
             when :nomarkdown
               Coradoc::CoreModel::PassBlock.new(
-                element_type: 'block',
                 content: ext.content.to_s
               )
             else
               # Unknown extensions: preserve content as a generic block
-              Coradoc::CoreModel::Block.new(
-                element_type: 'paragraph',
+              Coradoc::CoreModel::ParagraphBlock.new(
                 content: ext.content.to_s
               )
             end
@@ -263,12 +249,11 @@ module Coradoc
             attr_list.classes.each do |cls|
               attrs << Coradoc::CoreModel::ElementAttribute.new(name: 'class', value: cls.to_s)
             end
-            attr_list.attributes.each do |k, v|
-              attrs << Coradoc::CoreModel::ElementAttribute.new(name: k.to_s, value: v.to_s)
+            attr_list.attributes.each do |nv|
+              attrs << Coradoc::CoreModel::ElementAttribute.new(name: nv.name, value: nv.value)
             end
 
             Coradoc::CoreModel::StructuralElement.new(
-              element_type: 'attribute_list',
               children: attrs
             )
           end

data/lib/coradoc/markdown/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module Markdown
-    VERSION = '1.0.0'
+    VERSION = '1.0.2'
   end
 end

data/lib/coradoc/markdown.rb

@@ -21,7 +21,9 @@
 require 'parslet'
 require 'lutaml/model'
 
+# Coradoc document transformation library.
 module Coradoc
+  # Markdown document model, parser, and serializer.
   module Markdown
     # Error classes
     autoload :Errors, 'coradoc/markdown/errors'
@@ -54,6 +56,11 @@ module Coradoc
     autoload :Extension, 'coradoc/markdown/model/extension'
     autoload :Strikethrough, 'coradoc/markdown/model/strikethrough'
     autoload :Highlight, 'coradoc/markdown/model/highlight'
+    autoload :Subscript, 'coradoc/markdown/model/subscript'
+    autoload :Superscript, 'coradoc/markdown/model/superscript'
+    autoload :Underline, 'coradoc/markdown/model/underline'
+    autoload :CrossReference, 'coradoc/markdown/model/cross_reference'
+    autoload :NamedValue, 'coradoc/markdown/model/named_value'
 
     # Serializer
     autoload :Serializer, 'coradoc/markdown/serializer'
@@ -83,24 +90,6 @@ module Coradoc
     # Shared parser utilities
     autoload :ParserUtil, 'coradoc/markdown/parser_util'
 
-    # Convenience accessors for kramdown extension models
-    class << self
-      # Access AttributeList class
-      def AttributeList
-        @AttributeList ||= const_get(:AttributeList)
-      end
-
-      # Access Math class
-      def Math
-        @Math ||= const_get(:Math)
-      end
-
-      # Access Extension class
-      def Extension
-        @Extension ||= const_get(:Extension)
-      end
-    end
-
     class << self
       # Parse Markdown content into a Document model
       #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-markdown
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -13,30 +13,30 @@ dependencies:
   name: coradoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -111,6 +111,7 @@ files:
 - lib/coradoc/markdown/model/blockquote.rb
 - lib/coradoc/markdown/model/code.rb
 - lib/coradoc/markdown/model/code_block.rb
+- lib/coradoc/markdown/model/cross_reference.rb
 - lib/coradoc/markdown/model/definition_item.rb
 - lib/coradoc/markdown/model/definition_list.rb
 - lib/coradoc/markdown/model/definition_term.rb
@@ -127,11 +128,15 @@ files:
 - lib/coradoc/markdown/model/list.rb
 - lib/coradoc/markdown/model/list_item.rb
 - lib/coradoc/markdown/model/math.rb
+- lib/coradoc/markdown/model/named_value.rb
 - lib/coradoc/markdown/model/paragraph.rb
 - lib/coradoc/markdown/model/strikethrough.rb
 - lib/coradoc/markdown/model/strong.rb
+- lib/coradoc/markdown/model/subscript.rb
+- lib/coradoc/markdown/model/superscript.rb
 - lib/coradoc/markdown/model/table.rb
 - lib/coradoc/markdown/model/text.rb
+- lib/coradoc/markdown/model/underline.rb
 - lib/coradoc/markdown/parser.rb
 - lib/coradoc/markdown/parser/ast_processor.rb
 - lib/coradoc/markdown/parser/block_parser.rb
@@ -160,7 +165,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="