coradoc 2.0.1 → 2.0.2

data/coradoc-adoc/lib/coradoc/asciidoc/transform/to_core_model.rb

@@ -6,23 +6,12 @@ module Coradoc
   module AsciiDoc
     module Transform
       # Transforms AsciiDoc models to CoreModel equivalents
-      #
-      # This transformer converts the format-specific AsciiDoc model
-      # to the canonical CoreModel representation.
       class ToCoreModel
-        # Instance method that delegates to class method for convenience
         def transform(model)
           self.class.transform(model)
         end
 
         class << self
-          # Transform an AsciiDoc model to CoreModel
-          #
-          # Dispatches to the registered transformer for the model's class.
-          #
-          # @param model [Coradoc::AsciiDoc::Model::Base] AsciiDoc model to transform
-          # @return [Coradoc::CoreModel::Base] CoreModel equivalent
-          # @raise [TransformationError] if no transformer is registered for the model type
           def transform(model)
             return model.map { |item| transform(item) } if model.is_a?(Array)
             return model unless model.is_a?(Coradoc::AsciiDoc::Model::Base)
@@ -105,8 +94,6 @@ module Coradoc
             end
           end
 
-          private
-
           def transform_document(doc)
             title_text = extract_title_text(doc.header&.title)
             Coradoc::CoreModel::StructuralElement.new(
@@ -119,7 +106,6 @@ module Coradoc
 
           def transform_section(section)
             title_text = extract_title_text(section.title)
-            # Transform both contents and nested sections
             content_children = transform(section.contents || [])
             nested_sections = transform(section.sections || [])
 
@@ -133,7 +119,6 @@ module Coradoc
           end
 
           def transform_paragraph(para)
-            # Transform paragraph content, preserving inline elements
             children = transform_inline_content(para.content)
 
             Coradoc::CoreModel::Block.new(
@@ -144,39 +129,11 @@ module Coradoc
             )
           end
 
-          # Transform inline content, preserving inline element structure
-          # Returns an array of strings and CoreModel::InlineElement objects
-          def transform_inline_content(content)
-            return [] if content.nil?
-
-            case content
-            when Array
-              content.flat_map { |item| transform_inline_content(item) }
-            when Coradoc::AsciiDoc::Model::TextElement
-              transform_inline_content(content.content)
-            when Coradoc::AsciiDoc::Model::Term
-              [Coradoc::CoreModel::InlineElement.new(
-                format_type: 'term',
-                content: content.term.to_s
-              )]
-            when String
-              content.empty? ? [] : [content]
-            when Coradoc::AsciiDoc::Model::Base
-              [transform(content)]
-            else
-              text = extract_text_content(content)
-              text.empty? ? [] : [text]
-            end
-          end
-
           def transform_block(block, delimiter_type)
-            # Transform block content (lines) - they can contain nested elements
             content_lines = Array(block.lines).map do |line|
               case line
               when Coradoc::AsciiDoc::Model::Base
-                # Transform nested AsciiDoc model objects to CoreModel
                 transformed = transform(line)
-                # If it's a CoreModel type, extract text representation
                 if transformed.is_a?(Coradoc::CoreModel::Base)
                   extract_core_model_text(transformed)
                 else
@@ -187,7 +144,6 @@ module Coradoc
               end
             end.join("\n")
 
-            # Get language from block.lang or attributes
             language = block.lang || block.attributes&.[]('language') ||
                        block.attributes&.positional&.first
 
@@ -201,44 +157,6 @@ module Coradoc
             )
           end
 
-          # Extract text representation from CoreModel objects
-          def extract_core_model_text(model)
-            case model
-            when Coradoc::CoreModel::ListBlock
-              model.items.map do |item|
-                item.is_a?(Coradoc::CoreModel::ListItem) ? "* #{item.flat_text}" : item.to_s
-              end.join("\n")
-            when Coradoc::CoreModel::AnnotationBlock
-              "#{model.annotation_type}: #{model.flat_text}"
-            when Coradoc::CoreModel::Block
-              model.flat_text
-            when Coradoc::CoreModel::Image
-              model.alt || ''
-            when Coradoc::CoreModel::InlineElement
-              model.content.to_s
-            else
-              ''
-            end
-          end
-
-          # Extract text from a Title object
-          def extract_title_text(title)
-            return nil if title.nil?
-            return title.to_s unless title.is_a?(Coradoc::AsciiDoc::Model::Title)
-
-            content = title.content
-            return '' if content.nil?
-
-            # Content can be a string or an array
-            if content.is_a?(String)
-              content
-            elsif content.is_a?(Array)
-              content.map { |c| extract_text_content(c) }.join
-            else
-              extract_text_content(content)
-            end
-          end
-
           def transform_table(table)
             rows = Array(table.rows).map do |row|
               transform_table_row(row)
@@ -251,11 +169,30 @@ module Coradoc
             )
           end
 
+          def transform_table_row(row)
+            cells = Array(row.columns).map do |cell|
+              transform_table_cell(cell)
+            end
+            Coradoc::CoreModel::TableRow.new(cells: cells)
+          end
+
+          def transform_table_cell(cell)
+            children = transform_inline_content(cell.content)
+
+            Coradoc::CoreModel::TableCell.new(
+              content: extract_text_content(cell.content),
+              alignment: cell.horizontal_alignment,
+              vertical_alignment: cell.vertical_alignment,
+              colspan: cell.colspan,
+              rowspan: cell.rowspan,
+              style: cell.style_name,
+              children: children
+            )
+          end
+
           def transform_list(list, marker_type)
             items = Array(list.items).map do |item|
-              # Handle both ListItem (content) and ListItemDefinition (contents, terms)
               if item.is_a?(Coradoc::AsciiDoc::Model::List::DefinitionItem)
-                # Definition list item
                 term_content = item.terms
                 def_content = item.contents
 
@@ -264,8 +201,7 @@ module Coradoc
                   definitions: [extract_text_content(def_content)]
                 )
               else
-                # Regular list item - preserve inline elements
-                content_val = item.respond_to?(:content) ? item.content : item.contents
+                content_val = item.content
                 children = transform_inline_content(content_val)
 
                 li = Coradoc::CoreModel::ListItem.new(
@@ -333,37 +269,6 @@ module Coradoc
             )
           end
 
-          def transform_image(image)
-            Coradoc::CoreModel::Image.new(
-              src: image.src,
-              alt: image.title&.to_s,
-              width: image.attributes&.[]('width'),
-              height: image.attributes&.[]('height')
-            )
-          end
-
-          def transform_table_row(row)
-            cells = Array(row.columns).map do |cell|
-              transform_table_cell(cell)
-            end
-            Coradoc::CoreModel::TableRow.new(cells: cells)
-          end
-
-          def transform_table_cell(cell)
-            # Transform cell content, preserving inline elements
-            children = transform_inline_content(cell.content)
-
-            Coradoc::CoreModel::TableCell.new(
-              content: extract_text_content(cell.content),
-              alignment: cell.horizontal_alignment,
-              vertical_alignment: cell.vertical_alignment,
-              colspan: cell.colspan,
-              rowspan: cell.rowspan,
-              style: cell.style_name,
-              children: children
-            )
-          end
-
           def transform_cross_reference(xref)
             Coradoc::CoreModel::InlineElement.new(
               format_type: 'xref',
@@ -380,6 +285,15 @@ module Coradoc
             )
           end
 
+          def transform_image(image)
+            Coradoc::CoreModel::Image.new(
+              src: image.src,
+              alt: image.title&.to_s,
+              width: image.attributes&.[]('width'),
+              height: image.attributes&.[]('height')
+            )
+          end
+
           def transform_bibliography(bib)
             entries = Array(bib.entries).map do |entry|
               transform_bibliography_entry(entry)
@@ -388,7 +302,7 @@ module Coradoc
             Coradoc::CoreModel::Bibliography.new(
               id: bib.id,
               title: bib.title.to_s,
-              level: bib.respond_to?(:level) ? bib.level : nil,
+              level: nil,
               entries: entries
             )
           end
@@ -401,6 +315,66 @@ module Coradoc
             )
           end
 
+          private
+
+          def transform_inline_content(content)
+            return [] if content.nil?
+
+            case content
+            when Array
+              content.flat_map { |item| transform_inline_content(item) }
+            when Coradoc::AsciiDoc::Model::TextElement
+              transform_inline_content(content.content)
+            when Coradoc::AsciiDoc::Model::Term
+              [Coradoc::CoreModel::InlineElement.new(
+                format_type: 'term',
+                content: content.term.to_s
+              )]
+            when String
+              content.empty? ? [] : [content]
+            when Coradoc::AsciiDoc::Model::Base
+              [transform(content)]
+            else
+              text = extract_text_content(content)
+              text.empty? ? [] : [text]
+            end
+          end
+
+          def extract_core_model_text(model)
+            case model
+            when Coradoc::CoreModel::ListBlock
+              model.items.map do |item|
+                item.is_a?(Coradoc::CoreModel::ListItem) ? "* #{item.flat_text}" : item.to_s
+              end.join("\n")
+            when Coradoc::CoreModel::AnnotationBlock
+              "#{model.annotation_type}: #{model.flat_text}"
+            when Coradoc::CoreModel::Block
+              model.flat_text
+            when Coradoc::CoreModel::Image
+              model.alt || ''
+            when Coradoc::CoreModel::InlineElement
+              model.content.to_s
+            else
+              ''
+            end
+          end
+
+          def extract_title_text(title)
+            return nil if title.nil?
+            return title.to_s unless title.is_a?(Coradoc::AsciiDoc::Model::Title)
+
+            content = title.content
+            return '' if content.nil?
+
+            if content.is_a?(String)
+              content
+            elsif content.is_a?(Array)
+              content.map { |c| extract_text_content(c) }.join
+            else
+              extract_text_content(content)
+            end
+          end
+
           def extract_text_content(content)
             case content
             when nil
@@ -408,7 +382,6 @@ module Coradoc
             when String
               content
             when Array
-              # Join text elements with spaces (paragraph normalization)
               result = []
               content.each_with_index do |item, idx|
                 text = extract_text_content(item)
@@ -441,7 +414,7 @@ module Coradoc
             when Coradoc::AsciiDoc::Model::Inline::Stem
               content.content.to_s
             when Coradoc::AsciiDoc::Model::Inline::Footnote
-              if content.respond_to?(:content) && content.content
+              if content.content
                 extract_text_content(content.content)
               else
                 ''
@@ -453,14 +426,14 @@ module Coradoc
             when Coradoc::CoreModel::Image
               content.alt || content.src || ''
             when Coradoc::AsciiDoc::Model::Base
-              if content.respond_to?(:content)
+              if content.content
                 extract_text_content(content.content)
               else
                 ''
               end
             else
-              if content.respond_to?(:to_str)
-                content.to_s
+              if content.is_a?(String)
+                content
               elsif content.class.name.start_with?('Parslet::')
                 content.to_s
               else

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

@@ -53,7 +53,7 @@ module Coradoc
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Block::Core,
-              ->(model) { ToCoreModel.send(:transform_block, model, model.delimiter) }
+              block_wrapper(nil) # uses model.delimiter at call time
             )
 
             Registry.register(
@@ -194,23 +194,27 @@ module Coradoc
           end
 
           def method_wrapper(method_name)
-            ->(model) { ToCoreModel.send(method_name, model) }
+            ->(model) { ToCoreModel.public_send(method_name, model) }
           end
 
           def block_wrapper(delimiter_type)
-            ->(model) { ToCoreModel.send(:transform_block, model, delimiter_type) }
+            if delimiter_type
+              ->(model) { ToCoreModel.transform_block(model, delimiter_type) }
+            else
+              ->(model) { ToCoreModel.transform_block(model, model.delimiter) }
+            end
           end
 
           def list_wrapper(marker_type)
-            ->(model) { ToCoreModel.send(:transform_list, model, marker_type) }
+            ->(model) { ToCoreModel.transform_list(model, marker_type) }
           end
 
           def inline_wrapper(format_type)
-            ->(model) { ToCoreModel.send(:transform_inline, model, format_type) }
+            ->(model) { ToCoreModel.transform_inline(model, format_type) }
           end
 
           def inline_text_wrapper(format_type)
-            ->(model) { ToCoreModel.send(:transform_inline_text, model, format_type) }
+            ->(model) { ToCoreModel.transform_inline_text(model, format_type) }
           end
         end
       end

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

@@ -13,7 +13,7 @@ module Coradoc
               author: simple(:author),
               revision: simple(:revision)
             ) do
-              id = title.respond_to?(:id) ? title.id : nil
+              id = title.is_a?(Model::Title) ? title.id : nil
               Model::Header.new(id:, title:, author:, revision:)
             end
 
@@ -22,7 +22,7 @@ module Coradoc
               title: simple(:title),
               author: simple(:author)
             ) do
-              id = title.respond_to?(:id) ? title.id : nil
+              id = title.is_a?(Model::Title) ? title.id : nil
               Model::Header.new(id:, title:, author:, revision: nil)
             end
 
@@ -31,7 +31,7 @@ module Coradoc
               title: simple(:title),
               revision: simple(:revision)
             ) do
-              id = title.respond_to?(:id) ? title.id : nil
+              id = title.is_a?(Model::Title) ? title.id : nil
               Model::Header.new(id:, title:, author: nil, revision:)
             end
 
@@ -39,7 +39,7 @@ module Coradoc
             rule(
               title: simple(:title)
             ) do
-              id = title.respond_to?(:id) ? title.id : nil
+              id = title.is_a?(Model::Title) ? title.id : nil
               Model::Header.new(id:, title:, author: nil, revision: nil)
             end
 
@@ -72,7 +72,7 @@ module Coradoc
                 author = header[:author]
                 revision = header[:revision]
 
-                id = title.id if title.respond_to?(:id) && title.id && !id
+                id = title.id if title.is_a?(Model::Title) && title.id && !id
 
                 Model::Header.new(id:, title:, author:, revision:)
               else

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

@@ -19,8 +19,8 @@ module Coradoc
 
               # Convert nested array to proper List object if needed
               if nested.is_a?(Array) && nested.any?
-                first_marker = nested.first.respond_to?(:marker) ? nested.first.marker : marker
-                nested = if first_marker&.start_with?('.', '1', 'a', 'A', 'i', 'I')
+                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)

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

@@ -168,7 +168,7 @@ module Coradoc
               id = section[:id] || nil
               title = section[:title] || nil
 
-              id = title.id if title.respond_to?(:id) && title.id && !id
+              id = title.id if title.is_a?(Model::Title) && title.id && !id
 
               attribute_list = section[:attribute_list] || nil
               contents = section[:contents] || []

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

@@ -47,7 +47,7 @@ module Coradoc
           data.map do |item|
             if item.is_a?(Hash) && item.key?(:text)
               text = item[:text]
-              if text.respond_to?(:content)
+              if text.is_a?(Model::Base) && text.class.attributes.key?(:content)
                 text.content
               elsif text.is_a?(Model::Base)
                 text
@@ -197,7 +197,7 @@ module Coradoc
 
           # Repeat marker
           cell_opts[:repeat] = true if format[:repeat]
-        elsif format.is_a?(String) || format.respond_to?(:to_s)
+        elsif format.is_a?(String)
           # Parse format string like ".2+^.^" or "4+^" or ".3+a"
           # Format: [colspan][.rowspan][halign][valign][style][*]
           format_str = format.to_s
@@ -237,7 +237,7 @@ module Coradoc
         return nil if attrs.nil?
 
         # Get the cols value from named attributes
-        cols_value = if attrs.respond_to?(:named)
+        cols_value = if attrs.is_a?(Model::AttributeList)
                        attrs.named.find { |n| n.name.to_s == 'cols' }&.value
                      elsif attrs.is_a?(Hash)
                        attrs['cols'] || attrs[:cols]
@@ -312,7 +312,7 @@ module Coradoc
 
         normalized_cells.each do |cell|
           # Get colspan (default 1)
-          colspan = (cell.respond_to?(:colspan) && cell.colspan) || 1
+          colspan = cell.is_a?(Model::TableCell) && cell.colspan ? cell.colspan : 1
 
           current_row_cells << cell
           current_col_slots += colspan
@@ -339,7 +339,7 @@ module Coradoc
 
         # Count column slots for each cell
         col_slots = cells.map do |cell|
-          (cell.respond_to?(:colspan) && cell.colspan) || 1
+          cell.is_a?(Model::TableCell) && cell.colspan ? cell.colspan : 1
         end
 
         total_cells = col_slots.sum

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

@@ -136,7 +136,7 @@ end
 # Use conditional registration to handle load order issues
 Coradoc.register_format(:asciidoc, Coradoc::AsciiDoc,
                         aliases: %w[adoc asciidoc],
-                        extensions: %w[.adoc .asciidoc]) if Coradoc.respond_to?(:register_format)
+                        extensions: %w[.adoc .asciidoc])
 
 # Backward-compatibility: Coradoc::Model is now Coradoc::AsciiDoc::Model
 # This alias is provided for legacy code that hasn't been updated

data/coradoc-adoc/lib/coradoc/util/asciidoc.rb

@@ -16,11 +16,12 @@ module Coradoc
         return '' if model.nil?
         return model if model.is_a?(String)
 
-        if model.respond_to?(:to_adoc)
+        case model
+        when Coradoc::AsciiDoc::Model::Base
           model.to_adoc
-        elsif model.is_a?(Array)
+        when Array
           model.map { |item| serialize(item) }.join("\n")
-        elsif model.is_a?(Hash)
+        when Hash
           model.map { |k, v| "#{k}: #{serialize(v)}" }.join("\n")
         else
           model.to_s

data/coradoc-adoc/spec/coradoc/asciidoc/transform/from_core_model_spec.rb

@@ -189,12 +189,14 @@ RSpec.describe Coradoc::AsciiDoc::Transform::FromCoreModel do
       end
 
       it 'transforms xref InlineElement to AsciiDoc CrossReference' do
-        core_inline = Coradoc::CoreModel::InlineElement.new(format_type: 'xref', target: 'section1', content: 'Section 1')
+        core_inline = Coradoc::CoreModel::InlineElement.new(format_type: 'xref', target: 'section1',
+                                                            content: 'Section 1')
         expect(described_class.transform(core_inline)).to be_a(Coradoc::AsciiDoc::Model::Inline::CrossReference)
       end
 
       it 'transforms footnote InlineElement to AsciiDoc Footnote' do
-        core_inline = Coradoc::CoreModel::InlineElement.new(format_type: 'footnote', target: 'fn1', content: 'note text')
+        core_inline = Coradoc::CoreModel::InlineElement.new(format_type: 'footnote', target: 'fn1',
+                                                            content: 'note text')
         expect(described_class.transform(core_inline)).to be_a(Coradoc::AsciiDoc::Model::Inline::Footnote)
       end
 

data/coradoc-docx/lib/coradoc/docx/transform/rules/run_rule.rb

@@ -100,7 +100,10 @@ module Coradoc
             result << CoreModel::InlineElement.new(format_type: 'hard_line_break') if run.respond_to?(:carriage_return) && run.carriage_return
 
             # Alternate content — extract preferred/fallback content
-            result << extract_alternate_content(run.alternate_content, context) if run.respond_to?(:alternate_content) && run.alternate_content
+            if run.respond_to?(:alternate_content) && run.alternate_content
+              result << extract_alternate_content(run.alternate_content,
+                                                  context)
+            end
 
             result.compact
           end

data/coradoc-docx/lib/coradoc/docx/transform/rules/simple_field_rule.rb

@@ -63,7 +63,11 @@ module Coradoc
 
           def field_text(field)
             # SimpleField may have runs with resolved text
-            return field.runs.map { |r| r.text&.content.to_s }.join if field.respond_to?(:runs) && field.runs && !field.runs.empty?
+            if field.respond_to?(:runs) && field.runs && !field.runs.empty?
+              return field.runs.map do |r|
+                r.text&.content.to_s
+              end.join
+            end
 
             # Fall back to text attribute
             field.respond_to?(:text) ? field.text.to_s : nil

data/coradoc-docx/lib/coradoc/docx/transform/rules/table_rule.rb

@@ -79,7 +79,6 @@ module Coradoc
             vm = cell.properties.v_merge
             vm.respond_to?(:value) ? vm.value.to_s == 'restart' : false
           end
-
         end
       end
     end

data/coradoc-docx/lib/coradoc/docx.rb

@@ -91,7 +91,9 @@ module Coradoc
 end
 
 # Auto-register :docx format with Coradoc when both gems are loaded
-Coradoc.register_format(:docx, Coradoc::Docx,
-                        aliases: %w[docx],
-                        extensions: %w[.docx],
-                        binary: true) unless Coradoc.registered_formats.include?(:docx)
+unless Coradoc.registered_formats.include?(:docx)
+  Coradoc.register_format(:docx, Coradoc::Docx,
+                          aliases: %w[docx],
+                          extensions: %w[.docx],
+                          binary: true)
+end

data/coradoc-docx/spec/coradoc/docx/transform/from_core_model_spec.rb

@@ -120,7 +120,9 @@ RSpec.describe Coradoc::Docx::Transform::FromCoreModel do
     end
 
     context 'with Abbreviation' do
-      let(:core_model) { Coradoc::CoreModel::Abbreviation.new(term: 'API', definition: 'Application Programming Interface') }
+      let(:core_model) do
+        Coradoc::CoreModel::Abbreviation.new(term: 'API', definition: 'Application Programming Interface')
+      end
 
       it 'produces a Paragraph with term and definition' do
         expect(result).to be_a(Uniword::Wordprocessingml::Paragraph)
@@ -245,7 +247,8 @@ RSpec.describe Coradoc::Docx::Transform::FromCoreModel do
         @tmpdir = Dir.mktmpdir
         img_path = File.join(@tmpdir, 'test.png')
         # Minimal 1x1 PNG
-        File.binwrite(img_path, "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc\xf8\x0f\x00\x00\x01\x01\x00\x05\x18\xd8N\x00\x00\x00\x00IEND\xAEB`\x82".b)
+        File.binwrite(img_path,
+                      "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc\xf8\x0f\x00\x00\x01\x01\x00\x05\x18\xd8N\x00\x00\x00\x00IEND\xAEB`\x82".b)
         Coradoc::CoreModel::Image.new(src: img_path, alt: 'Test image')
       end