Add bufimage.CloneImage

private/bufpkg/bufimage/bufimage.go

@@ -23,6 +23,7 @@ import (
  "github.com/bufbuild/buf/private/pkg/normalpath"
  "github.com/bufbuild/buf/private/pkg/protodescriptor"
  "github.com/bufbuild/buf/private/pkg/protoencoding"
+ "google.golang.org/protobuf/proto"
  "google.golang.org/protobuf/types/descriptorpb"
  "google.golang.org/protobuf/types/pluginpb"
 )
@@ -122,6 +123,44 @@ func NewImage(imageFiles []ImageFile) (Image, error) {
  return newImage(imageFiles, false)
 }
 
+// CloneImage returns a deep copy of the given image.
+func CloneImage(image Image) (Image, error) {
+ originalFiles := image.Files()
+ imageFiles := make([]ImageFile, len(originalFiles))
+ for i, originalFile := range originalFiles {
+ clonedFile, err := CloneImageFile(originalFile)
+ if err != nil {
+ return nil, err
+ }
+ imageFiles[i] = clonedFile
+ }
+ return NewImage(imageFiles)
+}
+
+// CloneImageFile returns a deep copy of the given image file.
+func CloneImageFile(imageFile ImageFile) (ImageFile, error) {
+ clonedProto := proto.Clone(imageFile.FileDescriptorProto())
+ clonedDescriptor, ok := clonedProto.(*descriptorpb.FileDescriptorProto)
+ if !ok {
+ // Shouldn't actually be possible...
+ return nil, fmt.Errorf("failed to clone image file %q: input %T; clone is %T but expecting %T",
+ imageFile.Path(), imageFile, clonedProto, (*descriptorpb.FileDescriptorProto)(nil))
+ }
+ originalUnusedDeps := imageFile.UnusedDependencyIndexes()
+ unusedDeps := make([]int32, len(originalUnusedDeps))
+ copy(unusedDeps, originalUnusedDeps)
+ // The other attributes are already immutable, so we don't need to copy them.
+ return NewImageFile(
+ clonedDescriptor,
+ imageFile.ModuleIdentity(),
+ imageFile.Commit(),
+ imageFile.ExternalPath(),
+ imageFile.IsImport(),
+ imageFile.IsSyntaxUnspecified(),
+ unusedDeps,
+ )
+}
+
 // MergeImages returns a new Image for the given Images. ImageFiles
 // treated as non-imports in at least one of the given Images will
 // be treated as non-imports in the returned Image. The first non-import

private/bufpkg/bufimage/image_test.go

@@ -15,12 +15,16 @@
 package bufimage
 
 import (
+ "reflect"
  "testing"
 
  imagev1 "github.com/bufbuild/buf/private/gen/proto/go/buf/alpha/image/v1"
+ "github.com/google/go-cmp/cmp"
  "github.com/stretchr/testify/assert"
  "github.com/stretchr/testify/require"
  "google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/testing/protocmp"
+ "google.golang.org/protobuf/types/descriptorpb"
 )
 
 func TestMergeImagesWithImports(t *testing.T) {
@@ -137,3 +141,121 @@ func TestMergeImagesOrdered(t *testing.T) {
  }
  assert.Equal(t, []string{"a.proto", "b.proto", "c.proto", "d.proto"}, paths)
 }
+
+func TestCloneImage(t *testing.T) {
+ t.Parallel()
+ protoImage := &imagev1.Image{
+ File: []*imagev1.ImageFile{
+ {
+ Syntax: proto.String("proto3"),
+ Name: proto.String("a.proto"),
+ Dependency: []string{"b.proto", "c.proto"},
+ Package: proto.String("abc.def"),
+ MessageType: []*descriptorpb.DescriptorProto{
+ {
+ Name: proto.String("Msg"),
+ Field: []*descriptorpb.FieldDescriptorProto{
+ {
+ Name: proto.String("id"),
+ Label: descriptorpb.FieldDescriptorProto_LABEL_OPTIONAL.Enum(),
+ Number: proto.Int32(1),
+ Type: descriptorpb.FieldDescriptorProto_TYPE_STRING.Enum(),
+ JsonName: proto.String("id"),
+ },
+ {
+ Name: proto.String("en"),
+ Label: descriptorpb.FieldDescriptorProto_LABEL_REPEATED.Enum(),
+ Number: proto.Int32(2),
+ Type: descriptorpb.FieldDescriptorProto_TYPE_ENUM.Enum(),
+ TypeName: proto.String(".abc.def.Enum"),
+ JsonName: proto.String("en"),
+ },
+ },
+ },
+ },
+ BufExtension: &imagev1.ImageFileExtension{
+ IsImport: proto.Bool(false),
+ IsSyntaxUnspecified: proto.Bool(false),
+ UnusedDependency: []int32{1},
+ ModuleInfo: &imagev1.ModuleInfo{
+ Name: &imagev1.ModuleName{
+ Remote: proto.String("buf.build"),
+ Owner: proto.String("foo"),
+ Repository: proto.String("bar"),
+ },
+ },
+ },
+ },
+ {
+ Syntax: proto.String("proto3"),
+ Name: proto.String("b.proto"),
+ Package: proto.String("abc.def"),
+ EnumType: []*descriptorpb.EnumDescriptorProto{
+ {
+ Name: proto.String("Enum"),
+ Value: []*descriptorpb.EnumValueDescriptorProto{
+ {
+ Name: proto.String("ZERO"),
+ Number: proto.Int32(0),
+ },
+ {
+ Name: proto.String("ONE"),
+ Number: proto.Int32(1),
+ },
+ },
+ },
+ },
+ BufExtension: &imagev1.ImageFileExtension{
+ IsImport: proto.Bool(true),
+ IsSyntaxUnspecified: proto.Bool(false),
+ ModuleInfo: &imagev1.ModuleInfo{
+ Name: &imagev1.ModuleName{
+ Remote: proto.String("buf.build"),
+ Owner: proto.String("foo"),
+ Repository: proto.String("baz"),
+ },
+ },
+ },
+ },
+ {
+ Syntax: proto.String("proto2"),
+ Name: proto.String("c.proto"),
+ BufExtension: &imagev1.ImageFileExtension{
+ IsImport: proto.Bool(true),
+ IsSyntaxUnspecified: proto.Bool(true),
+ ModuleInfo: &imagev1.ModuleInfo{
+ Name: &imagev1.ModuleName{
+ Remote: proto.String("buf.build"),
+ Owner: proto.String("foo"),
+ Repository: proto.String("baz"),
+ },
+ },
+ },
+ },
+ },
+ }
+
+ image, err := NewImageForProto(protoImage)
+ require.NoError(t, err)
+
+ clone, err := CloneImage(image)
+ require.NoError(t, err)
+
+ // Test that they are equal by comparing their proto versions
+ protoClone := ImageToProtoImage(clone)
+
+ require.Empty(t, cmp.Diff(protoImage, protoClone, protocmp.Transform()))
+
+ // Verify the pointer values are different
+ for _, imageFile := range image.Files() {
+ cloneFile := clone.GetFile(imageFile.Path())
+ require.NotSame(t, imageFile.FileDescriptorProto(), cloneFile.FileDescriptorProto())
+ unused := reflect.ValueOf(imageFile.UnusedDependencyIndexes()).Pointer()
+ cloneUnused := reflect.ValueOf(cloneFile.UnusedDependencyIndexes()).Pointer()
+ if unused != 0 || cloneUnused != 0 {
+ // They can both be nil. But otherwise must not be equal since that
+ // means the backing arrays are shared.
+ require.NotEqual(t, unused, cloneUnused)
+ }
+ }
+}