grape-idempotency 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 756cff52967b35d996913c3d682847a4cd362c2cbd4a95d8bf766c2f037d86ce
-  data.tar.gz: bf87694a06895bfd09749676574a078f71b698f59c23211a438112b22f332f06
+  metadata.gz: be4536a211550d89d0c48cd4c83c7704cb5242bedd7028fe10037e1ceac11f76
+  data.tar.gz: 5fed5897f5416f70e99771aa7a773433420829acb60c9682fec55d943ac5080c
 SHA512:
-  metadata.gz: bdaaa014a0a39fdbba3f850bdddbd27db5fca791f543609c4a847615eaeeac52d0dfb16e642d1310915bbdada5b46267291a1e43fec70299a027c5a9848285b2
-  data.tar.gz: 2030a6016fcbaf64667b22a2be43af70239381e6d3311571e45c172d439bb67222ca57f2566becd847eb867d8ae9750ddcef70e1dd2444492191e2924f27e7cd
+  metadata.gz: 797f3ba565676d3eb97c5b0d38af871ec0c017b3f1a0705b08cd80c7f8b6fa30d32d3c921bb46aa2910827e06bb21500d3bf83e63c017177feb33e13bb5a0ab3
+  data.tar.gz: 071c4135447ceb9389cd2c5d8c2bb92477465318c523efc25eca43967e0c4533366a5d576cac3c52ee097c59ccd1164628124d73a5aea1072f6bfed7da3ae78b

data/CHANGELOG.md

@@ -4,6 +4,32 @@ All changes to `grape-idempotency` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.1] - 2026-10-15
+
+### Fix
+
+* Catch errors thrown with `error!` inside `rescue_from` handlers, which raised `UncaughtThrowError` with Grape >= 2.1 - [@jcagarcia](https://github.com/jcagarcia).
+* Return Grape's `500 Invalid response` when a `rescue_from` handler does not return a valid response, instead of raising `NoMethodError: undefined method 'default_rescue_handler'` with Grape >= 2.1 - [@jcagarcia](https://github.com/jcagarcia).
+* Store that `500 Invalid response` for the idempotency key, so retrying the request replays it instead of returning `409 Conflict` until the key expires - [@jcagarcia](https://github.com/jcagarcia).
+* Support `rescue_from ..., with: :helper_method` with Grape >= 3.0, which resolves symbol handlers on the endpoint - [@jcagarcia](https://github.com/jcagarcia).
+* Only treat a Hash returned by a `rescue_from` handler as an error response when it contains `:message`, `:status` and `:headers`, matching Grape - [@jcagarcia](https://github.com/jcagarcia).
+* Handle `Grape::Exceptions::ErrorResponse` thrown by `error!` with Grape >= 3.3, both inside `idempotent` blocks and inside `rescue_from` handlers - [@jcagarcia](https://github.com/jcagarcia).
+* [#22](https://github.com/jcagarcia/grape-idempotency/pull/22): Do not turn `rescue_from` responses into 500 errors when a stored error request expires or is invalid while being looked up. - [@salrepe](https://github.com/salrepe).
+* [#22](https://github.com/jcagarcia/grape-idempotency/pull/22): Only access the storage from the error middleware for requests that stored an error inside `idempotent`, reading that exact key instead of scanning all error keys. - [@salrepe](https://github.com/salrepe).
+* [#22](https://github.com/jcagarcia/grape-idempotency/pull/22): Do not store error requests when no idempotency key was provided. - [@salrepe](https://github.com/salrepe).
+
+### Changed
+
+* [#24](https://github.com/jcagarcia/grape-idempotency/issues/24): Test Ruby (2.6 - 4.0) and Grape (1.5 - 4.0) in CI: the combinations where behaviour changes on every push and pull request, and every supported combination plus the latest Grape release weekly or on demand - [@jcagarcia](https://github.com/jcagarcia).
+* Document Ruby and Grape compatibility in the README - [@jcagarcia](https://github.com/jcagarcia).
+
+
+## [1.1.0] - 2023-12-12
+
+### Feature
+
+* [#20](https://github.com/jcagarcia/grape-idempotency/pull/20): Allow consumers to configure the gem for handling `Redis` exceptions - [@jcagarcia](https://github.com/jcagarcia).
+
 ## [1.0.0] - 2023-11-23
 
 ### Changed

data/README.md

@@ -10,9 +10,11 @@ Implementation based on the Active Internet-Draft [draft-ietf-httpapi-idempotenc
 Topics covered in this README:
 
 - [Installation](#installation-)
+- [Compatibility](#compatibility-)
 - [Basic Usage](#basic-usage-)
 - [How it works](#how-it-works-)
-- [Making idempotency key header mandatory](#making-idempotency-key-header-mandatory-)
+  - [Making idempotency key header mandatory](#making-idempotency-key-header-mandatory-)
+  - [Redis Storage Connectivity Issue](#redis-storage-connectivity-issue)
 - [Configuration](#configuration-)
 - [Changelog](#changelog)
 - [Contributing](#contributing)
@@ -29,6 +31,20 @@ Ruby 2.6 or newer is required.
 gem install grape-idempotency
 ```
 
+## Compatibility 🤝
+
+- Ruby 2.6 or newer.
+- Grape 1.x and 2.x or newer are supported from a single codebase.
+- Grape 1.0 - 1.4 are allowed by the gemspec but are not tested.
+- Grape 1.x does not work with Rack 3, so if you are using Grape 1.x add `gem 'rack', '< 3'` to your `Gemfile`.
+- Grape 1.5 does not load with ActiveSupport 7.1.x (7.0 and 7.2+ work). On Ruby 2.7 / 3.0, where 7.1 is the newest installable ActiveSupport, add `gem 'activesupport', '< 7.1'` to your `Gemfile`.
+
+The tested Ruby and Grape combinations live in the [CI workflow](.github/workflows/ruby.yml): pushes and pull requests run the combinations where Ruby or Grape behaviour changes, and a weekly (or manually triggered) run tests every Grape minor line from 1.5 onwards against every Ruby version it supports, plus the latest Grape release on the newest Ruby. To run the specs against a specific Grape line locally, set `GRAPE_VERSION` (this rewrites your local `Gemfile.lock`, do not commit it):
+
+```shell
+GRAPE_VERSION="~> 1.8.0" bundle update grape && bundle exec rspec
+```
+
 ## Basic Usage 📖
 
 Configure the `Grape::Idempotency` class with a `Redis` instance.
@@ -81,7 +97,7 @@ Results are only saved if an API endpoint begins its execution. If incoming para
 
 Additionally, this gem automatically appends the `Original-Request` header and the `Idempotency-Key` header to your API's response, enabling you to trace back to the initial request that generated that specific response.
 
-## Making idempotency key header mandatory ⚠️
+### Making idempotency key header mandatory ⚠️
 
 For some endpoints, you want to enforce your consumers to provide idempotency key. So, when wrapping the code inside the `idempotent` method, you can mark it as `required`:
 
@@ -113,6 +129,37 @@ If the Idempotency-Key request header is missing for a idempotent operation requ
 
 If you want to change the error message returned in this scenario, check [How to configure idempotency key missing error message](#mandatory_header_response) section.
 
+### Redis Storage Connectivity Issue
+
+By default, `Redis` exceptions are not handled by the `grape-idempotency` gem.
+
+Therefore, if an exception arises while attempting to read, write or delete data from the `Redis` storage, the gem will re-raise the identical exception to your application. Thus, you will be responsible for handling it within your own code, such as:
+
+```ruby
+require 'grape'
+require 'grape-idempotency'
+
+class API < Grape::API
+    post '/payments' do
+      begin
+        idempotent do
+          status 201
+          Payment.create!({
+            amount: params[:amount]
+          })
+        end
+      rescue Redis::BaseError => e
+        error!("Redis error! Idempotency is very important here and we cannot continue.", 500)
+      end
+    end
+  end
+end
+```
+
+If you want to avoid this functionality, and you want the gem handles the potential `Redis` exceptions, you have the option to configure the gem for handling these `Redis` exceptions. Please refer to the [manage_redis_exceptions](#manage_redis_exceptions) configuration property.
+
+🚨 WARNING: If a `Redis` exception appears AFTER performing the wrapped code, nothing will be re-raised. The process will continue working and the response will be returned to the consumer of your API. However, a `409 Conflict` response can be returned to your consumer if it retried the same call with the same idempotency key. This is because the gem was not able to associate the response of the original request to the original idempotency key because those connectivity issues.
+
 ## Configuration 🪚
 
 In addition to the storage aspect, you have the option to supply additional configuration details to tailor the gem to the specific requirements of your project.
@@ -169,6 +216,7 @@ If you want to provide your own logger, you want to change the level to `DEBUG`
 
 ```ruby
 Grape::Idempotency.configure do |c|
+  c.storage = @storage
   c.logger = Infrastructure::MyLogger.new
   c.logger_level = :debug
   c.logger_prefix = '[my-own-prefix]'
@@ -194,6 +242,21 @@ I, [2023-11-23T22:41:39.148523 #1]  DEBUG -- : [my-own-prefix] Request has been
 I, [2023-11-23T22:41:39.148537 #1]  DEBUG -- : [my-own-prefix] Returning the response from the original request.
 ```
 
+### manage_redis_exceptions
+
+By default, the `grape-idempotency` gem is configured to re-raise `Redis` exceptions.
+
+If you want to delegate the `Redis` exception management into the gem, you can configure it using the `manage_redis_exceptions` configuration property.
+
+```ruby
+Grape::Idempotency.configure do |c|
+  c.storage = @storage
+  c.manage_redis_exceptions = true
+end
+```
+
+However, this approach carries a certain level of risk. In the case that `Redis` experiences an outage, the idempotent functionality will be lost, the endpoint will behave as no idempotent, and this issue may go unnoticed.
+
 ### conflict_error_response
 
 When providing a `Idempotency-Key: <key>` header, this gem compares incoming parameters to those of the original request (if exists) and returns a `409 - Conflict` status code if they don't match, preventing accidental misuse. The response body returned by the gem looks like:
@@ -320,4 +383,5 @@ Open issues on the GitHub issue tracker with clear information.
 ### Contributors
 
 * Juan Carlos García - Creator - https://github.com/jcagarcia
-* Carlos Cabanero - Contributor - https://github.com/Flip120
+* Carlos Cabanero - Contributor - https://github.com/Flip120
+* Salvador Revert Pedron - Contributor - https://github.com/salrepe

data/grape-idempotency.gemspec

@@ -22,7 +22,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.6'
 
-  spec.add_runtime_dependency 'grape', '~> 1'
+  spec.add_runtime_dependency 'grape', '>= 1'
+  spec.add_runtime_dependency 'redis', '>= 4'
   
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rspec'

data/lib/grape/idempotency/middleware/error.rb

@@ -5,36 +5,56 @@ module Grape
     class Error < Base
       def run_rescue_handler(handler, error, endpoint=nil)
         if handler.instance_of?(Symbol)
-          raise NoMethodError, "undefined method '#{handler}'" unless respond_to?(handler)
+          # grape >= 3.0 resolves symbol handlers (`rescue_from ..., with: :helper`) on the endpoint
+          handler_owner = respond_to?(handler) || endpoint.nil? ? self : endpoint
+          raise NoMethodError, "undefined method '#{handler}'" unless handler_owner.respond_to?(handler)
 
-          handler = public_method(handler)
+          handler = handler_owner.public_method(handler)
         end
 
-        if endpoint
-          response = handler.arity.zero? ? endpoint.instance_exec(&handler) : endpoint.instance_exec(error, &handler)
-        else
-          response = handler.arity.zero? ? instance_exec(&handler) : instance_exec(error, &handler)
+        response = catch(:error) do
+          if endpoint
+            handler.arity.zero? ? endpoint.instance_exec(&handler) : endpoint.instance_exec(error, &handler)
+          else
+            handler.arity.zero? ? instance_exec(&handler) : instance_exec(error, &handler)
+          end
         end
 
+        response = error_response(response) if thrown_error?(response)
+
         if response.is_a?(Rack::Response)
           update_idempotency_error_with(error, response)
           response
         else
-          run_rescue_handler(:default_rescue_handler, Grape::Exceptions::InvalidResponse.new)
+          # default_rescue_handler is private since grape 2.1
+          response = run_rescue_handler(method(:default_rescue_handler), Grape::Exceptions::InvalidResponse.new, endpoint)
+          # Store it under the original error, the one the pending idempotent request was registered with
+          update_idempotency_error_with(error, response)
+          response
         end
       end
 
       private
 
+      def thrown_error?(response)
+        # grape >= 3.3 throws Grape::Exceptions::ErrorResponse instead of a Hash
+        return true if defined?(Grape::Exceptions::ErrorResponse) && response.is_a?(Grape::Exceptions::ErrorResponse)
+
+        response.is_a?(Hash) && response.key?(:message) && response.key?(:status) && response.key?(:headers)
+      end
+
       def update_idempotency_error_with(error, response)
+        stored_error_key = env && env[Grape::Idempotency::ERROR_KEY_ENV]
+        return unless stored_error_key
+
         begin
           body = JSON.parse(response.body.join)
         rescue JSON::ParserError
           body = response.body.join
         end
 
-        Grape::Idempotency.update_error_with_rescue_from_result(error, response.status, body)
+        Grape::Idempotency.update_error_with_rescue_from_result(error, response.status, body, error_key: stored_error_key)
       end
     end
   end
-end
+end

data/lib/grape/idempotency/version.rb

@@ -2,6 +2,6 @@
 
 module Grape
   module Idempotency
-    VERSION = '1.0.0'
+    VERSION = '1.1.1'
   end
 end

data/lib/grape/idempotency.rb

@@ -1,4 +1,5 @@
 require 'grape'
+require 'redis'
 require 'logger'
 require 'securerandom'
 require 'grape/idempotency/version'
@@ -9,6 +10,8 @@ module Grape
     autoload :Helpers, 'grape/idempotency/helpers'
     Grape::Endpoint.send :include, Grape::Idempotency::Helpers
 
+    ERROR_KEY_ENV = "grape.idempotency.error_key".freeze
+
     class << self
       ORIGINAL_REQUEST_HEADER = "Original-Request".freeze
 
@@ -33,21 +36,21 @@ module Grape
         grape.error!(configuration.mandatory_header_response, 400) if required && !idempotency_key
         return block.call if !idempotency_key
 
-        cached_request = get_from_cache(idempotency_key)
-        log(:debug, "Request has been found for the provided idempotency key => #{cached_request}") if cached_request
-        if cached_request && (cached_request["params"] != grape.request.params || cached_request["path"] != grape.request.path)
-          log(:debug, "Request has conflicts. Same params? => #{cached_request["params"] != grape.request.params}. Same path? => #{cached_request["path"] != grape.request.path}")
+        stored_request = get_from_storage(idempotency_key)
+        log(:debug, "Request has been found for the provided idempotency key => #{stored_request}") if stored_request
+        if stored_request && (stored_request["params"] != grape.request.params || stored_request["path"] != grape.request.path)
+          log(:debug, "Request has conflicts. Same params? => #{stored_request["params"] != grape.request.params}. Same path? => #{stored_request["path"] != grape.request.path}")
           log(:debug, "Returning conflict error response.")
           grape.error!(configuration.conflict_error_response, 422)
-        elsif cached_request && cached_request["processing"] == true
+        elsif stored_request && stored_request["processing"] == true
           log(:debug, "Returning processing error response.")
           grape.error!(configuration.processing_response, 409)
-        elsif cached_request
+        elsif stored_request
           log(:debug, "Returning the response from the original request.")
-          grape.status cached_request["status"]
-          grape.header(ORIGINAL_REQUEST_HEADER, cached_request["original_request"])
+          grape.status stored_request["status"]
+          grape.header(ORIGINAL_REQUEST_HEADER, stored_request["original_request"])
           grape.header(configuration.idempotency_key_header, idempotency_key)
-          return cached_request["response"]
+          return stored_request["response"]
         end
 
         log(:debug, "Previous request information has NOT been found for the provided idempotency key.")
@@ -71,38 +74,45 @@ module Grape
 
         if is_an_error?(response)
           log(:debug, "An error response was returned by the performed block. => #{response}")
-          response = response[:message]
+          response = response.is_a?(Hash) ? response[:message] : response.message
         end
 
         grape.header(ORIGINAL_REQUEST_HEADER, original_request_id)
         grape.body response
+      rescue Redis::BaseError => e
+        raise
       rescue => e
         log(:debug, "An unexpected error was raised when performing the block.")
-        if !cached_request && !response
+        if idempotency_key && !stored_request && !response
           validate_config!
           log(:debug, "Storing error response.")
           original_request_id = get_request_id(grape.request.headers)
           stored_key = store_error_request(idempotency_key, grape.request.path, grape.request.params, grape.status, original_request_id, e)
-          log(:debug, "Error response stored.")
-          grape.header(ORIGINAL_REQUEST_HEADER, original_request_id)
-          grape.header(configuration.idempotency_key_header, stored_key)
+          if stored_key
+            log(:debug, "Error response stored.")
+            grape.env[ERROR_KEY_ENV] = error_key(stored_key)
+            grape.header(ORIGINAL_REQUEST_HEADER, original_request_id)
+            grape.header(configuration.idempotency_key_header, stored_key)
+          end
         end
         log(:debug, "Re-raising the error.")
         raise
       ensure
-        if !cached_request && response
+        if !stored_request && response
           validate_config!
           log(:debug, "Storing response.")
           stored_key = store_request_response(idempotency_key, grape.request.path, grape.request.params, grape.status, original_request_id, response)
-          log(:debug, "Response stored.")
-          grape.header(configuration.idempotency_key_header, stored_key)
+          if stored_key
+            log(:debug, "Response stored.")
+            grape.header(configuration.idempotency_key_header, stored_key)
+          end
         end
       end
 
-      def update_error_with_rescue_from_result(error, status, response)
+      def update_error_with_rescue_from_result(error, status, response, error_key: nil)
         validate_config!
 
-        stored_error = get_error_request_for(error)
+        stored_error = error_key ? get_error_request_by_key(error_key) : get_error_request_for(error)
         return unless stored_error
 
         request_with_unmanaged_error = stored_error[:request]
@@ -113,6 +123,9 @@ module Grape
 
         store_request_response(idempotency_key, path, params, status, original_request_id, response)
         storage.del(stored_error[:error_key])
+      rescue Redis::BaseError => e
+        log(:error, "Storage error => #{e.message} - #{e}")
+        nil
       end
 
       private
@@ -122,7 +135,10 @@ module Grape
       end
 
       def valid_storage?
-        configuration.storage && configuration.storage.respond_to?(:set)
+        configuration.storage &&
+        configuration.storage.respond_to?(:get) &&
+        configuration.storage.respond_to?(:set) &&
+        configuration.storage.respond_to?(:del)
       end
 
       def get_idempotency_key(headers)
@@ -141,11 +157,15 @@ module Grape
         request_id || "req_#{SecureRandom.hex}"
       end
 
-      def get_from_cache(idempotency_key)
+      def get_from_storage(idempotency_key)
         value = storage.get(key(idempotency_key))
         return unless value
 
         JSON.parse(value)
+      rescue Redis::BaseError => e
+        log(:error, "Storage error => #{e.message} - #{e}")
+        return if configuration.manage_redis_exceptions
+        raise
       end
 
       def store_processing_request(idempotency_key, path, params, request_id)
@@ -157,6 +177,9 @@ module Grape
         }
 
         storage.set(key(idempotency_key), body.to_json, ex: configuration.expires_in, nx: true)
+      rescue Redis::BaseError => e
+        return true if configuration.manage_redis_exceptions
+        raise
       end
 
       def store_request_response(idempotency_key, path, params, status, request_id, response)
@@ -170,6 +193,9 @@ module Grape
 
         storage.set(key(idempotency_key), body.to_json, ex: configuration.expires_in, nx: false)
 
+        idempotency_key
+      rescue Redis::BaseError => e
+        log(:error, "Storage error => #{e.message} - #{e}")
         idempotency_key
       end
 
@@ -187,29 +213,55 @@ module Grape
 
         storage.set(error_key(idempotency_key), body, ex: 30, nx: false)
 
+        idempotency_key
+      rescue Redis::BaseError => e
+        log(:error, "Storage error => #{e.message} - #{e}")
         idempotency_key
       end
 
+      def get_error_request_by_key(error_key)
+        raw_request_with_error = storage.get(error_key)
+        return unless raw_request_with_error
+
+        {
+          error_key: error_key,
+          request: JSON.parse(raw_request_with_error),
+          idempotency_key: error_key.delete_prefix(error_key_prefix)
+        }
+      rescue Redis::BaseError, JSON::ParserError, TypeError => e
+        log(:error, "Error retrieving stored error request => #{e.message} - #{e}")
+        nil
+      end
+
       def get_error_request_for(error)
         error_keys = storage.keys("#{error_key_prefix}*")
         return if error_keys.empty?
 
         error_keys.map do |key|
-          request_with_error = JSON.parse(storage.get(key))
+          raw_request_with_error = storage.get(key)
+          next unless raw_request_with_error
+
+          request_with_error = JSON.parse(raw_request_with_error)
           error_class_name = request_with_error["error"]["class_name"]
           error_message = request_with_error["error"]["message"]
-          
+
           if error_class_name == error.class.to_s && error_message == error.message
             {
               error_key: key,
               request: request_with_error,
-              idempotency_key: key.gsub(error_key_prefix, '')
+              idempotency_key: key.delete_prefix(error_key_prefix)
             }
           end
-        end.first
+        end.compact.first
+      rescue Redis::BaseError, JSON::ParserError, TypeError => e
+        log(:error, "Error retrieving stored error request => #{e.message} - #{e}")
+        nil
       end
 
       def is_an_error?(response)
+        # grape >= 3.3 throws Grape::Exceptions::ErrorResponse instead of a Hash
+        return true if defined?(Grape::Exceptions::ErrorResponse) && response.is_a?(Grape::Exceptions::ErrorResponse)
+
         response.is_a?(Hash) && response.has_key?(:message) && response.has_key?(:headers) && response.has_key?(:status)
       end
 
@@ -252,7 +304,8 @@ module Grape
 
     class Configuration
       attr_accessor :storage, :logger, :logger_level, :logger_prefix, :expires_in, :idempotency_key_header,
-        :request_id_header, :conflict_error_response, :processing_response, :mandatory_header_response
+        :request_id_header, :conflict_error_response, :processing_response, :mandatory_header_response,
+        :manage_redis_exceptions
 
       class Error < StandardError; end
 
@@ -264,6 +317,7 @@ module Grape
         @expires_in = 216_000
         @idempotency_key_header = "idempotency-key"
         @request_id_header = "x-request-id"
+        @manage_redis_exceptions = false
         @conflict_error_response = {
           "title" => "Idempotency-Key is already used",
           "detail" => "This operation is idempotent and it requires correct usage of Idempotency Key. Idempotency Key MUST not be reused across different payloads of this operation."

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: grape-idempotency
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Juan Carlos García
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-23 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -104,7 +118,7 @@ homepage: https://github.com/jcagarcia/grape-idempotency
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -120,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.4.10
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Gem for supporting idempotency in your Grape APIs
 test_files: []