json-rpc-client 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45369d3297682f37bcf9119e27b3756a89ed464c
+  data.tar.gz: 9e1d8b669fcb8c51dd814161c7337abf7a7769d0
+SHA512:
+  metadata.gz: e5d14d9afa48ab3f7b084d9d435aa081b54b411490b4530b189f27f90fa585942a1cb266b14a93e440656eaa663db528f40e683af47d02c1eb484edc5375a64b
+  data.tar.gz: 3c6093337ccce5a371c8115a5ef5ef248869405b5e00a628813d080e48d7d5b9eb3f5db2823ccda06bc4b002168b817a4d6dbd0628f41dc9d29dbeadcd2d90d6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'bundler'
+gemspec

data/LICENSE

@@ -0,0 +1,16 @@
+Copyright (C) 2012-2013 Textalk AB
+
+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.md

@@ -0,0 +1,87 @@
+Asynchronous (EventMachine) JSON-RPC 2.0 client
+===============================================
+
+This gem is a client implementation for JSON-RPC 2.0. It uses EventMachine to
+enable asynchronous communication with a JSON-RPC server. It can be used synchronously if
+called within a (non-root) fiber.
+
+Usage example for asynchronous behaviour:
+```Ruby
+wallet      = JsonRpcClient.new('https://localhost:8332/') # Local bitcoin wallet
+balance_rpc = wallet.getbalance()
+balance_rpc.callback do |result|
+  puts result # => 90.12345678
+end
+
+balance_rpc.errback do |error|
+  puts error
+  # => "JsonRpcClient.Error: Bad method, code: -32601, data: nil"
+end
+```
+
+Usage example for synchronous behaviour:
+```Ruby
+require 'eventmachine'
+require 'json-rpc-client'
+require 'fiber'
+
+EventMachine.run do
+  # To use the syncing behaviour, use it in a fiber.
+  fiber = Fiber.new do
+    article = JsonRpcClient.new(
+      'https://shop.textalk.se/backend/jsonrpc/Article/14284660',
+      {asynchronous_calls: false}
+    )
+    puts article.get({name: true})
+    # => {:name=>{:sv=>"Presentkort 1000 kr", :en=>"Gift certificate 1000 SEK"}}
+
+    EventMachine.stop
+  end
+
+  fiber.resume
+end
+```
+
+Logging
+-------
+
+The client supports both a default logger (for all instances) and a per instance logger.
+Simply attach a logger of your choice(that responds to info, warning, error and debug) and
+any interaction will be output as debug, and any errors as errors. Any per instance logger will
+override the default logger for that instance.
+
+```Ruby
+require 'logger'
+JsonRpcClient.default_logger = Logger.new($STDOUT)
+wallet = JsonRpcClient.new('https://localhost:8332/') # Local bitcoin wallet
+wallet.logger = MyCustomLogger.new()
+```
+
+Development
+-----------
+
+To set up a development environment, simply do:
+
+```bash
+bundle install
+bundle exec rake  # run the test suite
+```
+
+There are autotests located in the test folder and the framework used is
+[Bacon](https://github.com/chneukirchen/bacon). They're all mocked with
+[VCR](https://github.com/vcr/vcr)/[Webmock](https://github.com/bblimke/webmock)
+so no internet connection is required to run them.
+
+JSON-RPC 2.0
+------------
+
+JSON-RPC 2.0 is a very simple protocol for remote procedure calls,
+agnostic of carrier (http, websocket, tcp, whatever…).
+
+[JSON-RPC 2.0 Specification](http://www.jsonrpc.org/specification)
+
+Copyright
+---------
+Copyright (C) 2012-2013, Textalk AB <http://textalk.se/>
+
+JSON-RPC client is freely distributable under the terms of an MIT license. See [LICENCE](LICENSE).

data/Rakefile

@@ -0,0 +1,7 @@
+desc 'Runs the test suite'
+task :test do
+  sh "bacon test/json-rpc-test.rb"
+end
+
+desc "Run tests"
+task :default => :test

data/lib/json-rpc-client.rb

@@ -0,0 +1,261 @@
+require 'em-http-request'
+require 'json'
+require 'addressable/uri'
+
+# This implements a client for JSON-RPC (version 2) calls.
+#
+# @example Asynchronous
+#   wallet      = JsonRpcClient.new('https://localhost:8332/') # Local bitcoin wallet
+#   balance_rpc = wallet.getbalance()
+#   balance_rpc.callback do |result|
+#     puts result # => 90.12345678
+#   end
+#
+#   balance_rpc.errback do |error|
+#     puts error
+#     # => "JsonRpcClient.Error: Bad method, code: -32601, data: nil"
+#   end
+#
+# @example Synchronous
+#   require 'eventmachine'
+#   require 'json-rpc-client'
+#   require 'fiber'
+#
+#   EventMachine.run do
+#     # To use the syncing behaviour, use it in a fiber.
+#     fiber = Fiber.new do
+#       article = JsonRpcClient.new(
+#         'https://shop.textalk.se/backend/jsonrpc/Article/14284660',
+#         {asynchronous_calls: false}
+#       )
+#       puts article.get({name: true})
+#       # => {:name=>{:sv=>"Presentkort 1000 kr", :en=>"Gift certificate 1000 SEK"}}
+
+#       EventMachine.stop
+#     end
+
+#     fiber.resume
+#   end
+#
+# @!attribute asynchronous_calls
+#   @return [Boolean] If method_missing calls are made asynchronously. Default: true
+# @!attribute symbolize_names
+#   @return [Boolean] If the result of sync calls should have the names be symbols. Default: true
+# @!attribute logger
+#   @return [Logger] The logger instance attached to the instance of JsonRpcClient.
+#      Should accept method calls to debug, info, warning & error. Use JsonRpcClient.log for logging
+class JsonRpcClient
+  attr_accessor :asynchronous_calls, :symbolize_names, :logger
+
+  # Invalid JSON was received by the server.
+  # An error occurred on the server while parsing the JSON text.
+  INVALID_JSON     = -32700
+  # The JSON sent is not a valid Request object.
+  INVALID_REQUEST  = -32600
+  # The method does not exist / is not available.
+  METHOD_NOT_FOUND = -32601
+  # Invalid method parameter(s).
+  INVALID_PARAMS   = -32602
+  # Internal JSON-RPC error.
+  INTERNAL_ERROR   = -32603
+
+  # Create an instance to call the RPC methods on.
+  #
+  # @param [String, Addressable::URI, #to_str] service_uri The URI to connect to.
+  # @param [Hash] options Options hash to pass to the instance.
+  #   See Instance Attribute Details in the documentation for more details on supported options.
+  def initialize(service_uri, options = {})
+    @uri = Addressable::URI.parse(service_uri)
+    @asynchronous_calls = options.has_key?(:asynchronous_calls) ?
+      !!options[:asynchronous_calls] :
+      true
+    @symbolize_names = options.has_key?(:symbolize_names) ? !!options[:symbolize_names] : true
+    @logger = options[:logger]
+  end
+
+  # Called whenever the current object receives a method call that it does not respond to.
+  # Will make a call asynchronously or synchronously depending on asynchronous_calls.
+  #
+  # @param [String] method the API method, ie get, set.
+  # @param [Array]  params the parameters sent with the method call.
+  def method_missing(method, *params)
+    @asynchronous_calls ? self._call_async(method, params) : self._call_sync(method, params)
+  end
+
+  # Makes the call asynchronously and returns a EM::Deferrable.
+  # The underscore is there to avoid conflicts with server methods, not to denote a private method.
+  #
+  # @param [String] method The API method, ie get, set etc.
+  # @param [Array, Hash] params The parameters that should be sent along in the post body.
+  # @return [EM::Deferrable] The JsonRpcClient::Request as data.
+  def _call_async(method, params)
+    return Request.new({
+      service_uri:     @uri.to_s,
+      method:          method,
+      params:          params,
+      logger:          @logger,
+      symbolize_names: @symbolize_names
+    });
+  end
+
+  # Make the call synchronously, returns the result directly.
+  # The underscore is there to avoid conflicts with server methods, not to denote a private method.
+  #
+  # @param [String]       method The API method, ie get, set etc.
+  # @param [Array, Hash]  params The parameters that should be sent along in the post body.
+  # @return [Hash]        The result.
+  # @raise JsonRpcClient::Error When the request responds with failed status.
+  def _call_sync(method, params)
+    f = Fiber.current
+
+    request = _call_async(method, params)
+
+    request.callback do |*args|
+      # If we happen to be in the calling fiber, return the data directly.
+      return args.size == 1 ? args.first : args if f == Fiber.current
+      # else, return it to the yield call below (in the correct fiber).
+      f.resume(*args)
+    end
+
+    request.errback do |error|
+      json_rpc_error = Error.new(error[:message], error[:code], error[:data])
+      # If we happen to be in the calling fiber, raise the error directly.
+      raise json_rpc_error if f == Fiber.current
+      # else, return it to the yield call below (in the correct fiber).
+      f.resume(json_rpc_error)
+    end
+
+    begin
+      response = Fiber.yield # will yield and return the data or raise the error.
+    rescue FiberError
+      raise "To to use the syncing behaviour in JsonRpcClient, the call must be in a fiber."
+    end
+    raise response if response.kind_of?(Error)
+    return response
+  end
+
+  # Makes a notify call by just sending a HTTP request and not caring about the response.
+  # The underscore is there to avoid conflicts with server methods, not to denote a private method.
+  #
+  # @param [String]        method The API method, ie get, set etc.
+  # @param [Array, Hash]  params The parameters that should be sent along in the post body.
+  def _notify(method, params)
+    post_body = {
+      method:  method,
+      params:  params,
+      jsonrpc: '2.0'
+    }.to_json
+
+
+    EM::HttpRequest.new(@uri.to_s).post :body => post_body
+    self.class.log(:debug, "NOTIFY: #{@uri.to_s} --> #{post_body}", @logger)
+  end
+
+  # The logger to be used for an instances if they don't have a logger set on that instance.
+  @@default_logger = nil
+
+  # @return The default logger object.
+  def self.default_logger()
+    @@default_logger
+  end
+
+  # Add a default logging instance, that should accept method calls to debug, info, warning & error.
+  # Don't use directly, use self.log.
+  def self.default_logger=(logger)
+    @@default_logger = logger
+  end
+
+  # Logging class that takes severity and message. Only logs if a logger is attached.
+  #
+  # @param [Symbol, String] level The severity, ie a method of a logger, (info, debug, warn, error).
+  # @param [String]         message The log message.
+  # @param [Logger]         logger An instance of a logger class.
+  def self.log(level, message, logger = nil)
+    logger = logger || @@default_logger
+    logger.send(level.to_sym, message) if logger.respond_to?(level.to_sym)
+  end
+
+  # This class corresponds to the JSON-RPC error object gotten from the server.
+  # A "faked" instance of this will be thrown for communication errors as well.
+  class Error < RuntimeError
+    attr_reader :code, :data
+    def initialize(msg, code, data)
+      super(msg)
+      @code = code
+      @data = data
+    end
+
+
+    # Returns the contents of the current error object as a string.
+    #
+    # @return [String]
+    def inspect
+      %|#{self.class}: #{self.message}, code: #{@code.inspect}, data: #{@data.inspect}|
+    end
+  end
+
+  # This class makes a single request to the JSON-RPC service as a EventMachine::Deferrable.
+  # The deferrable object will give a successful callback in the result-part of the response.
+  # A unsuccessful request will set the deferred status as failed, and will not deliver a result
+  # only the JSON-RPC error object as a Hash.
+  class Request
+    include EM::Deferrable
+
+    def initialize(params)
+      service_uri = params[:service_uri]
+      post_body = {
+        method:  params[:method],
+        params:  params[:params],
+        id:      'jsonrpc',
+        jsonrpc: '2.0',
+      }.to_json
+
+      http = EM::HttpRequest.new(service_uri).post :body => post_body
+      JsonRpcClient.log(:debug, "NEW REQUEST: #{service_uri} --> #{post_body}", params[:logger])
+
+      http.callback do |response|
+        begin
+          resp = JSON.parse(response.response, {symbolize_names: params[:symbolize_names]})
+          JsonRpcClient.log(
+            :debug,
+            "REQUEST FINISH: #{service_uri} METHOD: #{params[:method]} RESULT: #{resp}",
+            params[:logger]
+          )
+
+          if resp.has_key?(:error) || resp.has_key?("error")
+            JsonRpcClient.log(
+              :error,
+              "Error in response from #{service_uri}: #{resp[:error]}",
+               params[:logger]
+            )
+            self.set_deferred_status :failed, resp[:error] || resp["error"]
+          end
+          self.set_deferred_status :succeeded, resp[:result] || resp["result"]
+        rescue JSON::ParserError => e
+          JsonRpcClient.log(
+            :error,
+            "Got exception during parsing of #{response}: #{e}",
+            params[:logger]
+          )
+
+          # Making an error object in the same style as a JSON RPC error.
+          set_deferred_status :failed, {
+            code:    JsonRpcClient::INVALID_JSON,
+            message: e.message,
+            data:    e
+          }
+        end
+      end
+
+      http.errback do |response|
+        JsonRpcClient.log(:error, "Error in http request: #{response.error}", params[:logger])
+        set_deferred_status :failed, {
+          code: JsonRpcClient::INVALID_JSON,
+          message: response.error
+        }
+      end
+
+      self
+    end
+  end
+end

data/test/json-rpc-test.rb

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+require 'em-spec/bacon'
+require 'vcr'
+require 'json'
+require File.expand_path(File.dirname(__FILE__) + '/test-helper.rb')
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/json-rpc-client'))
+
+# Sets up a eventmachine channel to be able to notify subscribers when a http request has been done
+# With the async nature and with _notify not returning a Deferrable we can't know if it sent
+# Or when it finished it's request, hence why we hook onto after_http_request and use that.
+vcr_channel = EventMachine::Channel.new
+
+VCR.configure do |c|
+  c.cassette_library_dir = File.expand_path(File.dirname(__FILE__)) + '/vcr_cassettes'
+  c.hook_into :webmock
+  # After a http request, push a notification in the EM channel with the request and response.
+  c.after_http_request do |request, response|
+    vcr_channel.push({request: request, response: response})
+  end
+end
+
+EM.spec_backend = EventMachine::Spec::Bacon
+EM.describe 'json-rpc-test' do
+
+  should 'Test default logging' do
+    VCR.use_cassette('logger-test') do
+      custom_logger = CustomLogger.new()
+      JsonRpcClient.default_logger = custom_logger
+      client = JsonRpcClient.new('https://shop.textalk.se/backend/jsonrpc/Article/12565607')
+      (JsonRpcClient.default_logger == custom_logger).should.equal true
+      JsonRpcClient.default_logger = nil #cleanup
+    end
+
+    done
+  end
+
+  should 'Make a sucessful sync json-rpc call and recieve symbolized values' do
+    VCR.use_cassette('sync-symbolized') do
+      client = JsonRpcClient.new(
+        'https://shop.textalk.se/backend/jsonrpc/Article/12565484',
+        {asynchronous_calls: false}
+      )
+      client.logger = CustomLogger.new()
+      uid = client.get(uid: true) # Calling method get on RPC backend, only asking for uid
+      client.logger.logs[0] == "NEW REQUEST: https://shop.textalk.se/backend/jsonrpc/Article/12565484 --> {\"method\":\"get\",\"params\":[{\"uid\":true}],\"id\":\"jsonrpc\",\"jsonrpc\":\"2.0\"}"
+      client.logger.logs[1] == "REQUEST FINISH: https://shop.textalk.se/backend/jsonrpc/Article/12565484 METHOD: get RESULT: {:jsonrpc=>\"2.0\", :id=>\"jsonrpc\", :result=>{:uid=>\"12565484\"}}"
+      (uid == {uid: "12565484"}).should.equal true
+    end
+
+    done
+  end
+
+  should 'Make a sucessful sync json-rpc call and recieve non-symbolized values' do
+    VCR.use_cassette('sync-nonsymbolized') do
+      client = JsonRpcClient.new('https://shop.textalk.se/backend/jsonrpc/Article/14284660', {
+        asynchronous_calls: false,
+        symbolize_names: false
+      })
+      name = client.get(name: true) # Calling same method, asking for name. Should not symobolize result
+      (name == {"name"=>{"sv"=>"Presentkort 1000 kr", "en"=>"Gift certificate 1000 SEK"}}).should.equal true
+    end
+
+    done
+  end
+
+  should 'Make a sucessful async json-rpc call and recieve a JsonRpcClient::Request' do
+      VCR.insert_cassette("async")
+      client = JsonRpcClient.new('https://shop.textalk.se/backend/jsonrpc/Article/12565605')
+      request = client.uid() # Calling a valid uri, should get a request back
+      request.is_a?(JsonRpcClient::Request).should.equal true
+      request.is_a?(EM::Deferrable).should.equal true
+      request.callback do |result|
+        result.should.equal "12565605"
+        VCR.eject_cassette
+        done
+      end
+  end
+
+  should 'Make a notify call' do
+    VCR.insert_cassette("notify")
+    # Subscribe to the EM channel, so that we only after the request do the matching and
+    # eject the VCR cassette and end the request.
+    subscription = vcr_channel.subscribe do |request_response_hash|
+      request = request_response_hash[:request]
+      (JSON.parse(request[:body]) == {"method"=>"uid", "params"=>{}, "jsonrpc"=>"2.0"}).should.equal true
+      vcr_channel.unsubscribe(subscription) # Unsub from the channel
+      VCR.eject_cassette
+      done # Exit out of the request
+    end
+    client = JsonRpcClient.new('https://shop.textalk.se/backend/jsonrpc/Article/12565604')
+    client._notify(:uid, {}) # Just shouldn't raise an error, and should hit backend.
+  end
+
+  should 'raise jsonrpcerror on bad response' do
+    should.raise(JsonRpcClient::Error) do
+      VCR.use_cassette('bad-response') do
+        client = JsonRpcClient.new('http://www.google.com/', {asynchronous_calls: false})
+        client.dummy() # Calling non-existing method on non-rpc backend.
+      end
+    end
+
+    done
+  end
+
+  should 'get an http error and raise jsonrpcerror on bad backend url' do
+    should.raise(JsonRpcClient::Error) do
+      VCR.use_cassette('weird-url') do
+        client = JsonRpcClient.new('http://@ł€®þ.com/', {asynchronous_calls: false})
+        client.dummy() # Calling non-existing method on non-rpc backend.
+      end
+    end
+
+    done
+  end
+
+  should 'get a jsonrpcerror from the backend' do
+    should.raise(JsonRpcClient::Error) do
+      VCR.use_cassette('jsonrpcerror-method-missing') do
+        client = JsonRpcClient.new(
+          'http://shop.textalk.se/backend/jsonrpc/Foo',
+          {asynchronous_calls: false}
+        )
+        error = client.dummy() # Calling non-existing method on rpc backend.
+      end
+    end
+
+    done
+  end
+
+  should 'test the error inspect method' do
+    VCR.use_cassette('inspect') do
+      begin
+        client = JsonRpcClient.new(
+          'http://shop.textalk.se/backend/jsonrpc/Article/12565604',
+          {asynchronous_calls: false}
+        )
+        client.dummy()
+      rescue JsonRpcClient::Error => e
+        e.inspect.should.equal "JsonRpcClient::Error: Method not found: dummy, code: -32601, data: nil"
+      end
+    end
+
+    done
+  end
+end
+
+describe 'Non-fiber' do
+
+  should 'raise an error about no fibers being used' do
+    VCR.use_cassette('non-fiber') do
+      should.raise(RuntimeError) do
+        EM.run do
+          client = JsonRpcClient.new(
+            'http://shop.textalk.se/backend/jsonrpc/Article/12565604',
+            {asynchronous_calls: false}
+          )
+          client.get()
+        end
+      end
+    end
+  end
+end

data/test/test-helper.rb

@@ -0,0 +1,23 @@
+require 'simplecov'
+require 'simplecov-rcov'
+require 'logger'
+
+SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+SimpleCov.command_name 'bacon'
+SimpleCov.start
+
+# A small custom logger for the tests, all log messages are saved to an array.
+class CustomLogger < Logger
+  attr_reader :logs
+  def initialize()
+    @logs = []
+  end
+
+  def debug(message)
+    @logs << message
+  end
+
+  def error(message)
+    @logs << message
+  end
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: json-rpc-client
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Fredrik Liljegren
+- Lars Olsson
+- Denis Dervisevic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+description: Asynchronous (EventMachine) JSON-RPC 2.0 over HTTP client.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/json-rpc-client.rb
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- test/json-rpc-test.rb
+- test/test-helper.rb
+homepage: https://github.com/Textalk/json-rpc-client-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: JSON-RPC 2.0 client.
+test_files: []
+has_rdoc: