grac 4.1.0 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bf256f12e71313e81a5c88ae39bb5b4e722d35d84a6ed9e2c041ff04c726d4d
-  data.tar.gz: 6a96ca28f2b8ef42a62e6921259b71dd3c0a56c27a5be17bb6432b42868de265
+  metadata.gz: 8460d522d154cc9553f4a67210e6509fd1e1e5d9b956cccf4e3e4701eccd6135
+  data.tar.gz: a8c70bc97eadf86324176c301b4bc5bd856f4d20e402ba111236860734d8e0b6
 SHA512:
-  metadata.gz: e003de0eff3e693c0363ba506e3575c922a805acf893374d65c134b2951fe06fb1bc5e40d474ff6ca4627babafcfc09ff0cf828ad930a26df2e0dfdd30b731d1
-  data.tar.gz: 19c10aaeddc339d86565c3c6e6848eb713f69d5c3e420825149f018c954910abe9b8c840db8a53aa5b32d57d74986f06e997d9adbc2883afe0c839281e8a8b09
+  metadata.gz: 2db352fde7d23f9e42d578b50c08c702232c096d0de59d4ed1075bf4db63946fbff16335de25bdbac7d076e9f176a8b18b78f506bd7c5b3fe8bb81e4d9d8ba57
+  data.tar.gz: 146317de75aa8ab0a276016b90cd3aac920594424edc2f601b650bc64746ff531c360b34997be1e6d1af73676826948ddb573ac4be2b11e004a24aed4250d779

data/lib/grac/client.rb

@@ -8,6 +8,7 @@ require_relative './response'
 
 module Grac
   class Client
+
     attr_reader :uri
 
     def initialize(uri, options = {})
@@ -15,21 +16,22 @@ module Grac
 
       @uri = uri
       @options = {
-        :connecttimeout => options[:connecttimeout] || 0.1,
-        :timeout        => options[:timeout]        || 15,
-        :params         => options[:params]         || {},
-        :headers        => {
-          "User-Agent"   => "Grac v#{Grac::VERSION}",
-          "Content-Type" => "application/json;charset=utf-8"
+        connecttimeout: options[:connecttimeout] || 0.1,
+        timeout:        options[:timeout]        || 15,
+        params:         options[:params]         || {},
+        headers:        {
+          'User-Agent'   => "Grac v#{Grac::VERSION}",
+          'Content-Type' => 'application/json;charset=utf-8'
         }.merge(options[:headers] || {}),
-        :postprocessing => {},
-        :middleware     => options[:middleware]     || []
+        postprocessing: {},
+        middleware:     options[:middleware] || [],
+        retry_get_head: options.fetch(:retry_get_head, true),
       }
 
       if options[:postprocessing]
         options[:postprocessing]
           .each_with_object(postprocessing = {}) do |(pattern, transformation), obj|
-          if pattern.kind_of?(Regexp)
+          if pattern.is_a?(Regexp)
             obj[pattern] = transformation
           else
             obj[Regexp.new(pattern)] = transformation
@@ -49,10 +51,12 @@ module Grac
     end
 
     def set(options = {})
-      options = options.merge({
-        headers:    @options[:headers].merge(options[:headers]    || {}),
-        middleware: @options[:middleware] + (options[:middleware] || [])
-      })
+      options = options.merge(
+                  {
+                    headers:    @options[:headers].merge(options[:headers]    || {}),
+                    middleware: @options[:middleware] + (options[:middleware] || []),
+                  },
+                )
 
       self.class.new(@uri, @options.merge(options))
     end
@@ -64,35 +68,38 @@ module Grac
       self.class.new("#{@uri}#{path}", @options)
     end
 
-    %w{post put patch}.each do |method|
+    ['post', 'put', 'patch'].each do |method|
       define_method method do |body = {}, params = {}|
-        response = build_and_run(method, { :body => body, :params => params })
+        response = build_and_run(method, { body: body, params: params })
         check_response(method, response)
       end
     end
 
-    %w{get delete}.each do |method|
+    ['get', 'delete'].each do |method|
       define_method method do |params = {}|
-        response = build_and_run(method, { :params => params })
+        response = build_and_run(method, { params: params })
         check_response(method, response)
       end
     end
 
     def call(opts, request_uri, method, params, body)
       request_hash = {
-        :method         => method,
-        :params         => params,  # Query params are escaped by Typhoeus
-        :body           => body,
-        :connecttimeout => opts[:connecttimeout],
-        :timeout        => opts[:timeout],
-        :headers        => opts[:headers]
+        method:         method,
+        params:         params,  # Query params are escaped by Typhoeus
+        body:           body,
+        connecttimeout: opts[:connecttimeout],
+        timeout:        opts[:timeout],
+        headers:        opts[:headers],
       }
 
       request  = ::Typhoeus::Request.new(request_uri, request_hash)
       response = request.run
 
       # Retry GET and HEAD requests - modifying requests might not be idempotent
-      response = request.run if response.timed_out? && ['get', 'head'].include?(method)
+      # Only retry those requests if the feature is enabled
+      if response.timed_out? && ['get', 'head'].include?(method) && @options[:retry_get_head]
+        response = request.run
+      end
 
       # A request can time out while receiving data. In this case response.code might indicate
       # success although data hasn't been fully transferred. Thus rely on Typhoeus for
@@ -119,122 +126,123 @@ module Grac
 
     private
 
-    def build_and_run(method, options = {})
-      body   = prepare_body_by_content_type(options[:body])
-      params = @options[:params].merge(options[:params] || {})
-      return middleware_chain.call(@options, uri, method, params, body)
-    end
-
-    def headers
-      @options[:headers] || {}
-    end
-
-    def prepare_body_by_content_type(body)
-      return nil if body.nil? || body.empty?
-
-      case headers['Content-Type']
-      when /\Aapplication\/json/
-        return body.to_json
-      when /\Aapplication\/x-www-form-urlencoded/
-        # Typhoeus will take care of the encoding when receiving a hash
-        return body
-      else
-        # Do not encode other unknown Content-Types either.
-        # The default is JSON through the Content-Type header which is set by default.
-        return body
+      def build_and_run(method, options = {})
+        body   = prepare_body_by_content_type(options[:body])
+        params = @options[:params].merge(options[:params] || {})
+        return middleware_chain.call(@options, uri, method, params, body)
       end
-    end
 
-    def middleware_chain
-      callee = self
+      def headers
+        @options[:headers] || {}
+      end
 
-      @options[:middleware].reverse.each do |mw|
-        if mw.kind_of?(Array)
-          middleware_class = mw[0]
-          params           = mw[1..-1]
+      def prepare_body_by_content_type(body)
+        return nil if body.nil? || body.empty?
 
-          callee = middleware_class.new(callee, *params)
+        case headers['Content-Type']
+        when /\Aapplication\/json/
+          return body.to_json
+        when /\Aapplication\/x-www-form-urlencoded/
+          # Typhoeus will take care of the encoding when receiving a hash
+          return body
         else
-          callee = mw.new(callee)
+          # Do not encode other unknown Content-Types either.
+          # The default is JSON through the Content-Type header which is set by default.
+          return body
         end
       end
 
-      return callee
-    end
+      def middleware_chain
+        callee = self
 
-    def check_response(method, response)
-      case response.code
-        when 200..203, 206..299
-          # unknown status codes must be treated as the x00 of their class, so 200
-          if response.json_content?
-            return postprocessing(response.parsed_json)
-          end
+        @options[:middleware].reverse.each do |mw|
+          if mw.kind_of?(Array)
+            middleware_class = mw[0]
+            params           = mw[1..-1]
 
-          return response.body
-        when 204, 205
-          return true
-        when 0
-          raise Exception::RequestFailed.new(method, response.effective_url, response.return_message)
-        else
-          begin
-            # The Response class doesn't have enough information to create a proper exception, so
-            # catch its exception and raise a proper one.
-            parsed_body = response.parsed_json
-          rescue Exception::InvalidContent
-            raise Exception::ErrorWithInvalidContent.new(
-              method,
-              response.effective_url,
-              response.code,
-              response.body,
-              'json'
-            )
-          end
-          case response.code
-          when 400
-            raise Exception::BadRequest.new(method, response.effective_url, parsed_body)
-          when 403
-            raise Exception::Forbidden.new(method, response.effective_url, parsed_body)
-          when 404
-            raise Exception::NotFound.new(method, response.effective_url, parsed_body)
-          when 409
-            raise Exception::Conflict.new(method, response.effective_url, parsed_body)
+            callee = middleware_class.new(callee, *params)
           else
-            raise Exception::ServiceError.new(method, response.effective_url, parsed_body)
+            callee = mw.new(callee)
           end
+        end
+
+        return callee
       end
-    end
 
-    def postprocessing(data, processing = nil)
-      return data if @options[:postprocessing].nil? || @options[:postprocessing].empty?
+      def check_response(method, response)
+        case response.code
+          when 200..203, 206..299
+            # unknown status codes must be treated as the x00 of their class, so 200
+            if response.json_content?
+              return postprocessing(response.parsed_json)
+            end
+
+            return response.body
+          when 204, 205
+            return true
+          when 0
+            raise Exception::RequestFailed.new(method, response.effective_url, response.return_message)
+          else
+            begin
+              # The Response class doesn't have enough information to create a proper exception, so
+              # catch its exception and raise a proper one.
+              parsed_body = response.parsed_json
+            rescue Exception::InvalidContent
+              raise Exception::ErrorWithInvalidContent.new(
+                method,
+                response.effective_url,
+                response.code,
+                response.body,
+                'json'
+              )
+            end
+            case response.code
+            when 400
+              raise Exception::BadRequest.new(method, response.effective_url, parsed_body)
+            when 403
+              raise Exception::Forbidden.new(method, response.effective_url, parsed_body)
+            when 404
+              raise Exception::NotFound.new(method, response.effective_url, parsed_body)
+            when 409
+              raise Exception::Conflict.new(method, response.effective_url, parsed_body)
+            else
+              raise Exception::ServiceError.new(method, response.effective_url, parsed_body)
+            end
+        end
+      end
+
+      def postprocessing(data, processing = nil)
+        return data if @options[:postprocessing].nil? || @options[:postprocessing].empty?
 
-      if data.kind_of?(Hash)
-        data.each do |key, value|
-          processing = nil
-          regexp = @options[:postprocessing].keys.detect { |pattern| pattern.match?(key) }
+        if data.kind_of?(Hash)
+          data.each do |key, value|
+            processing = nil
+            regexp = @options[:postprocessing].keys.detect { |pattern| pattern.match?(key) }
 
-          if !regexp.nil?
-            processing = @options[:postprocessing][regexp]
+            if !regexp.nil?
+              processing = @options[:postprocessing][regexp]
+            end
+            data[key] = postprocessing(value, processing)
           end
-          data[key] = postprocessing(value, processing)
-        end
-      elsif data.kind_of?(Array)
-        data.each_with_index do |value, index|
-          data[index] = postprocessing(value, processing)
+        elsif data.kind_of?(Array)
+          data.each_with_index do |value, index|
+            data[index] = postprocessing(value, processing)
+          end
+        else
+          data = processing.nil? ? data : processing.call(data)
         end
-      else
-        data = processing.nil? ? data : processing.call(data)
+
+        return data
       end
 
-      return data
-    end
+      def escape_url_param(value)
+        # We don't want spaces to be encoded as plus sign - a plus sign can be ambiguous in a URL and
+        # either represent a plus sign or a space.
+        # CGI::escape replaces all plus signs with their percent-encoding representation, so all
+        # remaining plus signs are spaces. Replacing these with a space's percent encoding makes the
+        # encoding unambiguous.
+        CGI::escape(value).gsub('+', '%20')
+      end
 
-    def escape_url_param(value)
-      # We don't want spaces to be encoded as plus sign - a plus sign can be ambiguous in a URL and
-      # either represent a plus sign or a space.
-      # CGI::escape replaces all plus signs with their percent-encoding representation, so all
-      # remaining plus signs are spaces. Replacing these with a space's percent encoding makes the
-      # encoding unambiguous.
-      CGI::escape(value).gsub('+', '%20')
-    end
   end
 end

data/lib/grac/version.rb

@@ -1,3 +1,3 @@
 module Grac
-  VERSION = "4.1.0"
+  VERSION = "4.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grac
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.3.0
 platform: ruby
 authors:
 - Tobias Schoknecht
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-24 00:00:00.000000000 Z
+date: 2024-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -72,28 +72,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -138,7 +138,7 @@ homepage: https://github.com/Barzahlen/grac
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -146,15 +146,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubygems_version: 3.5.3
+signing_key: 
 specification_version: 4
 summary: Very generic client for REST API with basic error handling
 test_files: []