jsonrpc2 0.0.8 → 0.0.9

data/lib/jsonrpc2/client.rb

@@ -10,6 +10,14 @@ end
 class RemoteAuthError < RemoteError
 end
 
+# JSON RPC invalid JSON data
+class RemoteDataError < RemoteError
+end
+
+# JSON RPC wrong content type
+class WrongContentTypeError < RemoteError
+end
+
 # Simple JSONRPC client
 class Client
   # Create client object
@@ -17,11 +25,11 @@ class Client
   # @param [String] uri Create client object
   # @param [Hash] options Global options
   def initialize(uri, options = {})
-		@uri = uri
-		@client = HTTPClient.new
+    @uri = uri
+    @client = HTTPClient.new
     @options = options
-		@id = 0
-	end
+    @id = 0
+  end
 
   # Call method with named arguments
   # @param [String] method Remote method name
@@ -30,8 +38,8 @@ class Client
   # @return Method call result
   # @raise [RemoteError] Error thrown by API
   # @raise Transport/Network/HTTP errors
-	def call(method, args = {}, options = {}, &block)
-		headers = { 'Content-Type' => 'application/json-rpc' }
+  def call(method, args = {}, options = {}, &block)
+    headers = { 'Content-Type' => 'application/json-rpc' }
 
     # Merge one level of hashes - ie. merge :headers
     options = @options.merge(options) { |key,v1,v2| v2 = v1.merge(v2) if v1.class == v2.class && v1.is_a?(Hash); v2 }
@@ -43,30 +51,57 @@ class Client
     if options[:user] && options[:pass]
       @client.set_auth(@uri, options[:user], options[:pass])
     end
-		result = @client.post(@uri, 
-							  { 'method' => method, 'params' => args, 'jsonrpc' => '2.0', 'id' => (@id+=1) }.to_json,
-							  headers)
-		if result.contenttype =~ /^application\/json/
-			body = result.body
-			body = body.content if body.respond_to?(:content) #
-			data = JSON.parse body
-			if data.has_key?('result')
-				return data['result']
-			else
+    result = @client.post(@uri,
+                { 'method' => method, 'params' => args, 'jsonrpc' => '2.0', 'id' => (@id+=1) }.to_json,
+                headers)
+
+    body = result.body
+    body = body.content if body.respond_to?(:content) # Only on old versions of HTTPAccess2 ?
+
+    if result.status_code == 200
+      begin
+        data = JSON.parse body
+      rescue Exception
+        body = result.body.to_s
+        body = "#{body[0..256]}...[#{body.size-256} bytes trimmed]" if body.size > 256
+
+        if result.contenttype =~ /^application\/json/
+          raise RemoteDataError, "Content-Type is '#{result.contenttype}', but body of '#{body}' failed to parse."
+        else
+          raise WrongContentTypeError, "Content-Type is '#{result.contenttype}', but should be application/json-rpc or application/json (body='#{body}')"
+        end
+      end
+
+      unless data.is_a?(Hash) && data["jsonrpc"] == "2.0"
+        raise RemoteDataError, "No jsonrpc parameter in response.  This must be \"2.0\""
+      end
+
+      unless result.contenttype =~ /^application\/json/
+        STDERR.puts "WARNING: Content-Type is '#{result.contenttype}', but should be application/json-rpc or application/json."
+      end
+
+      if data.has_key?('result')
+        return data['result']
+      elsif data.has_key?('error')
         if data['error']['code'] == -32000 && data['error']['message'] =~ /^AuthFail/
           raise RemoteAuthError, data['error']['message']
         else
           raise RemoteError, data['error']['message']
         end
-			end
+      else
+        body = result.body.to_s
+        body = "#{body[0..256]}...[#{body.size-256} bytes trimmed]" if body.size > 256
+
+        raise RemoteDataError, "A JSON-RPC 2.0 response must either have a 'result' or an 'error' value - in '#{body}'."
+      end
     elsif result.status_code == 401
       if result.headers['WWW-Authenticate'].to_s =~ /realm="([^"]*?)"/
         suffix = " for #{$1}"
       end
       raise RemoteAuthError, "Authentication failed#{suffix}"
-		else
-			raise result.body
-		end
-	end
+    else
+      raise RemoteAuthError, "Call failed - HTTP status #{result.status_code}"
+    end
+  end
 end
 end

data/lib/jsonrpc2/types.rb

@@ -15,8 +15,8 @@ module JSONRPC2
   # * Array [Type] - An array of type Type
   # * Value (or Any or void) - Any value of any type
   # * CustomType - A defined custom object type
-	module Types
-		module_function
+  module Types
+    module_function
     DateTimeRegex = %r"([0-9]{4})(-([0-9]{2})(-([0-9]{2})(T([0-9]{2}):([0-9]{2})(:([0-9]{2})(\.([0-9]+))?)?(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?"
     DateRegex     = %r'\A\d{4}-\d{2}-\d{2}\z'
     TimeRegex     = %r'\A\d{2}:\d{2}(?:\.\d{1,4})?\z'
@@ -29,53 +29,51 @@ module JSONRPC2
     # separated if more than one
     # @param object Value to check check type
     # @return [Boolean] true if ok
-		def valid?(interface, type_string, object)
-				res = type_string.split(/,/).any? do |type|
-          case type
-          when 'String'
-            object.is_a?(String)
-          when 'Number'
-            object.kind_of?(Numeric)
-          when 'true'
-            object == true
-          when 'false'
-            object == false
-          when 'Boolean'
-            object == true || object == false
-          when 'null'
-            object.nil?
-          when 'Integer'
-            object.kind_of?(Numeric) && (object.to_i.to_f == object.to_f)
-          when 'Object'
-            object.is_a?(Hash)
-          when 'Array'
-            object.is_a?(Array)
-          when 'Date'
-            object.is_a?(String) && DateRegex.match(object) || object.is_a?(Date)
-          when 'Time'
-            object.is_a?(String) && TimeRegex.match(object) || object.is_a?(Time)
-          when 'DateTime'
-            object.is_a?(String) && DateTimeRegex.match(object) || object.is_a?(Time)
-          when /\AArray\[(.*)\]\z/
-            object.is_a?(Array) && object.all? { |value| valid?(interface, $1, value) }
-          when 'Value', 'Any', 'void'
-            true
-          else # Custom type
-            subset = (type[-1] == ?*)
-            type = type[0...-1] if subset
+    def valid?(interface, type_string, object)
+      res = type_string.split(/,/).any? do |type|
+        case type
+        when 'String'
+          object.is_a?(String)
+        when 'Number'
+          object.kind_of?(Numeric)
+        when 'true'
+          object == true
+        when 'false'
+          object == false
+        when 'Boolean'
+          object == true || object == false
+        when 'null'
+          object.nil?
+        when 'Integer'
+          object.kind_of?(Numeric) && (object.to_i.to_f == object.to_f)
+        when 'Object'
+          object.is_a?(Hash)
+        when 'Array'
+          object.is_a?(Array)
+        when 'Date'
+          object.is_a?(String) && DateRegex.match(object) || object.is_a?(Date)
+        when 'Time'
+          object.is_a?(String) && TimeRegex.match(object) || object.is_a?(Time)
+        when 'DateTime'
+          object.is_a?(String) && DateTimeRegex.match(object) || object.is_a?(Time)
+        when /\AArray\[(.*)\]\z/
+          object.is_a?(Array) && object.all? { |value| valid?(interface, $1, value) }
+        when 'Value', 'Any', 'void'
+          true
+        else # Custom type
+          subset = (type[-1] == ?*)
+          type = type[0...-1] if subset
 
-            custom = interface.types[type]
-            #STDERR.puts "Type Info: #{custom.inspect}"
-            if custom
-              custom.valid_object?(interface, object, subset)
-            else
-              raise "Invalid/unknown type: #{type} for #{interface.name}"
-            end
+          custom = interface.types[type]
+          if custom
+            custom.valid_object?(interface, object, subset)
+          else
+            raise "Invalid/unknown type: #{type} for #{interface.name}"
           end
         end
-				#STDERR.puts "#{interface.name}: #{type} - #{object.inspect} - #{res ? "OK" : "FAIL"}"
-				res
-		end
+      end
+      res
+    end
 
     # Checks that param hash is valid for API call
     # 
@@ -83,103 +81,103 @@ module JSONRPC2
     # @param [String] method Method name
     # @param [Hash] data params hash to check
     # @return [Boolean] true if ok
-		def valid_params?(interface, method, data)
-			about = interface.about[method.to_s]
-			return true if about.nil? # No defined params
+    def valid_params?(interface, method, data)
+      about = interface.about[method.to_s]
+      return true if about.nil? # No defined params
 
-			params = (about[:params] || [])
-			param_names = params.map { |param| param[:name] }
+      params = (about[:params] || [])
+      param_names = params.map { |param| param[:name] }
 
-			if params.empty? && data.empty?
-				return true
-			end
+      if params.empty? && (data.nil? or data.empty?)
+        return true
+      end
 
-			extra_keys = data.keys - param_names
-			unless extra_keys.empty?
-				raise "Extra parameters #{extra_keys.inspect} for #{method}."
-			end
-			
-			params.each do |param|
-				if data.has_key?(param[:name])
+      raise "Params should not be nil" if data.nil?
+
+      extra_keys = data.keys - param_names
+      unless extra_keys.empty?
+        raise "Extra parameters #{extra_keys.inspect} for #{method}."
+      end
+
+      params.each do |param|
+        if data.has_key?(param[:name])
           value = data[param[:name].to_s]
-					unless valid?(interface, param[:type], value)
+          unless valid?(interface, param[:type], value)
             raise "'#{param[:name]}' should be of type #{param[:type]}, was #{value.class.name}"
           end
-				elsif ! param[:required]
-					next true
-				else
-					raise "Missing parameter: '#{param[:name]}' of type #{param[:type]} for #{method}"
-				end
-			end
-		end
+        elsif ! param[:required]
+          next true
+        else
+          raise "Missing parameter: '#{param[:name]}' of type #{param[:type]} for #{method}"
+        end
+      end
+    end
 
     # Checks that result is valid for API call
-    # 
+    #
     # @param [Interface] interface API class
     # @param [String] method Method name
     # @param [Hash] value Value to check
     # @return [Boolean] true if ok
-		def valid_result?(interface, method, value)
-			about = interface.about[method.to_s]
-			return true if about.nil? # Undefined
-			if about[:returns].nil?
-				return value.nil?
-			end
-			valid?(interface, about[:returns][:type], value) or
+    def valid_result?(interface, method, value)
+      about = interface.about[method.to_s]
+      return true if about.nil? # Undefined
+      if about[:returns].nil?
+        return value.nil?
+      end
+      valid?(interface, about[:returns][:type], value) or
         raise "Invalid return type: should have been #{about[:returns][:type]}, was #{value.class.name}"
-		end
-	end
+    end
+  end
 
   # Description of JSON object
-	class JsonObjectType
-		attr_accessor :name, :fields
-		def initialize(name, fields)
-			@name, @fields = name, fields
-			@required = true
-		end
+  class JsonObjectType
+    attr_accessor :name, :fields
+    def initialize(name, fields)
+      @name, @fields = name, fields
+      @required = true
+    end
 
     # Check that #object Hash is valid version of this type
-		def valid_object?(interface, object, subset = false)
-			object.keys.all? { |key| fields.any? { |field| field[:name] == key } } &&
-				fields.all? { |field| (object.keys.include?(field[:name]) &&
-					Types.valid?(interface, field[:type], object[field[:name]])) || subset || (! field[:required]) }
-		end
+    def valid_object?(interface, object, subset = false)
+      object.keys.all? { |key| fields.any? { |field| field[:name] == key } } &&
+        fields.all? { |field| (object.keys.include?(field[:name]) &&
+          Types.valid?(interface, field[:type], object[field[:name]])) || subset || (! field[:required]) }
+    end
 
     # Add field of #name and #type to type description
-		def field(name, type, desc, options={})
-			@fields << { :name => name, :type => type, :desc => desc, :required => @required }.merge(options)
-		end
+    def field(name, type, desc, options={})
+      @fields << { :name => name, :type => type, :desc => desc, :required => @required }.merge(options)
+    end
     # Shortcut to define string field
-		def string  name, desc, options={}; field(name, 'String',  desc, options); end
+    def string  name, desc, options={}; field(name, 'String',  desc, options); end
     # Shortcut to define number field
-		def number  name, desc, options={}; field(name, 'Number',  desc, options); end
+    def number  name, desc, options={}; field(name, 'Number',  desc, options); end
     # Shortcut to define integer field
-		def integer name, desc, options={}; field(name, 'Integer', desc, options); end
+    def integer name, desc, options={}; field(name, 'Integer', desc, options); end
     # Shortcut to define boolean field
-		def boolean name, desc, options={}; field(name, 'Boolean', desc, options); end
+    def boolean name, desc, options={}; field(name, 'Boolean', desc, options); end
 
     # Make fields defined in block optional by default
-		def optional(&block)
-			old_required = @required
-			begin
-				@required = false
-				yield(self)
-			ensure
-				@required = old_required
-			end
-		end
+    def optional(&block)
+      old_required = @required
+      begin
+        @required = false
+        yield(self)
+      ensure
+        @required = old_required
+      end
+    end
 
     # Make fields defined in block required by default
-		def required(&block)
-			old_required = @required
-			begin
-				@required = true
-				yield(self)
-			ensure
-				@required = old_required
-			end
-		end
-
-	end
-
+    def required(&block)
+      old_required = @required
+      begin
+        @required = true
+        yield(self)
+      ensure
+        @required = old_required
+      end
+    end
+  end
 end

data/lib/jsonrpc2/version.rb

@@ -1,5 +1,5 @@
 # JSONRPC2 namespace module
 module JSONRPC2
   # Version
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonrpc2
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors: