lhc 12.0.0

data/lib/lhc/concerns/lhc/basic_methods_concern.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHC
+  module BasicMethodsConcern
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def request(options)
+        if options.is_a? Array
+          parallel_requests(options)
+        else
+          LHC::Request.new(options).response
+        end
+      end
+
+      [:get, :post, :put, :delete].each do |http_method|
+        define_method(http_method) do |url, options = {}|
+          request(options.merge(
+                    url: url,
+                    method: http_method
+                  ))
+        end
+      end
+
+      private
+
+      def parallel_requests(options)
+        hydra = Typhoeus::Hydra.new # do not use memoization !
+        requests = []
+        options.each do |option|
+          request = LHC::Request.new(option, false)
+          requests << request
+          hydra.queue request.raw unless request.response.present?
+        end
+        hydra.run
+        requests.map(&:response)
+      end
+    end
+  end
+end

data/lib/lhc/concerns/lhc/configuration_concern.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHC
+  module ConfigurationConcern
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def config
+        LHC::Config.instance
+      end
+
+      def configure
+        LHC::Config.instance.reset
+        yield config
+      end
+    end
+  end
+end

data/lib/lhc/concerns/lhc/fix_invalid_encoding_concern.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHC
+  module FixInvalidEncodingConcern
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # fix strings that contain non-UTF8 encoding in a forceful way
+      # should none of the fix-attempts be successful,
+      # an empty string is returned instead
+      def fix_invalid_encoding(string)
+        return string unless string.is_a?(String)
+        result = string.dup
+
+        # we assume it's ISO-8859-1 first
+        if !result.valid_encoding? || !utf8?(result)
+          result.encode!('UTF-8', 'ISO-8859-1', invalid: :replace, undef: :replace, replace: '')
+        end
+
+        # if it's still an issue, try with BINARY
+        if !result.valid_encoding? || !utf8?(result)
+          result.encode!('UTF-8', 'BINARY', invalid: :replace, undef: :replace, replace: '')
+        end
+
+        # if its STILL an issue, return an empty string :(
+        if !result.valid_encoding? || !utf8?(result)
+          result = ""
+        end
+
+        result
+      end
+
+      private
+
+      def utf8?(string)
+        string.encoding == Encoding::UTF_8
+      end
+    end
+  end
+end

data/lib/lhc/concerns/lhc/formats_concern.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module LHC
+  module FormatsConcern
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def form
+        LHC::Formats::Form
+      end
+
+      def json
+        LHC::Formats::JSON
+      end
+
+      def multipart
+        LHC::Formats::Multipart
+      end
+
+      def plain
+        LHC::Formats::Plain
+      end
+    end
+  end
+end

data/lib/lhc/concerns/lhc/request/user_agent_concern.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'lhc/version'
+
+module LHC
+  class Request
+    module UserAgentConcern
+      extend ActiveSupport::Concern
+
+      included do
+        Typhoeus::Config.user_agent = begin
+          version = LHC::VERSION
+          application = nil
+          if defined?(Rails)
+            app_class = Rails.application.class
+            application = (ActiveSupport.gem_version >= Gem::Version.new('6.0.0')) ? app_class.module_parent_name : app_class.parent_name
+          end
+
+          "LHC (#{[version, application].compact.join('; ')}) [https://github.com/local-ch/lhc]"
+        end
+      end
+    end
+  end
+end

data/lib/lhc/config.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+class LHC::Config
+  include Singleton
+
+  def initialize
+    @endpoints = {}
+    @placeholders = {}
+  end
+
+  def endpoint(name, url, options = {})
+    name = name.to_sym
+    raise 'Endpoint already exists for that name' if @endpoints[name]
+    @endpoints[name] = LHC::Endpoint.new(url, options)
+  end
+
+  def endpoints
+    @endpoints.dup
+  end
+
+  def placeholder(name, value)
+    name = name.to_sym
+    raise 'Placeholder already exists for that name' if @placeholders[name]
+    @placeholders[name] = value
+  end
+
+  def placeholders
+    @placeholders.dup
+  end
+
+  def interceptors
+    (@interceptors || []).dup
+  end
+
+  def interceptors=(interceptors)
+    raise 'Default interceptors already set and can only be set once' if @interceptors
+    @interceptors = interceptors
+  end
+
+  def reset
+    @endpoints = {}
+    @placeholders = {}
+    @interceptors = nil
+  end
+end

data/lib/lhc/endpoint.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'addressable/template'
+
+# An endpoint is an url that leads to a backend resource.
+# The url can also be an url-template (https://tools.ietf.org/html/rfc6570).
+class LHC::Endpoint
+  attr_accessor :url
+  attr_writer :options
+
+  def initialize(url, options = nil)
+    self.url = url
+    self.options = options
+  end
+
+  def uri
+    @uri ||= Addressable::Template.new(url)
+  end
+
+  def compile(params)
+    context = LHC.config.placeholders.deep_dup
+    context.merge!(params) if params.is_a?(Hash)
+    expanded = uri.partial_expand(context)
+
+    if expanded.variables.empty?
+      expanded.pattern
+    else
+      raise("Compilation incomplete. Unable to find value for #{expanded.variables.join(', ')}.")
+    end
+  end
+
+  # Endpoint options are immutable
+  def options
+    @options.deep_dup
+  end
+
+  # Removes keys from provided params hash
+  # when they are used for interpolation.
+  def remove_interpolated_params!(params)
+    params ||= {}
+    removed = params.slice(*placeholders)
+    params.except!(*placeholders)
+
+    removed
+  end
+
+  # Returns all placeholders found in the url-template.
+  # They are alphabetically sorted.
+  def placeholders
+    uri.variables.sort.map(&:to_sym)
+  end
+
+  # Compares a concrete url with a template
+  # Returns true if concrete url is covered by the template
+  # Example: {+datastore}/contracts/{id} == http://local.ch/contracts/1
+  def match?(url)
+    return true if url == uri.pattern
+    match_data = match_data(url)
+    return false if match_data.nil?
+
+    first = match_data.values.first
+    last = match_data.values.last
+    url_format = File.extname(url)
+
+    # eliminate false positives in form:
+    # http://host/feedbacks matches {+service}/{entry_id}/feedbacks (service: http:/, entry_id: host)
+    first&.match(%{https?:/$}).nil? &&
+      # eliminates false positives in form:
+      # http://host/entries/123.json matches {+service}/entries/{id} (service: http://host, id: 123.json)
+      (url_format.blank? || !last&.ends_with?(url_format))
+  end
+
+  # Extracts the values from url and
+  # creates params according to template
+  def values_as_params(url)
+    match_data = match_data(url)
+    return if match_data.nil?
+    Hash[match_data.variables.map(&:to_sym).zip(match_data.values)]
+  end
+
+  # Checks if the name has a match in the current context
+  def find_value(name, mapping)
+    context = LHC.config.placeholders.deep_dup
+    context.merge!(mapping)
+
+    context[name]
+  end
+
+  # Compares a concrete url with a template
+  # Returns true if concrete url is covered by the template
+  # Example: {+datastore}/contracts/{id} == http://local.ch/contracts/1
+  def self.match?(url, template)
+    new(template).match?(url)
+  end
+
+  # Returns all placeholders found in the url-template.
+  # They are alphabetically sorted.
+  def self.placeholders(template)
+    new(template).placeholders
+  end
+
+  # Extracts the values from url and
+  # creates params according to template
+  def self.values_as_params(template, url)
+    raise("#{url} does not match the template: #{template}") if !match?(url, template)
+    new(template).values_as_params(url)
+  end
+
+  private
+
+  def match_data(url)
+    parsed = URI.parse(url)
+    parsed.query = parsed.fragment = nil
+
+    uri.match(parsed)
+  rescue URI::InvalidURIError
+    nil
+  end
+end

data/lib/lhc/error.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class LHC::Error < StandardError
+  include LHC::FixInvalidEncodingConcern
+
+  attr_accessor :response, :_message
+
+  def self.map
+    {
+      400 => LHC::BadRequest,
+      401 => LHC::Unauthorized,
+      402 => LHC::PaymentRequired,
+      403 => LHC::Forbidden,
+      404 => LHC::NotFound,
+      405 => LHC::MethodNotAllowed,
+      406 => LHC::NotAcceptable,
+      407 => LHC::ProxyAuthenticationRequired,
+      408 => LHC::RequestTimeout,
+      409 => LHC::Conflict,
+      410 => LHC::Gone,
+      411 => LHC::LengthRequired,
+      412 => LHC::PreconditionFailed,
+      413 => LHC::RequestEntityTooLarge,
+      414 => LHC::RequestUriToLong,
+      415 => LHC::UnsupportedMediaType,
+      416 => LHC::RequestedRangeNotSatisfiable,
+      417 => LHC::ExpectationFailed,
+      422 => LHC::UnprocessableEntity,
+      423 => LHC::Locked,
+      424 => LHC::FailedDependency,
+      426 => LHC::UpgradeRequired,
+
+      500 => LHC::InternalServerError,
+      501 => LHC::NotImplemented,
+      502 => LHC::BadGateway,
+      503 => LHC::ServiceUnavailable,
+      504 => LHC::GatewayTimeout,
+      505 => LHC::HttpVersionNotSupported,
+      507 => LHC::InsufficientStorage,
+      510 => LHC::NotExtended
+    }
+  end
+
+  def self.find(response)
+    return LHC::Timeout if response.timeout?
+    status_code = response.code.to_s[0..2].to_i
+    error = map[status_code]
+    error ||= LHC::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 if response.is_a?(String)
+    request = response.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/lhc/errors/client_error.rb

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