RPC method is always defined.

Author: samuel-williams-shopify

lib/protocol/grpc/interface.rb

@@ -7,16 +7,16 @@
 
 module Protocol
 	module GRPC
-		# RPC method definition
-		RPC = Struct.new(:request_class, :response_class, :streaming, :method, keyword_init: true) do
-			def initialize(request_class:, response_class:, streaming: :unary, method: nil)
-				super
-			end
-		end
-		
 		# Represents an interface definition for gRPC methods.
 		# Can be used by both client stubs and server implementations.
 		class Interface
+			# RPC method definition
+			RPC = Struct.new(:request_class, :response_class, :streaming, :method, keyword_init: true) do
+				def initialize(request_class:, response_class:, streaming: :unary, method: nil)
+					super
+				end
+			end
+			
 			# Hook called when a subclass is created.
 			# Initializes the RPC hash for the subclass.
 			# @parameter subclass [Class] The subclass being created
@@ -33,6 +33,9 @@ def self.inherited(subclass)
 			# @parameter streaming [Symbol] Streaming type (:unary, :server_streaming, :client_streaming, :bidirectional)
 			# @parameter method [Symbol | Nil] Optional explicit Ruby method name (snake_case). If not provided, automatically converts PascalCase to snake_case.
 			def self.rpc(name, **options)
+				# Ensure snake_case method name is always available
+				options[:method] ||= pascal_case_to_snake_case(name.to_s).to_sym
+				
 				@rpcs[name] = RPC.new(**options)
 			end
 
@@ -44,12 +47,15 @@ def self.lookup_rpc(name)
 				klass = self
 				while klass && klass != Interface
 					if klass.instance_variable_defined?(:@rpcs)
-						rpc = klass.instance_variable_get(:@rpcs)[name]
-						return rpc if rpc
+						if rpc = klass.instance_variable_get(:@rpcs)[name]
+							return rpc
+						end
 					end
 					klass = klass.superclass
 				end
-				nil
+				
+				# Not found:
+				return nil
 			end
 
 			# Get all RPC definitions from this class and all parent classes.
@@ -69,21 +75,33 @@ def self.rpcs
 				all_rpcs
 			end
 
-			# @attribute [String] The service name (e.g., "hello.Greeter").
-			attr :name
-			
 			# Initialize a new interface instance.
 			# @parameter name [String] Service name
 			def initialize(name)
 				@name = name
 			end
 
+			# @attribute [String] The service name (e.g., "hello.Greeter").
+			attr :name
+			
 			# Build gRPC path for a method.
 			# @parameter method_name [String, Symbol] Method name in PascalCase (e.g., :SayHello)
 			# @returns [String] gRPC path with PascalCase method name
 			def path(method_name)
 				Methods.build_path(@name, method_name.to_s)
 			end
+			
+		private
+			
+			# Convert PascalCase to snake_case.
+			# @parameter pascal_case [String] PascalCase string (e.g., "SayHello")
+			# @returns [String] snake_case string (e.g., "say_hello")
+			def self.pascal_case_to_snake_case(pascal_case)
+				pascal_case
+					.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')  # Insert underscore before capital letters followed by lowercase
+					.gsub(/([a-z\d])([A-Z])/, '\1_\2')      # Insert underscore between lowercase/digit and uppercase
+					.downcase
+			end
 		end
 	end
-end
+end

releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## Unreleased
+
+  - `RCP#method` is always defined (snake case).
+
 ## v0.1.0
 
   - Initial design.

test/protocol/grpc/interface.rb

@@ -10,11 +10,11 @@
 	let(:response_class) {Class.new}
 
 	it "can define and retrieve RPC methods" do
-		req_class = request_class
-		res_class = response_class
+		request_class = self.request_class
+		response_class = self.response_class
 
 		interface_class = Class.new(Protocol::GRPC::Interface) do
-			rpc :say_hello, request_class: req_class, response_class: res_class
+			rpc :say_hello, request_class: request_class, response_class: response_class
 		end
 
 		rpc = interface_class.lookup_rpc(:say_hello)
@@ -30,12 +30,12 @@
 	end
 
 	it "can retrieve all RPCs" do
-		req_class = request_class
-		res_class = response_class
+		request_class = self.request_class
+		response_class = self.response_class
 
 		interface_class = Class.new(Protocol::GRPC::Interface) do
-			rpc :method1, request_class: req_class, response_class: res_class
-			rpc :method2, request_class: req_class, response_class: res_class, streaming: :server_streaming
+			rpc :method1, request_class: request_class, response_class: response_class
+			rpc :method2, request_class: request_class, response_class: response_class, streaming: :server_streaming
 		end
 
 		rpcs = interface_class.rpcs
@@ -45,15 +45,15 @@
 	end
 
 	it "inherits RPCs from parent class" do
-		req_class = request_class
-		res_class = response_class
+		request_class = self.request_class
+		response_class = self.response_class
 
 		base_class = Class.new(Protocol::GRPC::Interface) do
-			rpc :base_method, request_class: req_class, response_class: res_class
+			rpc :base_method, request_class: request_class, response_class: response_class
 		end
 
 		subclass = Class.new(base_class) do
-			rpc :sub_method, request_class: req_class, response_class: res_class
+			rpc :sub_method, request_class: request_class, response_class: response_class
 		end
 
 		# Subclass should have both methods
@@ -71,13 +71,13 @@
 	end
 
 	it "can override RPCs in subclass" do
-		req_class = request_class
-		res_class = response_class
+		request_class = self.request_class
+		response_class = self.response_class
 		other_request_class = Class.new
 		other_response_class = Class.new
 
 		base_class = Class.new(Protocol::GRPC::Interface) do
-			rpc :method, request_class: req_class, response_class: res_class
+			rpc :method, request_class: request_class, response_class: response_class
 		end
 
 		subclass = Class.new(base_class) do
@@ -98,19 +98,19 @@
 	end
 
 	it "supports multiple levels of inheritance" do
-		req_class = request_class
-		res_class = response_class
+		request_class = self.request_class
+		response_class = self.response_class
 
 		level1 = Class.new(Protocol::GRPC::Interface) do
-			rpc :level1_method, request_class: req_class, response_class: res_class
+			rpc :level1_method, request_class: request_class, response_class: response_class
 		end
 
 		level2 = Class.new(level1) do
-			rpc :level2_method, request_class: req_class, response_class: res_class
+			rpc :level2_method, request_class: request_class, response_class: response_class
 		end
 
 		level3 = Class.new(level2) do
-			rpc :level3_method, request_class: req_class, response_class: res_class
+			rpc :level3_method, request_class: request_class, response_class: response_class
 		end
 
 		# Level 3 should have all methods
@@ -130,15 +130,15 @@
 	end
 
 	it "maintains separate RPC definitions for different classes" do
-		req_class = request_class
-		res_class = response_class
+		request_class = self.request_class
+		response_class = self.response_class
 
 		class1 = Class.new(Protocol::GRPC::Interface) do
-			rpc :method1, request_class: req_class, response_class: res_class
+			rpc :method1, request_class: request_class, response_class: response_class
 		end
 
 		class2 = Class.new(Protocol::GRPC::Interface) do
-			rpc :method2, request_class: req_class, response_class: res_class
+			rpc :method2, request_class: request_class, response_class: response_class
 		end
 
 		# Each class should only have its own RPCs
@@ -150,20 +150,102 @@
 	end
 
 	it "supports explicit method name in RPC definition" do
-		req_class = request_class
-		res_class = response_class
+		request_class = self.request_class
+		response_class = self.response_class
 
 		# Create interface with explicit method name
 		explicit_interface = Class.new(Protocol::GRPC::Interface) do
-			rpc :XMLParser, request_class: req_class, response_class: res_class,
+			rpc :XMLParser, request_class: request_class, response_class: response_class,
 				method: :xml_parser
 		end
 
 		rpc = explicit_interface.lookup_rpc(:XMLParser)
-		expect(rpc).to be_a(Protocol::GRPC::RPC)
+		expect(rpc).to be_a(Protocol::GRPC::Interface::RPC)
 		expect(rpc.method).to be == :xml_parser
-		expect(rpc.request_class).to be == req_class
-		expect(rpc.response_class).to be == res_class
+		expect(rpc.request_class).to be == request_class
+		expect(rpc.response_class).to be == response_class
+	end
+	
+	with "method field auto-conversion" do
+		it "always sets method field when not explicitly provided" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :SayHello, request_class: request_class, response_class: response_class
+			end
+			
+			rpc = interface_class.lookup_rpc(:SayHello)
+			expect(rpc.method).not.to be_nil
+			expect(rpc.method).to be == :say_hello
+		end
+		
+		it "converts PascalCase to snake_case correctly" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :SayHello, request_class: request_class, response_class: response_class
+				rpc :UnaryCall, request_class: request_class, response_class: response_class
+				rpc :ServerStreamingCall, request_class: request_class, response_class: response_class
+				rpc :XMLParser, request_class: request_class, response_class: response_class
+			end
+			
+			expect(interface_class.lookup_rpc(:SayHello).method).to be == :say_hello
+			expect(interface_class.lookup_rpc(:UnaryCall).method).to be == :unary_call
+			expect(interface_class.lookup_rpc(:ServerStreamingCall).method).to be == :server_streaming_call
+			expect(interface_class.lookup_rpc(:XMLParser).method).to be == :xml_parser
+		end
+		
+		it "uses explicit method name when provided" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :SayHello, request_class: request_class, response_class: response_class,
+					method: :greet_user
+				rpc :XMLParser, request_class: request_class, response_class: response_class,
+					method: :parse_xml
+			end
+			
+			expect(interface_class.lookup_rpc(:SayHello).method).to be == :greet_user
+			expect(interface_class.lookup_rpc(:XMLParser).method).to be == :parse_xml
+		end
+		
+		it "ensures method field is never nil" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :SayHello, request_class: request_class, response_class: response_class
+				rpc :UnaryCall, request_class: request_class, response_class: response_class,
+					method: :unary_call
+			end
+			
+			# Both should have method set
+			rpc1 = interface_class.lookup_rpc(:SayHello)
+			rpc2 = interface_class.lookup_rpc(:UnaryCall)
+			
+			expect(rpc1.method).not.to be_nil
+			expect(rpc2.method).not.to be_nil
+			expect(rpc1.method).to be_a(Symbol)
+			expect(rpc2.method).to be_a(Symbol)
+		end
+		
+		it "handles edge cases in PascalCase conversion" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :HTTPRequest, request_class: request_class, response_class: response_class
+				rpc :XMLHTTPRequest, request_class: request_class, response_class: response_class
+				rpc :GetUserByID, request_class: request_class, response_class: response_class
+			end
+			
+			expect(interface_class.lookup_rpc(:HTTPRequest).method).to be == :http_request
+			expect(interface_class.lookup_rpc(:XMLHTTPRequest).method).to be == :xmlhttp_request
+			expect(interface_class.lookup_rpc(:GetUserByID).method).to be == :get_user_by_id
+		end
 	end
 end