coradoc-mirror 0.1.1

data/lib/coradoc/mirror/handlers/image.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      # Image handler.
+      #
+      # Two emission shapes:
+      #   - Ruby legacy (default): bare `image` node, title/caption in attrs.
+      #   - JS @metanorma/mirror (`partition_structural: true`): when the
+      #     source image has a title, wrap it in a `figure` node with the
+      #     image plus a `caption` child, matching the JS schema.
+      module Image
+        def self.call(element, context:)
+          image_node = build_image_node(element)
+
+          return image_node unless context.partition_structural
+          return image_node unless caption_text?(element)
+
+          Node::Figure.new(
+            attrs: Node::Figure::Attrs.new(id: element.id, title: caption_value(element)),
+            content: [image_node, Node::Caption.new(content: caption_text_nodes(element, context))]
+          )
+        end
+
+        class << self
+          private
+
+          def build_image_node(element)
+            Node::Image.new(
+              attrs: Node::Image::Attrs.new(
+                src: element.src,
+                alt: element.alt,
+                title: element.title,
+                caption: element.caption,
+                width: element.width,
+                height: element.height,
+                inline: element.inline || nil
+              )
+            )
+          end
+
+          def caption_text?(element)
+            !caption_value(element).to_s.empty?
+          end
+
+          def caption_value(element)
+            element.caption || element.title
+          end
+
+          def caption_text_nodes(element, context)
+            [context.text_node(caption_value(element).to_s)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/inline.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module Inline
+        # Classification of inline handlers.
+        SIMPLE_MARK_TYPES = {
+          CoreModel::BoldElement => Mark::Bold,
+          CoreModel::ItalicElement => Mark::Italic,
+          CoreModel::MonospaceElement => Mark::Monospace,
+          CoreModel::UnderlineElement => Mark::Underline,
+          CoreModel::StrikethroughElement => Mark::Strikethrough,
+          CoreModel::SubscriptElement => Mark::Subscript,
+          CoreModel::SuperscriptElement => Mark::Superscript,
+          CoreModel::HighlightElement => Mark::Highlight,
+          CoreModel::TermElement => Mark::Bold
+        }.freeze
+
+        def self.process(element, context:)
+          return [] unless element
+
+          children = inline_children_for(element)
+
+          children.flat_map do |child|
+            process_child(child, context)
+          end
+        end
+
+        def self.process_child(child, context)
+          case child
+          when CoreModel::TextContent
+            return [] if child.text.nil? || child.text.empty?
+
+            [context.text_node(child.text)]
+          when CoreModel::InlineElement
+            [dispatch_inline(child, context)].compact
+          when CoreModel::FootnoteReference
+            [context.resolve_footnote_reference(child)]
+          when CoreModel::Block, CoreModel::StructuralElement
+            result = context.registry.handle(child, context: context)
+            return [] unless result
+
+            value, concat = result
+            return [] unless value
+
+            if concat
+              Array(value)
+            else
+              [value].compact
+            end
+          when CoreModel::Image
+            [Handlers::Image.call(child, context: context)]
+          else
+            []
+          end
+        end
+
+        def self.call(element, context:)
+          dispatch_inline(element, context)
+        end
+
+        def self.text_content(element, context:)
+          return nil if element.text.nil? || element.text.empty?
+
+          context.text_node(element.text)
+        end
+
+        class << self
+          private
+
+          def inline_children_for(element)
+            if element.is_a?(CoreModel::InlineElement) ||
+               element.is_a?(CoreModel::Block) ||
+               element.is_a?(CoreModel::TableCell) ||
+               element.is_a?(CoreModel::StructuralElement)
+              children = element.children
+              return children if children && !children.empty?
+            end
+
+            if element.is_a?(CoreModel::InlineElement) ||
+               element.is_a?(CoreModel::Block)
+              content = element.content
+              return [CoreModel::TextContent.new(text: content.to_s)] if content && !content.to_s.empty?
+            end
+
+            []
+          end
+
+          def dispatch_inline(element, context)
+            mark_class = SIMPLE_MARK_TYPES[element.class]
+            return build_simple_mark(element, context, mark_class) if mark_class
+
+            case element
+            when CoreModel::LinkElement
+              build_link_mark(element, context)
+            when CoreModel::CrossReferenceElement
+              build_xref_mark(element, context)
+            when CoreModel::StemElement
+              build_stem_mark(element, context)
+            when CoreModel::SpanElement
+              build_span_mark(element, context)
+            when CoreModel::FootnoteElement
+              build_footnote_node(element, context)
+            when CoreModel::HardLineBreakElement, CoreModel::LineBreakElement
+              Node::SoftBreak.new
+            when CoreModel::TextElement
+              build_text_only(element, context)
+            when CoreModel::InlineElement
+              handle_generic_inline(element, context)
+            end
+          end
+
+          def handle_generic_inline(element, context)
+            text = element.content.to_s
+            return nil if text.empty?
+
+            context.text_node(text)
+          end
+
+          def build_simple_mark(element, context, mark_class)
+            text = extract_inline_text(element)
+            return nil if text.empty?
+
+            context.text_node(text, marks: [mark_class.new])
+          end
+
+          def build_link_mark(element, context)
+            text = extract_inline_text(element)
+            text = element.target.to_s if text.empty? && element.target
+            return nil if text.empty?
+
+            context.text_node(text, marks: [
+                                Mark::Link.new(attrs: Mark::Link::Attrs.new(href: element.target))
+                              ])
+          end
+
+          def build_xref_mark(element, context)
+            text = extract_inline_text(element)
+            target = element.target
+
+            display_text = text.empty? ? (target || '') : text
+            return nil if display_text.empty?
+
+            context.text_node(display_text, marks: [Mark::CrossReference.new(
+              attrs: Mark::CrossReference::Attrs.new(
+                target: target,
+                resolved: text.empty? ? nil : text
+              )
+            )])
+          end
+
+          def build_stem_mark(element, context)
+            text = extract_inline_text(element)
+            return nil if text.empty?
+
+            context.text_node(text, marks: [
+                                Mark::Stem.new(attrs: Mark::Stem::Attrs.new(stem_type: element.stem_type))
+                              ])
+          end
+
+          def build_span_mark(element, context)
+            text = extract_inline_text(element)
+            return nil if text.empty?
+
+            role = element.attr('role')
+            context.text_node(text, marks: [
+                                Mark::Span.new(attrs: Mark::Span::Attrs.new(role: role))
+                              ])
+          end
+
+          def build_footnote_node(element, context)
+            footnote = nil
+            if element.is_a?(CoreModel::InlineElement) && element.content
+              fn_id = element.attr('id')
+              footnote = CoreModel::Footnote.new(
+                id: fn_id,
+                content: element.content.to_s
+              )
+            end
+
+            context.register_footnote(footnote)
+          end
+
+          def build_text_only(element, context)
+            text = extract_inline_text(element)
+            return nil if text.empty?
+
+            context.text_node(text)
+          end
+
+          def extract_inline_text(element)
+            return element.content.to_s if element.content && !element.content.to_s.empty?
+
+            return element.nested_elements.map { |nested| extract_inline_text(nested) }.join if element.is_a?(CoreModel::InlineElement) && element.nested_elements
+
+            if (element.is_a?(CoreModel::InlineElement) || element.is_a?(CoreModel::Block)) && element.children && !element.children.empty?
+              return element.children.map do |child|
+                case child
+                when CoreModel::TextContent then child.text.to_s
+                when CoreModel::InlineElement then extract_inline_text(child)
+                else ''
+                end
+              end.join
+            end
+
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/list.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module List
+        def self.call(element, context:)
+          items = Array(element.items).filter_map do |item|
+            list_item(item, context: context)
+          end
+          return nil if items.empty?
+
+          node_class = ordered?(element) ? Node::OrderedList : Node::BulletList
+          node_class.new(
+            attrs: node_class::Attrs.new(
+              id: element.id,
+              start: element.is_a?(CoreModel::ListBlock) ? element.start : nil
+            ),
+            content: items
+          )
+        end
+
+        class << self
+          private
+
+          def list_item(item, context:)
+            content = build_item_content(item, context)
+            return nil if content.empty?
+
+            Node::ListItem.new(
+              attrs: Node::ListItem::Attrs.new(id: item.id),
+              content: content
+            )
+          end
+
+          def build_item_content(item, context)
+            content = []
+
+            has_children = item.is_a?(CoreModel::ListItem) &&
+                           item.children && !item.children.empty?
+
+            if has_children
+              item.children.each do |child|
+                node = dispatch_child(child, context)
+                content << node if node
+              end
+            elsif item.content && !item.content.to_s.empty?
+              content << context.text_node(item.content.to_s)
+            end
+
+            if item.is_a?(CoreModel::ListItem) && item.nested_list
+              nested = Handlers::List.call(item.nested_list, context: context)
+              content << nested if nested
+            end
+
+            content
+          end
+
+          def dispatch_child(child, context)
+            case child
+            when CoreModel::TextContent
+              return nil if child.text.nil? || child.text.empty?
+
+              context.text_node(child.text)
+            when CoreModel::InlineElement
+              Handlers::Inline.call(child, context: context)
+            when CoreModel::Block, CoreModel::StructuralElement
+              result = context.registry.handle(child, context: context)
+              result&.first
+            end
+          end
+
+          def ordered?(element)
+            element.marker_type == 'ordered'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/open_block.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module OpenBlock
+        def self.call(element, context:)
+          content = context.extract_content(element)
+          return nil if content.empty?
+
+          Node::OpenBlock.new(content: content)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/paragraph.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module Paragraph
+        def self.call(element, context:)
+          content = context.process_inline_content(element)
+          return nil if content.empty?
+
+          Node::Paragraph.new(content: content)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/reviewer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      # Handles ReviewerBlock → omitted (reviewer notes are not rendered).
+      module Reviewer
+        def self.call(_element, *)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/sidebar.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module Sidebar
+        def self.call(element, context:)
+          content = context.extract_content(element)
+          return nil if content.empty?
+
+          Node::Sidebar.new(
+            attrs: Node::Sidebar::Attrs.new(id: element.id, title: element.title),
+            content: content
+          )
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/structural.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module Structural
+        # Top-level document handler. Stays flat; structural partitioning
+        # (preface/sections/bibliography) is opted into via the
+        # partition_structural: kwarg on CoreModelToMirror#call, which
+        # delegates to Mirror::Partitioner.
+        def self.document(element, context:)
+          content = context.extract_content(element)
+          Node::Document.new(
+            attrs: Node::Document::Attrs.new(title: element.title, id: element.id),
+            content: content
+          )
+        end
+
+        # Map CoreModel section style/title hints to JS SECTION_TYPES.
+        # When coradoc propagates AsciiDoc style attributes ([appendix],
+        # [bibliography], etc.) into SectionElement.attributes, this table
+        # is used to pick the right JS section type. Default fallback is
+        # `clause` (the JS generic section type).
+        SECTION_STYLE_TO_JS_TYPE = {
+          'appendix' => 'annex',
+          'annex' => 'annex',
+          'bibliography' => 'references',
+          'references' => 'references',
+          'abstract' => 'abstract',
+          'foreword' => 'foreword',
+          'introduction' => 'introduction',
+          'acknowledgements' => 'acknowledgements',
+          'terms' => 'terms',
+          'definitions' => 'definitions'
+        }.freeze
+
+        def self.section(element, context:)
+          content = context.extract_content(element)
+          type = context.partition_structural ? section_type_for(element) : 'section'
+
+          Node::Section.new(
+            type: type,
+            attrs: Node::Section::Attrs.new(
+              id: element.id,
+              title: element.title,
+              level: element.heading_level
+            ),
+            content: content
+          )
+        end
+
+        def self.section_type_for(element)
+          style = section_style(element)
+          SECTION_STYLE_TO_JS_TYPE[style] || 'clause'
+        end
+
+        # Reads `style` then `role` from SectionElement#attributes via the
+        # Metadata#[] accessor — no intermediate hash allocation per call.
+        def self.section_style(element)
+          attrs = element.attributes
+          return nil unless attrs.is_a?(Coradoc::CoreModel::Metadata)
+
+          attrs['style'] || attrs['role']
+        end
+
+        def self.preamble(element, context:)
+          content = context.extract_content(element)
+          Node::Preamble.new(content: content)
+        end
+
+        def self.header(element, context:)
+          content = context.extract_content(element)
+          Node::Header.new(
+            attrs: Node::Header::Attrs.new(
+              title: element.title,
+              level: element.heading_level
+            ),
+            content: content
+          )
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/table.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module Table
+        def self.call(element, context:)
+          rows = Array(element.rows)
+          return nil if rows.empty?
+
+          head_rows, body_rows = partition_rows(rows)
+
+          content = []
+          content << build_table_head(head_rows, context) unless head_rows.empty?
+          content << build_table_body(body_rows, context) unless body_rows.empty?
+
+          return nil if content.empty?
+
+          Node::Table.new(
+            attrs: Node::Table::Attrs.new(
+              id: element.id,
+              title: element.title,
+              width: element.width
+            ),
+            content: content
+          )
+        end
+
+        class << self
+          private
+
+          def partition_rows(rows)
+            head = rows.select { |r| r.is_a?(CoreModel::TableRow) && r.header }
+            body = rows.reject { |r| r.is_a?(CoreModel::TableRow) && r.header }
+            [head, body]
+          end
+
+          def build_table_head(rows, context)
+            content = rows.map { |r| build_table_row(r, context) }
+            Node::TableHead.new(content: content)
+          end
+
+          def build_table_body(rows, context)
+            content = rows.map { |r| build_table_row(r, context) }
+            Node::TableBody.new(content: content)
+          end
+
+          def build_table_row(row, context)
+            cells = Array(row.cells).map { |c| build_table_cell(c, context) }
+            Node::TableRow.new(content: cells)
+          end
+
+          def build_table_cell(cell, context)
+            content = build_cell_content(cell, context)
+            Node::TableCell.new(
+              attrs: Node::TableCell::Attrs.new(
+                colspan: cell.colspan,
+                rowspan: cell.rowspan,
+                alignment: cell.alignment,
+                header: cell.header || nil
+              ),
+              content: content
+            )
+          end
+
+          def build_cell_content(cell, context)
+            if cell.is_a?(CoreModel::TableCell) && cell.children && !cell.children.empty?
+              return cell.children.flat_map do |child|
+                Handlers::Inline.process_child(child, context)
+              end
+            end
+
+            text = cell.content
+            return [] if text.nil? || text.to_s.empty?
+
+            [context.text_node(text.to_s)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/toc.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module Toc
+        def self.call(element, context:)
+          entries = if element.is_a?(CoreModel::Toc) && element.entries
+                      Array(element.entries).filter_map do |entry|
+                        build_entry(entry, context)
+                      end
+                    else
+                      []
+                    end
+
+          Node::Toc.new(
+            attrs: Node::Toc::Attrs.new(title: element.title),
+            content: entries
+          )
+        end
+
+        class << self
+          private
+
+          def build_entry(entry, context)
+            children = if entry.is_a?(CoreModel::TocEntry) && entry.children
+                         entry.children.filter_map { |c| build_entry(c, context) }
+                       else
+                         []
+                       end
+
+            content = [context.text_node(entry.title.to_s)] unless children.any?
+            content ||= children
+
+            Node::TocEntry.new(
+              attrs: Node::TocEntry::Attrs.new(
+                id: entry.is_a?(CoreModel::TocEntry) ? entry.id : nil,
+                title: entry.is_a?(CoreModel::TocEntry) ? entry.title : nil,
+                level: entry.is_a?(CoreModel::TocEntry) ? entry.level : nil
+              ),
+              content: content
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/mirror/handlers/verse.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Mirror
+    module Handlers
+      module Verse
+        def self.call(element, context:)
+          text = if element.content && !element.content.to_s.empty?
+                   element.flat_text || element.content.to_s
+                 else
+                   ''
+                 end
+
+          Node::Verse.new(
+            attrs: Node::Verse::Attrs.new(attribution: element.attribution),
+            content: [context.text_node(text)]
+          )
+        end
+      end
+    end
+  end
+end