rspec-openapi 0.25.0 → 0.26.0

data/lib/rspec/openapi/extractors/hanami.rb

@@ -38,13 +38,11 @@ end
 InspectorAnalyzer = Inspector.new
 
 # Add default parameter to load inspector before test cases run
-module InspectorAnalyzerPrepender
+Hanami::Slice::ClassMethods.prepend(Module.new do
   def router(inspector: InspectorAnalyzer)
     super
   end
-end
-
-Hanami::Slice::ClassMethods.prepend(InspectorAnalyzerPrepender)
+end)
 
 # Extractor for hanami
 class << RSpec::OpenAPI::Extractors::Hanami = Object.new
@@ -56,18 +54,21 @@ class << RSpec::OpenAPI::Extractors::Hanami = Object.new
 
     return RSpec::OpenAPI::Extractors::Rack.request_attributes(request, example) unless route.routable?
 
-    summary, tags, formats, operation_id, required_request_params, security, description, deprecated, example_mode,
-      example_key, example_name, response_enum, request_enum = SharedExtractor.attributes(example)
+    summary, tags, formats, operation_id, required_request_params, security, description, deprecated,
+      request_example_mode, response_example_mode,
+      example_key, example_name, response_enum, request_enum, response_additional_properties,
+      request_additional_properties, response_hybrid_additional_properties,
+      request_hybrid_additional_properties = SharedExtractor.attributes(example)
 
     path = request.path
 
     raw_path_params = route.params
 
-    result = InspectorAnalyzer.call(request.method, add_id(path, route))
+    result = InspectorAnalyzer.call(request.method, replace_path_params(path, route, '/:%{key}'))
 
     summary ||= result[:summary]
     tags ||= result[:tags]
-    path = add_openapi_id(path, route)
+    path = replace_path_params(path, route, '/{%{key}}')
 
     raw_path_params = raw_path_params.slice(*(raw_path_params.keys - RSpec::OpenAPI.ignored_path_params))
 
@@ -82,11 +83,16 @@ class << RSpec::OpenAPI::Extractors::Hanami = Object.new
       security,
       deprecated,
       formats,
-      example_mode,
+      request_example_mode,
+      response_example_mode,
       example_key,
       example_name,
       response_enum,
       request_enum,
+      response_additional_properties,
+      request_additional_properties,
+      response_hybrid_additional_properties,
+      request_hybrid_additional_properties,
     ]
   end
 
@@ -101,21 +107,11 @@ class << RSpec::OpenAPI::Extractors::Hanami = Object.new
 
   private
 
-  def add_id(path, route)
-    return path if route.params.empty?
-
-    route.params.each_pair do |key, value|
-      path = path.sub("/#{value}", "/:#{key}")
-    end
-
-    path
-  end
-
-  def add_openapi_id(path, route)
+  def replace_path_params(path, route, format)
     return path if route.params.empty?
 
     route.params.each_pair do |key, value|
-      path = path.sub("/#{value}", "/{#{key}}")
+      path = path.sub("/#{value}", format % { key: key })
     end
 
     path

data/lib/rspec/openapi/extractors/rack.rb

@@ -6,8 +6,11 @@ class << RSpec::OpenAPI::Extractors::Rack = Object.new
   # @param [RSpec::Core::Example] example
   # @return Array
   def request_attributes(request, example)
-    summary, tags, formats, operation_id, required_request_params, security, description, deprecated, example_mode,
-      example_key, example_name, response_enum, request_enum = SharedExtractor.attributes(example)
+    summary, tags, formats, operation_id, required_request_params, security, description, deprecated,
+      request_example_mode, response_example_mode,
+      example_key, example_name, response_enum, request_enum, response_additional_properties,
+      request_additional_properties, response_hybrid_additional_properties,
+      request_hybrid_additional_properties = SharedExtractor.attributes(example)
 
     raw_path_params = request.path_parameters
     path = request.path
@@ -24,11 +27,16 @@ class << RSpec::OpenAPI::Extractors::Rack = Object.new
       security,
       deprecated,
       formats,
-      example_mode,
+      request_example_mode,
+      response_example_mode,
       example_key,
       example_name,
       response_enum,
       request_enum,
+      response_additional_properties,
+      request_additional_properties,
+      response_hybrid_additional_properties,
+      request_hybrid_additional_properties,
     ]
   end
 

data/lib/rspec/openapi/extractors/rails.rb

@@ -16,8 +16,11 @@ class << RSpec::OpenAPI::Extractors::Rails = Object.new
 
     raise "No route matched for #{fixed_request.request_method} #{fixed_request.path_info}" if route.nil?
 
-    summary, tags, formats, operation_id, required_request_params, security, description, deprecated, example_mode,
-      example_key, example_name, response_enum, request_enum = SharedExtractor.attributes(example)
+    summary, tags, formats, operation_id, required_request_params, security, description, deprecated,
+      request_example_mode, response_example_mode,
+      example_key, example_name, response_enum, request_enum, response_additional_properties,
+      request_additional_properties, response_hybrid_additional_properties,
+      request_hybrid_additional_properties = SharedExtractor.attributes(example)
 
     raw_path_params = request.path_parameters
 
@@ -40,16 +43,26 @@ class << RSpec::OpenAPI::Extractors::Rails = Object.new
       security,
       deprecated,
       formats,
-      example_mode,
+      request_example_mode,
+      response_example_mode,
       example_key,
       example_name,
       response_enum,
       request_enum,
+      response_additional_properties,
+      request_additional_properties,
+      response_hybrid_additional_properties,
+      request_hybrid_additional_properties,
     ]
   end
 
   # @param [RSpec::ExampleGroups::*] context
   def request_response(context)
+    # Read @integration_session directly so user-defined let(:request)/let(:response)
+    # don't shadow the real ActionDispatch objects we need for OpenAPI extraction.
+    session = context.instance_variable_get(:@integration_session)
+    return [session.request, session.response] if session
+
     [context.request, context.response]
   end
 

data/lib/rspec/openapi/extractors/shared_extractor.rb

@@ -4,6 +4,14 @@
 class SharedExtractor
   VALID_EXAMPLE_MODES = %i[none single multiple].freeze
 
+  EXAMPLE_MODE_MULTIPLE_SHORTHAND_WARNING = <<~MSG.tr("\n", ' ').strip.freeze
+    [rspec-openapi] DEPRECATION: example_mode: :multiple currently means
+    { request: :single, response: :multiple }. A future major version will
+    change it to { request: :multiple, response: :multiple } (both sides
+    multi). Specify the hash form explicitly to lock in current behavior or
+    opt in early.
+  MSG
+
   def self.attributes(example)
     metadata = merge_openapi_metadata(example.metadata)
     summary = metadata[:summary] || RSpec::OpenAPI.summary_builder.call(example)
@@ -14,7 +22,7 @@ class SharedExtractor
     security = metadata[:security]
     description = metadata[:description] || RSpec::OpenAPI.description_builder.call(example)
     deprecated = metadata[:deprecated]
-    example_mode = normalize_example_mode(metadata[:example_mode], example)
+    request_example_mode, response_example_mode = normalize_example_mode(metadata[:example_mode], example)
     example_name = metadata[:example_name] || RSpec::OpenAPI.example_name_builder.call(example)
     raw_example_key = metadata[:example_key] || example_name
     example_key = RSpec::OpenAPI::ExampleKey.normalize(raw_example_key)
@@ -25,8 +33,29 @@ class SharedExtractor
     response_enum = normalize_enum(metadata[:response_enum]) || base_enum
     request_enum = normalize_enum(metadata[:request_enum]) || base_enum
 
-    [summary, tags, formats, operation_id, required_request_params, security, description, deprecated, example_mode,
-     example_key, example_name, response_enum, request_enum,]
+    response_additional_properties, request_additional_properties = resolve_additional_properties(metadata)
+    response_hybrid_additional_properties, request_hybrid_additional_properties =
+      resolve_hybrid_additional_properties(metadata)
+
+    [summary, tags, formats, operation_id, required_request_params, security, description, deprecated,
+     request_example_mode, response_example_mode,
+     example_key, example_name, response_enum, request_enum, response_additional_properties,
+     request_additional_properties, response_hybrid_additional_properties,
+     request_hybrid_additional_properties,]
+  end
+
+  def self.resolve_additional_properties(metadata)
+    base = normalize_additional_properties(metadata[:additional_properties])
+    response = normalize_additional_properties(metadata[:response_additional_properties]) || base
+    request = normalize_additional_properties(metadata[:request_additional_properties]) || base
+    [response, request]
+  end
+
+  def self.resolve_hybrid_additional_properties(metadata)
+    base = normalize_additional_properties(metadata[:hybrid_additional_properties])
+    response = normalize_additional_properties(metadata[:response_hybrid_additional_properties]) || base
+    request = normalize_additional_properties(metadata[:request_hybrid_additional_properties]) || base
+    [response, request]
   end
 
   def self.normalize_enum(enum_hash)
@@ -36,6 +65,14 @@ class SharedExtractor
     enum_hash.transform_keys(&:to_s)
   end
 
+  def self.normalize_additional_properties(hash)
+    return nil if hash.nil? || hash.empty?
+
+    hash.each_with_object({}) do |(path, schema), result|
+      result[path.to_s] = RSpec::OpenAPI::KeyTransformer.symbolize(schema)
+    end
+  end
+
   def self.merge_openapi_metadata(metadata)
     collect_openapi_metadata(metadata).reduce({}, &:merge)
   end
@@ -54,9 +91,33 @@ class SharedExtractor
     end
   end
 
+  # Returns [request_mode, response_mode]. Accepts either a bare Symbol/String
+  # (applied to both sides, except :multiple which is treated as a backward-compat
+  # shorthand for { request: :single, response: :multiple } and emits a one-time
+  # deprecation warning) or a Hash with :request / :response keys.
   def self.normalize_example_mode(value, example = nil)
-    return :single if value.nil?
+    return %i[single single] if value.nil?
 
+    case value
+    when Hash
+      [
+        normalize_example_mode_hash_value(value, :request, example),
+        normalize_example_mode_hash_value(value, :response, example),
+      ]
+    when Symbol, String
+      mode = coerce_example_mode_value(value, example)
+      if mode == :multiple
+        warn_example_mode_multiple_shorthand
+        %i[single multiple]
+      else
+        [mode, mode]
+      end
+    else
+      raise ArgumentError, example_mode_error(value, example)
+    end
+  end
+
+  def self.coerce_example_mode_value(value, example)
     raise ArgumentError, example_mode_error(value, example) unless value.is_a?(String) || value.is_a?(Symbol)
 
     mode = value.to_s.strip.downcase.to_sym
@@ -65,9 +126,25 @@ class SharedExtractor
     raise ArgumentError, example_mode_error(value, example)
   end
 
+  def self.normalize_example_mode_hash_value(hash, key, example)
+    raw = hash[key]
+    raw = hash[key.to_s] if raw.nil?
+    return :single if raw.nil?
+
+    coerce_example_mode_value(raw, example)
+  end
+
+  def self.warn_example_mode_multiple_shorthand
+    return if @warned_example_mode_multiple_shorthand
+
+    @warned_example_mode_multiple_shorthand = true
+    Kernel.warn(EXAMPLE_MODE_MULTIPLE_SHORTHAND_WARNING)
+  end
+
   def self.example_mode_error(value, example)
     context = example&.full_description
     context = " (example: #{context})" if context
-    "example_mode must be one of #{VALID_EXAMPLE_MODES.inspect}, got #{value.inspect}#{context}"
+    "example_mode must be a Symbol/String in #{VALID_EXAMPLE_MODES.inspect} " \
+      "or a Hash with :request/:response keys, got #{value.inspect}#{context}"
   end
 end

data/lib/rspec/openapi/record.rb

@@ -20,7 +20,8 @@ RSpec::OpenAPI::Record = Struct.new(
   :security,              # @param [Array]  - [{securityScheme1: []}]
   :deprecated,            # @param [Boolean] - true
   :example_enabled,       # @param [Boolean] - true
-  :example_mode,          # @param [Symbol]  - :none | :single | :multiple
+  :request_example_mode,  # @param [Symbol]  - :none | :single | :multiple
+  :response_example_mode, # @param [Symbol]  - :none | :single | :multiple
   :status,                # @param [Integer] - 200
   :response_body,         # @param [Object]  - {"status" => "ok"}
   :response_headers,      # @param [Array]  - [["header_key1", "header_value1"], ["header_key2", "header_value2"]]
@@ -28,5 +29,9 @@ RSpec::OpenAPI::Record = Struct.new(
   :response_content_disposition, # @param [String]  - "inline"
   :response_enum,         # @param [Hash]    - {"status" => ["active", "inactive"], "user.role" => ["admin", "user"]}
   :request_enum,          # @param [Hash]    - {"type" => ["create", "update"]}
+  :response_additional_properties, # @param [Hash] - {"data" => { type: "boolean" }}
+  :request_additional_properties,  # @param [Hash] - {"meta" => { type: "string" }}
+  :response_hybrid_additional_properties, # @param [Hash] - {"data" => { type: "string" }}
+  :request_hybrid_additional_properties,  # @param [Hash] - {"meta" => { type: "string" }}
   keyword_init: true,
 )

data/lib/rspec/openapi/record_builder.rb

@@ -12,8 +12,11 @@ class << RSpec::OpenAPI::RecordBuilder = Object.new
     return if request.nil?
 
     title = RSpec::OpenAPI.title.then { |t| t.is_a?(Proc) ? t.call(example) : t }
-    path, summary, tags, operation_id, required_request_params, raw_path_params, description, security, deprecated,
-      formats, example_mode, example_key, example_name, response_enum, request_enum = extractor.request_attributes(request, example)
+    path, summary, tags, operation_id, required_request_params, raw_path_params,
+      description, security, deprecated, formats, request_example_mode, response_example_mode,
+      example_key, example_name, response_enum, request_enum, response_additional_properties,
+      request_additional_properties, response_hybrid_additional_properties,
+      request_hybrid_additional_properties = extractor.request_attributes(request, example)
 
     return if RSpec::OpenAPI.ignored_paths.any? { |ignored_path| path.match?(ignored_path) }
 
@@ -42,11 +45,16 @@ class << RSpec::OpenAPI::RecordBuilder = Object.new
       response_content_type: response.media_type,
       response_content_disposition: response.header['Content-Disposition'],
       example_enabled: RSpec::OpenAPI.enable_example,
-      example_mode: example_mode,
+      request_example_mode: request_example_mode,
+      response_example_mode: response_example_mode,
       example_key: example_key,
       example_name: example_name,
       response_enum: response_enum,
       request_enum: request_enum,
+      response_additional_properties: response_additional_properties,
+      request_additional_properties: request_additional_properties,
+      response_hybrid_additional_properties: response_hybrid_additional_properties,
+      request_hybrid_additional_properties: request_hybrid_additional_properties,
     ).freeze
   end
 

data/lib/rspec/openapi/schema_builder.rb

@@ -4,9 +4,15 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
   # @param [RSpec::OpenAPI::Record] record
   # @return [Hash]
   def build(record)
-    response = {
-      description: record.description,
-    }
+    response = if record.response_example_mode == :none
+                 # `:none` opts out of recording, so the description is provisional.
+                 # Stash it under a fallback key; SchemaCleaner promotes it to
+                 # `description` only if no documented test has set one. This makes
+                 # the merge result independent of RSpec's random execution order.
+                 { _fallback_description: record.description }
+               else
+                 { description: record.description }
+               end
 
     response_headers = build_response_headers(record)
     response[:headers] = response_headers unless response_headers.empty?
@@ -52,7 +58,7 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
     # If examples are globally disabled, always return schema-only content.
     return { content_type => { schema: schema }.compact } unless example_enabled?(record)
 
-    case record.example_mode
+    case record.response_example_mode
     when :none
       # Only schema, no examples
       {
@@ -74,8 +80,7 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
         content_type => {
           schema: schema,
           example: response_example(record, disposition: disposition),
-          _example_key: record.example_key,
-          _example_summary: example_summary(record),
+          **example_metadata(record),
         }.compact,
       }
     end
@@ -93,13 +98,21 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
   end
 
   def build_example_object(record, disposition:)
+    build_named_example(record, response_example(record, disposition: disposition))
+  end
+
+  def build_named_example(record, value)
     summary = example_summary(record)
     example = {}
     example[:summary] = summary if summary
-    example[:value] = response_example(record, disposition: disposition)
+    example[:value] = value
     example
   end
 
+  def example_metadata(record)
+    { _example_key: record.example_key, _example_summary: example_summary(record) }
+  end
+
   def example_summary(record)
     return nil unless example_summary_enabled?
     return nil if record.example_name.nil? || record.example_name.empty?
@@ -191,16 +204,33 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
 
   def build_request_body(record)
     return nil if record.request_content_type.nil?
-    return nil if record.status >= 400
+    return nil if record.status >= 400 && record.request_example_mode != :multiple
 
-    {
-      content: {
-        normalize_content_type(record.request_content_type) => {
-          schema: build_property(record.request_params, record: record, context: :request),
-          example: (build_example(record.request_params) if example_enabled?(record)),
-        }.compact,
-      },
-    }
+    content_type = normalize_content_type(record.request_content_type)
+    schema = build_property(record.request_params, record: record, context: :request)
+
+    return { content: { content_type => { schema: schema }.compact } } unless example_enabled?(record)
+
+    example = build_example(record.request_params)
+
+    body =
+      case record.request_example_mode
+      when :none
+        { schema: schema }
+      when :multiple
+        {
+          schema: schema,
+          examples: { record.example_key => build_named_example(record, example) },
+        }
+      else # :single (default)
+        {
+          schema: schema,
+          example: example,
+          **example_metadata(record),
+        }
+      end
+
+    { content: { content_type => body.compact } }
   end
 
   def build_property(value, disposition: nil, key: nil, record: nil, path: nil, context: nil)
@@ -217,13 +247,32 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
                            build_array_items_schema(value, record: record, path: path, context: context)
                          end
     when Hash
-      property[:properties] = {}.tap do |properties|
-        value.each do |k, v|
-          child_path = path ? "#{path}.#{k}" : k.to_s
-          properties[k] = build_property(v, record: record, key: k, path: child_path, context: context)
+      override = infer_additional_properties(path, record, context)
+      hybrid_override = infer_hybrid_additional_properties(path, record, context)
+      if override.is_a?(Hash) && !override.empty?
+        # Schema override: the object's keys are dynamic — replace captured
+        # `properties` / `required` with the supplied dictionary value schema.
+        property[:additionalProperties] = override
+      else
+        property[:properties] = {}.tap do |properties|
+          value.each do |k, v|
+            child_path = path ? "#{path}.#{k}" : k.to_s
+            properties[k] = build_property(v, record: record, key: k, path: child_path, context: context)
+          end
+        end
+        property = enrich_with_required_keys(property)
+        # Hybrid: keep the observed `properties` / `required` and attach
+        # `additionalProperties` alongside.
+        # - Boolean values are constraints (`false` forbids extras, `true`
+        #   explicitly allows them).
+        # - Hash schema values come from the dedicated `hybrid_additional_properties`
+        #   metadata, expressing "known keys + extras of this type".
+        if override == true || override == false
+          property[:additionalProperties] = override
+        elsif hybrid_override.is_a?(Hash) && !hybrid_override.empty?
+          property[:additionalProperties] = hybrid_override
         end
       end
-      property = enrich_with_required_keys(property)
     end
     property
   end
@@ -270,8 +319,38 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
     enum_hash = context == :request ? record.request_enum : record.response_enum
     return nil unless enum_hash
 
-    # Try both string and symbol keys
-    enum_hash[path.to_s] || enum_hash[path.to_sym]
+    # Keys are already normalized to strings by SharedExtractor.normalize_enum
+    enum_hash[path.to_s]
+  end
+
+  def infer_additional_properties(path, record, context)
+    return nil unless record
+
+    overrides = if context == :request
+                  record.request_additional_properties
+                else
+                  record.response_additional_properties
+                end
+    return nil unless overrides
+
+    # path is nil at the body root; nil.to_s == '' lets users target it via { '' => ... }.
+    # Use `key?` so a literal `false` override is distinguishable from "no override".
+    return nil unless overrides.key?(path.to_s)
+
+    overrides[path.to_s]
+  end
+
+  def infer_hybrid_additional_properties(path, record, context)
+    return nil unless record
+
+    overrides = if context == :request
+                  record.request_hybrid_additional_properties
+                else
+                  record.response_hybrid_additional_properties
+                end
+    return nil unless overrides
+
+    overrides[path.to_s]
   end
 
   # Convert an always-String param to an appropriate type
@@ -319,14 +398,13 @@ class << RSpec::OpenAPI::SchemaBuilder = Object.new
     content_type&.sub(/;.+\z/, '')
   end
 
-  def normalize_content_disposition(content_disposition)
-    content_disposition&.sub(/;.+\z/, '')
-  end
+  # Same logic as normalize_content_type – strips header parameters after ';'
+  alias normalize_content_disposition normalize_content_type
 
   def build_array_items_schema(array, record: nil, path: nil, context: nil)
     return {} if array.empty?
     return build_property(array.first, record: record, path: path, context: context) if array.size == 1
-    return build_property(array.first, record: record, path: path, context: context) unless array.all? { |item| item.is_a?(Hash) }
+    return build_property(array.first, record: record, path: path, context: context) unless array.all?(Hash)
 
     all_schemas = array.map { |item| build_property(item, record: record, path: path, context: context) }
     merged_schema = all_schemas.first.dup

data/lib/rspec/openapi/schema_cleaner.rb

@@ -70,6 +70,8 @@ class << RSpec::OpenAPI::SchemaCleaner = Object.new
     ]
     paths_to_objects.each do |path|
       parent = base.dig(*path.take(path.length - 1))
+      next unless parent
+
       # "required" array  must not be present if empty
       parent.delete(:required) if parent[:required] && parent[:required].empty?
     end
@@ -84,6 +86,9 @@ class << RSpec::OpenAPI::SchemaCleaner = Object.new
     hash.delete(:_example_key)
     hash.delete(:_example_summary)
     hash.delete(:_example_name)
+    if (fallback = hash.delete(:_fallback_description))
+      hash[:description] ||= fallback
+    end
 
     hash.each_value do |value|
       case value

data/lib/rspec/openapi/schema_merger.rb

@@ -9,6 +9,8 @@ class << RSpec::OpenAPI::SchemaMerger = Object.new
     merge_schema!(base, spec)
   end
 
+  SIMILARITY_THRESHOLD = 0.5
+
   private
 
   # Not doing `base.replace(deep_merge(base, spec))` to preserve key orders.
@@ -23,6 +25,17 @@ class << RSpec::OpenAPI::SchemaMerger = Object.new
       return base
     end
 
+    # When the new spec converts an object to a dictionary (introduces
+    # `additionalProperties` on a node that previously had `properties` /
+    # `required`), drop the stale fields so the merged result reflects the
+    # new intent. We only prune when base does not already declare
+    # `additionalProperties`, to preserve manual edits that intentionally
+    # combine fixed and dynamic keys.
+    if spec.is_a?(Hash) && spec.key?(:additionalProperties) && !base.key?(:additionalProperties)
+      base.delete(:properties)
+      base.delete(:required)
+    end
+
     spec.each do |key, value|
       if base[key].is_a?(Hash) && value.is_a?(Hash)
         # Handle example/examples conflict - convert to examples when mixed
@@ -121,13 +134,11 @@ class << RSpec::OpenAPI::SchemaMerger = Object.new
   end
 
   def build_unique_params(base, key)
-    base[key].each_with_object({}) do |parameter, hash|
-      hash[[parameter[:name], parameter[:in]]] = parameter
+    base[key].to_h do |parameter|
+      [[parameter[:name], parameter[:in]], parameter]
     end
   end
 
-  SIMILARITY_THRESHOLD = 0.5
-
   # Normalize example/examples fields when there's a conflict
   # OpenAPI spec doesn't allow both example and examples in the same object
   def normalize_example_fields!(base, spec)

data/lib/rspec/openapi/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module OpenAPI
-    VERSION = '0.25.0'
+    VERSION = '0.26.0'
   end
 end

data/lib/rspec/openapi.rb

@@ -33,7 +33,7 @@ module RSpec::OpenAPI
   @comment = nil
   @enable_example = true
   @enable_example_summary = true
-  @description_builder = ->(example) { example.description }
+  @description_builder = :description.to_proc
   @example_name_builder = :description.to_proc
   @summary_builder = ->(example) { example.metadata[:summary] }
   @tags_builder = ->(example) { example.metadata[:tags] }

data/redocly.yaml

@@ -0,0 +1,31 @@
+# Config for `redocly lint` used by .github/workflows/validate-openapi.yml
+# to validate test-fixture OpenAPI documents shipped under spec/apps/.
+#
+# spec/apps/rails/doc/smart/openapi.yaml is intentionally excluded:
+# it is the input fixture for the smart-merge feature test (it contains
+# unresolved $refs by design), not a complete API description.
+extends:
+  - minimal
+apis:
+  rails-rspec-yaml:
+    root: spec/apps/rails/doc/rspec_openapi.yaml
+  rails-rspec-json:
+    root: spec/apps/rails/doc/rspec_openapi.json
+  rails-minitest-yaml:
+    root: spec/apps/rails/doc/minitest_openapi.yaml
+  rails-minitest-json:
+    root: spec/apps/rails/doc/minitest_openapi.json
+  rails-smart-expected:
+    root: spec/apps/rails/doc/smart/expected.yaml
+  roda-rspec-yaml:
+    root: spec/apps/roda/doc/rspec_openapi.yaml
+  roda-rspec-json:
+    root: spec/apps/roda/doc/rspec_openapi.json
+  roda-minitest-yaml:
+    root: spec/apps/roda/doc/minitest_openapi.yaml
+  roda-minitest-json:
+    root: spec/apps/roda/doc/minitest_openapi.json
+  hanami-yaml:
+    root: spec/apps/hanami/doc/openapi.yaml
+  hanami-json:
+    root: spec/apps/hanami/doc/openapi.json

data/rspec-openapi.gemspec

@@ -31,5 +31,4 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'actionpack', '>= 5.2.0'
   spec.add_dependency 'rails-dom-testing'
   spec.add_dependency 'rspec-core'
-  spec.metadata['rubygems_mfa_required'] = 'true'
 end