lhc 12.0.0

data/lib/lhc/errors/parser_error.rb

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

data/lib/lhc/errors/server_error.rb

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

data/lib/lhc/errors/timeout.rb

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

data/lib/lhc/errors/unknown_error.rb

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

data/lib/lhc/format.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class LHC::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/local-ch/lhc#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/local-ch/lhc#formats for more information.'
+  end
+end

data/lib/lhc/formats.rb

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

data/lib/lhc/formats/form.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module LHC::Formats
+  class Form < LHC::Format
+    include LHC::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/lhc/formats/json.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module LHC::Formats
+  class JSON < LHC::Format
+    include LHC::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 LHC::ParserError.new(e.message, input)
+    end
+  end
+end

data/lib/lhc/formats/multipart.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module LHC::Formats
+  class Multipart < LHC::Format
+    include LHC::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/lhc/formats/plain.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module LHC::Formats
+  class Plain < LHC::Format
+    include LHC::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/lhc/interceptor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class LHC::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?(LHC::Caching) # false
+  def self.dup
+    self
+  end
+end

data/lib/lhc/interceptors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Handles interceptions during the lifecycle of a request
+# Represents all active interceptors for a request/response.
+class LHC::Interceptors
+
+  attr_accessor :all
+
+  # Intitalizes and determines if global or local interceptors are used
+  def initialize(request)
+    self.all = (request.options[:interceptors] || LHC.config.interceptors).map do |interceptor|
+      interceptor.new(request)
+    end
+  end
+
+  # Forwards messages to interceptors and handles provided responses.
+  def intercept(name)
+    all.each do |interceptor|
+      result = interceptor.send(name)
+      if result.is_a? LHC::Response
+        raise 'Response already set from another interceptor' if @response
+        @response = interceptor.request.response = result
+      end
+    end
+  end
+end

data/lib/lhc/interceptors/auth.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+class LHC::Auth < LHC::Interceptor
+  include ActiveSupport::Configurable
+  config_accessor :refresh_client_token
+
+  def before_request
+    authenticate!
+  end
+
+  def after_response
+    return unless configuration_correct?
+    return unless reauthenticate?
+    reauthenticate!
+  end
+
+  private
+
+  def authenticate!
+    if auth_options[:bearer]
+      bearer_authentication!
+    elsif auth_options[:basic]
+      basic_authentication!
+    end
+  end
+
+  def basic_authentication!
+    auth = auth_options[:basic]
+    credentials = "#{auth[:username]}:#{auth[:password]}"
+    set_authorization_header("Basic #{Base64.encode64(credentials).chomp}")
+  end
+
+  def bearer_authentication!
+    token = auth_options[:bearer]
+    token = token.call if token.is_a?(Proc)
+    set_bearer_authorization_header(token)
+  end
+
+  # rubocop:disable Style/AccessorMethodName
+  def set_authorization_header(value)
+    request.headers['Authorization'] = value
+  end
+
+  def set_bearer_authorization_header(token)
+    set_authorization_header("Bearer #{token}")
+  end
+  # rubocop:enable Style/AccessorMethodName
+
+  def reauthenticate!
+    # refresh token and update header
+    token = refresh_client_token_option.call
+    set_bearer_authorization_header(token)
+    # trigger LHC::Retry and ensure we do not trigger reauthenticate!
+    # again should it fail another time
+    new_options = request.options.dup
+    new_options = new_options.merge(retry: { max: 1 })
+    new_options = new_options.merge(auth: { reauthenticated: true })
+    request.options = new_options
+  end
+
+  def reauthenticate?
+    !response.success? &&
+      !auth_options[:reauthenticated] &&
+      bearer_header_present? &&
+      LHC::Error.find(response) == LHC::Unauthorized
+  end
+
+  def bearer_header_present?
+    @has_bearer_header ||= request.headers['Authorization'] =~ /^Bearer .+$/i
+  end
+
+  def refresh_client_token_option
+    @refresh_client_token_option ||= auth_options[:refresh_client_token] || refresh_client_token
+  end
+
+  def all_interceptor_classes
+    @all_interceptors ||= LHC::Interceptors.new(request).all.map(&:class)
+  end
+
+  def auth_options
+    @auth_options ||= request.options[:auth].dup || {}
+  end
+
+  def configuration_correct?
+    # warn user about configs, only if refresh_client_token_option is set at all
+    refresh_client_token_option && refresh_client_token? && retry_interceptor?
+  end
+
+  def refresh_client_token?
+    return true if refresh_client_token_option.is_a?(Proc)
+    warn("[WARNING] The given refresh_client_token must be a Proc for reauthentication.")
+  end
+
+  def retry_interceptor?
+    return true if all_interceptor_classes.include?(LHC::Retry) && all_interceptor_classes.index(LHC::Retry) > all_interceptor_classes.index(self.class)
+    warn("[WARNING] Your interceptors must include LHC::Retry after LHC::Auth.")
+  end
+end

data/lib/lhc/interceptors/caching.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+class LHC::Caching < LHC::Interceptor
+  include ActiveSupport::Configurable
+
+  config_accessor :cache, :logger
+
+  CACHE_VERSION = '1'
+
+  # Options forwarded to the cache
+  FORWARDED_OPTIONS = [:expires_in, :race_condition_ttl]
+
+  def before_request
+    return unless cache?(request)
+    deprecation_warning(request.options)
+    options = options(request.options)
+    key = key(request, options[:key])
+    response_data = cache_for(options).fetch(key)
+    return unless response_data
+    logger&.info "Served from cache: #{key}"
+    from_cache(request, response_data)
+  end
+
+  def after_response
+    return unless response.success?
+    request = response.request
+    return unless cache?(request)
+    options = options(request.options)
+    cache_for(options).write(
+      key(request, options[:key]),
+      to_cache(response),
+      cache_options(options)
+    )
+  end
+
+  private
+
+  # return the cache for the given options
+  def cache_for(options)
+    options.fetch(:use, cache)
+  end
+
+  # do we even need to bother with this interceptor?
+  # based on the options, this method will
+  # return false if this interceptor cannot work
+  def cache?(request)
+    return false unless request.options[:cache]
+    options = options(request.options)
+    cache_for(options) &&
+      cached_method?(request.method, options[:methods])
+  end
+
+  # returns the request_options
+  # will map deprecated options to the new format
+  def options(request_options)
+    options = (request_options[:cache] == true) ? {} : request_options[:cache].dup
+    map_deprecated_options!(request_options, options)
+    options
+  end
+
+  # maps `cache_key` -> `key`, `cache_expires_in` -> `expires_in` and so on
+  def map_deprecated_options!(request_options, options)
+    deprecated_keys(request_options).each do |deprecated_key|
+      new_key = deprecated_key.to_s.gsub(/^cache_/, '').to_sym
+      options[new_key] = request_options[deprecated_key]
+    end
+  end
+
+  # converts json we read from the cache to an LHC::Response object
+  def from_cache(request, data)
+    raw = Typhoeus::Response.new(data)
+    response = LHC::Response.new(raw, request, from_cache: true)
+    request.response = response
+    response
+  end
+
+  # converts a LHC::Response object to json, we store in the cache
+  def to_cache(response)
+    data = {}
+    data[:body] = response.body
+    data[:code] = response.code
+    # convert into a actual hash because the typhoeus headers object breaks marshaling
+    data[:headers] = response.headers ? Hash[response.headers] : response.headers
+    # return_code is quite important as Typhoeus relies on it in order to determin 'success?'
+    data[:return_code] = response.options[:return_code]
+    # in a test scenario typhoeus uses mocks and not return_code to determine 'success?'
+    data[:mock] = response.mock
+    data
+  end
+
+  def key(request, key)
+    unless key
+      key = "#{request.method.upcase} #{request.url}"
+      key += "?#{request.params.to_query}" unless request.params.blank?
+    end
+    "LHC_CACHE(v#{CACHE_VERSION}): #{key}"
+  end
+
+  # Checks if the provided method should be cached
+  # in regards of the provided options.
+  def cached_method?(method, cached_methods)
+    (cached_methods || [:get]).include?(method)
+  end
+
+  # extracts the options that should be forwarded to
+  # the cache
+  def cache_options(input = {})
+    input.each_with_object({}) do |(key, value), result|
+      result[key] = value if key.in? FORWARDED_OPTIONS
+      result
+    end
+  end
+
+  # grabs the deprecated keys from the request options
+  def deprecated_keys(request_options)
+    request_options.keys.select { |k| k =~ /^cache_.*/ }.sort
+  end
+
+  # emits a deprecation warning if necessary
+  def deprecation_warning(request_options)
+    unless deprecated_keys(request_options).empty?
+      ActiveSupport::Deprecation.warn(
+        "Cache options have changed! #{deprecated_keys(request_options).join(', ')} are deprecated and will be removed in future versions."
+      )
+    end
+  end
+end