wrest 4.0.0-universal-java-18

data/lib/wrest/native/response.rb

@@ -0,0 +1,278 @@
+# 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.
+# 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:
+    # Decorates a response providing support for deserialisation.
+    #
+    # The following methods are also available (unlisted by rdoc because they're forwarded to Net::HTTP::Response):
+    #
+    # <tt>:@Http_response,  :code, :message, :body, :Http_version,
+    # :[], :content_length, :content_type, :each_header, :each_name, :each_value, :fetch,
+    # :get_fields, :key?, :type_params</tt>
+    #
+    # They behave exactly like their Net::HttpResponse equivalents.
+    #
+    # Also provides set of HTTP response code checkers. For instance, the method ok? checks if the response was
+    # successful with HTTP code 200.
+    # See HttpCodes for a list of all such response checkers.
+    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 :headers, :[]
+
+      # TODO : Are these needed in the Response namespace itself? Can be accessed from the headers method.
+      def_delegators :@http_response, :each_header, :each_name, :each_value, :fetch,
+                     :get_fields, :key?, :type_params
+
+      # We're overriding :new to act as a factory so
+      # we can build the appropriate Response instance based
+      # 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.send :initialize, http_response
+        instance
+      end
+
+      def initialize(http_response)
+        @http_response = http_response
+      end
+
+      def initialize_copy(source)
+        @headers = source.headers.clone
+      end
+
+      # Checks equality between two Wrest::Native::Response objects.
+      def ==(other)
+        return true if equal?(other)
+        return false unless other.class == self.class
+        return true if these_fields_are_equal(other)
+
+        false
+      end
+
+      # Return the hash of a Wrest::Native::Response object.
+      def 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)
+      end
+
+      def deserialize(options = {})
+        deserialise(options)
+      end
+
+      def deserialise_using(translator, options = {})
+        translator.deserialise(@http_response, options)
+      end
+
+      def deserialize_using(options = {})
+        deserialise_using(options)
+      end
+
+      # Gives a hash of the response headers. The keys of the hash are case-insensitive.
+      def headers
+        return @headers if @headers
+
+        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
+      # a response simply returns the same response unless
+      # 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 = {})
+        self
+      end
+
+      def connection_closed?
+        self[Native::StandardHeaders::Connection].downcase == Native::StandardTokens::Close.downcase
+      end
+
+      # Returns whether this response is cacheable.
+      def cacheable?
+        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:
+      def code_cacheable?
+        !code.nil? && [200, 203, 300, 301, 302, 304, 307].include?(code.to_i)
+      end
+
+      # :nodoc:
+      def vary_header_valid?
+        headers['vary'] != '*'
+      end
+
+      # :nodoc:
+      def max_age
+        return @max_age if @max_age
+
+        max_age = cache_control_headers.grep(/max-age/)
+
+        @max_age = (max_age.first.split('=').last.to_i unless max_age.empty?)
+      end
+
+      def no_cache_flag_not_set?
+        !cache_control_headers.include?('no-cache')
+      end
+
+      def no_store_flag_not_set?
+        !cache_control_headers.include?('no-store')
+      end
+
+      def pragma_nocache_not_set?
+        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
+
+      # Returns the Expires date from the response headers.
+      def expires
+        return @expires if @expires
+
+        @expires = parse_datefield(headers, 'expires')
+      end
+
+      # Returns whether the Expires header of this response is earlier than current time.
+      def expires_not_in_our_past?
+        if expires.nil?
+          false
+        else
+          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?
+          false
+        else
+          expires > response_date
+        end
+      end
+
+      # Age of the response calculated according to RFC 2616 13.2.3
+      def current_age
+        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 = 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, age_value].max
+      end
+
+      # The values in Cache-Control header as an array.
+      def cache_control_headers
+        @cache_control_headers ||= recalculate_cache_control_headers
+      end
+
+      # :nodoc:
+      def recalculate_cache_control_headers
+        headers['cache-control'].split(',').collect(&:strip)
+      rescue StandardError
+        []
+      end
+
+      # How long (in seconds) is this response expected to be fresh
+      def freshness_lifetime
+        @freshness_lifetime ||= recalculate_freshness_lifetime
+      end
+
+      # :nodoc:
+      def recalculate_freshness_lifetime
+        return max_age if max_age
+
+        response_date = Utils.datetime_to_i(DateTime.parse(headers['date']))
+        expires_date = Utils.datetime_to_i(DateTime.parse(headers['expires']))
+
+        (expires_date - response_date)
+      end
+
+      # Has this response expired? The expiry is calculated from the Max-Age/Expires header.
+      def expired?
+        freshness = freshness_lifetime
+        return true if freshness <= 0
+
+        freshness <= current_age
+      end
+
+      def last_modified
+        headers['last-modified']
+      end
+
+      # 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?
+        !(last_modified.nil? and headers['etag'].nil?)
+      end
+
+      # :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)
+        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

data/lib/wrest/native/session.rb

@@ -0,0 +1,66 @@
+# 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.
+# 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.
+
+module Wrest
+  module Native
+    # This class is a wrapper for a keep-alive HTTP connection. It simply passes the
+    # same connection instance as an option to all Wrest::Native::Request instances created using it.
+    #
+    # If at any point the server closes an existing connection during a Session by returning a
+    # Connection: Close header the current connection is destroyed and a fresh one created for the next
+    # request.
+    #
+    # The Session constructor can accept either a String URI or a Wrest::Uri as a parameter. If you
+    # need HTTP authentication, you should use a Wrest::Uri.
+    class Session
+      attr_reader :uri
+
+      def initialize(uri)
+        @uri = Wrest::Uri.new(uri)
+        @default_headers = { Wrest::Native::StandardHeaders::Connection => Wrest::Native::StandardTokens::KeepAlive }
+
+        yield(self) if block_given?
+      end
+
+      def connection
+        @connection ||= @uri.create_connection
+      end
+
+      def get(path = '', parameters = {}, headers = {})
+        maybe_destroy_connection @uri[path, { connection: connection }].get(parameters,
+                                                                            headers.merge(@default_headers))
+      end
+
+      def post(path = '', body = '', headers = {}, params = {})
+        maybe_destroy_connection @uri[path, { connection: connection }].post(body, headers.merge(@default_headers),
+                                                                             params)
+      end
+
+      def put(path = '', body = '', headers = {}, params = {})
+        maybe_destroy_connection @uri[path, { connection: connection }].put(body, headers.merge(@default_headers),
+                                                                            params)
+      end
+
+      def delete(path = '', parameters = {}, headers = {})
+        maybe_destroy_connection @uri[path, { connection: connection }].delete(parameters,
+                                                                               headers.merge(@default_headers))
+      end
+
+      def maybe_destroy_connection(response)
+        if response.connection_closed?
+          Wrest.logger.warn "Connection #{@connection.hash} has been closed by the server"
+          @connection = nil
+        end
+        response
+      end
+    end
+  end
+end

data/lib/wrest/native.rb

@@ -0,0 +1,36 @@
+# 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.
+# You may obtain a copy of the License at native://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.
+
+module Wrest
+  # Contains all native protocol related classes such as
+  # Get, Post, Request, Response etc. and uses the native
+  # Ruby Net::HTTP libraries.
+  #
+  # Wrest::Http points to this module by default.
+  module Native
+    include Wrest::HttpShared
+  end
+end
+
+require 'wrest/native/connection_factory'
+require 'wrest/native/response'
+require 'wrest/native/redirection'
+require 'wrest/native/request'
+require 'wrest/native/get'
+require 'wrest/native/put'
+require 'wrest/native/patch'
+require 'wrest/native/post'
+require 'wrest/native/delete'
+require 'wrest/native/options'
+require 'wrest/native/session'
+
+# default to using Native libs
+Wrest::Http = Wrest::Native

data/lib/wrest/test/request_patches.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Wrest
+  module Native
+    class Request
+      def invoke
+        raise Wrest::Exceptions::RealRequestMadeInTestEnvironmet,
+              'A real HTTP request was made while running tests. Please avoid using live HTTP connections while testing and replace them with mocks.'
+      end
+    end
+  end
+end

data/lib/wrest/test.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'wrest/test/request_patches'

data/lib/wrest/uri/builders.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Wrest
+  class Uri
+    # Contains methods that depend on Uri#clone to build
+    # new Uris configured in particular ways.
+    module Builders
+      # Returns a Uri object that uses threads to perform asynchronous requests.
+      def using_threads
+        clone(asynchronous_backend: Wrest::AsyncRequest::ThreadBackend.new)
+      end
+
+      # Returns a Uri object that uses eventmachine to perform asynchronous requests.
+      # Remember to do Wrest::AsyncRequest.enable_em first so that
+      # EventMachine is available for use.
+      def using_em
+        clone(asynchronous_backend: Wrest::AsyncRequest::EventMachineBackend.new)
+      end
+
+      # Returns a Uri object that uses hash for caching responses.
+      def using_hash
+        clone(cache_store: {})
+      end
+
+      # Returns a Uri object that uses memcached for caching responses.
+      # Remember to do Wrest::AsyncRequest.enable_memcached first so that
+      # memcached is available for use.
+      def using_memcached
+        clone(cache_store: Wrest::Caching::Memcached.new)
+      end
+
+      def using_redis
+        clone(cache_store: Wrest::Caching::Redis.new)
+      end
+
+      # Disables using the globally configured cache for GET requests
+      # made using the Uri returned by this method.
+      def disable_cache
+        clone(disable_cache: true)
+      end
+
+      # Sets the specified string as the cookie for the Uri
+      def using_cookie(cookie_string)
+        clone(default_headers: { Wrest::H::Cookie => cookie_string })
+      end
+    end
+  end
+end