openapi_parameters 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97605d112ff65a874f5fa63dc7ecd13d3ca37468e559dbf7980a1f6c55e37274
+  data.tar.gz: 280fe6bc55862118dc65e77a6e29c6a3f27ee3c3d07f1361003c9cbd52fdc660
+SHA512:
+  metadata.gz: e1cff00125ffb1ea81548a6e8f5bee73b1cedc29ccb2569296e0f869a9ac3412cc9c683afcba2f48bcc6cca06287a1fba251068b4c831e2d4933497268a58da8
+  data.tar.gz: 6177d8425f16f678af64f4059ecc1fecf70e954ce0edd95ce2e38a7b5bbd1efe801951fffb9ca8932d7d4d258100af0070623c5c04672d1e539caee1cbc8204e

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,16 @@
+require:
+  - rubocop-rspec
+
+Naming/MethodParameterName:
+  Enabled: false
+
+AllCops:
+  NewCops: enable
+  SuggestExtensions: false
+  TargetRubyVersion: 3.1
+
+RSpec/ExampleLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 20

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.2.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2032-03-25
+
+- Initial release

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in OpenapiParameters.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'
+
+gem 'rspec', '~> 3.0'
+gem 'rubocop'
+gem 'rubocop-rspec'

data/Gemfile.lock

@@ -0,0 +1,69 @@
+PATH
+  remote: .
+  specs:
+    openapi_parameters (0.1.0)
+      rack (>= 2.2)
+      uri_template (>= 0.7, < 2.0)
+      zeitwerk (~> 2.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.0)
+    json (2.6.2)
+    parallel (1.22.1)
+    parser (3.1.2.1)
+      ast (~> 2.4.1)
+    rack (3.0.0)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.6.1)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.39.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.23.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.23.0)
+      parser (>= 3.1.1.0)
+    rubocop-rspec (2.11.1)
+      rubocop (~> 1.19)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.3.0)
+    uri_template (0.7.0)
+    zeitwerk (2.6.7)
+
+PLATFORMS
+  arm64-darwin-21
+  arm64-darwin-22
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  openapi_parameters!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop
+  rubocop-rspec
+
+BUNDLED WITH
+   2.3.10

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Andreas Haller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,89 @@
+# OpenapiParameters
+
+OpenapiParameters is an an [OpenAPI](https://www.openapis.org/) aware parameter parser.
+
+OpenapiParameters unpacks HTTP/Rack (query / header / cookie) parameters exactly as described in an [OpenAPI](https://www.openapis.org/) definition. It supports `style`, `explode` and `schema` definitions according to OpenAPI 3.1 (or 3.0).
+
+## Synopsis
+
+Note that OpenAPI supportes parameter definition on path and operation objects. Parameter definitions must use strings as keys.
+
+### Unpack query/path/header/cookie parameters from HTTP requests according to their OpenAPI definition
+
+```ruby
+parameters = [{
+  'name' => 'ids',
+  'required' => true,
+  'in' => 'query', # or 'path', 'header', 'cookie'
+  'schema' => {
+    'type' => 'array',
+    'items' => {
+      'type' => 'integer'
+    }
+  }
+}]
+
+query_parameters = OpenapiParameters::Query.new(parameters)
+query_string = env['QUERY_STRING'] # => 'ids=1&ids=2'
+query_parameters.unpack(query_string) # => { 'ids' => [1, 2] }
+query_parameters.unpack(query_string, convert: false) # => { 'ids' => ['1', '2'] }
+
+path_parameters = OpenapiParameters::Path.new(parameters, '/pets/ids')
+path_info = env['PATH_INFO'] # => '/pets/1,2,3'
+path_parameters.unpack(path_info) # => { 'ids' => [1, 2, 3] }
+
+header_parameters = OpenapiParameters::Header.new(parameters)
+header_parameters.unpack_env(env)
+
+cookie_parameters = OpenapiParameters::Cookie.new(parameters)
+cookie_string = env['HTTP_COOKIE'] # => "ids=3"
+cookie_parameters.unpack(cookie_string) # => { 'ids' => [3] }
+```
+
+Note that this library does not validate the parameter value against it's JSON Schema.
+
+### Inspect parameter definition
+
+```ruby
+parameter = OpenapiParameters::Parameter.new({
+  'name' => 'ids',
+  'required' => true,
+  'in' => 'query', # or 'path', 'header', 'cookie'
+  'schema' => {
+    'type' => 'array',
+    'items' => {
+      'type' => 'integer'
+    }
+  }
+})
+parameter.name # => 'ids'
+parameter.required? # => true
+parameter.in # => 'query'
+parameter.location # => 'query' (alias for in)
+parameter.schema # => { 'type' => 'array', 'items' => { 'type' => 'integer' } }
+parameter.type # => 'array'
+parameter.deprecated? # => false
+parameter.media_type # => nil
+parameter.allow_reserved? # => false
+# etc.
+```
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add OpenapiParameters
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install OpenapiParameters
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ahx/OpenapiParameters.

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/openapi_parameters/converter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module OpenapiParameters
+  ##
+  # Tries to convert a request parameter value (string) to the type specified in the JSON Schema.
+  class Converter
+    ##
+    # @param input [String, Hash, Array] the value to convert
+    # @param schema [Hash] the schema to use for conversion.
+    def self.call(input, schema)
+      new(input, schema).call
+    end
+
+    def initialize(input, schema)
+      @input = input
+      @root_schema = schema
+    end
+
+    def call
+      convert(@input, @root_schema)
+    end
+
+    private
+
+    require 'json'
+
+    def convert(value, schema)
+      check_supported!(schema)
+      return if value.nil?
+      return value if schema.nil?
+
+      case type(schema)
+      when 'integer'
+        begin
+          Integer(value, 10)
+        rescue StandardError
+          value
+        end
+      when 'number'
+        begin
+          Float(value)
+        rescue StandardError
+          value
+        end
+      when 'boolean'
+        if value == 'true'
+          true
+        else
+          value == 'false' ? false : value
+        end
+      when 'object'
+        convert_object(value, schema)
+      when 'array'
+        convert_array(value, schema)
+      else
+        value
+      end
+    end
+
+    REF = '$ref'.freeze
+    private_constant :REF
+
+    def check_supported!(schema)
+      return unless schema&.key?(REF)
+
+      raise NotSupportedError,
+            "$ref is not supported: #{@root_schema.inspect}"
+    end
+
+    def type(schema)
+      schema && schema['type']
+    end
+
+    def convert_object(object, schema)
+      object.each_with_object({}) do |(key, value), hsh|
+        hsh[key] = convert(value, schema['properties']&.fetch(key))
+      end
+    end
+
+    def convert_array(array, schema)
+      item_schema = schema['items']
+      prefix_schemas = schema['prefixItems']
+      return convert_array_with_prefixes(array, prefix_schemas, item_schema) if prefix_schemas
+
+      array.map { |item| convert(item, item_schema) }
+    end
+
+    def convert_array_with_prefixes(array, prefix_schemas, item_schema)
+      prefixes =
+        array
+        .slice(0, prefix_schemas.size)
+        .each_with_index
+        .map { |item, index| convert(item, prefix_schemas[index]) }
+      array =
+        array[prefix_schemas.size..].map! do |item|
+          convert(item, item_schema)
+        end
+      prefixes + array
+    end
+  end
+end

data/lib/openapi_parameters/cookie.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module OpenapiParameters
+  # Cookie parses OpenAPI cookie parameters from a cookie string.
+  class Cookie
+    # @param parameters [Array<Hash>] The OpenAPI parameter definitions.
+    # @param convert [Boolean] Whether to convert the values to the correct type.
+    def initialize(parameters, convert: true)
+      @parameters = parameters
+      @convert = convert
+    end
+
+    # @param cookie_string [String] The cookie string from the request. Example "foo=bar; baz=qux"
+    def unpack(cookie_string)
+      cookies = Rack::Utils.parse_cookies_header(cookie_string)
+      parameters.each_with_object({}) do |parameter, result|
+        parameter = Parameter.new(parameter)
+        next unless cookies.key?(parameter.name)
+
+        result[parameter.name] = catch :skip do
+          value = unpack_parameter(parameter, cookies)
+          @convert ? Converter.call(value, parameter.schema) : value
+        end
+      end
+    end
+
+    private
+
+    attr_reader :parameters
+
+    def unpack_parameter(parameter, cookies)
+      value = cookies[parameter.name]
+      return if value.nil?
+      return unpack_object(parameter, value) if parameter.object?
+      return unpack_array(value) if parameter.array?
+
+      value
+    end
+
+    def unpack_array(value)
+      value.split(ARRAY_DELIMER)
+    end
+
+    ARRAY_DELIMER = ','
+    OBJECT_EXPLODE_SPLITTER = Regexp.union(',', '=').freeze
+
+    def unpack_object(parameter, value)
+      entries =
+        if parameter.explode?
+          value.split(OBJECT_EXPLODE_SPLITTER)
+        else
+          value.split(ARRAY_DELIMER)
+        end
+      throw :skip, value if entries.length.odd?
+
+      Hash[*entries]
+    end
+  end
+end

data/lib/openapi_parameters/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OpenapiParameters
+  class Error < StandardError
+  end
+
+  class NotSupportedError < Error
+  end
+end

data/lib/openapi_parameters/header.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenapiParameters
+  # Header parses OpenAPI parameters from the request headers.
+  class Header
+    # @param parameters [Array<Hash>] The OpenAPI parameters
+    # @param convert [Boolean] Whether to convert the values to the correct type.
+    def initialize(parameters, convert: true)
+      @parameters = parameters
+      @convert = convert
+    end
+
+    # @param headers [Hash] The headers from the request. Use HeadersHash to convert a Rack env to a Hash.
+    def unpack(headers)
+      parameters.each_with_object({}) do |parameter, result|
+        parameter = Parameter.new(parameter)
+        next unless headers.key?(parameter.name)
+
+        result[parameter.name] = catch :skip do
+          value = unpack_parameter(parameter, headers)
+          @convert ? Converter.call(value, parameter.schema) : value
+        end
+      end
+    end
+
+    def unpack_env(env)
+      unpack(HeadersHash.new(env))
+    end
+
+    attr_reader :parameters
+
+    private
+
+    def unpack_parameter(parameter, headers)
+      value = headers[parameter.name]
+      return value if parameter.primitive?
+      return unpack_object(parameter, value) if parameter.object?
+      return unpack_array(value) if parameter.array?
+    end
+
+    def unpack_array(value)
+      value.split(ARRAY_DELIMER)
+    end
+
+    ARRAY_DELIMER = ','
+    OBJECT_EXPLODE_SPLITTER = Regexp.union(',', '=').freeze
+
+    def unpack_object(parameter, value)
+      entries =
+        if parameter.explode?
+          value.split(OBJECT_EXPLODE_SPLITTER)
+        else
+          value.split(ARRAY_DELIMER)
+        end
+      throw :skip, value if entries.length.odd?
+
+      Hash[*entries]
+    end
+  end
+end

data/lib/openapi_parameters/headers_hash.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OpenapiParameters
+  # This is a wrapper around the Rack env hash that allows us to access headers with headers names
+  class HeadersHash
+    # This was copied from this Rack::Request PR: https://github.com/rack/rack/pull/1881
+    # It is not yet released in Rack, so we copied it here.
+    def initialize(env)
+      @env = env
+    end
+
+    def [](k)
+      @env[header_to_env_key(k)]
+    end
+
+    def key?(k)
+      @env.key?(header_to_env_key(k))
+    end
+
+    def header_to_env_key(k)
+      k = k.upcase
+      k.tr!('-', '_')
+      k = "HTTP_#{k}" unless %w[CONTENT_LENGTH CONTENT_TYPE].include?(k)
+      k
+    end
+  end
+end

data/lib/openapi_parameters/parameter.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module OpenapiParameters
+  ##
+  # Represents a parameter in an OpenAPI operation.
+  class Parameter
+    def initialize(definition)
+      check_supported!(definition)
+      @definition = definition
+    end
+
+    attr_reader :definition
+
+    def name
+      definition['name']
+    end
+
+    ##
+    # @return [String] The location of the parameter in the request, "path", "query", "header" or "cookie".
+    def location
+      definition['in']
+    end
+
+    alias in location
+
+    def schema
+      return definition.dig('content', media_type, 'schema') if media_type
+
+      definition['schema']
+    end
+
+    def media_type
+      definition['content']&.keys&.first
+    end
+
+    def type
+      schema && schema['type']
+    end
+
+    def primitive?
+      type != 'object' && type != 'array'
+    end
+
+    def array?
+      type == 'array'
+    end
+
+    def object?
+      type == 'object'
+    end
+
+    def style
+      return definition['style'] if definition['style']
+
+      DEFAULT_STYLE.fetch(location)
+    end
+
+    def required?
+      return true if location == 'path'
+
+      definition['required'] == true
+    end
+
+    def deprecated?
+      definition['deprecated'] == true
+    end
+
+    def allow_reserved?
+      definition['allowReserved'] == true
+    end
+
+    def explode?
+      return definition['explode'] if definition.key?('explode')
+      return true if style == 'form'
+
+      false
+    end
+
+    private
+
+    DEFAULT_STYLE = {
+      'query' => 'form',
+      'path' => 'simple',
+      'header' => 'simple',
+      'cookie' => 'form'
+    }.freeze
+    private_constant :DEFAULT_STYLE
+
+
+    VALID_LOCATIONS = Set.new(%w[query header path cookie]).freeze
+    private_constant :VALID_LOCATIONS
+
+    REF = '$ref'.freeze
+    private_constant :REF
+
+    def check_supported!(definition)
+      if definition.values.any? { |v| v.is_a?(Hash) && v.key?(REF) }
+        raise NotSupportedError,
+              "Parameter schema with $ref is not supported: #{definition.inspect}"
+      end
+      return if VALID_LOCATIONS.include?(definition['in'])
+
+      raise ArgumentError,
+            %(Parameter definition must have an 'in' property defined
+               which should be one of #{VALID_LOCATIONS.join(', ')}).freeze
+    end
+  end
+end

data/lib/openapi_parameters/path.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'uri_template'
+
+module OpenapiParameters
+  # Parses OpenAPI path parameters from path template strings and the request path.
+  class Path
+    # @param parameters [Array<Hash>] The OpenAPI path parameters.
+    # @param path [String] The OpenAPI path template string.
+    # @param convert [Boolean] Whether to convert the values to the correct type.
+    def initialize(parameters, path, convert: true)
+      @parameters = parameters
+      @path = path
+      @convert = convert
+    end
+
+    attr_reader :parameters, :path
+
+    def unpack(path_info)
+      parsed_path = URITemplate.new(url_template).extract(path_info) || {}
+      parameters.each_with_object(parsed_path) do |param, result|
+        parameter = Parameter.new(param)
+        next unless parsed_path.key?(parameter.name)
+
+        result[parameter.name] = catch :skip do
+          value = unpack_parameter(parameter, result)
+          @convert ? Converter.call(value, parameter.schema) : value
+        end
+      end
+    end
+
+    def unpack_parameter(parameter, parsed_path)
+      value = parsed_path[parameter.name]
+      if parameter.object? && value.is_a?(Array)
+        throw :skip, value if value.length.odd?
+        return Hash[*value]
+      end
+      value
+    end
+
+    def url_template
+      @url_template ||=
+        begin
+          path = @path.dup
+          parameters.each do |p|
+            param = Parameter.new(p)
+            next unless param.array? || param.object?
+
+            path.gsub!(
+              "{#{param.name}}",
+              "{#{operator(param)}#{param.name}#{modifier(param)}}"
+            )
+          end
+          path
+        end
+    end
+
+    private
+
+    LIST_OPS = { 'simple' => nil, 'label' => '.', 'matrix' => ';' }.freeze
+    private_constant :LIST_OPS
+
+    def operator(param)
+      LIST_OPS[param.style]
+    end
+
+    def modifier(param)
+      return '*' if param.explode?
+      return if param.style == 'matrix' && !param.explode?
+    end
+  end
+end

data/lib/openapi_parameters/query.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module OpenapiParameters
+  # Query parses query parameters from a http query strings.
+  class Query
+    # @param parameters [Array<Hash>] The OpenAPI query parameter definitions.
+    # @param convert [Boolean] Whether to convert the values to the correct type.
+    def initialize(parameters, convert: true)
+      @parameters = parameters
+      @convert = convert
+    end
+
+    def unpack(query_string) # rubocop:disable Metrics/AbcSize
+      parsed_query = Rack::Utils.parse_query(query_string)
+      parameters.each_with_object({}) do |parameter, result|
+        parameter = Parameter.new(parameter)
+        if parameter.style == 'deepObject' && parameter.object?
+          parsed_nested_query = Rack::Utils.parse_nested_query(query_string)
+          next unless parsed_nested_query.key?(parameter.name)
+
+          result[parameter.name] = convert(parsed_nested_query[parameter.name], parameter)
+        else
+          next unless parsed_query.key?(parameter.name)
+
+          unpacked = unpack_parameter(parameter, parsed_query)
+          result[parameter.name] = convert(unpacked, parameter)
+        end
+      end
+    end
+
+    attr_reader :parameters
+
+    private
+
+    def convert(value, parameter)
+      return value unless @convert
+      return value if value == ''
+
+      Converter.call(value, parameter.schema)
+    end
+
+    QUERY_PARAMETER_DELIMETER = '&'
+    ARRAY_DELIMER = ','
+
+    def unpack_parameter(parameter, parsed_query)
+      value = parsed_query[parameter.name]
+      return value if parameter.primitive? || value.nil?
+      return unpack_array(parameter, parsed_query) if parameter.array?
+      return unpack_object(parameter, parsed_query) if parameter.object?
+    end
+
+    def unpack_array(parameter, parsed_query)
+      value = parsed_query[parameter.name]
+      return value if value.empty?
+      return Array(value) if parameter.explode?
+
+      value.split(array_delimiter(parameter.style))
+    end
+
+    def unpack_object(parameter, parsed_query)
+      return parsed_query[parameter.name] if parameter.explode?
+
+      array = parsed_query[parameter.name]&.split(ARRAY_DELIMER)
+      return array if array.length.odd?
+
+      Hash[*array]
+    end
+
+    DELIMERS = {
+      'pipeDelimited' => '|',
+      'spaceDelimited' => ' ',
+      'form' => ',',
+      'simple' => ','
+    }.freeze
+
+    def array_delimiter(style)
+      DELIMERS.fetch(style, ARRAY_DELIMER)
+    end
+  end
+end

data/lib/openapi_parameters/version.rb

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

data/lib/openapi_parameters.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+# OpenapiParameters is a gem that parses OpenAPI parameters from Rack
+module OpenapiParameters
+end
+
+require_relative 'openapi_parameters/errors'

data/openapi_parameters.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'lib/openapi_parameters/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'openapi_parameters'
+  spec.version = OpenapiParameters::VERSION
+  spec.authors = ['Andreas Haller']
+  spec.email = ['andreas.haller@posteo.de']
+
+  spec.summary = 'OpenapiParameters is an OpenAPI aware parameter parser'
+  spec.description =
+    'OpenapiParameters parses HTTP query parameters exactly as described in an OpenAPI API description.'
+  spec.homepage = 'https://github.com/ahx/OpenapiParameters'
+  spec.required_ruby_version = '>= 3.1.0'
+  spec.licenses = ['MIT']
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/ahx/OpenapiParameters'
+  spec.metadata[
+    'changelog_uri'
+  ] = 'https://github.com/ahx/openapi_parameters/blob/main/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files =
+    Dir.chdir(__dir__) do
+      `git ls-files -z`.split("\x0")
+                       .reject do |f|
+        (f == __FILE__) ||
+          f.match(
+            %r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)}
+          )
+      end
+    end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'rack', '>= 2.2'
+  spec.add_dependency 'uri_template', '>= 0.7', '< 2.0'
+  spec.add_dependency 'zeitwerk', '~> 2.6'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/sig/openapi_parameters.rbs

@@ -0,0 +1,4 @@
+module OpenapiParameters
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: openapi_parameters
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andreas Haller
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: uri_template
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: OpenapiParameters parses HTTP query parameters exactly as described in
+  an OpenAPI API description.
+email:
+- andreas.haller@posteo.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".tool-versions"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/openapi_parameters.rb
+- lib/openapi_parameters/converter.rb
+- lib/openapi_parameters/cookie.rb
+- lib/openapi_parameters/errors.rb
+- lib/openapi_parameters/header.rb
+- lib/openapi_parameters/headers_hash.rb
+- lib/openapi_parameters/parameter.rb
+- lib/openapi_parameters/path.rb
+- lib/openapi_parameters/query.rb
+- lib/openapi_parameters/version.rb
+- openapi_parameters.gemspec
+- sig/openapi_parameters.rbs
+homepage: https://github.com/ahx/OpenapiParameters
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ahx/OpenapiParameters
+  source_code_uri: https://github.com/ahx/OpenapiParameters
+  changelog_uri: https://github.com/ahx/openapi_parameters/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: OpenapiParameters is an OpenAPI aware parameter parser
+test_files: []