Class: Token::Resolver::Resolve

Inherits:
Object
  • Object
show all
Defined in:
lib/token/resolver/resolve.rb

Overview

Resolves tokens in a parsed Document using a replacement map.

Text nodes pass through unchanged. Token nodes are looked up in the
replacement map by their key. Missing tokens are handled according
to the on_missing policy.

Examples:

Resolve all tokens

doc = Document.new("Hello {KJ|NAME}!")
resolver = Resolve.new
resolver.resolve(doc, {"KJ|NAME" => "World"})
# => "Hello World!"

Keep unresolved tokens

resolver = Resolve.new(on_missing: :keep)
resolver.resolve(doc, {})
# => "Hello {KJ|NAME}!"

Remove unresolved tokens

resolver = Resolve.new(on_missing: :remove)
resolver.resolve(doc, {})
# => "Hello !"

Constant Summary collapse

VALID_ON_MISSING = 
%i[raise keep remove].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(on_missing: :raise) ⇒ Resolve

Returns a new instance of Resolve.

Parameters:

  • on_missing (Symbol) (defaults to: :raise) —

    Behavior for unresolved tokens

Raises:

  • (ArgumentError) —

    If on_missing is invalid



35
36
37
38
39
40
41
42
 
# File 'lib/token/resolver/resolve.rb', line 35

def initialize(on_missing: :raise)
  unless VALID_ON_MISSING.include?(on_missing)
    raise ArgumentError,
      "Invalid on_missing: #{on_missing.inspect}. Must be one of: #{VALID_ON_MISSING.map(&:inspect).join(", ")}"
  end

  @on_missing = on_missing
end

Instance Attribute Details

#on_missing ⇒ Symbol (readonly)

Returns Policy for unresolved tokens (:raise, :keep, :remove).

Returns:

  • (Symbol) —

    Policy for unresolved tokens (:raise, :keep, :remove)



31
32
33
 
# File 'lib/token/resolver/resolve.rb', line 31

def on_missing
  @on_missing
end

Instance Method Details

#resolve(document_or_nodes, replacements) ⇒ String

Resolve tokens in a document or node array using a replacement map.

Resolution is single-pass — replacement values are NOT re-scanned for tokens.

Parameters:

  • document_or_nodes (Document, Array<Node::Text, Node::Token>) —

    Parsed input

  • replacements (Hash{String => String}) —

    Map of token keys to replacement values

Returns:

  • (String) —

    Resolved text

Raises:



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/token/resolver/resolve.rb', line 53

def resolve(document_or_nodes, replacements)
  nodes = case document_or_nodes
  when Document
    document_or_nodes.nodes
  when Array
    document_or_nodes
  else
    raise ArgumentError, "Expected Document or Array of nodes, got #{document_or_nodes.class}"
  end

  result = +""
  nodes.each do |node|
    if node.token?
      replacement = replacements[node.key]
      if replacement
        result << replacement
      else
        handle_missing(node, result)
      end
    else
      result << node.to_s
    end
  end
  result
end