openapi_first 0.19.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d09bae8b5126245d86fceeb81b2d0d46fb1a9e1cb10370527327edb3e370fe59
-  data.tar.gz: 2bd5e71bd8022506be07ab7c60b2740d490fc0f2a0995ded0f6a9c6dc4d165e3
+  metadata.gz: 0b8b03aaa251de1bdb5cbba71de089bf1ffc6b9dbb96512008f88e783c3cea27
+  data.tar.gz: 02eb6cec864e9b5ed272d4392b31fd9e006713d3a8b00df9b26e9a52fa68e555
 SHA512:
-  metadata.gz: 4d7d449f19fe40c49ea701eb28aca2a140ec41a5efb5be7433a5a60d85376a139a18c772ff34f211fbfb02e557ddddfdfad8ca547a695cb849bd62b69015775d
-  data.tar.gz: 6693234aab12e85893fedfa831ff21c831f00aa4040475a8a6e9fdbc5a2500e094f552ff1efef1c459af4df2eff21ad9f7ac4b6f93b2628f76d5f5169c4ad228
+  metadata.gz: e37e99e982f0ead9d54587683fa74491e69998f520b1cfb4993c9e1ee81273537dfdf1751c77daef856ab3c3051660589d2f8ac6e58508fd11d3ea130734d2a5
+  data.tar.gz: 6944ae2444da29928eeb12e70326505aa154f1c36a09f033083098b1e34be766b075257fd2459b94574370fa8cc417ef488f74dafcec6026eaab07a47f471445

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.0.5
   NewCops: enable
   SuggestExtensions: false
 Style/Documentation:

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## Unreleased
+
+## 0.21.0
+
+- Fix: Query parameter validation does not fail if header parameters are defined (Thanks to [JF Lalonde](https://github.com/JF-Lalonde))
+- Update Ruby dependency to >= 3.0.5
+- Handle simple form-data in request bodies (see https://github.com/ahx/openapi_first/issues/149)
+- Update to hanami-router 2.0.0 stable
+
+## 0.20.0
+
+- You can pass a filepath to `spec:` now so you no longer have to call `OpenapiFirst.load` anymore.
+- Router is optional now.
+  You no longer have to add `Router` to your middleware stack. You still can add it to customize behaviour by setting options, but you no longer have to add it.
+  If you don't add the Router, make sure you pass `spec:` to your request/response validation middleware.
+- Support "4xx" and "4XX" response definitions.
+  (4XX is defined in the standard, but 2xx is used in the wild as well 🦁.)
+- Removed warning about missing operationId, because operationId is not used until the Responder is used.
+- Raise HandlerNotFoundError when handler cannot be found
+
 ## 0.19.0
 
 - Add `RackResponder`
@@ -37,7 +57,7 @@ Yanked. No useful changes.
 
 ## 0.14.1
 
-- Bugfix: Don't mix path- and operation-level parameters for request validation
+- Fix: Don't mix path- and operation-level parameters for request validation
 
 ## 0.14.0
 

data/Gemfile.lock

@@ -1,10 +1,10 @@
 PATH
   remote: .
   specs:
-    openapi_first (0.19.0)
+    openapi_first (0.21.0)
       deep_merge (>= 1.2.1)
-      hanami-router (= 2.0.alpha5)
-      hanami-utils (= 2.0.alpha3)
+      hanami-router (~> 2.0.0)
+      hanami-utils (~> 2.0.0)
       json_refs (~> 0.1, >= 0.1.7)
       json_schemer (~> 0.2.16)
       multi_json (~> 1.14)
@@ -15,78 +15,84 @@ GEM
   specs:
     ast (2.4.2)
     coderay (1.1.3)
-    concurrent-ruby (1.1.10)
+    concurrent-ruby (1.2.2)
     deep_merge (1.2.2)
     diff-lcs (1.5.0)
-    dry-transformer (0.1.1)
+    dry-core (1.0.0)
+      concurrent-ruby (~> 1.0)
+      zeitwerk (~> 2.6)
+    dry-transformer (1.0.1)
+      zeitwerk (~> 2.6)
     ecma-re-validator (0.4.0)
       regexp_parser (~> 2.2)
     hana (1.3.7)
-    hanami-router (2.0.0.alpha5)
-      mustermann (~> 1.0)
-      mustermann-contrib (~> 1.0)
+    hanami-router (2.0.2)
+      mustermann (~> 3.0)
+      mustermann-contrib (~> 3.0)
       rack (~> 2.0)
-    hanami-utils (2.0.0.alpha3)
+    hanami-utils (2.0.3)
       concurrent-ruby (~> 1.0)
-      dry-transformer (~> 0.1)
+      dry-core (~> 1.0, < 2)
+      dry-transformer (~> 1.0, < 2)
     hansi (0.2.1)
-    json (2.6.2)
+    json (2.6.3)
     json_refs (0.1.7)
       hana
-    json_schemer (0.2.21)
+    json_schemer (0.2.24)
       ecma-re-validator (~> 0.3)
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       uri_template (~> 0.7)
     method_source (1.0.0)
     multi_json (1.15.0)
-    mustermann (1.1.2)
+    mustermann (3.0.0)
       ruby2_keywords (~> 0.0.1)
-    mustermann-contrib (1.1.2)
+    mustermann-contrib (3.0.0)
       hansi (~> 0.2.0)
-      mustermann (= 1.1.2)
+      mustermann (= 3.0.0)
     parallel (1.22.1)
-    parser (3.1.2.0)
+    parser (3.2.1.0)
       ast (~> 2.4.1)
-    pry (0.14.1)
+    pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    rack (2.2.4)
+    rack (2.2.6.2)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.5.0)
+    regexp_parser (2.7.0)
     rexml (3.2.5)
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.3)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
-    rubocop (1.32.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.45.1)
       json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 3.1.0.0)
+      parser (>= 3.2.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.19.1, < 2.0)
+      rubocop-ast (>= 1.24.1, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.19.1)
-      parser (>= 3.1.1.0)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.26.0)
+      parser (>= 3.2.1.0)
     ruby-progressbar (1.11.0)
     ruby2_keywords (0.0.5)
-    unicode-display_width (2.2.0)
+    unicode-display_width (2.4.2)
     uri_template (0.7.0)
+    zeitwerk (2.6.7)
 
 PLATFORMS
   arm64-darwin-21

data/README.md

@@ -18,42 +18,28 @@ Here's a [comparison between committee and openapi_first](https://gist.github.co
 
 OpenapiFirst consists of these Rack middlewares:
 
-- [`OpenapiFirst::Router`](#OpenapiFirst::Router) – Finds the OpenAPI operation for the current request or returns 404 if no operation was found. This can be customized.
 - [`OpenapiFirst::RequestValidation`](#OpenapiFirst::RequestValidation) – Validates the request against the API description and returns 400 if the request is invalid.
-- [`OpenapiFirst::Responder`](#OpenapiFirst::Responder) calls the [handler](#handlers) found for the operation, sets the correct content-type and serializes the response body to json if needed.
-- [`OpenapiFirst::RackResponder`](#OpenapiFirst::RackResponder) calls the [handler](#handlers) found for the operation as a normal Rack application (`call(env)`) and returns the result as is.
 - [`OpenapiFirst::ResponseValidation`](#OpenapiFirst::ResponseValidation) Validates the response and raises an exception if the response body is invalid.
+- [`OpenapiFirst::Router`](#OpenapiFirst::Router) – This internal middleware is added automatically before request/response validation. Finds the OpenAPI operation for the current request or returns 404 if no operation was found. This can be customized by adding it yourself.
 
-## OpenapiFirst::Router
-
-You always have to add this middleware first in order to make the other middlewares work.
-
-```ruby
-use OpenapiFirst::Router, spec: OpenapiFirst.load('./openapi/openapi.yaml')
-```
-
-This middleware adds `env[OpenapiFirst::OPERATION]` which holds an Operation object that responds to `#operation_id`, `#path` (and `#[]` to access raw fields).
-
-### Options and defaults
 
-| Name           | Possible values      | Description                                                                                                                                                                                                                                                     | Default                            |
-| :------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
-| `spec:`        |                      | The spec loaded via `OpenapiFirst.load`                                                                                                                                                                                                                         |                                    |
-| `raise_error:` | `false`, `true`      | If set to true the middleware raises `OpenapiFirst::NotFoundError` when a path or method was not found in the API description. This is useful during testing to spot an incomplete API description.                                                             | `false` (don't raise an exception) |
-| `not_found:`   | `:continue`, `:halt` | If set to `:continue` the middleware will not return 404 (405, 415), but just pass handling the request to the next middleware or application in the Rack stack. If combined with `raise_error: true` `raise_error` gets preference and an exception is raised. | `:halt` (return 4xx response)      |
+And these Rack apps:
+- [`OpenapiFirst::Responder`](#OpenapiFirst::Responder) calls the [handler](#handlers) found for the operation, sets the correct content-type and serializes the response body to json if needed.
+- [`OpenapiFirst::RackResponder`](#OpenapiFirst::RackResponder) calls the [handler](#handlers) found for the operation as a normal Rack application (`call(env)`) and returns the result as is.
 
 ## OpenapiFirst::RequestValidation
 
 This middleware returns a 400 status code with a body that describes the error if the request is not valid.
 
 ```ruby
-use OpenapiFirst::RequestValidation
+use OpenapiFirst::RequestValidation, spec: 'openapi.yaml'
 ```
 
 ### Options and defaults
 
 | Name           | Possible values | Description                                                                                        | Default                            |
 | :------------- | --------------- | -------------------------------------------------------------------------------------------------- | ---------------------------------- |
+| `spec:`        |                      | The path to the spec file or spec loaded via `OpenapiFirst.load`
 | `raise_error:` | `false`, `true` | If set to true the middleware raises `OpenapiFirst::RequestInvalidError` instead of returning 4xx. | `false` (don't raise an exception) |
 
 The error responses conform with [JSON:API](https://jsonapi.org).
@@ -107,21 +93,38 @@ Request validation fails if request includes a property with `readOnly: true`.
 
 Response validation fails if response body includes a property with `writeOnly: true`.
 
-## OpenapiFirst::Responder
+## OpenapiFirst::ResponseValidation
+
+This middleware is especially useful when testing. It _always_ raises an error if the response is not valid.
 
-This Rack endpoint maps the HTTP request to a method call based on the [operationId](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#operation-object) in your API description and calls it. Responder also adds a content-type to the response.
 
 ```ruby
-run OpenapiFirst::Responder
+use OpenapiFirst::ResponseValidation, spec: 'openapi.yaml' if ENV['RACK_ENV'] == 'test'
 ```
 
 ### Options
 
-| Name         | Description                                                                                                                                                                                       |
-| :----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `namespace:` | Optional. A class or module where to find the handler method.                                                                                                                                     |
-| `resolver:`  | Optional. An object that responds to `#call(operation)` and returns a [handler](#handlers). By default this is an instance of [DefaultOperationResolver](#OpenapiFirst::DefaultOperationResolver) |
+| Name           | Possible values      | Description                                                                                                                                                                                                                                                     | Default                            |
+| :------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
+| `spec:`        |                      | The path to the spec file or spec loaded via `OpenapiFirst.load`
+
+## OpenapiFirst::Router
+
+This middleware is used automatically, but you can add it to the top of your middleware stack if you want to change configuration.
 
+```ruby
+use OpenapiFirst::Router, spec: './openapi/openapi.yaml'
+```
+
+This middleware adds `env[OpenapiFirst::OPERATION]` which holds an Operation object that responds to `#operation_id`, `#path` (and `#[]` to access raw fields).
+
+### Options and defaults
+
+| Name           | Possible values      | Description                                                                                                                                                                                                                                                     | Default                            |
+| :------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
+| `spec:`        |                      | The path to the spec file or spec loaded via `OpenapiFirst.load` |                                    |
+| `raise_error:` | `false`, `true`      | If set to true the middleware raises `OpenapiFirst::NotFoundError` when a path or method was not found in the API description. This is useful during testing to spot an incomplete API description.                                                             | `false` (don't raise an exception) |
+| `not_found:`   | `:continue`, `:halt` | If set to `:continue` the middleware will not return 404 (405, 415), but just pass handling the request to the next middleware or application in the Rack stack. If combined with `raise_error: true` `raise_error` gets preference and an exception is raised. | `:halt` (return 4xx response)      |
 
 ## OpenapiFirst::RackResponder
 
@@ -139,6 +142,20 @@ run OpenapiFirst::RackResponder
 | `namespace:` | Optional. A class or module where to find the handler method.                                                                                                                                     |
 | `resolver:`  | Optional. An object that responds to `#call(operation)` and returns a [handler](#handlers). By default this is an instance of [DefaultOperationResolver](#OpenapiFirst::DefaultOperationResolver) |
 
+## OpenapiFirst::Responder
+
+This Rack endpoint maps the HTTP request to a method call based on the [operationId](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#operation-object) in your API description and calls it. Responder also adds a content-type to the response.
+
+```ruby
+run OpenapiFirst::Responder
+```
+
+### Options
+
+| Name         | Description                                                                                                                                                                                       |
+| :----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `namespace:` | Optional. A class or module where to find the handler method.                                                                                                                                     |
+| `resolver:`  | Optional. An object that responds to `#call(operation)` and returns a [handler](#handlers). By default this is an instance of [DefaultOperationResolver](#OpenapiFirst::DefaultOperationResolver) |
 
 ### OpenapiFirst::DefaultOperationResolver
 
@@ -164,14 +181,6 @@ There are two ways to set the response body:
 - Calling `res.write "things"` (see [Rack::Response](https://www.rubydoc.info/github/rack/rack/Rack/Response))
 - Returning a value which will get converted to JSON
 
-## OpenapiFirst::ResponseValidation
-
-This middleware is especially useful when testing. It _always_ raises an error if the response is not valid.
-
-```ruby
-use OpenapiFirst::ResponseValidation if ENV['RACK_ENV'] == 'test'
-```
-
 ## Standalone usage
 
 Instead of composing these middlewares yourself you can use `OpenapiFirst.app`.
@@ -248,8 +257,7 @@ Instead of using the ResponseValidation middleware you can validate the response
 ```ruby
 # In your test (rspec example):
 require 'openapi_first'
-spec = OpenapiFirst.load('petstore.yaml')
-validator = OpenapiFirst::ResponseValidator.new(spec)
+validator = OpenapiFirst::ResponseValidator.new('petstore.yaml')
 
 # This will raise an exception if it found an error
 validator.validate(last_request, last_response)
@@ -260,7 +268,7 @@ validator.validate(last_request, last_response)
 You can filter the URIs that should be handled by passing `only` to `OpenapiFirst.load`:
 
 ```ruby
-spec = OpenapiFirst.load './openapi/openapi.yaml', only: '/pets'.method(:==)
+spec = OpenapiFirst.load('./openapi/openapi.yaml', only: { |path| path.starts_with? '/pets' })
 run OpenapiFirst.app(spec, namespace: Pets)
 ```
 
@@ -278,8 +286,7 @@ describe MyApp do
   include Rack::Test::Methods
 
   before(:all) do
-    spec = OpenapiFirst.load('petstore.yaml')
-    @app_wrapper = OpenapiFirst::Coverage.new(MyApp, spec)
+    @app_wrapper = OpenapiFirst::Coverage.new(MyApp, 'petstore.yaml')
   end
 
   after(:all) do

data/benchmarks/Gemfile

@@ -10,6 +10,7 @@ gem 'hanami-api'
 gem 'hanami-router'
 gem 'multi_json'
 gem 'openapi_first', path: '../'
+gem 'puma'
 gem 'roda'
 gem 'sinatra'
 gem 'syro'

data/benchmarks/Gemfile.lock

@@ -1,10 +1,10 @@
 PATH
   remote: ..
   specs:
-    openapi_first (0.19.0)
+    openapi_first (0.21.0)
       deep_merge (>= 1.2.1)
-      hanami-router (= 2.0.alpha5)
-      hanami-utils (= 2.0.alpha3)
+      hanami-router (~> 2.0.0)
+      hanami-utils (~> 2.0.0)
       json_refs (~> 0.1, >= 0.1.7)
       json_schemer (~> 0.2.16)
       multi_json (~> 1.14)
@@ -13,43 +13,40 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.2.3)
+    activesupport (7.0.4.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
-    benchmark-ips (2.10.0)
+    benchmark-ips (2.11.0)
     benchmark-memory (0.2.0)
       memory_profiler (~> 1)
     builder (3.2.4)
-    committee (4.4.0)
+    committee (5.0.0)
       json_schema (~> 0.14, >= 0.14.3)
-      openapi_parser (>= 0.11.1, < 1.0)
+      openapi_parser (~> 1.0)
       rack (>= 1.5)
-    concurrent-ruby (1.1.10)
+    concurrent-ruby (1.2.0)
     deep_merge (1.2.2)
-    dry-configurable (0.14.0)
+    dry-core (1.0.0)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.6)
-    dry-container (0.9.0)
+      zeitwerk (~> 2.6)
+    dry-inflector (1.0.0)
+    dry-logic (1.5.0)
       concurrent-ruby (~> 1.0)
-      dry-configurable (~> 0.13, >= 0.13.0)
-    dry-core (0.7.1)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-transformer (1.0.1)
+      zeitwerk (~> 2.6)
+    dry-types (1.7.0)
       concurrent-ruby (~> 1.0)
-    dry-inflector (0.2.1)
-    dry-logic (1.2.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.5, >= 0.5)
-    dry-transformer (0.1.1)
-    dry-types (1.5.1)
-      concurrent-ruby (~> 1.0)
-      dry-container (~> 0.3)
-      dry-core (~> 0.5, >= 0.5)
-      dry-inflector (~> 0.1, >= 0.1.2)
-      dry-logic (~> 1.0, >= 1.0.2)
+      dry-core (~> 1.0, < 2)
+      dry-inflector (~> 1.0, < 2)
+      dry-logic (>= 1.4, < 2)
+      zeitwerk (~> 2.6)
     ecma-re-validator (0.4.0)
       regexp_parser (~> 2.2)
-    grape (1.6.2)
+    grape (1.7.0)
       activesupport
       builder
       dry-types (>= 1.1)
@@ -57,59 +54,64 @@ GEM
       rack (>= 1.3.0)
       rack-accept
     hana (1.3.7)
-    hanami-api (0.2.0)
-      hanami-router (~> 2.0.alpha)
-    hanami-router (2.0.0.alpha5)
-      mustermann (~> 1.0)
-      mustermann-contrib (~> 1.0)
+    hanami-api (0.3.0)
+      hanami-router (~> 2.0)
+    hanami-router (2.0.2)
+      mustermann (~> 3.0)
+      mustermann-contrib (~> 3.0)
       rack (~> 2.0)
-    hanami-utils (2.0.0.alpha3)
+    hanami-utils (2.0.3)
       concurrent-ruby (~> 1.0)
-      dry-transformer (~> 0.1)
-    hansi (0.2.0)
-    i18n (1.10.0)
+      dry-core (~> 1.0, < 2)
+      dry-transformer (~> 1.0, < 2)
+    hansi (0.2.1)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     json_refs (0.1.7)
       hana
     json_schema (0.21.0)
-    json_schemer (0.2.21)
+    json_schemer (0.2.24)
       ecma-re-validator (~> 0.3)
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       uri_template (~> 0.7)
-    memory_profiler (1.0.0)
-    minitest (5.15.0)
+    memory_profiler (1.0.1)
+    minitest (5.17.0)
     multi_json (1.15.0)
-    mustermann (1.1.1)
+    mustermann (3.0.0)
       ruby2_keywords (~> 0.0.1)
-    mustermann-contrib (1.1.1)
+    mustermann-contrib (3.0.0)
       hansi (~> 0.2.0)
-      mustermann (= 1.1.1)
-    mustermann-grape (1.0.1)
+      mustermann (= 3.0.0)
+    mustermann-grape (1.0.2)
       mustermann (>= 1.0.0)
-    openapi_parser (0.15.0)
-    rack (2.2.3.1)
+    nio4r (2.5.8)
+    openapi_parser (1.0.0)
+    puma (6.1.0)
+      nio4r (~> 2.0)
+    rack (2.2.6.2)
     rack-accept (0.4.5)
       rack (>= 0.4)
-    rack-protection (2.2.0)
+    rack-protection (3.0.5)
       rack
-    regexp_parser (2.5.0)
-    roda (3.54.0)
+    regexp_parser (2.7.0)
+    roda (3.65.0)
       rack
     ruby2_keywords (0.0.5)
     seg (1.2.0)
-    sinatra (2.2.0)
-      mustermann (~> 1.0)
-      rack (~> 2.2)
-      rack-protection (= 2.2.0)
+    sinatra (3.0.5)
+      mustermann (~> 3.0)
+      rack (~> 2.2, >= 2.2.4)
+      rack-protection (= 3.0.5)
       tilt (~> 2.0)
     syro (3.2.1)
       rack (>= 1.6.0)
       seg
-    tilt (2.0.10)
-    tzinfo (2.0.4)
+    tilt (2.0.11)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     uri_template (0.7.0)
+    zeitwerk (2.6.7)
 
 PLATFORMS
   arm64-darwin-21
@@ -124,6 +126,7 @@ DEPENDENCIES
   hanami-router
   multi_json
   openapi_first!
+  puma
   roda
   sinatra
   syro

data/benchmarks/README.md

@@ -0,0 +1,29 @@
+# How to run these bechmarks
+
+## Setup
+
+```bash
+cd benchmarks
+bundle install
+```
+
+## Run Ruby benchmarks
+
+This compares ips and memory usage for all apps defined in /apps
+
+```bash
+bundle exec ruby benchmarks.rb
+```
+
+## Run benchmark using [wrk](https://github.com/wg/wrk)
+
+1. Start the example app
+Example: openapi_first
+```bash
+bundle exec puma apps/openapi_first_with_response_validation.ru
+```
+
+2. Run wrk
+```bash
+./benchmark-wrk.sh
+```