Class: Rigor::TypeNode::ResolverChain

Inherits:
Object
  • Object
show all
Defined in:
lib/rigor/type_node/resolver_chain.rb

Overview

Walks an ordered list of Plugin::TypeNodeResolver instances, returning the first non-nil ‘resolve(node, scope)` answer. ADR-13 § “`Plugin::TypeNodeResolver` shape” — first non-nil wins; registration order is the user’s lever for shadowing per WD3 / WD5.

The chain is itself a ‘TypeNodeResolver`-shaped object (`#resolve(node, scope)`) so it slots into a NameScope as the `resolver:` field without further indirection: a plugin resolver that wants to recursively resolve a nested argument calls `scope.resolver.resolve(arg, scope)` and reaches every resolver in the chain plus the built-in registry through the same entry point.

Constructed once per ‘Analysis::Runner.run` from `Plugin::Registry#type_node_resolvers`. The chain is immutable and re-entrant; the parser may consult it many times for the same node.

Constant Summary collapse

EMPTY =

Shared empty chain — a ‘NameScope` constructed without any plugin-supplied resolvers can use this to satisfy the `responds_to?(:resolve)` contract without a per-call allocation.

new([]).freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(resolvers) ⇒ ResolverChain

Returns a new instance of ResolverChain.



24
25
26
27
28
29
30
31
32
33
 
# File 'lib/rigor/type_node/resolver_chain.rb', line 24

def initialize(resolvers)
  unless resolvers.is_a?(Array) && resolvers.all? { |r| r.respond_to?(:resolve) }
    raise ArgumentError,
          "TypeNode::ResolverChain expects an Array of resolvers " \
          "responding to #resolve(node, scope), got #{resolvers.inspect}"
  end

  @resolvers = resolvers.dup.freeze
  freeze
end

Instance Attribute Details

#resolvers ⇒ Array<Rigor::Plugin::TypeNodeResolver> (readonly)

Returns ordered resolver instances, in plugin-registration order.

Returns:



37
38
39
 
# File 'lib/rigor/type_node/resolver_chain.rb', line 37

def resolvers
  @resolvers
end

Instance Method Details

#resolve(node, scope) ⇒ Object

First non-nil ‘resolve(node, scope)` answer from the chain; `nil` when every resolver declined.



41
42
43
44
45
46
47
 
# File 'lib/rigor/type_node/resolver_chain.rb', line 41

def resolve(node, scope)
  @resolvers.each do |resolver|
    result = resolver.resolve(node, scope)
    return result unless result.nil?
  end
  nil
end