call_map 0.1.0

data/lib/call_map/resolver.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module CallMap
+  # Resolves a MethodCall to a Definition using the SourceIndex.
+  #
+  # This handles the common Rails patterns:
+  # - bare call within the same class → instance method on `context_owner`
+  # - `SomeService.execute` → class method on SomeService
+  # - `SomeClass.new(...).execute` → instance method on SomeClass
+  # - `self.foo` → class method on `context_owner`
+  class Resolver
+    # @param index [SourceIndex]
+    def initialize(index)
+      @index = index
+    end
+
+    # @param call [MethodCall] the call to resolve
+    # @param context_owner [String] the class/module the calling method belongs to
+    # @return [Definition, nil]
+    def resolve(call, context_owner:, context_kind: :instance_method, lexical_nesting: nil)
+      return nil if call.dynamic?
+
+      if call.bare? || call.receiver == "self"
+        resolve_bare(call, context_owner, context_kind)
+      else
+        resolve_receiver(call, context_owner, context_kind, lexical_nesting)
+      end
+    end
+
+    private
+
+    # Bare (and `self.`) calls dispatch through normal method lookup, so walk
+    # the owner's superclass chain — inherited helpers like a parent
+    # controller's `authenticate_user!` resolve too.
+    def resolve_bare(call, context_owner, context_kind)
+      finder = context_kind == :class_method ? :find_class_method : :find_instance_method
+      find_in_chain(finder, context_owner, call.method_name)
+    end
+
+    # Resolve a call with an explicit receiver.
+    def resolve_receiver(call, context_owner, context_kind, lexical_nesting)
+      receiver = call.receiver
+
+      # `SomeClass.new(...)` chain → instance method on SomeClass
+      if receiver.match?(/\A([A-Z][A-Za-z0-9:]*?)\.new\z/)
+        owner = receiver.sub(/\.new\z/, "")
+        return resolve_constant(:instance_method, owner, call, lexical_nesting, context_owner)
+      end
+
+      # bare `new` or `self.new` chain (implicit self.new inside a class method only)
+      if %w[new self.new].include?(receiver) && context_kind == :class_method
+        return find_in_chain(:find_instance_method, context_owner, call.method_name)
+      end
+
+      # `SomeClass.method` → class method
+      return unless receiver.match?(/\A[A-Z]/)
+
+      resolve_constant(:class_method, receiver, call, lexical_nesting, context_owner)
+    end
+
+    def resolve_constant(kind, owner, call, lexical_nesting, context_owner)
+      finder = kind == :class_method ? :find_class_method : :find_instance_method
+      if call.absolute?
+        find_in_chain(finder, owner, call.method_name)
+      else
+        find_with_namespace_fallback(finder, owner, call.method_name, lexical_nesting, context_owner)
+      end
+    end
+
+    # Try the constant against each lexical scope from innermost outward
+    # (mirroring Ruby's constant lookup), then against the context class's
+    # superclass chain (constants nested in a parent class are visible from
+    # the child), then fall back to top-level. Each scope entry is a full
+    # qualified name used as a prefix directly.
+    def find_with_namespace_fallback(finder, owner, method_name, lexical_nesting, context_owner)
+      scopes = (lexical_nesting || []).reverse + ancestor_scopes(lexical_nesting, context_owner)
+      scopes.each do |scope|
+        result = find_in_chain(finder, "#{scope}::#{owner}", method_name)
+        return result if result
+      end
+
+      find_in_chain(finder, owner, method_name)
+    end
+
+    # Ruby searches the ancestors of the innermost lexically enclosing scope
+    # (the cref), not the method's owner. Only when the method is defined
+    # inside its own class body do the two coincide — for explicit-receiver
+    # definitions like `module Reports; def Generator.build` the owner's
+    # ancestors are NOT part of constant lookup.
+    def ancestor_scopes(lexical_nesting, context_owner)
+      return [] unless (lexical_nesting || []).last == context_owner
+
+      @index.ancestor_chain(context_owner)
+    end
+
+    # Method dispatch walks the receiver class's superclass chain, so a
+    # method defined on a parent (class or instance side) resolves too.
+    def find_in_chain(finder, owner, method_name)
+      @index.ancestor_chain(owner).each do |candidate|
+        result = @index.public_send(finder, candidate, method_name)
+        return result if result
+      end
+
+      nil
+    end
+  end
+end

data/lib/call_map/source_index.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "definition_collector"
+
+module CallMap
+  # Indexes class / module / method definitions found under a directory.
+  #
+  # AST handling is delegated to DefinitionCollector; this class only stores
+  # the resulting Definitions and answers lookups against them.
+  class SourceIndex
+    DEFAULT_GLOB = "app/**/*.rb"
+
+    # Build a SourceIndex by indexing every Ruby file under `root`.
+    def self.build(root:, glob: DEFAULT_GLOB)
+      new.index_directory(root, glob: glob)
+    end
+
+    def initialize
+      @definitions = []
+    end
+
+    attr_reader :definitions
+
+    # @param root [String] directory to search from
+    # @param glob [String] glob pattern relative to root
+    def index_directory(root, glob: DEFAULT_GLOB)
+      Dir.glob(File.join(root, glob)).each { |path| index_file(path) }
+      self
+    end
+
+    def index_file(path)
+      @definitions.concat(DefinitionCollector.collect(File.read(path), path: path))
+      self
+    end
+
+    def find_instance_method(owner, name)
+      find_method(:instance_method, owner, name)
+    end
+
+    def find_class_method(owner, name)
+      find_method(:class_method, owner, name)
+    end
+
+    # All :class definitions matching the qualified name (a class may be
+    # reopened across files), in indexing order.
+    def find_class_definitions(qualified_name)
+      definitions.select { |d| d.kind == :class && d.name == qualified_name }
+    end
+
+    # The class plus its superclasses (innermost first), resolved against the
+    # index. Stops at classes not present in the index or on a cycle.
+    def ancestor_chain(owner)
+      chain = []
+      current = owner
+      while current && !chain.include?(current)
+        chain << current
+        current = superclass_of(current)
+      end
+      chain
+    end
+
+    def superclass_of(owner)
+      definition = find_class_definitions(owner).find(&:superclass)
+      return nil unless definition
+
+      superclass = definition.superclass
+      # A "::"-prefixed superclass is an absolute path — no namespace fallback.
+      return superclass.delete_prefix("::") if superclass.start_with?("::")
+
+      resolve_class_name(superclass, definition.lexical_nesting)
+    end
+
+    private
+
+    def find_method(kind, owner, name)
+      definitions.reverse_each.find { |d| d.kind == kind && d.owner == owner && d.name == name.to_s }
+    end
+
+    # Resolve a superclass constant written relative to the subclass, mirroring
+    # Ruby's lexical lookup: each enclosing scope (a full qualified name) from
+    # innermost outward, then top-level.
+    def resolve_class_name(name, nesting)
+      (nesting || []).reverse_each do |scope|
+        candidate = "#{scope}::#{name}"
+        return candidate if find_class_definitions(candidate).any?
+      end
+
+      name
+    end
+  end
+end

data/lib/call_map/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CallMap
+  VERSION = "0.1.0"
+end

data/lib/call_map.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "call_map/version"
+require_relative "call_map/definition"
+require_relative "call_map/definition_collector"
+require_relative "call_map/source_index"
+require_relative "call_map/method_call"
+require_relative "call_map/call_extractor"
+require_relative "call_map/callback_extractor"
+require_relative "call_map/call_node"
+require_relative "call_map/resolver"
+require_relative "call_map/analyzer"
+require_relative "call_map/formatters/text_tree"
+
+module CallMap
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/call_map.rbs

@@ -0,0 +1,4 @@
+module CallMap
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: call_map
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- bumpfuji10
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: CallMap statically analyzes a Rails application and prints the method
+  call chain from a controller action as a stable text tree, including before_action
+  callbacks. It is a code-reading aid focused on application code, not a full static
+  analyzer.
+email:
+- bumpfuji10@gmail.com
+executables:
+- call_map
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/call_map
+- lib/call_map.rb
+- lib/call_map/analyzer.rb
+- lib/call_map/call_extractor.rb
+- lib/call_map/call_node.rb
+- lib/call_map/callback_extractor.rb
+- lib/call_map/cli.rb
+- lib/call_map/definition.rb
+- lib/call_map/definition_collector.rb
+- lib/call_map/formatters/text_tree.rb
+- lib/call_map/method_call.rb
+- lib/call_map/resolver.rb
+- lib/call_map/source_index.rb
+- lib/call_map/version.rb
+- sig/call_map.rbs
+homepage: https://github.com/bumpfuji10/call_map
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bumpfuji10/call_map
+  source_code_uri: https://github.com/bumpfuji10/call_map
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Generate readable call maps from Rails controller actions.
+test_files: []