grac 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b7388a3893226c18a95cf03b7f9c11dada6f6bc
-  data.tar.gz: 617dd5a6f749929bbe26277bfd0ae9b26fe91091
+  metadata.gz: 33443c6f3e578e14ecc60fcffe50fb7c27d6ce6b
+  data.tar.gz: 60df99b767b5cfe672c6981faeb561e65b7f82ab
 SHA512:
-  metadata.gz: bf132d0ea4f5d427c36b79c5a3fa124bad63990eef29e8974252b09658cc78e6e3c0df9e95ed914cb9416a144569a942bccdf7a57c25f2076e19c055324640f0
-  data.tar.gz: b1dc8341930b7352ff18484f0591c038fc8d4269915195b69b340cbb50bf8a802448f83e9a0c43a18d63e1b30bca32be489d517952d195677ee18c74c81be13c
+  metadata.gz: c60ec0246b6bfde509fbcdbde29e382839822113a777d218d1f01a340164d5ab4e141b3cc652a5f04e59806e86b6622bb5b292776d38fa2fb60e5c229be8d0d9
+  data.tar.gz: 338143fb8bb70fb2e237a6f25c10748e705260be627d0b9f7ff67a7359d1e50a4c55dd91be0b100895bff9ae7e2fa4d5e569a38c8b9d5aa6414d890aa2761a1e

data/lib/grac/client.rb

@@ -19,7 +19,7 @@ module Grac
         :params         => options[:params]         || {},
         :headers        => { "User-Agent" => "Grac v#{Grac::VERSION}" }.merge(options[:headers] || {}),
         :postprocessing => options[:postprocessing] || {},
-        :middleware     => options[:middleware]    || []
+        :middleware     => options[:middleware]     || []
       }
       @options.freeze
       [:params, :headers, :postprocessing, :middleware].each do |k|
@@ -30,7 +30,7 @@ module Grac
 
     def set(options = {})
       options = options.merge({
-        headers:    @options[:headers].merge(options[:headers]      || {}),
+        headers:    @options[:headers].merge(options[:headers]    || {}),
         middleware: @options[:middleware] + (options[:middleware] || [])
       })
 
@@ -46,103 +46,118 @@ module Grac
 
     %w{post put patch}.each do |method|
       define_method method do |body = {}, params = {}|
-        request = build_request(method, { :body => body, :params => params })
-        run(request)
+        response = build_and_run(method, { :body => body, :params => params })
+        check_response(method, response)
       end
     end
 
     %w{get delete}.each do |method|
       define_method method do |params = {}|
-        request = build_request(method, { :params => params })
-        run(request)
+        response = build_and_run(method, { :params => params })
+        check_response(method, response)
       end
     end
 
-    private
-      def build_request(method, options = {})
-        body   = options[:body].nil? || options[:body].empty? ? nil : options[:body].to_json
-        params = @options[:params].merge(options[:params] || {})
-
-        opts        = @options
-        request_uri = uri
+    def call(opts, request_uri, method, params, body)
+      request_hash = {
+        :method         => method,
+        :params         => params,
+        :body           => body,
+        :connecttimeout => opts[:connecttimeout],
+        :timeout        => opts[:timeout],
+        :headers        => opts[:headers]
+      }
 
-        @options[:middleware].each do |mw|
-          opts, request_uri, method, params, body = mw.call(opts, request_uri, method, params, body)
-        end
+      request  = ::Typhoeus::Request.new(request_uri, request_hash)
+      response = request.run
 
-        request_hash = { :method => method }
-        request_hash[:params]         = params
-        request_hash[:body]           = body
-        request_hash[:connecttimeout] = opts[:connecttimeout]
-        request_hash[:timeout]        = opts[:timeout]
-        request_hash[:headers]        = opts[:headers]
+      # Retry GET and HEAD requests - modifying requests might not be idempotent
+      response = request.run if response.timed_out? && ['get', 'head'].include?(method)
 
-        return ::Typhoeus::Request.new(request_uri, request_hash)
+      # 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
+      # detecting a timeout.
+      if response.timed_out?
+        raise Exception::ServiceTimeout.new(method, request.url, response.return_message)
       end
 
-      def postprocessing(data, processing = nil)
-        return data if @options[:postprocessing].nil? || @options[:postprocessing].empty?
+      return Response.new(response)
+    end
 
-        if data.kind_of?(Hash)
-          data.each do |key, value|
-            processing = nil
-            @options[:postprocessing].each do |regex, action|
-              if /#{regex}/ =~ key
-                processing = action
-              end
-            end
+    private
 
-            data[key] = postprocessing(value, processing)
-          end
-        elsif data.kind_of?(Array)
-          data.each_with_index do |value, index|
-            data[index] = postprocessing(value, processing)
-          end
+    def build_and_run(method, options = {})
+      body   = options[:body].nil? || options[:body].empty? ? nil : options[:body].to_json
+      params = @options[:params].merge(options[:params] || {})
+      return middleware_chain.call(@options, uri, method, params, body)
+    end
+
+    def middleware_chain
+      callee = self
+
+      @options[:middleware].reverse.each do |mw|
+        if mw.kind_of?(Array)
+          middleware_class = mw[0]
+          params           = mw[1..-1]
+
+          callee = middleware_class.new(callee, *params)
         else
-          data = processing.nil? ? data : processing.call(data)
+          callee = mw.new(callee)
         end
-
-        return data
       end
 
-      def run(request)
-        response = request.run
+      return callee
+    end
 
-        # Retry GET and HEAD requests - modifying requests might not be idempotent
-        method = request.options[:method].to_s.downcase
-        response = request.run if response.timed_out? && ['get', 'head'].include?(method)
+    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
 
-        # 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
-        # detecting a timeout.
-        if response.timed_out?
-          raise Exception::ServiceTimeout.new(method, request.url, response.return_message)
-        end
+          return response.body
+        when 204, 205
+          return true
+        when 0
+          raise Exception::RequestFailed.new(method, response.effective_url, response.return_message)
+        when 400
+          raise Exception::BadRequest.new(method, response.effective_url, response.parsed_or_raw_body)
+        when 403
+          raise Exception::Forbidden.new(method, response.effective_url, response.parsed_or_raw_body)
+        when 404
+          raise Exception::NotFound.new(method, response.effective_url, response.parsed_or_raw_body)
+        when 409
+          raise Exception::Conflict.new(method, response.effective_url, response.parsed_or_raw_body)
+        else
+          raise Exception::ServiceError.new(method, response.effective_url, response.parsed_or_raw_body)
+      end
+    end
+
+    def postprocessing(data, processing = nil)
+      return data if @options[:postprocessing].nil? || @options[:postprocessing].empty?
 
-        grac_response = Response.new(response)
-        case response.code
-          when 200..203, 206..299
-            # unknown status codes must be treated as the x00 of their class, so 200
-            if grac_response.json_content?
-              return postprocessing(grac_response.parsed_json)
+      if data.kind_of?(Hash)
+        data.each do |key, value|
+          processing = nil
+          @options[:postprocessing].each do |regex, action|
+            if /#{regex}/ =~ key
+              processing = action
             end
+          end
 
-            return grac_response.body
-          when 204, 205
-            return true
-          when 0
-            raise Exception::RequestFailed.new(method, request.url, response.return_message)
-          when 400
-            raise Exception::BadRequest.new(method, request.url, grac_response.parsed_or_raw_body)
-          when 403
-            raise Exception::Forbidden.new(method, request.url, grac_response.parsed_or_raw_body)
-          when 404
-            raise Exception::NotFound.new(method, request.url, grac_response.parsed_or_raw_body)
-          when 409
-            raise Exception::Conflict.new(method, request.url, grac_response.parsed_or_raw_body)
-          else
-            raise Exception::ServiceError.new(method, request.url, grac_response.parsed_or_raw_body)
+          data[key] = postprocessing(value, processing)
         end
+      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
+
+      return data
+    end
   end
 end

data/lib/grac/response.rb

@@ -8,9 +8,13 @@ module Grac
     extend Forwardable
 
     def_delegator :@response, :body
+    def_delegator :@response, :code
+    def_delegator :@response, :effective_url
+    def_delegator :@response, :headers
+    def_delegator :@response, :return_message
 
     def initialize(typhoeus_response)
-      @response = typhoeus_response
+      @response    = typhoeus_response
     end
 
     def content_type

data/lib/grac/version.rb

@@ -1,3 +1,3 @@
 module Grac
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grac
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Tobias Schoknecht
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-22 00:00:00.000000000 Z
+date: 2016-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake