rspec-signal 0.2.0 → 0.3.0

data/lib/rspec/signal/causal/analysis.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Signal
+    module Causal
+      # One exact signature, or one set of identical errors outside examples.
+      # Signatures stay authoritative: this layer relates them, never re-cuts
+      # them.
+      Unit = Struct.new(:key, :failures, :outside, :position, keyword_init: true) do
+        def size
+          failures.size
+        end
+
+        def evidence
+          failures.map(&:evidence).compact
+        end
+
+        def representative
+          failures.first
+        end
+
+        def exception_class
+          representative.exception_class
+        end
+      end
+
+      # A classified set of units.
+      #
+      #   causal       structural evidence that the members share an origin.
+      #                Always "high": nothing weaker is allowed to form one.
+      #   scope        failures unusually concentrated in one file or one
+      #                `type:`. A fact about where, never a claim about why.
+      #   independent  no relationship found. Not "proven unrelated".
+      Relation = Struct.new(:kind, :units, :evidence, :scope, keyword_init: true) do
+        def initialize(**)
+          super
+          self.evidence ||= []
+        end
+
+        def failures
+          units.sum(&:size)
+        end
+
+        def confidence
+          kind == :causal ? "high" : nil
+        end
+      end
+
+      # Relates signatures by structural evidence and reports how much of the
+      # run it has classified. No weights, no similarity, no model: every
+      # relationship is an equality between facts read from the run.
+      class Analysis
+        # The three structural relations, in the order their evidence is shown.
+        LINKS = { identities: "shared_exception_object", link_key: "same_underlying_exception",
+                  entities: "missing_entity" }.freeze
+
+        SETUP = [["setup", "before(:context) hook"], ["setup", "before hook"], %w[body let]].freeze
+
+        EVIDENCE_ORDER = %w[shared_exception_object missing_entity outside_examples same_underlying_exception
+                            setup_failure setup_code failed_in_let teardown_failure].freeze
+
+        attr_reader :relations, :hints, :expected
+
+        def self.call(report)
+          outside = Grouper.call(report.outside_example_failures)
+          units = report.groups.map { |group| unit(group, false) } + outside.map { |group| unit(group, true) }
+          units.each_with_index { |unit, index| unit.position = index }
+          new(units, census: report.census,
+                     expected: report.failure_count + report.errors_outside_examples)
+        end
+
+        def self.unit(group, outside)
+          key = outside ? "outside:#{group.fingerprint.digest}" : group.fingerprint.digest
+          Unit.new(key: key, failures: group.failures, outside: outside)
+        end
+
+        def initialize(units, census:, expected:)
+          @units = units
+          @census = census
+          @expected = expected
+          @hints = []
+          causal, residual = relate
+          scoped, independent = ScopeAnalysis.call(residual, @census)
+          @relations = causal + scoped + independent.map { |unit| Relation.new(kind: :independent, units: [unit]) }
+          @hints.concat(same_origin_hints)
+          @hints.concat(reused_instance_hints)
+        end
+
+        def accounted
+          @relations.sum(&:failures)
+        end
+
+        def count(kind)
+          @relations.select { |relation| relation.kind == kind }.sum(&:failures)
+        end
+
+        def not_captured
+          [@expected - accounted, 0].max
+        end
+
+        # Whether there is anything to say beyond the signatures themselves.
+        def informative?
+          @relations.any? { |relation| relation.kind != :independent }
+        end
+
+        private
+
+        # ---- causal ------------------------------------------------------
+
+        def relate
+          links = structural_links
+          parent = @units.map(&:position)
+          links.map(&:first).each { |units| units.each_cons(2) { |a, b| union(parent, a.position, b.position) } }
+
+          causal, residual = components(parent, links).partition { |members, evidence| causal?(members, evidence) }
+          relations = causal.map { |members, evidence| Relation.new(kind: :causal, units: members, evidence: evidence) }
+          [relations.sort_by { |relation| [-relation.failures, relation.units.first.position] },
+           residual.flat_map(&:first)]
+        end
+
+        # [units, evidence] for every value of a linking field that more than
+        # one unit carries.
+        def structural_links
+          LINKS.flat_map do |field, type|
+            shared(field).map { |value, units| [units, link_evidence(type, value, units)] }
+          end
+        end
+
+        def components(parent, links)
+          @units.group_by { |unit| find(parent, unit.position) }.values.map do |members|
+            [members, component_evidence(members, links)]
+          end
+        end
+
+        # Several related signatures always form a group. One signature forms
+        # one only when it carries a fact beyond its own fingerprint.
+        def causal?(members, evidence)
+          members.size > 1 || (members.first.size > 1 && !evidence.empty?)
+        end
+
+        # Values of one evidence field carried by more than one unit.
+        def shared(field)
+          index = Hash.new { |hash, key| hash[key] = [] }
+          @units.each { |unit| linkable(unit, field).each { |value| index[value] << unit } }
+          index.select { |_, units| units.size > 1 }
+        end
+
+        def linkable(unit, field)
+          evidence = field == :identities ? unit.evidence.select { |item| context_hook?(item) } : unit.evidence
+          evidence.flat_map { |item| Array(item.public_send(field)) }.uniq
+        end
+
+        def component_evidence(members, links)
+          linked = links.select { |units, _| members.include?(units.first) }.map(&:last)
+          dedupe(linked + members.flat_map { |unit| facts(unit) })
+        end
+
+        def link_evidence(type, value, units)
+          case type
+          when "missing_entity" then entity_evidence(value)
+          when "same_underlying_exception" then underlying_evidence(units)
+          else { "type" => type, "detail" => "one exception object reached #{units.sum(&:size)} examples" }
+          end
+        end
+
+        def underlying_evidence(units)
+          wrapped = units.flat_map(&:evidence).map(&:wrapped).compact.uniq
+          classes = units.map(&:exception_class).uniq
+          { "type" => "same_underlying_exception", "exception" => wrapped.first || classes.first,
+            "raised_as" => classes, "origin" => units.flat_map(&:evidence).map(&:origin).compact.first }.compact
+        end
+
+        def entity_evidence(value)
+          kind, name = value.split(":", 2)
+          { "type" => "missing_entity", "entity" => value, "kind" => kind, "name" => name }
+        end
+
+        # RSpec shares one exception object between examples in exactly one
+        # case: a before(:context) hook failed. Any other sharing is an
+        # exception *instance* being reused -- and Ruby keeps the first raise's
+        # backtrace when an instance is raised again, so nothing about it can
+        # be trusted as "raised once". That is a hint, never a link.
+        def context_hook?(evidence)
+          evidence.phase_detail == "before(:context) hook"
+        end
+
+        def reused_instance_hints
+          carriers = Hash.new { |hash, key| hash[key] = [] }
+          @units.reject(&:outside).each do |unit|
+            unit.evidence.reject { |item| context_hook?(item) }.each do |item|
+              item.identities.each { |token| carriers[token] << unit.key }
+            end
+          end
+          carriers.select { |_, owners| owners.size > 1 }.map do |_, owners|
+            { "type" => "reused_exception_instance", "signatures" => owners.uniq,
+              "detail" => "one exception instance was reported by #{owners.size} examples outside a " \
+                          "before(:context) hook; Ruby keeps the first raise's backtrace, so its origin may be stale" }
+          end.uniq
+        end
+
+        # Facts a single unit carries beyond its fingerprint, when every one of
+        # its failures carries them.
+        def facts(unit)
+          return outside_facts(unit) if unit.outside
+
+          evidence = unit.evidence
+          return [] if evidence.empty? || evidence.size < unit.size
+
+          common = evidence.map(&:entities).reduce(:&) || []
+          shared_object_facts(unit, evidence) + phase_facts(evidence) + common.map { |value| entity_evidence(value) }
+        end
+
+        def shared_object_facts(unit, evidence)
+          tokens = evidence.select { |item| context_hook?(item) }.flat_map(&:identities)
+          return [] if tokens.uniq.size == tokens.size
+
+          [{ "type" => "shared_exception_object", "detail" => "one exception object reached #{unit.size} examples" }]
+        end
+
+        # Only when every member failed in a phase that says the same thing. A
+        # signature failing partly in setup and partly in the body gets none.
+        def phase_facts(evidence)
+          phases = evidence.map { |item| [item.phase, item.phase_detail] }.uniq
+          type = phase_fact(phases)
+          return [] unless type
+
+          reached = { "teardown_failure" => true, "failed_in_let" => true, "setup_failure" => false }[type]
+          [{ "type" => type, "body_reached" => reached, "phase_detail" => phases.map(&:last).join(", "),
+             "sites" => evidence.map(&:site).compact.uniq.first(3) }.compact]
+        end
+
+        def phase_fact(phases)
+          return "teardown_failure" if phases == [["teardown", "after hook"]]
+          return "failed_in_let" if phases == [%w[body let]]
+          return nil unless (phases - SETUP).empty?
+
+          phases.include?(%w[body let]) ? "setup_code" : "setup_failure"
+        end
+
+        def outside_facts(unit)
+          return [] if unit.size < 2
+
+          files = unit.failures.map(&:rerun).uniq
+          [{ "type" => "outside_examples", "files" => files.first(5), "file_count" => files.size,
+             "detail" => "the same error was raised outside any example #{unit.size} times" }]
+        end
+
+        def dedupe(evidence)
+          evidence.uniq { |item| [item["type"], item["entity"], item["phase_detail"]] }
+                  .sort_by { |item| EVIDENCE_ORDER.index(item["type"]) || EVIDENCE_ORDER.size }
+        end
+
+        def find(parent, index)
+          parent[index] = find(parent, parent[index]) unless parent[index] == index
+          parent[index]
+        end
+
+        def union(parent, first, second)
+          a = find(parent, first)
+          b = find(parent, second)
+          parent[[a, b].max] = [a, b].min unless a == b
+        end
+
+        # ---- hints -------------------------------------------------------
+
+        # Two unrelated units raising the same class from the same first-party
+        # line, with different messages. Worth knowing; not worth merging --
+        # a chokepoint raises for many reasons.
+        def same_origin_hints
+          grouped = Hash.new { |hash, key| hash[key] = [] }
+          @units.reject(&:outside).each do |unit|
+            evidence = unit.evidence.first
+            next unless evidence&.origin && evidence.link_key
+
+            grouped[[unit.exception_class, evidence.origin]] << unit
+          end
+          grouped.filter_map do |(exception, origin), units|
+            next if units.size < 2 || same_relation?(units)
+
+            { "type" => "same_origin_different_message", "exception" => exception, "origin" => origin,
+              "signatures" => units.map(&:key) }
+          end
+        end
+
+        def same_relation?(units)
+          owner = units.map { |unit| @relations.index { |relation| relation.units.include?(unit) } }
+          owner.uniq.size == 1 && @relations[owner.first].kind == :causal
+        end
+      end
+    end
+  end
+end

data/lib/rspec/signal/causal/census.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Signal
+    module Causal
+      # How many examples ran, and failed, per spec file and per `type:`.
+      # Counters only -- no descriptions, no messages.
+      #
+      # Deliberately not per parallel worker: parallel_tests assigns files to
+      # workers by size, so "every failure ran on worker 2" usually means
+      # "every failing file was assigned to worker 2".
+      #
+      # This is the base rate every other signal lacks: "9 failures in one file"
+      # means something only next to "11 examples in that file, 0 of 493
+      # elsewhere failed".
+      class Census
+        DIMENSIONS = %w[file type].freeze
+
+        attr_reader :total, :failed
+
+        def initialize
+          @total = 0
+          @failed = 0
+          @counts = DIMENSIONS.to_h { |dimension| [dimension, Hash.new { |hash, key| hash[key] = [0, 0] }] }
+        end
+
+        # Called with the notification for every passed and failed example.
+        # Pending examples neither passed nor failed, and are left out of both
+        # sides. Never raises: counting must not cost a failure its report.
+        def record(notification, failed:)
+          example = notification.example
+          add({ "file" => Capture.file_of(example), "type" => Capture.type_of(example) }, failed: failed)
+        rescue StandardError
+          nil
+        end
+
+        def add(keys, failed:)
+          @total += 1
+          @failed += 1 if failed
+          keys.each { |dimension, value| bump(dimension, value, 1, failed ? 1 : 0) }
+          self
+        end
+
+        # @return [Array(Integer, Integer)] examples run and failed for one value
+        def count(dimension, value)
+          @counts.fetch(dimension, {}).fetch(value.to_s, [0, 0])
+        end
+
+        def values(dimension)
+          @counts.fetch(dimension, {}).keys.sort
+        end
+
+        def empty?
+          @total.zero?
+        end
+
+        def to_h
+          { "total" => @total, "failed" => @failed }.merge(@counts.reject { |_, values| values.empty? })
+        end
+
+        # Adds one parallel worker's census.
+        def merge(data)
+          return self unless data.is_a?(Hash)
+
+          run = data.fetch("total", 0).to_i
+          failures = data.fetch("failed", 0).to_i
+          @total += run
+          @failed += failures
+          %w[file type].each do |dimension|
+            data.fetch(dimension, {}).each { |value, (count, failed)| bump(dimension, value, count.to_i, failed.to_i) }
+          end
+          self
+        end
+
+        private
+
+        def bump(dimension, value, run, failures)
+          return if value.nil? || value.to_s.empty? || !@counts.key?(dimension)
+
+          @counts[dimension][value.to_s][0] += run
+          @counts[dimension][value.to_s][1] += failures
+        end
+      end
+    end
+  end
+end

data/lib/rspec/signal/causal/entities.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Signal
+    module Causal
+      # Missing definitions a failure names, read from Ruby exception
+      # attributes -- never from message text. See {.call}.
+      module Entities
+        module_function
+
+        # Missing definitions, read from exception attributes rather than
+        # message text:
+        #
+        #   env:KEY          KeyError whose receiver is ENV itself
+        #   const:A::B       NameError for a constant, qualified by its namespace
+        #   method:C#m       NoMethodError/NameError on an instance of a class
+        #                    defined in this project (never nil, never a core
+        #                    class: two nils are not the same nil)
+        def call(error, config)
+          case error
+          when KeyError then env_entity(error)
+          when NoMethodError then method_entity(error, config)
+          when NameError then constant_entity(error) || method_entity(error, config)
+          else []
+          end
+        rescue StandardError
+          []
+        end
+
+        def env_entity(error)
+          error.receiver.equal?(ENV) ? ["env:#{error.key}"] : []
+        rescue ArgumentError
+          []
+        end
+
+        def constant_entity(error)
+          name = error.name.to_s
+          return nil unless /\A[A-Z]/.match?(name)
+
+          namespace = error.receiver
+          qualified = namespace.is_a?(Module) && namespace != Object && namespace.name
+          ["const:#{qualified ? "#{namespace.name}::#{name}" : name}"]
+        rescue ArgumentError
+          nil
+        end
+
+        def method_entity(error, config)
+          receiver = error.receiver
+          owner = receiver.is_a?(Module) ? receiver : receiver.class
+          return [] unless owner.name && first_party_class?(owner, config)
+
+          separator = receiver.is_a?(Module) ? "." : "#"
+          ["method:#{owner.name}#{separator}#{error.name}"]
+        rescue ArgumentError
+          []
+        end
+
+        def first_party_class?(owner, config)
+          file, = Object.const_source_location(owner.name)
+          !file.nil? && config.project.first_party?(file)
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rspec/signal/causal/evidence.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module RSpec
+  module Signal
+    # Experimental causal-evidence layer. See docs/design/causal-failure-intelligence.md.
+    #
+    # Everything under this namespace is removable: delete the directory, the
+    # relationships reporter, and the few lines that call into it.
+    module Causal
+      # Structural facts about one failure, captured before backtrace reduction
+      # throws the evidence away. Plain data: it serializes into worker payloads
+      # so the parallel merger reasons over the same facts a serial run does.
+      #
+      #   phase         "setup" | "body" | "teardown" | "outside" | "unknown"
+      #   phase_detail  "before(:context) hook", "before hook", "after hook",
+      #                 "around hook", "let", or nil
+      #   body_reached  true / false, or nil when it cannot be known
+      #   site          the first-party line of the hook or `let` that failed
+      #   origin        innermost first-party frame, spec suite included
+      #   origin_kind   "app" | "support" | "spec"
+      #   link_key      identity of the *underlying* exception: innermost cause
+      #                 class, normalized message and origin. nil for assertion
+      #                 failures, which never link on origin.
+      #   wrapped       the innermost cause's class when the failure wraps one
+      #   entities      missing definitions read from exception attributes
+      #   identities    one token per exception object in the chain
+      Evidence = Struct.new(:phase, :phase_detail, :body_reached, :site, :origin, :origin_kind,
+                            :link_key, :wrapped, :entities, :identities, :file, :type,
+                            keyword_init: true) do
+        def to_h
+          super.transform_keys(&:to_s).reject { |_, value| value.nil? || value == [] }
+        end
+
+        def self.from_h(data)
+          return nil unless data.is_a?(Hash)
+
+          new(**members.to_h { |name| [name, data[name.to_s]] }).tap do |evidence|
+            evidence.entities = Array(evidence.entities)
+            evidence.identities = Array(evidence.identities)
+          end
+        end
+      end
+
+      # Reads {Evidence} out of an exception and its parsed frames.
+      #
+      # Nothing here guesses. Every field is either read from a Ruby exception
+      # attribute, from a frame RSpec itself put on the stack, or left nil.
+      module Capture
+        ASSERTION = /\ARSpec::(?:Expectations|Mocks)::|\ARSpec::Core::MultipleExceptionError/.freeze
+        SPEC_FILE = /_(?:spec|test)\.rb\z/.freeze
+        TEST_TREE = %r{\A(?:spec|test)/}.freeze
+        MAX_CAUSES = 3
+        MAX_CAUSE_FRAMES = 60
+
+        module_function
+
+        # @param exception [Exception]
+        # @param frames [Array<Backtrace::Frame>] the full parsed backtrace
+        # @param identities [Hash] compare_by_identity map shared across a run
+        def call(exception, frames:, config:, identities:, example: nil)
+          chain = chain(exception)
+          phase, detail, reached, site = Phase.call(frames)
+          origin = frames.find(&:project?)
+          Evidence.new(
+            phase: phase, phase_detail: detail, body_reached: reached, site: site&.location,
+            origin: origin&.location, origin_kind: origin && origin_kind(origin),
+            link_key: link_key(chain, origin, config),
+            wrapped: chain.size > 1 ? class_name(chain.last) : nil,
+            entities: chain.flat_map { |error| Entities.call(error, config) }.uniq,
+            identities: chain.map { |error| identities[error] ||= "e#{identities.size + 1}" },
+            **location_of(example)
+          )
+        end
+
+        def location_of(example)
+          example ? { file: file_of(example), type: type_of(example) } : {}
+        end
+
+        def chain(exception)
+          chain = [exception]
+          while (cause = chain.last.cause) && chain.none? { |seen| seen.equal?(cause) } && chain.size <= MAX_CAUSES
+            chain << cause
+          end
+          chain
+        end
+
+        def origin_kind(frame)
+          path = frame.display_path.to_s
+          return "spec" if SPEC_FILE.match?(path)
+          return "support" if TEST_TREE.match?(path)
+
+          "app"
+        end
+
+        # Failures link on origin only when the *underlying* exception is the
+        # same class, with the same normalized message, raised at the same
+        # first-party line. That relates a wrapped exception to its bare
+        # twin; it deliberately does not relate two different messages that
+        # happen to leave one chokepoint.
+        #
+        # The exception's own message is used, never RSpec's rendering of it:
+        # the rendering opens with the failing source line, which differs at
+        # every call site.
+        def link_key(chain, origin, config)
+          innermost = chain.last
+          name = class_name(innermost)
+          return nil if ASSERTION.match?(class_name(chain.first)) || ASSERTION.match?(name)
+
+          location = chain.size == 1 ? origin&.location : cause_origin(innermost, config)
+          return nil unless location
+
+          text = Message.new(innermost.message.to_s.split("\n").first(5), redactor: config.redactor,
+                                                                          project: config.project,
+                                                                          html_threshold: nil).normalized
+          Digest::SHA256.hexdigest([name, text, location].join("\0"))[0, 12]
+        end
+
+        def cause_origin(error, config)
+          frames = Backtrace::Parser.parse(Array(error.backtrace).first(MAX_CAUSE_FRAMES), config.classifier)
+          frames.find(&:project?)&.location
+        end
+
+        def file_of(example)
+          example.metadata[:rerun_file_path].to_s.sub(%r{\A\./}, "")
+        rescue StandardError
+          nil
+        end
+
+        def type_of(example)
+          example.metadata[:type]&.to_s
+        rescue StandardError
+          nil
+        end
+
+        def class_name(error)
+          name = error.class.name.to_s
+          name.empty? ? "(anonymous error class)" : name
+        end
+      end
+    end
+  end
+end

data/lib/rspec/signal/causal/phase.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Signal
+    module Causal
+      # Which part of an example a failure happened in, read from the
+      # rspec-core frames just outside the failing code. See {.call}.
+      module Phase
+        CORE_FILE = %r{/lib/rspec/core/(\w+\.rb)\z}.freeze
+
+        # The hook methods RSpec runs a failing hook's block from. Resolved from
+        # the loaded rspec-core rather than hardcoded, so line numbers moving
+        # between releases cannot misclassify a frame.
+        HOOKS = {
+          "before hook" => %i[BeforeHook run],
+          "after hook" => %i[AfterHook run],
+          "around hook" => %i[AroundHook execute_with]
+        }.freeze
+
+        module_function
+
+        # Where the failure happened relative to the example, read from the
+        # rspec-core frames just outside the failing code:
+        #
+        #   Example#instance_exec -> Example#run            example body
+        #   Example#instance_exec -> BeforeHook#run         before(:each)
+        #   Example#instance_exec -> AfterHook#run          after(:each)
+        #   BasicObject#instance_exec -> BeforeHook#run     before(:context)
+        #                                                   (no Example involved)
+        #
+        # A `let` raising from inside the body is still the body: it began.
+        def call(frames)
+          core = frames.each_with_index.filter_map { |frame, index| [frame, index] if core_file(frame) }
+          anchor = core.index { |frame, _| %w[example.rb hooks.rb].include?(core_file(frame)) }
+          return ["unknown", nil, nil, nil] unless anchor
+
+          anchor_frame, anchor_index = core[anchor]
+          memoized = core.first(anchor).any? { |frame, _| core_file(frame) == "memoized_helpers.rb" }
+          caller = core.drop(anchor).map(&:first).find { |frame| !frame.label.to_s.end_with?("instance_exec") }
+          site = site(frames, anchor_index, memoized)
+          classify(caller, core_file(anchor_frame) == "hooks.rb", memoized) + [site]
+        end
+
+        def classify(caller, context, memoized)
+          return ["unknown", nil, nil] unless caller
+          return ["body", memoized ? "let" : nil, true] if body_frame?(caller)
+
+          case hook_kind(caller)
+          when "before hook" then context ? ["setup", "before(:context) hook", false] : ["setup", "before hook", false]
+          when "after hook" then ["teardown", "after hook", true]
+          when "around hook" then ["unknown", "around hook", nil]
+          else ["unknown", nil, nil]
+          end
+        end
+
+        def body_frame?(frame)
+          core_file(frame) == "example.rb" && /block in (?:\S+#)?run\z/.match?(frame.label.to_s)
+        end
+
+        def hook_kind(frame)
+          return nil unless core_file(frame) == "hooks.rb"
+
+          label = frame.label.to_s
+          by_label = HOOKS.find { |_, (klass, method)| label.include?("#{klass}##{method}") }
+          return by_label.first if by_label
+
+          path = File.expand_path(frame.path)
+          hook_sites.find { |_, file, line| file == path && frame.line.to_i.between?(line, line + 3) }&.first
+        end
+
+        def hook_sites
+          @hook_sites ||= HOOKS.filter_map do |name, (klass, method)|
+            file, line = ::RSpec::Core::Hooks.const_get(klass).instance_method(method).source_location
+            [name, File.expand_path(file), line]
+          rescue StandardError
+            nil
+          end
+        end
+
+        # The first-party line that *is* the failing hook or `let`: the frame
+        # just inside the memoized helper for a `let`, and the outermost
+        # first-party frame inside the runner otherwise.
+        def site(frames, anchor_index, memoized)
+          inner = frames.first(anchor_index)
+          if memoized
+            helper = inner.index { |frame| core_file(frame) == "memoized_helpers.rb" }
+            return inner.first(helper.to_i).reverse.find(&:project?)
+          end
+          inner.reverse.find(&:project?)
+        end
+
+        def core_file(frame)
+          frame.path.to_s[CORE_FILE, 1]
+        end
+      end
+    end
+  end
+end