feat: adjust to MethodNameFormatter concept

Author: chris-4chain

README.md

@@ -246,12 +246,24 @@ if err := client.Call(); err != nil {
 
 ## Options
 
-### Using `WithMethodNameFormatter`
+### Using `WithServerMethodNameFormatter`
+
+`WithServerMethodNameFormatter` allows you to customize a function that formats the JSON-RPC method name, given namespace and method name.
+
+There are three predefined formatters:
+- `jsonrpc.DefaultMethodNameFormatter` - default method name formatter, e.g. `SimpleServerHandler.AddGet`
+- `jsonrpc.NoNamespaceMethodNameFormatter` - method name formatter without namespace, e.g. `AddGet`
+- `jsonrpc.NoNamespaceDecapitalizedMethodNameFormatter` - method name formatter without namespace and decapitalized, e.g. `addGet`
+
+> [!NOTE]  
+> The default method name formatter concatenates the namespace and method name with a dot.
+> Go exported methods are capitalized, so, the method name will be capitalized as well.
+> e.g. `SimpleServerHandler.AddGet` (capital "A" in "AddGet")
 
 ```go
 func main() {
 	// create a new server instance with a custom separator
-	rpcServer := jsonrpc.NewServer(jsonrpc.WithMethodNameFormatter(
+	rpcServer := jsonrpc.NewServer(jsonrpc.WithServerMethodNameFormatter(
 		func(namespace, method string) string {
 			return namespace + "_" + method
 		}),
@@ -273,11 +285,28 @@ func main() {
 }
 ```
 
+### Using `WithMethodNameFormatter`
+
+`WithMethodNameFormatter` is the client-side counterpart to `WithServerMethodNameFormatter`.
+
+```go
+func main() {
+    closer, err := NewMergeClient(
+        context.Background(),
+        "http://example.com",
+        "SimpleServerHandler",
+        []any{&client},
+        nil,
+        WithMethodNameFormatter(test.namer),
+    )
+    defer closer()
+}
+```
 
 ## Contribute
 
 PRs are welcome!
 
 ## License
 
-Dual-licensed under [MIT](https://github.com/filecoin-project/go-jsonrpc/blob/master/LICENSE-MIT) + [Apache 2.0](https://github.com/filecoin-project/go-jsonrpc/blob/master/LICENSE-APACHE)
+Dual-licensed under [MIT](https://github.com/filecoin-project/go-jsonrpc/blob/master/LICENSE-MIT) + [Apache 2.0](https://github.com/filecoin-project/go-jsonrpc/blob/master/LICENSE-APACHE)

client.go

@@ -98,13 +98,14 @@ func NewClient(ctx context.Context, addr string, namespace string, handler inter
 
 type client struct {
 	namespace     string
-	methodNamer   MethodNamer
 	paramEncoders map[reflect.Type]ParamEncoder
 	errors        *Errors
 
 	doRequest func(context.Context, clientRequest) (clientResponse, error)
 	exiting   <-chan struct{}
 	idCtr     int64
+
+	methodNameFormatter MethodNameFormatter
 }
 
 // NewMergeClient is like NewClient, but allows to specify multiple structs
@@ -139,10 +140,10 @@ func NewCustomClient(namespace string, outs []interface{}, doRequest func(ctx co
 	}
 
 	c := client{
-		namespace:     namespace,
-		methodNamer:   config.methodNamer,
-		paramEncoders: config.paramEncoders,
-		errors:        config.errors,
+		namespace:           namespace,
+		methodNameFormatter: config.methodNamer,
+		paramEncoders:       config.paramEncoders,
+		errors:              config.errors,
 	}
 
 	stop := make(chan struct{})
@@ -194,10 +195,10 @@ func NewCustomClient(namespace string, outs []interface{}, doRequest func(ctx co
 
 func httpClient(ctx context.Context, addr string, namespace string, outs []interface{}, requestHeader http.Header, config Config) (ClientCloser, error) {
 	c := client{
-		namespace:     namespace,
-		methodNamer:   config.methodNamer,
-		paramEncoders: config.paramEncoders,
-		errors:        config.errors,
+		namespace:           namespace,
+		methodNameFormatter: config.methodNamer,
+		paramEncoders:       config.paramEncoders,
+		errors:              config.errors,
 	}
 
 	stop := make(chan struct{})
@@ -290,10 +291,10 @@ func websocketClient(ctx context.Context, addr string, namespace string, outs []
 	}
 
 	c := client{
-		namespace:     namespace,
-		methodNamer:   config.methodNamer,
-		paramEncoders: config.paramEncoders,
-		errors:        config.errors,
+		namespace:           namespace,
+		methodNameFormatter: config.methodNamer,
+		paramEncoders:       config.paramEncoders,
+		errors:              config.errors,
 	}
 
 	requests := c.setupRequestChan()
@@ -714,7 +715,7 @@ func (c *client) makeRpcFunc(f reflect.StructField) (reflect.Value, error) {
 		return reflect.Value{}, xerrors.New("handler field not a func")
 	}
 
-	name := c.methodNamer(c.namespace, f.Name)
+	name := c.methodNameFormatter(c.namespace, f.Name)
 	if tag, ok := f.Tag.Lookup(ProxyTagRPCMethod); ok {
 		name = tag
 	}

method_formatter.go

@@ -0,0 +1,26 @@
+package jsonrpc
+
+import "strings"
+
+// MethodNameFormatter is a function that takes a namespace and a method name and returns the full method name, sent via JSON-RPC.
+// This is useful if you want to customize the default behaviour, e.g. send without the namespace or make it lowercase.
+type MethodNameFormatter func(namespace, method string) string
+
+// DefaultMethodNameFormatter joins the namespace and method name with a dot.
+func DefaultMethodNameFormatter(namespace, method string) string {
+	return namespace + "." + method
+}
+
+// NoNamespaceMethodNameFormatter returns the method name as is, without the namespace.
+func NoNamespaceMethodNameFormatter(_, method string) string {
+	return method
+}
+
+// NoNamespaceDecapitalizedMethodNameFormatter returns the method name as is, without the namespace, and decapitalizes the first letter.
+// e.g. "Inc" -> "inc"
+func NoNamespaceDecapitalizedMethodNameFormatter(_, method string) string {
+	if len(method) == 0 {
+		return ""
+	}
+	return strings.ToLower(method[:1]) + method[1:]
+}

namer_test.go renamed to method_formatter_test.go

@@ -12,26 +12,26 @@ import (
 
 func TestDifferentMethodNamers(t *testing.T) {
 	tests := map[string]struct {
-		namer MethodNamer
+		namer MethodNameFormatter
 
 		requestedMethod string
 	}{
 		"default namer": {
-			namer:           DefaultMethodNamer,
+			namer:           DefaultMethodNameFormatter,
 			requestedMethod: "SimpleServerHandler.Inc",
 		},
 		"no namespace namer": {
-			namer:           NoNamespaceMethodNamer,
+			namer:           NoNamespaceMethodNameFormatter,
 			requestedMethod: "Inc",
 		},
 		"no namespace & decapitalized namer": {
-			namer:           NoNamespaceDecapitalizedMethodNamer,
+			namer:           NoNamespaceDecapitalizedMethodNameFormatter,
 			requestedMethod: "inc",
 		},
 	}
 	for name, test := range tests {
 		t.Run(name, func(t *testing.T) {
-			rpcServer := NewServer(WithServerMethodNamer(test.namer))
+			rpcServer := NewServer(WithServerMethodNameFormatter(test.namer))
 
 			serverHandler := &SimpleServerHandler{}
 			rpcServer.Register("SimpleServerHandler", serverHandler)
@@ -52,37 +52,37 @@ func TestDifferentMethodNamers(t *testing.T) {
 
 func TestDifferentMethodNamersWithClient(t *testing.T) {
 	tests := map[string]struct {
-		namer     MethodNamer
+		namer     MethodNameFormatter
 		urlPrefix string
 	}{
 		"default namer & http": {
-			namer:     DefaultMethodNamer,
+			namer:     DefaultMethodNameFormatter,
 			urlPrefix: "http://",
 		},
 		"default namer & ws": {
-			namer:     DefaultMethodNamer,
+			namer:     DefaultMethodNameFormatter,
 			urlPrefix: "ws://",
 		},
 		"no namespace namer & http": {
-			namer:     NoNamespaceMethodNamer,
+			namer:     NoNamespaceMethodNameFormatter,
 			urlPrefix: "http://",
 		},
 		"no namespace namer & ws": {
-			namer:     NoNamespaceMethodNamer,
+			namer:     NoNamespaceMethodNameFormatter,
 			urlPrefix: "ws://",
 		},
 		"no namespace & decapitalized namer & http": {
-			namer:     NoNamespaceDecapitalizedMethodNamer,
+			namer:     NoNamespaceDecapitalizedMethodNameFormatter,
 			urlPrefix: "http://",
 		},
 		"no namespace & decapitalized namer & ws": {
-			namer:     NoNamespaceDecapitalizedMethodNamer,
+			namer:     NoNamespaceDecapitalizedMethodNameFormatter,
 			urlPrefix: "ws://",
 		},
 	}
 	for name, test := range tests {
 		t.Run(name, func(t *testing.T) {
-			rpcServer := NewServer(WithServerMethodNamer(test.namer))
+			rpcServer := NewServer(WithServerMethodNameFormatter(test.namer))
 
 			serverHandler := &SimpleServerHandler{}
 			rpcServer.Register("SimpleServerHandler", serverHandler)
@@ -101,7 +101,7 @@ func TestDifferentMethodNamersWithClient(t *testing.T) {
 				[]any{&client},
 				nil,
 				WithHTTPClient(testServ.Client()),
-				WithMethodNamer(test.namer),
+				WithMethodNameFormatter(test.namer),
 			)
 			require.NoError(t, err)
 			defer closer()

namer.go

@@ -31,7 +31,7 @@ type Config struct {
 	noReconnect      bool
 	proxyConnFactory func(func() (*websocket.Conn, error)) func() (*websocket.Conn, error) // for testing
 
-	methodNamer MethodNamer
+	methodNamer MethodNameFormatter
 }
 
 func defaultConfig() Config {
@@ -49,7 +49,7 @@ func defaultConfig() Config {
 
 		httpClient: _defaultHTTPClient,
 
-		methodNamer: DefaultMethodNamer,
+		methodNamer: DefaultMethodNameFormatter,
 	}
 }
 
@@ -115,7 +115,7 @@ func WithHTTPClient(h *http.Client) func(c *Config) {
 	}
 }
 
-func WithMethodNamer(namer MethodNamer) func(c *Config) {
+func WithMethodNameFormatter(namer MethodNameFormatter) func(c *Config) {
 	return func(c *Config) {
 		c.methodNamer = namer
 	}

options.go

@@ -13,8 +13,6 @@ type jsonrpcReverseClient struct{ reflect.Type }
 
 type ParamDecoder func(ctx context.Context, json []byte) (reflect.Value, error)
 
-type MethodNameFormatter func(namespace, method string) string
-
 type ServerConfig struct {
 	maxRequestSize int64
 	pingInterval   time.Duration
@@ -34,10 +32,8 @@ func defaultServerConfig() ServerConfig {
 		paramDecoders:  map[reflect.Type]ParamDecoder{},
 		maxRequestSize: DEFAULT_MAX_REQUEST_SIZE,
 
-		pingInterval: 5 * time.Second,
-		methodNameFormatter: func(namespace, method string) string {
-			return namespace + "." + method
-		},
+		pingInterval:        5 * time.Second,
+		methodNameFormatter: DefaultMethodNameFormatter,
 	}
 }
 
@@ -65,7 +61,7 @@ func WithServerPingInterval(d time.Duration) ServerOption {
 	}
 }
 
-func WithMethodNameFormatter(formatter MethodNameFormatter) ServerOption {
+func WithServerMethodNameFormatter(formatter MethodNameFormatter) ServerOption {
 	return func(c *ServerConfig) {
 		c.methodNameFormatter = formatter
 	}
@@ -85,9 +81,9 @@ func WithReverseClient[RP any](namespace string) ServerOption {
 	return func(c *ServerConfig) {
 		c.reverseClientBuilder = func(ctx context.Context, conn *wsConn) (context.Context, error) {
 			cl := client{
-				namespace:     namespace,
-				methodNamer:   c.methodNamer,
-				paramEncoders: map[reflect.Type]ParamEncoder{},
+				namespace:           namespace,
+				methodNameFormatter: c.methodNameFormatter,
+				paramEncoders:       map[reflect.Type]ParamEncoder{},
 			}
 
 			// todo test that everything is closing correctly

options_server.go

@@ -1719,7 +1719,7 @@ func TestNewCustomClient(t *testing.T) {
 func TestReverseCallWithCustomMethodName(t *testing.T) {
 	// setup server
 
-	rpcServer := NewServer(WithMethodNameFormatter(func(namespace, method string) string { return namespace + "_" + method }))
+	rpcServer := NewServer(WithServerMethodNameFormatter(func(namespace, method string) string { return namespace + "_" + method }))
 	rpcServer.Register("Server", &RawParamHandler{})
 
 	// httptest stuff