lhc 0.2.1

data/docs/response.md

@@ -0,0 +1,19 @@
+Response
+===
+
+```ruby
+  response.request #<LHC::Request> the associated request.
+
+  response.data #<OpenStruct> in case response body contains parsable JSON.
+  response.data.something.nested
+
+  response.body #<String>
+
+  response.code #<Fixnum>
+
+  response.headers #<Hash>
+
+  response.time #<Fixnum> Provides response time in ms.
+
+  response.timeout? #true|false
+```

data/lhc.gemspec

@@ -0,0 +1,30 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "lhc/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "lhc"
+  s.version     = LHC::VERSION
+  s.authors     = ['local.ch']
+  s.email       = ['ws-operations@local.ch']
+  s.homepage    = 'https://github.com/local-ch/lhc'
+  s.summary     = 'LocalHttpServices'
+  s.description = 'Rails gem wrapping typhoeus and providing additional features (like interceptors)'
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.requirements << 'Ruby >= 1.9.2'
+  s.required_ruby_version = '>= 1.9.2'
+  
+  s.add_dependency 'typhoeus'
+
+  s.add_development_dependency 'rspec-rails', '>= 3.0.0'
+  s.add_development_dependency 'rails', '~> 4.1.1'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'geminabox'
+  s.add_development_dependency 'pry'
+end

data/lib/lhc.rb

@@ -0,0 +1,16 @@
+Dir[File.dirname(__FILE__) + '/lhc/concerns/lhc/*.rb'].sort.each {|file| require file }
+
+module LHC
+  include BasicMethods
+
+  def self.config
+    LHC::Config.instance
+  end
+
+  def self.configure
+    LHC::Config.instance.reset
+    yield config
+  end
+end
+
+Gem.find_files('lhc/**/*.rb').sort.each { |path| require path }

data/lib/lhc/concerns/lhc/basic_methods.rb

@@ -0,0 +1,42 @@
+require 'active_support'
+
+module LHC
+
+  module BasicMethods
+    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.hydra
+        requests = []
+        options.each do |options|
+          request = LHC::Request.new(options, false)
+          requests << request
+          hydra.queue request.raw
+        end
+        hydra.run
+        requests.map(&:response)
+      end
+    end
+  end
+end

data/lib/lhc/config.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+
+class LHC::Config
+  include Singleton
+
+  def initialize
+    @endpoints = {}
+    @placeholders = {}
+  end
+
+  def endpoint(name, url, options = {})
+    name = name.to_sym
+    fail '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
+    fail '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)
+    fail '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,53 @@
+# An endpoint is an url that leads to a backend resource.
+# The url can also be an url-template.
+class LHC::Endpoint
+
+  PLACEHOLDER = /\:[A-Z,a-z,_,-]+/
+
+  attr_accessor :url, :options
+
+  def initialize(url, options = nil)
+    self.url = url
+    self.options = options
+  end
+
+  def compile(params)
+    url.gsub(PLACEHOLDER) do |match|
+      replacement = if params.is_a? Proc
+        params.call(match)
+      else
+        find_value(match, params)
+      end
+      replacement || fail("Compilation incomplete. Unable to find value for #{match.gsub(':', '')}.")
+    end
+  end
+
+  # Removes keys from provided params hash
+  # when they are used for interpolation.
+  def remove_interpolated_params!(params)
+    params ||= {}
+    removed = {}
+    url.scan(PLACEHOLDER) do |match|
+      match = match.gsub(/^\:/, '')
+      if value = find_value(match, params)
+        removed[match.to_sym] = value
+        params.delete(match.to_sym)
+      end
+    end
+    removed
+  end
+
+  # Returns all placeholders found in the url-template.
+  # They are alphabetically sorted.
+  def placeholders
+    url.scan(PLACEHOLDER).sort
+  end
+
+  # Find a value for a placeholder either in the configuration
+  # or in the provided params.
+  def find_value(match, params)
+    params ||= {}
+    match = match.gsub(/^\:/, '').to_sym
+    params[match] || LHC.config.placeholders[match]
+  end
+end

data/lib/lhc/error.rb

@@ -0,0 +1,63 @@
+class LHC::Error < StandardError
+
+  attr_accessor :response
+
+  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 initialize(message, response)
+    super(message)
+    self.response = response
+  end
+
+  def to_s
+    request = response.request
+    debug = []
+    debug << "#{request.method} #{request.url}"
+    debug << "Params: #{request.options}"
+    debug << "Response Code: #{response.code}"
+    debug << response.body
+    debug.join("\n")
+  end
+end

data/lib/lhc/errors/client_error.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../error'
+
+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

data/lib/lhc/errors/server_error.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../error'
+
+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 @@
+require File.dirname(__FILE__) + '/../error'
+
+class LHC::Timeout < LHC::Error
+end

data/lib/lhc/errors/unknown_error.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/../error'
+
+class LHC::UnknownError < LHC::Error
+end

data/lib/lhc/interceptor.rb

@@ -0,0 +1,9 @@
+class LHC::Interceptor
+
+  def before_request(request); end
+  def after_request(request); end
+
+  def before_response(request); end
+  def after_response(response); end
+
+end

data/lib/lhc/interceptor_processor.rb

@@ -0,0 +1,24 @@
+# Handles interceptions during the lifecycle of a request
+class LHC::InterceptorProcessor
+
+  attr_accessor :interceptors
+
+  # Intitalizes the processor and determines if global or local interceptors are used
+  def initialize(target)
+    options = target.options if target.is_a? LHC::Request
+    options ||= target.request.options if target.is_a? LHC::Response
+    self.interceptors = (options[:interceptors] || LHC.config.interceptors).map{ |i| i.new }
+  end
+
+  # Forwards messages to interceptors and handles provided responses.
+  def intercept(name, target)
+    interceptors.each do |interceptor|
+      result = interceptor.send(name, target)
+      if result.is_a? LHC::Response
+        fail 'Response already set from another interceptor' if @response
+        request = target.is_a?(LHC::Request) ? target : target.request
+        @response = request.response = result
+      end
+    end
+  end
+end

data/lib/lhc/request.rb

@@ -0,0 +1,91 @@
+require 'typhoeus'
+
+# The request is doing an http-request using typhoeus.
+# It provides functionalities to access and alter request data
+# and it communicates with interceptors.
+class LHC::Request
+
+  TYPHOEUS_OPTIONS = [:params, :method, :body, :headers]
+
+  attr_accessor :response, :options, :raw
+
+  def initialize(options, self_executing = true)
+    self.options = options.deep_dup
+    use_configured_endpoint!
+    generate_url_from_template!
+    self.iprocessor = LHC::InterceptorProcessor.new(self)
+    self.raw = create_request
+    return unless self_executing
+    iprocessor.intercept(:before_request, self)
+    raw.run if !response
+  end
+
+  def url
+    raw.base_url || options[:url]
+  end
+
+  def method
+    (raw.options[:method] || options[:method] || :get).to_sym
+  end
+
+  def headers
+    raw.options.fetch(:headers, nil) || raw.options[:headers] = {}
+  end
+
+  def params
+    raw.options.fetch(:params, nil) || raw.options[:params] = {}
+  end
+
+  private
+
+  attr_accessor :iprocessor
+
+  def create_request
+    request = Typhoeus::Request.new(options[:url], typhoeusize(options))
+    request.on_headers do
+      iprocessor.intercept(:after_request, self)
+      iprocessor.intercept(:before_response, self)
+    end
+    request.on_complete { |response| on_complete(response) }
+    request
+  end
+
+  def typhoeusize(options)
+    options = options.deep_dup
+    easy = Ethon::Easy.new
+    options.delete(:url)
+    options.each do |key, v|
+      next if TYPHOEUS_OPTIONS.include? key
+      method = "#{key}="
+      options.delete key unless easy.respond_to?(method)
+    end
+    options
+  end
+
+  # Get configured endpoint and use it for doing the request.
+  # Explicit request options are overriding configured options.
+  def use_configured_endpoint!
+    return unless (endpoint = LHC.config.endpoints[options[:url]])
+    endpoint.options.deep_merge!(options)
+    options.deep_merge!(endpoint.options)
+    options[:url] = endpoint.url
+  end
+
+  # Generates URL from a URL template
+  def generate_url_from_template!
+    endpoint = LHC::Endpoint.new(options[:url])
+    options[:url] = endpoint.compile(options[:params])
+    endpoint.remove_interpolated_params!(options[:params])
+  end
+
+  def on_complete(response)
+    self.response ||= LHC::Response.new(response, self)
+    iprocessor.intercept(:after_response, self.response)
+    throw_error unless self.response.success?
+  end
+
+  def throw_error
+    error = LHC::Error.find(response)
+    fail error.new(error, response)
+  end
+end