aria2_driver 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de5dcdac31c34a26de91ab9d1a937b4071b887cc
+  data.tar.gz: 5182d13796e0e10255f1a415535eb84e48cef84f
+SHA512:
+  metadata.gz: 50376891c256b04f70b59d72846604e32b5c9b1cd1cd7f490ff3f6ea8447c889e847d54a0ee346482c53239250dc54f98c2e8b845c51f9d4bc61afecf8c5a828
+  data.tar.gz: 91fce3fbe30c07057c646285cd1488277c4e114271860bf1a57d04e5b565baa7ed7e377602430ff6bd150c9cf8b3779b88c7725faa8d606b2af8a6c3f317994e

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+.idea
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,29 @@
+language: ruby
+before_install: gem install bundler
+script: bundle exec rake spec
+addons:
+  code_climate:
+    repo_token: ab624e4e0be1ac70631beeb8cb61fed99d511a93d8bf437255a4ff94f69e7836
+rvm:
+- 2.0
+- 2.1
+- 2.2
+- jruby
+- ruby-head
+- rbx-2
+matrix:
+  allow_failures:
+  - rvm: rbx-2
+  - rvm: ruby-head
+notifications:
+  email:
+  - roberto.ciatti@overhilllab.com
+  - matteo.foccoli@overhilllab.com
+deploy:
+  provider: rubygems
+  api_key:
+    secure: f0JeJrfONLwfwYA2B8MZWNZ0yr7dZn9wtgZKKqP20F5qTjswlPSMndU3/WwbHoYYbCcmgj30zDDld4IBcoGofh+bSSPwSmgtm05+cKYakKiHz8Hqja0ygcxt9w+T7IC8anH0HdNd6DGKvXOBKC5x4w5xGeAiKRmYNGpm+htX6ZA=
+  gem: aria2_driver
+  on:
+    tags: true
+    repo: OverHillLab/aria2_driver

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aria2_driver.gemspec
+gemspec
+
+gem 'codeclimate-test-reporter', group: :test, require: false

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 OverHill Lab
+
+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,35 @@
+# Aria2Driver
+
+Simple api to manage aria2c via api
+
+# Status
+[![Build Status](http://img.shields.io/travis/OverHillLab/aria2_driver/master.svg)](https://travis-ci.org/OverHillLab/aria2_driver?branch=master)
+[![Code Climate](http://img.shields.io/codeclimate/github/OverHillLab/aria2_driver.svg)](https://codeclimate.com/github/OverHillLab/aria2_driver)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'aria2_driver'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install aria2_driver
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/aria2_driver/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color']
+end
+
+task default: :spec
+

data/aria2_driver.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'aria2_driver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aria2_driver"
+  spec.version       = Aria2Driver::VERSION
+  spec.authors       = ['Roberto Ciatti', 'Matteo Foccoli']
+  spec.email         = ['info@overhilllab.com']
+  spec.summary       = 'Simple api to manage aria2c via api'
+  spec.description   = ''
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'json_spec'
+  spec.add_development_dependency 'webmock'
+end

data/lib/aria2_driver.rb

@@ -0,0 +1,14 @@
+require 'aria2_driver/version'
+
+require 'aria2_driver/json_rpc/client'
+require 'aria2_driver/json_rpc/connection'
+require 'aria2_driver/json_rpc/client'
+require 'aria2_driver/json_rpc/request'
+require 'aria2_driver/json_rpc/response'
+require 'aria2_driver/json_rpc/error'
+
+module Aria2Driver
+
+
+
+end

data/lib/aria2_driver/json_rpc/client.rb

@@ -0,0 +1,75 @@
+require 'securerandom'
+require 'json'
+
+module Aria2Driver
+  module JsonRpc
+    class Client
+
+      attr_reader :id, :connection, :token
+
+      def initialize(host, options={})
+        @id = options[:id] || generate_uuid
+        @token = options[:token]
+        options.delete :id
+        options.delete :token
+        @connection = Aria2Driver::JsonRpc::Connection.new host, options
+      end
+
+      def request(request)
+        req_hash = request_to_hash(request)
+        http = Net::HTTP.new(connection.host, connection.port)
+        http_response = http.request_post(
+            request.path,
+            JSON.generate(req_hash),
+            {
+                'Accept' => 'application/json',
+                'Content-Type' => 'application/json'
+            }
+        )
+        Aria2Driver::JsonRpc::Response.new(JSON.parse(http_response.body))
+      end
+
+      def self.from_url(url, options={})
+        uri = URI.parse(url)
+        new uri.host, options.merge({scheme: uri.scheme, port: uri.port, path: uri.path})
+      end
+
+      def method_missing(method, *args)
+        if supported_request?(method)
+          rpc_method = snake_lower_camel method.to_s
+          if args.any?
+            request Aria2Driver::JsonRpc::Request.new "aria2.#{rpc_method}", args[0]
+          else
+            request Aria2Driver::JsonRpc::Request.new "aria2.#{rpc_method}"
+          end
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        supported_request?(method)
+      end
+
+      private
+
+      def supported_request?(request)
+        [:get_version, :add_uri].include?(request)
+      end
+
+      def snake_lower_camel(snake)
+        snake.gsub(/(_.)/){ $1.upcase[-1] }
+      end
+
+      def generate_uuid
+        SecureRandom.uuid
+      end
+
+      def request_to_hash(request)
+        req_hash = request.to_hash
+        req_hash[:params].insert(0, "token:#{token}")
+        req_hash[:id] = id
+        req_hash
+      end
+
+    end
+  end
+end

data/lib/aria2_driver/json_rpc/connection.rb

@@ -0,0 +1,27 @@
+
+module Aria2Driver
+  module JsonRpc
+    class Connection
+
+      DEFAULTS = {
+          scheme: 'http',
+          port: 80
+      }
+
+      attr_reader :scheme, :port, :host
+
+      def initialize(host, options={})
+        @host = host
+        check_defaults(options)
+      end
+
+      private
+
+      def check_defaults(options)
+        @scheme = options.fetch(:scheme, DEFAULTS[:scheme])
+        @port = options.fetch(:port, DEFAULTS[:port])
+      end
+
+    end
+  end
+end

data/lib/aria2_driver/json_rpc/error.rb

@@ -0,0 +1,14 @@
+
+module Aria2Driver
+  module JsonRpc
+    class Error
+      attr_reader :message, :code, :data
+
+      def initialize(error_hash)
+        @code = error_hash['code']
+        @message = error_hash['message']
+        @data = error_hash['data']
+      end
+    end
+  end
+end

data/lib/aria2_driver/json_rpc/request.rb

@@ -0,0 +1,28 @@
+require 'net/http'
+require 'json'
+
+module Aria2Driver
+  module JsonRpc
+    class Request
+
+      DEFAULT_PATH = '/jsonrpc'
+      JSON_RPC_VERSION = '2.0'
+
+      attr_reader :rpc_method, :params, :path
+
+      def initialize(rpc_method, options={})
+        @path = options[:path] || DEFAULT_PATH
+        @rpc_method = rpc_method
+        @params = options[:params] || []
+      end
+
+      def to_hash
+        {
+            jsonrpc: JSON_RPC_VERSION,
+            method: rpc_method,
+            params: params
+        }
+      end
+    end
+  end
+end

data/lib/aria2_driver/json_rpc/response.rb

@@ -0,0 +1,35 @@
+module Aria2Driver
+  module JsonRpc
+    class Response
+      attr_reader :jsonrpc, :id, :result, :error
+
+      def initialize(response_hash)
+        @jsonrpc = response_hash['jsonrpc']
+        @id = response_hash['id']
+        detect_payload(response_hash)
+      end
+
+      def error?
+        error != nil
+      end
+
+      private
+
+      def result=(result_payload)
+        @result = result_payload
+      end
+
+      def error=(error_payload)
+        @error = Aria2Driver::JsonRpc::Error.new error_payload
+      end
+
+      def detect_payload(response_hash)
+        if response_hash['error']
+          self.error = response_hash['error']
+        else
+          self.result = response_hash['result']
+        end
+      end
+    end
+  end
+end

data/lib/aria2_driver/version.rb

@@ -0,0 +1,3 @@
+module Aria2Driver
+  VERSION = "0.0.1"
+end

data/spec/aria2_driver/json_rpc/client_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'support/mocks/json_rpc/get_version'
+require 'support/mocks/json_rpc/add_uri'
+
+module Aria2Driver
+  module JsonRpc
+
+
+    describe Client do
+
+      it 'should create with defaults' do
+        client = Aria2Driver::JsonRpc::Client.new 'localhost', {id: 'my', token: 'abcd-1234'}
+        expect(client.id).to eq('my')
+        expect(client.token).to eq('abcd-1234')
+        expect(client.connection).to have_attributes({
+                                                         scheme: Aria2Driver::JsonRpc::Connection::DEFAULTS[:scheme],
+                                                         host: 'localhost',
+                                                         port: Aria2Driver::JsonRpc::Connection::DEFAULTS[:port]
+                                                     })
+      end
+
+      it 'should create from url' do
+        client = Aria2Driver::JsonRpc::Client.from_url(
+            'https://localhost:9090/jsonrpc', {id: 'my', token: 'abcd-1234'})
+        expect(client.id).to eq('my')
+        expect(client.token).to eq('abcd-1234')
+        expect(client.connection).to have_attributes({
+                                                         scheme: 'https',
+                                                         host: 'localhost',
+                                                         port: 9090
+                                                     })
+      end
+
+      describe 'requests' do
+        it 'simple successful generic request' do
+          stubbed_request = Mocks::JsonRpc::GetVersionRequest.new('localhost', {port: 80, params: ["token:abcd-1234"]})
+          mock_response = Mocks::JsonRpc::GetVersionSuccessfulResponse.new
+          stubbed_request.with_response(mock_response)
+
+          client = Aria2Driver::JsonRpc::Client.from_url(
+              'https://localhost:80/jsonrpc', {id: 'local_client', token: 'abcd-1234'})
+          response = client.request(Aria2Driver::JsonRpc::Request.new 'aria2.getVersion')
+
+          expect(response.error?).to be_falsey
+          expect(response.result['version']).to eq(mock_response.result[:version])
+          expect(response.result['enabledFeatures']).to eq(mock_response.result[:enabledFeatures])
+        end
+
+        it 'simple unsuccessful generic request' do
+          stubbed_request = Mocks::JsonRpc::GetVersionRequest.new('localhost', {port: 80, params: ["token:abcd-1234"]})
+          mock_error_response = Mocks::JsonRpc::ErrorResponse.new({code: -32700, message: 'Parse error'})
+          stubbed_request.with_response(mock_error_response)
+
+          client = Aria2Driver::JsonRpc::Client.from_url(
+              'https://localhost:80/jsonrpc', {id: 'local_client', token: 'abcd-1234'})
+          response = client.request(Aria2Driver::JsonRpc::Request.new 'aria2.getVersion')
+
+          expect(response.error?).to be_truthy
+          expect(response.error).to have_attributes({
+                                                        code: mock_error_response.code,
+                                                        message: mock_error_response.message
+                                                    })
+        end
+
+        it 'get_version request' do
+          stubbed_request = Mocks::JsonRpc::GetVersionRequest.new('localhost', {port: 80, params: ["token:abcd-1234"]})
+          mock_response = Mocks::JsonRpc::GetVersionSuccessfulResponse.new
+          stubbed_request.with_response(mock_response)
+
+          aria2 = Aria2Driver::JsonRpc::Client.from_url(
+              'https://localhost:80/jsonrpc', {id: 'local_client', token: 'abcd-1234'})
+
+          expect(aria2.respond_to?(:get_version)).to be true
+
+          response = aria2.get_version
+
+          expect(response.error?).to be_falsey
+          expect(response.result['version']).to eq(mock_response.result[:version])
+          expect(response.result['enabledFeatures']).to eq(mock_response.result[:enabledFeatures])
+        end
+
+        it 'add_uri request' do
+          stubbed_request = Mocks::JsonRpc::AddUriRequest.new('localhost',
+                                                              {
+                                                                  port: 80,
+                                                                  params: [
+                                                                      "token:abcd-1234",
+                                                                      ['http://www.example.com/a.jpg'],
+                                                                      {"dir" => "/tmp/"}
+                                                                  ]
+                                                              })
+          mock_response = Mocks::JsonRpc::AddUriSuccessfulResponse.new
+          stubbed_request.with_response(mock_response)
+
+          aria2 = Aria2Driver::JsonRpc::Client.from_url(
+              'https://localhost:80/jsonrpc', {id: 'local_client', token: 'abcd-1234'})
+
+          response = aria2.add_uri({params: [['http://www.example.com/a.jpg'], {"dir" => "/tmp/"}]})
+
+          expect(response.error?).to be_falsey
+          expect(response.result).to eq(mock_response.result)
+        end
+
+      end
+    end
+  end
+end

data/spec/aria2_driver/json_rpc/connection_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Aria2Driver
+  module JsonRpc
+    describe Connection do
+      it 'should create a new connection with defaults parameters' do
+        conn = Connection.new 'localhost'
+        expect(conn).to have_attributes({
+                                            scheme: 'http',
+                                            host: 'localhost',
+                                            port: 80
+                                        })
+      end
+
+      it 'should override defaults' do
+        conn = Connection.new 'example', {scheme: 'https', host: 'example', port: 9090}
+        expect(conn).to have_attributes({
+                                            scheme: 'https',
+                                            host: 'example',
+                                            port: 9090
+                                        })
+      end
+    end
+  end
+end

data/spec/aria2_driver/json_rpc/error_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Aria2Driver
+  module JsonRpc
+    describe Error do
+
+      let :error_payload do
+        {
+            'code' => 25,
+            'message' => 'message',
+            'data' => {'data' => 'error data'}
+        }
+      end
+
+      it 'should create a new error from hash' do
+        error = Error.new error_payload
+        expect(error).to have_attributes({
+                                             code: 25,
+                                             message: 'message',
+                                             data: {'data' => 'error data'}
+                                         })
+      end
+    end
+
+  end
+end

data/spec/aria2_driver/json_rpc/request_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Aria2Driver
+  module JsonRpc
+    describe Request do
+
+      let :method do
+        'aria2.method'
+      end
+
+      let :params do
+        ['sample_gid', {max_download_limit: '10K'}]
+      end
+
+      subject do
+        Aria2Driver::JsonRpc::Request.new method, {params: params}
+      end
+
+      it 'should create a new request' do
+        expect(subject).not_to be_nil
+        expect(subject.path).to eq(Aria2Driver::JsonRpc::Request::DEFAULT_PATH)
+        expect(subject.to_hash).to eq({
+                                          jsonrpc: '2.0',
+                                          method: method,
+                                          params: params
+                                      })
+      end
+    end
+  end
+
+
+end

data/spec/aria2_driver/json_rpc/response_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Aria2Driver
+  module JsonRpc
+    describe Response do
+
+      let :successful_response do
+        {
+            'id' =>  'local_client',
+            'jsonrpc' => '2.0',
+            'result' => {
+                'enabledFeatures' => ['BitTorrent','Gzip'],
+                'version' => '1.18.9'
+            }
+        }
+      end
+
+      let :error_response do
+        {
+            'id' =>  'local_client',
+            'jsonrpc' => '2.0',
+            'error' => {
+                'code' => 3600,
+                'message' => 'invalid request'
+            }
+        }
+      end
+
+      it 'should build a response with a result' do
+        response = Aria2Driver::JsonRpc::Response.new successful_response
+
+        expect(response.id).to eq('local_client')
+        expect(response.jsonrpc).to eq('2.0')
+        expect(response.error?).to be_falsey
+        expect(response.error).to be_nil
+
+        result = response.result
+
+        expect(result).not_to be_nil
+        expect(result['version']).to eq('1.18.9')
+        expect(result['enabledFeatures']).to eq(['BitTorrent','Gzip'])
+      end
+
+      it 'should build a response with a error' do
+        response = Aria2Driver::JsonRpc::Response.new error_response
+
+        expect(response.id).to eq('local_client')
+        expect(response.jsonrpc).to eq('2.0')
+        expect(response.error?).to be_truthy
+        expect(response.result).to be_nil
+
+        error = response.error
+
+        expect(error).not_to be_nil
+        expect(error.code).to eq(error_response['error']['code'])
+        expect(error.message).to eq(error_response['error']['message'])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+if RUBY_ENGINE == "rbx"
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+require 'json_spec'
+require 'webmock/rspec'
+
+require 'aria2_driver'
+
+RSpec.configure do |config|
+  config.include JsonSpec::Helpers
+  config.mock_with :rspec
+
+# Re-Enable connection to codeclimate to post coverage report
+  config.after(:suite) do
+    WebMock.disable_net_connect!(:allow => 'codeclimate.com')
+  end
+end

data/spec/support/mocks/json_rpc/add_uri.rb

@@ -0,0 +1,23 @@
+require_relative './request'
+require_relative './response'
+
+module Mocks
+  module JsonRpc
+
+    class AddUriSuccessfulResponse < SuccessfulResponse
+      def result
+        "2089b05ecca3d829"
+      end
+    end
+
+    class AddUriRequest < Request
+
+      protected
+
+      def rpc_method
+        'aria2.addUri'
+      end
+
+    end
+  end
+end

data/spec/support/mocks/json_rpc/get_version.rb

@@ -0,0 +1,30 @@
+require_relative './request'
+require_relative './response'
+
+module Mocks
+  module JsonRpc
+
+    class GetVersionSuccessfulResponse < SuccessfulResponse
+      def result
+        {
+            enabledFeatures: ["BitTorrent",
+                              "Firefox3 Cookie",
+                              "GZip", "HTTPS",
+                              "Message Digest",
+                              "Metalink", "XML-RPC"],
+            version: "1.18.9"
+        }
+      end
+    end
+
+    class GetVersionRequest < Request
+
+      protected
+
+      def rpc_method
+        'aria2.getVersion'
+      end
+
+    end
+  end
+end

data/spec/support/mocks/json_rpc/request.rb

@@ -0,0 +1,78 @@
+require 'webmock/rspec'
+
+module Mocks
+  module JsonRpc
+
+    class Request
+      attr_reader :request_method, :uri, :body, :headers, :params,
+                  :client_id, :json_rpc_version, :stubbed_request
+
+      DEFAULT_HEADERS = {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json'
+      }
+      DEFAULT_SCHEME = 'http'
+      DEFAULT_PORT = 80
+      DEFAULT_PATH = 'jsonrpc'
+      DEFAULT_CLIENT_ID = 'fake_id'
+      DEFAULT_JSON_RPC_VERSION = '2.0'
+
+
+      def initialize(host, options={})
+        @request_method = options[:method] || :post
+        @uri = build_uri(
+            host, options[:path] || DEFAULT_PATH,
+            options[:port] || DEFAULT_PORT,
+            options[:scheme] || DEFAULT_SCHEME)
+        @params = options[:params] || []
+        @client_id = options[:client_id] || DEFAULT_CLIENT_ID
+        @json_rpc_version = options[:json_rpc_version] || DEFAULT_JSON_RPC_VERSION
+        set_headers DEFAULT_HEADERS
+        stub_request
+      end
+
+      def with_response(response)
+        request rpc_method, response
+      end
+
+
+      protected
+
+      def rpc_method
+        raise NotImplementedError
+      end
+
+      private
+
+      def request(rpc, response)
+        set_body(rpc, params) if !params.empty?
+        response.stub_for self
+      end
+
+      def build_uri(host, path, port, scheme)
+        "#{scheme}://#{host}:#{port}/#{path}"
+      end
+
+      def set_body(rpc_method, params)
+        @body = JSON.generate({
+                                  jsonrpc: '2.0',
+                                  method: rpc_method,
+                                  params: params,
+                                  id: 'local_client'
+                              })
+      end
+
+      def stub_request
+        @stubbed_request = WebMock::API.stub_request(
+            request_method, uri
+        )
+      end
+
+      def set_headers(headers)
+        @headers = headers
+      end
+    end
+  end
+end
+
+

data/spec/support/mocks/json_rpc/response.rb

@@ -0,0 +1,89 @@
+module Mocks
+  module JsonRpc
+    class Response
+
+      attr_reader :request
+
+      def stub_for(request)
+        @request = request
+        stubbed_request = request.stubbed_request
+        with_hash = {}
+        with_hash[:body] = request.body if request.body
+        with_hash[:headers] = request.headers if request.headers
+
+        stubbed_request.with(with_hash) if !with_hash.empty?
+
+        stubbed_request.to_return({
+                                      status: response_status(),
+                                      body: response_body()
+                                  })
+      end
+
+      protected
+
+      def response_body
+        raise NotImplementedError
+      end
+
+      def response_status
+        raise NotImplementedError
+      end
+    end
+
+    class SuccessfulResponse < Response
+
+      def initialize(options={})
+        @result = options[:result] || {}
+      end
+
+      def result
+        @result
+      end
+
+      protected
+
+      def response_body
+        JSON.generate({
+                          jsonrpc: request.json_rpc_version,
+                          result: result,
+                          client_id: request.client_id
+                      })
+      end
+
+      def response_status
+        200
+      end
+
+    end
+
+    class ErrorResponse < Response
+
+      attr_reader :message, :code, :data
+
+      DEFAULT_ERROR_CODE = -3200
+      DEFAULT_ERROR_MESSAGE = 'Server error'
+
+      def initialize(options={})
+        @code = options[:code] || DEFAULT_ERROR_CODE
+        @message = options[:message] || DEFAULT_ERROR_MESSAGE
+        @data = options[:data]
+      end
+
+      def response_body
+        JSON.generate({
+                          jsonrpc: request.json_rpc_version,
+                          error: {}.tap do |error|
+                            error[:code] = code
+                            error[:message] = message
+                            error[:data] = data if data
+                          end,
+                          client_id: request.client_id
+                      })
+      end
+
+      def response_status
+        200
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: aria2_driver
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Roberto Ciatti
+- Matteo Foccoli
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json_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: webmock
+  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'
+description: ''
+email:
+- info@overhilllab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- aria2_driver.gemspec
+- lib/aria2_driver.rb
+- lib/aria2_driver/json_rpc/client.rb
+- lib/aria2_driver/json_rpc/connection.rb
+- lib/aria2_driver/json_rpc/error.rb
+- lib/aria2_driver/json_rpc/request.rb
+- lib/aria2_driver/json_rpc/response.rb
+- lib/aria2_driver/version.rb
+- spec/aria2_driver/json_rpc/client_spec.rb
+- spec/aria2_driver/json_rpc/connection_spec.rb
+- spec/aria2_driver/json_rpc/error_spec.rb
+- spec/aria2_driver/json_rpc/request_spec.rb
+- spec/aria2_driver/json_rpc/response_spec.rb
+- spec/spec_helper.rb
+- spec/support/mocks/json_rpc/add_uri.rb
+- spec/support/mocks/json_rpc/get_version.rb
+- spec/support/mocks/json_rpc/request.rb
+- spec/support/mocks/json_rpc/response.rb
+homepage: ''
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Simple api to manage aria2c via api
+test_files:
+- spec/aria2_driver/json_rpc/client_spec.rb
+- spec/aria2_driver/json_rpc/connection_spec.rb
+- spec/aria2_driver/json_rpc/error_spec.rb
+- spec/aria2_driver/json_rpc/request_spec.rb
+- spec/aria2_driver/json_rpc/response_spec.rb
+- spec/spec_helper.rb
+- spec/support/mocks/json_rpc/add_uri.rb
+- spec/support/mocks/json_rpc/get_version.rb
+- spec/support/mocks/json_rpc/request.rb
+- spec/support/mocks/json_rpc/response.rb