Add MergeSpecs and use variadic args for NewSpec (#5)

Author: bufdev

Makefile

@@ -12,8 +12,8 @@ export GOBIN := $(abspath $(BIN))
 COPYRIGHT_YEARS := 2024
 LICENSE_IGNORE := --ignore /testdata/
 
-BUF_VERSION := v1.39.0
-GO_MOD_GOTOOLCHAIN := go1.23.0
+BUF_VERSION := v1.42.0
+GO_MOD_GOTOOLCHAIN := go1.23.1
 GOLANGCI_LINT_VERSION := v1.60.1
 # https://github.com/golangci/golangci-lint/issues/4837
 GOLANGCI_LINT_GOTOOLCHAIN := $(GO_MOD_GOTOOLCHAIN)

cmd/protoc-gen-pluginrpc-go/main.go

@@ -300,7 +300,7 @@ func generateSpecBuilder(g *protogen.GeneratedFile, service *protogen.Service, n
 		g.P("}")
 		g.P("procedures = append(procedures, procedure)")
 	}
-	g.P("return ", pluginrpcPackage.Ident("NewSpec"), "(procedures)")
+	g.P("return ", pluginrpcPackage.Ident("NewSpec"), "(procedures...)")
 	g.P("}")
 	g.P()
 }

internal/example/gen/pluginrpc/example/v1/examplev1pluginrpc/example.pluginrpc.go

@@ -21,4 +21,6 @@ const (
 
 	// IsAtLeastVersion0_1_0 is used in compile-time handshake's with pluginrpc's generated code.
 	IsAtLeastVersion0_1_0 = true
+	// IsAtLeastVersion0_4_0 is used in compile-time handshake's with pluginrpc's generated code.
+	IsAtLeastVersion0_4_0 = true
 )

pluginrpc.go

@@ -20,6 +20,7 @@ import (
 	"net/url"
 	"regexp"
 	"slices"
+	"strings"
 
 	pluginrpcv1 "buf.build/gen/go/pluginrpc/pluginrpc/protocolbuffers/go/pluginrpc/v1"
 )
@@ -115,6 +116,29 @@ func newProcedureOptions() *procedureOptions {
 	return &procedureOptions{}
 }
 
+func validateProcedures(procedures []Procedure) error {
+	usedPathMap := make(map[string]struct{})
+	usedArgsMap := make(map[string]struct{})
+	for _, procedure := range procedures {
+		path := procedure.Path()
+		if _, ok := usedPathMap[path]; ok {
+			return fmt.Errorf("duplicate procedure path: %q", path)
+		}
+		usedPathMap[path] = struct{}{}
+		args := procedure.Args()
+		if len(args) > 0 {
+			// We can do this given that we have a valid Spec where
+			// args do not contain spaces.
+			joinedArgs := strings.Join(args, " ")
+			if _, ok := usedArgsMap[joinedArgs]; ok {
+				return fmt.Errorf("duplicate procedure args: %q", joinedArgs)
+			}
+			usedArgsMap[joinedArgs] = struct{}{}
+		}
+	}
+	return nil
+}
+
 func validateProcedure(procedure *procedure) error {
 	if procedure.path == "" {
 		return errors.New("procedure path is empty")

procedure.go

@@ -0,0 +1,42 @@
+// Copyright 2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pluginrpc
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcedureBasic(t *testing.T) {
+	t.Parallel()
+
+	procedure, err := NewProcedure("/foo/bar")
+	require.NoError(t, err)
+	require.Equal(t, "/foo/bar", procedure.Path())
+	require.Empty(t, procedure.Args())
+
+	procedure, err = NewProcedure("/foo/bar", ProcedureWithArgs("foo", "bar"))
+	require.NoError(t, err)
+	require.Equal(t, "/foo/bar", procedure.Path())
+	require.Equal(t, []string{"foo", "bar"}, procedure.Args())
+
+	_, err = NewProcedure("foo/bar")
+	require.Error(t, err)
+	_, err = NewProcedure("\\foo\\bar")
+	require.Error(t, err)
+	_, err = NewProcedure("/foo/bar", ProcedureWithArgs("f"))
+	require.Error(t, err)
+}

procedure_test.go

@@ -15,9 +15,7 @@
 package pluginrpc
 
 import (
-	"fmt"
 	"slices"
-	"strings"
 
 	pluginrpcv1 "buf.build/gen/go/pluginrpc/pluginrpc/protocolbuffers/go/pluginrpc/v1"
 )
@@ -40,7 +38,7 @@ type Spec interface {
 }
 
 // NewSpec returns a new validated Spec for the given Procedures.
-func NewSpec(procedures []Procedure) (Spec, error) {
+func NewSpec(procedures ...Procedure) (Spec, error) {
 	return newSpec(procedures)
 }
 
@@ -54,7 +52,7 @@ func NewSpecForProto(protoSpec *pluginrpcv1.Spec) (Spec, error) {
 		}
 		procedures[i] = procedure
 	}
-	return NewSpec(procedures)
+	return NewSpec(procedures...)
 }
 
 // NewProtoSpec returns a new pluginrpcv1.Spec for the given Spec.
@@ -69,6 +67,17 @@ func NewProtoSpec(spec Spec) *pluginrpcv1.Spec {
 	}
 }
 
+// MergeSpecs merges the given Specs.
+//
+// Returns error if any Procedures overlap by Path or Args.
+func MergeSpecs(specs ...Spec) (Spec, error) {
+	var procedures []Procedure
+	for _, spec := range specs {
+		procedures = append(procedures, spec.Procedures()...)
+	}
+	return NewSpec(procedures...)
+}
+
 // *** PRIVATE ***
 
 type spec struct {
@@ -77,7 +86,7 @@ type spec struct {
 }
 
 func newSpec(procedures []Procedure) (*spec, error) {
-	if err := validateSpecProcedures(procedures); err != nil {
+	if err := validateProcedures(procedures); err != nil {
 		return nil, err
 	}
 	pathToProcedure := make(map[string]Procedure)
@@ -99,26 +108,3 @@ func (s *spec) Procedures() []Procedure {
 }
 
 func (*spec) isSpec() {}
-
-func validateSpecProcedures(procedures []Procedure) error {
-	usedPathMap := make(map[string]struct{})
-	usedArgsMap := make(map[string]struct{})
-	for _, procedure := range procedures {
-		path := procedure.Path()
-		if _, ok := usedPathMap[path]; ok {
-			return fmt.Errorf("duplicate procedure path: %q", path)
-		}
-		usedPathMap[path] = struct{}{}
-		args := procedure.Args()
-		if len(args) > 0 {
-			// We can do this given that we have a valid Spec where
-			// args do not contain spaces.
-			joinedArgs := strings.Join(args, " ")
-			if _, ok := usedArgsMap[joinedArgs]; ok {
-				return fmt.Errorf("duplicate procedure args: %q", joinedArgs)
-			}
-			usedArgsMap[joinedArgs] = struct{}{}
-		}
-	}
-	return nil
-}

spec.go

@@ -0,0 +1,71 @@
+// Copyright 2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pluginrpc
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestMergeSpecsSuccess(t *testing.T) {
+	t.Parallel()
+
+	procedure1, err := NewProcedure("/foo/bar")
+	require.NoError(t, err)
+	procedure2, err := NewProcedure("/foo/baz")
+	require.NoError(t, err)
+	spec1, err := NewSpec(procedure1)
+	require.NoError(t, err)
+	spec2, err := NewSpec(procedure2)
+	require.NoError(t, err)
+	spec, err := MergeSpecs(spec1, spec2)
+	require.NoError(t, err)
+	require.Equal(
+		t,
+		[]Procedure{procedure1, procedure2},
+		spec.Procedures(),
+	)
+}
+
+func TestMergeSpecsErrorOverlappingPaths(t *testing.T) {
+	t.Parallel()
+
+	procedure1, err := NewProcedure("/foo/bar")
+	require.NoError(t, err)
+	procedure2, err := NewProcedure("/foo/bar")
+	require.NoError(t, err)
+	spec1, err := NewSpec(procedure1)
+	require.NoError(t, err)
+	spec2, err := NewSpec(procedure2)
+	require.NoError(t, err)
+	_, err = MergeSpecs(spec1, spec2)
+	require.Error(t, err)
+}
+
+func TestMergeSpecsErrorOverlappingArgs(t *testing.T) {
+	t.Parallel()
+
+	procedure1, err := NewProcedure("/foo/bar", ProcedureWithArgs("foo", "bar"))
+	require.NoError(t, err)
+	procedure2, err := NewProcedure("/foo/baz", ProcedureWithArgs("foo", "bar"))
+	require.NoError(t, err)
+	spec1, err := NewSpec(procedure1)
+	require.NoError(t, err)
+	spec2, err := NewSpec(procedure2)
+	require.NoError(t, err)
+	_, err = MergeSpecs(spec1, spec2)
+	require.Error(t, err)
+}