clamo 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93acbb6067140d2268cec5379f519ab6e693949f36f76e3933f8a93c246dbd96
-  data.tar.gz: 6811ac69e7b7b405991d2b1ce73e7138f4fb0709101e482da7f3744826dec592
+  metadata.gz: 410f469e07b16f8273149b1eded89c94692a91c8b41cd7c47642e897ca8d97fb
+  data.tar.gz: 2d6be4be393cfd70d5bf22109943b7735de5ca0abe93b65a888fe1a372640faa
 SHA512:
-  metadata.gz: 1c83b16bd8e702714fca22d0277206538f22c560f795ed01f8ae76268304209b2ae0669e988e3897725a62856fe286832ffe3f3993cdd99040659a4178373efb
-  data.tar.gz: bed60d4e01db858ea8875c420258c5754efdaa21a34cdb35b337c13168c811f6c2f7945f0510680fb872644ddf9d872a9a30f7ecbd164010d4eddf3d8dac7edc
+  metadata.gz: 385175b28fea11461b35a98860a6b8099bd9c88bc8dfef4f2603dc911a3d9e1709b51343d2b22ebb524ffc82aa03de7d8886a50b078c258d5fe28ec897a17296
+  data.tar.gz: 0c37f0971e24855610a91c8687d8e55ff32a03accf1effc73b6a1090118b46e3d78ffd9f0a7531418aa97a3154969bf7fb4d2dd0da9dc0cfe1b2b7aa94778cda

data/.rubocop.yml

@@ -1,10 +1,16 @@
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.3
 
 Metrics/MethodLength:
   Enabled: false
 
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
 Style/Documentation:
   Enabled: false
 

data/CHANGELOG.md

@@ -0,0 +1,101 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [0.7.0] - 2026-03-14
+
+### Added
+
+- `Clamo::Server.timeout` — per-dispatch timeout with 30-second default; returns `-32000 Server error` on timeout for requests, calls `on_error` for notifications. Set to `nil` to disable.
+- MIT LICENSE file and `spec.license` in gemspec
+- Indifferent key access in JSONRPC validators (symbol and string keys both accepted)
+- Tests for string ids, arity mismatch, single-item batches, and handle+timeout (77 tests / 105 assertions)
+
+### Changed
+
+- `proper_pragma?`, `proper_method?`, `proper_id_if_any?` moved from public to private API on `Clamo::JSONRPC`
+- Notifications with invalid params type now return `nil` instead of an error response (spec compliance)
+- `parsed_dispatch_to_object` now validates `object:` argument (raises `ArgumentError` if nil)
+- Single-item batches skip `Parallel.map` overhead
+- Gemspec description expanded (no longer identical to summary)
+- README updated with `Server.handle`, `timeout`, and `on_error` documentation
+
+### Removed
+
+- `Clamo::Error` base exception class (unused)
+- `sig/clamo.rbs` type signatures (misleadingly incomplete)
+- Dead `else` branch in `dispatch_to_ruby`
+
+## [0.6.0] - 2026-03-14
+
+### Added
+
+- `Clamo::Server.handle` — JSON string in, JSON string out entry point for HTTP/socket integrations
+- `Clamo::Server.on_error` callback for notification failure reporting
+- `Clamo::Error` base exception class
+
+### Changed
+
+- Notifications now dispatch synchronously instead of spawning a background thread per call; callers control their own concurrency
+- `build_error_response_from` accepts explicit `descriptor:` and `id:` keyword arguments instead of `**opts`
+- `build_error_response_parse_error` takes no arguments (always returns `id: nil`)
+- `parallel` dependency relaxed from `~> 1.27.0` to `~> 1.27`
+- Minimum Ruby version raised from 3.0 to 3.3
+
+### Removed
+
+- `JSONRPC.valid_params?` (use `JSONRPC.proper_params_if_any?` directly)
+- `JSONRPC::PROTOCOL_VERSION_PRAGMA` constant (unused)
+- `JSONRPC::ProtocolErrors::SERVER_ERROR_CODE_RANGE` constant (unused)
+
+### Fixed
+
+- **Security:** replaced `send` with `public_send` to prevent remote invocation of private methods
+- **Security:** `method_known?` now uses `public_methods(false)` to expose only explicitly defined methods
+- Notifications now validate method existence before dispatch (previously skipped validation)
+- Empty batch requests correctly return Invalid Request error per spec
+- All-notification batches return `nil` instead of empty array per spec
+- `build_error_response_from` no longer leaks the `:descriptor` key into the error response builder
+
+### Internal
+
+- `method_known?`, `dispatch_to_ruby`, `response_for` moved from public to private API
+- `response_for_single_request` extracted into focused private helpers
+- Test suite expanded from scaffold to 62 tests / 84 assertions covering validation, dispatch, security, error handling, batching, notifications, and argument edge cases
+- CI matrix set to Ruby 3.3, 3.4, 4.0
+
+## [0.5.0] - 2025-02-07
+
+### Changed
+
+- Updated README with detailed usage examples, error table, and batch/notification documentation
+
+## [0.4.0] - 2025-02-07
+
+### Fixed
+
+- Corrected gem metadata URLs
+
+## [0.3.0] - 2025-02-06
+
+### Added
+
+- Batch request support via `parallel` gem
+- Named parameter (Hash) dispatch
+- JSON-RPC 2.0 validation (pragma, method, id, params)
+- Protocol error constants (`PARSE_ERROR`, `INVALID_REQUEST`, etc.)
+- RuboCop configuration
+
+### Changed
+
+- Multiple version bumps during initial development
+
+## [0.1.0] - 2025-02-06
+
+### Added
+
+- Initial release
+- Basic JSON-RPC 2.0 server with positional parameter dispatch
+- `Clamo::JSONRPC` request/response builders

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Andriy Tyurnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,26 +1,5 @@
 # Clamo
 
-JSON-RPC protocol toolkit for Ruby.
-
-Consume, Serve or test JSON-RPC endpoints with Clamo.
-
-## Installation
-
-Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add clamo
-
-If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install clamo
-
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machi# Clamo
-
 A Ruby implementation of [JSON-RPC 2.0](https://www.jsonrpc.org/specification) designed for simplicity and compliance with the specification.
 
 
@@ -36,26 +15,41 @@ module MyService
   def self.add(a, b)
     a + b
   end
-  
+
   def self.subtract(a:, b:)
     a - b
   end
-  
+
   # Private methods won't be accessible via JSON-RPC
   private_class_method def self.internal_method
     # This won't be exposed
   end
 end
 
-# Handle a JSON-RPC request
-request_body = '{"jsonrpc": "2.0", "method": "add", "params": [1, 2], "id": 1}'
+# JSON string in, JSON string out — the primary entry point for HTTP/socket integrations.
+# Returns nil for notifications (no response expected).
+json_response = Clamo::Server.handle(
+  request: '{"jsonrpc": "2.0", "method": "add", "params": [1, 2], "id": 1}',
+  object: MyService
+)
+# => '{"jsonrpc":"2.0","result":3,"id":1}'
+```
+
+If you need the parsed hash instead of a JSON string, use the lower-level methods:
+
+```ruby
+# From a JSON string
 response = Clamo::Server.unparsed_dispatch_to_object(
-  request: request_body,
+  request: '{"jsonrpc": "2.0", "method": "add", "params": [1, 2], "id": 1}',
   object: MyService
 )
+# => {jsonrpc: "2.0", result: 3, id: 1}
 
-puts response
-# => {"jsonrpc":"2.0","result":3,"id":1}
+# From a pre-parsed hash
+response = Clamo::Server.parsed_dispatch_to_object(
+  request: { "jsonrpc" => "2.0", "method" => "add", "params" => [1, 2], "id" => 1 },
+  object: MyService
+)
 ```
 
 ### Handling Different Parameter Types
@@ -88,7 +82,7 @@ batch_response = Clamo::Server.unparsed_dispatch_to_object(
 )
 
 puts batch_response
-# => [{"jsonrpc":"2.0","result":3,"id":1},{"jsonrpc":"2.0","result":2,"id":2}]
+# => [{jsonrpc: "2.0", result: 3, id: 1}, {jsonrpc: "2.0", result: 2, id: 2}]
 ```
 
 ### Notifications
@@ -118,7 +112,7 @@ request = Clamo::JSONRPC.build_request(
 )
 
 puts request
-# => {:jsonrpc=>"2.0", :method=>"add", :params=>[1, 2], :id=>1}
+# => {jsonrpc: "2.0", method: "add", params: [1, 2], id: 1}
 ```
 
 ## Error Handling
@@ -134,11 +128,32 @@ Clamo follows the JSON-RPC 2.0 specification for error handling:
 | -32603     | Internal error   | Internal JSON-RPC error                              |
 | -32000     | Server error     | Reserved for implementation-defined server errors    |
 
+## Configuration
+
+### Timeout
+
+Every method dispatch is wrapped in a timeout. The default is 30 seconds. Timed-out requests return a `-32000 Server error` response.
+
+```ruby
+Clamo::Server.timeout = 10  # seconds
+Clamo::Server.timeout = nil # disable timeout
+```
+
+### Error Callback
+
+Notifications don't return responses, so errors during notification dispatch are silent by default. Use `on_error` to capture them:
+
+```ruby
+Clamo::Server.on_error = ->(exception, method, params) {
+  Rails.logger.error("#{method} failed: #{exception.message}")
+}
+```
+
 ## Advanced Features
 
 ### Parallel Processing
 
-Batch requests are processed in parallel using the [parallel](https://github.com/grosser/parallel) gem. You can pass options to `Parallel.map` via the `parsed_dispatch_to_object` method:
+Batch requests are processed in parallel using the [parallel](https://github.com/grosser/parallel) gem. You can pass options to `Parallel.map`:
 
 ```ruby
 Clamo::Server.parsed_dispatch_to_object(
@@ -156,12 +171,8 @@ To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/clamo.
+Bug reports and pull requests are welcome on GitHub at https://github.com/rubakas/clamo.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).ne, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/rubakas/clamo
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/clamo/jsonrpc.rb

@@ -2,11 +2,8 @@
 
 module Clamo
   module JSONRPC
-    PROTOCOL_VERSION_PRAGMA = { jsonrpc: "2.0" }.freeze
-
     module ProtocolErrors
       ErrorDescriptor = Data.define(:code, :message)
-      SERVER_ERROR_CODE_RANGE = ((-32_099)..(-32_000))
 
       PARSE_ERROR       = ErrorDescriptor.new(code: -32_700, message: "Parse error")
       INVALID_REQUEST   = ErrorDescriptor.new(code: -32_600, message: "Invalid request")
@@ -17,27 +14,10 @@ module Clamo
     end
 
     class << self
-      def proper_pragma?(request)
-        request["jsonrpc"] == "2.0"
-      end
-
-      def proper_method?(request)
-        request["method"].is_a?(String)
-      end
-
-      def proper_id_if_any?(request)
-        if request.key?("id")
-          request["id"].is_a?(String) ||
-            request["id"].is_a?(Integer) ||
-            request["id"].is_a?(NilClass)
-        else
-          true
-        end
-      end
-
       def proper_params_if_any?(request)
-        if request.key?("params")
-          request["params"].is_a?(Array) || request["params"].is_a?(Hash)
+        if key_indifferent?(request, "params")
+          params = fetch_indifferent(request, "params")
+          params.is_a?(Array) || params.is_a?(Hash)
         else
           true
         end
@@ -50,28 +30,24 @@ module Clamo
           proper_id_if_any?(request)
       end
 
-      def valid_params?(request)
-        proper_params_if_any?(request)
-      end
+      def build_request(**opts)
+        raise ArgumentError, "method is required" unless opts.key?(:method)
 
-      def build_request **opts
-        # raise if no method present
-        # raise if params present, but not an array
-        { jsonrpc: "2.0",
-          method: opts[:method] }
-          .merge({ params: opts[:params] })
-          .merge(opts.key?(:id) ? { id: opts[:id] } : {})
+        validate_params_type!(opts[:params]) if opts.key?(:params)
+
+        { jsonrpc: "2.0", method: opts[:method] }
+          .then { |r| opts.key?(:params) ? r.merge(params: opts[:params]) : r }
+          .then { |r| opts.key?(:id) ? r.merge(id: opts[:id]) : r }
       end
 
       def build_result_response(id:, result:)
-        {}.merge(PROTOCOL_VERSION_PRAGMA)
-          .merge({ result: result })
-          .merge({ id: id })
+        { jsonrpc: "2.0", result: result, id: id }
       end
 
-      def build_error_response **opts
-        # raise if no error code present
-        # raise if no error message present
+      def build_error_response(**opts)
+        raise ArgumentError, "error code is required" unless opts.dig(:error, :code)
+        raise ArgumentError, "error message is required" unless opts.dig(:error, :message)
+
         { jsonrpc: "2.0",
           id: opts[:id],
           error: {
@@ -81,23 +57,57 @@ module Clamo
           }.reject { |k, _| k == :data && !opts[:error].key?(:data) } }
       end
 
-      def build_error_response_from **opts
-        # raise unless opts[:descriptor]
-        opts.merge(
-          { error:
-            { code: opts[:descriptor].code,
-              message: opts[:descriptor].message } }
+      def build_error_response_from(descriptor:, id: nil)
+        build_error_response(
+          id: id,
+          error: {
+            code: descriptor.code,
+            message: descriptor.message
+          }
         )
-            .then { |hash| build_error_response(**hash) }
       end
 
-      def build_error_response_parse_error **opts
-        opts.merge(
-          { error:
-            { code: ProtocolErrors::PARSE_ERROR.code,
-              message: ProtocolErrors::PARSE_ERROR.message } }
+      def build_error_response_parse_error
+        build_error_response(
+          id: nil,
+          error: {
+            code: ProtocolErrors::PARSE_ERROR.code,
+            message: ProtocolErrors::PARSE_ERROR.message
+          }
         )
-            .then { |hash| build_error_response(**hash) }
+      end
+
+      private
+
+      def proper_pragma?(request)
+        fetch_indifferent(request, "jsonrpc") == "2.0"
+      end
+
+      def proper_method?(request)
+        fetch_indifferent(request, "method").is_a?(String)
+      end
+
+      def proper_id_if_any?(request)
+        if key_indifferent?(request, "id")
+          id = fetch_indifferent(request, "id")
+          id.is_a?(String) || id.is_a?(Integer) || id.is_a?(NilClass)
+        else
+          true
+        end
+      end
+
+      def validate_params_type!(params)
+        return if params.is_a?(Array) || params.is_a?(Hash)
+
+        raise ArgumentError, "params must be an Array or Hash"
+      end
+
+      def fetch_indifferent(hash, key)
+        hash.fetch(key.to_s) { hash.fetch(key.to_sym, nil) }
+      end
+
+      def key_indifferent?(hash, key)
+        hash.key?(key.to_s) || hash.key?(key.to_sym)
       end
     end
   end

data/lib/clamo/server.rb

@@ -1,129 +1,182 @@
 # frozen_string_literal: true
 
 require "json"
+require "parallel"
+require "timeout"
 
 module Clamo
   module Server
     class << self
+      # Global error callback for notification failures.
+      # This is module-level state shared across all callers.
+      # Set to any callable (lambda, method, proc) that accepts (exception, method, params).
+      #
+      #   Clamo::Server.on_error = ->(e, method, params) { Rails.logger.error(e) }
+      #
+      attr_accessor :on_error
+
+      # Maximum seconds allowed for a single method dispatch. Defaults to 30.
+      # Set to nil to disable.
+      #
+      #   Clamo::Server.timeout = 10
+      #
+      attr_writer :timeout
+
+      def timeout
+        return @timeout if defined?(@timeout)
+
+        30
+      end
+
+      # JSON string in, JSON string out. Full round-trip for HTTP/socket integrations.
+      #
+      #   Clamo::Server.handle(request: body, object: MyService)
+      #
+      def handle(request:, object:, **)
+        response = unparsed_dispatch_to_object(request: request, object: object, **)
+        response&.to_json
+      end
+
       # Clamo::Server.unparsed_dispatch_to_object(
       #   request:  request_body,
       #   object:   MyModule
       # )
-      def unparsed_dispatch_to_object(request:, object:, **opts)
-        # TODO: raise unless object is present?
+      def unparsed_dispatch_to_object(request:, object:, **)
+        raise ArgumentError, "object is required" unless object
+
         begin
           parsed = JSON.parse(request)
-        rescue JSON::JSONError # TODO: any error
+        rescue JSON::JSONError
           return JSONRPC.build_error_response_parse_error
         end
 
-        parsed_dispatch_to_object(request: parsed, object: object, **opts)
+        parsed_dispatch_to_object(request: parsed, object: object, **)
       end
 
       def parsed_dispatch_to_object(request:, object:, **opts)
+        raise ArgumentError, "object is required" unless object
+
         response_for(request: request, object: object, **opts) do |method, params|
-          dispatch_to_ruby(
-            object: object,
-            method: method,
-            params: params # consider splating
-          )
+          dispatch_to_ruby(object: object, method: method, params: params)
         end
       end
 
+      private
+
       def method_known?(object:, method:)
-        (object.public_methods - Object.methods)
-          .map(&:to_sym)
-          .include?(method.to_sym)
+        object.public_methods(false).map(&:to_sym).include?(method.to_sym)
       end
 
       def dispatch_to_ruby(object:, method:, params:)
         case params
+        when Array    then object.public_send(method.to_sym, *params)
+        when Hash     then object.public_send(method.to_sym, **params.transform_keys(&:to_sym))
+        when NilClass then object.public_send(method.to_sym)
+        end
+      end
+
+      # Extra keyword arguments (**) are forwarded to response_for_batch only,
+      # where they become options for Parallel.map (e.g., in_processes: 4).
+      # For single requests they are silently ignored.
+      def response_for(request:, object:, **, &block)
+        case request
         when Array
-          object.send method.to_sym, *params
+          response_for_batch(request: request, object: object, block: block, **)
         when Hash
-          object.send method.to_sym, **params.transform_keys(&:to_sym)
-        when NilClass
-          object.send method.to_sym
+          response_for_single_request(request: request, object: object, block: block)
         else
-          # TODO: raise
-          raise "WTF"
+          JSONRPC.build_error_response_from(id: nil, descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST)
         end
       end
 
-      def response_for(request:, object:, **opts, &block)
-        case request
-        when Array # batch request
-          Parallel.map(request, **opts) do |item|
-            response_for_single_request(
-              request: item,
-              object: object,
-              block: block
-            )
-          end.compact
-        when Hash # single request
-          response_for_single_request(
-            request: request,
-            object: object,
-            block: block
-          )
-        else
-          JSONRPC.build_error_response_from(
-            id: nil,
-            descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST
-          )
+      def response_for_single_request(request:, object:, block:)
+        error = validate_request_structure(request)
+        return error if error
+
+        unless method_known?(object: object, method: request["method"])
+          return request.key?("id") ? method_not_found_error(request) : nil
         end
+
+        return dispatch_notification(request, block) unless request.key?("id")
+
+        dispatch_request(request, block)
       end
 
-      def yield_to_execution(block:, method:, params:)
-        block.yield method, params
+      def response_for_batch(request:, object:, block:, **opts)
+        if request.empty?
+          return JSONRPC.build_error_response_from(id: nil, descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST)
+        end
+
+        if request.size == 1
+          result = response_for_single_request(request: request.first, object: object, block: block)
+          return result ? [result] : nil
+        end
+
+        result = Parallel.map(request, **opts) do |item|
+          response_for_single_request(request: item, object: object, block: block)
+        end.compact
+        result.empty? ? nil : result
       end
 
-      def response_for_single_request(request:, object:, block:)
+      def validate_request_structure(request)
         unless JSONRPC.valid_request?(request)
           return JSONRPC.build_error_response_from(
-            id: request["id"],
+            id: request.is_a?(Hash) ? request["id"] : nil,
             descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST
           )
         end
 
-        unless JSONRPC.valid_params?(request)
-          return JSONRPC.build_error_response_from(
-            id: request["id"],
-            descriptor: JSONRPC::ProtocolErrors::INVALID_PARAMS
-          )
-        end
+        return if JSONRPC.proper_params_if_any?(request)
 
-        unless request.key?("id") # notification - no result needed
-          # TODO: block.call off the current thread
-          Thread.new do
-            yield_to_execution(
-              block: block,
-              method: request["method"],
-              params: request["params"]
-            )
-          rescue StandardError
-            # TODO: add exception handler
-            nil
-          end
-
-          return nil
-        end
+        # Notifications must never produce a response, even for invalid params
+        return nil unless request.key?("id")
 
-        unless method_known?(object: object, method: request["method"])
-          return JSONRPC.build_error_response_from(
-            id: request["id"],
-            descriptor: JSONRPC::ProtocolErrors::METHOD_NOT_FOUND
-          )
-        end
+        JSONRPC.build_error_response_from(id: request["id"], descriptor: JSONRPC::ProtocolErrors::INVALID_PARAMS)
+      end
 
+      def method_not_found_error(request)
+        JSONRPC.build_error_response_from(id: request["id"], descriptor: JSONRPC::ProtocolErrors::METHOD_NOT_FOUND)
+      end
+
+      def dispatch_notification(request, block)
+        with_timeout { block.yield request["method"], request["params"] }
+        nil
+      rescue StandardError => e
+        on_error&.call(e, request["method"], request["params"])
+        nil
+      end
+
+      def dispatch_request(request, block)
         JSONRPC.build_result_response(
           id: request["id"],
-          result: yield_to_execution(
-            block: block,
-            method: request["method"],
-            params: request["params"]
-          )
+          result: with_timeout { block.yield(request["method"], request["params"]) }
+        )
+      rescue Timeout::Error
+        JSONRPC.build_error_response(
+          id: request["id"],
+          error: {
+            code: JSONRPC::ProtocolErrors::SERVER_ERROR.code,
+            message: JSONRPC::ProtocolErrors::SERVER_ERROR.message,
+            data: "Request timed out"
+          }
         )
+      rescue StandardError => e
+        JSONRPC.build_error_response(
+          id: request["id"],
+          error: {
+            code: JSONRPC::ProtocolErrors::INTERNAL_ERROR.code,
+            message: JSONRPC::ProtocolErrors::INTERNAL_ERROR.message,
+            data: e.message
+          }
+        )
+      end
+
+      def with_timeout(&block)
+        if timeout
+          Timeout.timeout(timeout, &block)
+        else
+          block.call
+        end
       end
     end
   end

data/lib/clamo/version.rb

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

data/lib/clamo.rb

@@ -5,5 +5,4 @@ require_relative "clamo/jsonrpc"
 require_relative "clamo/server"
 
 module Clamo
-  # class Error < StandardError; end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: clamo
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Andriy Tyurnikov
 bindir: exe
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -15,15 +15,16 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.27.0
+        version: '1.27'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.27.0
-description: JSON-RPC Client/Server tooling for Ruby
+        version: '1.27'
+description: Minimal, spec-compliant JSON-RPC 2.0 server for Ruby with request validation,
+  method dispatch, batch processing, and notification support.
 email:
 - Andriy.Tyurnikov@gmail.com
 executables: []
@@ -31,21 +32,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE
 - README.md
 - 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
-- sig/clamo.rbs
 homepage: https://github.com/rubakas/clamo
-licenses: []
+licenses:
+- MIT
 metadata:
   homepage_uri: https://github.com/rubakas/clamo
   source_code_uri: https://github.com/rubakas/clamo
-  changelog_uri: https://github.com/rubakas/clamo
+  changelog_uri: https://github.com/rubakas/clamo/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -54,14 +55,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 4.0.3
 specification_version: 4
-summary: JSON-RPC Client/Server tooling for Ruby
+summary: JSON-RPC 2.0 server toolkit for Ruby
 test_files: []

data/lib/clamo/client.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class Client
-  ANSWER = 42
-end

data/lib/clamo/gpt_json_rpc_server.rb

@@ -1,186 +0,0 @@
-# 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/sig/clamo.rbs

@@ -1,4 +0,0 @@
-module Clamo
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end