chore(metadata): convert metadata to bindnode

Author: rvagg

metadata/metadata.go

@@ -1,12 +1,9 @@
 package metadata
 
 import (
-	"bytes"
-	"fmt"
-
 	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	xerrors "golang.org/x/xerrors"
+	"github.com/ipld/go-ipld-prime/datamodel"
+	"github.com/ipld/go-ipld-prime/node/bindnode"
 )
 
 // Item is a single link traversed in a repsonse
@@ -21,57 +18,17 @@ type Metadata []Item
 
 // DecodeMetadata assembles metadata from a raw byte array, first deserializing
 // as a node and then assembling into a metadata struct.
-func DecodeMetadata(data []byte) (Metadata, error) {
-	var metadata Metadata
-	r := bytes.NewReader(data)
-
-	br := cbg.GetPeeker(r)
-	scratch := make([]byte, 8)
-
-	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+func DecodeMetadata(data datamodel.Node) (Metadata, error) {
+	builder := Prototype.Metadata.Representation().NewBuilder()
+	err := builder.AssignNode(data)
 	if err != nil {
 		return nil, err
 	}
-
-	if extra > cbg.MaxLength {
-		return nil, fmt.Errorf("t.Metadata: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return nil, fmt.Errorf("expected cbor array")
-	}
-
-	if extra > 0 {
-		metadata = make(Metadata, extra)
-	}
-
-	for i := 0; i < int(extra); i++ {
-
-		var v Item
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return nil, err
-		}
-
-		metadata[i] = v
-	}
-
-	return metadata, nil
+	metadata := bindnode.Unwrap(builder.Build()).(*Metadata)
+	return *metadata, nil
 }
 
 // EncodeMetadata encodes metadata to an IPLD node then serializes to raw bytes
-func EncodeMetadata(entries Metadata) ([]byte, error) {
-	w := new(bytes.Buffer)
-	scratch := make([]byte, 9)
-	if len(entries) > cbg.MaxLength {
-		return nil, xerrors.Errorf("Slice value was too long")
-	}
-	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(entries))); err != nil {
-		return nil, err
-	}
-	for _, v := range entries {
-		if err := v.MarshalCBOR(w); err != nil {
-			return nil, err
-		}
-	}
-	return w.Bytes(), nil
+func EncodeMetadata(entries Metadata) datamodel.Node {
+	return bindnode.Wrap(&entries, Prototype.Metadata.Type())
 }

metadata/metadata_cbor_gen.go

@@ -1,11 +1,11 @@
 package metadata
 
 import (
-	"bytes"
 	"math/rand"
+	"os"
 	"testing"
 
-	"github.com/ipld/go-ipld-prime/codec/dagcbor"
+	"github.com/ipld/go-ipld-prime/codec/dagjson"
 	"github.com/ipld/go-ipld-prime/fluent"
 	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
 	"github.com/ipld/go-ipld-prime/node/basicnode"
@@ -29,29 +29,16 @@ func TestDecodeEncodeMetadata(t *testing.T) {
 	})
 
 	// verify metadata matches
-	encoded, err := EncodeMetadata(initialMetadata)
-	require.NoError(t, err, "encode errored")
+	encoded := EncodeMetadata(initialMetadata)
 
 	decodedMetadata, err := DecodeMetadata(encoded)
 	require.NoError(t, err, "decode errored")
 	require.Equal(t, initialMetadata, decodedMetadata, "metadata changed during encoding and decoding")
 
 	// verify metadata is equivalent of IPLD node encoding
-	encodedNode := new(bytes.Buffer)
-	err = dagcbor.Encode(nd, encodedNode)
-	require.NoError(t, err)
-	decodedMetadataFromNode, err := DecodeMetadata(encodedNode.Bytes())
+	decodedMetadataFromNode, err := DecodeMetadata(nd)
 	require.NoError(t, err)
 	require.Equal(t, decodedMetadata, decodedMetadataFromNode, "metadata not equal to IPLD encoding")
 
-	nb := basicnode.Prototype.List.NewBuilder()
-	err = dagcbor.Decode(nb, encodedNode)
-	require.NoError(t, err)
-	decodedNode := nb.Build()
-	require.Equal(t, nd, decodedNode)
-	nb = basicnode.Prototype.List.NewBuilder()
-	err = dagcbor.Decode(nb, bytes.NewReader(encoded))
-	require.NoError(t, err)
-	decodedNodeFromMetadata := nb.Build()
-	require.Equal(t, decodedNode, decodedNodeFromMetadata, "deserialzed metadata does not match deserialized node")
+	dagjson.Encode(nd, os.Stdout)
 }

metadata/metadata_test.go

@@ -0,0 +1,25 @@
+package metadata
+
+import (
+	_ "embed"
+
+	"github.com/ipld/go-ipld-prime"
+	"github.com/ipld/go-ipld-prime/node/bindnode"
+	"github.com/ipld/go-ipld-prime/schema"
+)
+
+//go:embed schema.ipldsch
+var embedSchema []byte
+
+var Prototype struct {
+	Metadata schema.TypedPrototype
+}
+
+func init() {
+	ts, err := ipld.LoadSchemaBytes(embedSchema)
+	if err != nil {
+		panic(err)
+	}
+
+	Prototype.Metadata = bindnode.Prototype((*Metadata)(nil), ts.TypeByName("Metadata"))
+}

metadata/schema.go

@@ -0,0 +1,6 @@
+type Item struct {
+  link         Link
+  blockPresent Bool
+} representation map
+
+type Metadata [Item]