Module: Rigor::ModuleGraph::ConstantName

Defined in:
lib/rigor/module_graph/constant_name.rb

Overview

Resolves a fully-qualified constant name from Prism AST nodes and lexical ancestor chains.

Three things this module handles that the bare Prism API does not give you in one place:

  • Owner from lexical nesting. ‘node.constant_path.full_name` on a `class Billing::Invoice` only returns `“Invoice”`; the outer `module Billing` does not enter unless we walk ancestors ourselves.

  • Absolute paths (‘::Foo::Bar`). Prism encodes the leading `::` as an empty-symbol `:“”` in `full_name_parts`; we render it as `“::Foo::Bar”`.

  • Mixed AST shapes. ‘ClassNode#constant_path` is either a `ConstantReadNode` (single name) or a `ConstantPathNode` (dotted path); same for `superclass` and `include` args.

Class Method Summary collapse

Class Method Details

.full_name_for_path(node) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
 
# File 'lib/rigor/module_graph/constant_name.rb', line 74

def full_name_for_path(node)
  parts = node.full_name_parts
  # Prism encodes a leading `::` as an empty-symbol first
  # part. Render it as a literal `"::"` prefix.
  if parts.first == :""
    "::" + parts.drop(1).join("::")
  else
    parts.join("::")
  end
end

.lexical_owner(context) ⇒ Object

Build the lexical-nesting owner string for a node, by walking ‘context.ancestors` from outer to inner and joining every enclosing `ClassNode`/`ModuleNode` constant path with `::`. Returns nil when no class/module encloses the node.



43
44
45
46
47
48
 
# File 'lib/rigor/module_graph/constant_name.rb', line 43

def lexical_owner(context)
  parts = lexical_parts(context.ancestors)
  return nil if parts.empty?

  parts.join("::")
end

.lexical_owner_with(context, extra) ⇒ Object

Same as ‘#lexical_owner`, but with `extra` appended as the innermost element. Used to build the owner of a class or module decl itself: pass `context.ancestors` (which does NOT include the node itself) plus the node’s own constant path.



54
55
56
57
58
59
60
 
# File 'lib/rigor/module_graph/constant_name.rb', line 54

def lexical_owner_with(context, extra)
  parts = lexical_parts(context.ancestors)
  parts << extra unless extra.nil? || extra.empty?
  return nil if parts.empty?

  parts.join("::")
end

.lexical_parts(ancestors) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/rigor/module_graph/constant_name.rb', line 62

def lexical_parts(ancestors)
  ancestors.flat_map do |ancestor|
    case ancestor
    when Prism::ClassNode, Prism::ModuleNode
      name = render(ancestor.constant_path)
      name ? [name] : []
    else
      []
    end
  end
end

.render(node) ⇒ Object

Render a single Prism constant node into a string like ‘“Foo”`, `“Foo::Bar”`, or `“::Foo::Bar”`. Returns nil when the node is not a constant carrier (e.g. `include SOME_VAR` where the arg is a `CallNode`).



30
31
32
33
34
35
36
37
 
# File 'lib/rigor/module_graph/constant_name.rb', line 30

def render(node)
  case node
  when Prism::ConstantReadNode
    node.name.to_s
  when Prism::ConstantPathNode
    full_name_for_path(node)
  end
end