chimera_http_client 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd7ec7cbd4783fd8bd3c23a03ac5608c1357dfc7e300dc97a8ae721855b520f9
+  data.tar.gz: 28503993a05c765deb35bab4f263d47fb73bbc05ada7c3425a4b88b8531237d2
+SHA512:
+  metadata.gz: f444bb5f204a7212648d22392a3881085269e8e355ad18bf165eb61ea3e468fd6aba06c6debdd418b8d6eba0c6a80f9ce21ef2f2c3656ee080972731ba37cdbf
+  data.tar.gz: 13e1706d0f6d0b3a1cce9087e35c675d78053d53f2c8c5c0f113669dcaa10d1bf0badda6437c9eb45e8a08b8c00ac5a45411886cb2144bb942efa1403151f5e6

data/.gitignore

@@ -0,0 +1,4 @@
+/.bundle/
+/Gemfile.lock
+/doc/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,95 @@
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.5
+  Exclude:
+      - vendor/**/*
+      - config.ru
+
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, SupportedStyles, IndentationWidth.
+# SupportedStyles: special_inside_parentheses, consistent, align_braces
+Layout/IndentHash:
+  EnforcedStyle: consistent
+
+Metrics/AbcSize:
+  Max: 35
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 125
+
+# Offense count: 5
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 32
+
+Metrics/ParameterLists:
+  Max: 7
+
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+# SupportedStyles: braces, no_braces, context_dependent
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/CommentedKeyword:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/StringLiterals:
+  Description: 'Checks if uses of quotes match the configured preference.'
+  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#consistent-string-literals'
+  Enabled: true
+  EnforcedStyle: double_quotes
+  SupportedStyles:
+    - single_quotes
+    - double_quotes
+
+# Cop supports --auto-correct.
+Style/NumericLiterals:
+  MinDigits: 15
+
+# Cop supports --auto-correct.
+# Configuration parameters: AllowAsExpressionSeparator.
+Style/Semicolon:
+  AllowAsExpressionSeparator: true
+
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyleForMultiline, SupportedStyles.
+# SupportedStyles: comma, consistent_comma, no_comma
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+# Cop supports --auto-correct.
+# Configuration parameters: SupportedStyles, MinSize, WordRegex.
+# SupportedStyles: percent, brackets
+Style/WordArray:
+  EnforcedStyle: percent
+
+Style/SignalException:
+  EnforcedStyle: semantic

data/.ruby-version

@@ -0,0 +1 @@
+2.6.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in chimera_http_client.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2020 Andreas Finger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.markdown

@@ -0,0 +1,180 @@
+# ChimeraHttpClient
+
+When starting to split monolithic apps into smaller services, you need an easy way to access the remote data from the other apps. This chimera_http_client gem should serve as a unified way to access endpoints from other apps. And what works for the internal communication between your own apps, will also work to work with external APIs that do not offer a client for simplified access.
+
+## Dependencies
+
+The `chimera_http_client` gem is using the _libcurl_ wrapper [**Typhoeus**](https://typhoeus.github.io/). This allows for fast requests, for caching, and for queueing requests to run them in parallel (queueing and parallel requests are not implemented in the gem yet).
+
+It does not have any other runtime dependencies.
+
+### optional
+
+Setting the environment variable `ENV['CHIMERA_HTTP_CLIENT_LOG_REQUESTS']` to `true` (or `'true'`) will provide more detailed error messages for logging and also add additional information to the Error JSON. It is recommended to use this only in development environments.
+
+## The Connection class
+
+The basic usage looks like this:
+
+```ruby
+connection = ChimeraHttpClient::Connection.new(base_url: 'http://localhost/namespace')
+response = connection.get!(endpoint, params: params)
+```
+
+`ChimeraHttpClient::Connection.new` expects an options hash as parameter. The only required option is **base_url** which should include the host, port and base path to the API endpoints you want to call, e.g.  
+`base_url: 'http://localhost:3000/v1'`.
+
+On this connection object, you can call methods like `#get!` or `#post!` with an endpoint and an options hash as parameters, e.g.  
+`connection.get!("users/#{id}")` or  
+`connection.get(['users', id], options: { headers: { '	Accept-Charset' => 'utf-8' })`  
+
+Please take note that _the endpoint can be given as a String, a Symbol, or as an Array._  
+While they do no harm, there is _no need to pass leading or trailing `/` in endpoints._
+When passing the endpoint as an Array, _it's elements are converted to Strings and concatenated with `/`._  
+On each request _the http-headers can be amended or overwritten_ completely or partially.
+
+In case you need to use an API that is protected by **basic_auth** just pass the credentials in the options hash:  
+`options: { username: 'admin', password: 'secret' }`
+
+### Example usage
+
+To use the gem, it is recommended to write wrapper classes for the endpoints used. While it would be possible to use the `get, get!, post, post!, put, put!, patch, patch!, delete, delete!` or also the bare `request.run` methods directly, wrapper classes will unify the usage pattern and be very convenient to use by veterans and newcomers to the team. A wrapper class could look like this:
+
+```ruby
+require 'chimera_http_client'
+
+class Users
+  def initialize(base_url: 'http://localhost:3000/v1')
+    @base_url = base_url
+  end
+
+  def find(id:)
+    response = connection.get!(['users', id])
+
+    user = response.parsed_body
+    User.new(id: id, name: user['name'], email: user['email'])
+
+  rescue ChimeraHttpClient::Error => error
+    # handle / log / raise error
+  end
+
+  def all(filter: nil, page: nil)
+    params = {}
+    params[:filter] = filter
+    params[:page] = page
+
+    response = connection.get!('users', params: params)
+
+    all_users = response.parsed_body
+    all_users.map { |user| User.new(id: user['id'], name: user['name'], email: user['email']) }
+
+  rescue ChimeraHttpClient::Error => error
+    # handle / log / raise error
+  end
+
+  def create(body:)
+    response = connection.post!('users', body: body.to_json) # body.to_json
+
+    user = response.parsed_body
+    User.new(id: user['id'], name: user['name'], email: user['email'])
+
+  rescue ChimeraHttpClient::Error => error
+    # handle / log / raise error
+  end
+
+  private
+
+  def connection
+    @connection ||= ChimeraHttpClient::Connection.new(base_url: @base_url)
+  end
+end
+```
+
+To create and fetch a user from a remote service with the `Users` wrapper listed above, calls could be made like this:
+
+```ruby
+  users = Users.new
+
+  new_user = users.create(body: { name: "Andy", email: "andy@example.com" })
+  id = new_user.id
+
+  user = users.find(id: id)
+  user.name # == "Andy"
+```
+
+## The Request class
+
+Usually it does not have to be used directly. It is the class that executes the `Typhoeus::Requests`, raises `Errors` on failing and returns `Response` objects on successful calls.
+
+It will be expanded by a `.queue` method, that will queue (sic) calls and run them in parallel and not run every call directly, like the `.run` method does.
+
+## The Response class
+
+The `ChimeraHttpClient::Response` objects have the following interface:
+
+    * body             (content the call returns)
+    * code             (http code, should be 200 or 2xx)
+    * time             (for monitoring)
+    * response         (the full response object, including the request)
+    * error?           (returns false)
+    * parsed_body      (returns the result of JSON.parse(body))
+
+If your API does not use JSON, but a different format e.g. XML, you can either monkey patch a `parsed_xml` method to the Response class, or let your wrapper handle the parsing of `body`.
+
+## Error classes
+
+All errors inherit from `ChimeraHttpClient::Error` and therefore offer the same attributes:
+
+    * code             (http error code)
+    * body             (alias => message)
+    * time             (for monitoring)
+    * response         (the full response object, including the request)
+    * error?           (returns true)
+    * error_class      (e.g. ChimeraHttpClient::NotFoundError)
+    * to_s             (information for logging / respects ENV['CHIMERA_HTTP_CLIENT_LOG_REQUESTS'])
+    * to_json          (information to return to the API consumer / respects ENV['CHIMERA_HTTP_CLIENT_LOG_REQUESTS'])
+
+The error classes and their corresponding http error codes:
+
+    ConnectionError           # 0
+    RedirectionError          # 301, 302, 303, 307
+    BadRequestError           # 400
+    UnauthorizedError         # 401
+    ForbiddenError            # 403
+    NotFoundError             # 404
+    MethodNotAllowedError     # 405
+    ResourceConflictError     # 409
+    UnprocessableEntityError  # 422
+    ClientError               # 400..499
+    ServerError               # 500..599
+    TimeoutError              # timeout
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chimera_http_client', '~> 0.2'
+
+And then execute:
+
+    $ bundle
+
+When updating the version, do not forget to run
+
+    $ bundle update chimera_http_client
+
+## Maintainers and Contributors
+
+After checking out the repo, run `rake` to run the **tests and rubocop**.
+
+You can also run `rake console` to open an irb session with the `ChimeraHttpClient` pre-loaded that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/mediafinger/chimera_http_client>
+
+## Chimera
+
+Why this name? First of all, I needed a unique namespace. _HttpClient_ is already used too often. And as this gem is based on **Typhoeus** I picked the name of one of his (mythological) children.
+
+<https://en.wikipedia.org/wiki/Chimera_(mythology)>

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:rspec)
+
+desc "Open a console with the ChimeraHttpClient loaded"
+task :console do
+  system "irb -r lib/chimera_http_client.rb"
+end
+
+desc "Run Rubocop"
+task :rubocop do
+  system "bundle exec rubocop -c .rubocop.yml"
+end
+
+desc "Run Rubocop and auto-correct issues"
+task :rubocopa do
+  system "bundle exec rubocop -c .rubocop.yml -a"
+end
+
+desc "Run all the tests"
+task default: %i[rspec rubocop]

data/TODO.markdown

@@ -0,0 +1,56 @@
+# ChimeraHttpClient TODOs
+
+## Bugs
+
+* The connection_specs are testing for a Hash in the body instead for serialized JSON content
+* The implementation seems to be buggy, not handling JSON as intended
+
+## Features
+
+### HTTP Headers
+
+* make Connection#default_headers configurable
+* allow to set default_headers via ENV vars
+* give example how to use default_headers (e.g. request_id)
+* explain in README how to benefit from this gem in a given setting
+
+### Logger
+
+* allow to pass a logger
+* add logger.info when starting a http call
+* add logger.info when finishing a successful http call
+* add logger.warn / .error for error cases
+* include the total_time of the requests in the log
+* add example to README
+
+### Custom Serializer
+
+* allow to pass custom serializer
+* use custom serializer instead of expecting a JSON (or other) body
+* set header for the serializer
+* add example to README
+
+### Custom De-serializer
+
+* allow to pass custom deserializer
+* use custom deserializer in #parsed_body instead of default JSON parsing
+* add example to README
+
+### Queueing
+
+* allow to queue multiple calls
+* execute (up to 10) calls in parallel
+* add example to README
+
+### Caching
+
+* optional per connection or call
+* add example to README
+
+### Release
+
+* make repo public
+* hook up Travis-CI
+* ensure it runs with Ruby 2.5 and newer
+* get feedback
+* release to rubygems to add to the plethora of similar gems

data/chimera_http_client.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "chimera_http_client/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "chimera_http_client"
+  spec.version       = ChimeraHttpClient::VERSION
+  spec.authors       = ["Andreas Finger"]
+  spec.email         = ["webmaster@mediafinger.com"]
+
+  spec.summary       = "Http Client to connect to REST APIs"
+  spec.description   = "General http client functionality to easily connect to JSON endpoints"
+  spec.homepage      = "https://github.com/mediafinger/chimera_http_client"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "typhoeus", "~> 1.1"
+
+  spec.add_development_dependency "bundler",       "~> 1.13"
+  spec.add_development_dependency "irb",           "~> 1.0"
+  spec.add_development_dependency "rake",          ">= 10.0"
+  spec.add_development_dependency "rspec",         "~> 3.0"
+  spec.add_development_dependency "rubocop",       "~> 0.50"
+  spec.add_development_dependency "rubocop-rspec", "~> 1.4"
+end

data/lib/chimera_http_client.rb

@@ -0,0 +1,8 @@
+module ChimeraHttpClient
+  ROOT_PATH = File.expand_path("..", __dir__)
+
+  require "json"
+  require "typhoeus"
+
+  Dir.glob(ROOT_PATH + "/lib/chimera_http_client/*.rb") { |file| require file }
+end

data/lib/chimera_http_client/connection.rb

@@ -0,0 +1,99 @@
+# The get, post, put, patch and delete methods return either a Response or a Error
+# The bang methods get!, post!, put!, patch! and delete! raise a Error in case of failure
+
+module ChimeraHttpClient
+  class Connection
+    USER_AGENT = "ChimeraHttpClient (by mediafinger)".freeze
+
+    def initialize(base_url:, user_agent: USER_AGENT, verbose: false)
+      fail(ChimeraHttpClient::ParameterMissingError, "base_url expected, but not given") if base_url.nil?
+      @base_url = base_url
+
+      define_bang_methods
+
+      Typhoeus::Config.user_agent = user_agent
+      Typhoeus::Config.verbose = verbose
+      Typhoeus::Config.memoize = false
+      # Typhoeus::Config.cache
+    end
+
+    def request
+      @request ||= Request.new
+    end
+
+    def get(endpoint, options = {})
+      headers = extract_headers(options, default_headers)
+
+      request.run(url: url(endpoint), method: :get, options: options, headers: headers)
+    end
+
+    def post(endpoint, options = {})
+      run_with_body(:post, endpoint, options)
+    end
+
+    def put(endpoint, options = {})
+      run_with_body(:put, endpoint, options)
+    end
+
+    def patch(endpoint, options = {})
+      run_with_body(:patch, endpoint, options)
+    end
+
+    def delete(endpoint, options = {})
+      run_with_body(:delete, endpoint, options.merge(body_optional: true))
+    end
+
+    private
+
+    def run_with_body(method, endpoint, options = {})
+      body = extract_body(options)
+      headers = extract_headers(options, default_headers)
+
+      request.run(url: url(endpoint), method: method, body: body, options: options, headers: headers)
+    end
+
+    def url(endpoint)
+      trimmed_endpoint = Array(endpoint).map { |e| trim(e) }
+      [@base_url.chomp("/"), trimmed_endpoint].flatten.reject(&:empty?).join("/")
+    end
+
+    def trim(element)
+      element.to_s.sub(%r{^\/}, "").chomp("/")
+    end
+
+    def extract_body(options)
+      body = options.delete(:body)
+      body_optional = options.delete(:body_optional)
+      fail(ChimeraHttpClient::ParameterMissingError, "body expected, but not given") if body.nil? && !body_optional
+      body
+    end
+
+    def extract_headers(options, headers)
+      given_headers = options.delete(:headers) || {}
+      headers.merge(given_headers)
+    end
+
+    def default_headers
+      { "Content-Type" => "application/json" }
+    end
+
+    # get! post! put! patch! delete! return an Response when successful, but raise an Error otherwise
+    def define_bang_methods
+      {
+        get!:    :get,
+        post!:   :post,
+        put!:    :put,
+        patch!:  :patch,
+        delete!: :delete,
+      }.each do |method_name, implemented_method|
+        self.class.send(:define_method, method_name) do |endpoint, options = {}|
+          result = public_send(implemented_method, endpoint, options)
+
+          fail result if result.error?
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/chimera_http_client/error.rb

@@ -0,0 +1,76 @@
+module ChimeraHttpClient
+  class Error < StandardError
+    attr_reader :body, :code, :time, :response
+    alias message body
+
+    def initialize(response)
+      @body     = response.body
+      @code     = response.code
+      @time     = response.options&.fetch(:total_time, nil)
+      @response = response # contains the request
+      super
+    end
+
+    def error?
+      true
+    end
+
+    def parsed_body
+      JSON.parse(body)
+    rescue JSON::ParserError
+      { "non_json_body" => body }
+    end
+
+    def to_s
+      error = "#{self.class.name} (#{code}) #{message}, URL: #{url}"
+
+      return "#{error}, Request: #{response.request.inspect}" if log_requests?
+
+      error
+    end
+
+    def to_json
+      error = {
+        code:        code,
+        error_class: self.class.name,
+        method:      http_method,
+        url:         url,
+        message:     message,
+      }
+
+      return error.merge({ request: response.request.inspect }).to_json if log_requests?
+
+      error.to_json
+    end
+
+    private
+
+    def url
+      response.request.base_url
+    end
+
+    def http_method
+      response.request.options[:method]
+    end
+
+    def log_requests?
+      ENV["CHIMERA_HTTP_CLIENT_LOG_REQUESTS"] == true || ENV["CHIMERA_HTTP_CLIENT_LOG_REQUESTS"] == "true"
+    end
+  end
+
+  class ParameterMissingError < StandardError; end     # missing parameters
+  class JsonParserError < StandardError; end           # body is not parsable json
+
+  class ConnectionError < Error; end           # 0
+  class RedirectionError < Error; end          # 301, 302, 303, 307
+  class BadRequestError < Error; end           # 400
+  class UnauthorizedError < Error; end         # 401
+  class ForbiddenError < Error; end            # 403
+  class NotFoundError < Error; end             # 404
+  class MethodNotAllowedError < Error; end     # 405
+  class ResourceConflictError < Error; end     # 409
+  class UnprocessableEntityError < Error; end  # 422
+  class ClientError < Error; end               # 400..499
+  class ServerError < Error; end               # 500..599
+  class TimeoutError < Error; end              # timeout
+end

data/lib/chimera_http_client/request.rb

@@ -0,0 +1,71 @@
+module ChimeraHttpClient
+  class Request
+    TIMEOUT_SECONDS = 5
+
+    def run(url:, method:, body: nil, options: {}, headers: {})
+      request_params = {
+        method:          method,
+        body:            body,
+        params:          options.fetch(:params, {}),
+        headers:         headers,
+        timeout:         options.fetch(:timeout, TIMEOUT_SECONDS),
+        accept_encoding: "gzip",
+      }
+
+      # Basic-auth support:
+      username = options.fetch(:username, nil)
+      password = options.fetch(:password, nil)
+      request_params[:userpwd] = "#{username}:#{password}" if username && password
+
+      request = Typhoeus::Request.new(url, request_params)
+
+      result = nil
+      request.on_complete do |response|
+        result = on_complete_handler(response)
+      end
+
+      request.run
+
+      result
+    end
+
+    private
+
+    def on_complete_handler(response)
+      return Response.new(response) if response.success?
+
+      exception_for(response)
+    end
+
+    def exception_for(response)
+      return TimeoutError.new(response) if response.timed_out?
+
+      case response.code.to_i
+      when 301, 302, 303, 307
+        RedirectionError.new(response)
+      when 200..399
+        nil
+      when 400
+        BadRequestError.new(response)
+      when 401
+        UnauthorizedError.new(response)
+      when 403
+        ForbiddenError.new(response)
+      when 404
+        NotFoundError.new(response)
+      when 405
+        MethodNotAllowedError.new(response)
+      when 409
+        ResourceConflictError.new(response)
+      when 422
+        UnprocessableEntityError.new(response)
+      when 400..499
+        ClientError.new(response)
+      when 500..599
+        ServerError.new(response)
+      else # response.code.zero?
+        ConnectionError.new(response)
+      end
+    end
+  end
+end

data/lib/chimera_http_client/response.rb

@@ -0,0 +1,22 @@
+module ChimeraHttpClient
+  class Response
+    attr_reader :body, :code, :time, :response
+
+    def initialize(response)
+      @body     = response.body
+      @code     = response.code
+      @time     = response.total_time
+      @response = response # contains the request
+    end
+
+    def parsed_body
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      raise ChimeraHttpClient::JsonParserError, "Could not parse body as JSON: #{body}, error: #{e.message}"
+    end
+
+    def error?
+      false
+    end
+  end
+end

data/lib/chimera_http_client/version.rb

@@ -0,0 +1,3 @@
+module ChimeraHttpClient
+  VERSION = "0.2.0".freeze
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: chimera_http_client
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Andreas Finger
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.50'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: General http client functionality to easily connect to JSON endpoints
+email:
+- webmaster@mediafinger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- LICENSE
+- README.markdown
+- Rakefile
+- TODO.markdown
+- chimera_http_client.gemspec
+- lib/chimera_http_client.rb
+- lib/chimera_http_client/connection.rb
+- lib/chimera_http_client/error.rb
+- lib/chimera_http_client/request.rb
+- lib/chimera_http_client/response.rb
+- lib/chimera_http_client/version.rb
+homepage: https://github.com/mediafinger/chimera_http_client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Http Client to connect to REST APIs
+test_files: []