linzer 0.7.9.beta1 → 0.7.9.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e68e3de6c89b69da86e383a47e365ab275597440ac71ffb6ce261cd10ad9f51
-  data.tar.gz: d036d8264a8bba7a7d964432e187725da146f228ee81335d3db5c3659d1578ee
+  metadata.gz: f13471dec9f1ca620ac5fa94faeb2173632bec2aede20fbb1e156988c48fd10d
+  data.tar.gz: 4dffdf98551884ea0a1b11c892ef1cb2ee5cad1fb6234e1d54890feea210a898
 SHA512:
-  metadata.gz: b635cf2b46a0235a7e4131719b225df2a8c03b689c175baf4d9d234dcb1e1ad9f2b4ad1b52da19296444e2883064dbf11e69509ebce96695e3ee51fe7aa31f45
-  data.tar.gz: 729797295ce7a27128046cd6ae9714d0a74e6ba64f3db74e9f4fe48106548fd911c60a2f9442e387a5a04e82c54644294587f5b61e2d3aaa21d6a09aa5e1681e
+  metadata.gz: 1ca361d6e8dbc9d1960f37f33785a56cb7cd5a22a61d9fbe44228541c5cf54791acc21d9d19b4fb9a078322855776686d42aff86bbc05d4014cc017669375e9a
+  data.tar.gz: 89979f2b5c0e2d2a527cb04e223879f543a26c0cc81ef702ce5c3858c8f241126a38d28aeb9070bacebfbfdf488eae75e5e75f9fd0a242b5e04dfa12c76f6d6d

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.7.9.beta2] - 2026-04-19
+
+- Add support for http gem 6.x while maintaining compatibility with 5.x.
+  Handles API differences introduced in 6.0.
+- Improve README clarity and align it with current behavior and production usage.
+
 ## [0.7.9.beta1] - 2026-03-03
 
 (Beta release to test gem release automation; no functional changes)

data/README.md

@@ -9,7 +9,12 @@
 [rubydoc-badge]: https://img.shields.io/badge/docs-RubyDoc.info-blue
 [rubydoc-link]: https://www.rubydoc.info/gems/linzer
 
-Linzer is a Ruby library for [HTTP Message Signatures (RFC 9421)](https://www.rfc-editor.org/rfc/rfc9421.html).
+Linzer is a Ruby library for [HTTP Message Signatures (RFC 9421)](https://www.rfc-editor.org/rfc/rfc9421.html),
+allowing you to sign and verify HTTP requests and responses with
+standard-compliant cryptographic signatures.
+
+Useful for APIs, webhooks, and services that need to verify request
+authenticity or prevent tampering.
 
 ## Install
 
@@ -23,48 +28,79 @@ Or just `gem install linzer`.
 
 ## Usage
 
-### TL;DR: I just want to protect my application!!
+### Quick start
 
-Add the following middleware to your Rack application and configure it
-as needed, e.g.:
+Add the middleware to your Rack application:
 
 ```ruby
 # config.ru
-use Rack::Auth::Signature, except: "/login",
-  default_key: {material: Base64.strict_decode64(ENV["MYAPP_KEY"]), alg: "hmac-sha256"}
-  # or: default_key: {material: IO.read("app/config/pubkey.pem"), "ed25519"}
+use Rack::Auth::Signature,
+  except: "/login",
+  default_key: {
+    material: Base64.strict_decode64(ENV["MYAPP_KEY"]),
+    alg: "hmac-sha256"
+  }
+  # or using a public/private key pair:
+  # default_key: { material: IO.read("app/config/pubkey.pem"), alg: "ed25519" }
 ```
 
-or on more complex scenarios:
+In this example, the middleware requires a valid HTTP Message Signature
+for all endpoints except /login.
+
+To learn how to sign requests, see the
+[Signing Requests](#signing-http-requests-and-responses) section.
+
+#### Using a configuration file
+
+For more complex setups, you can load configuration from a file, e.g.:
 
 ```ruby
 # config.ru
-use Rack::Auth::Signature, except: "/login",
+use Rack::Auth::Signature,
+  except: "/login",
   config_path: "app/configuration/http-signatures.yml"
 ```
 
-or with a typical Rails application:
+#### Rails
+
+In a Rails application, add the middleware in your configuration:
 
 ```ruby
 # config/application.rb
-config.middleware.use Rack::Auth::Signature, except: "/login",
+config.middleware.use Rack::Auth::Signature,
+  except: "/login",
   config_path: "http-signatures.yml"
 ```
 
-And that's it, all routes in the example app (except `/login`) above will
-require a valid signature created with the respective private key held by a
-client. For more details on what configuration options are available, take a
-look at
-[examples/sinatra/http-signatures.yml](https://github.com/nomadium/linzer/tree/master/examples/sinatra/http-signatures.yml) to get started and/or
-[lib/rack/auth/signature.rb](https://github.com/nomadium/linzer/tree/master/lib/rack/auth/signature.rb) for full implementation details.
+#### What this does?
+
+Once enabled, all protected routes will require a valid signature
+generated by a client using the corresponding private key. Requests
+without a valid signature will be rejected.
+
+#### Next steps
+
+- See a full configuration example:
+[examples/sinatra/http-signatures.yml](https://github.com/nomadium/linzer/tree/master/examples/sinatra/http-signatures.yml)
+
+- Browse the middleware implementation for all options:
+[lib/rack/auth/signature.rb](https://github.com/nomadium/linzer/tree/master/lib/rack/auth/signature.rb)
+
+- For more specific scenarios and use cases, continue below.
+
+### Signing HTTP requests and responses
 
-To learn about more specific scenarios or use cases, keep reading on below.
+Linzer signs HTTP requests by adding the required `Signature` and
+`Signature-Input` headers based on selected request components (e.g.
+method, path, headers, etc).
 
-### To sign a HTTP request:
+Choose your client:
 
-There are several options:
+- Use the [http gem](https://github.com/httprb/http) → recommended (simplest)
+- Use `Net::HTTP` → lower-level control
+- Use `Linzer::HTTP` → quick experiments / debugging
 
-#### If you are using http gem:
+#### Using [http gem](https://github.com/httprb/http)
 
 ```ruby
 # first require http signatures feature class ready to be used with http gem:
@@ -85,7 +121,7 @@ response.body.to_s
 => "protected content..."
 ```
 
-#### If you are using plain old Net::HTTP:
+#### Using `Net::HTTP` (manual control)
 
 ```ruby
 key = Linzer.generate_ed25519_key
@@ -111,7 +147,7 @@ request["signature-input"]
 # => "sig1=(\"@method\" \"@request-target\" \"date\" ..."}
 ```
 
-Then you can submit the signed request with Net::HTTP client:
+Then send the request:
 
 ```ruby
 require "net/http"
@@ -152,10 +188,7 @@ response = http.request(request)
 # => #<Net::HTTPOK 200 OK readbody=true>
 ```
 
-#### Or you can also use the simple HTTP client bundled with this library:
-
-(This client is probably not suitable for production use but could be useful
-enough to get started. It's build on top of Net::HTTP.)
+#### Using the built-in client
 
 ```ruby
 key = Linzer.generate_rsa_pss_sha512_key(4096)
@@ -172,13 +205,62 @@ response =
 => #<Net::HTTPOK 200 OK readbody=true>
 ```
 
-### To verify an incoming request on the server side:
+(This client is intended for testing and exploration.
+For production use, prefer a full-featured HTTP client).
 
-The middleware `Rack::Auth::Signature` can be used for this scenario
-[as shown above](#tldr-i-just-want-to-protect-my-application).
+#### Signing HTTP responses (server-side)
 
-Or directly in the application controller (or routes), the incoming request can
-be verified with the following approach:
+You can sign responses using the same API as for requests, e.g.:
+
+```ruby
+put "/baz" do
+  ...
+  response
+  # => #<Sinatra::Response:0x0000000109ac40b8 ...
+  response.headers["x-custom-app-header"] = "..."
+  Linzer.sign!(response,
+    key: my_key,
+    components: %w[@status content-type content-digest x-custom-app-header],
+    label: "sig1",
+    params: {
+      created: Time.now.to_i
+    }
+  )
+  response["signature"]
+  # => "sig1=:2TPCzD4l48bg6LMcVXdV9u..."
+  response["signature-input"]
+  # => "sig1=(\"@status\" \"content-type\" \"content-digest\"..."
+  ...
+end
+```
+
+### Verifying HTTP signatures
+
+Linzer verifies incoming requests (or responses) by checking:
+
+- the signature is valid for the given key
+- the signed components match the actual request
+- any signature parameters (e.g. created, expires) are valid
+
+If verification fails, an exception is raised explaining the reason.
+
+#### Recommended: Rack middleware
+
+The easiest way to verify incoming requests is via middleware:
+
+```ruby
+use Rack::Auth::Signature, except: "/login"
+```
+
+This automatically:
+
+- verifies all incoming requests
+- rejects invalid or unsigned requests
+- integrates cleanly with Rack-based frameworks (Rails, Sinatra, etc.)
+
+#### Manual verification (controller / route level)
+
+If you need more control, you can verify incoming requests manually:
 
 ```ruby
 post "/foo" do
@@ -190,18 +272,31 @@ post "/foo" do
   #   "PATH_INFO" => "/api",
   # ...
 
-  result = Linzer.verify!(request, key: some_client_key)
+  result = Linzer.verify!(request, key: some_client_key) rescue false
   # => true
   ...
+  # proceed with trusted request
 end
 ```
 
-If the signature is missing or invalid, the verification method will raise an
-exception with a message clarifying why the request signature failed verification.
+If the signature is missing or invalid, verify! will raise an exception.
 
-Also, for additional flexibility on the server side, the method above can take
-a block with the `keyid` parameter extracted from the signature (if any) as argument.
-This can be useful to retrieve key data from databases/caches on the server side, e.g.:
+```ruby
+head "/bar" do
+  begin
+    Linzer.verify!(request, key: key)
+  rescue Linzer::VerifyError => e
+    halt 401, e.message
+  end
+end
+```
+
+#### Dynamic key lookup
+
+In many cases, the verification key depends on the `keyid` parameter provided in
+the signature.
+
+You can supply a block to resolve keys dynamically:
 
 ```ruby
 get "/bar" do
@@ -211,14 +306,22 @@ get "/bar" do
   end
   # => true
   ...
+  # request is now verified
 end
 ```
 
-### To verify a received response on the client side:
+This is useful when:
+
+- you have multiple clients
+- keys are stored in a database or external service
+- keys rotate over time
 
-It's similar to verifying requests, the same method is used, see example below:
+#### Verifying responses (client-side)
+
+As expected, signed responses are verified using the same API shown previously:
 
 ```ruby
+...
 response
 # => #<Net::HTTPOK 200 OK readbody=true>
 response.body
@@ -228,43 +331,26 @@ result = Linzer.verify!(response, key: pubkey, no_older_than: 600)
 # => true
 ```
 
-### To sign an outgoing response on the server side:
+### Using a custom HTTP library
 
-Again, the same principle used to sign outgoing requests, the same method is used,
-see example below:
+If you’re using an HTTP library or framework other than Rack, http gem or
+`Net::HTTP`, you can plug in your own adapter with very little effort.
 
-```ruby
-put "/baz" do
-  ...
-  response
-  # => #<Sinatra::Response:0x0000000109ac40b8 ...
-  response.headers["x-custom-app-header"] = "..."
-  Linzer.sign!(response,
-    key: my_key,
-    components: %w[@status content-type content-digest x-custom-app-header],
-    label: "sig1",
-    params: {
-      created: Time.now.to_i
-    }
-  )
-  response["signature"]
-  # => "sig1=:2TPCzD4l48bg6LMcVXdV9u..."
-  response["signature-input"]
-  # => "sig1=(\"@status\" \"content-type\" \"content-digest\"..."
-  ...
-end
-```
+In most cases, implementing an adapter just means mapping your library’s
+request/response objects to the small interface Linzer expects,
+then registering it.
+
+To do this:
+
+- implement a simple adapter for your request/response objects
+- register it with `Linzer::Message`
 
-### What do you do if you want to sign/verify requests and responses with your preferred HTTP ruby library/framework (not using Rack or `Net::HTTP`, for example)?
+You can use the existing adapters as references:
 
-You can provide an adapter class and then register it with this library.
-For guidance on how to implement such adapters, you can consult an
-[example adapter for http gem response](https://github.com/nomadium/linzer/blob/master/lib/linzer/message/adapter/http_gem/response.rb)
-included with this gem or the ones
-[provided out of the box](https://github.com/nomadium/linzer/blob/master/lib/linzer/message/adapter).
+- [HTTP gem response adapter](https://github.com/nomadium/linzer/blob/master/lib/linzer/message/adapter/http_gem/response.rb)
+- [Built-in adapters](https://github.com/nomadium/linzer/blob/master/lib/linzer/message/adapter)
 
-For how to register a custom adapter and how to verify signatures in a response,
-see this example:
+Example of how to register an adapter before using a custom HTTP library:
 
 ```ruby
 Linzer::Message.register_adapter(HTTP::Response, Linzer::Message::Adapter::HTTPGem::Response)
@@ -278,22 +364,19 @@ response["signature-input"]
 result = Linzer.verify!(response, key: my_key)
 # => true
 ```
----
 
-Furthermore, on some low-level scenarios where a user wants or needs additional
-control on how the signing and verification routines are performed, Linzer allows
-to manipulate instances of internal HTTP messages (requests & responses, see
-`Linzer::Message` class and available adapters), signature objects
-(`Linzer::Signature`) and how to register additional message adapters for any
-HTTP ruby library not supported out of the box by this gem.
+### Advanced verification
 
-See below for a few examples of these scenarios.
+For low-level control over signing and verification, Linzer
+exposes internal message and signature objects. This allows
+you to work directly with `Linzer::Message` and `Linzer::Signature`,
+or integrate custom HTTP adapters if needed.
 
-#### To verify a valid signature:
+#### Verifying a signature manually
 
 ```ruby
 test_ed25519_key_pub = key.material.public_to_pem
-# => "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAK1ZrC4JqC356pRsUiLVJdFZ3dAjo909VfWs1li33MCQ=\n-----END PUBLIC KEY-----\n"
+# => "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAK1ZrC4JqC356pRs..."
 
 pubkey = Linzer.new_ed25519_public_key(test_ed25519_key_pub, "some-key-ed25519")
 # => #<Linzer::Ed25519::Key:0x00000fe19b9384b0
@@ -306,53 +389,45 @@ Linzer.verify(pubkey, message, signature)
 # => true
 ```
 
-To mitigate the risk of "replay attacks" (i.e. an attacker capturing a message with a valid signature and re-sending it at a later point) applications may want to validate the `created` parameter of the signature. Linzer can do this automatically when given the optional `no_older_than` keyword argument:
+#### Preventing replay attacks
 
-```ruby
-Linzer.verify(pubkey, message, signature, no_older_than: 500)
-```
+To reduce the risk of replay attacks (e.g. reusing a captured
+valid request), you can validate the `created` timestamp in the signature.
 
-`no_older_than` expects a number of seconds, but you can pass anything that to responds to `#to_i`, including an `ActiveSupport::Duration`.
-`::verify` will raise if the `created` parameter of the signature is older than the given number of seconds.
-
-#### What if an invalid signature if verified?
+Linzer supports this via the `no_older_than` option:
 
 ```ruby
-result = Linzer.verify(pubkey, message, signature)
-lib/linzer/verifier.rb:38:in `verify_or_fail': Failed to verify message: Invalid signature. (Linzer::Error)
+Linzer.verify(pubkey, message, signature, no_older_than: 500)
 ```
 
-#### HTTP responses are also supported
+`no_older_than` expects a number of seconds, but you can pass
+anything that to responds to `#to_i`, including an `ActiveSupport::Duration`.
 
-HTTP responses can also be signed and verified in the same way as requests.
+If the signature is older than the allowed window, verification
+fails with an error.
 
-```ruby
-headers = {
-  "date" => "Sat, 30 Mar 2024 21:40:13 GMT",
-  "x-response-custom" => "bar"
-}
+## Supported algorithms
 
-response = Linzer.new_response("request body", 200, headers)
-# or just use the response object exposed by your HTTP framework
+Linzer currently supports the following signature algorithms:
 
-message = Linzer::Message.new(response)
-fields  = %w[@status date x-response-custom]
+- RSASSA-PSS (SHA-512)
+- RSASSA-PKCS1-v1_5 (SHA-256)
+- HMAC-SHA256
+- Ed25519
+- ECDSA (P-256 and P-384 curves).
 
-signature = Linzer.sign(key, message, fields)
+Of the JSON Web Signature (JWS) algorithms mentioned in RFC 9421,
+only Ed25519 is currently supported. Support for additional
+algorithms is planned and should be straightforward to add.
 
-pp signature.to_h
-# => {"signature"=>
-#   "sig1=:tCldwXqbISktyABrmbhszo...",
-#  "signature-input"=>"sig1=(\"@status\" \"date\" ..."}
-
-```
+The goal is to support as much of the RFC as possible before the 1.0 release.
 
-For now, to consult additional details just take a look at source code and/or the unit tests.
+## Documentation
 
-Please note that is still early days and extensive testing is still ongoing. For now the following algorithms are supported: RSASSA-PSS using SHA-512, RSASSA-PKCS1-v1_5 using SHA-256, HMAC-SHA256, Ed25519 and ECDSA (P-256 and P-384 curves). JSON Web Signature (JWS) algorithms mentioned in the RFC are not supported yet.
+The codebase is well-documented, and the Ruby API documentation is
+available on [Rubydoc](https://www.rubydoc.info/gems/linzer).
 
-I'll be expanding the library to cover more functionality specified in the RFC
-in subsequent releases.
+For deeper details or edge cases, the source code and unit tests are also a good reference.
 
 ## Ruby version compatibility
 
@@ -360,7 +435,17 @@ linzer is built in [Continuous Integration](https://github.com/nomadium/linzer/a
 
 ## Security
 
-This gem is provided “as is” without any warranties. It has not been audited for security vulnerabilities. Users are advised to review the code and assess its suitability for their use case, particularly in production environments.
+This gem is provided “as is” without any warranties. It has not
+been independently audited for security vulnerabilities. Users
+are advised to review the code and assess its suitability for their
+use case, particularly in production environments.
+
+Despite this, Linzer is already used in production by other projects
+with security-sensitive requirements, including
+[Mastodon](https://github.com/mastodon/mastodon)
+([since version 4.5.0](https://docs.joinmastodon.org/spec/security/#http-message-signatures)).
+This does not constitute a security guarantee or endorsement,
+but it may be useful context when evaluating adoption.
 
 ## Development
 

data/flake.lock

@@ -2,7 +2,9 @@
   "nodes": {
     "bundix": {
       "inputs": {
-        "nixpkgs": "nixpkgs"
+        "nixpkgs": [
+          "nixpkgs"
+        ]
       },
       "locked": {
         "lastModified": 1762235257,
@@ -20,25 +22,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1761880412,
-        "narHash": "sha256-QoJjGd4NstnyOG4mm4KXF+weBzA2AH/7gn1Pmpfcb0A=",
+        "lastModified": 1775710090,
+        "narHash": "sha256-ar3rofg+awPB8QXDaFJhJ2jJhu+KqN/PRCXeyuXR76E=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "a7fc11be66bdfb5cdde611ee5ce381c183da8386",
-        "type": "github"
-      },
-      "original": {
-        "id": "nixpkgs",
-        "type": "indirect"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1770115704,
-        "narHash": "sha256-KHFT9UWOF2yRPlAnSXQJh6uVcgNcWlFqqiAZ7OVlHNc=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "e6eae2ee2110f3d31110d5c222cd395303343b08",
+        "rev": "4c1018dae018162ec878d42fec712642d214fdfa",
         "type": "github"
       },
       "original": {
@@ -48,31 +36,19 @@
         "type": "github"
       }
     },
-    "nixpkgs_3": {
-      "locked": {
-        "lastModified": 1678875422,
-        "narHash": "sha256-T3o6NcQPwXjxJMn2shz86Chch4ljXgZn746c2caGxd8=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "126f49a01de5b7e35a43fd43f891ecf6d3a51459",
-        "type": "github"
-      },
-      "original": {
-        "id": "nixpkgs",
-        "type": "indirect"
-      }
-    },
     "root": {
       "inputs": {
         "bundix": "bundix",
-        "nixpkgs": "nixpkgs_2",
+        "nixpkgs": "nixpkgs",
         "ruby-nix": "ruby-nix",
         "systems": "systems"
       }
     },
     "ruby-nix": {
       "inputs": {
-        "nixpkgs": "nixpkgs_3"
+        "nixpkgs": [
+          "nixpkgs"
+        ]
       },
       "locked": {
         "lastModified": 1755059052,

data/flake.nix

@@ -1,11 +1,23 @@
 {
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-    # XXX: should work, not tested yet on MacOS
-    # systems.url = "github:nix-systems/default";
-    systems.url = "github:nix-systems/default-linux";
-    ruby-nix.url = "github:inscapist/ruby-nix";
-    bundix.url = "github:inscapist/bundix";
+
+    systems = {
+      url = "github:nix-systems/default-linux";
+      # XXX: should work, not tested yet on MacOS
+      # url = "github:nix-systems/default";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
+    ruby-nix = {
+      url = "github:inscapist/ruby-nix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
+    bundix = {
+      url = "github:inscapist/bundix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
   };
 
   outputs = {

data/lib/linzer/message/adapter/http_gem/common.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Linzer
+  class Message
+    module Adapter
+      # http.rb gem message adapters.
+      #
+      # Provides adapters for {HTTP::Request} and {HTTP::Response} objects
+      # from the http.rb gem.
+      #
+      # @note These adapters are loaded on-demand when using the
+      #   {Linzer::HTTP::SignatureFeature}.
+      module HTTPGem
+        # Shared functionality for http.rb request and response adapters.
+        module Common
+          # Retrieves a header value by name.
+          # @param name [String] The header name
+          # @return [String, nil] The header value
+          def header(name)
+            @operation.headers[name]
+          end
+
+          # Attaches a signature to the response.
+          # @param signature [Signature] The signature to attach
+          # @return [Object] The underlying response object
+          def attach!(signature)
+            signature.to_h.each { |h, v| @operation.headers[h] = v }
+            @operation
+          end
+
+          private
+
+          def field(name)
+            has_tr = name.parameters["tr"]
+            return nil if has_tr # XXX: is there a library actually supporting trailers?
+            value = @operation.headers[name.value.to_s]
+            value.dup&.strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linzer/message/adapter/http_gem/request.rb

@@ -1,24 +1,22 @@
 # frozen_string_literal: true
 
+require "linzer/message/adapter/http_gem/common"
+
 module Linzer
   class Message
     module Adapter
-      # http.rb gem message adapters.
-      #
-      # Provides adapters for {HTTP::Request} and {HTTP::Response} objects
-      # from the http.rb gem.
-      #
-      # @note These adapters are loaded on-demand when using the
-      #   {Linzer::HTTP::SignatureFeature}.
       module HTTPGem
         # Adapter for {HTTP::Request} objects from http.rb gem.
         #
         # Extends the generic request adapter with http.rb-specific
         # method name retrieval.
         class Request < Generic::Request
+          include HTTPGem::Common
+
           private
 
           def derived(name)
+            return @operation.uri.host         if name.value == "@authority"
             return @operation.verb.to_s.upcase if name.value == "@method"
             super
           end

data/lib/linzer/message/adapter/http_gem/response.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "linzer/message/adapter/http_gem/common"
+
 module Linzer
   class Message
     module Adapter
@@ -13,6 +15,8 @@ module Linzer
         #
         # @see https://github.com/httprb/http http.rb gem
         class Response < Generic::Response
+          include HTTPGem::Common
+
           private
 
           def derived(name)

data/lib/linzer/version.rb

@@ -3,5 +3,5 @@
 module Linzer
   # Current version of the Linzer gem.
   # @return [String]
-  VERSION = "0.7.9.beta1"
+  VERSION = "0.7.9.beta2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: linzer
 version: !ruby/object:Gem::Version
-  version: 0.7.9.beta1
+  version: 0.7.9.beta2
 platform: ruby
 authors:
 - Miguel Landaeta
@@ -199,6 +199,7 @@ files:
 - lib/linzer/message/adapter/abstract.rb
 - lib/linzer/message/adapter/generic/request.rb
 - lib/linzer/message/adapter/generic/response.rb
+- lib/linzer/message/adapter/http_gem/common.rb
 - lib/linzer/message/adapter/http_gem/request.rb
 - lib/linzer/message/adapter/http_gem/response.rb
 - lib/linzer/message/adapter/net_http/request.rb