rest-client-wrapper 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b402585e6034813c0b9d3fa1af05e943ca106f7cdcae0b0f6e205e822250304
-  data.tar.gz: 64390499b6848d1dab15c57a723b9b02bded8eedf2b5f3650e8f3f8ed789f3f2
+  metadata.gz: 9fb801363ad2583dd1774f9c662fea54d6fe3b42747296e959e51a712f5f0795
+  data.tar.gz: 1ff4d4aed156a6a99467997d20f1713a72d4976e9082fba2fda3e8589b2ee6d0
 SHA512:
-  metadata.gz: 8769b420a7bfe481450e0665a3f4899564dff302769bf050f7d512564b828479529a5a3859dd8fb581d714e8b4452601e102a0d28226771bc57ece9f16b4cc88
-  data.tar.gz: 46a6573d732840fe66240d6773db7f07ecd274d70b3a7b794b44d1bb31eca85fe514a050726571afe47538b8b4a16b260013c872b20283eb52c515df47829d6f
+  metadata.gz: 2804b60c91e9d6df61cda9471eae4b3af1f3297d0dd21b47e957077b0873df55784d207ac595acc9e56b819ba05910dd11100e43604d78a0bb53773cdde56caa
+  data.tar.gz: db9077dfaf78eed8d79cca584949a4ceb0ca4a13fa4a02ab5068bdc098d7b84a15488b1b86e05f34b2c5e1ed1c0a1f4b3d97cd3972dcd492837215ba4e178a17

data/README.md

@@ -31,7 +31,7 @@ A `rest_client` must be created to make requests (if the rest_client requires au
 require "rest_client_wrapper"
 
 # Create a rest_client
-rest_client = RestClientWrapper::RestClient.new({ host: "https://www.host.com" })
+rest_client = RestClientWrapper::RestClient.new(host: "https://www.host.com")
 ```
 
 ## Basic Usage: `make_request`
@@ -40,7 +40,7 @@ The `rest_client` can make HTTP requests using `make_request`:
 
 ```ruby
 # Make a request
-response = rest_client.make_request({ http_method: :get, uri: "https://www.host.com" })
+response = rest_client.make_request(http_method: :get, uri: "https://www.host.com")
 ```
 <a name="get_started"></a>
 ## Basic Usage: `execute`
@@ -51,23 +51,23 @@ _Segment parameters_ can be added to an existing `request`:
 
 ```ruby
 # Create an HTTP request with a segmented uri
-request = Request.new({ http_method: :get, uri: "/%<segment_1>s/%<segment_2>s" })
+request = Request.new(http_method: :get, uri: "/%<segment_1>s/%<segment_2>s")
 
 # Add the segment parameter(s) to the request ('%<segment_x>s' in the uri will be replaced with the matching segment param when the request is executed)
 request.segment_params = { segment_1: "user_id_0001", segment_2: "course_id_0001" }
 
 # Execute a request
-response = rest_client.execute({ request: request })
+response = rest_client.execute(request: request)
 ```
 
 _Segment parameters_ can be created with the `request`:
 
 ```ruby
 # Segment parameters can be created with the request
-request = Request.new({ http_method: :post, uri: "/%<segment_1>s", segment_params: { segment_1: "user_id_0001" }, payload: { first_name: "name" }, headers: { content_type: "application/json" } })
+request = Request.new(http_method: :post, uri: "/%<segment_1>s", segment_params: { segment_1: "user_id_0001" }, payload: { first_name: "name" }, headers: { content_type: "application/json" })
 
 # Execute a request
-response = rest_client.execute({ request: request })
+response = rest_client.execute(request: request)
 ```
 <a name="authentication"></a>
 ## Authentication
@@ -78,10 +78,10 @@ The `rest_client` can make authenticated HTTP requests using an `authenticator`.
 
 ```ruby
 # Add a Basic authenticator to the rest_client
-rest_client.authenticator = Authenticator::Basic.new({ username: "username", password: "password" })
+rest_client.authenticator = Authenticator::Basic.new(username: "username", password: "password")
 
 # Make a request
-response = rest_client.make_request({ http_method: :get, uri: "https://www.host.com/api/v1/resource" })
+response = rest_client.make_request(http_method: :get, uri: "https://www.host.com/api/v1/resource")
 ```
 
 ### Custom
@@ -93,39 +93,39 @@ response = rest_client.make_request({ http_method: :get, uri: "https://www.host.
 ```ruby
 # Add a Custom authenticator using query_param
 # The custom auth parameter will be added as a query parameter
-rest_client.authenticator = Authenticator::Custom.new({ type: :query_param, auth_param: { custom_auth_param: "auth_value" } })
+rest_client.authenticator = Authenticator::Custom.new(type: :query_param, auth_param: { custom_auth_param: "auth_value" })
 
 # Make a request
-response = rest_client.make_request({ http_method: :get, uri: "https://www.host.com/api/v1/resource" })
+response = rest_client.make_request(http_method: :get, uri: "https://www.host.com/api/v1/resource")
 ```
 
 ```ruby
 # Add a Custom authenticator using header
 # The custom auth parameter will be added to the request header
-rest_client.authenticator = Authenticator::Custom.new({ type: :header, auth_param: { custom_auth_param: "auth_value" } })
+rest_client.authenticator = Authenticator::Custom.new(type: :header, auth_param: { custom_auth_param: "auth_value" })
 
 # Make a request
-response = rest_client.make_request({ http_method: :get, uri: "https://www.host.com/api/v1/resource" })
+response = rest_client.make_request(http_method: :get, uri: "https://www.host.com/api/v1/resource")
 ```
 
 ### OAuth
 
 ```ruby
 # Add an OAuth authenticator to the rest_client
-rest_client.authenticator = Authenticator::Oauth.new({ site: "https://www.host.com", token_url_path: "token_url_path", client_id: "client_id", client_secret: "secret" })
+rest_client.authenticator = Authenticator::Oauth.new(site: "https://www.host.com", token_url_path: "token_url_path", client_id: "client_id", client_secret: "secret")
 
 # Make a request
-response = rest_client.make_request({ http_method: :get, uri: "/api/v1/user" })
+response = rest_client.make_request(http_method: :get, uri: "/api/v1/user")
 ```
 
 ### Token
 
 ```ruby
 # Add a Token authenticator to the rest_client
-rest_client.authenticator = Authenticator::Token.new({ access_token: "access_token" })
+rest_client.authenticator = Authenticator::Token.new(access_token: "access_token")
 
 # Make a request
-response = rest_client.make_request({ http_method: :get, uri: "/api/v1/user" })
+response = rest_client.make_request(http_method: :get, uri: "/api/v1/user")
 ```
 
 ## Pagination
@@ -139,7 +139,7 @@ The `rest_client` can make paginated HTTP requests using a `paginator`.
 rest_client.paginator = Paginator::HeaderLink.new
 
 # Make a request for paginated data
-rest_client.make_request_for_pages({ http_method: :get, uri: "/api/v1/user" })
+rest_client.make_request_for_pages(http_method: :get, uri: "/api/v1/user")
 ```
 
 ### Echo360
@@ -148,7 +148,7 @@ rest_client.make_request_for_pages({ http_method: :get, uri: "/api/v1/user" })
 # Add an Echo paginator to the rest_client
 rest_client.paginator = Paginator::Echo.new
 
-rest_client.make_request_for_pages({ http_method: :get, uri: "/api/v1/user" })
+rest_client.make_request_for_pages(http_method: :get, uri: "/api/v1/user")
 ```
 
 ---
@@ -184,7 +184,7 @@ config = {
   }
 }
 
-rest_client = RestClientWrapper::RestClient.new({ host: "host" })
+rest_client = RestClientWrapper::RestClient.new(host: "host")
 ```
 
 If the caller wishes for additional HTTP codes to be handled, they can be specified in the `config`:
@@ -197,7 +197,7 @@ config = {
   }
 }
 
-rest_client = RestClientWrapper::RestClient.new({ host: "host", config: config })
+rest_client = RestClientWrapper::RestClient.new(host: "host", config: config)
 ```
 
 ## make_request
@@ -389,8 +389,8 @@ _Response_ objects have the following methods:
 
 ```ruby
 begin
-  request = Request.new({http_method: :get, uri: "https://www.host.com/public/api/v1/resource" })
-  response = rest_client.execute({ request: request })
+  request = Request.new(http_method: :get, uri: "https://www.host.com/public/api/v1/resource")
+  response = rest_client.execute(request: request)
 rescue RestClientError => e
   e.response
 end
@@ -408,14 +408,14 @@ end
 host_url = "https://www.host.com"
 username = "api_user_name"
 password = "password"
-client = Client.new({ host: host_url })
-client.authenticator = Authenticator::Basic.new({ username: username, password: password })
-client.paginator = Paginator::HeaderLink.new({ per_page: 10 })
+client = Client.new(host: host_url)
+client.authenticator = Authenticator::Basic.new(username: username, password: password)
+client.paginator = Paginator::HeaderLink.new(per_page: 10)
 
-response = client.make_request({ http_method: :get, uri: "/api/v1/resource" })
+response = client.make_request(http_method: :get, uri: "/api/v1/resource")
 
 # paginated request
-data = client.make_request_for_pages({ http_method: :get, uri: "/api/v1/resource", data: true })
+data = client.make_request_for_pages(http_method: :get, uri: "/api/v1/resource", data: true)
 
 ```
 
@@ -424,28 +424,28 @@ data = client.make_request_for_pages({ http_method: :get, uri: "/api/v1/resource
 ```ruby
 canvas_host = "https://host.instructure.com"
 canvas_access_token = "access_token"
-canvas_client = Client.new({ host: canvas_host })
-canvas_client.authenticator = Authenticator::Token.new({ access_token: canvas_access_token })
-canvas_client.paginator = Paginator::HeaderLink.new({ per_page: 10 })
+canvas_client = Client.new(host: canvas_host)
+canvas_client.authenticator = Authenticator::Token.new(access_token: canvas_access_token)
+canvas_client.paginator = Paginator::HeaderLink.new(per_page: 10)
 
-canvas_response = canvas_client.make_request({ http_method: :get, uri: "/api/v1/accounts/1/terms" })
+canvas_response = canvas_client.make_request(http_method: :get, uri: "/api/v1/accounts/1/terms")
 
 # paginated request
-canvas_data = canvas_client.make_request_for_pages({ http_method: :get, uri: "/api/v1/accounts/1/terms", data: true })
+canvas_data = canvas_client.make_request_for_pages(http_method: :get, uri: "/api/v1/accounts/1/terms", data: true)
 ```
 
 ### Echo
 
 ```ruby
-echo_host = "https://echo360.org.au"
+echo_host = "https://echo360.net.au"
 echo_client_id = "client_id"
 echo_client_secret = "client_secret"
-echo_client = Client.new({ host: echo_host })
-echo_client.authenticator = Authenticator::Oauth.new({ site: echo_host, token_url_path: "/oauth2/access_token", client_id: echo_client_id, client_secret: echo_client_secret })
-echo_client.paginator = Paginator::Echo.new({ limit: 10 })
+echo_client = Client.new(host: echo_host)
+echo_client.authenticator = Authenticator::Oauth.new(site: echo_host, token_url_path: "/oauth2/access_token", client_id: echo_client_id, client_secret: echo_client_secret)
+echo_client.paginator = Paginator::Echo.new(limit: 10)
 
-echo_response = echo_client.make_request({ http_method: :get, uri: "/public/api/v1/terms" })
-echo_data = echo_client.make_request_for_pages({ http_method: :get, uri: "/public/api/v1/terms", data: true })
+echo_response = echo_client.make_request(http_method: :get, uri: "/public/api/v1/terms")
+echo_data = echo_client.make_request_for_pages(http_method: :get, uri: "/public/api/v1/terms", data: true)
 ```
 
 ## Create a request object
@@ -453,32 +453,32 @@ echo_data = echo_client.make_request_for_pages({ http_method: :get, uri: "/publi
 Create a `rest_client`.
 
 ```ruby
-rest_client = RestClientWrapper::RestClient.new({ host: "https://www.host.com" })
+rest_client = RestClientWrapper::RestClient.new(host: "https://www.host.com")
 ```
 
 ## Request with a segmented absolute URI
 
 ```ruby
-request = Request.new({http_method: :get, uri: "https://www.host.com/public/api/v1/users/%<user_id>s" })
+request = Request.new(http_method: :get, uri: "https://www.host.com/public/api/v1/users/%<user_id>s")
 request.segment_params = { user_id: "user_id" }
-response = rest_client.execute({ request: request })
+response = rest_client.execute(request: request)
 ```
 
 ## Request with a segmented resource path
 
 ```ruby
-rest_client = RestClientWrapper::RestClient.new({ host: "https://www.host.com" })
-request = Request.new({ http_method: :get, uri: "/public/api/v1/users/%<user_id>s" })
+rest_client = RestClientWrapper::RestClient.new(host: "https://www.host.com")
+request = Request.new(http_method: :get, uri: "/public/api/v1/users/%<user_id>s")
 request.segment_params = { user_id: "user_id" }
-response = rest_client.execute({ request: request })
+response = rest_client.execute(request: request)
 ```
 
 ## Query Parameters
 
 ```ruby
-rest_client = RestClientWrapper::RestClient.new({ host: "https://www.host.com" })
-request = Request.new({ http_method: :put, uri: "/api/v1/resource/" })
+rest_client = RestClientWrapper::RestClient.new(host: "https://www.host.com")
+request = Request.new(http_method: :put, uri: "/api/v1/resource/")
 request.payload = { user_id: "user_id" }
 request.query_params = { id: "value" }
-response = rest_client.execute({ request: request })
+response = rest_client.execute(request: request)
 ```

data/lib/rest_client_wrapper/authenticators/oauth.rb

@@ -50,14 +50,14 @@ module RestClientWrapper
       end
 
       def generate_auth
-        Authenticator::Oauth.authenticate({ client_id: @client_id }) if @@api_client&.[](@client_id)&.[](:access_token).nil?
+        Authenticator::Oauth.authenticate(client_id: @client_id) if @@api_client&.[](@client_id)&.[](:access_token).nil?
         access_token = @@api_client&.[](@client_id)&.[](:access_token)
         raise StandardError "Unable to authenticate #{ @client_id }" if @@api_client&.[](@client_id)&.[](:access_token).nil?
 
         return { Authorization: "Bearer #{ access_token }" }
       end
 
-      def self.authenticate(client_id:, access_token: nil)
+      def self.authenticate(client_id:, access_token: nil) # rubocop:disable Metrics/CyclomaticComplexity,  Metrics/PerceivedComplexity
         # Ensure that other threads aren't checking and updating the token at the same time
         @@api_client[client_id][:lock].synchronize do
           # Return access_token from @@api_client when the current_token is different to what's in @@api_client as it's already been refreshed
@@ -65,12 +65,12 @@ module RestClientWrapper
 
           payload = {
             grant_type:    GrantType::CLIENT_CREDENTIALS,
-            client_id:     client_id,
+            client_id:,
             client_secret: @@api_client&.[](client_id)&.[](:settings)&.[](:client_secret)
           }
           url = "#{ @@api_client&.[](client_id)&.[](:settings)&.[](:site) }#{ @@api_client&.[](client_id)&.[](:settings)&.[](:token_url_path) }"
 
-          response = ::RestClient::Request.execute({ method: :post, url: url, payload: payload })
+          response = ::RestClient::Request.execute(method: :post, url:, payload:)
 
           if Http.ok?(response.code)
             content_type = MIME::Types[response&.headers&.[](:content_type)].first

data/lib/rest_client_wrapper/http.rb

@@ -33,7 +33,7 @@ module RestClientWrapper
 
     # success
     def self.success?(code)
-      return SUCCESS_STATUS_CODES[code].nil? ? false : true
+      return !SUCCESS_STATUS_CODES[code].nil?
     end
 
     # 200

data/lib/rest_client_wrapper/paginators/echo.rb

@@ -33,7 +33,7 @@ module RestClientWrapper
 
       def initialize(limit: Paginate::DEFAULT_PAGINATION_PAGE_SIZE)
         @rest_client = nil
-        @config = { limit: limit }
+        @config = { limit: }
       end
 
       def paginate(http_method:, uri:, segment_params: {}, query_params: {}, headers: {}, data: false)
@@ -42,14 +42,14 @@ module RestClientWrapper
         query_params.reverse_merge!(@config)
         responses = []
         loop do
-          response = @rest_client.make_request({ http_method: http_method, uri: uri, segment_params: segment_params, query_params: query_params, headers: headers })
-          block_given? ? yield(response) : (responses << response)
+          response = @rest_client.make_request(http_method:, uri:, segment_params:, query_params:, headers:)
+          (block_given?) ? yield(response) : (responses << response)
           links = _pagination_links(response)
           break unless links.key?(:offset)
 
           query_params[:offset] = links[:offset]
         end
-        return data ? responses.map(&:body).pluck(:data).flatten : responses
+        return (data) ? responses.map(&:body).pluck(:data).flatten : responses
       end
 
       private

data/lib/rest_client_wrapper/paginators/echo_paginator.rb

@@ -33,7 +33,7 @@ module RestClientWrapper
 
       def initialize(limit: Paginate::DEFAULT_PAGINATION_PAGE_SIZE)
         @rest_client = nil
-        @config = { limit: limit }
+        @config = { limit: }
       end
 
       def paginate(http_method:, uri:, segment_params: {}, query_params: {}, headers: {}, data: false)
@@ -42,20 +42,20 @@ module RestClientWrapper
         query_params.reverse_merge!(@config)
         responses = []
         loop do
-          response = @rest_client.make_request({ http_method: http_method, uri: uri, segment_params: segment_params, query_params: query_params, headers: headers })
-          block_given? ? yield(response) : (responses << response)
+          response = @rest_client.make_request(http_method:, uri:, segment_params:, query_params:, headers:)
+          (block_given?) ? yield(response) : (responses << response)
           links = _pagination_links(response)
           break unless links.key?(:offset)
 
           query_params[:offset] = links[:offset]
         end
-        return data ? responses.map(&:body).pluck(:data).flatten : responses
+        return (data) ? responses.map(&:body).pluck(:data).flatten : responses
       end
 
       private
 
       def _pagination_links(response)
-        next_l = response&.body.instance_of?(Hash) ? response&.body&.[](:next) || "" : ""
+        next_l = (response&.body.instance_of?(Hash)) ? response&.body&.[](:next) || "" : ""
         next_h = Rack::Utils.parse_query(URI.parse(next_l)&.query)
         return next_h.symbolize_keys!
       end

data/lib/rest_client_wrapper/paginators/header_link.rb

@@ -33,7 +33,7 @@ module RestClientWrapper
 
       def initialize(per_page: Paginate::DEFAULT_PAGINATION_PAGE_SIZE)
         @rest_client = nil
-        @config = { page: nil, per_page: per_page }
+        @config = { page: nil, per_page: }
       end
 
       def paginate(http_method:, uri:, segment_params: {}, query_params: {}, headers: {}, data: false)
@@ -43,18 +43,18 @@ module RestClientWrapper
         responses = []
         loop.with_index(1) do |_, page|
           query_params[:page] = page
-          response = @rest_client.make_request({ http_method: http_method, uri: uri, segment_params: segment_params, query_params: query_params, headers: headers })
-          block_given? ? yield(response) : (responses << response)
+          response = @rest_client.make_request(http_method:, uri:, segment_params:, query_params:, headers:)
+          (block_given?) ? yield(response) : (responses << response)
           links = _pagination_links(response)
           break unless links.key?(:next)
         end
-        return data ? responses.map(&:body).flatten : responses
+        return (data) ? responses.map(&:body).flatten : responses
       end
 
       private
 
-      def _pagination_links(response)
-        re_uri = "\<(.*?)\>".freeze
+      def _pagination_links(response) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        re_uri = "<(.*?)>".freeze
         re_rel = "current|next|first|last".freeze
         links_a = response&.headers&.[](:link)&.split(",") || []
         links_h = {}

data/lib/rest_client_wrapper/paginators/header_link_paginator.rb

@@ -33,7 +33,7 @@ module RestClientWrapper
 
       def initialize(per_page: Paginate::DEFAULT_PAGINATION_PAGE_SIZE)
         @rest_client = nil
-        @config = { page: nil, per_page: per_page }
+        @config = { page: nil, per_page: }
       end
 
       def paginate(http_method:, uri:, segment_params: {}, query_params: {}, headers: {}, data: false)
@@ -43,18 +43,18 @@ module RestClientWrapper
         responses = []
         loop.with_index(1) do |_, page|
           query_params[:page] = page
-          response = @rest_client.make_request({ http_method: http_method, uri: uri, segment_params: segment_params, query_params: query_params, headers: headers })
-          block_given? ? yield(response) : (responses << response)
+          response = @rest_client.make_request(http_method:, uri:, segment_params:, query_params:, headers:)
+          (block_given?) ? yield(response) : (responses << response)
           links = _pagination_links(response)
           break unless links.key?(:next)
         end
-        return data ? responses.map(&:body).flatten : responses
+        return (data) ? responses.map(&:body).flatten : responses
       end
 
       private
 
-      def _pagination_links(response)
-        re_uri = "\<(.*?)\>".freeze
+      def _pagination_links(response) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        re_uri = "<(.*?)>".freeze
         re_rel = "current|next|first|last".freeze
         links_a = response&.headers&.[](:link)&.split(",") || []
         links_h = {}

data/lib/rest_client_wrapper/request.rb

@@ -30,11 +30,11 @@ module RestClientWrapper
 
     def initialize(**params)
       @uri = params[:uri]
-      self.headers = params[:headers].nil? ? {} : params[:headers]
+      self.headers = (params[:headers].nil?) ? {} : params[:headers]
       self.http_method = params[:http_method]
-      self.segment_params = params[:segment_params].nil? ? {} : params[:segment_params]
-      self.payload = params[:payload].nil? ? {} : params[:payload]
-      self.query_params = params[:query_params].nil? ? {} : params[:query_params]
+      self.segment_params = (params[:segment_params].nil?) ? {} : params[:segment_params]
+      self.payload = (params[:payload].nil?) ? {} : params[:payload]
+      self.query_params = (params[:query_params].nil?) ? {} : params[:query_params]
     end
 
     def http_method=(http_method)
@@ -67,7 +67,7 @@ module RestClientWrapper
     def headers=(headers)
       raise TypeError, "Request headers parameters is not a hash" unless headers.is_a?(Hash)
 
-      @headers.nil? ? @headers = headers : @headers.merge!(headers)
+      (@headers.nil?) ? @headers = headers : @headers.merge!(headers)
     end
 
   end

data/lib/rest_client_wrapper/rest_client.rb

@@ -62,13 +62,13 @@ module RestClientWrapper
       url = _build_uri(request)
 
       loop do
-        access_token = @authenticator.is_a?(Authenticator::Oauth) ? @authenticator.access_token : nil
+        access_token = (@authenticator.is_a?(Authenticator::Oauth)) ? @authenticator.access_token : nil
         response_code = nil
 
         begin
-          payload = Request::HTTP_METHOD_FOR_JSON.include?(request.http_method) && request.headers[:content_type] == :json ? request.payload.to_json : request.payload
+          payload = (Request::HTTP_METHOD_FOR_JSON.include?(request.http_method) && request.headers[:content_type] == :json) ? request.payload.to_json : request.payload
           request.headers[:params] = request.query_params
-          response = ::RestClient::Request.execute({ method: request.http_method, url: url, payload: payload, headers: request.headers })
+          response = ::RestClient::Request.execute(method: request.http_method, url:, payload:, headers: request.headers)
           response_code = response&.code
         rescue StandardError => e
           response_code = e.response&.code
@@ -85,20 +85,20 @@ module RestClientWrapper
     end
 
     def execute_paginated_request(request:, data: true)
-      return self.make_request_for_pages({ http_method: request.http_method, uri: request.uri, segment_params: request.segment_params, query_params: request.query_params, headers: request.headers, data: data }) # rubocop:disable Metrics/LineLength
+      return self.make_request_for_pages({ http_method: request.http_method, uri: request.uri, segment_params: request.segment_params, query_params: request.query_params, headers: request.headers, data: }) # rubocop:disable Metrics/LineLength
     end
 
     def make_request(http_method:, uri:, payload: {}, segment_params: {}, query_params: {}, headers: {})
-      request = Request.new({ http_method: http_method, uri: uri, payload: payload, segment_params: segment_params, query_params: query_params })
+      request = Request.new(http_method:, uri:, payload:, segment_params:, query_params:)
       request.headers = headers
-      return self.execute({ request: request })
+      return self.execute(request:)
     end
 
     def make_request_for_pages(http_method:, uri:, segment_params: {}, query_params: {}, headers: {}, data: false)
       raise RestClientError.new("Paginator not set, unable to make API call", nil, nil) unless @paginator
 
       @paginator.rest_client ||= self
-      return @paginator.paginate({ http_method: http_method, uri: uri, segment_params: segment_params, query_params: query_params, headers: headers, data: data })
+      return @paginator.paginate(http_method:, uri:, segment_params:, query_params:, headers:, data:)
     end
 
     private
@@ -106,7 +106,7 @@ module RestClientWrapper
     def _set_auth(request)
       return if @authenticator.nil?
 
-      auth = @authenticator.respond_to?(:generate_auth) ? @authenticator.generate_auth : {}
+      auth = (@authenticator.respond_to?(:generate_auth)) ? @authenticator.generate_auth : {}
       if @authenticator.is_a?(Authenticator::Custom)
         case @authenticator.type
         when :query_param
@@ -124,7 +124,7 @@ module RestClientWrapper
       parsed_uri = URI.parse(uri)
       raise ArgumentError, "URL host does not match config host of instance, unable to make API call" if parsed_uri.absolute? && @host.casecmp("#{ parsed_uri.scheme }://#{ parsed_uri.host }").nonzero?
 
-      return parsed_uri.absolute? ? uri : "#{ @host }#{ uri }"
+      return (parsed_uri.absolute?) ? uri : "#{ @host }#{ uri }"
     end
 
     def _validate_request(request)
@@ -172,7 +172,7 @@ module RestClientWrapper
 
     def _wait_and_retry(response_code, access_token)
       sleep(@retry_configs[response_code][:wait].to_f)
-      Authenticator::Oauth.authenticate({ client_id: @authenticator&.client_id, access_token: access_token }) if Http.unauthorized?(response_code) && @authenticator.is_a?(Authenticator::Oauth)
+      Authenticator::Oauth.authenticate(client_id: @authenticator&.client_id, access_token:) if Http.unauthorized?(response_code) && @authenticator.is_a?(Authenticator::Oauth)
       @retry_configs[response_code][:retry] += 1
     end
 

data/lib/rest_client_wrapper/version.rb

@@ -18,6 +18,6 @@
 
 module RestClientWrapper
 
-  VERSION = "4.0.0".freeze
+  VERSION = "5.0.0".freeze
 
 end

data/rest-client-wrapper.gemspec

@@ -30,22 +30,17 @@ Gem::Specification.new do |s|
   s.summary     = "Rest client wrapper"
   s.description = "Generic REST client wrapper"
   s.license     = "GPL 3.0"
-  s.required_ruby_version = ">= 2.6.0"
+  s.required_ruby_version = ">= 3.2.2"
 
-  s.add_runtime_dependency "json", ">= 1.8.3"
-  s.add_runtime_dependency "oauth2", ">= 1.2"
-  s.add_runtime_dependency "rack", ">= 2.0.5"
-  s.add_runtime_dependency "rest-client", ">= 2.0.2"
-  s.add_runtime_dependency "typhoeus", "~> 1.0", ">= 1.0.1"
-
-  s.add_development_dependency "colorize", "~> 0.7", ">= 0.7.0"
-  s.add_development_dependency "geminabox", "~> 0.13.0"
-  s.add_development_dependency "rspec", "~> 3.4", ">= 3.4.0"
+  s.add_runtime_dependency "json", "~> 2.6.3"
+  s.add_runtime_dependency "oauth2", "~> 2.0.9"
+  s.add_runtime_dependency "rest-client", "~> 2.1.0"
+  s.add_runtime_dependency "typhoeus", "~> 1.4"
 
   s.metadata["allowed_push_host"] = "https://rubygems.org"
 
   s.files = Dir.glob("lib/**/*.{rake,rb}") + ["#{ s.name }.gemspec", "README.md"]
-  s.test_files    = `find spec/*`.split("\n")
   s.executables   = []
   s.require_paths = ["lib"]
+  s.metadata["rubygems_mfa_required"] = "true"
 end