dhc 1.0.0

data/lib/dhc/error.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class DHC::Error < StandardError
+  include DHC::FixInvalidEncodingConcern
+
+  attr_accessor :response, :_message
+
+  def self.map
+    {
+      400 => DHC::BadRequest,
+      401 => DHC::Unauthorized,
+      402 => DHC::PaymentRequired,
+      403 => DHC::Forbidden,
+      404 => DHC::NotFound,
+      405 => DHC::MethodNotAllowed,
+      406 => DHC::NotAcceptable,
+      407 => DHC::ProxyAuthenticationRequired,
+      408 => DHC::RequestTimeout,
+      409 => DHC::Conflict,
+      410 => DHC::Gone,
+      411 => DHC::LengthRequired,
+      412 => DHC::PreconditionFailed,
+      413 => DHC::RequestEntityTooLarge,
+      414 => DHC::RequestUriToLong,
+      415 => DHC::UnsupportedMediaType,
+      416 => DHC::RequestedRangeNotSatisfiable,
+      417 => DHC::ExpectationFailed,
+      422 => DHC::UnprocessableEntity,
+      423 => DHC::Locked,
+      424 => DHC::FailedDependency,
+      426 => DHC::UpgradeRequired,
+
+      500 => DHC::InternalServerError,
+      501 => DHC::NotImplemented,
+      502 => DHC::BadGateway,
+      503 => DHC::ServiceUnavailable,
+      504 => DHC::GatewayTimeout,
+      505 => DHC::HttpVersionNotSupported,
+      507 => DHC::InsufficientStorage,
+      510 => DHC::NotExtended
+    }
+  end
+
+  def self.find(response)
+    return DHC::Timeout if response.timeout?
+    status_code = response.code.to_s[0..2].to_i
+    error = map[status_code]
+    error ||= DHC::UnknownError
+    error
+  end
+
+  def self.dup
+    self
+  end
+
+  def initialize(message, response)
+    super(message)
+    self._message = message
+    self.response = response
+  end
+
+  def self.to_a
+    [self]
+  end
+
+  def to_s
+    return response.to_s unless response.is_a?(DHC::Response)
+    request = response.request
+    return unless request.is_a?(DHC::Request)
+
+    debug = []
+    debug << [request.method, request.url].map { |str| self.class.fix_invalid_encoding(str) }.join(' ')
+    debug << "Options: #{request.options}"
+    debug << "Headers: #{request.headers}"
+    debug << "Response Code: #{response.code} (#{response.options[:return_code]})"
+    debug << "Response Options: #{response.options}"
+    debug << response.body
+    debug << _message
+
+    debug.map { |str| self.class.fix_invalid_encoding(str) }.join("\n")
+  end
+end

data/lib/dhc/errors/client_error.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class DHC::ClientError < DHC::Error
+end
+
+class DHC::BadRequest < DHC::ClientError
+end
+
+class DHC::Unauthorized < DHC::ClientError
+end
+
+class DHC::PaymentRequired < DHC::ClientError
+end
+
+class DHC::Forbidden < DHC::ClientError
+end
+
+class DHC::Forbidden < DHC::ClientError
+end
+
+class DHC::NotFound < DHC::ClientError
+end
+
+class DHC::MethodNotAllowed < DHC::ClientError
+end
+
+class DHC::NotAcceptable < DHC::ClientError
+end
+
+class DHC::ProxyAuthenticationRequired < DHC::ClientError
+end
+
+class DHC::RequestTimeout < DHC::ClientError
+end
+
+class DHC::Conflict < DHC::ClientError
+end
+
+class DHC::Gone < DHC::ClientError
+end
+
+class DHC::LengthRequired < DHC::ClientError
+end
+
+class DHC::PreconditionFailed < DHC::ClientError
+end
+
+class DHC::RequestEntityTooLarge < DHC::ClientError
+end
+
+class DHC::RequestUriToLong < DHC::ClientError
+end
+
+class DHC::UnsupportedMediaType < DHC::ClientError
+end
+
+class DHC::RequestedRangeNotSatisfiable < DHC::ClientError
+end
+
+class DHC::ExpectationFailed < DHC::ClientError
+end
+
+class DHC::UnprocessableEntity < DHC::ClientError
+end
+
+class DHC::Locked < DHC::ClientError
+end
+
+class DHC::FailedDependency < DHC::ClientError
+end
+
+class DHC::UpgradeRequired < DHC::ClientError
+end

data/lib/dhc/errors/parser_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class DHC::ParserError < DHC::Error
+end

data/lib/dhc/errors/server_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class DHC::ServerError < DHC::Error
+end
+
+class DHC::InternalServerError < DHC::ServerError
+end
+
+class DHC::NotImplemented < DHC::ServerError
+end
+
+class DHC::BadGateway < DHC::ServerError
+end
+
+class DHC::ServiceUnavailable < DHC::ServerError
+end
+
+class DHC::GatewayTimeout < DHC::ServerError
+end
+
+class DHC::HttpVersionNotSupported < DHC::ServerError
+end
+
+class DHC::InsufficientStorage < DHC::ServerError
+end
+
+class DHC::NotExtended < DHC::ServerError
+end

data/lib/dhc/errors/timeout.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class DHC::Timeout < DHC::Error
+end

data/lib/dhc/errors/unknown_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class DHC::UnknownError < DHC::Error
+end

data/lib/dhc/format.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class DHC::Format
+
+  private
+
+  def no_content_type_header!(options)
+    return if (options[:headers].keys & [:'Content-Type', 'Content-Type']).blank?
+
+    raise 'Content-Type header is not allowed for formatted requests!\nSee https://github.com/DePayFi/dhc#formats for more information.'
+  end
+
+  def no_accept_header!(options)
+    return if (options[:headers].keys & [:Accept, 'Accept']).blank?
+
+    raise 'Accept header is not allowed for formatted requests!\nSee https://github.com/DePayFi/dhc#formats for more information.'
+  end
+end

data/lib/dhc/formats.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DHC::Formats
+  autoload :Form, 'dhc/formats/form'
+  autoload :JSON, 'dhc/formats/json'
+  autoload :Multipart, 'dhc/formats/multipart'
+  autoload :Plain, 'dhc/formats/plain'
+end

data/lib/dhc/formats/form.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module DHC::Formats
+  class Form < DHC::Format
+    include DHC::BasicMethodsConcern
+
+    def self.request(options)
+      options[:format] = new
+      super(options)
+    end
+
+    def format_options(options)
+      options[:headers] ||= {}
+      no_content_type_header!(options)
+      options[:headers]['Content-Type'] = 'application/x-www-form-urlencoded'
+      options
+    end
+
+    def as_json(input)
+      parse(input)
+    end
+
+    def as_open_struct(input)
+      parse(input)
+    end
+
+    def to_body(input)
+      input
+    end
+
+    def to_s
+      'form'
+    end
+
+    def to_sym
+      to_s.to_sym
+    end
+
+    private
+
+    def parse(input)
+      input
+    end
+  end
+end

data/lib/dhc/formats/json.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DHC::Formats
+  class JSON < DHC::Format
+    include DHC::BasicMethodsConcern
+
+    def self.request(options)
+      options[:format] = new
+      super(options)
+    end
+
+    def format_options(options)
+      options[:headers] ||= {}
+      no_content_type_header!(options)
+      no_accept_header!(options)
+
+      options[:headers]['Content-Type'] = 'application/json; charset=utf-8'
+      options[:headers]['Accept'] = 'application/json,application/vnd.api+json'
+      options[:headers]['Accept-Charset'] = 'utf-8'
+      options
+    end
+
+    def as_json(input)
+      parse(input, Hash)
+    end
+
+    def as_open_struct(input)
+      parse(input, OpenStruct)
+    end
+
+    def to_body(input)
+      if input.is_a?(String)
+        input
+      else
+        input.to_json
+      end
+    end
+
+    def to_s
+      'json'
+    end
+
+    def to_sym
+      to_s.to_sym
+    end
+
+    private
+
+    def parse(input, object_class)
+      ::JSON.parse(input, object_class: object_class)
+    rescue ::JSON::ParserError => e
+      raise DHC::ParserError.new(e.message, input)
+    end
+  end
+end

data/lib/dhc/formats/multipart.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module DHC::Formats
+  class Multipart < DHC::Format
+    include DHC::BasicMethodsConcern
+
+    def self.request(options)
+      options[:format] = new
+      super(options)
+    end
+
+    def format_options(options)
+      options[:headers] ||= {}
+      no_content_type_header!(options)
+      options[:headers]['Content-Type'] = 'multipart/form-data'
+      options
+    end
+
+    def as_json(input)
+      parse(input)
+    end
+
+    def as_open_struct(input)
+      parse(input)
+    end
+
+    def to_body(input)
+      input
+    end
+
+    def to_s
+      'multipart'
+    end
+
+    def to_sym
+      to_s.to_sym
+    end
+
+    private
+
+    def parse(input)
+      input
+    end
+  end
+end

data/lib/dhc/formats/plain.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DHC::Formats
+  class Plain < DHC::Format
+    include DHC::BasicMethodsConcern
+
+    def self.request(options)
+      options[:format] = new
+      super(options)
+    end
+
+    def format_options(options)
+      options
+    end
+
+    def as_json(input)
+      parse(input)
+    end
+
+    def as_open_struct(input)
+      parse(input)
+    end
+
+    def to_body(input)
+      input
+    end
+
+    def to_s
+      'plain'
+    end
+
+    def to_sym
+      to_s.to_sym
+    end
+
+    private
+
+    def parse(input)
+      input
+    end
+  end
+end

data/lib/dhc/interceptor.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class DHC::Interceptor
+
+  attr_reader :request
+
+  def initialize(request)
+    @request = request
+  end
+
+  def response
+    @request.response
+  end
+
+  def before_raw_request; end
+
+  def before_request; end
+
+  def after_request; end
+
+  def before_response; end
+
+  def after_response; end
+
+  # Prevent Interceptors from beeing duplicated!
+  # Their classes have flag-character.
+  # When duplicated you can't check for their class name anymore:
+  # e.g. options.deep_dup[:interceptors].include?(DHC::Caching) # false
+  def self.dup
+    self
+  end
+
+  def all_interceptor_classes
+    @all_interceptors ||= DHC::Interceptors.new(request).all.map(&:class)
+  end
+end