rspec-debugging 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18dc39f0ec372fefa54e665b0f8fa941ee58d2e5437d0f7baf165411a7ae3706
-  data.tar.gz: bd59263041e3197220b04c1cda058e1d57fe91eb86ed4a50d461c06c02620c98
+  metadata.gz: cef0952745e075d2ddb60bf6827985ae51dcc935b14624f97bebb48bda5b29f1
+  data.tar.gz: 104a0eae0841e4c02dc15004254f020c87f7f79aaa4058183c88a1d3bbe2ef54
 SHA512:
-  metadata.gz: f1a1432398be62a3f54c4c3b198b94b6a69ac9f1524a36f25026ff53bfd5af7ec17dcb0b64c2f01f6b3886492055121f961216f5a818cd37ca2bfbf831fed4cc
-  data.tar.gz: eda816fa9f998da2aaf4075010af9e06bafca4b2c308609a2285e0fc202c325284e77eefa5d39ddca787f4a18f7b4ada05265955c08caa2bdd5bc14969765f90
+  metadata.gz: f4d818d570b7d1c2d1ddfaf919112b2291a996b6dc2e064b18b342e8dc997c8dcf77603bcb961c0a2c45b21a4c49949a9f0bb6afb14ce6e7495113b0905a6fbd
+  data.tar.gz: affde56467e8d7ae4c842a9cd83cff7bd8833f4c09a7acdfb276b6e8e963ec72e6dc3322c431349e1d80e4b3e1d65041fed38ad7d635e46f19ae02f210cd9a11

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+###  0.0.6  (2026-11-03)
+- fix: an example that closes `$stdin` and then fails skips the postmortem debugger instead of crashing its thread with `IOError: closed stream`
+
+###  0.0.5  (2026-11-03)
+- feature: failures in `before` / `after` hooks and `let!` now open the postmortem debugger
+- feature: the postmortem banner lists the names of initialized `let` variables
+- fix: quitting the debugger no longer ends the run as a pass; the failing example is reported and the run stops with a non-zero exit
+- fix: `dit` never opens the debugger when stdin isn't a TTY (CI), so it can't block a run
+- fix: `dit` blocks that take the example (`dit "x" do |example|`) receive it again instead of nil
+- fix: examples inside `ddescribe` / `dcontext` now open the debugger
+- fix: `skip`, `pending` and `exit` no longer open the debugger; only real failures do
+- fix: blockless `dit` reports the right location on Ruby 4.0, and blockless `it` / `dit ... do` examples no longer report a location inside rspec-debugging
+- fix: declare `debug` and `rspec-core` as runtime dependencies; the gem failed to load (`LoadError: cannot load such file -- debug`) in a bundle without `debug`
+- drop Ruby 3.1 (end of life); requires Ruby >= 3.2
+- fix: `let_variable_values` no longer memoizes the lets its definitions reference, so inspecting a let doesn't change what the example does next
+- fix: `let_variable_values` returns a raising definition's error as that scope's value instead of aborting the whole call
+- fix: let helpers accept String names, and raise `ArgumentError` naming an unknown let instead of `undefined method 'map' for nil` (or quietly returning nil/false)
+- fix: `let_variable_*(:subject)` follows a named subject (`subject(:thing)`) to its let instead of crashing or returning an outer group's subject
+- fix: the gem's private helpers (`normalize_path`, `let_variable_methods`) are no longer mixed into example groups, where they collided with user helpers of the same name
+- fix: let helpers work inside `before(:context)` (lets read as uninitialized) instead of raising `undefined method 'key?' for nil`
+- fix: `let_variable_values` reports the right value for a definition that calls `super()` after the let has been memoized (it used to build on the memoized value)
+- fix: `let_variable_values` passes the current example to `let(:x) { |example| ... }` definitions instead of reporting an `ArgumentError`
+- fix: `dit` no longer opens the debugger when stderr isn't a TTY (e.g. `rspec --bisect` children, which showed a bare debugger prompt)
+- fix: `--dry-run` reports a blockless `dit` as pending, not passed
+- fix: let helpers no longer treat a described class whose name contains `LetDefinitions` as a source of let variables
+- fix: `dit` no longer opens the debugger when stdout is redirected (e.g. `rspec -f json > out.json`), which looked like a hang and corrupted the output
+- fix: the postmortem no longer hides your own code under `lib/rspec/` or in a project checked out under `lib/rspec-*/`
+- fix: a blockless `dit` under `xdescribe`, a skipped group, or `pending` (on the group or itself) stays pending instead of becoming a breakpoint
+- fix: debugged examples no longer tag exceptions with debugger state, so rescued errors and failures can be marshaled again, and raising a frozen exception no longer crashes with "exception reentered"
+- fix: rspec-debugging's own frames no longer appear in failure backtraces when the gem is loaded from a path or git checkout
+
 ###  0.0.4  (2025-02-08)
 - dependency fix
 - readme

data/Gemfile.lock

@@ -1,54 +1,66 @@
 PATH
   remote: .
   specs:
-    rspec-debugging (0.0.4)
-      rspec-expectations (>= 3)
+    rspec-debugging (0.0.5)
+      debug (>= 1.10)
+      rspec-core (>= 3.10)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    debug (1.9.2)
+    cgi (0.5.1)
+    date (3.5.1)
+    debug (1.11.1)
       irb (~> 1.10)
       reline (>= 0.3.8)
-    diff-lcs (1.5.1)
+    diff-lcs (1.6.2)
     docile (1.4.1)
-    io-console (0.7.2)
-    irb (1.14.1)
+    erb (4.0.4.1)
+      cgi (>= 0.3.3)
+    io-console (0.8.2)
+    irb (1.16.0)
+      pp (>= 0.6.0)
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
-    psych (5.2.0)
+    pp (0.6.3)
+      prettyprint
+    prettyprint (0.2.0)
+    psych (5.3.1)
+      date
       stringio
-    rdoc (6.8.1)
+    rdoc (7.0.1)
+      erb
       psych (>= 4.0.0)
-    reline (0.5.11)
+      tsort
+    reline (0.6.3)
       io-console (~> 0.5)
-    rspec (3.13.0)
+    rspec (3.13.2)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
       rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.2)
+    rspec-core (3.13.6)
       rspec-support (~> 3.13.0)
-    rspec-expectations (3.13.3)
+    rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.2)
+    rspec-mocks (3.13.6)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-support (3.13.1)
+    rspec-support (3.13.6)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.13.1)
     simplecov_json_formatter (0.1.4)
-    stringio (3.1.2)
+    stringio (3.2.0)
+    tsort (0.2.0)
 
 PLATFORMS
   arm64-darwin-24
   ruby
 
 DEPENDENCIES
-  debug
   rspec
   rspec-debugging!
   simplecov

data/README.md

@@ -6,86 +6,161 @@ rspec-debugging
 
 Tools to make debugging RSpec tests easier.
 
+```ruby
+# Gemfile
+gem "rspec-debugging"
+
+# spec/spec_helper.rb
+require "rspec/debugging"
+```
+
+Built on the [debug](https://github.com/ruby/debug) gem.
+
 <br />
 
 Debug broken specs
 ----
-Use `dit`, `dcontext`, or `ddescribe` to run a subset of examples and and start the debugger if anything breaks.
+Swap `it` for `dit` (or `describe` / `context` for `ddescribe` / `dcontext`). When the example fails, you land in the debugger right where it broke, with the stack intact.
 
 ```ruby
-require "rspec/debugging"
-
 describe MySpec do
   dit { is_expected.to ... }
 end
 ```
 
-or set an environment variable to run and debug all specs:
+Failures in `before` / `after` hooks and `let!` count too. Before the prompt opens, you get the error and the names of any `let` variables that were initialized:
+
+```
+Error:
+
+expected: "Bob"
+     got: "Ada"
+
+(compared using ==)
+
+
+initialized lets: user
+```
+
+Getting around: `c` (continue) re-raises the error, so the example fails as usual and the run carries on. `q` quits, which stops the run and fails it; it asks `Really quit? [Y/n]` first, and `q!` skips the question.
+
+Or debug every example, no code changes:
 ```
 RSPEC_DEBUGGING=true bundle exec rspec
 ```
 
+Tip: `RSPEC_DEBUGGING=true bundle exec rspec --only-failures --fail-fast` debugs the first remaining failure. `--only-failures` needs one prior run and this line in your config:
+
+```ruby
+config.example_status_persistence_file_path = "spec/examples.txt"
+```
+
+Use `rspec path/to/spec.rb:42` to target one example.
+
 <br />
 
 Stop and explore
 ----
-Drop `dit` anywhere to start a debugger.
+A `dit` with no block is a breakpoint.
 
 ```ruby
 describe MySpec do
+  let(:user) { ... }
+
   dit
 end
 ```
 
 <br />
 
+Good to know
+----
+* `dit` and friends tag examples `focus: true`, so they only narrow the run if your config has `config.filter_run_when_matching :focus`.
+* Keep a stray `dit` from being committed: [rubocop-rspec](https://github.com/rubocop/rubocop-rspec)'s `RSpec/Focus` cop flags them once they're in its list of focused methods (`fit` and friends stay flagged):
+
+  ```yaml
+  # .rubocop.yml
+  RSpec:
+    Language:
+      ExampleGroups:
+        Focused: [ddescribe, dcontext]
+      Examples:
+        Focused: [dit]
+  ```
+* The debugger only opens when stdin, stdout and stderr are all terminals. Redirect any of them (CI, or `rspec -f json > out.json`) and nothing interactive happens, so a stray `dit` won't hang CI. It still tags `focus: true`, though, so like a stray `fit` it can narrow the run to that one example. A blockless `dit` reports as pending ("Not yet implemented").
+* A `Timeout`-style `around` hook (`Timeout.timeout(n) { ex.run }`) keeps ticking while you debug. When it expires, it breaks the debugger session and the example fails with the timeout instead of the original error.
+* `skip` and `pending` don't open the debugger; only real failures do.
+* Not covered: `before(:all)` failures, unmet mock expectations, and `aggregate_failures`.
+* While debugging, every raised exception has its frames captured — even ones your code rescues — so `RSPEC_DEBUGGING=true` can slow down exception-heavy suites.
+
+<br />
+
 Got let variables?
 ----
-`let` variables are great, but complexity can obscure their value.
+`let` variables are great, but complexity can obscure their values.
 
 ```ruby
-describe RSpec::Debugging do
-  describe RSpec::Debugging::LetVariables do
-    subject { a }
+describe "a" do
+  subject { a }
 
-    let(:a) { "a" }
-    let!(:b) { "b" }
+  let(:a) { "a" }
+  let!(:b) { "b" }
 
-    it { is_expected.to be ??? }
+  it { is_expected.to eq ??? }
 
-    context "when we nest" do
-      let(:a) { "A" + b }
+  context "when we nest" do
+    let(:a) { "A" + b }
 
-      it { is_expected.to be ??? }
+    it { is_expected.to eq ??? }
 
-      context "...and nest" do
-        let(:a) { super() * 2 }
+    context "...and nest" do
+      let(:a) { super() * 2 }
 
-        it { is_expected.to be ??? }
-      end
+      it { is_expected.to eq ??? }
     end
+  end
+end
 ```
 
-...add a hundred lines of legacy code and then solve for `a`.  Or use tooling :)
+...add a hundred lines of legacy code and then solve for `a`. Or use tooling :)
 
-<br />
+```ruby
+# inside the innermost example
+let_variables                  # => [:a, :b, :subject]
+let_variable_initialized?(:a)  # => false
+let_variable_initialized?(:b)  # => true, thanks to let!
+let_variable_locations(:a)     # => ["spec/a_spec.rb:15", "spec/a_spec.rb:10", "spec/a_spec.rb:4"]
+let_variable_values(:a)
+# => [
+#   { "spec/a_spec.rb:15" => "AbAb" },
+#   { "spec/a_spec.rb:10" => "Ab" },
+#   { "spec/a_spec.rb:4" => "a" },
+# ]
+```
 
-----
+Names can be a Symbol or a String. An unknown name raises `ArgumentError`.
 
 ### let_variables
-* list of variables defined by RSpec `let`
-
+* names of all `let` variables in scope (including `subject`)
 
 ### let_variable_initialized?(name)
-* whether a specified let variable been initialized
-
+* whether the variable has been evaluated yet in this example
 
 ### let_variable_get(name)
-* the value of a let variable, if initialized
+* the memoized value, or `nil` if it hasn't been evaluated. Never triggers evaluation.
+
+### let_variable_reset(name)
+* forget the memoized value, so the next call re-evaluates it
+
+### let_variable_locations(name)
+* every place the variable is defined, innermost first
 
 ### let_variable_values(name)
-* all locations where the specified variable has been defined or redefined, and it's value at each location
+* every place the variable is defined, innermost first, with the value each definition produces
+* doesn't memoize anything, so the example carries on as if you never looked. If a definition raises, its error is its value.
+* it does run each definition, though, so external side effects (DB writes, HTTP calls) still happen
 
+The helpers only see `let` definitions: a plain `def` that overrides a `let` of the same name isn't detected.
 
 <br />
 

data/lib/rspec/debugging/debug_it.rb

@@ -6,55 +6,149 @@ module RSpec
     module DebugIt
       ENABLED = ['1', 'true'].include?(ENV['RSPEC_DEBUGGING'])
 
-      def initialize(example_group_class, description, user_metadata, example_block=nil)
-        return super unless user_metadata[:debug] || ENABLED
+      GEM_LIB = %r{\A#{Regexp.escape(File.expand_path("../..", __dir__))}/}
 
-        if example_block
-          orig_example_block = example_block
+      # Frames to hide from the postmortem: rspec's gems and executable, and this
+      # gem. Anchored to those dirs so user code under lib/rspec/ stays visible.
+      HIDDEN_FRAMES = Regexp.union(
+        %r{/rspec-(core|expectations|mocks|support)(-[^/]+)?/lib/},
+        %r{/(exe|bin)/rspec\z},
+        GEM_LIB,
+        %r{\A<internal:trace_point>\z},
+      )
 
-          example_block = Proc.new do
-            e = DEBUGGER__::SESSION.capture_exception_frames /(exe|bin|lib)\/rspec/ do
-              instance_exec(&orig_example_block)
-            end
+      # Mirrors debug's SESSION.capture_exception_frames, which tags every
+      # exception raised on any thread while it runs, rescued and frozen ones
+      # included. This watches only this thread and keeps the frames in a local
+      # table, keyed weakly so rescued exceptions can still be collected (not
+      # WeakMap: it holds values weakly too, so a GC would drop the frames).
+      # Ruby 3.2 lacks WeakKeyMap. Returns [error, frames] for an error that
+      # escapes the block.
+      def self.capture_frames
+        frames = defined?(ObjectSpace::WeakKeyMap) ? ObjectSpace::WeakKeyMap.new : {}.compare_by_identity
+        hook = TracePoint.new(:raise) do |tp|
+          # C frames have a nil path on Ruby 4.0
+          frames[tp.raised_exception] = DEBUGGER__.capture_frames(nil).reject { |f| f.path&.match?(HIDDEN_FRAMES) }
+        rescue StandardError
+          # WeakKeyMap calls the exception's #hash; if that raises, skip it
+        end
 
-            if e
-              $stderr.puts <<~MSG
+        hook.enable(target_thread: Thread.current) { yield }
+      rescue Exception => error
+        found = (frames[error] rescue nil)
+        found ? [error, found] : raise
+      end
 
-              Error:
-              #{e.message}
+      # Skip, an expected failure of a pending example, and exit aren't failures.
+      # Nor is anything once the run is stopping.
+      def self.failure?(error)
+        !RSpec.world.wants_to_quit &&
+          !RSpec.current_example.pending? &&
+          !error.is_a?(RSpec::Core::Pending::SkipDeclaredInExample) &&
+          RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue === error
+      end
 
-              MSG
+      # Quitting the debugger raises SystemExit, which would end the run as a
+      # pass. Stop the run instead; the examples it skips make it fail.
+      def self.session
+        yield
+      rescue SystemExit
+        RSpec.world.wants_to_quit = true
+      end
 
-              DEBUGGER__::SESSION.enter_postmortem_session e
-              raise e
-            end
-          end # Proc.new
-        elsif user_metadata[:debug] && user_metadata[:skip] == RSpec::Core::Pending::NOT_YET_IMPLEMENTED
-          # called with no block
-          user_metadata.delete(:skip)
+      # The console reads stdin and writes stdout; our banner goes to stderr.
+      # Any one redirected (rspec -f json > out, --bisect children) or closed
+      # (tty? raises on a closed IO) means no one can drive it.
+      def self.interactive?
+        [$stdin, $stdout, $stderr].all? { |io| !io.closed? && io.tty? } &&
+          !RSpec.configuration.dry_run?
+      end
 
-          location = RSpec::Core::Metadata.relative_path(caller[2].split(":in").first)
+      # Hooks in at run time, not in initialize: an extra frame there would
+      # become the location RSpec records for blockless examples.
+      def run(example_group_instance, reporter)
+        if (ENABLED || metadata[:debug]) && DebugIt.interactive?
+          debug_blockless if breakpoint?
+          example_group_instance.extend(Postmortem)
+        end
 
-          example_block = Proc.new do
-            $stderr.puts <<~MSG
-            debugging: #{location}
+        super
+      end
 
-            MSG
+      private
 
-            debugger
-          end.tap do |block|
-            # redefine source_location to return the correct location
-            block.define_singleton_method(:source_location) { location.split(":") }
-          end
+      # A blockless dit, not otherwise skipped or pending. Its "Not yet
+      # implemented" skip overrides one inherited from the group, so ask the group.
+      def breakpoint?
+        metadata[:dit] &&
+          metadata[:skip] == RSpec::Core::Pending::NOT_YET_IMPLEMENTED &&
+          !metadata[:pending] &&
+          !example_group.metadata[:skip]
+      end
+
+      # A blockless dit opens the debugger instead of being "Not yet implemented".
+      def debug_blockless
+        metadata.delete(:skip)
+        location = self.location
+
+        @example_block = Proc.new do
+          $stderr.puts <<~MSG
+          debugging: #{location}
+
+          MSG
+
+          DebugIt.session { debugger }
         end
+      end
 
-        super
+      # Extended onto the example group instance a debugged example runs in.
+      module Postmortem
+        # rspec-core runs the example body and its before/after hooks (so let!
+        # too) as instance_exec(example, &block). Around hooks get a Procsy, and
+        # user code passes other args, so a failure is only debugged once. In a
+        # thread there is no current example: leave that alone too.
+        def instance_exec(*args, &block)
+          example = RSpec.current_example
+          return super unless example && args.first.equal?(example)
+
+          error, frames = DebugIt.capture_frames { return super }
+          # the example may have closed or swapped stdin since run checked
+          raise error unless DebugIt.failure?(error) && DebugIt.interactive?
+
+          $stderr.puts <<~MSG
+
+          Error:
+          #{error.message}
+
+          MSG
+
+          # names only: values can be huge
+          lets = let_variables.select { |name| let_variable_initialized?(name) }
+          $stderr.puts "initialized lets: #{lets.join(", ")}\n\n" if lets.any?
+
+          # debug reads the frames from this ivar. Set it on a copy so the
+          # user's error stays as raised (it may be frozen, or get marshaled).
+          # (A copy that can't be made just skips the session.)
+          copy = begin
+            error.dup
+          rescue Exception
+            nil
+          end
+          if copy
+            copy.instance_variable_set(:@__debugger_postmortem_frames, frames)
+            DebugIt.session { DEBUGGER__::SESSION.enter_postmortem_session(copy) }
+          end
+          raise error
+        end
       end
     end
   end
 end
 
 RSpec::Core::Example.prepend RSpec::Debugging::DebugIt
-RSpec::Core::ExampleGroup.define_example_method(:dit, debug: true, focus: true)
+# a gem install is already hidden by RSpec's /gems/ pattern; this covers a path or git checkout
+RSpec.configuration.backtrace_exclusion_patterns << RSpec::Debugging::DebugIt::GEM_LIB
+# :dit marks the example itself; :debug is also inherited from ddescribe/dcontext
+RSpec::Core::ExampleGroup.define_example_method(:dit, debug: true, focus: true, dit: true)
 RSpec::Core::ExampleGroup.define_example_group_method(:ddescribe, debug: true, focus: true)
 RSpec::Core::ExampleGroup.define_example_group_method(:dcontext, debug: true, focus: true)

data/lib/rspec/debugging/let_variables.rb

@@ -2,62 +2,84 @@ module RSpec
   module Debugging
     module LetVariables
       def let_variables
-        let_variable_methods(self).keys
+        Internal.definitions(self).keys
       end
 
       def let_variable_initialized?(name)
-        __memoized.instance_variable_get("@memoized").key?(name)
+        Internal.memoized(self).key?(Internal.resolve(self, name))
       end
 
       def let_variable_get(name)
-        __memoized.instance_variable_get("@memoized")[name]
+        Internal.memoized(self)[Internal.resolve(self, name)]
       end
 
       def let_variable_reset(name)
-        __memoized.instance_variable_get("@memoized").delete(name)
+        Internal.memoized(self).delete(Internal.resolve(self, name))
       end
 
       def let_variable_locations(name)
-        let_variable_methods(self)[name].map do |fn|
-          normalize_path(fn.source_location.join(":"))
+        Internal.definitions(self)[Internal.resolve(self, name)].map do |fn|
+          Internal.location(fn)
         end
       end
 
       def let_variable_values(name)
-        let_variable_methods(self)[name].map do |fn|
-          {
-            normalize_path(fn.source_location.join(":")) => fn.bind(self).call
-          }
+        memo = Internal.memoized(self)
+
+        name = Internal.resolve(self, name)
+
+        Internal.definitions(self)[name].map do |fn|
+          snapshot = memo.dup
+          memo.delete(name) # else super() reads the memoized value via the outer wrapper
+          value = begin
+            # mirrors rspec-core's `let`, which passes the example to a 1-arity block
+            fn.arity == 1 ? fn.bind_call(self, RSpec.current_example) : fn.bind_call(self)
+          rescue => e
+            e
+          ensure
+            memo.replace(snapshot) # forget lets the definition pulled in
+          end
+
+          { Internal.location(fn) => value }
         end
       end
 
-      private
+      # Helpers live here rather than in the mixin, which is included into
+      # every example group and would collide with users' own methods.
+      module Internal
+        module_function
 
-      extend self
+        # let name => definitions, innermost scope first
+        def definitions(example)
+          mods = example.class.ancestors.select { |x| x.name&.end_with?("::LetDefinitions") }
 
-      def let_variable_methods(example)
-        # find RSpec modules containing `let` blocks
-        mods = self.class.ancestors.select {|x| x.to_s.include?('::LetDefinitions') }
+          mods.each_with_object({}) do |mod, defs|
+            mod.instance_methods.each do |name|
+              (defs[name] ||= []) << mod.instance_method(name)
+            end
+          end
+        end
 
-        locations = {}
+        def resolve(example, name)
+          name = name.to_sym
+          # a named subject is an alias of its let
+          name = example.class.instance_method(:subject).original_name if name == :subject
+          return name if definitions(example).key?(name)
 
-        mods.each do |mod|
-          mod.instance_methods.each do |method_name|
-            locations[method_name] ||= []
-            locations[method_name] << mod.instance_method(method_name)
-          end
+          raise ArgumentError, "no let variable named #{name.inspect}"
         end
 
-        locations
-      end
+        def memoized(example)
+          # before(:context) swaps in a memo object with no hash
+          example.instance_variable_get(:@__memoized).instance_variable_get(:@memoized) || {}
+        end
 
-      def normalize_path(path)
-        path.delete_prefix(
-          Dir.pwd + "/"
-        ).gsub(
-          %r{.*/gems/},
-          ".../gems/"
-        ).sub(Dir.home, "~")
+        def location(fn)
+          fn.source_location.join(":")
+            .delete_prefix(Dir.pwd + "/")
+            .gsub(%r{.*/gems/}, ".../gems/")
+            .sub(Dir.home, "~")
+        end
       end
     end
   end

data/lib/rspec/debugging/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module Debugging
-    VERSION = "0.0.4"
+    VERSION = "0.0.6"
   end
 end

data/lib/rspec/debugging.rb

@@ -1,4 +1,4 @@
-require "rspec/expectations"
+require "rspec/core"
 
 require "rspec/debugging/debug_it"
 require "rspec/debugging/let_variables"

data/rspec-debugging.gemspec

@@ -1,3 +1,5 @@
+require_relative "lib/rspec/debugging/version"
+
 Gem::Specification.new do |s|
   s.authors     = ["Daniel Pepper"]
   s.description = "Tools to improve debugging in RSpec"
@@ -6,13 +8,19 @@ Gem::Specification.new do |s|
   s.license     = "MIT"
   s.name        = File.basename(__FILE__, ".gemspec")
   s.summary     = s.description
-  s.version     = "0.0.4"
+  s.version     = RSpec::Debugging::VERSION
+
+  s.metadata = {
+    "changelog_uri" => "#{s.homepage}/blob/main/CHANGELOG.md",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => s.homepage,
+  }
 
-  s.required_ruby_version = ">= 3.1"
+  s.required_ruby_version = ">= 3.2"
 
-  s.add_dependency "rspec-expectations", ">= 3"
+  s.add_dependency "debug", ">= 1.10"
+  s.add_dependency "rspec-core", ">= 3.10"
 
-  s.add_development_dependency "debug"
   s.add_development_dependency "rspec"
   s.add_development_dependency "simplecov"
 end

metadata

@@ -1,42 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: rspec-debugging
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Daniel Pepper
 bindir: bin
 cert_chain: []
-date: 2025-02-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec-expectations
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '1.10'
 - !ruby/object:Gem::Dependency
-  name: debug
+  name: rspec-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '3.10'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -84,7 +84,10 @@ files:
 homepage: https://github.com/dpep/rspec-debugging
 licenses:
 - MIT
-metadata: {}
+metadata:
+  changelog_uri: https://github.com/dpep/rspec-debugging/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/dpep/rspec-debugging
 rdoc_options: []
 require_paths:
 - lib
@@ -92,14 +95,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Tools to improve debugging in RSpec
 test_files: []