protocol-jsonrpc 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0488651e9e3c97f90a8bfe83c904ade78a8e0532e524fc6b1e97fd7ec2334f0f'
-  data.tar.gz: 2d9c402bcd8786051868b545afdb858ca862fcd4e699e6910a720467b4d0ab3d
+  metadata.gz: b54b4f7232fe6c0daa9a4e589f4db5edd2aba983cbcfc7a4ab880cfaaa2c2ffa
+  data.tar.gz: f8df39a2b673213f62e9681e1500d7f7b487aa4c77d925253e3dc019c6c0f8d1
 SHA512:
-  metadata.gz: 32a5eaf0c2424ce7a93250a7d164fb98a856eb918422481de1d7348906edbd9817cd87d32f55c1eeef3338c9ff7c531329cdd98bad5512254e4c121ae5442b0f
-  data.tar.gz: be8901fb47e177223a99175999b3e25798c0709505f558442020cca36d24da59e970114cefdbb907874005fac1c241360a78134e7bba2ca49869fbde3182cab2
+  metadata.gz: ee456605301d8af0745a57b453583ba115f711f63a93b24463ad86fafaa32e862832d81359654eb48ded753ba6aa1568e251855ec115858984bed24b6dc4277a
+  data.tar.gz: 6683a84ec2f1bdc098dfb09caf187cf34763896067f10711b232f54971b8566a3ffedf13224e3a2b9fbb726d799d4e249b9b761f03b92e938d168402d7fecc5f

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.2.1] - 2025-06-01
+
+- If a reply block for a Notification raises, suppress the error as defined in the spec
+
 ## [0.2.0] - 2025-06-01
 
 **Breaking changes**: As I work towarsd a 1.0.0 release, I've changed the interface to ensure a uniform interface for [JSON-RPC 2.0 batch processing](https://www.jsonrpc.org/specification#batch). I believe we have a much more robust implementation now, so I will try to stay more consistent, but please be cautious upgrading until 1.0.0 is released and we finalize the interface.

data/README.md

@@ -52,10 +52,8 @@ This wraps a framer and provides higher-level methods for communication.
 Here's a basic example showing how to create a JSON-RPC connection over a socket pair:
 
 ```ruby
-require 'protocol/jsonrpc'
-require 'protocol/jsonrpc/connection'
-require 'protocol/jsonrpc/framer'
-require 'socket'
+require "protocol/jsonrpc"
+require "socket"
 
 # Create a socket pair for testing
 client_socket, server_socket = UNIXSocket.pair
@@ -179,6 +177,13 @@ Typically created by replying to a request:
 # From a request object
 response = request.reply(19)
 
+response = request.reply do |message|
+  message.params.sum if message.request? && message.method == "add"
+  if message.method == "fail"
+    raise "Oops, we failed" # gets turned into a error response
+  end
+end
+
 # Or directly
 response = Protocol::Jsonrpc::Response.new(
   result: 19,
@@ -194,6 +199,11 @@ For error responses:
 # Create from an error object
 error = Protocol::Jsonrpc::InvalidParamsError.new("Invalid parameters")
 error_response = request.reply(error)
+
+# Create from a reply that raises
+response = request.reply do |message|
+  raise "Oops" # Returns an InternalError response
+end
 ```
 
 Error types represent the standard JSON-RPC error codes:
@@ -206,6 +216,14 @@ Protocol::Jsonrpc::InvalidParamsError
 Protocol::Jsonrpc::InternalError
 ```
 
+Most of the errors happen automatically, but some must be triggered manually.
+
+```ruby
+response = request.reply do |message|
+  raise Protocol::Jsonrpc::MethodNotFoundError, "We don't support any methods"
+end
+```
+
 ## Batch Processing
 
 JSON-RPC supports batch requests and responses. The library returns a `Protocol::Jsonrpc::Batch` that acts like an array and provides a `reply` method for processing:

data/lib/protocol/jsonrpc/connection.rb

@@ -26,7 +26,9 @@ module Protocol
       def read(&block)
         flush
         frame = read_frame
-        Message.load(frame.unpack)
+        message = Message.load(frame.unpack)
+        yield message if block_given?
+        message
       rescue => e
         InvalidMessage.new(error: e)
       end

data/lib/protocol/jsonrpc/error.rb

@@ -24,8 +24,10 @@ module Protocol
       ).freeze
 
       # Factory method to create the appropriate error type
+      # @param code [Integer] The JSON-RPC error code
+      # @param message [String] The error message
+      # @param data [#as_json, #to_json] Serializable data to return to the client
       # @param id [String, Integer] The request ID
-      # @param error [Hash] The error data from the JSON-RPC response
       # @return [Error] The appropriate error instance
       def self.from_message(code:, message:, data: nil, id: nil)
         case code
@@ -54,17 +56,22 @@ module Protocol
           error = error.transform_keys(&:to_sym)
           from_message(id: id, data: data, **error)
         in Jsonrpc::Error
+          error.data ||= data if data
+          error.id ||= id if id
           error
         in JSON::ParserError
           ParseError.new("Parse error: #{error.message}", data:, id:)
         in StandardError
           InternalError.new(error.message, data:, id:)
-        else
+        in Exception
           raise error
+        else
+          raise ArgumentError, "Unknown error type: #{error.class}"
         end
       end
 
-      attr_reader :data, :code, :id
+      attr_accessor :data, :id
+      attr_reader :code
 
       def initialize(message = nil, data: nil, id: nil)
         message = nil if message&.empty?

data/lib/protocol/jsonrpc/message.rb

@@ -36,16 +36,17 @@ module Protocol
         # @return [Message] The parsed message
         def from_hash(parsed)
           return InvalidMessage.new(data: parsed.inspect) unless parsed.is_a?(Hash)
+
           jsonrpc = parsed[:jsonrpc]
 
           case parsed
-          in { id:, error: }
+          in {id:, error:}
             ErrorResponse.new(id:, error: Error.from_message(**error), jsonrpc:)
-          in { id:, result: }
+          in {id:, result:}
             Response.new(id:, result:, jsonrpc:)
-          in { id:, method: }
+          in {id:, method:}
             Request.new(id:, method:, params: parsed[:params], jsonrpc:)
-          in { method: }
+          in {method:}
             Notification.new(method:, params: parsed[:params], jsonrpc:)
           else
             InvalidMessage.new(data: parsed.inspect)

data/lib/protocol/jsonrpc/notification.rb

@@ -29,10 +29,12 @@ module Protocol
       def id = nil
 
       # Compatibility with the Request
-      # Yields the notificatino for processing but ignores the result
+      # Yields the notification for processing but ignores the result
       def reply(*, &)
         yield self if block_given?
-        nil # notification always returns nil
+        nil
+      rescue
+        nil # JSON-RPC 2.0 spec says notifications should never return, even on error.
       end
 
       def notification? = true

data/lib/protocol/jsonrpc/version.rb

@@ -5,6 +5,6 @@
 
 module Protocol
   module Jsonrpc
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/protocol/jsonrpc.rb

@@ -6,18 +6,18 @@
 module Protocol
   module Jsonrpc
     JSONRPC_VERSION = "2.0"
-
-    autoload :Batch, "protocol/jsonrpc/batch"
-    autoload :Connection, "protocol/jsonrpc/connection"
-    autoload :Error, "protocol/jsonrpc/error"
-    autoload :ErrorResponse, "protocol/jsonrpc/error_response"
-    autoload :Frame, "protocol/jsonrpc/frame"
-    autoload :Framer, "protocol/jsonrpc/framer"
-    autoload :InvalidMessage, "protocol/jsonrpc/invalid_message"
-    autoload :Message, "protocol/jsonrpc/message"
-    autoload :Notification, "protocol/jsonrpc/notification"
-    autoload :Request, "protocol/jsonrpc/request"
-    autoload :Response, "protocol/jsonrpc/response"
-    autoload :VERSION, "protocol/jsonrpc/version"
   end
 end
+
+require_relative "jsonrpc/version"
+require_relative "jsonrpc/error"
+require_relative "jsonrpc/message"
+require_relative "jsonrpc/error_response"
+require_relative "jsonrpc/invalid_message"
+require_relative "jsonrpc/notification"
+require_relative "jsonrpc/request"
+require_relative "jsonrpc/response"
+require_relative "jsonrpc/frame"
+require_relative "jsonrpc/framer"
+require_relative "jsonrpc/connection"
+require_relative "jsonrpc/batch"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-jsonrpc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Martin Emde