rest-core 3.5.4 → 3.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c924d022a2e6884c045b8d70ad7c1a30d86a5ca5
-  data.tar.gz: 29232062eafc2a9f2dc6619da8470c79cf475dab
+  metadata.gz: 02a017ca6ef776af782e4e7c575858b0cb8f3703
+  data.tar.gz: 8d29c4f87749dccb787c0134f6938a95fe57b733
 SHA512:
-  metadata.gz: b9b3a2c2fd0c54d3406988ded11b4954a7f620f3209a8fec4187e013a39b039be17a8ce68186365ed6c7d0a740130b177ab06f9323cea5b87bd88746235c3351
-  data.tar.gz: 87b917cd53b4f80ed97d7ed172b5ad54063d5db868b525ca0501297f85c2f413d1c88d43ee80a8e59cda2179f5c0600156f4d36b0e85eca8169bfba210fe2d75
+  metadata.gz: 0d6aad0bedad2f4b7a72a78ec984721515157508d20983425eb2f0354fad6cd092beaaa4d626ae4f1000339d248535d83b9b1da8568afe13adcdb5cf5064fe07
+  data.tar.gz: 2b75fccd0ba262c7f8915217cd142dbcc85f49497a2fe7b40b5d84b3818b74dea0b0982ba8ab601fa6a044c83e346054edd7beab24a56f67766a5c688ad61942

data/.travis.yml

@@ -6,7 +6,6 @@ rvm:
   - 2.2
   - rbx-2
   - jruby
-  - jruby-head
 
 install: 'bundle install --retry=3'
 script: 'ruby -r bundler/setup -S rake test'

data/CHANGES.md

@@ -1,5 +1,11 @@
 # CHANGES
 
+## rest-core 3.5.5 -- 2015-07-22
+
+### Bugs fixed
+
+* Fixed a possible data race for thread pool when enqueuing very quickly.
+
 ## rest-core 3.5.4 -- 2015-01-17
 
 ### Bugs fixed

data/Gemfile

@@ -25,6 +25,7 @@ end
 
 platforms :rbx do
   gem 'rubysl-weakref'    # used in rest-core
+  gem 'rubysl-socket'     # used in test
   gem 'rubysl-singleton'  # used in rake
   gem 'rubysl-rexml'      # used in crack used in webmock
   gem 'rubysl-bigdecimal' # used in crack used in webmock

data/README.md

@@ -1,4 +1,4 @@
-# rest-core [![Build Status](https://secure.travis-ci.org/godfat/rest-core.png?branch=master)](http://travis-ci.org/godfat/rest-core) [![Coverage Status](https://coveralls.io/repos/godfat/rest-core/badge.png)](https://coveralls.io/r/godfat/rest-core)
+# rest-core [![Build Status](https://secure.travis-ci.org/godfat/rest-core.png?branch=master)](http://travis-ci.org/godfat/rest-core) [![Coverage Status](https://coveralls.io/repos/godfat/rest-core/badge.png)](https://coveralls.io/r/godfat/rest-core) [![Join the chat at https://gitter.im/godfat/rest-core](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/godfat/rest-core)
 
 by Lin Jen-Shin ([godfat](http://godfat.org))
 
@@ -301,8 +301,9 @@ Not only JavaScript could receive server-sent events, any languages could.
 Doing so would establish a keep-alive connection to the server, and receive
 data periodically. We'll take Firebase as an example:
 
-If you are using Firebase, please consider the pre-built client in
-[rest-more][] instead.
+If you are using Firebase, please consider [rest-firebase][] instead.
+
+[rest-firebase]: https://github.com/CodementorIO/rest-firebase
 
 ``` ruby
 require 'rest-core'
@@ -685,9 +686,67 @@ and complete.
 
 [example/use-cases.rb]: example/use-cases.rb
 
+## Configure the underlying HTTP engine
+
+Occasionally we might want to configure the underlying HTTP engine, which
+for now is [httpclient][]. For example, we might not want to decompress
+gzip automatically, (rest-core configures httpclient to request and
+decompress gzip automatically). or we might want to skip verifying SSL
+in some situation. (e.g. making requests against a self-signed testing server)
+
+In such cases, we could use `config_engine` option to configure the underlying
+engine. This could be set with request based, client instance based, or
+client class based. Please refer to:
+[How We Pick the Default Value](#how-we-pick-the-default-value),
+except that there's no middleware for `config_engine`.
+
+Here are some examples:
+
+``` ruby
+require 'rest-core'
+YourClient = RC::Builder.client
+
+# class based:
+def YourClient.default_config_engine
+  lambda do |engine|
+    # disable auto-gzip:
+    engine.transparent_gzip_decompression = false
+
+    # disable verifying SSL
+    engine.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+  end
+end
+
+# instance based:
+client = YourClient.new(:config_engine => lambda do |engine|
+  # disable auto-gzip:
+  engine.transparent_gzip_decompression = false
+
+  # disable verifying SSL
+  engine.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+end)
+
+# request based:
+client.get('http://example.com/', {}, :config_engine => lambda do |engine|
+  # disable auto-gzip:
+  engine.transparent_gzip_decompression = false
+
+  # disable verifying SSL
+  engine.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+end)
+```
+
+As we stated in
+[How We Pick the Default Value](#how-we-pick-the-default-value),
+the priority here is:
+
+0. request based
+0. instance based
+0. class based
+
 ## rest-core users:
 
-* [rest-firebase](https://github.com/CodementorIO/rest-firebase)
+* [rest-firebase][]
 * [rest-more][]
 * [rest-more-yahoo_buy](https://github.com/GoodLife/rest-more-yahoo_buy)
 * [s2sync](https://github.com/brucehsu/s2sync)
@@ -727,7 +786,7 @@ and complete.
 
 Apache License 2.0
 
-Copyright (c) 2011-2014, Lin Jen-Shin (godfat)
+Copyright (c) 2011-2015, Lin Jen-Shin (godfat)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/TODO.md

@@ -1,14 +1,13 @@
 # TODO
 
-* middleware revisit (how to initialize?)
-* X-Method-Override
+# NEAR FUTURE
 
-# FEATURE
+* revisit error_callback (use middleware)
+* ActiveRecord::ConnectionAdapters::ConnectionManagement
+
+# FAR FUTURE
 
 * middleware composer
 * headers and payload logs for CommonLogger
-
-# rest-request
-
 * fix DRY by defining `prepare :: env -> env`
 * FAIL and LOG need to be reimplemented as well.

data/lib/rest-core/builder.rb

@@ -54,7 +54,7 @@ class RestCore::Builder
   end
 
   def to_client *attrs
-    fields = members + attrs
+    fields = (members + attrs + [:config_engine]).uniq
     struct = build_struct(fields)
     client = Class.new(struct)
     client.const_set('Struct', struct)

data/lib/rest-core/engine.rb

@@ -3,6 +3,7 @@ require 'rest-core/promise'
 require 'rest-core/middleware'
 
 class RestCore::Engine
+  def self.members; [:config_engine]; end
   include RestCore::Middleware
 
   def call env, &k

data/lib/rest-core/engine/http-client.rb

@@ -9,6 +9,7 @@ class RestCore::HttpClient < RestCore::Engine
     client.cookie_manager = nil
     client.follow_redirect_count = 0
     client.transparent_gzip_decompression = true
+    config = config_engine(env) and config.call(client)
     payload, headers = payload_and_headers(env)
 
     if env[HIJACK]

data/lib/rest-core/middleware/json_response.rb

@@ -28,11 +28,16 @@ class RestCore::JsonResponse
   end
 
   def process response
-    # StackExchange returns the problematic BOM! in UTF-8, so we need to
-    # strip it or it would break JSON parsers (i.e. yajl-ruby and json)
     body = response[RESPONSE_BODY].to_s.sub(/\A\xEF\xBB\xBF/, '')
-    response.merge(RESPONSE_BODY => Json.decode("[#{body}]").first)
-    # [this].first is not needed for yajl-ruby
+    if response[HIJACK] && Json.respond_to?(:decode_from_io)
+      response.merge(
+        RESPONSE_SOCKET => Json.decode_from_io(response[RESPONSE_SOCKET]))
+    else
+      # StackExchange returns the problematic BOM! in UTF-8, so we need to
+      # strip it or it would break JSON parsers (i.e. yajl-ruby and json)
+      response.merge(RESPONSE_BODY => Json.decode("[#{body}]").first)
+      # [this].first is not needed for yajl-ruby
+    end
   rescue Json.const_get(:ParseError) => error
     fail(response, ParseError.new(error, body))
   end

data/lib/rest-core/thread_pool.rb

@@ -11,25 +11,24 @@ class RestCore::ThreadPool
   class Queue
     def initialize
       @queue = []
-      @mutex = Mutex.new
       @condv = ConditionVariable.new
     end
 
+    def size
+      @queue.size
+    end
+
     def << task
-      mutex.synchronize do
-        queue << task
-        condv.signal
-      end
+      queue << task
+      condv.signal
     end
 
-    def pop timeout=60
-      mutex.synchronize do
-        if queue.empty?
-          condv.wait(mutex, timeout)
-          queue.shift || lambda{ |_| false } # shutdown idle workers
-        else
-          queue.shift
-        end
+    def pop mutex, timeout=60
+      if queue.empty?
+        condv.wait(mutex, timeout)
+        queue.shift || lambda{ |_| false } # shutdown idle workers
+      else
+        queue.shift
       end
     end
 
@@ -38,7 +37,7 @@ class RestCore::ThreadPool
     end
 
     protected
-    attr_reader :queue, :mutex, :condv
+    attr_reader :queue, :condv
   end
 
   class Task < Struct.new(:job, :mutex, :thread, :cancelled)
@@ -61,7 +60,7 @@ class RestCore::ThreadPool
     (@pools ||= {})[client_class] ||= new(client_class)
   end
 
-  attr_reader :client_class
+  attr_reader :client_class, :workers
 
   def initialize client_class
     @client_class = client_class
@@ -87,37 +86,43 @@ class RestCore::ThreadPool
     client_class.pool_idle_time
   end
 
-  def defer mutex=nil, &job
-    task = Task.new(job, mutex)
-    queue << task
-    spawn_worker if waiting == 0 && workers.size < max_size
-    task
+  def defer promise_mutex, &job
+    mutex.synchronize do
+      task = Task.new(job, promise_mutex)
+      queue << task
+      spawn_worker if waiting < queue.size && workers.size < max_size
+      task
+    end
   end
 
   def trim force=false
-    queue << lambda{ |_| false } if force || waiting > 0
+    mutex.synchronize do
+      queue << lambda{ |_| false } if force || waiting > 0
+    end
   end
 
   # Block on shutting down, and should not add more jobs while shutting down
   def shutdown
     workers.size.times{ trim(true) }
     workers.first.join && trim(true) until workers.empty?
-    queue.clear
+    mutex.synchronize{ queue.clear }
   end
 
   protected
-  attr_reader :queue, :mutex, :condv, :workers, :waiting
+  attr_reader :queue, :mutex, :condv, :waiting
 
   private
   def spawn_worker
     workers << Thread.new{
-      Thread.current.abort_on_exception = !!$DEBUG
+      Thread.current.abort_on_exception = true
 
       task = nil
       begin
-        mutex.synchronize{ @waiting += 1 }
-        task = queue.pop(idle_time)
-        mutex.synchronize{ @waiting -= 1 }
+        mutex.synchronize do
+          @waiting += 1
+          task = queue.pop(mutex, idle_time)
+          @waiting -= 1
+        end
       end while task.call(Thread.current)
 
       mutex.synchronize{ workers.delete(Thread.current) }

data/lib/rest-core/util/json.rb

@@ -23,6 +23,7 @@ module RestCore::Json
     def decode json
       Yajl::Parser.parse(json)
     end
+    alias_method :decode_from_io, :decode
   end
 
   module Json

data/lib/rest-core/util/payload.rb

@@ -3,7 +3,11 @@
 
 require 'rest-core/error'
 
-require 'mime/types'
+begin
+  require 'mime/types/columnar'
+rescue LoadError
+  require 'mime/types'
+end
 
 require 'stringio'
 require 'tempfile'

data/lib/rest-core/version.rb

@@ -1,4 +1,4 @@
 
 module RestCore
-  VERSION = '3.5.4'
+  VERSION = '3.5.5'
 end

data/rest-core.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: rest-core 3.5.4 ruby lib
+# stub: rest-core 3.5.5 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rest-core"
-  s.version = "3.5.4"
+  s.version = "3.5.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2015-01-17"
+  s.date = "2015-07-22"
   s.description = "Modular Ruby clients interface for REST APIs.\n\nThere has been an explosion in the number of REST APIs available today.\nTo address the need for a way to access these APIs easily and elegantly,\nwe have developed rest-core, which consists of composable middleware\nthat allows you to build a REST client for any REST API. Or in the case of\ncommon APIs such as Facebook, Github, and Twitter, you can simply use the\ndedicated clients provided by [rest-more][].\n\n[rest-more]: https://github.com/godfat/rest-more"
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
@@ -113,7 +113,7 @@ Gem::Specification.new do |s|
   "test/test_universal.rb"]
   s.homepage = "https://github.com/godfat/rest-core"
   s.licenses = ["Apache License 2.0"]
-  s.rubygems_version = "2.4.5"
+  s.rubygems_version = "2.4.8"
   s.summary = "Modular Ruby clients interface for REST APIs."
   s.test_files = [
   "test/test_auth_basic.rb",

data/task/gemgem.rb

@@ -100,8 +100,12 @@ module Gemgem
     if ENV['COV'] || ENV['CI']
       require 'simplecov'
       if ENV['CI']
-        require 'coveralls'
-        SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+        begin
+          require 'coveralls'
+          SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+        rescue LoadError => e
+          puts "Cannot load coveralls, skip: #{e}"
+        end
       end
       SimpleCov.start do
         add_filter('test/')

data/test/test_builder.rb

@@ -25,7 +25,7 @@ describe RC::Builder do
   would 'accept middleware without a member' do
     RC::Builder.client{
       use Class.new.send(:include, RC::Middleware)
-    }.members.should.eq []
+    }.members.should.eq [:config_engine]
   end
 
   would 'not have duplicated fields' do

data/test/test_default_payload.rb

@@ -5,6 +5,10 @@ describe RC::DefaultPayload do
   app = RC::DefaultPayload.new(RC::Dry.new, {})
   env = {RC::REQUEST_PAYLOAD => {}}
 
+  before do
+    app.instance_eval{@payload = {}}
+  end
+
   would 'do nothing' do
     app.call(env){ |r| r[RC::REQUEST_PAYLOAD].should.eq({}) }
   end
@@ -16,9 +20,9 @@ describe RC::DefaultPayload do
       {'pay' => 'load'}}) }
 
     format = {'format' => 'json'}
-    env    = {RC::REQUEST_PAYLOAD => format}
+    e      = {RC::REQUEST_PAYLOAD => format}
 
-    app.call(env){ |r| r.should.eq({RC::REQUEST_PAYLOAD =>
+    app.call(e){ |r| r.should.eq({RC::REQUEST_PAYLOAD =>
       {'pay' => 'load'}.merge(format)})}
   end
 
@@ -32,15 +36,15 @@ describe RC::DefaultPayload do
 
   would 'accept non-hash payload' do
     u = RC::Universal.new(:log_method => false)
-    env = {RC::REQUEST_PAYLOAD => 'payload'}
-    u.request_full(env, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
+    e = {RC::REQUEST_PAYLOAD => 'payload'}
+    u.request_full(e, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
 
     u.payload = 'default'
-    u.request_full(env, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
-    u.request_full({} , u.dry)[RC::REQUEST_PAYLOAD].should.eq('default')
+    u.request_full( e, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
+    u.request_full({}, u.dry)[RC::REQUEST_PAYLOAD].should.eq('default')
 
     u = RC::Builder.client{use RC::DefaultPayload, 'maylord'}.new
-    u.request_full({} , u.dry)[RC::REQUEST_PAYLOAD].should.eq('maylord')
-    u.request_full(env, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
+    u.request_full({}, u.dry)[RC::REQUEST_PAYLOAD].should.eq('maylord')
+    u.request_full( e, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
   end
 end

data/test/test_error_handler.rb

@@ -44,17 +44,17 @@ describe RC::ErrorHandler do
 
   would 'set full backtrace' do
     url = 'http://example.com/'
-    client = RC::Builder.client do
+    c = RC::Builder.client do
       use RC::ErrorHandler, lambda{ |env|
                               RuntimeError.new(env[RC::RESPONSE_BODY]) }
       use RC::ErrorDetectorHttp
     end.new
     stub_request(:get, url).to_return(:status => 404, :body => 'nnf')
-    client.get(url) do |error|
+    c.get(url) do |error|
       error.message.should.eq 'nnf'
       error.backtrace.grep(/^#{__FILE__}/).should.not.empty?
     end
-    client.wait
+    c.wait
   end
 
   would 'not call error_handler if there is already an exception' do

data/test/test_httpclient.rb

@@ -1,6 +1,10 @@
 
 require 'rest-core/test'
 
+require 'openssl'
+require 'socket'
+require 'zlib'
+
 describe RC::HttpClient do
   describe 'POST Payload' do
     after do
@@ -8,7 +12,6 @@ describe RC::HttpClient do
     end
 
     client = RC::Builder.client
-    client.builder.run(RC::HttpClient)
     path = 'http://example.com'
     ok   = 'OK'
     c    = client.new
@@ -43,5 +46,73 @@ describe RC::HttpClient do
       c.request(RC::ASYNC => true).message.should.eq 'boom'
       Muack.verify
     end
+
+    def accept body
+      server = TCPServer.new(0)
+      t = Thread.new do
+        client = server.accept
+        client.write(<<-HTTP)
+HTTP/1.0 200 OK\r
+Connection: close\r
+Content-Encoding: deflate\r
+\r
+#{body}\r
+          HTTP
+        client.close_write
+      end
+
+      yield("http://localhost:#{server.local_address.ip_port}")
+
+      t.join
+    end
+
+    would 'accept deflate' do
+      accept(Zlib::Deflate.deflate(ok)) do |site|
+        c.post(site, 'body').should.eq ok
+      end
+    end
+
+    config_engine = lambda do |engine|
+      engine.transparent_gzip_decompression = false
+      engine.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    define_method(:define_default_config_engine) do |d|
+      d.singleton_class.module_eval do
+        define_method(:default_config_engine) do
+          config_engine
+        end
+      end
+    end
+
+    would 'disable auto-deflate' do
+      accept(ok) do |site|
+        c.post(site, 'body', {}, :config_engine => config_engine).
+          chomp.should.eq ok
+      end
+    end
+
+    would 'disable auto-deflate with class default_config_engine' do
+      accept(ok) do |site|
+        d = RC::Builder.client
+        define_default_config_engine(d)
+        d.new.post(site, 'body').chomp.should.eq ok
+      end
+    end
+
+    would 'disable auto-deflate with instance default_config_engine' do
+      accept(ok) do |site|
+        d = RC::Builder.client.new
+        define_default_config_engine(d)
+        d.post(site, 'body').chomp.should.eq ok
+      end
+    end
+
+    would 'disable auto-deflate with setting config_engine' do
+      accept(ok) do |site|
+        d = RC::Builder.client.new(:config_engine => config_engine)
+        d.post(site, 'body').chomp.should.eq ok
+      end
+    end
   end
 end

data/test/test_thread_pool.rb

@@ -2,9 +2,33 @@
 require 'rest-core/test'
 
 describe RC::ThreadPool do
-  would 'have the same pool for the same client' do
-    client = RC::Builder.client
-    pool   = RC::ThreadPool[client]
-    RC::ThreadPool[client].object_id.should.eq pool.object_id
+  # would 'have the same pool for the same client' do
+  #   client = RC::Builder.client
+  #   pool   = RC::ThreadPool[client]
+  #   RC::ThreadPool[client].object_id.should.eq pool.object_id
+  # end
+
+  would 'not waiting forever' do
+    mutex = Mutex.new
+    condv = ConditionVariable.new
+    klass = Struct.new(:pool_size, :pool_idle_time).new(2, 10)
+    pool = RC::ThreadPool[klass]
+    pool.defer(mutex){mutex.synchronize{ condv.signal }} # populate one worker
+    mutex.synchronize{ condv.wait(mutex) }
+    called = []
+    pool.defer(mutex) do
+      sleep 1
+      called << 0
+    end
+    pool.defer(mutex) do
+      sleep 1
+      called << 0
+      pool.defer(mutex) do
+        called << 1
+      end
+    end
+    sleep 5
+    p called
+    ok
   end
 end

data/test/test_timeout.rb

@@ -23,7 +23,7 @@ describe RC::Timeout do
 
   would "not raise timeout error if there's already an error" do
     env = {'timeout' => 0.01}
-    mock(app.app).call(hash_including(env)){ raise "error" }
+    mock(app.app).call(having(env)){ raise "error" }
     lambda{ app.call(env){} }.should    .raise(RuntimeError)
     lambda{ sleep 0.01      }.should.not.raise(Timeout::Error)
   end
@@ -51,21 +51,21 @@ describe RC::Timeout do
 
   would 'cancel the task if timing out for thread pool' do
     timer = fake_timer
-    app   = sleeping_app
-    app.pool_size = 1
-    app.new.request(RC::TIMER => timer, RC::ASYNC => true).
+    a     = sleeping_app
+    a.pool_size = 1
+    a.new.request(RC::TIMER => timer, RC::ASYNC => true).
       message.should.eq 'boom'
     timer.timer.should.not.nil?
   end
 
   would 'still timeout if the task never processed for thread pool' do
-    app = sleeping_app
-    app.pool_size = 1
-    app.new.request(RC::TIMER => fake_timer, RC::ASYNC => true) do |e|
+    a = sleeping_app
+    a.pool_size = 1
+    a.new.request(RC::TIMER => fake_timer, RC::ASYNC => true) do |e|
       e.message.should.eq 'boom'
-      app.new.request(RC::TIMER => fake_timer, RC::ASYNC => true).tap{}
+      a.new.request(RC::TIMER => fake_timer, RC::ASYNC => true).tap{}
     end
-    app.wait
+    a.wait
   end
 
   would 'interrupt the task if timing out' do
@@ -85,7 +85,7 @@ describe RC::Timeout do
       def timer     ; @block; end
       self
     end
-    app = RC::Builder.client do
+    a = RC::Builder.client do
       run Class.new(RC::Engine){
         def request _, env
           env['pipe'].puts
@@ -94,8 +94,8 @@ describe RC::Timeout do
       }
     end
     (-1..1).each do |size|
-      app.pool_size = size
-      app.new.request(RC::TIMER => timer, RC::ASYNC => true, 'pipe' => wr).
+      a.pool_size = size
+      a.new.request(RC::TIMER => timer, RC::ASYNC => true, 'pipe' => wr).
         message.should.eq 'boom'
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest-core
 version: !ruby/object:Gem::Version
-  version: 3.5.4
+  version: 3.5.5
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-17 00:00:00.000000000 Z
+date: 2015-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -188,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Modular Ruby clients interface for REST APIs.