Class: Coradoc::AsciiDoc::Model::Resolver

Inherits:
Object
  • Object
show all
Defined in:
lib/coradoc/asciidoc/model/resolver.rb

Overview

Resolver classes for handling external document references.

The resolver infrastructure provides a unified way to handle different types of external references (includes, images, media) with configurable resolution strategies.

Examples:

Resolving includes only

resolver = Resolver.new(includes: true, images: :reference, media: :reference)
resolved = resolver.resolve_document(doc, base_dir)

Creating a self-contained document

resolver = Resolver.new(
  includes: true,
  images: :embed,
  media: :copy,
  output_dir: "/path/to/output"
)
resolved = resolver.resolve_document(doc, base_dir)

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Resolver

Create a new Resolver with specified options.

Parameters:

  • options (Hash) (defaults to: {}) —

    resolution options

Options Hash (options):

  • :includes (Boolean) —

    Whether to resolve include directives

  • :images (Symbol) —

    Image resolution strategy (:reference, :copy, :embed)

  • :media (Symbol) —

    Media resolution strategy (:reference, :copy, :embed)

  • :output_dir (String) —

    Output directory for :copy mode

  • :max_recursion (Integer) —

    Maximum recursion depth for includes



49
50
51
52
53
54
55
56
 
# File 'lib/coradoc/asciidoc/model/resolver.rb', line 49

def initialize(options = {})
  @include_resolver = options[:includes] ? IncludeResolver.new : nil
  @image_resolver = ImageResolver.new(strategy: options[:images] || :reference)
  @media_resolver = MediaResolver.new(strategy: options[:media] || :reference)
  @output_dir = options[:output_dir]
  @max_recursion = options[:max_recursion] || 10
  @resolved_paths = {} # Track resolved paths to prevent infinite recursion
end

Instance Attribute Details

#image_resolver ⇒ ImageResolver (readonly)

Returns the image resolver.

Returns:



32
33
34
 
# File 'lib/coradoc/asciidoc/model/resolver.rb', line 32

def image_resolver
  @image_resolver
end

#include_resolver ⇒ IncludeResolver? (readonly)

Returns the include resolver (nil if disabled).

Returns:



29
30
31
 
# File 'lib/coradoc/asciidoc/model/resolver.rb', line 29

def include_resolver
  @include_resolver
end

#media_resolver ⇒ MediaResolver (readonly)

Returns the media resolver.

Returns:



35
36
37
 
# File 'lib/coradoc/asciidoc/model/resolver.rb', line 35

def media_resolver
  @media_resolver
end

#output_dir ⇒ String? (readonly)

Returns the output directory for copied files.

Returns:

  • (String, nil) —

    the output directory for copied files



38
39
40
 
# File 'lib/coradoc/asciidoc/model/resolver.rb', line 38

def output_dir
  @output_dir
end

Instance Method Details

#resolve(node, base_dir, depth = 0) ⇒ Base+

Resolve a single node.

Parameters:

  • node (Base) —

    the node to resolve

  • base_dir (String) —

    base directory for relative paths

  • depth (Integer) (defaults to: 0) —

    current recursion depth

Returns:

  • (Base, Array<Base>) —

    the resolved node(s)



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/coradoc/asciidoc/model/resolver.rb', line 65

def resolve(node, base_dir, depth = 0)
  return node if depth > @max_recursion

  case node
  when Include
    resolve_include(node, base_dir, depth)
  when Image::BlockImage, Image::InlineImage
    resolve_image(node, base_dir)
  when Video
    resolve_media(node, base_dir, :video)
  when Audio
    resolve_media(node, base_dir, :audio)
  else
    node
  end
end

#resolve_document(document, base_dir) ⇒ Document

Resolve an entire document.

Parameters:

  • document (Document) —

    the document to resolve

  • base_dir (String) —

    base directory for relative paths

Returns:

  • (Document) —

    a NEW document with resolved references



88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/coradoc/asciidoc/model/resolver.rb', line 88

def resolve_document(document, base_dir)
  resolved_sections = document.sections.map do |section|
    resolve_node_recursive(section, base_dir, 0)
  end.flatten.compact

  document.class.new(
    document_attributes: document.document_attributes,
    header: document.header,
    sections: resolved_sections
  )
end