lhc 12.0.0

data/lib/lhc/request.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'active_support/core_ext/object/deep_dup'
+require 'lhc/concerns/lhc/request/user_agent_concern'
+
+# 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
+  include UserAgentConcern
+
+  TYPHOEUS_OPTIONS ||= [:params, :method, :body, :headers, :follow_location, :params_encoding]
+
+  attr_accessor :response, :options, :raw, :format, :error_handler, :errors_ignored, :source
+
+  def initialize(options, self_executing = true)
+    self.errors_ignored = (options.fetch(:ignore, []) || []).to_a.compact
+    self.source = options&.dig(:source)
+    self.options = format!(options.deep_dup || {})
+    self.error_handler = options.delete :rescue
+    use_configured_endpoint!
+    generate_url_from_template!
+    self.interceptors = LHC::Interceptors.new(self)
+    interceptors.intercept(:before_raw_request)
+    self.raw = create_request
+    interceptors.intercept(:before_request)
+    run! if self_executing && !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
+
+  def error_ignored?
+    ignore_error?
+  end
+
+  def run!
+    raw.run
+  end
+
+  private
+
+  attr_accessor :interceptors
+
+  def format!(options)
+    self.format = options.delete(:format) || LHC::Formats::JSON.new
+    format.format_options(options)
+  end
+
+  def optionally_encoded_url(options)
+    return options[:url] unless options.fetch(:url_encoding, true)
+    encode_url(options[:url])
+  end
+
+  def create_request
+    request = Typhoeus::Request.new(
+      optionally_encoded_url(options),
+      translate_body(typhoeusize(options))
+    )
+    request.on_headers do
+      interceptors.intercept(:after_request)
+      interceptors.intercept(:before_response)
+    end
+    request.on_complete { |response| on_complete(response) }
+    request
+  end
+
+  def translate_body(options)
+    return options if options.fetch(:body, nil).blank?
+    options[:body] = format.to_body(options[:body])
+    options
+  end
+
+  def encode_url(url)
+    return url if url.nil?
+    URI.escape(url)
+  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!
+    endpoint = LHC.config.endpoints[options[:url]]
+    return unless endpoint
+    # explicit options override endpoint options
+    new_options = endpoint.options.deep_merge(options)
+    # set new options
+    self.options = new_options
+    options[:url] = endpoint.url
+  end
+
+  # Generates URL from a URL template
+  def generate_url_from_template!
+    endpoint = LHC::Endpoint.new(options[:url])
+    params =
+      if format && options[:body].present? && options[:body].respond_to?(:as_json) && options[:body].as_json.is_a?(Hash)
+        options[:body].as_json.merge(options[:params] || {}).deep_symbolize_keys
+      else
+        options[:params]
+      end
+    options[:url] = endpoint.compile(params)
+    endpoint.remove_interpolated_params!(options[:params])
+  end
+
+  def on_complete(response)
+    self.response = LHC::Response.new(response, self)
+    interceptors.intercept(:after_response)
+    handle_error(self.response) unless self.response.success?
+  end
+
+  def handle_error(response)
+    return if ignore_error?
+    throw_error(response) unless error_handler
+    response.body_replacement = error_handler.call(response)
+  end
+
+  def ignore_error?
+    @ignore_error ||= begin
+      errors_ignored.detect do |ignored_error|
+        error <= ignored_error
+      end.present?
+    end
+  end
+
+  def error
+    @error ||= LHC::Error.find(response)
+  end
+
+  def throw_error(response)
+    raise error.new(error, response)
+  end
+end

data/lib/lhc/response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module'
+
+# The response contains the raw response (typhoeus)
+# and provides functionality to access response data.
+class LHC::Response
+  autoload :Data, 'lhc/response/data'
+
+  attr_accessor :request, :body_replacement
+  attr_reader :from_cache
+
+  delegate :effective_url, :code, :headers, :options, :mock, :success?, to: :raw
+  delegate :error_ignored?, to: :request
+  alias from_cache? from_cache
+
+  # A response is initalized with the underlying raw response (typhoeus in our case)
+  # and the associated request.
+  def initialize(raw, request, from_cache: false)
+    self.request = request
+    self.raw = raw
+    @from_cache = from_cache
+  end
+
+  def data
+    @data ||= body.present? ? LHC::Response::Data.new(self) : nil
+  end
+
+  def [](key)
+    data[key]
+  end
+
+  def body
+    body_replacement || raw.body.presence
+  end
+
+  # Provides response time in seconds
+  def time
+    raw.time || 0
+  end
+
+  # Provides response time in milliseconds
+  def time_ms
+    time * 1000
+  end
+
+  def timeout?
+    raw.timed_out?
+  end
+
+  def format
+    return LHC::Formats::JSON.new if request.nil?
+    request.format
+  end
+
+  private
+
+  attr_accessor :raw
+
+end

data/lib/lhc/response/data.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class LHC::Response::Data
+  autoload :Base, 'lhc/response/data/base'
+  autoload :Item, 'lhc/response/data/item'
+  autoload :Collection, 'lhc/response/data/collection'
+
+  include LHC::Response::Data::Base
+
+  def initialize(response, data: nil)
+    @response = response
+    @data = data
+
+    if as_json.is_a?(Hash)
+      @base = LHC::Response::Data::Item.new(response, data: data)
+    elsif as_json.is_a?(Array)
+      @base = LHC::Response::Data::Collection.new(response, data: data)
+    end
+  end
+
+  def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissingSuper
+    @base.send(method, *args, &block)
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @base.respond_to?(method_name, include_private) || super
+  end
+end

data/lib/lhc/response/data/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Response data is data provided through the response body
+# but made accssible in the ruby world
+module LHC::Response::Data::Base
+  def as_json
+    @json ||= (@data || response.format.as_json(response.body))
+  end
+
+  def as_open_struct
+    @open_struct ||=
+      if @data
+        JSON.parse(@data.to_json, object_class: OpenStruct)
+      else
+        response.format.as_open_struct(response.body)
+      end
+  end
+
+  private
+
+  attr_reader :response
+end

data/lib/lhc/response/data/collection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class LHC::Response::Data::Collection < Array
+  include LHC::Response::Data::Base
+
+  def initialize(response, data: nil)
+    @response = response
+    @data = data
+
+    super(
+      as_json.map do |i|
+        LHC::Response::Data.new(response, data: i)
+      end
+    )
+  end
+end

data/lib/lhc/response/data/item.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class LHC::Response::Data::Item < OpenStruct
+  include LHC::Response::Data::Base
+
+  def initialize(response, data: nil)
+    @response = response
+    @data = data
+
+    set_dynamic_accessor_methods
+
+    super(as_json)
+  end
+
+  def [](key)
+    @hash ||= as_json.with_indifferent_access
+    @hash[key]
+  end
+
+  private
+
+  def set_dynamic_accessor_methods
+    as_json.keys.each do |key|
+      define_singleton_method key do |*args|
+        as_open_struct.send key, *args
+      end
+    end
+  end
+end

data/lib/lhc/rspec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'lhc'
+
+RSpec.configure do |config|
+  LHC::Caching.cache = ActiveSupport::Cache::MemoryStore.new
+
+  config.before(:each) do
+    LHC::Caching.cache.clear
+    LHC::Throttle.track = nil
+  end
+end

data/lib/lhc/test/cache_helper.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+warn("[WARNING] require 'lhc/test/cache_helper.rb' is not needed any more! Just require 'lhc/rspec' in your spec helper instead.")

data/lib/lhc/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LHC
+  VERSION ||= '12.0.0'
+end

data/script/ci/build.sh

@@ -0,0 +1,19 @@
+#!/bin/bash -e
+
+# custom vars
+# RUBY = ruby-1.9.3-p125
+# GEMSET = location-app-${GitHub pull request id|branch name}
+# standard vars
+
+if [ -z "$SKIP_RVM" ]; then
+  [[ -s "/usr/local/rvm/scripts/rvm" ]] && . "/usr/local/rvm/scripts/rvm"
+  RUBY=${RUBY:-ruby-2.1.2}
+  GEMSET=${GEMSET:-LHC}
+  rvm use ${RUBY}@${GEMSET} --create
+  gem install bundler --no-rdoc --no-ri
+fi
+
+bundle install --local --quiet || bundle install --quiet
+RAILS_ENV=test bundle exec rspec
+bundle exec rspec non_rails_spec
+rvm --force gemset delete ${RUBY}@${GEMSET}

data/spec/basic_methods/delete_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'delete' do
+    let(:feedback) do
+      {
+        recommended: true,
+        source_id: 'aaa',
+        content_ad_id: '1z-5r1fkaj'
+      }
+    end
+
+    before(:each) do
+      stub_request(:delete, "http://datastore/v2/feedbacks/12121")
+        .to_return(status: 200, body: feedback.to_json, headers: { 'Content-Encoding' => 'UTF-8' })
+    end
+
+    it 'does a delete request when providing a complete url' do
+      LHC.delete('http://datastore/v2/feedbacks/12121')
+    end
+
+    it 'makes response data available in a rails way' do
+      response = LHC.delete('http://datastore/v2/feedbacks/12121')
+      expect(response.data.recommended).to eq true
+    end
+
+    it 'provides response headers' do
+      response = LHC.delete('http://datastore/v2/feedbacks/12121')
+      expect(response.headers).to be_present
+    end
+  end
+end

data/spec/basic_methods/get_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'get' do
+    before(:each) do
+      stub_request(:get, 'http://datastore/v2/feedbacks?has_reviews=true')
+        .to_return(status: 200, body: { total: 99 }.to_json, headers: { 'Content-Encoding' => 'UTF-8' })
+    end
+
+    let(:parameters) do
+      { has_reviews: true }
+    end
+
+    it 'does a get request when providing a complete url' do
+      LHC.get('http://datastore/v2/feedbacks', params: parameters)
+    end
+
+    it 'does a get request when providing the name of a configured endpoint' do
+      url = 'http://{+datastore}/v2/feedbacks'
+      options = { params: { datastore: 'datastore' } }
+      LHC.configure { |c| c.endpoint(:feedbacks, url, options) }
+      LHC.get(:feedbacks, params: parameters)
+    end
+
+    it 'makes response data available in a rails way' do
+      response = LHC.get('http://datastore/v2/feedbacks', params: parameters)
+      expect(response.data.total).to eq 99
+    end
+
+    it 'provides response headers' do
+      response = LHC.get('http://datastore/v2/feedbacks', params: parameters)
+      expect(response.headers).to be_present
+    end
+  end
+
+  context 'get json' do
+    before(:each) do
+      stub_request(:get, 'http://datastore/v2/feedbacks').with(headers: { 'Content-Type' => 'application/json; charset=utf-8' })
+        .to_return(body: { some: 'json' }.to_json)
+    end
+
+    it 'requests json and parses response body' do
+      data = LHC.json.get('http://datastore/v2/feedbacks').data
+      expect(data.some).to eq 'json'
+    end
+  end
+end