tickethub 0.3.51 → 0.3.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3b1862803f43e2f70410a2eb6108b1d13ed51a4
-  data.tar.gz: 7a630302ee8cd1745aae8107d4635818494daf27
+  metadata.gz: 0c3d2fbee50f8b1649c00ce062145feba07d6ad1
+  data.tar.gz: e5ab1ddb6e9503d8d3a7b77c834f04223765f96b
 SHA512:
-  metadata.gz: 7aed3e243ea8f61ecdb5729b916ef64837051eee842b182617cd4e4e24e93332b8fa1c103d9af2d6fe3ad153ae2f781f126a701600253bac42b7efc8e723a390
-  data.tar.gz: d8c8e3ea78ac78453813dbadb3a51f0c76274f1bc75cc44dee55301bfeb64a4f8ecaa2e53e0d77e087a0af0321824aa95399cc662b7a0db6e5cba1a5f753e0fa
+  metadata.gz: e148ff6eede8074c3b76be0f36f69f79c5143fcf20bba3f6ef79d2784c7c5a90dceebacc38543ff7b8bab5b141be45877f2d0d243fa197442606d5fda4ed639f
+  data.tar.gz: 67e18750bd49ba334f9092d31caa2642e412b9a8d67f0d654a27698608fcbd42deb867d6f7bf4f8b356d09ffa8545b1b5eb96ba258280f58f6e01ce5b5a0c455

data/lib/tickethub/connection.rb

@@ -40,6 +40,10 @@ module Tickethub
       request(:head, path, headers, &block)
     end
 
+    def put(path, body = '', headers = {}, &block)
+      request(:put, path, body, headers, &block)
+    end
+
     def patch(path, body = '', headers = {}, &block)
       request(:patch, path, body, headers, &block)
     end
@@ -50,48 +54,72 @@ module Tickethub
 
     protected
 
+    def request=(request)
+      @request = request
+    end
+
     # Makes a request to the remote service.
     def request(method, path, *arguments)
       response = http.send(method, path, *arguments)
+      response.uri = URI.join(endpoint, path)
+
       handle_response(response)
 
-    rescue Timeout::Error => e
-      raise TimeoutError.new(e.message)
+    rescue Timeout::Error, Net::OpenTimeout => e
+      raise TimeoutError.new(@request, e.message)
     rescue OpenSSL::SSL::SSLError => e
-      raise SSLError.new(e.message)
+      raise SSLError.new(@request, e.message)
+    rescue SocketError,
+           EOFError,
+           Net::HTTPBadResponse,
+           Net::HTTPHeaderSyntaxError,
+           Net::HTTPServerException,
+           Net::ProtocolError,
+           Errno::ECONNABORTED,
+           Errno::ECONNREFUSED,
+           Errno::ECONNRESET,
+           Errno::ETIMEDOUT,
+           Errno::ENETUNREACH,
+           Errno::EHOSTUNREACH,
+           Errno::EINVAL,
+           Errno::ENOPROTOOPT => e
+      raise ErrnoError.new(@request, e.message)
+    rescue Zlib::DataError,
+           Zlib::BufError => e
+      raise ZlibError.new(@request, e.message)
     end
 
     # Handles response and error codes from the remote service.
     def handle_response(response)
       case response.code.to_i
-        when 301,302
-          raise Redirection.new(response)
-        when 200...400
-          response
-        when 400
-          raise BadRequest.new(response)
-        when 401
-          raise UnauthorizedAccess.new(response)
-        when 403
-          raise ForbiddenAccess.new(response)
-        when 404
-          raise ResourceNotFound.new(response)
-        when 405
-          raise MethodNotAllowed.new(response)
-        when 409
-          raise ResourceConflict.new(response)
-        when 410
-          raise ResourceGone.new(response)
-        when 422
-          raise ResourceInvalid.new(response)
-        when 401...500
-          raise ClientError.new(response)
-        when 500...600
-          raise ServerError.new(response)
-        else
-          raise ConnectionError.new(
-            response, "Unknown response code: #{response.code}"
-          )
+      when 200...299
+        response
+      when 300..399
+        raise Redirection.new(@request, response)
+      when 400
+        raise BadRequest.new(@request, response)
+      when 401
+        raise UnauthorizedAccess.new(@request, response)
+      when 403
+        raise ForbiddenAccess.new(@request, response)
+      when 404
+        raise ResourceNotFound.new(@request, response)
+      when 405
+        raise MethodNotAllowed.new(@request, response)
+      when 409
+        raise ResourceConflict.new(@request, response)
+      when 410
+        raise ResourceGone.new(@request, response)
+      when 422
+        raise ResourceInvalid.new(@request, response)
+      when 401...500
+        raise ClientError.new(@request, response)
+      when 500...600
+        raise ServerError.new(@request, response)
+      else
+        raise ResponseError.new(
+          @request, response, "Unknown response code: #{response.code}"
+        )
       end
     end
 
@@ -113,7 +141,13 @@ module Tickethub
 
     def configure_http(http)
       http = apply_ssl_options(http)
-      http.read_timeout = timeout if timeout
+
+      # Net::HTTP timeouts default to 60 seconds.
+      if timeout
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+      end
+
       http
     end
 

data/lib/tickethub/exceptions.rb

@@ -1,44 +1,65 @@
 module Tickethub
-  class ConnectionError < StandardError # :nodoc:
+  class Error < StandardError
+    attr_reader :request
+
+    def initialize(request = nil, message = nil)
+      super(message)
+      @request = request
+    end
+  end
+
+  ConnectionError = Error
+  RequestError = Error
+
+  class ResponseError < Error
     attr_reader :response
 
-    def initialize(response, message = nil)
+    def initialize(request, response, message = nil)
+      super(request, message)
       @response = response
-      @message  = message
     end
 
     def to_s
       message = "Failed."
       message << "  Response code = #{response.code}." if response.respond_to?(:code)
       message << "  Response message = #{response.message}." if response.respond_to?(:message)
-      message << "  Response Body = #{response.body}." if response.respond_to?(:body)
+
+      if response.respond_to?(:body)
+        # Error messages need to be in UTF-8
+        body = response.body.dup.to_s
+        body = body.encode('UTF-8', :invalid => :replace, :undef => :replace, :replace => '?')
+        message << "  Response Body = #{body}."
+      end
+
       message
     end
   end
 
   # Raised when a Timeout::Error occurs.
-  class TimeoutError < ConnectionError
-    def initialize(message)
-      @message = message
-    end
-    def to_s; @message ;end
+  class TimeoutError < RequestError
   end
 
   # Raised when a OpenSSL::SSL::SSLError occurs.
-  class SSLError < ConnectionError
-    def initialize(message)
-      @message = message
-    end
-    def to_s; @message ;end
+  class SSLError < RequestError
+  end
+
+  class ErrnoError < RequestError
+  end
+
+  class ZlibError < RequestError
   end
 
   # 3xx Redirection
-  class Redirection < ConnectionError # :nodoc:
+  class Redirection < ResponseError # :nodoc:
+    def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end
+  end
+
+  class RedirectionLoop < ResponseError # :nodoc:
     def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end
   end
 
   # 4xx Client Error
-  class ClientError < ConnectionError; end # :nodoc:
+  class ClientError < ResponseError; end # :nodoc:
 
   # 400 Bad Request
   class BadRequest < ClientError; end # :nodoc
@@ -52,11 +73,17 @@ module Tickethub
   # 404 Not Found
   class ResourceNotFound < ClientError; end # :nodoc:
 
+  # 409 Conflict
+  class ResourceConflict < ClientError; end # :nodoc:
+
+  # 410 Gone
+  class ResourceGone < ClientError; end # :nodoc:
+
   # 422 Invalid
   class ResourceInvalid < ClientError; end # :nodoc:
 
   # 5xx Server Error
-  class ServerError < ConnectionError; end # :nodoc:
+  class ServerError < ResponseError; end # :nodoc:
 
   # 405 Method Not Allowed
   class MethodNotAllowed < ClientError # :nodoc:

data/lib/tickethub/helpers.rb

@@ -10,6 +10,14 @@ module Tickethub
       value.to_s.split('_').map {|w| w.capitalize }.join
     end
 
+    def deep_merge(hash, other_hash)
+      hash.merge(other_hash) do |key, oldval, newval|
+        oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+        newval = newval.to_hash if newval.respond_to?(:to_hash)
+        oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? deep_merge(oldval, newval) : newval
+      end
+    end
+
     # Stolen from Rack:
 
     DEFAULT_SEP = /[&;] */n
@@ -30,6 +38,22 @@ module Tickethub
       end
     end
 
+    def to_url_param(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          to_url_param(v, "#{prefix}[]")
+        }.join("&")
+      when Hash
+        value.map { |k, v|
+          to_url_param(v, prefix ? "#{prefix}[#{uri_escape(k)}]" : uri_escape(k))
+        }.join("&")
+      else
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{prefix}=#{uri_escape(value)}"
+      end
+    end
+
     def from_param(param)
       Rack::Utils.parse_nested_query(param)
       (value || '').split('&').each do |res|
@@ -51,7 +75,15 @@ module Tickethub
     end
 
     def escape(s)
-      URI.encode_www_form_component(s)
+      URI.encode_www_form_component(s.to_s)
+    end
+
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
+
+    def uri_escape(s)
+      s.to_s.gsub(ESCAPE_RE) {|match|
+        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
+      }.tr(' ', '+')
     end
 
     if defined?(::Encoding)

data/lib/tickethub/request.rb

@@ -2,12 +2,12 @@ require 'securerandom'
 
 module Tickethub
   class Request
-
     attr_reader :options, :format, :url
-    attr_accessor :params, :body, :method, :headers
 
-    # Connection options
-    attr_accessor :proxy, :user, :password, :auth_type, :timeout, :retries, :ssl_options
+    attr_accessor :params, :body, :method, :headers,
+                  :proxy, :user, :password, :retries,
+                  :auth_type, :timeout, :ssl_options,
+                  :max_attempts, :follow_redirection
 
     def initialize(url, options = {})
       @url = url.to_s
@@ -15,16 +15,19 @@ module Tickethub
       @retries = 3
       @timeout = 10
 
-      @options = options
+      @options = {
+        :method           => :get,
+        :params           => {},
+        :headers          => {},
+        :format           => :form,
+        :max_attempts     => 5,
+        :follow_redirection => true
+      }.merge(options)
+
       @options.each do |key, val|
         method = "#{key}="
         send(method, val) if respond_to?(method)
       end
-
-      self.method  ||= :get
-      self.params  ||= {}
-      self.headers ||= {}
-      self.format  ||= :form
     end
 
     def format=(mime_or_format)
@@ -46,50 +49,86 @@ module Tickethub
       @uri = URI.parse(url)
       @uri.path = '/' if @uri.path.empty?
 
-      if @uri.query
-        @params.merge!(Helpers.from_param(@uri.query))
-        @uri.query = nil
-      end
-
       @uri
     end
 
+    def uri_params
+      uri.query ? Helpers.from_param(uri.query) : {}
+    end
+
     def path
       uri.path
     end
 
-    def execute
-      if encoded?
-        result = connection.send(method, path, encoded, build_headers)
-      else
-        result = connection.send(method, query_path, build_headers)
+    def query_path
+      query_path   = path.dup
+      query_params = uri_params.dup
+      query_params.merge!(params) unless encoded?
+
+      if query_params.any?
+        query_path += '?' + Helpers.to_url_param(query_params)
       end
 
-      Response.new(result)
+      query_path
+    end
 
-    rescue TimeoutError, ServerError, SSLError => err
-      raise err if (@retries -= 1) == 0
-      execute
-    rescue Redirection => error
-      raise error unless error.response['Location']
-      location = URI.parse(error.response['Location'])
+    def encoded?
+      [:post, :put].include?(method)
+    end
 
-      # Path is relative
-      unless location.host
-        location = URI.join(uri, location)
-      end
+    def encoded
+      params.any? ? format.encode(params) : body
+    end
 
-      self.url = location.to_s
+    def execute
+      with_redirection do
+        if encoded?
+          result = connection.send(method, query_path, encoded, build_headers)
+        else
+          result = connection.send(method, query_path, build_headers)
+        end
+
+        Response.new(result, uri)
+      end
+    rescue ServerError, RequestError => err
+      raise err if (@retries -= 1) == 0
       execute
     end
 
     protected
 
+    def with_redirection(&block)
+      attempts = 1
+
+      begin
+        yield
+      rescue Redirection => error
+        raise error unless follow_redirection
+
+        attempts += 1
+
+        raise error unless error.response['Location']
+        raise RedirectionLoop.new(self, error.response) if attempts > max_attempts
+
+        location = error.response['Location'].scrub
+        location = URI.parse(location)
+
+        # Path is relative
+        unless location.host
+          location = URI.join(uri, location)
+        end
+
+        self.url = location.to_s
+        retry
+      end
+    end
+
     def connection
       Connection.new(uri,
         :proxy       => proxy,
         :timeout     => timeout,
-        :ssl_options => ssl_options
+        :ssl_options => ssl_options,
+        :request     => self
       )
     end
 
@@ -117,23 +156,5 @@ module Tickethub
         .merge(headers)
         .merge('X-Request-ID' => @id)
     end
-
-    def query_path
-      query_path = path
-
-      if params.any?
-        query_path += '?' + Helpers.to_param(params)
-      end
-
-      query_path
-    end
-
-    def encoded?
-      [:post, :patch].include?(method)
-    end
-
-    def encoded
-      params.any? ? format.encode(params) : body
-    end
   end
 end

data/lib/tickethub/version.rb

@@ -1,3 +1,3 @@
 module Tickethub
-  VERSION = '0.3.51'
+  VERSION = '0.3.52'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tickethub
 version: !ruby/object:Gem::Version
-  version: 0.3.51
+  version: 0.3.52
 platform: ruby
 authors:
 - Oliver Morgan