jsonrpc-server 0.1.1 → 0.2.0

data/README

@@ -0,0 +1,35 @@
+== About
+
+This is an implementation of {JSON RPC 2.0}[link:http://groups.google.com/group/json-rpc/web/json-rpc-2-0?pli=1] server
+
+== Using
+
+To make your rails controller JSON RPC 2.0 callable, make next include:
+
+    class TestController < ActionController::Base
+      include JSONServer
+
+      def summ(left, right)
+        return left+right
+      end
+    end
+
+In your config/routing.rb you will have to add
+
+    post 'json'     => 'test#index'
+
+JSONServer will automaticaly check if  posted json is valid JSON-RPC 2.0 request
+and and fire called method. if method is not found - propper error will be sent.
+
+Batch request are handled.
+
+== Errors
+
+You can raise standart errors, or JSONServer::Error with parameters :code,
+:message, :data, which will be set for correspoding fields
+:code defaults to -30000 if JSONServer::Error and to -32000 otherwise
+:message defaults to "Runtime Error"
+
+== TODO list
+
+write tests

data/lib/json_server.rb

@@ -1,6 +1,10 @@
+require 'json'
+
 module JSONServer
 
-  class Error < RuntimeError
+  @@JSONRPCVersion = "2.0".freeze
+
+  class JSONRPCError < RuntimeError
     attr_reader :code, :message, :data
     def initialize obj = {}
       @code    = obj[:code]    || -30000
@@ -9,87 +13,123 @@ module JSONServer
     end
   end
 
-  def index
+  def dispatch_json_2 request
+    # here request specific errors are handled
     begin
-      data = ActiveSupport::JSON.decode request.body
-    rescue StandardError
-      render :json => parseError
-      return
+      # no wraping, because single_request dispatcher does it
+      result = core_dispatch request
+    rescue JSONRPCError
+      result = wrap_error({ :code => $!.code,
+                            :message => $!.message,
+                            :data => $!.data
+                          })
+    rescue RuntimeError
+      result = wrap_error({ :code => -32000,
+                            :message => $!.message,
+                            :data => $!.to_s
+                          })
     end
-    if data.class == Array
-      if data.length == 0
-        render :json => invalidRequest
-        return
-      end
-      res = data.collect { |single|
-        parseSingle single
-      }
-      render :json => res
-      return
+    if result != nil
+      return result.to_json
     end
-    render :json => parseSingle(data)
+    return ''
   end
 
   private
 
-  def parseSingle(data)
-    if data.class != Hash ||
-        data["jsonrpc"] != "2.0" ||
-        data["method"].class != String ||
-        data["method"] == ""
-      return invalidRequest
+  def core_dispatch request
+    begin
+      data = JSON.parse request
+    rescue JSON::ParserError
+      parse_error # converting error into json-rpc 2.0
+    end
+    if data.kind_of? Array
+      invalid_request if data.length == 0 # batch can not be empty
+      res = data.collect{ |single|
+        parse_single single
+      }
+      res.delete(nil)
+      return res unless res.length == 0
+      return nil
     end
-    result = { :jsonrpc => "2.0", :id => data["id"] }
+    parse_single data
+  end
+
+  def wrap data, id = nil
+    data.update({ :jsonrpc => @@JSONRPCVersion, :id => id })
+  end
+
+  def wrap_error error, id = nil
+    wrap({ :error => error }, id)
+  end
+
+  def wrap_result result, id = nil
+    wrap({:result => result}, id)
+  end
+
+  def parse_single(data)
+    current_id = nil
     begin
+      invalid_request unless data.kind_of?(Hash)
+      current_id = data["id"] unless data["id"] == nil
+      if data["jsonrpc"] != @@JSONRPCVersion ||
+          (not data["method"].kind_of?(String)) ||
+          data["method"] == ""
+        invalid_request
+      end
       self.class.public_instance_methods.each { |method|
         if method.to_s == data["method"]
-          if data["params"].class == Array
+          if data["params"].kind_of? Array
             arr = data["params"]
           elsif
             arr = self.method(data["method"]).parameters.collect { |pd|
               data["params"][pd[1].to_s]
             }
           end
-          result["result"] = self.send(data["method"], *arr)
-          return result
+          result = self.send(data["method"], *arr)
+          if current_id != nil
+            return wrap_result(result, current_id)
+          else
+            return
+          end
         end
       }
-    rescue Error
-      result["code"]    = $!.code
-      result["message"] = $!.message
-      result["data"]    = $!.data
-      return result
+      method_not_found
+    rescue JSONRPCError
+      result = wrap_error({ :code => $!.code,
+                            :message => $!.message,
+                            :data => $!.data
+                          }, current_id)
     rescue RuntimeError
-      result["code"]    = -32000
-      result["message"] = $!.message
-      result["data"]    = $!
-      return result
+      result = wrap_error({ :code => -32000,
+                            :message => $!.message,
+                            :data => $!.to_s
+                          }, current_id)
     end
-    return methodNotFound data["id"]
   end
 
   ##
   #  Error handling section
   ##
 
-  def methodNotFound id
-    return {:jsonrpc => "2.0",
-      :error => {:code => -32601,
-        :message => "Procedure not found."},
-      :id => id}
+  def method_not_found
+    raise(JSONRPCError, {
+            :code => -32601,
+            :message => "Method not found."
+          }, caller)
   end
 
-  def parseError
-    return {:jsonrpc => "2.0",
-      :error => {:code => -32700,
-        :message => "Parse error."},
-      :id => nil}
+  def parse_error
+    raise(JSONRPCError, {
+            :code => -32700,
+            :message => "Parse error."
+          }, caller)
   end
 
-  def invalidRequest
-    return {:jsonrpc => "2.0",
-      :error => {:code => -32600,
-        :message => "Invalid Request."},
-      :id => nil}
+  def invalid_request
+    raise(JSONRPCError, {
+            :code => -32600,
+            :message => "Invalid Request."
+          }, caller)
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Dima Levchenko
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-30 00:00:00 +03:00
+date: 2011-05-31 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -28,6 +28,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/json_server.rb
+- README
 has_rdoc: true
 homepage: http://rubygems.org/gems/jsonrpc-server
 licenses: []
@@ -55,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: "[none]"
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3