vcr-unused_cassettes 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29639a4cd178bd1c230d8e2bd6497458e1d9b2e3c61c675924f88b2382c227ae
-  data.tar.gz: 6cabbd3841f908571002517ceef11d25530cd339f2ccd3da86693879409954eb
+  metadata.gz: 0a648da7caa35c506546937a278548e14b4d912d0c6ca618da0390b576b22f29
+  data.tar.gz: c8f9f08054107b7c7b0b2e3e641b8fa470d414bc1d5f9218938e60dc00d84905
 SHA512:
-  metadata.gz: 617933f66c7c60f04ffe0aced7a24e430434489d34f8257de8971d68b98478a4262124934542233ae934cca9f0fb1afda030fcc3716b8a0d0b90aab026519628
-  data.tar.gz: e61cedf39718fba1122f19b10c1cb778b7a05e6638ace0941163765e1cb754cdcc17a5972b88b99f848960084f1f3bb20839a360c43e763e496817c8fcaefd5c
+  metadata.gz: 564910bb7f1e4d5c70238d089e03bbad0549b7ec6bd02e24e1c20c7c69ce8f8311a6ce54eafea67d69614df10ddee955f298e3c636e2c17d9aec65956adf6c67
+  data.tar.gz: 04b05af06f640486af07e4bfab652e9b605c63ae226cbc9e6a59f6ccbb44bc0410f1349de825707818306440c531f668569f99c820aa7324ef5ebec46a9c0cd6

data/.standard.yml

@@ -1 +1,3 @@
 parallel: true
+ignore:
+  - 'spec/fixtures/**/*'

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [1.2.0] - 2026-05-22
+
+- Fix `NoMethodError` when emitting a warning for an unresolveable cassette name
+- Resolve cassette names that come from method parameters by binding helper-method parameters to literal defaults and to the values passed at same-file call sites. Multi-value bindings fan out into one cassette entry per value; interpolations fan out via Cartesian product, so patterns like `"#{prefix}_#{suffix}"` resolve to concrete cassettes instead of being flagged as unused.
+- Raise on unbound local/instance variable reads instead of silently returning `nil`, so unresolved interpolation parts collapse to `"*"` wildcards rather than producing garbage patterns.
+- Chore: Add tests
+
 ## [1.1.0] - 2025-03-03
 
 - Comply with zeitwerks eager loading

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    vcr-unused_cassettes (1.1.0)
+    vcr-unused_cassettes (1.2.0)
       vcr
       zeitwerk
 

data/README.md

@@ -53,11 +53,16 @@ Open for contributions. Some ideas what could be done in the future:
 - fancy spinner with progress indicator (configurable for ci environments)
 - parallelize the analysis of the cassettes
 
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the changelog and the version number in `version.rb`, commit it, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
 ## Contributing
 
 Contributions and ideas are welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information.
 
-
 ## Code of Conduct
 
 Everyone interacting in the Vcr::UnusedCassettes project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jbockler/vcr-unused_cassettes/blob/master/CODE_OF_CONDUCT.md).

data/lib/vcr/unused_cassettes/call_context.rb

@@ -4,11 +4,17 @@ module VCR::UnusedCassettes
   class CallContext
     ValueUnresolveable = Class.new(StandardError)
 
-    def initialize
+    # Reads under :raise mode raise ValueUnresolveable; only :wildcard callers
+    # can safely unpack the values.
+    MultiValue = Struct.new(:values)
+
+    def initialize(method_index: nil)
+      @method_index = method_index
       @context = {
         variables: {},
         constants: {}
       }
+      @parameter_scopes = []
     end
 
     def track(node)
@@ -23,7 +29,18 @@ module VCR::UnusedCassettes
       end
     end
 
+    def enter_method(def_node)
+      @parameter_scopes.push(build_parameter_frame(def_node))
+    end
+
+    def exit_method
+      @parameter_scopes.pop
+    end
+
     def resolve_variable(variable_name)
+      @parameter_scopes.reverse_each do |frame|
+        return frame[variable_name] if frame.key?(variable_name)
+      end
       @context.dig(:variables, variable_name)
     end
 
@@ -56,29 +73,21 @@ module VCR::UnusedCassettes
           extract_value(element, string_interpolation_error: string_interpolation_error)
         end
       when :interpolated_string_node
-        node.parts.map do |part_node|
-          if part_node.type == :embedded_statements_node
-            if part_node.statements.body.size != 1
-              if string_interpolation_error == :raise
-                raise ValueUnresolveable, "Could not resolve value for node: #{part_node.inspect}"
-              elsif string_interpolation_error == :wildcard
-                "*"
-              end
-            else
-              extract_value(part_node.statements.body.first, string_interpolation_error: string_interpolation_error)
-            end
-          else
-            extract_value(part_node, string_interpolation_error: string_interpolation_error)
-          end
-        rescue ValueUnresolveable
-          if string_interpolation_error == :raise
-            raise ValueUnresolveable, "Could not resolve value for node: #{part_node.inspect}"
-          elsif string_interpolation_error == :wildcard
-            "*"
-          end
-        end.join
+        part_options = node.parts.map { |part_node| interpolation_part_options(part_node, string_interpolation_error) }
+        combinations = part_options.reduce([[]]) do |acc, options|
+          acc.flat_map { |prefix| options.map { |opt| prefix + [opt] } }
+        end
+        results = combinations.map { |parts| parts.map(&:to_s).join }.uniq
+        (results.size == 1) ? results.first : MultiValue.new(results)
       when :local_variable_read_node, :instance_variable_read_node
-        resolve_variable(node.name)
+        unless variable_bound?(node.name)
+          raise ValueUnresolveable, "Could not resolve value for node: #{node.inspect}"
+        end
+        value = resolve_variable(node.name)
+        if value.is_a?(MultiValue) && string_interpolation_error != :wildcard
+          raise ValueUnresolveable, "Multi-value binding cannot be embedded: #{node.inspect}"
+        end
+        value
       when :constant_read_node
         @context.dig(:constants, node.name)
       when :assoc_splat_node
@@ -94,6 +103,11 @@ module VCR::UnusedCassettes
 
     private
 
+    def variable_bound?(name)
+      return true if @parameter_scopes.any? { |frame| frame.key?(name) }
+      @context[:variables].key?(name)
+    end
+
     def reset_local_variables!
       @context[:variables].select! { |key, _value| key.start_with?("@") }
     end
@@ -123,5 +137,75 @@ module VCR::UnusedCassettes
       end
       false
     end
+
+    def build_parameter_frame(def_node)
+      frame = {}
+      return frame if def_node.parameters.nil?
+      params = def_node.parameters
+
+      call_bindings = @method_index ? @method_index.call_arguments_for(def_node.name) : []
+
+      parameter_specs(params).each do |name, default_node|
+        candidates = []
+        if default_node
+          begin
+            candidates << extract_value(default_node, string_interpolation_error: :raise)
+          rescue ValueUnresolveable
+          end
+        end
+        call_bindings.each do |call_binding|
+          candidates << call_binding[name] if call_binding.key?(name)
+        end
+        candidates = flatten_candidates(candidates)
+        next if candidates.empty?
+        frame[name] = (candidates.size == 1) ? candidates.first : MultiValue.new(candidates)
+      end
+
+      frame
+    end
+
+    def parameter_specs(parameters_node)
+      specs = []
+      if parameters_node.respond_to?(:requireds)
+        parameters_node.requireds.each { |p| specs << [p.name, nil] if p.respond_to?(:name) }
+      end
+      if parameters_node.respond_to?(:optionals)
+        parameters_node.optionals.each { |p| specs << [p.name, p.value] }
+      end
+      if parameters_node.respond_to?(:keywords)
+        parameters_node.keywords.each do |p|
+          default = p.respond_to?(:value) ? p.value : nil
+          specs << [p.name, default]
+        end
+      end
+      specs
+    end
+
+    def interpolation_part_options(part_node, string_interpolation_error)
+      if part_node.type == :embedded_statements_node
+        if part_node.statements.body.size != 1
+          raise ValueUnresolveable, "Could not resolve value for node: #{part_node.inspect}"
+        end
+        value = extract_value(part_node.statements.body.first, string_interpolation_error: string_interpolation_error)
+        value.is_a?(MultiValue) ? value.values : [value]
+      else
+        [extract_value(part_node, string_interpolation_error: string_interpolation_error)]
+      end
+    rescue ValueUnresolveable
+      raise if string_interpolation_error == :raise
+      ["*"]
+    end
+
+    def flatten_candidates(candidates)
+      flat = []
+      candidates.each do |c|
+        if c.is_a?(MultiValue)
+          flat.concat(c.values)
+        else
+          flat << c
+        end
+      end
+      flat.uniq
+    end
   end
 end

data/lib/vcr/unused_cassettes/cassette_usage_finder.rb

@@ -10,13 +10,15 @@ module VCR::UnusedCassettes
       self.filename = filename
       self.used_cassettes = []
       self.warnings = []
-      self.call_context = CallContext.new
     end
 
     def find_cassette_usages
       parse_result = Prism.parse_file(filename)
       return [[], []] unless parse_result
 
+      method_index = MethodIndex.new(parse_result.value)
+      self.call_context = CallContext.new(method_index: method_index)
+
       find_cassette_usages_in(parse_result.value)
 
       [used_cassettes, warnings]
@@ -28,20 +30,36 @@ module VCR::UnusedCassettes
       call_context.track(node)
 
       if node_contains_call?(node)
-        found_name = find_cassette_name(node)
-        if !found_name.nil? && /[a-zA-Z0-9]/.match?(found_name)
-          cassette_use = {pattern: found_name}
-          cassette_options = extract_options(node)
-          cassette_use[:persister] = cassette_options[:persist_with] if cassette_options&.has_key?(:persist_with)
-          cassette_use[:serializer] = cassette_options[:serialize_with] if cassette_options&.has_key?(:serialize_with)
-          used_cassettes << cassette_use
-        end
+        record_cassette_uses(node)
       end
 
       return if node.child_nodes.nil?
 
-      node.child_nodes.each do |child_node|
-        find_cassette_usages_in(child_node)
+      if node.is_a?(Prism::DefNode)
+        call_context.enter_method(node)
+        begin
+          node.child_nodes.each { |child| find_cassette_usages_in(child) }
+        ensure
+          call_context.exit_method
+        end
+      else
+        node.child_nodes.each { |child| find_cassette_usages_in(child) }
+      end
+    end
+
+    def record_cassette_uses(node)
+      found_name = find_cassette_name(node)
+      return if found_name.nil?
+
+      cassette_options = extract_options(node)
+      patterns = found_name.is_a?(CallContext::MultiValue) ? found_name.values : [found_name]
+
+      patterns.each do |pattern|
+        next unless pattern.is_a?(String) && /[a-zA-Z0-9*]/.match?(pattern)
+        cassette_use = {pattern: pattern}
+        cassette_use[:persister] = cassette_options[:persist_with] if cassette_options&.has_key?(:persist_with)
+        cassette_use[:serializer] = cassette_options[:serialize_with] if cassette_options&.has_key?(:serialize_with)
+        used_cassettes << cassette_use
       end
     end
 
@@ -76,7 +94,7 @@ module VCR::UnusedCassettes
 
     def build_warning(node, error)
       Warning.new.tap do |warning|
-        warning.message = "Could not determine cassette name for #{filename}:#{node.line}"
+        warning.message = "Could not determine cassette name for #{filename}:#{node.location.start_line}"
         warning.details = error.message
         warning.backtrace = error.backtrace
       end

data/lib/vcr/unused_cassettes/method_index.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module VCR::UnusedCassettes
+  class MethodIndex
+    def initialize(root_node)
+      @definitions = {}
+      @call_arguments = Hash.new { |h, k| h[k] = [] }
+      collect_definitions(root_node)
+      collect_calls(root_node, CallContext.new) unless @definitions.empty?
+    end
+
+    def call_arguments_for(method_name)
+      @call_arguments[method_name] || []
+    end
+
+    private
+
+    def collect_definitions(node)
+      return if node.nil?
+      @definitions[node.name] = node if node.is_a?(Prism::DefNode)
+      return if node.child_nodes.nil?
+      node.child_nodes.each { |child| collect_definitions(child) }
+    end
+
+    def collect_calls(node, context)
+      return if node.nil?
+      context.track(node)
+      record_call(node, context) if known_helper_call?(node)
+      return if node.child_nodes.nil?
+      node.child_nodes.each { |child| collect_calls(child, context) }
+    end
+
+    def known_helper_call?(node)
+      return false unless node.is_a?(Prism::CallNode)
+      return false unless node.receiver.nil?
+      @definitions.key?(node.name)
+    end
+
+    def record_call(call_node, context)
+      def_node = @definitions[call_node.name]
+      return if call_node.arguments.nil?
+
+      positional_names = positional_parameter_names(def_node)
+      keyword_names = keyword_parameter_names(def_node)
+      call_binding = {}
+      pos_index = 0
+      positional_unknown = false
+
+      call_node.arguments.arguments.each do |arg|
+        case arg
+        when Prism::KeywordHashNode
+          arg.elements.each do |element|
+            next unless element.is_a?(Prism::AssocNode)
+            next unless element.key.is_a?(Prism::SymbolNode)
+            name = element.key.unescaped.to_sym
+            next unless keyword_names.include?(name)
+            begin
+              call_binding[name] = context.extract_value(element.value, string_interpolation_error: :raise)
+            rescue CallContext::ValueUnresolveable
+            end
+          end
+        when Prism::BlockArgumentNode
+          # block arg does not consume a positional slot
+        when Prism::SplatNode, Prism::ForwardingArgumentsNode
+          # alignment between source args and parameter list is lost from here on
+          positional_unknown = true
+        else
+          if !positional_unknown && pos_index < positional_names.size
+            name = positional_names[pos_index]
+            begin
+              call_binding[name] = context.extract_value(arg, string_interpolation_error: :raise)
+            rescue CallContext::ValueUnresolveable
+            end
+          end
+          pos_index += 1
+        end
+      end
+
+      @call_arguments[call_node.name] << call_binding unless call_binding.empty?
+    end
+
+    def positional_parameter_names(def_node)
+      return [] if def_node.parameters.nil?
+      params = def_node.parameters
+      names = []
+      names.concat(params.requireds.map(&:name)) if params.respond_to?(:requireds)
+      names.concat(params.optionals.map(&:name)) if params.respond_to?(:optionals)
+      names
+    end
+
+    def keyword_parameter_names(def_node)
+      return [] if def_node.parameters.nil?
+      params = def_node.parameters
+      return [] unless params.respond_to?(:keywords)
+      params.keywords.map(&:name)
+    end
+  end
+end

data/lib/vcr/unused_cassettes/version.rb

@@ -2,6 +2,6 @@
 
 module VCR
   module UnusedCassettes
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vcr-unused_cassettes
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Josch Bockler
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-03 00:00:00.000000000 Z
+date: 2026-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vcr
@@ -61,6 +61,7 @@ files:
 - lib/vcr/unused_cassettes/Rakefile
 - lib/vcr/unused_cassettes/call_context.rb
 - lib/vcr/unused_cassettes/cassette_usage_finder.rb
+- lib/vcr/unused_cassettes/method_index.rb
 - lib/vcr/unused_cassettes/railtie.rb
 - lib/vcr/unused_cassettes/runner.rb
 - lib/vcr/unused_cassettes/tasks/vcr/unused_cassettes.rake