coradoc 2.0.23 → 2.0.24

data/lib/coradoc/core_model/inline_element.rb

@@ -24,6 +24,13 @@ module Coradoc
         self.class.format_type || format_type
       end
 
+      # Return a duplicate of this element with its content replaced.
+      # Used by InlineContent.strip_edges (and other edge-cleanup
+      # callers) so that mutations never leak through the public API.
+      def with_content(new_content)
+        dup.tap { |copy| copy.content = new_content }
+      end
+
       # Polymorphic classification used by LinkRewriter::Visitor. Returns
       # :link / :xref when this node carries a rewrite-able target, nil
       # otherwise. Generic InlineElement instances defer to their
@@ -36,14 +43,6 @@ module Coradoc
         end
       end
 
-      FORMAT_TYPES = %w[
-        bold italic monospace underline strikethrough
-        subscript superscript highlight
-        link xref stem footnote
-        hard_line_break text span term
-        line_break quotation
-      ].freeze
-
       attribute :format_type, :string
       attribute :content, :string
       attribute :nested_elements, InlineElement, collection: true
@@ -169,24 +168,31 @@ module Coradoc
       end
     end
 
-    FORMAT_TYPE_CLASS_MAP = {
-      'bold' => BoldElement,
-      'italic' => ItalicElement,
-      'monospace' => MonospaceElement,
-      'underline' => UnderlineElement,
-      'strikethrough' => StrikethroughElement,
-      'subscript' => SubscriptElement,
-      'superscript' => SuperscriptElement,
-      'highlight' => HighlightElement,
-      'link' => LinkElement,
-      'xref' => CrossReferenceElement,
-      'stem' => StemElement,
-      'footnote' => FootnoteElement,
-      'hard_line_break' => HardLineBreakElement,
-      'text' => TextElement,
-      'span' => SpanElement,
-      'term' => TermElement,
-      'line_break' => LineBreakElement
-    }.freeze
+    # Wire-name table: bidirectional string ↔ class index. Single source
+    # of truth for serialization names and runtime dispatch. Reopened
+    # onto InlineElement so the subclasses above are defined first.
+    class InlineElement
+      FORMAT_TYPE_CLASS_MAP = {
+        'bold' => BoldElement,
+        'italic' => ItalicElement,
+        'monospace' => MonospaceElement,
+        'underline' => UnderlineElement,
+        'strikethrough' => StrikethroughElement,
+        'subscript' => SubscriptElement,
+        'superscript' => SuperscriptElement,
+        'highlight' => HighlightElement,
+        'link' => LinkElement,
+        'xref' => CrossReferenceElement,
+        'stem' => StemElement,
+        'footnote' => FootnoteElement,
+        'hard_line_break' => HardLineBreakElement,
+        'text' => TextElement,
+        'span' => SpanElement,
+        'term' => TermElement,
+        'line_break' => LineBreakElement
+      }.freeze
+
+      FORMAT_TYPES = FORMAT_TYPE_CLASS_MAP.keys.freeze
+    end
   end
 end

data/lib/coradoc/core_model.rb

@@ -13,6 +13,7 @@ module Coradoc
     autoload :Base, "#{__dir__}/core_model/base"
     autoload :ChildrenContent, "#{__dir__}/core_model/children_content"
     autoload :HasChildren, "#{__dir__}/core_model/has_children"
+    autoload :InlineContent, "#{__dir__}/core_model/inline_content"
     autoload :Callout, "#{__dir__}/core_model/callout"
     autoload :CalloutText, "#{__dir__}/core_model/callout_text"
     autoload :Block, "#{__dir__}/core_model/block"

data/lib/coradoc/dispatch.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Coradoc
+  # Type-keyed handler dispatch.
+  #
+  # Replaces the bespoke `register/lookup` hashes that recur across gems with
+  # one cohesive registry. Each gem that needs type-keyed dispatch configures
+  # a single Dispatch instance and exposes its legacy DSL as thin delegates.
+  #
+  # Two resolution policies cover the common shapes:
+  #
+  # - `Coradoc::Dispatch.strict`     — exact key match, raises on miss
+  # - `Coradoc::Dispatch.hierarchical` — walks ancestors on miss, returns nil
+  #
+  # Registries that need priority ordering, predicate matching, or lazy
+  # loading do not fit this shape and stay as they are; the friction there is
+  # genuine semantic difference, not duplicated mechanism.
+  class Dispatch
+    TERMINAL_ANCESTORS = [Object, BasicObject].freeze
+    private_constant :TERMINAL_ANCESTORS
+
+    class << self
+      # Exact key match; raises if no entry. Used by registries that map a
+      # concrete type to its sole handler (e.g. AsciiDoc ElementRegistry).
+      def strict = new(walk_ancestors: false)
+
+      # Walks the key's class ancestors on miss; returns nil if no entry.
+      # Used by registries that want base-class handlers to apply to all
+      # subclasses (e.g. Mirror HandlerRegistry).
+      def hierarchical = new(walk_ancestors: true, miss: :return_nil)
+    end
+
+    def initialize(walk_ancestors: false, miss: :raise, &default)
+      @walk_ancestors = walk_ancestors
+      @miss = miss
+      @default = default
+      @entries = {}
+    end
+
+    def register(key, handler)
+      @entries[key] = handler
+    end
+
+    # Replace the handler for an existing key. Returns the previous handler
+    # so wrappers can chain: original = dispatch.override(K, Wrapper.new(original))
+    def override(key, handler)
+      previous = @entries[key]
+      @entries[key] = handler
+      previous
+    end
+
+    def unregister(key)
+      @entries.delete(key)
+    end
+
+    # Resolve the handler for a key. Returns nil if no handler matches
+    # unless the dispatch is configured to raise.
+    def lookup(key)
+      exact = @entries[key]
+      return exact if exact
+      return walk(key) if @walk_ancestors && key.is_a?(Class)
+
+      apply_default(key)
+    end
+
+    # Resolve the handler, raising Coradoc::Error on miss.
+    def lookup!(key)
+      lookup(key) || raise(Coradoc::Error, "no handler registered for #{key.inspect}")
+    end
+
+    def registered?(key) = @entries.key?(key)
+
+    def registered_keys = @entries.keys
+
+    def clear! = @entries.clear
+
+    private
+
+    def walk(klass)
+      klass.ancestors.each do |ancestor|
+        next if ancestor == klass
+        break if TERMINAL_ANCESTORS.include?(ancestor)
+
+        entry = @entries[ancestor]
+        return entry if entry
+      end
+      apply_default(klass)
+    end
+
+    def apply_default(key)
+      return @default.call(key) if @default
+      nil
+    end
+  end
+end

data/lib/coradoc/format_catalog.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Coradoc
+  # Format registry, detection, and capability introspection. Single
+  # source of truth for "what formats exist and what can they do?",
+  # extracted from the top-level Coradoc façade. Public API on
+  # +Coradoc+ delegates here.
+  module FormatCatalog
+    class << self
+      def registry
+        @registry ||= Registry.new
+      end
+
+      def register_format(format_name, format_module, **options)
+        format_module.extend(FormatModule::Interface) unless format_module.is_a?(FormatModule::Interface)
+        registry.register(format_name, format_module, options)
+        FormatModule.validate!(format_module, format_name)
+      end
+
+      def get_format(format_name)
+        registry.get(format_name)
+      end
+
+      def registered_formats
+        registry.list
+      end
+
+      def detect_format(filename)
+        ext = File.extname(filename).downcase
+        registry.each_key do |name|
+          opts = registry.options_for(name)
+          return name if opts[:extensions]&.include?(ext)
+        end
+        nil
+      end
+
+      def binary_format?(format)
+        opts = registry.options_for(format)
+        opts&.fetch(:binary, false) == true
+      end
+
+      def normalize_format(name)
+        return nil unless name
+
+        key = name.to_s.downcase
+        registry.each_key do |fmt_name|
+          opts = registry.options_for(fmt_name)
+          return fmt_name if opts[:aliases]&.include?(key)
+        end
+        key.to_sym
+      end
+
+      def serialize_format?(format)
+        mod = get_format(format)
+        return false unless mod
+
+        mod.serialize?
+      end
+
+      def parse_format?(format)
+        mod = get_format(format)
+        return false unless mod
+
+        mod.public_methods.include?(:parse_to_core) || mod.public_methods.include?(:parse)
+      end
+
+      def capabilities
+        registered_formats.each_with_object({}) do |name, caps|
+          caps[name] = {
+            parse: parse_format?(name),
+            serialize: serialize_format?(name)
+          }
+        end
+      end
+
+      def resolve_output_format(output_file, default: :html)
+        return default unless output_file
+
+        detect_format(output_file) || default
+      end
+    end
+  end
+end

data/lib/coradoc/introspection/element_counter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Introspection
+    # Visitor that walks a document and counts each CoreModel node by
+    # its type key. Used by Introspection.count_element_types to back
+    # the +Coradoc.document_stats+ API.
+    #
+    # Typed StructuralElement / Block nodes are counted under their
+    # +element_type+ (semantic identity). Other nodes fall back to a
+    # snake_case rendering of their class name.
+    class ElementCounter < Visitor::Base
+      def initialize
+        @counts = Hash.new(0)
+      end
+
+      attr_reader :counts
+
+      def visit(element)
+        return super(element) unless element.is_a?(CoreModel::Base)
+
+        @counts[type_key_for(element)] += 1
+        super(element)
+      end
+
+      private
+
+      def type_key_for(element)
+        if typed_node?(element) && element.element_type
+          element.element_type
+        else
+          snake_case(element.class.name)
+        end
+      end
+
+      def typed_node?(element)
+        element.is_a?(CoreModel::StructuralElement) || element.is_a?(CoreModel::Block)
+      end
+
+      def snake_case(class_name)
+        class_name.split('::').last
+                  .gsub(/([A-Z])/, '_\1')
+                  .downcase
+                  .sub(/^_/, '')
+      end
+    end
+  end
+end

data/lib/coradoc/introspection.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Coradoc
+  # Document introspection: file metadata, validation, stats. Extracted
+  # from the top-level Coradoc façade so the document-counting visitor
+  # and file-metadata helpers have their own home. Public API on
+  # +Coradoc+ delegates here.
+  module Introspection
+    autoload :ElementCounter, "#{__dir__}/introspection/element_counter"
+
+    class << self
+      def file_info(path)
+        fmt = FormatCatalog.detect_format(path)
+        info = { size: File.size(path), format: fmt }
+        info[:lines] = File.foreach(path).count unless FormatCatalog.binary_format?(fmt)
+        info
+      end
+
+      def validate_file(path, format: nil)
+        doc = Pipeline.parse_file(path, format: format)
+
+        schema = Validation::SchemaGenerator.generate(doc.class)
+        return schema.validate(doc) if schema
+
+        Validation::Result.new
+      end
+
+      def document_stats(doc)
+        stats = {}
+        stats[:title] = doc.title if doc.title
+
+        if doc.is_a?(CoreModel::StructuralElement)
+          stats[:child_count] = count_elements(doc)
+          stats[:element_counts] = count_element_types(doc)
+        end
+
+        stats
+      end
+
+      def describe_element(elem)
+        return elem.to_s unless elem.is_a?(CoreModel::Base)
+
+        type = elem.class.name.split('::').last
+        if elem.title
+          "#{type}: #{elem.title}"
+        elsif elem.is_a?(CoreModel::Block) && elem.content
+          preview = elem.content.to_s[0..50]
+          preview += '...' if elem.content.to_s.length > 50
+          "#{type}: #{preview}"
+        else
+          type
+        end
+      end
+
+      private
+
+      def count_elements(doc)
+        return 0 unless doc.is_a?(CoreModel::StructuralElement)
+
+        doc.children.sum do |child|
+          1 + (child.is_a?(CoreModel::StructuralElement) ? count_elements(child) : 0)
+        end
+      end
+
+      def count_element_types(doc)
+        counter = ElementCounter.new
+        counter.visit(doc)
+        counter.counts.reject { |_, v| v.zero? }
+      end
+    end
+  end
+end

data/lib/coradoc/pipeline.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Coradoc
+  # Parse / serialize / convert pipeline. Single source of truth for
+  # the document transformation flow, extracted from the top-level
+  # Coradoc façade so pipeline logic has its own home and its own
+  # spec surface. Public API on +Coradoc+ delegates here.
+  module Pipeline
+    class << self
+      # Parse text to a document model. Graph mode: +include::+
+      # directives survive as +CoreModel::Include+ link nodes — no
+      # file I/O happens during parse. Splicing included content is
+      # a separate, explicit step (see +Coradoc.resolve_includes+).
+      def parse(text, format:)
+        format_module = FormatCatalog.get_format(format)
+        unless format_module
+          raise UnsupportedFormatError,
+                "Format '#{format}' is not registered. " \
+                "Available formats: #{FormatCatalog.registered_formats.join(', ')}"
+        end
+
+        text = Hooks.invoke(:before_parse, text, format: format)
+        result = format_module.parse_to_core(text)
+        Hooks.invoke(:after_parse, result, format: format)
+      end
+
+      def resolve_includes(document, base_dir:,
+                           missing_include: :error,
+                           max_depth: Coradoc::ResolveIncludes::DEFAULT_MAX_DEPTH,
+                           allow_unsafe: false,
+                           resolver: nil)
+        resolver = Coradoc::IncludeResolver.coerce(
+          resolver,
+          base_dir: base_dir,
+          allow_unsafe: allow_unsafe
+        )
+        Coradoc::ResolveIncludes.call(
+          document,
+          resolver: resolver,
+          base_dir: base_dir,
+          missing_include: missing_include,
+          max_depth: max_depth
+        )
+      end
+
+      def rewrite_links(document, rewriter: nil, &block)
+        Coradoc::LinkRewriter.rewrite(document, rewriter: rewriter, &block)
+      end
+
+      def convert(text, from:, to:, **)
+        core = parse(text, format: from)
+        serialize(core, to: to, **)
+      end
+
+      def to_core(model)
+        return model if model.is_a?(CoreModel::Base)
+
+        FormatCatalog.registry.each_value do |format_module|
+          next unless format_module.handles_model?(model)
+
+          return format_module.to_core(model)
+        end
+
+        raise TransformationError, "No transformer found for #{model.class}"
+      end
+
+      def serialize(model, to:, **)
+        format_module = FormatCatalog.get_format(to)
+        raise UnsupportedFormatError, "Format '#{to}' is not registered" unless format_module
+
+        model = Hooks.invoke(:before_serialize, model, format: to)
+        result = format_module.serialize(model, **)
+        Hooks.invoke(:after_serialize, result, format: to)
+      end
+
+      def build(&block)
+        CoreModel::DocumentElement.build(children: [], &block)
+      end
+
+      def parse_file(path, format: nil)
+        raise FileNotFoundError, path unless File.exist?(path)
+
+        source_format = format || FormatCatalog.detect_format(path)
+        raise UnsupportedFormatError, "Could not detect format for: #{path}" unless source_format
+
+        format_module = FormatCatalog.get_format(source_format)
+        raise UnsupportedFormatError, "Format '#{source_format}' is not registered" unless format_module
+
+        if FormatCatalog.binary_format?(source_format)
+          format_module.parse_to_core(path)
+        else
+          content = File.read(path)
+          content = Hooks.invoke(:before_parse, content, format: source_format)
+          result = format_module.parse_file_to_core(path, content)
+          Hooks.invoke(:after_parse, result, format: source_format)
+        end
+      end
+
+      def convert_file(path, to:, from: nil, **)
+        source_format = from || FormatCatalog.detect_format(path)
+        raise UnsupportedFormatError, "Could not detect format for: #{path}" unless source_format
+
+        core = parse_file(path, format: source_format)
+        serialize(core, to: to, **)
+      end
+    end
+  end
+end

data/lib/coradoc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coradoc
-  VERSION = '2.0.23'
+  VERSION = '2.0.24'
 end

data/lib/coradoc.rb

@@ -20,18 +20,13 @@
 #
 # @example Manipulating documents
 #   doc = Coradoc.parse(text, format: :asciidoc)
-#   html = Coradoc.manipulate(doc)
-#              .transform_text(&:upcase)
-#              .add_toc
-#              .to_html
+#   html = Coradoc.serialize(doc, to: :html)
 #
 # @example Building documents programmatically
-#   doc = Coradoc.build do
-#     title "My Document"
-#     section "Intro" do
-#       paragraph "Hello world"
-#     end
-#   end.to_core
+#   doc = Coradoc.build do |d|
+#     d.title = "My Document"
+#     d.children << Coradoc::CoreModel::ParagraphBlock.new(content: "Hello")
+#   end
 #   Coradoc.serialize(doc, to: :html)
 
 require_relative 'coradoc/coradoc'
@@ -39,10 +34,7 @@ require_relative 'coradoc/version'
 
 module Coradoc
   autoload :CLI, 'coradoc/cli'
-  autoload :DocumentBuilder, 'coradoc/document_builder'
-  autoload :DocumentManipulator, 'coradoc/document_manipulator'
   autoload :Visitor, 'coradoc/visitor'
-  autoload :Serializer, 'coradoc/serializer/registry'
   autoload :LinkRewriter, 'coradoc/link_rewriter'
   autoload :RelativePath, 'coradoc/relative_path'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc
 version: !ruby/object:Gem::Version
-  version: 2.0.23
+  version: 2.0.24
 platform: ruby
 authors:
 - Ribose Inc.
@@ -83,6 +83,7 @@ files:
 - lib/coradoc/core_model/include.rb
 - lib/coradoc/core_model/include_level_offset.rb
 - lib/coradoc/core_model/include_options.rb
+- lib/coradoc/core_model/inline_content.rb
 - lib/coradoc/core_model/inline_element.rb
 - lib/coradoc/core_model/list_block.rb
 - lib/coradoc/core_model/list_item.rb
@@ -106,9 +107,9 @@ files:
 - lib/coradoc/core_model/toc.rb
 - lib/coradoc/core_model/toc_generator.rb
 - lib/coradoc/core_model/verse_block.rb
-- lib/coradoc/document_builder.rb
-- lib/coradoc/document_manipulator.rb
+- lib/coradoc/dispatch.rb
 - lib/coradoc/errors.rb
+- lib/coradoc/format_catalog.rb
 - lib/coradoc/format_module.rb
 - lib/coradoc/hooks.rb
 - lib/coradoc/include_resolver.rb
@@ -118,21 +119,18 @@ files:
 - lib/coradoc/include_selectors/level_offset.rb
 - lib/coradoc/include_selectors/lines.rb
 - lib/coradoc/include_selectors/tags.rb
-- lib/coradoc/input.rb
+- lib/coradoc/introspection.rb
+- lib/coradoc/introspection/element_counter.rb
 - lib/coradoc/link_rewriter.rb
 - lib/coradoc/link_rewriter/identity.rb
 - lib/coradoc/link_rewriter/visitor.rb
 - lib/coradoc/logger.rb
-- lib/coradoc/output.rb
 - lib/coradoc/performance_regression.rb
-- lib/coradoc/processor_registry.rb
+- lib/coradoc/pipeline.rb
 - lib/coradoc/query.rb
 - lib/coradoc/registry.rb
 - lib/coradoc/relative_path.rb
 - lib/coradoc/resolve_includes.rb
-- lib/coradoc/serializer/registry.rb
-- lib/coradoc/transform.rb
-- lib/coradoc/transform/base.rb
 - lib/coradoc/validation.rb
 - lib/coradoc/version.rb
 - lib/coradoc/visitor.rb