rspec-enriched_json 0.6.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d601f3b9829a2dd3bc4af4a42e65b01819ec6152156552f25b9e188ad47d828d
-  data.tar.gz: 1a08c66c4308c8f7e33ab3769c7bc1bc0601ace0588c242690d7edb2d02175d0
+  metadata.gz: 840927ecfa09fc825a0f9656e11b7e10c4f4f5b368c144e5536dfa0595714192
+  data.tar.gz: 5616ee6697817e0321938e53ae71410c110d9dc13bbd697dd0f2e974325efa7e
 SHA512:
-  metadata.gz: 86d612e624b12e6da7e6a32d877479a548ee301d79e5c231a6741843c83f07f635c11415e9945d84c68b076dda67b96712a5786a7d3cd4967923d4526be2f6d8
-  data.tar.gz: 5478f0f570d46b58139d82f16f1e305290370ca41ee99045ff382dfa4e77644afab8dd6fd408e98c495d2c23f14fc7c227120e87d1ab08da533dcb77df4e225f
+  metadata.gz: ea0dcb189eafca59326cab5550444fe262f4475575b0860381c203dc3c16886fb7c4244df7123bdd854c398ad0b47b4fdaf0d523425fcba843845ea1f72f3eb0
+  data.tar.gz: d8c279936a9641ea12377e4952c747bc9da60abaa15542bd973143180c1249bbcb8504e161411cb78a5cb07cd406c96612ce2ed24a00bfd695c268e24c5ea799

data/README.md

@@ -1,5 +1,9 @@
 # RSpec::EnrichedJson
 
+[![CI](https://github.com/firstdraft/rspec-enriched_json/actions/workflows/ci.yml/badge.svg)](https://github.com/firstdraft/rspec-enriched_json/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/rspec-enriched_json.svg)](https://badge.fury.io/rb/rspec-enriched_json)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/standardrb/standard)
+
 A drop-in replacement for RSpec's built-in JSON formatter that enriches the output with structured failure data. This makes it easy to programmatically analyze test results, extract expected/actual values, and build better CI/CD integrations.
 
 ## Quick Demo
@@ -30,7 +34,7 @@ This interactive demo script runs the same failing tests with both formatters an
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'rspec-enriched_json'
+gem "rspec-enriched_json"
 ```
 
 And then execute:
@@ -95,14 +99,14 @@ With this gem, you get structured data alongside the original message:
 
 ## Features
 
-- **Drop-in replacement**: Inherits from RSpec's JsonFormatter, maintaining 100% compatibility
-- **Structured data extraction**: Expected and actual values as proper JSON objects
-- **Rich object support**: Arrays, hashes, and custom objects are properly serialized
-- **Original message preservation**: When you override with a custom message, the original is preserved
-- **Graceful degradation**: Regular exceptions (non-expectation failures) work normally
-- **Enhanced metadata capture**: Test location, tags, hierarchy, and custom metadata
-- **Robust error recovery**: Handles objects that fail to serialize without crashing
-- **Diff information**: Includes `diffable` to help tools determine if values can be meaningfully diffed
+- **Drop-in replacement**: Inherits from RSpec's JsonFormatter, maintaining 100% compatibility.
+- **Structured data extraction**: Expected and actual values as proper JSON objects.
+- **Rich object support**: Arrays, hashes, and custom objects are properly serialized.
+- **Original message preservation**: When you override with a custom message, the original is preserved.
+- **Graceful degradation**: Regular exceptions (non-expectation failures) work normally.
+- **Enhanced metadata capture**: Test location, tags, hierarchy, and custom metadata.
+- **Robust error recovery**: Handles objects that fail to serialize without crashing.
+- **Diff information**: Includes `diffable` to help tools determine if values can be meaningfully diffed.
 
 ## Examples
 
@@ -147,36 +151,50 @@ end
 
 ## Use Cases
 
-- **CI/CD Integration**: Parse test results to create rich error reports
-- **Test Analytics**: Track which values commonly cause test failures  
-- **Debugging Tools**: Build tools that can display expected vs actual diffs
-- **Learning Platforms**: Provide detailed feedback on why tests failed
+- **CI/CD Integration**: Parse test results to create rich error reports.
+- **Test Analytics**: Track which values commonly cause test failures.
+- **Debugging Tools**: Build tools that can display expected vs actual diffs.
+- **Learning Platforms**: Provide detailed feedback on why tests failed.
 
 ## How It Works
 
 The gem works by:
 
-1. Patching RSpec's expectation system to capture structured data when expectations fail
-2. Extending the JsonFormatter to include this data in the JSON output
-3. Maintaining full backward compatibility with existing tools
+1. Patching RSpec's expectation system to capture structured data when expectations fail.
+2. Extending the JsonFormatter to include this data in the JSON output.
+3. Maintaining full backward compatibility with existing tools.
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
 
-## Performance Considerations
+This project uses [StandardRB](https://github.com/standardrb/standard) for code formatting and style. Before committing:
+
+```bash
+# Check for style violations
+bundle exec standardrb
+
+# Auto-fix style violations
+bundle exec standardrb --fix
+```
+
+## Additional Features
+
+### Passing Test Value Capture
+The formatter also captures expected/actual values for passing tests, useful for:
+- Test analytics and insights.
+- Understanding test coverage patterns.
+- Debugging flaky tests.
 
-The enriched formatter adds minimal overhead:
-- Only processes failing tests (passing tests have no extra processing)
-- Limits serialization depth to prevent infinite recursion
-- Truncates large strings and collections to maintain reasonable output sizes
-- No impact on test execution time, only on failure reporting
+### Negation Detection
+Tests using `not_to` or `to_not` include a `negated: true` flag in the details.
 
-Default limits:
-- Max serialization depth: 5 levels
-- Max array size: 100 items
-- Max hash size: 100 keys
-- Max string length: 1000 characters
+### Serialization
+Values are serialized using [Oj](https://github.com/ohler55/oj) in object mode, providing:
+- Circular reference handling.
+- Proper Ruby object serialization.
+- Excellent performance.
+- Special handling for Regexp objects (serialized as inspect strings).
 
 ## Contributing
 

data/lib/rspec/enriched_json/expectation_helper_wrapper.rb

@@ -1,275 +1,201 @@
 # frozen_string_literal: true
 
 require "json"
+require "oj"
 require "rspec/expectations"
 require "rspec/support/differ"
 
 module RSpec
   module EnrichedJson
-    # Universal wrapper to catch ALL matchers and attach structured data
+    @all_test_values = {}
+
+    def self.all_test_values
+      @all_test_values
+    end
+
+    def self.clear_test_values
+      @all_test_values = {}
+    end
+
     module ExpectationHelperWrapper
-      MAX_SERIALIZATION_DEPTH = 5
-      MAX_ARRAY_SIZE = 100
-      MAX_HASH_SIZE = 100
-      MAX_STRING_LENGTH = 1000
       def self.install!
         RSpec::Expectations::ExpectationHelper.singleton_class.prepend(self)
+        RSpec::Expectations::PositiveExpectationHandler.singleton_class.prepend(PositiveHandlerWrapper)
+        RSpec::Expectations::NegativeExpectationHandler.singleton_class.prepend(NegativeHandlerWrapper)
       end
 
-      # Make serialize_value accessible for other components
       module Serializer
         extend self
 
-        MAX_SERIALIZATION_DEPTH = 5
-        MAX_ARRAY_SIZE = 100
-        MAX_HASH_SIZE = 100
-        MAX_STRING_LENGTH = 1000
-
-        def serialize_value(value, depth = 0)
-          return "[Max depth exceeded]" if depth > MAX_SERIALIZATION_DEPTH
-
-          case value
-          when Numeric, TrueClass, FalseClass
-            value
-          when String
-            unescape_string_double_quotes(
-              truncate_string(value)
-            )
-          when Symbol
-            serialize_object(value)
-          when nil
-            serialize_object(value)
-          when Array
-            return "[Large array: #{value.size} items]" if value.size > MAX_ARRAY_SIZE
-            value.map { |v| serialize_value(v, depth + 1) }
-          when Hash
-            return "[Large hash: #{value.size} keys]" if value.size > MAX_HASH_SIZE
-            value.transform_values { |v| serialize_value(v, depth + 1) }
-          else
-            serialize_object(value, depth)
-          end
-        rescue => e
-          {
-            "class" => value.class.name,
-            "serialization_error" => e.message
-          }
-        end
-
-        def serialize_object(obj, depth = 0)
-          result = {
-            "class" => obj.class.name,
-            "inspect" => safe_inspect(obj),
-            "to_s" => safe_to_s(obj)
-          }
-
-          # Handle Structs specially
-          if obj.is_a?(Struct)
-            result["struct_values"] = obj.to_h.transform_values { |v| serialize_value(v, depth + 1) }
-          end
-
-          # Include instance variables only for small objects
-          ivars = obj.instance_variables
-          if ivars.any? && ivars.length <= 10
-            result["instance_variables"] = ivars.each_with_object({}) do |ivar, hash|
-              hash[ivar.to_s] = serialize_value(obj.instance_variable_get(ivar), depth + 1)
-            end
-          end
-
-          result
-        end
-
-        def truncate_string(str)
-          return str if str.length <= MAX_STRING_LENGTH
-          "#{str[0...MAX_STRING_LENGTH]}... (truncated)"
-        end
+        OJ_OPTIONS = {
+          mode: :object,
+          circular: true,
+          class_cache: false,
+          create_additions: false,
+          symbol_keys: false,
+          auto_define: false,
+          create_id: nil,
+          use_to_json: false,
+          use_as_json: false,
+          use_raw_json: false,
+          bigdecimal_as_decimal: true,
+          nan: :word
+        }
 
-        def unescape_string_double_quotes(str)
-          if str.start_with?('"') && str.end_with?('"')
-            begin
-              # Only undump if it's a valid dumped string
-              # Check if the string is properly escaped by attempting undump
-              str.undump
-            rescue RuntimeError => e
-              # If undump fails, just return the original string
-              # This handles cases where the string has quotes but isn't a valid dump format
-              str
-            end
-          else
-            str
+        def serialize_value(value)
+          if value.is_a?(Regexp)
+            return Oj.dump(value.inspect, mode: :compat)
           end
-        end
 
-        def safe_inspect(obj)
-          truncate_string(obj.inspect)
+          Oj.dump(value, OJ_OPTIONS)
         rescue => e
-          "[inspect failed: #{e.class}]"
-        end
-
-        def safe_to_s(obj)
-          truncate_string(obj.to_s)
-        rescue => e
-          "[to_s failed: #{e.class}]"
+          Oj.dump({
+            "_serialization_error" => e.message,
+            "_class" => value.class.name,
+            "_to_s" => begin
+              value.to_s
+            rescue
+              "[to_s failed]"
+            end
+          }, mode: :compat)
         end
       end
 
       def handle_failure(matcher, message, failure_message_method)
-        # If a custom message is provided, capture the original message first
         original_message = nil
         if message
           original_message = matcher.send(failure_message_method)
         end
 
-        # Call original handler with the original message
         super
       rescue RSpec::Expectations::ExpectationNotMetError => e
-        # Extract raw values for diff analysis
-        expected_raw = extract_value(matcher, :expected)
-        actual_raw = extract_value(matcher, :actual)
+        expected_raw = extract_value(matcher, :expected, failure_message_method)
+        actual_raw = extract_value(matcher, :actual, failure_message_method)
+        negated = failure_message_method == :failure_message_when_negated
 
-        # Collect structured data
         details = {
           expected: Serializer.serialize_value(expected_raw),
           actual: Serializer.serialize_value(actual_raw),
-          original_message: original_message, # Only populated when custom message overrides it
+          original_message: original_message,
           matcher_name: matcher.class.name,
-          diffable: values_diffable?(expected_raw, actual_raw, matcher)
+          diffable: matcher.respond_to?(:diffable?) && matcher.diffable?,
+          negated: negated
         }
 
-        # Generate diff if values are diffable
         if details[:diffable] && expected_raw && actual_raw
           diff = generate_diff(actual_raw, expected_raw)
           details[:diff] = diff unless diff.nil? || diff.strip.empty?
         end
 
-        # Capture matcher-specific instance variables
-        matcher_data = extract_matcher_specific_data(matcher)
-        details.merge!(matcher_data) unless matcher_data.empty?
-
-        # Raise new exception with data attached
         raise EnrichedExpectationNotMetError.new(e.message, details)
       end
 
       private
 
-      def extract_value(matcher, method_name)
-        return nil unless matcher.respond_to?(method_name)
-
-        value = matcher.send(method_name)
-        # Don't return nil if the value itself is nil
-        # Only return nil if the value is the matcher itself (self-referential)
-        (value == matcher && !value.nil?) ? nil : value
+      def extract_value(matcher, method_name, failure_message_method = nil)
+        if matcher.is_a?(RSpec::Matchers::BuiltIn::BePredicate) || matcher.is_a?(RSpec::Matchers::BuiltIn::Has)
+          case method_name
+          when :expected
+            !(failure_message_method == :failure_message_when_negated)
+          when :actual
+            if matcher.instance_variable_defined?(:@predicate_result)
+              matcher.instance_variable_get(:@predicate_result)
+            end
+          end
+        else
+          return nil unless matcher.respond_to?(method_name)
+          value = matcher.send(method_name)
+          (value == matcher && !value.nil?) ? nil : value
+        end
       rescue
         nil
       end
 
-      def extract_matcher_specific_data(matcher)
-        # Skip common instance variables that are already captured
-        skip_vars = [
-          :@expected, :@actual, :@args, :@name,
-          # Skip internal implementation details
-          :@matcher, :@matchers, :@target,
-          :@delegator, :@base_matcher,
-          :@block, :@event_proc,
-          # Skip verbose internal state
-          :@pairings_maximizer, :@best_solution,
-          :@expected_captures, :@match_captures,
-          :@failures, :@errors,
-          # Skip RSpec internals
-          :@matcher_execution_context,
-          :@chained_method_with_args_combos
-        ]
+      def generate_diff(actual, expected)
+        differ = RSpec::Support::Differ.new(
+          object_preparer: lambda { |obj|
+            RSpec::Matchers::Composable.surface_descriptions_in(obj)
+          },
+          color: RSpec.configuration.color_enabled?
+        )
+        differ.diff(actual, expected)
+      rescue
+        nil
+      end
+    end
 
-        # Define meaningful variables we want to keep
-        useful_vars = [
-          :@missing_items, :@extra_items,  # ContainExactly
-          :@expecteds, :@actuals,           # Include
-          :@operator, :@delta, :@tolerance, # Comparison matchers
-          :@expected_before, :@expected_after, :@actual_before, :@actual_after, # Change matcher
-          :@from, :@to, :@minimum, :@maximum, :@count, # Various matchers
-          :@failure_message, :@failure_message_when_negated,
-          :@description
-        ]
+    module HandlerWrapperShared
+      def capture_test_values(actual, initial_matcher, negated: false)
+        return unless initial_matcher && RSpec.current_example
 
-        # Get all instance variables
-        ivars = matcher.instance_variables - skip_vars
-        return {} if ivars.empty?
+        begin
+          if initial_matcher.is_a?(RSpec::Matchers::BuiltIn::BePredicate) || initial_matcher.is_a?(RSpec::Matchers::BuiltIn::Has)
+            expected_value = !negated
 
-        # Build a hash of matcher-specific data
-        matcher_data = {}
+            if negated && initial_matcher.respond_to?(:does_not_match?)
+              initial_matcher.does_not_match?(actual)
+            else
+              initial_matcher.matches?(actual)
+            end
 
-        ivars.each do |ivar|
-          # Only include if it's in our useful list or looks like user data
-          unless useful_vars.include?(ivar) || ivar.to_s.match?(/^@(missing|extra|failed|unmatched|matched)_/)
-            next
+            actual_value = if initial_matcher.instance_variable_defined?(:@predicate_result)
+              initial_matcher.instance_variable_get(:@predicate_result)
+            end
+          else
+            expected_value = initial_matcher.respond_to?(:expected) ? initial_matcher.expected : nil
+            actual_value = actual
           end
 
-          value = matcher.instance_variable_get(ivar)
-
-          # Skip if value is nil or the matcher itself
-          next if value.nil? || value == matcher
+          key = RSpec.current_example.id
+          RSpec::EnrichedJson.all_test_values[key] = {
+            expected: ExpectationHelperWrapper::Serializer.serialize_value(expected_value),
+            actual: ExpectationHelperWrapper::Serializer.serialize_value(actual_value),
+            matcher_name: initial_matcher.class.name,
+            passed: nil
+          }
 
-          # Skip procs and complex objects unless they're simple collections
-          if value.is_a?(Proc) || (value.is_a?(Object) && !value.is_a?(Enumerable) && !value.is_a?(Numeric) && !value.is_a?(String) && !value.is_a?(Symbol))
-            next
+          RSpec::EnrichedJson.all_test_values[key][:negated] = true if negated
+        rescue => e
+          if defined?(RSpec.configuration) && RSpec.configuration.reporter
+            RSpec.configuration.reporter.message("Warning: Error capturing test values: #{e.message}")
+          elsif ENV["DEBUG"]
+            puts "Error capturing test values: #{e.message}"
           end
-
-          # Convert instance variable name to a more readable format
-          # @missing_items -> missing_items
-          key = ivar.to_s.delete_prefix("@").to_sym
-
-          # Serialize the value
-          matcher_data[key] = Serializer.serialize_value(value)
-        rescue
-          # Skip this instance variable if we can't serialize it
-          next
         end
-
-        matcher_data
       end
 
-      def values_diffable?(expected, actual, matcher)
-        # First check if the matcher itself declares diffability
-        if matcher.respond_to?(:diffable?)
-          return matcher.diffable?
-        end
+      def mark_as_passed(initial_matcher)
+        return unless initial_matcher && RSpec.current_example
 
-        # If either value is nil, not diffable
-        return false if expected.nil? || actual.nil?
+        key = RSpec.current_example.id
+        if RSpec::EnrichedJson.all_test_values[key]
+          RSpec::EnrichedJson.all_test_values[key][:passed] = true
+        end
+      end
+    end
 
-        # For different classes, generally not diffable
-        return false unless actual.instance_of?(expected.class)
+    module PositiveHandlerWrapper
+      include HandlerWrapperShared
 
-        # Check if both values are of the same basic diffable type
-        case expected
-        when String, Array, Hash
-          # These types are inherently diffable when compared to same type
-          true
-        else
-          # For other types, they're diffable if they respond to to_s
-          # and their string representations would be meaningful
-          expected.respond_to?(:to_s) && actual.respond_to?(:to_s)
-        end
-      rescue
-        # If any error occurs during checking, assume not diffable
-        false
+      def handle_matcher(actual, initial_matcher, custom_message = nil, &block)
+        capture_test_values(actual, initial_matcher, negated: false)
+        result = super
+        mark_as_passed(initial_matcher)
+        result
       end
+    end
 
-      def generate_diff(actual, expected)
-        # Use RSpec's own differ for consistency
-        differ = RSpec::Support::Differ.new(
-          object_preparer: lambda { |obj|
-            RSpec::Matchers::Composable.surface_descriptions_in(obj)
-          },
-          color: false # Always disable color for JSON output
-        )
-        differ.diff(actual, expected)
-      rescue
-        # If diff generation fails, return nil rather than crashing
-        nil
+    module NegativeHandlerWrapper
+      include HandlerWrapperShared
+
+      def handle_matcher(actual, initial_matcher, custom_message = nil, &block)
+        capture_test_values(actual, initial_matcher, negated: true)
+        result = super
+        mark_as_passed(initial_matcher)
+        result
       end
     end
   end
 end
 
-# Auto-install when this file is required
 RSpec::EnrichedJson::ExpectationHelperWrapper.install!

data/lib/rspec/enriched_json/formatters/enriched_json_formatter.rb

@@ -12,9 +12,7 @@ module RSpec
         def stop(group_notification)
           @output_hash[:examples] = group_notification.notifications.map do |notification|
             format_example(notification.example).tap do |hash|
-              # Add enhanced metadata
               add_metadata(hash, notification.example)
-
               e = notification.example.exception
 
               if e
@@ -24,16 +22,14 @@ module RSpec
                   backtrace: notification.formatted_backtrace
                 }
 
-                # Add structured data if available
                 if e.is_a?(RSpec::EnrichedJson::EnrichedExpectationNotMetError) && e.details
-                  hash[:details] = safe_structured_data(e.details)
+                  hash[:details] = e.details
                 end
-
-                if hash.key?(:details) && hash[:details].key?(:expected) && hash[:details].key?(:actual)
-                  exception_message = hash[:exception][:message]
-                  if exception_message.include?("\nDiff:")
-                    hash[:exception][:message] = exception_message.sub(/Diff:.*/m, "").strip
-                  end
+              else
+                key = notification.example.id
+                if RSpec::EnrichedJson.all_test_values.key?(key)
+                  captured_values = RSpec::EnrichedJson.all_test_values[key]
+                  hash[:details] = captured_values
                 end
               end
             end
@@ -45,38 +41,25 @@ module RSpec
         def add_metadata(hash, example)
           metadata = example.metadata.dup
 
-          # Extract custom tags (all symbols and specific keys)
           custom_tags = {}
           metadata.each do |key, value|
-            # Include all symbol keys (like :focus, :slow, etc.)
             if key.is_a?(Symbol) && value == true
               custom_tags[key] = true
-            # Include specific metadata that might be useful
             elsif [:type, :priority, :severity, :db, :js].include?(key)
               custom_tags[key] = value
             end
           end
 
-          # Add enhanced metadata
           hash[:metadata] = {
-            # Location information
             location: example.location,
             absolute_file_path: File.expand_path(example.metadata[:file_path]),
             rerun_file_path: example.location_rerun_argument,
-
-            # Example hierarchy
             example_group: example.example_group.description,
             example_group_hierarchy: extract_group_hierarchy(example),
-
-            # Described class if available
             described_class: metadata[:described_class]&.to_s,
-
-            # Custom tags and metadata
             tags: custom_tags.empty? ? nil : custom_tags,
-
-            # Shared example information if applicable
             shared_group_inclusion_backtrace: metadata[:shared_group_inclusion_backtrace]
-          }.compact # Remove nil values
+          }.compact
         end
 
         def extract_group_hierarchy(example)
@@ -91,54 +74,9 @@ module RSpec
           hierarchy
         end
 
-        def safe_structured_data(details)
-          # Start with core fields
-          result = {
-            expected: safe_serialize(details[:expected]),
-            actual: safe_serialize(details[:actual]),
-            matcher_name: details[:matcher_name],
-            original_message: details[:original_message],
-            diffable: details[:diffable]
-          }
-
-          # Add any additional matcher-specific fields
-          details.each do |key, value|
-            next if [:expected, :actual, :matcher_name, :original_message, :diffable].include?(key)
-            result[key] = safe_serialize(value)
-          end
-
-          result.compact
-        end
-
-        def safe_serialize(value)
-          # Delegate to the existing serialization logic in ExpectationHelperWrapper
-          RSpec::EnrichedJson::ExpectationHelperWrapper::Serializer.serialize_value(value)
-        rescue => e
-          # Better error recovery - provide context about what failed
-          begin
-            obj_class = value.class.name
-          rescue
-            obj_class = "Unknown"
-          end
-
-          {
-            "serialization_error" => true,
-            "error_class" => e.class.name,
-            "error_message" => e.message,
-            "object_class" => obj_class,
-            "fallback_value" => safe_fallback_value(value)
-          }
-        end
-
-        def safe_fallback_value(value)
-          # Try multiple fallback strategies
-          value.to_s
-        rescue
-          begin
-            value.class.name
-          rescue
-            "Unable to serialize"
-          end
+        def close(_notification)
+          super
+          RSpec::EnrichedJson.clear_test_values
         end
       end
     end

data/lib/rspec/enriched_json/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module EnrichedJson
-    VERSION = "0.6.2"
+    VERSION = "0.8.0"
   end
 end

data/rspec-enriched_json.gemspec

@@ -20,9 +20,10 @@ Gem::Specification.new do |spec|
     "source_code_uri" => "https://github.com/firstdraft/rspec-enriched_json"
   }
 
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.required_ruby_version = ">= 3.2"
   spec.add_dependency "rspec-core", ">= 3.0"
   spec.add_dependency "rspec-expectations", ">= 3.0"
+  spec.add_dependency "oj", "~> 3.16"
 
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rake", "~> 13.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-enriched_json
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Raghu Betina
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.16'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -113,7 +127,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="