clamo 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: debb0ed8e3b749ff9e0213c9c97e821668f45d179c7e72d1f4a1a506cd710b75
-  data.tar.gz: dcd24d91533bfe8c50bb5456745b342fc35cab1d38714b3552df36e2fdf34df0
+  metadata.gz: 103be8c6254e2ed646ebe13671e38dfea1af22f94bd8c082dc11ef6efe287260
+  data.tar.gz: 2094ae4b5697e41421d6014345ba34205a1db1b512907e341e66fe90b7d1b44e
 SHA512:
-  metadata.gz: 7e2df3792feceedc6c98c92b29ddb25e67db2a57972ee08b20e71b13327b4c1296269ef7c873b7e9181aa042d03a2ab7849dde8498750088d2419789a1e33254
-  data.tar.gz: c49ce4742815d16fab1b9cbcf30f621ae2429b515bab8e245f43c069a9be70bbbfe519b6cd8868cf5275c29dd3d1f7e2aa3f54f57e1973b2557c3203871c3614
+  metadata.gz: 73c85c552789c203b2ab88849501911784789c45fb027e821158bb6f3b359d2cc61acbdddd910f7f0bf802899ed070ced035f0ee8eeb736b6fc410ca1277caa6
+  data.tar.gz: b3a4295676b10ca536eb75c34d42ef3103b1900a73f748a39d486ab07ec3ac48a77d12f074ea393bb2276a2b3aa4f3521818e9127d919cde1631a3bc37752c40

data/lib/clamo/gpt_json_rpc_server.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "json"
+
+module GPTJsonRpcServer
+  PROTOCOL_VERSION = "2.0"
+
+  def self.handle_request(object:, request_json:)
+    requests = JSON.parse(request_json)
+    if requests.is_a?(Array)
+      responses = requests.map do |request|
+        Thread.new { process_request(object, request) }
+      end.map(&:value).compact
+      responses.empty? ? nil : responses.to_json
+    else
+      response = process_request(object, requests)
+      response&.to_json
+    end
+  rescue JSON::ParserError
+    { jsonrpc: PROTOCOL_VERSION, error: { code: -32_700, message: "Parse error" }, id: nil }.to_json
+  end
+
+  def self.process_request(object, request)
+    method = request["method"]
+    params = request["params"]
+    id = request["id"]
+
+    unless valid_id?(id)
+      return { jsonrpc: PROTOCOL_VERSION, error: { code: -32_600, message: "Invalid Request" }, id: nil }
+    end
+
+    unless method.is_a?(String) && object.public_methods(false).include?(method.to_sym)
+      return { jsonrpc: PROTOCOL_VERSION, error: { code: -32_601, message: "Method not found" }, id: id }
+    end
+
+    method_object = object.method(method)
+    param_list = method_object.parameters
+    valid_params = case params
+                   when Array
+                     param_list.none? { |type, _| type == :rest } && params.size == param_list.count do |type, _|
+                       %i[req opt rest].include?(type)
+                     end
+                   when Hash
+                     required_params = param_list.slice(:keyreq).map(&:last)
+                     required_params.all? { |key| params.key?(key) } && param_list.all? do |type, name|
+                       type != :keyreq || params.key?(name)
+                     end
+                   when NilClass
+                     param_list.empty?
+                   else
+                     false
+                   end
+
+    unless valid_params
+      return { jsonrpc: PROTOCOL_VERSION, error: { code: -32_602, message: "Invalid params" },
+               id: id }
+    end
+
+    if id.nil?
+      # Treat id: null as a notification
+      Thread.new { safe_call_method(method_object, params) }
+      return nil
+    end
+
+    begin
+      result = safe_call_method(method_object, params)
+      { jsonrpc: PROTOCOL_VERSION, result: result, id: id }
+    rescue StandardError => e
+      { jsonrpc: PROTOCOL_VERSION, error: { code: -32_603, message: "Internal error", data: e.message }, id: id }
+    end
+  end
+
+  def self.safe_call_method(method_object, params)
+    if params.is_a?(Array)
+      method_object.call(*params)
+    elsif params.is_a?(Hash)
+      method_object.call(**params)
+    else
+      method_object.call
+    end
+  end
+
+  def self.valid_id?(id)
+    return false unless id.is_a?(String) || id.is_a?(Numeric) || id.nil?
+    return false if id.is_a?(Numeric) && id != id.to_i
+
+    true
+  end
+end
+
+# Example usage
+
+class MyService
+  def add(a, b)
+    a + b
+  end
+
+  def subtract(a:, b:)
+    a - b
+  end
+
+  private
+
+  def private_method
+    "This should not be exposed"
+  end
+end
+
+service = MyService.new
+
+# Example JSON-RPC requests
+single_request_positional = {
+  jsonrpc: "2.0",
+  method: "add",
+  params: [1, 2],
+  id: 1
+}.to_json
+
+single_request_keyword = {
+  jsonrpc: "2.0",
+  method: "subtract",
+  params: { a: 5, b: 3 },
+  id: 2
+}.to_json
+
+batch_request = [
+  { jsonrpc: "2.0", method: "add", params: [1, 2], id: 1 },
+  { jsonrpc: "2.0", method: "subtract", params: { a: 5, b: 3 }, id: 2 },
+  { jsonrpc: "2.0", method: "add", params: [7, 3], id: 3 }
+].to_json
+
+notification_request = {
+  jsonrpc: "2.0",
+  method: "add",
+  params: [1, 2]
+}.to_json
+
+invalid_id_null_request = {
+  jsonrpc: "2.0",
+  method: "add",
+  params: [1, 2],
+  id: nil
+}.to_json
+
+invalid_id_object_request = {
+  jsonrpc: "2.0",
+  method: "add",
+  params: [1, 2],
+  id: {}
+}.to_json
+
+invalid_method_request = {
+  jsonrpc: "2.0",
+  method: {},
+  params: [1, 2],
+  id: 1
+}.to_json
+
+# Handling single request with positional parameters
+response_json_positional = GPTJsonRpcServer.handle_request(object: service, request_json: single_request_positional)
+puts response_json_positional # Output: {"jsonrpc":"2.0","result":3,"id":1}
+
+# Handling single request with keyword parameters
+response_json_keyword = GPTJsonRpcServer.handle_request(object: service, request_json: single_request_keyword)
+puts response_json_keyword # Output: {"jsonrpc":"2.0","result":2,"id":2}
+
+# Handling batch request
+batch_response_json = GPTJsonRpcServer.handle_request(object: service, request_json: batch_request)
+puts batch_response_json # Output: [{"jsonrpc":"2.0","result":3,"id":1},{"jsonrpc":"2.0","result":2,"id":2},{"jsonrpc":"2.0","result":10,"id":3}]
+
+# Handling notification request (no response expected)
+notification_response_json = GPTJsonRpcServer.handle_request(object: service, request_json: notification_request)
+puts notification_response_json.nil? # Output: true
+
+# Handling request with id = null (treated as a notification)
+invalid_id_null_response_json = GPTJsonRpcServer.handle_request(object: service, request_json: invalid_id_null_request)
+puts invalid_id_null_response_json.nil? # Output: true
+
+# Handling request with id as an object (should return an error)
+invalid_id_object_response_json = GPTJsonRpcServer.handle_request(object: service,
+                                                                  request_json: invalid_id_object_request)
+puts invalid_id_object_response_json # Output: {"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request"},"id":null}
+
+# Handling request with method as an object (should return an error)
+invalid_method_response_json = GPTJsonRpcServer.handle_request(object: service, request_json: invalid_method_request)
+puts invalid_method_response_json # Output: {"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request"},"id":1}

data/lib/clamo/jsonrpc.rb

@@ -37,7 +37,7 @@ module Clamo
 
       def proper_params_if_any?(request)
         if request.key?("params")
-          request["params"].is_a?(Array)
+          request["params"].is_a?(Array) || request["params"].is_a?(Hash)
         else
           true
         end
@@ -47,8 +47,11 @@ module Clamo
         request.is_a?(Hash) &&
           proper_pragma?(request) &&
           proper_method?(request) &&
-          proper_id_if_any?(request) &&
-          proper_params_if_any?(request)
+          proper_id_if_any?(request)
+      end
+
+      def valid_params?(request)
+        proper_params_if_any?(request)
       end
 
       def build_request **opts

data/lib/clamo/server.rb

@@ -41,7 +41,7 @@ module Clamo
         when Array
           object.send method.to_sym, *params
         when Hash
-          object.send method.to_sym, **params
+          object.send method.to_sym, **params.transform_keys(&:to_sym)
         when NilClass
           object.send method.to_sym
         else
@@ -86,6 +86,13 @@ module Clamo
           )
         end
 
+        unless JSONRPC.valid_params?(request)
+          return JSONRPC.build_error_response_from(
+            id: request["id"],
+            descriptor: JSONRPC::ProtocolErrors::INVALID_PARAMS
+          )
+        end
+
         unless request.key?("id") # notification - no result needed
           # TODO: block.call off the current thread
           Thread.new do

data/lib/clamo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clamo
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: clamo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andriy Tyurnikov
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-04 00:00:00.000000000 Z
+date: 2025-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.24.0
+        version: 1.27.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.24.0
+        version: 1.27.0
 description: JSON-RPC Client/Server tooling for Ruby
 email:
 - Andriy.Tyurnikov@gmail.com
@@ -36,6 +35,7 @@ files:
 - Rakefile
 - lib/clamo.rb
 - lib/clamo/client.rb
+- lib/clamo/gpt_json_rpc_server.rb
 - lib/clamo/jsonrpc.rb
 - lib/clamo/server.rb
 - lib/clamo/version.rb
@@ -46,8 +46,7 @@ metadata:
   homepage_uri: https://github.com/andriytyurnikov/clamo
   source_code_uri: https://github.com/andriytyurnikov/clamo
   changelog_uri: https://github.com/andriytyurnikov/clamo
-  rubygems_mfa_required: 'false'
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -62,8 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.6.5
 specification_version: 4
 summary: JSON-RPC Client/Server tooling for Ruby
 test_files: []