activerecord_callback_lens 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a539b633bd3793bd684d7a93236783afbdb13b946400fd968c204281c3435e7f
-  data.tar.gz: 806014fbee749570c24bac4df333d85f96157d16e42ba5b880380682c729102d
+  metadata.gz: 253d8c471770342d467836fd019cdf2712d7601b3bc3b03f71a23dffe2170fe2
+  data.tar.gz: 53bd60c299d8041698740cecbe133c798482bb7642d0f02a0c93843e815907ce
 SHA512:
-  metadata.gz: 44ab27417d490c5ab1e39b8d3f900f92aa94ece3334be91dd65a04113b77ad2c93a1b95a09b5ec12e90344bd9911f7239e2b9f6864c11cd1f673d4cd23ec792a
-  data.tar.gz: 384e76570141682a41e7fd5dd2402580999a52e24c8196271739017b83452d4ec5ccd94fcf1918ef8a04f1a8842ea1c49ed16a68653b665796d427fdff29be53
+  metadata.gz: 8deed0aa768a9ed5b06a423d8e88a84588737b88409e1bdfecb213ae48e1b33e751bc53e938edefff3d6c1567c0e5c0276f4e546c338c184cc4927aff164f293
+  data.tar.gz: b4edfa71ceb65df82d3e0807bb146bf5cbecaf78b1eae5a02dc288f0b7f1268d3c8a0e42970825b716c242f6aace8c08d163e69ca35bdc978b0101b88f21a7df

data/README.md

@@ -57,6 +57,25 @@ rake callback_lens:analyze MODEL=User
 rake callback_lens:mermaid  MODEL=User   # alias
 ```
 
+#### Recursive method expansion
+
+Pass `--expand` (CLI) or `EXPAND=true` (Rake) to recursively resolve symbol
+callback conditions into their `ConditionTree` representations (up to 5
+levels deep). Cycles and unresolvable methods are left unexpanded with a
+warning printed to stderr.
+
+```bash
+# CLI
+callback_lens analyze User --expand --mermaid
+
+# Rake
+rake callback_lens:analyze MODEL=User EXPAND=true
+rake callback_lens:mermaid  MODEL=User EXPAND=true
+```
+
+Only the exact value `EXPAND=true` (case-insensitive) enables expansion; any
+other value (`EXPAND=1`, `EXPAND=yes`, empty, or absent) leaves it off.
+
 ### Programmatic API
 
 ```ruby
@@ -98,8 +117,8 @@ puts ActiverecordCallbackLens::Renderer::MermaidRenderer.render(graph)
 
 | Version | Feature |
 |---|---|
-| **v0.1** | CallbackCollector, Prism condition parser, Mermaid renderer, CLI, Rake task |
-| v0.2 | MethodResolver — recursive expansion of Symbol conditions |
+| v0.1 | CallbackCollector, Prism condition parser, Mermaid renderer, CLI, Rake task |
+| **v0.2** | MethodResolver — recursive expansion of Symbol conditions (`--expand` / `EXPAND=true`) |
 | v0.3 | Graphviz / DOT renderer |
 | v0.4 | HTML report (callback list, execution flow, embedded diagram) |
 | v1.0 | Runtime tracer via `ActiveSupport::Notifications` |

data/lib/activerecord_callback_lens/cli/cli.rb

@@ -4,6 +4,7 @@ require "thor"
 
 require_relative "../collector/callback_collector"
 require_relative "../parser/condition_parser"
+require_relative "../resolver/method_resolver"
 require_relative "../graph/graph_builder"
 require_relative "../renderer/mermaid_renderer"
 
@@ -26,13 +27,15 @@ module ActiverecordCallbackLens
 
       desc "analyze MODEL", "Analyze callbacks for a model class and print a Mermaid diagram"
       option :mermaid, type: :boolean, default: true, desc: "Output a Mermaid diagram to stdout"
+      option :expand, type: :boolean, default: false,
+                      desc: "Expand method conditions recursively (up to depth 5)"
       # Runs the analysis pipeline for +model_name+ and prints the result.
       #
       # @param model_name [String] the ActiveRecord model class name
       # @return [void]
       def analyze(model_name)
         model_class = resolve_model(model_name)
-        graph = build_graph(model_class)
+        graph = build_graph(model_class, expand: options[:expand])
         puts Renderer::MermaidRenderer.render(graph) if options[:mermaid]
       end
 
@@ -50,13 +53,22 @@ module ActiverecordCallbackLens
         exit 1
       end
 
-      # Collect -> Parse -> Build the dependency graph for a model class.
+      # Collect -> Parse -> (optionally Expand) -> Build the dependency graph for
+      # a model class.
+      #
+      # When +expand+ is true, every parsed definition's condition_tree has its
+      # MethodRefNodes resolved into ConditionTree sub-trees via MethodResolver.
+      # When false, the pipeline is identical to v0.1 output.
       #
       # @param model_class [Class]
+      # @param expand [Boolean]
       # @return [Graph::Graph]
-      def build_graph(model_class)
+      def build_graph(model_class, expand: false)
         definitions = Collector::CallbackCollector.collect(model_class)
         definitions = definitions.map { |definition| Parser::ConditionParser.parse(definition) }
+        if expand
+          definitions = definitions.map { |definition| Resolver::MethodResolver.expand(definition, model_class) }
+        end
         Graph::GraphBuilder.build(definitions)
       end
     end

data/lib/activerecord_callback_lens/graph/graph_builder.rb

@@ -89,6 +89,12 @@ module ActiverecordCallbackLens
         tree_node.children.each { |child| add_tree(child, parent_id: condition_node.id) }
       end
 
+      # The +expanded_tree+ inspected here is populated upstream by
+      # Resolver::MethodResolver.expand; the GraphBuilder neither resolves nor
+      # mutates it. When the tree was not run through expand (the v0.1 path),
+      # +expanded_tree+ is nil and the MethodNode stays a leaf, so unexpanded
+      # output is byte-for-byte identical to v0.1.
+      #
       # @param tree_node [Parser::ConditionTree::MethodRefNode]
       # @param parent_id [String]
       # @return [void]

data/lib/activerecord_callback_lens/parser/ast_walker.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "condition_tree"
+
+module ActiverecordCallbackLens
+  module Parser
+    # Maps a Prism boolean AST (`&&`, `||`, `!`, predicate calls) onto the
+    # ConditionTree node types. Shared by ConditionParser (lambda bodies) and
+    # MethodResolver (method bodies) so the two stay in lockstep.
+    #
+    # The walker recognises the same boolean vocabulary the v0.1 ConditionParser
+    # established:
+    #   - StatementsNode  -> the last statement is the effective return value
+    #   - ParenthesesNode -> transparent; walk the inner body
+    #   - AndNode/OrNode  -> AndNode/OrNode combinators (nil operands dropped)
+    #   - CallNode `!`    -> NotNode wrapping the negated receiver
+    #   - CallNode        -> PredicateNode for the called method name
+    #   - anything else    -> nil (unresolvable)
+    module AstWalker
+      module_function
+
+      # Recursively maps a Prism boolean AST onto ConditionTree nodes.
+      #
+      # @param node [Prism::Node, nil]
+      # @return [ConditionTree::Node, nil]
+      def walk(node)
+        case node
+        in Prism::StatementsNode then walk(node.body.last)
+        in Prism::ParenthesesNode then walk(node.body)
+        in Prism::AndNode then combinator(ConditionTree::AndNode, node)
+        in Prism::OrNode then combinator(ConditionTree::OrNode, node)
+        in Prism::CallNode if node.name == :! then negate(walk(node.receiver))
+        in Prism::CallNode then ConditionTree::PredicateNode.new(name: node.name.to_s)
+        else nil
+        end
+      end
+
+      # Builds an And/Or combinator from a binary Prism node, walking both sides
+      # and dropping any unresolved (nil) operand.
+      #
+      # @param klass [Class] ConditionTree::AndNode or ConditionTree::OrNode
+      # @param node [Prism::AndNode, Prism::OrNode]
+      # @return [ConditionTree::Node]
+      def combinator(klass, node)
+        klass.new(children: [walk(node.left), walk(node.right)].compact)
+      end
+
+      # @param node [ConditionTree::Node, nil]
+      # @return [ConditionTree::NotNode, nil]
+      def negate(node)
+        return nil if node.nil?
+
+        ConditionTree::NotNode.new(child: node)
+      end
+    end
+  end
+end

data/lib/activerecord_callback_lens/parser/condition_parser.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "condition_tree"
+require_relative "ast_walker"
 
 module ActiverecordCallbackLens
   module Parser
@@ -64,9 +65,7 @@ module ActiverecordCallbackLens
       # @param node [ConditionTree::Node, nil]
       # @return [ConditionTree::NotNode, nil]
       def negate(node)
-        return nil if node.nil?
-
-        ConditionTree::NotNode.new(child: node)
+        AstWalker.negate(node)
       end
 
       # Dispatches a single raw condition entry to the right handler.
@@ -96,33 +95,7 @@ module ActiverecordCallbackLens
 
         locator = LambdaLocator.new(target_line: line)
         locator.visit(result.value)
-        walk(locator.node)
-      end
-
-      # Recursively maps a Prism boolean AST onto ConditionTree nodes.
-      #
-      # @param node [Prism::Node, nil]
-      # @return [ConditionTree::Node, nil]
-      def walk(node)
-        case node
-        in Prism::StatementsNode then walk(node.body.last)
-        in Prism::ParenthesesNode then walk(node.body)
-        in Prism::AndNode then combinator(ConditionTree::AndNode, node)
-        in Prism::OrNode then combinator(ConditionTree::OrNode, node)
-        in Prism::CallNode if node.name == :! then negate(walk(node.receiver))
-        in Prism::CallNode then ConditionTree::PredicateNode.new(name: node.name.to_s)
-        else nil
-        end
-      end
-
-      # Builds an And/Or combinator from a binary Prism node, walking both sides
-      # and dropping any unresolved (nil) operand.
-      #
-      # @param klass [Class] ConditionTree::AndNode or ConditionTree::OrNode
-      # @param node [Prism::AndNode, Prism::OrNode]
-      # @return [ConditionTree::Node]
-      def combinator(klass, node)
-        klass.new(children: [walk(node.left), walk(node.right)].compact)
+        AstWalker.walk(locator.node)
       end
 
       # A Prism visitor that captures the innermost LambdaNode or BlockNode whose

data/lib/activerecord_callback_lens/resolver/method_resolver.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../parser/condition_tree"
+require_relative "../parser/ast_walker"
+
+module ActiverecordCallbackLens
+  module Resolver
+    # Resolves a callback's MethodRefNode symbol (e.g. :sync_required?) into an
+    # expanded ConditionTree.
+    #
+    # Given a model class and a method name, MethodResolver locates the method's
+    # source via `instance_method(name).source_location`, parses the file with
+    # Prism, isolates the matching DefNode, and maps its body onto a
+    # ConditionTree with the shared Parser::AstWalker. Any MethodRefNode found in
+    # that tree is then resolved recursively, so a predicate that delegates to
+    # other predicates expands into a full boolean tree.
+    #
+    # Two guards prevent runaway recursion:
+    #   - a `visited` Set closes direct (A -> A) and indirect (A -> B -> A) cycles
+    #   - a MAX_DEPTH cap bounds otherwise-acyclic but deep chains
+    #
+    # Known limitation: a DefNode body is a StatementsNode and the resolver treats
+    # the *last* statement as the effective return value (the same assumption
+    # ConditionParser makes for lambda bodies). Methods with early returns or
+    # guard clauses are therefore only partially understood and are left
+    # unexpanded where the heuristic does not apply.
+    class MethodResolver
+      # Hard cap on recursion depth. A chain of method refs deeper than this is
+      # left unexpanded rather than followed further.
+      MAX_DEPTH = 5
+
+      # @param model_class [Class] the ActiveRecord model the method is defined on
+      # @param method_name [Symbol] the predicate/method to resolve
+      # @return [Parser::ConditionTree::Node, nil] the expanded tree, or nil when
+      #   the method cannot be located/parsed
+      def self.resolve(model_class, method_name)
+        new(model_class).resolve(method_name)
+      end
+
+      # Per-definition expansion entry point. Walks a CallbackDefinition's
+      # condition_tree, resolves every MethodRefNode against the model, and
+      # returns a new definition whose tree carries populated expanded_tree
+      # fields. Bridges the resolver core and the CLI/Rake integration.
+      #
+      # @param definition [Collector::CallbackDefinition]
+      # @param model_class [Class]
+      # @return [Collector::CallbackDefinition] with condition_tree fully expanded
+      def self.expand(definition, model_class)
+        new(model_class).expand(definition)
+      end
+
+      # @param model_class [Class]
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      # Expands every MethodRefNode in the definition's condition_tree.
+      #
+      # A definition with no condition_tree (nil) is returned unchanged; so is a
+      # tree that contains no MethodRefNodes (expand_tree rebuilds it into a
+      # value-equal copy, leaving non-expansion output identical to v0.1).
+      #
+      # @param definition [Collector::CallbackDefinition]
+      # @return [Collector::CallbackDefinition]
+      def expand(definition)
+        return definition unless definition.condition_tree
+
+        expanded = expand_tree(definition.condition_tree)
+        definition.with(condition_tree: expanded)
+      end
+
+      # Resolves a method name into an expanded ConditionTree.
+      #
+      # @param method_name [Symbol]
+      # @param depth [Integer] current recursion depth (0 at the entry point)
+      # @param visited [Set<Symbol>] method names already on the current path
+      # @return [Parser::ConditionTree::Node, nil]
+      def resolve(method_name, depth: 0, visited: Set.new)
+        if depth >= MAX_DEPTH
+          warn("[ActiverecordCallbackLens] Max resolution depth (#{MAX_DEPTH}) reached at #{method_name}")
+          return nil
+        end
+        return nil if visited.include?(method_name)
+
+        visited = visited.dup
+        visited.add(method_name)
+
+        node = locate_and_parse(method_name)
+        return nil if node.nil?
+
+        expand_refs(node, depth: depth + 1, visited: visited)
+      end
+
+      private
+
+      # Recursively rebuilds a condition_tree, populating expanded_tree on every
+      # MethodRefNode. And/Or/Not structure is preserved by rebuilding children
+      # through Data#with so callers' references are never mutated; nodes with no
+      # MethodRefNode beneath them rebuild into value-equal copies.
+      #
+      # Each MethodRefNode is resolved from a fresh depth-0 walk (resolve applies
+      # its own MAX_DEPTH/visited guards), so a ref's name (a String) is converted
+      # to a Symbol before being handed to resolve.
+      #
+      # @param node [Parser::ConditionTree::Node, nil]
+      # @return [Parser::ConditionTree::Node, nil]
+      def expand_tree(node)
+        case node
+        in Parser::ConditionTree::AndNode | Parser::ConditionTree::OrNode
+          node.with(children: node.children.map { |child| expand_tree(child) })
+        in Parser::ConditionTree::NotNode
+          node.with(child: expand_tree(node.child))
+        in Parser::ConditionTree::MethodRefNode
+          node.with(expanded_tree: resolve(node.name.to_sym))
+        else
+          node
+        end
+      end
+
+      # Locates the method's source and parses its body into a ConditionTree.
+      #
+      # @param method_name [Symbol]
+      # @return [Parser::ConditionTree::Node, nil] nil when the method has no Ruby
+      #   source, the file is missing/unparseable, or no DefNode is found
+      def locate_and_parse(method_name)
+        location = source_location_for(method_name)
+        return nil if location.nil?
+
+        file, line = location
+        return nil unless file && File.exist?(file)
+
+        result = Prism.parse_file(file)
+        unless result.success?
+          warn("[ActiverecordCallbackLens] Failed to parse #{file}: #{result.errors.map(&:message).join(', ')}")
+          return nil
+        end
+
+        locator = DefLocator.new(target_line: line, method_name: method_name)
+        locator.visit(result.value)
+        reclassify_refs(Parser::AstWalker.walk(locator.node))
+      end
+
+      # The shared AstWalker maps every bare predicate call to a PredicateNode
+      # leaf. Inside a *method* body, though, a call to another method that this
+      # model defines in Ruby is a MethodRefNode the resolver can expand. This
+      # pass rewrites those leaves: a PredicateNode whose name resolves to a
+      # method with a Ruby source_location becomes a (yet-unexpanded)
+      # MethodRefNode; everything else (AR-generated dirty-tracking predicates,
+      # C-level methods) stays a PredicateNode leaf.
+      #
+      # @param node [Parser::ConditionTree::Node, nil]
+      # @return [Parser::ConditionTree::Node, nil]
+      def reclassify_refs(node)
+        tree = Parser::ConditionTree
+        case node
+        when tree::PredicateNode
+          resolvable?(node.name) ? tree::MethodRefNode.new(name: node.name, expanded_tree: nil) : node
+        when tree::AndNode, tree::OrNode
+          node.with(children: node.children.map { |child| reclassify_refs(child) })
+        when tree::NotNode
+          node.with(child: reclassify_refs(node.child))
+        else
+          node
+        end
+      end
+
+      # @param name [String] a predicate/method name
+      # @return [Boolean] true when the model defines a method by this name that
+      #   has a Ruby source_location (i.e. can be followed by the resolver)
+      def resolvable?(name)
+        location = source_location_for(name.to_sym)
+        !location.nil?
+      end
+
+      # @param method_name [Symbol]
+      # @return [Array(String, Integer), nil] the [file, line] pair, or nil when
+      #   the method is undefined or C-level/eval'd (nil source_location)
+      def source_location_for(method_name)
+        @model_class.instance_method(method_name).source_location
+      rescue NameError
+        nil
+      end
+
+      # Walks a parsed ConditionTree and replaces every MethodRefNode with a copy
+      # whose `expanded_tree` is the recursive resolution of that ref. And/Or/Not
+      # structure is preserved by rebuilding children through Data#with.
+      #
+      # @param node [Parser::ConditionTree::Node, nil]
+      # @param depth [Integer]
+      # @param visited [Set<Symbol>]
+      # @return [Parser::ConditionTree::Node, nil]
+      def expand_refs(node, depth:, visited:)
+        tree = Parser::ConditionTree
+        case node
+        when tree::MethodRefNode
+          sub_tree = resolve(node.name.to_sym, depth: depth, visited: visited)
+          node.with(expanded_tree: sub_tree)
+        when tree::AndNode, tree::OrNode
+          node.with(children: node.children.map { |child| expand_refs(child, depth: depth, visited: visited) })
+        when tree::NotNode
+          node.with(child: expand_refs(node.child, depth: depth, visited: visited))
+        else
+          node
+        end
+      end
+
+      # A Prism visitor that captures the body of the DefNode matching a target
+      # line (and, when available, a target method name). Mirrors ConditionParser's
+      # LambdaLocator but targets `def` definitions rather than lambdas/blocks.
+      class DefLocator < Prism::Visitor
+        # @return [Prism::Node, nil] the body of the matched DefNode
+        attr_reader :node
+
+        # @param target_line [Integer] the line source_location reports for the def
+        # @param method_name [Symbol, nil] the method name to disambiguate overloads
+        def initialize(target_line:, method_name: nil)
+          @target_line = target_line
+          @method_name = method_name
+          @node = nil
+          super()
+        end
+
+        # @param def_node [Prism::DefNode]
+        # @return [void]
+        def visit_def_node(def_node)
+          capture(def_node)
+          super
+        end
+
+        private
+
+        # Records the def's body when it both starts on the target line and (if a
+        # name was supplied) carries the expected method name. Matching on the
+        # start line keeps a method's own `def` from being shadowed by an enclosing
+        # definition, while the name check guards against same-line edge cases.
+        #
+        # @param candidate [Prism::DefNode]
+        # @return [void]
+        def capture(candidate)
+          return unless candidate.location.start_line == @target_line
+          return if @method_name && candidate.name != @method_name
+
+          @node = candidate.body
+        end
+      end
+    end
+  end
+end

data/lib/activerecord_callback_lens/tasks/callback_lens.rake

@@ -3,15 +3,18 @@
 require_relative "callback_lens_helpers"
 
 namespace :callback_lens do
-  desc "Print callback Mermaid diagram for MODEL (e.g. rake callback_lens:analyze MODEL=User)"
+  desc "Print callback Mermaid diagram for MODEL " \
+       "(e.g. rake callback_lens:analyze MODEL=User EXPAND=true)"
   task analyze: :environment do
     model_class = CallbackLensRakeHelpers.resolve_model!(ENV.fetch("MODEL", nil))
-    puts CallbackLensRakeHelpers.render_mermaid(model_class)
+    expand = CallbackLensRakeHelpers.expand?(ENV.fetch("EXPAND", nil))
+    puts CallbackLensRakeHelpers.render_mermaid(model_class, expand: expand)
   end
 
   desc "Alias for callback_lens:analyze — print Mermaid diagram for MODEL"
   task mermaid: :environment do
     model_class = CallbackLensRakeHelpers.resolve_model!(ENV.fetch("MODEL", nil))
-    puts CallbackLensRakeHelpers.render_mermaid(model_class)
+    expand = CallbackLensRakeHelpers.expand?(ENV.fetch("EXPAND", nil))
+    puts CallbackLensRakeHelpers.render_mermaid(model_class, expand: expand)
   end
 end

data/lib/activerecord_callback_lens/tasks/callback_lens_helpers.rb

@@ -22,14 +22,37 @@ module CallbackLensRakeHelpers
     raise "Cannot find model class '#{name}'. Make sure it is loaded."
   end
 
-  # Runs the full pipeline (collect -> parse -> build -> render) for a model.
+  # Runs the full pipeline (collect -> parse -> [expand] -> build -> render) for
+  # a model.
+  #
+  # When +expand+ is true, every parsed definition's condition_tree has its
+  # MethodRefNodes resolved into ConditionTree sub-trees via MethodResolver,
+  # matching the CLI's +--expand+ behaviour. When false (the default), the
+  # pipeline is identical to v0.1 output. Threading +expand+ through this single
+  # helper keeps every rake task that delegates here uniform.
   #
   # @param model_class [Class]
+  # @param expand [Boolean]
   # @return [String] the Mermaid diagram
-  def render_mermaid(model_class)
+  def render_mermaid(model_class, expand: false)
     definitions = ActiverecordCallbackLens::Collector::CallbackCollector.collect(model_class)
     definitions = definitions.map { |definition| ActiverecordCallbackLens::Parser::ConditionParser.parse(definition) }
+    if expand
+      definitions = definitions.map do |definition|
+        ActiverecordCallbackLens::Resolver::MethodResolver.expand(definition, model_class)
+      end
+    end
     graph = ActiverecordCallbackLens::Graph::GraphBuilder.build(definitions)
     ActiverecordCallbackLens::Renderer::MermaidRenderer.render(graph)
   end
+
+  # Parses the EXPAND environment variable using the strict truthy rule: only the
+  # exact string "true" (case-insensitive, surrounding whitespace stripped)
+  # enables expansion. Any other value ("1", "yes", "", nil) leaves it off.
+  #
+  # @param value [String, nil] the raw ENV["EXPAND"] value
+  # @return [Boolean]
+  def expand?(value)
+    value.to_s.strip.downcase == "true"
+  end
 end

data/lib/activerecord_callback_lens/version.rb

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

data/lib/activerecord_callback_lens.rb

@@ -4,7 +4,9 @@ require "activerecord_callback_lens/version"
 require "activerecord_callback_lens/collector/callback_definition"
 require "activerecord_callback_lens/collector/callback_collector"
 require "activerecord_callback_lens/parser/condition_tree"
+require "activerecord_callback_lens/parser/ast_walker"
 require "activerecord_callback_lens/parser/condition_parser"
+require "activerecord_callback_lens/resolver/method_resolver"
 require "activerecord_callback_lens/graph/nodes"
 require "activerecord_callback_lens/graph/graph_builder"
 require "activerecord_callback_lens/renderer/mermaid_renderer"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_callback_lens
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Eraxel.Dev
@@ -77,10 +77,12 @@ files:
 - lib/activerecord_callback_lens/collector/callback_definition.rb
 - lib/activerecord_callback_lens/graph/graph_builder.rb
 - lib/activerecord_callback_lens/graph/nodes.rb
+- lib/activerecord_callback_lens/parser/ast_walker.rb
 - lib/activerecord_callback_lens/parser/condition_parser.rb
 - lib/activerecord_callback_lens/parser/condition_tree.rb
 - lib/activerecord_callback_lens/railtie.rb
 - lib/activerecord_callback_lens/renderer/mermaid_renderer.rb
+- lib/activerecord_callback_lens/resolver/method_resolver.rb
 - lib/activerecord_callback_lens/tasks/callback_lens.rake
 - lib/activerecord_callback_lens/tasks/callback_lens_helpers.rb
 - lib/activerecord_callback_lens/version.rb