jsonrpc-rails 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ca6d0bdf5ffc4f71a7be0e4669bad7bd1a215a647d9e5604be69b40caa86acd
-  data.tar.gz: 27359e3bc0eeaab09c659fd618f20eb15448293180d4f437fd0cd1deff1584ef
+  metadata.gz: 439108bab45d71dabc7ca40fa35042cdaecd7f3dc6988bc3a13fb0d825ef38ac
+  data.tar.gz: 34142d82edff4b8099610d44ca19bc039571fbcc0651a44c24588047a141838a
 SHA512:
-  metadata.gz: fc155ba77be68184eaeefc330a0f1829e5c0854da1cce49b7abddc870cbc158eccac3881d0bf4d00af932609aae4b84abd99868761d2ccb074840456c9d6e0b8
-  data.tar.gz: 866302ed5d32d518fbd3fc6be6cfd34c7a0e7d3f4e4466cd96cb99a102ab5795b9f29a14501e3ed96332e22472892d764087fc0668898e11dbe2fb90b9ff16ab
+  metadata.gz: a9b228edf10da4b05019c87643079e3ebe673fb98913dfba6567877293c28e8d2fd3a6507174d2aec8010d8254bab551631b38ac20e3784281773b4546bafb16
+  data.tar.gz: 3a4cbec99a1dd380a32263d6db57b4550f030aa50c67f29af3b8b25f827dc7d8a5c2be600e282426f36b826a82d393d2a61adda782040aeb0a44f76a455d96ba

data/lib/jsonrpc_rails/railtie.rb

@@ -1,72 +1,97 @@
 # frozen_string_literal: true
 
+# lib/jsonrpc_rails/railtie.rb
 require_relative "middleware/validator"
 
 module JSONRPC_Rails
-  # Use Rails::Railtie to integrate with the Rails application
   class Railtie < Rails::Railtie
     config.jsonrpc_rails = ActiveSupport::OrderedOptions.new
-    config.jsonrpc_rails.validated_paths = [] # By default, we inject it into the void.
-    # Insert the JSON-RPC Validator middleware early in the stack.
+    config.jsonrpc_rails.validated_paths = []
+
     initializer "jsonrpc-rails.add_validator_middleware" do |app|
       app.middleware.use JSONRPC_Rails::Middleware::Validator
     end
 
+    # -----------------------------------------------------------------------
+    # Renderer
+    # -----------------------------------------------------------------------
     initializer "jsonrpc-rails.add_renderers" do
       ActiveSupport.on_load(:action_controller) do
         ActionController::Renderers.add :jsonrpc do |obj, options|
-          # Use the Response class to build the payload
-          response_id = options[:id] # ID is required for Response
-          error_input = options[:error] # Can be nil, Symbol, Hash, or JsonRpcError
-          payload_obj = obj # The main object passed to render
+          response_id = options[:id]
+          error_opt = options[:error]
 
           begin
-            response_obj = case error_input
-            when Symbol
-                             # Build error from symbol, allowing overrides from payload_obj
-                             message_override = payload_obj.is_a?(Hash) ? payload_obj[:message] : nil
-                             data_override = payload_obj.is_a?(Hash) ? payload_obj[:data] : nil
-                             error_hash = JSON_RPC::JsonRpcError.build(error_input, message: message_override,
-                                                                                    data: data_override)
-                             JSON_RPC::Response.new(id: response_id, error: error_hash)
-            when Integer
-                             # Build error from numeric code, allowing overrides from payload_obj
-                             error_code = error_input
-                             default_details = JSON_RPC::JsonRpcError.find_by_code(error_code)
-                             message_override = payload_obj.is_a?(Hash) ? payload_obj[:message] : nil
-                             data_override = payload_obj.is_a?(Hash) ? payload_obj[:data] : nil
-                             error_hash = {
-                               code: error_code,
-                               message: message_override || default_details&.fetch(:message, "Unknown error") # Use override, default, or generic
-                             }
-                             error_hash[:data] = data_override if data_override
-                             JSON_RPC::Response.new(id: response_id, error: error_hash)
-            when ->(ei) { ei } # Catch any other truthy value
-                             raise ArgumentError,
-                                   "The :error option for render :jsonrpc must be a Symbol or an Integer, got: #{error_input.inspect}"
-            # # Original logic (removed): Treat payload_obj as the error hash
-            # JSON_RPC::Response.new(id: response_id, error: payload_obj)
-            else # Falsy (nil, false)
-                             # Treat payload_obj as the result
-                             JSON_RPC::Response.new(id: response_id, result: payload_obj)
-            end
-            response_payload = response_obj.to_h
+            payload =
+              case obj
+                # ─── Already JSON-RPC objects ───────────────────────────────
+              when JSON_RPC::Response,
+                JSON_RPC::Request,
+                JSON_RPC::Notification
+                obj.to_h
+
+                # ─── Batch of objects ──────────────────────────────────────
+              when Array
+                unless obj.all? { |o| o.is_a?(JSON_RPC::Response) ||
+                  o.is_a?(JSON_RPC::Request) ||
+                  o.is_a?(JSON_RPC::Notification) }
+                  raise ArgumentError, "Batch contains non-JSON-RPC objects"
+                end
+                obj.map(&:to_h)
+
+                # ─── Legacy “result + :error” path ─────────────────────────
+              else
+                case error_opt
+                when nil, false
+                  JSON_RPC::Response.new(id: response_id,
+                                         result: obj).to_h
+
+                when Symbol
+                  msg = obj.is_a?(Hash) ? obj[:message] : nil
+                  dat = obj.is_a?(Hash) ? obj[:data] : nil
+                  err = JSON_RPC::JsonRpcError.build(error_opt,
+                                                     message: msg,
+                                                     data: dat)
+                  JSON_RPC::Response.new(id: response_id,
+                                         error: err).to_h
+
+                when Integer
+                  defaults = JSON_RPC::JsonRpcError.find_by_code(error_opt)
+                  msg = obj.is_a?(Hash) ? obj[:message] : nil
+                  msg ||= defaults&.fetch(:message, "Unknown error")
+
+                  dat = obj.is_a?(Hash) ? obj[:data] : nil
+                  hash = { code: error_opt, message: msg }
+                  hash[:data] = dat if dat
+                  JSON_RPC::Response.new(id: response_id,
+                                         error: hash).to_h
+
+                when JSON_RPC::JsonRpcError
+                  JSON_RPC::Response.new(id: response_id,
+                                         error: error_opt.to_h).to_h
+
+                when Hash
+                  JSON_RPC::Response.new(id: response_id,
+                                         error: error_opt).to_h
+
+                else
+                  raise ArgumentError,
+                        ":error must be Symbol, Integer, Hash, or JSON_RPC::JsonRpcError " \
+                          "(got #{error_opt.class})"
+                end
+              end
+
           rescue ArgumentError => e
-            # Handle cases where Response initialization fails (e.g., invalid id/result/error combo)
-            # Respond with an Internal Error according to JSON-RPC spec
-            internal_error = JSON_RPC::JsonRpcError.new(:internal_error,
-                                                        message: "Server error generating response: #{e.message}")
-            response_payload = { jsonrpc: "2.0", error: internal_error.to_h, id: response_id }
-            # Consider logging the error e.message
+            internal = JSON_RPC::JsonRpcError.new(:internal_error,
+                                                  message: "Server error: #{e.message}")
+            payload = { jsonrpc: "2.0", error: internal.to_h, id: response_id }
+
           rescue JSON_RPC::JsonRpcError => e
-            # Handle specific JsonRpcError during Response processing (e.g., invalid error symbol)
-            response_payload = { jsonrpc: "2.0", error: e.to_h, id: response_id }
-            # Consider logging the error e.message
+            payload = { jsonrpc: "2.0", error: e.to_h, id: response_id }
           end
 
-          # Set the proper MIME type and convert the hash to JSON.
           self.content_type ||= Mime[:json]
-          self.response_body = response_payload.to_json
+          self.response_body = payload.to_json
         end
       end
     end

data/lib/jsonrpc_rails/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonrpc-rails
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Abdelkader Boudih