ft: add a common name formatter

Author: raul0ligma

README.md

@@ -1,5 +1,4 @@
-go-jsonrpc
-==================
+# go-jsonrpc
 
 [![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/filecoin-project/go-jsonrpc)
 [![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](https://protocol.ai)
@@ -24,41 +23,42 @@ func (h *SimpleServerHandler) AddGet(in int) int {
 func main() {
     // create a new server instance
     rpcServer := jsonrpc.NewServer()
-    
+
     // create a handler instance and register it
     serverHandler := &SimpleServerHandler{}
     rpcServer.Register("SimpleServerHandler", serverHandler)
-    
+
     // rpcServer is now http.Handler which will serve jsonrpc calls to SimpleServerHandler.AddGet
     // a method with a single int param, and an int response. The server supports both http and websockets.
-    
+
     // serve the api
     testServ := httptest.NewServer(rpcServer)
     defer testServ.Close()
-	
+
     fmt.Println("URL: ", "ws://"+testServ.Listener.Addr().String())
-    
+
     [..do other app stuff / wait..]
 }
 ```
 
 ### Client
+
 ```go
 func start() error {
     // Create a struct where each field is an exported function with signatures matching rpc calls
     var client struct {
         AddGet      func(int) int
     }
-	
+
 	// Make jsonrp populate func fields in the struct with JSONRPC calls
     closer, err := jsonrpc.NewClient(context.Background(), rpcURL, "SimpleServerHandler", &client, nil)
     if err != nil {
     	return err
     }
     defer closer()
-    
+
     ...
-    
+
     n := client.AddGet(10)
     // if the server is the one from the example above, n = 10
 
@@ -73,28 +73,28 @@ func start() error {
 type _ interface {
     // No Params / Return val
     Func1()
-    
+
     // With Params
     // Note: If param types implement json.[Un]Marshaler, go-jsonrpc will use it
     Func2(param1 int, param2 string, param3 struct{A int})
-    
+
     // Returning errors
     // * For some connection errors, go-jsonrpc will return jsonrpc.RPCConnectionError{}.
     // * RPC-returned errors will be constructed with basic errors.New(__"string message"__)
     // * JSON-RPC error codes can be mapped to typed errors with jsonrpc.Errors - https://pkg.go.dev/github.com/filecoin-project/go-jsonrpc#Errors
     // * For typed errors to work, server needs to be constructed with the `WithServerErrors`
     //   option, and the client needs to be constructed with the `WithErrors` option
     Func3() error
-    
+
     // Returning a value
     // Note: The value must be serializable with encoding/json.
     Func4() int
-    
+
     // Returning a value and an error
     // Note: if the handler returns an error and a non-zero value, the value will not
     //       be returned to the client - the client will see a zero value.
     Func4() (int, error)
-    
+
     // With context
     // * Context isn't passed as JSONRPC param, instead it has a number of different uses
     // * When the context is cancelled on the client side, context cancellation should propagate to the server handler
@@ -103,9 +103,9 @@ type _ interface {
     // * If the context contains an opencensus trace span, it will be propagated to the server through a
     //   `"Meta": {"SpanContext": base64.StdEncoding.EncodeToString(propagation.Binary(span.SpanContext()))}` field in
     //   the jsonrpc request
-    //   
+    //
     Func5(ctx context.Context, param1 string) error
-    
+
     // With non-json-serializable (e.g. interface) params
     // * There are client and server options which make it possible to register transformers for types
     //   to make them json-(de)serializable
@@ -115,7 +115,7 @@ type _ interface {
     //   which will pass reader data through separate http streams on a different hanhler.
     // * Note: a similar mechanism for return value transformation isn't supported yet
     Func6(r io.Reader)
-    
+
     // Returning a channel
     // * Only supported in websocket mode
     // * If no error is returned, the return value will be an int channelId
@@ -132,12 +132,13 @@ type _ interface {
 ```
 
 ### Custom Transport Feature
+
 The go-jsonrpc library supports creating clients with custom transport mechanisms (e.g. use for IPC). This allows for greater flexibility in how requests are sent and received, enabling the use of custom protocols, special handling of requests, or integration with other systems.
 
 #### Example Usage of Custom Transport
 
 Here is an example demonstrating how to create a custom client with a custom transport mechanism:
-    
+
 ```go
 // Setup server
 serverHandler := &SimpleServerHandler{} // some type with methods
@@ -175,6 +176,7 @@ fmt.Printf("Current value: %d\n", client.AddGet(5))
 ```
 
 ### Reverse Calling Feature
+
 The go-jsonrpc library also supports reverse calling, where the server can make calls to the client. This is useful in scenarios where the server needs to notify or request data from the client.
 
 NOTE: Reverse calling only works in websocket mode
@@ -244,49 +246,31 @@ if err := client.Call(); err != nil {
 }
 ```
 
-## Options 
+## Options
 
+### Using `WithMethodNameFormatter`
 
-### Using `WithNamespaceSeparator`
-```go 
+```go
 func main() {
-    // create a new server instance with a custom namespace separator
-    rpcServer := jsonrpc.NewServer(jsonrpc.WithNamespaceSeparator("_"))
-    
-    // create a handler instance and register it
-    serverHandler := &SimpleServerHandler{}
-    rpcServer.Register("SimpleServerHandler", serverHandler)
-    
-    // serve the api
-    testServ := httptest.NewServer(rpcServer)
-    defer testServ.Close()
-    
-    fmt.Println("URL: ", "ws://"+testServ.Listener.Addr().String())
+	// create a new server instance with a custom separator
+	rpcServer := jsonrpc.NewServer(jsonrpc.WithMethodNameFormatter(
+		func(namespace, method string) string {
+			return namespace + "_" + method
+		}),
+	)
 
-    // rpc method becomes SimpleServerHandler_AddGet
-    
-    [..do other app stuff / wait..]
-}
-```
+	// create a handler instance and register it
+	serverHandler := &SimpleServerHandler{}
+	rpcServer.Register("SimpleServerHandler", serverHandler)
 
-### Using `WithMethodNameTransformer`
-```go
-func main() {
-    // create a new server instance with a custom method transformer
-    rpcServer := jsonrpc.NewServer(jsonrpc.WithMethodNameTransformer(toSnakeCase))
-    
-    // create a handler instance and register it
-    serverHandler := &SimpleServerHandler{}
-    rpcServer.Register("SimpleServerHandler", serverHandler)
-    
-    // serve the api
-    testServ := httptest.NewServer(rpcServer)
-    defer testServ.Close()
-    
-    fmt.Println("URL: ", "ws://"+testServ.Listener.Addr().String())
+	// serve the api
+	testServ := httptest.NewServer(rpcServer)
+	defer testServ.Close()
+
+	fmt.Println("URL: ", "ws://"+testServ.Listener.Addr().String())
+
+	// rpc method becomes SimpleServerHandler_AddGet
 
-    // rpc method becomes SimpleServerHandler.add_get
-    
     [..do other app stuff / wait..]
 }
 ```

handler.go

@@ -77,10 +77,9 @@ type handler struct {
 
 	paramDecoders map[reflect.Type]ParamDecoder
 
-	methodNameTransformer MethodNameTransformer
+	methodNameFormatter MethodNameFormatter
 
-	tracer    Tracer
-	separator string
+	tracer Tracer
 }
 
 type Tracer func(method string, params []reflect.Value, results []reflect.Value, err error)
@@ -93,12 +92,11 @@ func makeHandler(sc ServerConfig) *handler {
 		aliasedMethods: map[string]string{},
 		paramDecoders:  sc.paramDecoders,
 
-		methodNameTransformer: sc.methodNameTransformer,
+		methodNameFormatter: sc.methodNameFormatter,
 
 		maxRequestSize: sc.maxRequestSize,
 
-		tracer:    sc.tracer,
-		separator: sc.separator,
+		tracer: sc.tracer,
 	}
 }
 
@@ -131,11 +129,8 @@ func (s *handler) register(namespace string, r interface{}) {
 		}
 
 		valOut, errOut, _ := processFuncOut(funcType)
-		if s.methodNameTransformer != nil {
-			method.Name = s.methodNameTransformer(method.Name)
-		}
 
-		s.methods[namespace+s.separator+method.Name] = methodHandler{
+		s.methods[s.methodNameFormatter(namespace, method.Name)] = methodHandler{
 			paramReceivers: recvs,
 			nParams:        ins,
 

options_server.go

@@ -13,9 +13,7 @@ type jsonrpcReverseClient struct{ reflect.Type }
 
 type ParamDecoder func(ctx context.Context, json []byte) (reflect.Value, error)
 
-type MethodNameTransformer func(string) string
-
-const defaultSeparator = "."
+type MethodNameFormatter func(namespace string, method string) string
 
 type ServerConfig struct {
 	maxRequestSize int64
@@ -24,10 +22,9 @@ type ServerConfig struct {
 	paramDecoders map[reflect.Type]ParamDecoder
 	errors        *Errors
 
-	reverseClientBuilder  func(context.Context, *wsConn) (context.Context, error)
-	tracer                Tracer
-	methodNameTransformer MethodNameTransformer
-	separator             string
+	reverseClientBuilder func(context.Context, *wsConn) (context.Context, error)
+	tracer               Tracer
+	methodNameFormatter  MethodNameFormatter
 }
 
 type ServerOption func(c *ServerConfig)
@@ -38,7 +35,9 @@ func defaultServerConfig() ServerConfig {
 		maxRequestSize: DEFAULT_MAX_REQUEST_SIZE,
 
 		pingInterval: 5 * time.Second,
-		separator:    defaultSeparator,
+		methodNameFormatter: func(namespace, method string) string {
+			return namespace + "." + method
+		},
 	}
 }
 
@@ -66,15 +65,9 @@ func WithServerPingInterval(d time.Duration) ServerOption {
 	}
 }
 
-func WithNamespaceSeparator(separator string) ServerOption {
-	return func(c *ServerConfig) {
-		c.separator = separator
-	}
-}
-
-func WithMethodNameTransformer(methodNameTransformer MethodNameTransformer) ServerOption {
+func WithMethodNameFormatter(formatter MethodNameFormatter) ServerOption {
 	return func(c *ServerConfig) {
-		c.methodNameTransformer = methodNameTransformer
+		c.methodNameFormatter = formatter
 	}
 }
 

rpc_test.go

@@ -12,7 +12,6 @@ import (
 	"net/http/httptest"
 	"os"
 	"reflect"
-	"regexp"
 	"strconv"
 	"strings"
 	"sync"
@@ -1717,10 +1716,10 @@ func TestNewCustomClient(t *testing.T) {
 	require.Equal(t, int32(13), serverHandler.n)
 }
 
-func TestReverseCallWithCustomSeparator(t *testing.T) {
+func TestReverseCallWithCustomMethodName(t *testing.T) {
 	// setup server
 
-	rpcServer := NewServer(WithNamespaceSeparator("_"))
+	rpcServer := NewServer(WithMethodNameFormatter(func(namespace, method string) string { return namespace + "_" + method }))
 	rpcServer.Register("Server", &RawParamHandler{})
 
 	// httptest stuff
@@ -1750,37 +1749,3 @@ type MethodTransformedHandler struct{}
 func (h *RawParamHandler) CallSomethingInSnakeCase(ctx context.Context, v int) (int, error) {
 	return v + 1, nil
 }
-
-func TestCallWithMethodTransformer(t *testing.T) {
-	// setup server
-
-	var matchFirstCap = regexp.MustCompile("(.)([A-Z][a-z]+)")
-	var matchAllCap = regexp.MustCompile("([a-z0-9])([A-Z])")
-
-	rpcServer := NewServer(WithMethodNameTransformer(func(method string) string {
-		snake := matchFirstCap.ReplaceAllString(method, "${1}_${2}")
-		snake = matchAllCap.ReplaceAllString(snake, "${1}_${2}")
-		return strings.ToLower(snake)
-	}))
-	rpcServer.Register("Raw", &RawParamHandler{})
-
-	// httptest stuff
-	testServ := httptest.NewServer(rpcServer)
-	defer testServ.Close()
-
-	// setup client
-	var client struct {
-		Call func(ctx context.Context, v int) (int, error) `rpc_method:"Raw.call_something_in_snake_case"`
-	}
-	closer, err := NewMergeClient(context.Background(), "ws://"+testServ.Listener.Addr().String(), "Raw", []interface{}{
-		&client,
-	}, nil)
-	require.NoError(t, err)
-
-	// this will block if it's not sent as a notification
-	n, err := client.Call(context.Background(), 6)
-	require.NoError(t, err)
-	require.Equal(t, 7, n)
-
-	closer()
-}