jimson 0.3.1 → 0.4.0

data/README.md

@@ -0,0 +1,21 @@
+# Jimson
+### JSON-RPC 2.0 Client and Server for Ruby
+
+## Client: Quick Start
+    require 'jimson'
+    client = Jimson::Client.new("http://www.example.com:8999") # the URL for the JSON-RPC 2.0 server to connect to
+    result = client.sum(1,2) # call the 'sum' method on the RPC server and save the result '3'
+
+## Server: Quick Start
+    require 'jimson'
+
+    class MyHandler
+      extend Jimson::Handler 
+
+      def sum(a,b)
+        a + b
+      end
+    end
+
+    server = Jimson::Server.new(MyHandler.new)
+    server.start # serve with webrick on http://0.0.0.0:8999/

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/lib/jimson.rb

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'jimson/handler'
 require 'jimson/server'
 require 'jimson/client'
 

data/lib/jimson/client.rb

@@ -1,6 +1,11 @@
+require 'blankslate'
+module Jimson
+  class Client < BlankSlate
+  end
+end
+
 require 'rest-client'
-require 'jimson/server_error'
-require 'jimson/client_error'
+require 'jimson/client/error'
 require 'jimson/request'
 require 'jimson/response'
 
@@ -24,10 +29,14 @@ module Jimson
       begin
         data = JSON.parse(resp)
       rescue
-        raise Jimson::ClientError::InvalidJSON.new(resp)
+        raise Client::Error::InvalidJSON.new(resp)
       end
 
       return process_single_response(data)
+
+      rescue Exception, StandardError => e
+        e.extend(Client::Error) unless e.is_a?(Client::Error)
+        raise e
     end
 
     def send_single_request(method, args)
@@ -39,20 +48,17 @@ module Jimson
                   }.to_json
       resp = RestClient.post(@url, post_data, :content_type => 'application/json')
       if resp.nil? || resp.body.nil? || resp.body.empty?
-        raise Jimson::ClientError::InvalidResponse.new
+        raise Client::Error::InvalidResponse.new
       end
 
       return resp.body
-
-      rescue Exception, StandardError
-        raise Jimson::ClientError::InternalError.new($!)
     end
 
     def send_batch_request(batch)
       post_data = batch.to_json
       resp = RestClient.post(@url, post_data, :content_type => 'application/json')
       if resp.nil? || resp.body.nil? || resp.body.empty?
-        raise Jimson::ClientError::InvalidResponse.new
+        raise Client::Error::InvalidResponse.new
       end
 
       return resp.body
@@ -61,29 +67,21 @@ module Jimson
     def process_batch_response(responses)
       responses.each do |resp|
         saved_response = @batch.map { |r| r[1] }.select { |r| r.id == resp['id'] }.first
-        raise Jimson::ClientError::InvalidResponse.new unless !!saved_response
+        raise Client::Error::InvalidResponse.new if saved_response.nil?
         saved_response.populate!(resp)
       end
     end
 
     def process_single_response(data)
-      raise Jimson::ClientError::InvalidResponse.new if !valid_response?(data)
+      raise Client::Error::InvalidResponse.new if !valid_response?(data)
 
       if !!data['error']
         code = data['error']['code']
-        if Jimson::ServerError::CODES.keys.include?(code)
-          raise Jimson::ServerError::CODES[code].new
-        else
-          raise Jimson::ClientError::UnknownServerError.new(code, data['error']['message'])
-        end
+        msg = data['error']['message']
+        raise Client::Error::ServerError.new(code, msg)
       end
 
       return data['result']
-
-      rescue Jimson::ClientError::Generic, Jimson::ServerError::Generic => e
-        raise e
-      rescue Exception, StandardError => e
-        raise Jimson::ClientError::InternalError.new(e)
     end
 
     def valid_response?(data)
@@ -113,7 +111,7 @@ module Jimson
 
     def push_batch_request(request)
       request.id = self.class.make_id
-      response = Jimson::Response.new(request.id)
+      response = Response.new(request.id)
       @batch << [request, response]
       return response
     end
@@ -125,7 +123,7 @@ module Jimson
       begin
         responses = JSON.parse(response)
       rescue
-        raise Jimson::ClientError::InvalidJSON.new(json)
+        raise Client::Error::InvalidJSON.new(json)
       end
 
       process_batch_response(responses)
@@ -134,7 +132,7 @@ module Jimson
 
   end
 
-  class BatchClient
+  class BatchClient < BlankSlate
     
     def initialize(helper)
       @helper = helper
@@ -147,7 +145,10 @@ module Jimson
 
   end
 
-  class Client
+  class Client < BlankSlate
+    reveal :instance_variable_get
+    reveal :inspect
+    reveal :to_s
     
     def self.batch(client)
       helper = client.instance_variable_get(:@helper)
@@ -161,7 +162,11 @@ module Jimson
     end
 
     def method_missing(sym, *args, &block)
-      @helper.process_call(sym, args) 
+      self[sym, args]
+    end
+
+    def [](method, *args)
+      @helper.process_call(method, args.flatten) 
     end
 
   end

data/lib/jimson/client/error.rb

@@ -0,0 +1,23 @@
+module Jimson
+  class Client
+    module Error
+      class InvalidResponse < StandardError
+        def initialize()
+          super('Invalid or empty response from server.')
+        end
+      end
+
+      class InvalidJSON < StandardError
+        def initialize(json)
+          super("Couldn't parse JSON string received from server:\n#{json}")
+        end
+      end
+
+      class ServerError < StandardError
+        def initialize(code, message)
+          super("Server error #{code}: #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/jimson/handler.rb

@@ -0,0 +1,25 @@
+module Jimson
+  module Handler
+    
+    def jimson_default_methods
+      self.instance_methods.map(&:to_s) - Object.methods.map(&:to_s)
+    end
+
+    def jimson_expose(*methods)
+      @jimson_exposed_methods ||= []
+      @jimson_exposed_methods += methods.map(&:to_s)
+    end
+
+    def jimson_exclude(*methods)
+      @jimson_excluded_methods ||= []
+      @jimson_excluded_methods += methods.map(&:to_s)
+    end
+
+    def jimson_exposed_methods
+      @jimson_exposed_methods ||= []
+      @jimson_excluded_methods ||= []
+      (jimson_default_methods - @jimson_excluded_methods + @jimson_exposed_methods).sort.map(&:to_sym)
+    end
+
+  end
+end

data/lib/jimson/server.rb

@@ -2,10 +2,28 @@ require 'rack'
 require 'rack/request'
 require 'rack/response'
 require 'json'
+require 'jimson/handler'
+require 'jimson/server/error'
 
 module Jimson
   class Server
     
+    class System
+      extend Handler
+
+      def initialize(handler)
+        @handler = handler
+      end
+
+      def listMethods
+        @handler.class.jimson_exposed_methods
+      end
+
+      def isAlive 
+        true
+      end
+    end
+
     JSON_RPC_VERSION = '2.0'
 
     attr_accessor :handler, :host, :port
@@ -52,17 +70,17 @@ module Jimson
       begin
         request = parse_request(content)
         if request.is_a?(Array)
-          raise Jimson::ServerError::InvalidRequest.new if request.empty?
+          raise Server::Error::InvalidRequest.new if request.empty?
           response = request.map { |req| handle_request(req) }
         else
           response = handle_request(request)
         end
-      rescue Jimson::ServerError::ParseError, Jimson::ServerError::InvalidRequest => e
+      rescue Server::Error::ParseError, Server::Error::InvalidRequest => e
         response = error_response(e)
-      rescue Jimson::ServerError::Generic => e
+      rescue Server::Error => e
         response = error_response(e, request)
-      rescue StandardError, Exception
-        response = error_response(Jimson::ServerError::InternalError.new)
+      rescue StandardError, Exception => e
+        response = error_response(Server::Error::InternalError.new(e))
       end
 
       response.compact! if response.is_a?(Array)
@@ -76,11 +94,11 @@ module Jimson
       response = nil
       begin
         if !validate_request(request)
-          response = error_response(Jimson::ServerError::InvalidRequest.new)
+          response = error_response(Server::Error::InvalidRequest.new)
         else
           response = create_response(request)
         end
-      rescue Jimson::ServerError::Generic => e
+      rescue Server::Error => e
         response = error_response(e, request)
       end
 
@@ -112,20 +130,9 @@ module Jimson
     end
 
     def create_response(request)
+      method = request['method']
       params = request['params']
-      begin
-        if params.is_a?(Hash)
-          result = @handler.send(request['method'], params)
-        else
-          result = @handler.send(request['method'], *params)
-        end
-      rescue NoMethodError
-        raise Jimson::ServerError::MethodNotFound.new 
-      rescue ArgumentError
-        raise Jimson::ServerError::InvalidParams.new
-      rescue
-        raise Jimson::ServerError::ApplicationError.new($!)
-      end
+      result = dispatch_request(method, params)
 
       response = success_response(request, result)
 
@@ -134,7 +141,42 @@ module Jimson
       # that are within a batch request.
       response = nil if !request.has_key?('id')
 
-      response 
+      return response 
+
+      rescue Server::Error => e
+        raise e
+      rescue ArgumentError
+        raise Server::Error::InvalidParams.new
+      rescue Exception, StandardError => e
+        raise Server::Error::ApplicationError.new(e)
+    end
+
+    def dispatch_request(method, params)
+      # normally route requests to the user-suplied handler
+      handler = @handler
+
+      # switch to the System handler if a system method was called
+      sys_regex = /^system\./
+      if method =~ sys_regex
+        handler = System.new(@handler)
+        # remove the 'system.' prefix before from the method name
+        method.gsub!(sys_regex, '')
+      end
+
+      method = method.to_sym
+
+      if !handler.class.jimson_exposed_methods.include?(method) \
+         || !handler.respond_to?(method)
+        raise Server::Error::MethodNotFound.new(method)
+      end
+
+      if params.nil?
+        return handler.send(method)
+      elsif params.is_a?(Hash)
+        return handler.send(method, params)
+      else
+        return handler.send(method, *params)
+      end
     end
 
     def error_response(error, request = nil)
@@ -162,7 +204,7 @@ module Jimson
     def parse_request(post)
       data = JSON.parse(post)
       rescue 
-        raise Jimson::ServerError::ParseError.new 
+        raise Server::Error::ParseError.new 
     end
 
   end

data/lib/jimson/server/error.rb

@@ -0,0 +1,64 @@
+module Jimson
+  class Server
+    class Error < StandardError
+      attr_accessor :code, :message
+
+      def initialize(code, message)
+        @code = code
+        @message = message
+        super(message)
+      end
+
+      def to_h
+        {
+          'code'    => @code,
+          'message' => @message
+        }
+      end
+
+      class ParseError < Error
+        def initialize
+          super(-32700, 'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.')
+        end
+      end
+
+      class InvalidRequest < Error
+        def initialize
+          super(-32600, 'The JSON sent is not a valid Request object.')
+        end
+      end
+
+      class MethodNotFound < Error
+        def initialize(method)
+          super(-32601, "Method '#{method}' not found.")
+        end
+      end
+
+      class InvalidParams < Error
+        def initialize
+          super(-32602, 'Invalid method parameter(s).')
+        end
+      end
+
+      class InternalError < Error
+        def initialize(e)
+          super(-32603, "Internal server error: #{e}")
+        end
+      end
+
+      class ApplicationError < Error
+        def initialize(err)
+          super(-32099, "Application error: #{err} #{err.backtrace.join("\n")}")
+        end
+      end
+
+      CODES = {
+                -32700 => ParseError,
+                -32600 => InvalidRequest,
+                -32601 => MethodNotFound,
+                -32602 => InvalidParams,
+                -32603 => InternalError
+              }
+    end
+  end
+end

data/spec/client_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 module Jimson
   describe Client do
     BOILERPLATE = {'jsonrpc' => '2.0', 'id' => 1}
@@ -10,6 +12,42 @@ module Jimson
     after(:each) do
     end
 
+    describe "hidden methods" do
+      it "should reveal inspect" do
+        Client.new(SPEC_URL).inspect.should match /Jimson::Client/
+      end
+
+      it "should reveal to_s" do
+        Client.new(SPEC_URL).to_s.should match /Jimson::Client/
+      end
+    end
+
+    describe "#[]" do
+      before(:each) do
+        expected = {
+                     'jsonrpc' => '2.0',
+                     'method'  => 'foo',
+                     'params'  => [1,2,3],
+                     'id'      => 1
+                   }.to_json
+        response = BOILERPLATE.merge({'result' => 42}).to_json
+        RestClient.should_receive(:post).with(SPEC_URL, expected, {:content_type => 'application/json'}).and_return(@resp_mock)
+        @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+        @client = Client.new(SPEC_URL)
+      end
+
+      context "when using an array of args" do
+        it "sends a request with the correct method and args" do
+          @client['foo', [1,2,3]].should == 42
+        end
+      end
+      context "when using a splat for args" do
+        it "sends a request with the correct method and args" do
+          @client['foo', 1, 2, 3].should == 42
+        end
+      end
+    end
+
     describe "sending a single request" do
       context "when using positional parameters" do
         before(:each) do
@@ -73,5 +111,17 @@ module Jimson
       end
     end
 
+    describe "error handling" do
+      context "when an error occurs in the Jimson::Client code" do
+        it "tags the raised exception with Jimson::Client::Error" do
+          client_helper = ClientHelper.new(SPEC_URL)
+          ClientHelper.stub!(:new).and_return(client_helper)
+          client = Client.new(SPEC_URL)
+          client_helper.stub!(:send_single_request).and_raise "intentional error"
+          lambda { client.foo }.should raise_error(Jimson::Client::Error)
+        end
+      end
+    end
+
   end
 end

data/spec/handler_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module Jimson
+  describe Handler do
+
+    class FooHandler
+      extend Jimson::Handler
+
+      jimson_expose :to_s, :bye
+
+      jimson_exclude :hi, :bye
+
+      def hi
+        'hi'
+      end
+
+      def bye
+        'bye'
+      end
+
+      def to_s
+        'foo'
+      end
+
+      def so_exposed
+        "I'm so exposed!"
+      end
+    end
+
+    let(:foo) { FooHandler.new }
+
+    describe "#jimson_expose" do
+      it "exposes a method even if it was defined on Object" do
+        foo.class.jimson_exposed_methods.should include(:to_s)
+      end
+    end
+
+    describe "#jimson_exclude" do
+      context "when a method was not explicitly exposed" do
+        it "excludes the method" do
+          foo.class.jimson_exposed_methods.should_not include(:hi)
+        end
+      end
+      context "when a method was explicitly exposed" do
+        it "does not exclude the method" do
+          foo.class.jimson_exposed_methods.should include(:bye)
+        end
+      end
+    end
+
+    describe "#jimson_exposed_methods" do
+      it "doesn't include methods defined on Object" do
+        foo.class.jimson_exposed_methods.should_not include(:object_id)
+      end
+      it "includes methods defined on the extending class but not on Object" do
+        foo.class.jimson_exposed_methods.should include(:so_exposed)
+      end
+    end
+
+  end
+end
+

data/spec/server_spec.rb

@@ -1,7 +1,37 @@
 require 'spec_helper'
+require 'rack/test'
 
 module Jimson
     describe Server do
+      include Rack::Test::Methods
+
+      class TestHandler
+        extend Jimson::Handler
+
+        def subtract(a, b = nil)
+          if a.is_a?(Hash)
+            return a['minuend'] - a['subtrahend']
+          else 
+            return a - b
+          end
+        end
+
+        def sum(a,b,c)
+          a + b + c
+        end
+
+        def notify_hello(*args)
+          # notification, doesn't do anything
+        end
+
+        def update(*args)
+          # notification, doesn't do anything
+        end
+
+        def get_data
+          ['hello', 5]
+        end
+      end
 
       INVALID_RESPONSE_EXPECTATION = {
                                         'jsonrpc' => '2.0',
@@ -11,6 +41,14 @@ module Jimson
                                                       },
                                         'id'      => nil
                                       }
+      def app
+        Server.new(TestHandler.new)
+      end
+
+      def post_json(hash)
+        post '/', hash.to_json, {'Content-Type' => 'application/json'}
+      end
+      
       before(:each) do
         @url = SPEC_URL
       end
@@ -24,7 +62,10 @@ module Jimson
                     'params'  => [24, 20],
                     'id'      => 1
                   }
-            resp = JSON.parse(RestClient.post(@url, req.to_json).body)
+            post_json(req)
+
+            last_response.should be_ok
+            resp = JSON.parse(last_response.body)
             resp.should == {
                              'jsonrpc' => '2.0',
                              'result'  => 4,
@@ -43,7 +84,10 @@ module Jimson
                     'params'  => {'subtrahend'=> 20, 'minuend' => 24},
                     'id'      => 1
                   }
-            resp = JSON.parse(RestClient.post(@url, req.to_json).body)
+            post_json(req)
+            
+            last_response.should be_ok
+            resp = JSON.parse(last_response.body)
             resp.should == {
                              'jsonrpc' => '2.0',
                              'result'  => 4,
@@ -61,8 +105,8 @@ module Jimson
                     'method'  => 'update',
                     'params'  => [1,2,3,4,5]
                   }
-            resp = RestClient.post(@url, req.to_json).body
-            resp.should be_empty
+            post_json(req)
+            last_response.body.should be_empty
           end
         end
       end
@@ -74,12 +118,35 @@ module Jimson
                   'method'  => 'foobar',
                   'id'      => 1
                 }
-          resp = JSON.parse(RestClient.post(@url, req.to_json).body)
+          post_json(req)
+
+          resp = JSON.parse(last_response.body)
+          resp.should == {
+                            'jsonrpc' => '2.0',
+                            'error'   => {
+                                            'code' => -32601,
+                                            'message' => "Method 'foobar' not found."
+                                          },
+                            'id'      => 1
+                          }
+        end
+      end
+
+      describe "receiving a call for a method which exists but is not exposed" do
+        it "returns an error response" do
+          req = {
+                  'jsonrpc' => '2.0',
+                  'method'  => 'object_id',
+                  'id'      => 1
+                }
+          post_json(req)
+
+          resp = JSON.parse(last_response.body)
           resp.should == {
                             'jsonrpc' => '2.0',
                             'error'   => {
                                             'code' => -32601,
-                                            'message' => 'Method not found.'
+                                            'message' => "Method 'object_id' not found."
                                           },
                             'id'      => 1
                           }
@@ -94,7 +161,9 @@ module Jimson
                   'params'  => [1,2,3],
                   'id'      => 1
                 }
-          resp = JSON.parse(RestClient.post(@url, req.to_json).body)
+          post_json(req)
+
+          resp = JSON.parse(last_response.body)
           resp.should == {
                             'jsonrpc' => '2.0',
                             'error'   => {
@@ -114,7 +183,9 @@ module Jimson
                   'id'      => 1
                 }.to_json
           req += '}' # make the json invalid
-          resp = JSON.parse(RestClient.post(@url, req).body)
+          post '/', req, {'Content-type' => 'application/json'}
+
+          resp = JSON.parse(last_response.body)
           resp.should == {
                             'jsonrpc' => '2.0',
                             'error'   => {
@@ -132,24 +203,27 @@ module Jimson
             req = {
                     'jsonrpc' => '2.0',
                     'method'  => 1 # method as int is invalid
-                  }.to_json
-            resp = JSON.parse(RestClient.post(@url, req).body)
+                  }
+            post_json(req)
+            resp = JSON.parse(last_response.body)
             resp.should == INVALID_RESPONSE_EXPECTATION 
           end
         end
 
         context "when the request is an empty batch" do
           it "returns an error response" do
-            req = [].to_json
-            resp = JSON.parse(RestClient.post(@url, req).body)
+            req = []
+            post_json(req)
+            resp = JSON.parse(last_response.body)
             resp.should == INVALID_RESPONSE_EXPECTATION
           end
         end
 
         context "when the request is an invalid batch" do
           it "returns an error response" do
-            req = [1,2].to_json
-            resp = JSON.parse(RestClient.post(@url, req).body)
+            req = [1,2]
+            post_json(req)
+            resp = JSON.parse(last_response.body)
             resp.should == [INVALID_RESPONSE_EXPECTATION, INVALID_RESPONSE_EXPECTATION] 
           end
         end
@@ -165,13 +239,14 @@ module Jimson
                       {'foo' => 'boo'},
                       {'jsonrpc' => '2.0', 'method' => 'foo.get', 'params' => {'name' => 'myself'}, 'id' => '5'},
                       {'jsonrpc' => '2.0', 'method' => 'get_data', 'id' => '9'} 
-                   ].to_json
-            resp = JSON.parse(RestClient.post(@url, reqs).body)
+                   ]
+            post_json(reqs)
+            resp = JSON.parse(last_response.body)
             resp.should == [
                     {'jsonrpc' => '2.0', 'result' => 7, 'id' => '1'},
                     {'jsonrpc' => '2.0', 'result' => 19, 'id' => '2'},
                     {'jsonrpc' => '2.0', 'error' => {'code' => -32600, 'message' => 'The JSON sent is not a valid Request object.'}, 'id' => nil},
-                    {'jsonrpc' => '2.0', 'error' => {'code' => -32601, 'message' => 'Method not found.'}, 'id' => '5'},
+                    {'jsonrpc' => '2.0', 'error' => {'code' => -32601, 'message' => "Method 'foo.get' not found."}, 'id' => '5'},
                     {'jsonrpc' => '2.0', 'result' => ['hello', 5], 'id' => '9'}
             ]
           end
@@ -191,11 +266,51 @@ module Jimson
                       'params'  => [1,2,3,4,5]
                     }
                   ]
-            resp = RestClient.post(@url, req.to_json).body
-            resp.should be_empty
+            post_json(req)
+            last_response.body.should be_empty
           end
         end
       end
 
+      describe "receiving a 'system.' request" do
+        context "when the request is 'isAlive'" do
+          it "returns response 'true'" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'system.isAlive',
+                    'params'  => [],
+                    'id'      => 1
+                  }
+            post_json(req)
+
+            last_response.should be_ok
+            resp = JSON.parse(last_response.body)
+            resp.should == {
+                             'jsonrpc' => '2.0',
+                             'result'  => true,
+                             'id'      => 1
+                           }
+          end
+        end
+        context "when the request is 'listMethods'" do
+          it "returns response with all listMethods on the handler as strings" do
+            req = {
+                    'jsonrpc' => '2.0',
+                    'method'  => 'system.listMethods',
+                    'params'  => [],
+                    'id'      => 1
+                  }
+            post_json(req)
+
+            last_response.should be_ok
+            resp = JSON.parse(last_response.body)
+            resp.should == {
+                             'jsonrpc' => '2.0',
+                             'result'  => ['subtract', 'sum', 'notify_hello', 'update', 'get_data'].sort,
+                             'id'      => 1
+                           }
+          end
+        end
+      end
   end
 end

data/spec/spec_helper.rb

@@ -2,18 +2,6 @@ require 'rubygems'
 $:.unshift(File.dirname(__FILE__) + '/../lib/')
 require 'jimson/server'
 require 'jimson/client'
-require 'open-uri'
 require 'json'
 
 SPEC_URL = 'http://localhost:8999'
-
-pid = Process.spawn(File.dirname(__FILE__) + '/server_helper.rb')
-
-RSpec.configure do |config|
-  config.after(:all) do
-    Process.kill(9, pid)
-  end
-end
-
-sleep 1
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jimson
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-11 00:00:00.000000000Z
+date: 2011-09-07 00:00:00.000000000Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: blankslate
+  requirement: &13756100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *13756100
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &12229180 !ruby/object:Gem::Requirement
+  requirement: &13755420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +32,10 @@ dependencies:
         version: 1.6.3
   type: :runtime
   prerelease: false
-  version_requirements: *12229180
+  version_requirements: *13755420
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &12228700 !ruby/object:Gem::Requirement
+  requirement: &13754820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +43,10 @@ dependencies:
         version: 1.5.1
   type: :runtime
   prerelease: false
-  version_requirements: *12228700
+  version_requirements: *13754820
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &12225120 !ruby/object:Gem::Requirement
+  requirement: &13754200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,29 +54,30 @@ dependencies:
         version: '1.3'
   type: :runtime
   prerelease: false
-  version_requirements: *12225120
+  version_requirements: *13754200
 description: 
 email: 
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
 - VERSION
 - LICENSE.txt
 - CHANGELOG.rdoc
-- README.rdoc
+- README.md
 - Rakefile
 - lib/jimson.rb
-- lib/jimson/client_error.rb
+- lib/jimson/server/error.rb
+- lib/jimson/handler.rb
 - lib/jimson/server.rb
-- lib/jimson/server_error.rb
 - lib/jimson/response.rb
+- lib/jimson/client/error.rb
 - lib/jimson/request.rb
 - lib/jimson/client.rb
+- spec/handler_spec.rb
 - spec/server_spec.rb
 - spec/client_spec.rb
-- spec/server_helper.rb
 - spec/spec_helper.rb
 homepage: http://www.github.com/chriskite/jimson
 licenses: []
@@ -92,7 +104,7 @@ signing_key:
 specification_version: 3
 summary: JSON-RPC 2.0 client and server
 test_files:
+- spec/handler_spec.rb
 - spec/server_spec.rb
 - spec/client_spec.rb
-- spec/server_helper.rb
 - spec/spec_helper.rb

data/lib/jimson/client_error.rb

@@ -1,31 +0,0 @@
-module Jimson
-  module ClientError
-    class Generic < Exception
-    end
-
-    class InvalidResponse < Generic 
-      def initialize()
-        super('Invalid or empty response from server.')
-      end
-    end
-
-    class InvalidJSON <  Generic
-      def initialize(json)
-        super("Couldn't parse JSON string received from server:\n#{json}")
-      end
-    end
-
-    class InternalError < Generic
-      def initialize(e)
-        super("An internal client error occurred when processing the request: #{e}\n#{e.backtrace.join("\n")}")
-      end
-    end
-
-    class UnknownServerError < Generic 
-      def initialize(code, message)
-        super("The server specified an error the client doesn't know about: #{code} #{message}")
-      end
-    end
-
-  end
-end

data/lib/jimson/server_error.rb

@@ -1,64 +0,0 @@
-module Jimson
-  module ServerError
-    class Generic < Exception
-      attr_accessor :code, :message
-
-      def initialize(code, message)
-        @code = code
-        @message = message
-        super(message)
-      end
-
-      def to_h
-        {
-          'code'    => @code,
-          'message' => @message
-        }
-      end
-    end
-
-    class ParseError < Generic
-      def initialize
-        super(-32700, 'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.')
-      end
-    end
-
-    class InvalidRequest < Generic
-      def initialize
-        super(-32600, 'The JSON sent is not a valid Request object.')
-      end
-    end
-
-    class MethodNotFound < Generic
-      def initialize
-        super(-32601, 'Method not found.')
-      end
-    end
-
-    class InvalidParams < Generic
-      def initialize
-        super(-32602, 'Invalid method parameter(s).')
-      end
-    end
-
-    class InternalError < Generic
-      def initialize
-        super(-32603, 'Internal server error.')
-      end
-    end
-
-    class ApplicationError < Generic
-      def initialize(err)
-        super(-32099, "The application being served raised an error: #{err}")
-      end
-    end
-
-    CODES = {
-              -32700 => ParseError,
-              -32600 => InvalidRequest,
-              -32601 => MethodNotFound,
-              -32602 => InvalidParams,
-              -32603 => InternalError
-            }
-  end
-end

data/spec/server_helper.rb

@@ -1,34 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-$:.unshift(File.dirname(__FILE__) + '/../lib/')
-require 'jimson'
-
-class TestHandler
-  def subtract(a, b = nil)
-    if a.is_a?(Hash)
-      return a['minuend'] - a['subtrahend']
-    else 
-      return a - b
-    end
-  end
-
-  def sum(a,b,c)
-    a + b + c
-  end
-
-  def notify_hello(*args)
-    # notification, doesn't do anything
-  end
-
-  def update(*args)
-    # notification, doesn't do anything
-  end
-
-  def get_data
-    ['hello', 5]
-  end
-end
-
-server = Jimson::Server.new(TestHandler.new)
-server.start