wrest 2.1.9 → 4.0.0

data/lib/wrest/native/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2009 Sidu Ponnappa
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -7,117 +9,153 @@
 # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and limitations under the License.
 
-module Wrest::Native
-  # This represents a HTTP request. Typically you will never need to instantiate
-  # one of these yourself - you can use one of the more conveient APIs via Wrest::Uri
-  # or Wrest::Native::Get etc. instead.
-  class Request
-    attr_reader :http_request, :uri, :body, :headers, :username, :password, :follow_redirects,
-                :follow_redirects_limit, :follow_redirects_count, :timeout, :connection, :parameters,
-                :cache_store, :verify_mode, :options, :ca_path
-    # Valid tuples for the options are:
-    #   :username => String, defaults to nil
-    #   :password => String, defaults to nil
-    #   :follow_redirects => Boolean, defaults to true for Get, false for anything else
-    #   :follow_redirects_limit => Integer, defaults to 5. This is the number of redirects
-    #                              that Wrest will automatically follow before raising an
-    #                              Wrest::Exceptions::AutoRedirectLimitExceeded exception.
-    #                              For example, if you set this to 1, the very first redirect
-    #                              will raise the exception.
-    #   :follow_redirects_count => Integer, defaults to 0. This is a count of the hops made to
-    #                              get to this request and increases by one for every redirect
-    #                              until the follow_redirects_limit is hit. You should never set
-    #                              this option yourself.
-    #   :timeout => The period, in seconds, after which a Timeout::Error is raised
-    #               in the event of a connection failing to open. Defaulted to 60 by Uri#create_connection.
-    #   :connection => The HTTP Connection object to use. This is how a keep-alive connection can be
-    #                  used for multiple requests.
-    #   :cache_store => The object which should be used as cache store for cacheable responses. If not supplied, caching will be disabled.
-    #   :callback => A Hash whose keys are the response codes (or Range of response codes),
-    #                        and the values are the callback functions to be executed.
-    #                        eg: { <response code> => lambda { |response| some_operation } }
-    #  The following options are Net::HTTP specific config options
-    #   :detailed_http_logging => nil/$stdout/$stderr or File/Logger/IO object. Defaults to nil (recommended).
-    #                             *WARNING* : detailed_http_logging causes a serious security hole. Never use it in production code.
-    #   :verify_mode => The verification mode to be used for Net::HTTP https connections. Defaults to OpenSSL::SSL::VERIFY_PEER
-    #   :ca_path => The path to the certificates
-    def initialize(wrest_uri, http_request_klass, parameters = {}, body = nil, headers = {}, options = {})
-      @uri = wrest_uri
-      @headers = headers.stringify_keys
-      @parameters = parameters
-      @body = body
-      @options = options.clone
-      @username = @options[:username]
-      @password = @options[:password]
-      @follow_redirects = (@options[:follow_redirects] ||= false)
-      @follow_redirects_count = (@options[:follow_redirects_count] ||= 0)
-      @follow_redirects_limit = (@options[:follow_redirects_limit] ||= 5)
-      @timeout = @options[:timeout]
-      @connection = @options[:connection]
-      @http_request = self.build_request(http_request_klass, @uri, @parameters, @headers)
-      @cache_store = @options[:cache_store]
-      @verify_mode = @options[:verify_mode]
-      @ca_path = @options[:ca_path]
-      @detailed_http_logging = options[:detailed_http_logging]
-      @callback = @options[:callback] || Wrest::Callback.new({})
-      @callback = @callback.merge(Wrest::Callback.new(@options[:callback_block] || {}))
-    end
+module Wrest
+  module Native
+    # This represents a HTTP request. Typically you will never need to instantiate
+    # one of these yourself - you can use one of the more conveient APIs via Wrest::Uri
+    # or Wrest::Native::Get etc. instead.
+    class Request
+      attr_reader :http_request, :uri, :body, :headers, :username, :password, :follow_redirects,
+                  :follow_redirects_limit, :follow_redirects_count, :timeout, :connection, :parameters,
+                  :cache_store, :verify_mode, :options, :ca_path
 
-    # Makes a request, runs the appropriate callback if any and
-    # returns a Wrest::Native::Response.
-    #
-    # Data about the request is and logged to Wrest.logger
-    # The log entry contains the following information:
-    #
-    #   <- indicates a request
-    #   -> indicates a response
-    #
-    # The type of request is mentioned in caps, followed by a hash
-    # uniquely identifying a particular request/response pair.
-    # In a multi-process or multi-threaded scenario, this can be used
-    # to identify request-response pairs.
-    #
-    # The request hash is followed by a connection hash; requests using the
-    # same connection (effectively a keep-alive connection) will have the
-    # same connection hash.
-    #
-    # This is followed by the response code, the payload size and the time taken.
-    def invoke
-      response = nil
-      @connection ||= @uri.create_connection(:timeout => timeout, :verify_mode => verify_mode, :ca_path => ca_path)
-      @connection.set_debug_output @detailed_http_logging
-      http_request.basic_auth username, password unless username.nil? || password.nil?
-
-      prefix = "#{http_request.method} #{self.hash} #{@connection.hash} #{Thread.current.object_id}"
-
-      Wrest.logger.debug "<- (#{prefix}) #{@uri.protocol}://#{@uri.host}:#{@uri.port}#{@http_request.path}"
-      Wrest.logger.debug "<- Body: #{@body}"
-      time = Benchmark.realtime { response = Wrest::Native::Response.new( do_request ) }
-
-      execute_callback_if_any(response)
-
-      @follow_redirects ? response.follow(@options) : response
-    rescue Timeout::Error => e
-      raise Wrest::Exceptions::Timeout.new(e)
-    end
+      # Valid tuples for the options are:
+      #   :username => String, defaults to nil
+      #   :password => String, defaults to nil
+      #   :follow_redirects => Boolean, defaults to true for Get, false for anything else
+      #   :follow_redirects_limit => Integer, defaults to 5. This is the number of redirects
+      #                              that Wrest will automatically follow before raising an
+      #                              Wrest::Exceptions::AutoRedirectLimitExceeded exception.
+      #                              For example, if you set this to 1, the very first redirect
+      #                              will raise the exception.
+      #   :follow_redirects_count => Integer, defaults to 0. This is a count of the hops made to
+      #                              get to this request and increases by one for every redirect
+      #                              until the follow_redirects_limit is hit. You should never set
+      #                              this option yourself.
+      #   :timeout => The period, in seconds, after which a Timeout::Error is raised
+      #               in the event of a connection failing to open. Defaulted to 60 by Uri#create_connection.
+      #   :connection => The HTTP Connection object to use. This is how a keep-alive connection can be
+      #                  used for multiple requests.
+      #   :cache_store => The object which should be used as cache store for cacheable responses. If not supplied, caching will be disabled.
+      #   :callback => A Hash whose keys are the response codes (or Range of response codes),
+      #                        and the values are the callback functions to be executed.
+      #                        eg: { <response code> => lambda { |response| some_operation } }
+      #  The following options are Net::HTTP specific config options
+      #   :detailed_http_logging => nil/$stdout/$stderr or File/Logger/IO object. Defaults to nil (recommended).
+      #                             *WARNING* : detailed_http_logging causes a serious security hole. Never use it in production code.
+      #   :verify_mode => The verification mode to be used for Net::HTTP https connections. Defaults to OpenSSL::SSL::VERIFY_PEER
+      #   :ca_path => The path to the certificates
+      def initialize(wrest_uri, http_request_klass, parameters = {}, body = nil, headers = {}, options = {}) # rubocop:disable Metrics/ParameterLists
+        setup_request_state!(body, headers, parameters, wrest_uri)
+        setup_options_state!(options)
+        @detailed_http_logging = options[:detailed_http_logging]
+        @follow_redirects = (@options[:follow_redirects] ||= false)
+        @follow_redirects_count = (@options[:follow_redirects_count] ||= 0)
+        @follow_redirects_limit = (@options[:follow_redirects_limit] ||= 5)
+        @callback = @options[:callback] || Wrest::Callback.new({})
+        @callback = @callback.merge(Wrest::Callback.new(@options[:callback_block] || {}))
+        @http_request = build_request(http_request_klass, @uri, @parameters, @headers)
+      end
+
+      # Makes a request, runs the appropriate callback if any and
+      # returns a Wrest::Native::Response.
+      #
+      # Data about the request is and logged to Wrest.logger
+      # The log entry contains the following information:
+      #
+      #   <- indicates a request
+      #   -> indicates a response
+      #
+      # The type of request is mentioned in caps, followed by a hash
+      # uniquely identifying a particular request/response pair.
+      # In a multi-process or multi-threaded scenario, this can be used
+      # to identify request-response pairs.
+      #
+      # The request hash is followed by a connection hash; requests using the
+      # same connection (effectively a keep-alive connection) will have the
+      # same connection hash.
+      #
+      # Passing nil for either username or password will skip HTTP authentication
+      #
+      # This is followed by the response code, the payload size and the time taken.
+      def invoke
+        response = nil
+        setup_connection!
+
+        response = execute_request(response)
+
+        execute_callback_if_any(response)
 
-    #:nodoc:
-    def build_request(request_klass, uri, parameters, headers)
-      if(!uri.query.empty?)
-        request_klass.new(parameters.empty? ? "#{uri.uri_path}?#{uri.query}" : "#{uri.uri_path}?#{uri.query}&#{parameters.to_query}", headers)
-      else
-        request_klass.new(parameters.empty? ? "#{uri.uri_path}" : "#{uri.uri_path}?#{parameters.to_query}", headers)
+        @follow_redirects ? response.follow(@options) : response
+      rescue Timeout::Error => e
+        raise Wrest::Exceptions::Timeout, e
       end
-    end
 
-    #:nodoc:
-    def do_request
-      @connection.request(@http_request, @body)
-    end
+      # :nodoc:
+      def build_request(request_klass, uri, parameters, headers)
+        if uri.query.empty?
+          request_klass.new(parameters.empty? ? uri.uri_path.to_s : "#{uri.uri_path}?#{Utils.hash_to_param(parameters)}", headers)
+        else
+          request_klass.new(
+            parameters.empty? ? "#{uri.uri_path}?#{uri.query}" : "#{uri.uri_path}?#{uri.query}&#{Utils.hash_to_param(parameters)}", headers
+          )
+        end
+      end
+
+      # :nodoc:
+      def do_request
+        @connection.request(@http_request, @body)
+      end
+
+      # :nodoc:
+      def execute_callback_if_any(actual_response)
+        @callback.execute(actual_response)
+      end
 
-    #:nodoc:
-    def execute_callback_if_any(actual_response)
-      @callback.execute(actual_response)
+      private
+
+      def setup_connection!
+        @connection ||= @uri.create_connection(timeout: timeout, verify_mode: verify_mode, ca_path: ca_path)
+        @connection.set_debug_output @detailed_http_logging
+        http_request.basic_auth(username, password) unless username.nil? || password.nil?
+      end
+
+      def execute_request(response)
+        prefix = "#{http_request.method} #{hash} #{@connection.hash} #{Thread.current.object_id}"
+
+        log_before_request(prefix)
+        time = Benchmark.realtime { response = Wrest::Native::Response.new(do_request) }
+        log_after_request(prefix, time)
+
+        response
+      end
+
+      def log_after_request(prefix, time)
+        Wrest.logger.debug "<- (#{prefix}) Time: #{time}"
+      end
+
+      def log_before_request(prefix)
+        Wrest.logger.debug "<- (#{prefix}) #{@uri.protocol}://#{@uri.host}:#{@uri.port}#{@http_request.path}"
+        Wrest.logger.debug "<- (#{prefix}) Body: #{@body}"
+      end
+
+      def setup_request_state!(body, headers, parameters, wrest_uri)
+        @uri = wrest_uri
+        @headers = headers.transform_keys(&:to_s)
+        @parameters = parameters
+        @body = body
+      end
+
+      def setup_options_state!(options)
+        @options = options.clone
+        @username = @options[:username]
+        @password = @options[:password]
+        @timeout = @options[:timeout]
+        @connection = @options[:connection]
+        @cache_store = @options[:cache_store]
+        @verify_mode = @options[:verify_mode]
+        @ca_path = @options[:ca_path]
+      end
     end
   end
 end

data/lib/wrest/native/response.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 # Copyright 2009 Sidu Ponnappa
 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at Http://www.apache.org/licenses/LICENSE-2.0
-# Unless required by applicable law or agreed to in writing, software distributed under the License 
-# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and limitations under the License. 
-require "rexml/document"
-module Wrest #:nodoc:
-  module Native #:nodoc:
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+require 'rexml/document'
+module Wrest # :nodoc:
+  module Native # :nodoc:
     # Decorates a response providing support for deserialisation.
     #
     # The following methods are also available (unlisted by rdoc because they're forwarded to Net::HTTP::Response):
@@ -25,11 +27,12 @@ module Wrest #:nodoc:
     class Response
       attr_reader :http_response
       attr_accessor :deserialised_body
+
       include HttpCodes
-      
+
       extend Forwardable
-      def_delegators  :@http_response,  :code, :message, :body, :http_version,
-              :content_length, :content_type
+      def_delegators :@http_response, :code, :message, :body, :http_version,
+                     :content_length, :content_type
 
       def_delegators :headers, :[]
 
@@ -42,7 +45,7 @@ module Wrest #:nodoc:
       # on the response code.
       def self.new(http_response)
         code = http_response.code.to_i
-        instance = ((300..303).include?(code) || (305..399).include?(code)  ? Wrest::Native::Redirection : self).allocate
+        instance = ((300..303).include?(code) || (305..399).include?(code) ? Wrest::Native::Redirection : self).allocate
         instance.send :initialize, http_response
         instance
       end
@@ -57,32 +60,29 @@ module Wrest #:nodoc:
 
       # Checks equality between two Wrest::Native::Response objects.
       def ==(other)
-        return true if self.equal?(other)
+        return true if equal?(other)
         return false unless other.class == self.class
-        return true if self.code == other.code and
-            self.headers == other.headers and
-            self.http_version == other.http_version and
-            self.message == other.message and
-            self.body == other.body
+        return true if these_fields_are_equal(other)
+
         false
       end
 
       # Return the hash of a Wrest::Native::Response object.
       def hash
-        self.code.hash + self.message.hash + self.headers.hash + self.http_version.hash + self.body.hash
+        [code, message, headers, http_version, body].hash
       end
 
-
       def deserialise(options = {})
-        @deserialised_body ||= deserialise_using(Wrest::Components::Translators.lookup(@http_response.content_type),options)
+        @deserialised_body ||= deserialise_using(Wrest::Components::Translators.lookup(@http_response.content_type),
+                                                 options)
       end
 
       def deserialize(options = {})
         deserialise(options)
       end
 
-      def deserialise_using(translator,options = {})
-        translator.deserialise(@http_response,options)
+      def deserialise_using(translator, options = {})
+        translator.deserialise(@http_response, options)
       end
 
       def deserialize_using(options = {})
@@ -93,13 +93,11 @@ module Wrest #:nodoc:
       def headers
         return @headers if @headers
 
-        nethttp_headers_with_string_values=@http_response.to_hash.inject({}) {|new_headers, (old_key, old_value)|
-          new_headers[old_key] = old_value.is_a?(Array) ? old_value.join(",") : old_value
-          new_headers
-          }
-        
-        @headers=Wrest::HashWithCaseInsensitiveAccess.new(nethttp_headers_with_string_values)
+        nethttp_headers_with_string_values = @http_response.to_hash.transform_values do |old_value|
+          old_value.is_a?(Array) ? old_value.join(',') : old_value
+        end
 
+        @headers = Wrest::HashWithCaseInsensitiveAccess.new(nethttp_headers_with_string_values)
       end
 
       # A null object implementation - invoking this method on
@@ -107,7 +105,7 @@ module Wrest #:nodoc:
       # the response is Redirection (code 3xx), in which case a
       # get is invoked on the url stored in the response headers
       # under the key 'location' and the new Response is returned.
-      def follow(redirect_request_options = {})
+      def follow(_redirect_request_options = {})
         self
       end
 
@@ -115,77 +113,74 @@ module Wrest #:nodoc:
         self[Native::StandardHeaders::Connection].downcase == Native::StandardTokens::Close.downcase
       end
 
-      # Returns whether this response is cacheable. 
+      # Returns whether this response is cacheable.
       def cacheable?
-        code_cacheable? && no_cache_flag_not_set? && no_store_flag_not_set? &&
-        (not max_age.nil? or (expires_not_in_our_past? && expires_not_in_its_past?)) && pragma_nocache_not_set? &&
-        vary_header_valid?
+        cache_configs_set? &&
+          (!max_age.nil? or (expires_not_in_our_past? && expires_not_in_its_past?)) && pragma_nocache_not_set? &&
+          vary_header_valid?
       end
 
-      #:nodoc:
+      # :nodoc:
       def code_cacheable?
-        !code.nil? && ([200, 203, 300, 301, 302, 304, 307].include?(code.to_i))
+        !code.nil? && [200, 203, 300, 301, 302, 304, 307].include?(code.to_i)
       end
 
-      #:nodoc:
+      # :nodoc:
       def vary_header_valid?
         headers['vary'] != '*'
       end
 
-      #:nodoc:
+      # :nodoc:
       def max_age
         return @max_age if @max_age
 
-        max_age  =cache_control_headers.grep(/max-age/)
+        max_age = cache_control_headers.grep(/max-age/)
 
-        @max_age = unless max_age.empty?
-                     max_age.first.split('=').last.to_i
-                   else
-                     nil
-                   end
+        @max_age = (max_age.first.split('=').last.to_i unless max_age.empty?)
       end
 
       def no_cache_flag_not_set?
-        not cache_control_headers.include?('no-cache')
+        !cache_control_headers.include?('no-cache')
       end
 
       def no_store_flag_not_set?
-        not cache_control_headers.include?('no-store')
+        !cache_control_headers.include?('no-store')
       end
 
       def pragma_nocache_not_set?
-        headers['pragma'].nil? || (not headers['pragma'].include? 'no-cache')
+        headers['pragma'].nil? || (!headers['pragma'].include? 'no-cache')
       end
 
       # Returns the Date from the response headers.
       def response_date
         return @response_date if @response_date
-        @response_date = parse_datefield(headers, "date")
-      end
 
+        @response_date = parse_datefield(headers, 'date')
+      end
 
       # Returns the Expires date from the response headers.
       def expires
         return @expires if @expires
-        @expires = parse_datefield(headers, "expires")
+
+        @expires = parse_datefield(headers, 'expires')
       end
 
-      # Returns whether the Expires header of this response is earlier than current time.    
+      # Returns whether the Expires header of this response is earlier than current time.
       def expires_not_in_our_past?
         if expires.nil?
           false
         else
-          expires.to_i > Time.now.to_i
+          Utils.datetime_to_i(expires) > Time.now.to_i
         end
       end
 
       # Is the Expires of this response earlier than its Date header.
       def expires_not_in_its_past?
         # Invalid header value for Date or Expires means the response is not cacheable
-        if  expires.nil? || response_date.nil?
+        if expires.nil? || response_date.nil?
           false
         else
-           expires > response_date
+          expires > response_date
         end
       end
 
@@ -194,10 +189,14 @@ module Wrest #:nodoc:
         current_time = Time.now.to_i
 
         # RFC 2616 13.2.3 Age Calculations. TODO: include response_delay in the calculation as defined in RFC. For this, include original Request with Response.
-        date_value             = DateTime.parse(headers['date']).to_i rescue current_time
-        age_value              = headers['age'].to_i || 0
+        date_value = begin
+          Utils.datetime_to_i(DateTime.parse(headers['date']))
+        rescue StandardError
+          current_time
+        end
+        age_value = headers['age'].to_i || 0
 
-        apparent_age           = current_time - date_value
+        apparent_age = current_time - date_value
 
         [apparent_age, age_value].max
       end
@@ -207,9 +206,11 @@ module Wrest #:nodoc:
         @cache_control_headers ||= recalculate_cache_control_headers
       end
 
-      #:nodoc:
+      # :nodoc:
       def recalculate_cache_control_headers
-        headers['cache-control'].split(",").collect {|cc| cc.strip } rescue []
+        headers['cache-control'].split(',').collect(&:strip)
+      rescue StandardError
+        []
       end
 
       # How long (in seconds) is this response expected to be fresh
@@ -217,22 +218,20 @@ module Wrest #:nodoc:
         @freshness_lifetime ||= recalculate_freshness_lifetime
       end
 
-      #:nodoc:
+      # :nodoc:
       def recalculate_freshness_lifetime
         return max_age if max_age
 
-        response_date = DateTime.parse(headers['date']).to_i
-        expires_date  = DateTime.parse(headers['expires']).to_i
+        response_date = Utils.datetime_to_i(DateTime.parse(headers['date']))
+        expires_date = Utils.datetime_to_i(DateTime.parse(headers['expires']))
 
-        return (expires_date - response_date)
+        (expires_date - response_date)
       end
 
       # Has this response expired? The expiry is calculated from the Max-Age/Expires header.
       def expired?
-        freshness=freshness_lifetime
-        if freshness <= 0
-          return true
-        end
+        freshness = freshness_lifetime
+        return true if freshness <= 0
 
         freshness <= current_age
       end
@@ -244,26 +243,36 @@ module Wrest #:nodoc:
       # Can this response be validated by sending a validation request to the server. The response need to have either
       # Last-Modified or ETag header (or both) for it to be validatable.
       def can_be_validated?
-        not (last_modified.nil? and headers['etag'].nil?)
+        !(last_modified.nil? and headers['etag'].nil?)
       end
 
-
-      #:nodoc:
+      # :nodoc:
       # helper function. Used to parse date fields.
       # this function is used and tested by the expires and response_date methods
       def parse_datefield(hash, key)
-        if hash[key]
-          # Can't trust external input. Do not crash even if invalid dates are passed.
-          begin
-            DateTime.parse(hash[key].to_s)
-          rescue ArgumentError
-            nil
-          end
-        else
+        return unless hash[key]
+
+        # Can't trust external input. Do not crash even if invalid dates are passed.
+        begin
+          DateTime.parse(hash[key].to_s)
+        rescue ArgumentError
           nil
         end
       end
 
+      private
+
+      def cache_configs_set?
+        code_cacheable? && no_cache_flag_not_set? && no_store_flag_not_set?
+      end
+
+      def these_fields_are_equal(other)
+        (code == other.code) &&
+          (headers == other.headers) &&
+          (http_version == other.http_version) &&
+          (message == other.message) &&
+          (body == other.body)
+      end
     end
   end
 end