openapi_parameters 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52bca4aebd3d66fa0a3edc68d3ce71a24a223a31be135677a8fb9ea09a4055bc
-  data.tar.gz: '03230596b824ee0a59ca68048bcfc68e884af2cbbb3b14ea3952c1f917a7d87b'
+  metadata.gz: 69f716831414a1780a62e1d78b4405f3e9bc293f8dea9dcd9d56330c56180322
+  data.tar.gz: 4621c4705857aa76cdf67c3f0275d4e515b63fe8429fd9de406174dd04625f23
 SHA512:
-  metadata.gz: e5bf0752ef3be5d397cd5f5cee010a5e89fc4c1a1821ec0b86411fb1a97bfae8e81be46f5fa94d5bd47940c921f0a0dab9641f591f6ceddecfc856dd881f34d7
-  data.tar.gz: 8244a7c1c93ef4c0c2ee88374c4bb72f3f6295a11637fff60b02ad96e9015e702b284251eff003309ebdc0bb8f6ccf38f85334a9be7d6801bcd0b6f48cc5e808
+  metadata.gz: cc2fb07a22b21031c311271166a204929170fd678385e0f69e00af18c98109550709da12bc9cd625a456cff8cd93a887c2d4b0eabb8c7850765e6095b4cf53b1
+  data.tar.gz: f0d679df5b595877fc2033e6ee68014ef108fe13b1c9c128f423220397d79e9aba9f1cf2a5feac4bb63e6ba5afe7b59ca46c97373fcba0102e2e455f94cad960

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.12.0] - 2026-05-18
+
+- Add support for parameters defined with a `content` field. Values for media types matching `application/json` or `*+json` are decoded with `JSON.parse` before conversion. Works for query, path, header, and cookie parameters.
+
+## [0.11.0] - 2025-11-30
+
+- Changed:  Passing a plain query string like `filter=ada` to a`deepObject` parameter instead of using the brackets syntax `filter[name]=ada` no longer results in an empty object, but in the plain string value (like `{ filter: 'ada'} `), which will make request validation fail.
+
 ## [0.10.0] - 2025-11-23
 
 - remove `OpenapiParameters::Parameter#definition` to clean up interface

data/lib/openapi_parameters/content_parsers.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module OpenapiParameters
+  # Registry of content parsers keyed by media type.
+  #
+  # A parser is a callable that takes a raw string and returns the parsed value.
+  # It should `throw :skip, value` if the input cannot be parsed, so the
+  # parameter falls through gracefully at the location class level.
+  #
+  # Built-in: `application/json` and any `*+json` subtype.
+  #
+  # To register your own:
+  #
+  #   OpenapiParameters::ContentParsers.register('application/xml', ->(v) { ... })
+  module ContentParsers
+    @parsers = []
+
+    class << self
+      attr_reader :parsers
+
+      # @param matcher [String, Regexp] exact media type or a pattern.
+      # @param parser [#call] callable that takes the raw string and returns the parsed value.
+      def register(matcher, parser)
+        parsers.reject! { |existing, _| existing == matcher }
+        parsers << [matcher, parser]
+      end
+
+      # @param media_type [String, nil]
+      # @return [#call, nil] the parser, or nil if none is registered.
+      def [](media_type)
+        return nil if media_type.nil?
+
+        parsers.each do |matcher, parser|
+          return parser if match?(matcher, media_type)
+        end
+        nil
+      end
+
+      private
+
+      def match?(matcher, media_type)
+        case matcher
+        when Regexp then matcher.match?(media_type)
+        else matcher == media_type
+        end
+      end
+    end
+
+    register(%r{\A[\w.+-]+/(?:[\w.-]+\+)?json\z}i, lambda do |value|
+      JSON.parse(value)
+    rescue JSON::ParserError
+      throw :skip, value
+    end)
+  end
+end

data/lib/openapi_parameters/cookie.rb

@@ -17,7 +17,7 @@ module OpenapiParameters
         next unless cookies.key?(parameter.name)
 
         result[parameter.name] = catch :skip do
-          value = Unpacker.unpack_value(parameter, cookies[parameter.name])
+          value = parameter.unpack(cookies[parameter.name])
           @convert ? parameter.convert(value) : value
         end
       end

data/lib/openapi_parameters/header.rb

@@ -16,7 +16,7 @@ module OpenapiParameters
         next unless headers.key?(parameter.name)
 
         result[parameter.name] = catch :skip do
-          value = Unpacker.unpack_value(parameter, headers[parameter.name])
+          value = parameter.unpack(headers[parameter.name])
           @convert ? parameter.convert(value) : value
         end
       end

data/lib/openapi_parameters/parameter.rb

@@ -11,10 +11,18 @@ module OpenapiParameters
       @is_deep_object = style == 'deepObject'
       @converter = Converters[schema]
       check_supported!
+      @unpacker = Unpackers.find(self)
+      @bracket_array = (array? && @name&.end_with?(EMPTY_BRACKETS)) || false
     end
 
     attr_reader :name
-    private attr_reader :definition
+    private attr_reader :definition, :unpacker
+
+    def unpack(value)
+      return value if value.nil?
+
+      unpacker.call(value)
+    end
 
     def convert(value)
       @converter.call(value)
@@ -57,7 +65,7 @@ module OpenapiParameters
     private_constant :EMPTY_BRACKETS
 
     def bracket_array?
-      @bracket_array ||= array? && name.end_with?(EMPTY_BRACKETS)
+      @bracket_array
     end
 
     def object?

data/lib/openapi_parameters/path.rb

@@ -20,7 +20,7 @@ module OpenapiParameters
         next unless path_params.key?(parameter.name)
 
         result[parameter.name] = catch :skip do
-          value = Unpacker.unpack_value(parameter, path_params[parameter.name])
+          value = parameter.unpack(path_params[parameter.name])
           @convert ? parameter.convert(value) : value
         end
       end

data/lib/openapi_parameters/query.rb

@@ -12,18 +12,26 @@ module OpenapiParameters
       @parameters = parameters.map { Parameter.new(_1) }
       @convert = convert
       @remove_array_brackets = rack_array_compat
+      @deep_object_properties = @parameters.each_with_object({}) do |param, hsh|
+        hsh[param.name] = ObjectConverter.get_properties(param.schema) if param.deep_object?
+      end
     end
 
-    def unpack(query_string) # rubocop:disable Metrics/AbcSize
+    def unpack(query_string) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       parsed_query = parse_query(query_string)
       parameters.each_with_object({}) do |parameter, result|
         if parameter.deep_object?
-          value = parse_deep_object(parameter, parsed_query)
-          next if value.empty?
+          if parsed_query.key?(parameter.name)
+            value = parsed_query[parameter.name]
+          else
+            value = parse_deep_object(parameter, parsed_query)
+            next if value.empty?
+          end
         else
           next unless parsed_query.key?(parameter.name)
 
-          value = Unpacker.unpack_value(parameter, parsed_query[parameter.name])
+          raw = parsed_query[parameter.name]
+          value = catch(:skip) { parameter.unpack(raw) }
         end
         key = if remove_array_brackets && parameter.bracket_array?
                 parameter.name.delete_suffix('[]')
@@ -65,18 +73,13 @@ module OpenapiParameters
       end
     end
 
-    def build_properties_schema(parameter)
-      schema = parameter.schema
-      ObjectConverter.get_properties(schema) if schema
-    end
-
     DEEP_PROP = '\[([\w-]+)\]$'
     private_constant :DEEP_PROP
 
     def parse_deep_object(parameter, parsed_query)
       name = parameter.name
       prop_regx = /^#{name}#{DEEP_PROP}/
-      properties_schema = build_properties_schema(parameter)
+      properties_schema = @deep_object_properties[name]
 
       parsed_query.each.with_object({}) do |(key, value), result|
         next unless parsed_query.key?(key)

data/lib/openapi_parameters/unpackers.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module OpenapiParameters
+  # Resolves the per-parameter unpacker once at Parameter construction time.
+  # Each unpacker is a callable that takes a raw string (or already-parsed
+  # value) and returns the unpacked Ruby value, throwing :skip on unrecoverable
+  # parse errors.
+  # @visibility private
+  module Unpackers
+    ARRAY_DELIMITER = {
+      'label' => '.',
+      'simple' => ',',
+      'form' => ',',
+      'pipeDelimited' => '|',
+      'spaceDelimited' => ' '
+    }.freeze
+    private_constant :ARRAY_DELIMITER
+
+    PREFIXED_STYLES = %w[label matrix].freeze
+    private_constant :PREFIXED_STYLES
+
+    OBJECT_EXPLODE_SPLITTER = Regexp.union(',', '=').freeze
+    private_constant :OBJECT_EXPLODE_SPLITTER
+
+    PassThrough = ->(value) { value }
+
+    DelimitedArray = Data.define(:delimiter, :strip_prefix) do
+      def call(value)
+        return value if value.is_a?(::Array)
+        return value if value.empty?
+
+        value = value[1..] if strip_prefix
+        value.split(delimiter)
+      end
+    end
+
+    MatrixArray = Data.define(:name, :explode) do
+      def call(value)
+        return value if value.is_a?(::Array)
+        return value if value.empty?
+
+        result = Rack::Utils.parse_query(value, ';')[name]
+        explode ? result : result.split(',')
+      end
+    end
+
+    ExplodeFormObject = lambda do |value|
+      entries = value.split(OBJECT_EXPLODE_SPLITTER)
+      throw :skip, value if entries.length.odd?
+
+      Hash[*entries]
+    end
+
+    DelimitedObject = Data.define(:delimiter) do
+      def call(value)
+        entries = value.split(delimiter)
+        throw :skip, value if entries.length.odd?
+
+        Hash[*entries]
+      end
+    end
+
+    ExplodePathObject = ->(value) { Rack::Utils.parse_query(value, ',') }
+
+    NonExplodePathObject = Data.define(:array_unpacker) do
+      def call(value)
+        array = array_unpacker.call(value)
+        throw :skip, value if array.length.odd?
+
+        Hash[*array]
+      end
+    end
+
+    class << self
+      def find(parameter)
+        return find_media_type(parameter) if parameter.media_type
+        return find_array(parameter) if parameter.array?
+        return find_object(parameter) if parameter.object?
+
+        PassThrough
+      end
+
+      private
+
+      def find_media_type(parameter)
+        ContentParsers[parameter.media_type] || PassThrough
+      end
+
+      def find_array(parameter)
+        style = parameter.style
+        return MatrixArray.new(name: parameter.name, explode: parameter.explode?) if style == 'matrix'
+
+        DelimitedArray.new(
+          delimiter: ARRAY_DELIMITER[style],
+          strip_prefix: PREFIXED_STYLES.include?(style)
+        )
+      end
+
+      def find_object(parameter)
+        return find_path_object(parameter) if parameter.location == 'path'
+        return ExplodeFormObject if parameter.explode?
+
+        DelimitedObject.new(delimiter: ARRAY_DELIMITER[parameter.style])
+      end
+
+      def find_path_object(parameter)
+        return ExplodePathObject if parameter.explode?
+
+        NonExplodePathObject.new(array_unpacker: find_array(parameter))
+      end
+    end
+  end
+end

data/lib/openapi_parameters/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenapiParameters
-  VERSION = '0.10.0'
+  VERSION = '0.12.0'
 end

data/lib/openapi_parameters.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'rack'
 require_relative 'openapi_parameters/converters'
 require_relative 'openapi_parameters/converter'
@@ -8,10 +9,11 @@ require_relative 'openapi_parameters/error'
 require_relative 'openapi_parameters/header'
 require_relative 'openapi_parameters/headers_hash'
 require_relative 'openapi_parameters/not_supported_error'
+require_relative 'openapi_parameters/content_parsers'
+require_relative 'openapi_parameters/unpackers'
 require_relative 'openapi_parameters/parameter'
 require_relative 'openapi_parameters/path'
 require_relative 'openapi_parameters/query'
-require_relative 'openapi_parameters/unpacker'
 
 # OpenapiParameters is a gem that parses OpenAPI parameters from Rack
 module OpenapiParameters

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openapi_parameters
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Andreas Haller
@@ -35,6 +35,7 @@ files:
 - README.md
 - lib/openapi_parameters.rb
 - lib/openapi_parameters/array_converter.rb
+- lib/openapi_parameters/content_parsers.rb
 - lib/openapi_parameters/converter.rb
 - lib/openapi_parameters/converters.rb
 - lib/openapi_parameters/cookie.rb
@@ -46,7 +47,7 @@ files:
 - lib/openapi_parameters/parameter.rb
 - lib/openapi_parameters/path.rb
 - lib/openapi_parameters/query.rb
-- lib/openapi_parameters/unpacker.rb
+- lib/openapi_parameters/unpackers.rb
 - lib/openapi_parameters/version.rb
 homepage: https://github.com/ahx/openapi_parameters
 licenses:

data/lib/openapi_parameters/unpacker.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiParameters
-  # Unpacks a parameter value from a string as defined in the OpenAPI specification.
-  # @visibility private
-  module Unpacker
-    class << self
-      def unpack_value(parameter, value)
-        return value if value.nil?
-        return unpack_array(parameter, value) if parameter.array?
-        return unpack_object(parameter, value) if parameter.object?
-
-        value
-      end
-
-      def unpack_array(parameter, value)
-        return value if value.is_a?(Array)
-        return value if value.empty?
-        return unpack_matrix(parameter, value) if parameter.style == 'matrix'
-
-        value = value[1..] if PREFIXED.key?(parameter.style)
-        value.split(ARRAY_DELIMITER[parameter.style])
-      end
-
-      def unpack_matrix(parameter, value)
-        result = Rack::Utils.parse_query(value, ';')[parameter.name]
-        return result if parameter.explode?
-
-        result.split(',')
-      end
-
-      OBJECT_EXPLODE_SPLITTER = Regexp.union(',', '=').freeze
-      private_constant :OBJECT_EXPLODE_SPLITTER
-
-      def unpack_object(parameter, value)
-        return unpack_object_path(parameter, value) if parameter.location == 'path'
-
-        entries =
-          if parameter.explode?
-            value.split(OBJECT_EXPLODE_SPLITTER)
-          else
-            value.split(ARRAY_DELIMITER[parameter.style])
-          end
-        throw :skip, value if entries.length.odd?
-
-        Hash[*entries]
-      end
-
-      def unpack_object_path(parameter, value)
-        return Rack::Utils.parse_query(value, ',') if parameter.explode?
-
-        array = unpack_array(parameter, value)
-        throw :skip, value if array.length.odd?
-
-        Hash[*array]
-      end
-
-      PREFIXED = {
-        'label' => '.',
-        'matrix' => ';'
-      }.freeze
-
-      ARRAY_DELIMITER = {
-        'label' => '.',
-        'simple' => ',',
-        'form' => ',',
-        'pipeDelimited' => '|',
-        'spaceDelimited' => ' '
-      }.freeze
-      private_constant :ARRAY_DELIMITER
-    end
-  end
-end