feat(ipldbridge): update to latest

Update the IPLD bridge for the newest version of IPLD prime and add a node builder method.

go.mod

@@ -9,7 +9,7 @@ require (
 	github.com/ipfs/go-ipfs-blocksutil v0.0.1
 	github.com/ipfs/go-ipfs-pq v0.0.1
 	github.com/ipfs/go-log v0.0.1
-	github.com/ipld/go-ipld-prime v0.0.0-20190320000329-46ca29fe25db
+	github.com/ipld/go-ipld-prime v0.0.0-20190329013432-23c6f913c975
 	github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c
 	github.com/libp2p/go-libp2p v0.0.2
 	github.com/libp2p/go-libp2p-host v0.0.1

go.sum

@@ -62,6 +62,8 @@ github.com/ipld/go-ipld-prime v0.0.0-20190316215235-adc089c2d3fb h1:pBiRTPGX6V8H
 github.com/ipld/go-ipld-prime v0.0.0-20190316215235-adc089c2d3fb/go.mod h1:hSGXgXt4BSdqvjA3Kkxhzcg4Rsk9yvIeEuEVCPCi7/A=
 github.com/ipld/go-ipld-prime v0.0.0-20190320000329-46ca29fe25db h1:/6+Pat3+xFjSaBHudbUm+KFyf/11JLuMHGM2dGVNkHc=
 github.com/ipld/go-ipld-prime v0.0.0-20190320000329-46ca29fe25db/go.mod h1:hSGXgXt4BSdqvjA3Kkxhzcg4Rsk9yvIeEuEVCPCi7/A=
+github.com/ipld/go-ipld-prime v0.0.0-20190329013432-23c6f913c975 h1:rwQVBxB/muR+Og3iu8ypYp6Rerkcp5pi2j0qfAtqQeI=
+github.com/ipld/go-ipld-prime v0.0.0-20190329013432-23c6f913c975/go.mod h1:hSGXgXt4BSdqvjA3Kkxhzcg4Rsk9yvIeEuEVCPCi7/A=
 github.com/jackpal/gateway v1.0.4 h1:LS5EHkLuQ6jzaHwULi0vL+JO0mU/n4yUtK8oUjHHOlM=
 github.com/jackpal/gateway v1.0.4/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA=
 github.com/jackpal/go-nat-pmp v1.0.1 h1:i0LektDkO1QlrTm/cSuP+PyBCDnYvjPLGl4LdWEMiaA=

ipldbridge/ipld_impl.go

@@ -30,6 +30,18 @@ func NewIPLDBridge() IPLDBridge {
 	return &ipldBridge{}
 }
 
+func (rb *ipldBridge) BuildNode(buildFn func(NodeBuilder) ipld.Node) (ipld.Node, error) {
+	var node ipld.Node
+	err := fluent.Recover(func() {
+		nb := fluent.WrapNodeBuilder(free.NodeBuilder())
+		node = buildFn(nb)
+	})
+	if err != nil {
+		return nil, err
+	}
+	return node, nil
+}
+
 func (rb *ipldBridge) Traverse(ctx context.Context, loader Loader, root ipld.Node, s Selector, fn AdvVisitFn) error {
 	config := &TraversalConfig{Ctx: ctx, LinkLoader: loader}
 	return TraversalProgress{TraversalConfig: config}.TraverseInformatively(root, s, fn)

ipldbridge/ipldbridge.go

@@ -3,6 +3,8 @@ package ipldbridge
 import (
 	"context"
 
+	"github.com/ipld/go-ipld-prime/fluent"
+
 	ipld "github.com/ipld/go-ipld-prime"
 	ipldtraversal "github.com/ipld/go-ipld-prime/traversal"
 	ipldselector "github.com/ipld/go-ipld-prime/traversal/selector"
@@ -26,9 +28,19 @@ type TraversalProgress = ipldtraversal.TraversalProgress
 // TraversalReason is an alias from ipld, in case it's renamed/moved.
 type TraversalReason = ipldtraversal.TraversalReason
 
+// NodeBuilder is an alias from the ipld fluent nodebuilder, in case it's moved
+type NodeBuilder = fluent.NodeBuilder
+
+// ListBuilder is an alias from ipld fluent, in case it's moved
+type ListBuilder = fluent.ListBuilder
+
+// MapBuilder is an alias from ipld fluent, in case it's moved
+type MapBuilder = fluent.MapBuilder
+
 // IPLDBridge is an interface for making calls to IPLD, which can be
 // replaced with alternative implementations
 type IPLDBridge interface {
+	BuildNode(func(NodeBuilder) ipld.Node) (ipld.Node, error)
 
 	// ValidateSelectorSpec verifies if a node matches the selector spec.
 	ValidateSelectorSpec(rootedSelector ipld.Node) []error

testbridge/mocklink.go

+package testbridge
+
+import (
+	"context"
+	"fmt"
+
+	ipldbridge "github.com/ipfs/go-graphsync/ipldbridge"
+	ipld "github.com/ipld/go-ipld-prime"
+)
+
+type mockLink struct {
+	index int
+}
+
+var nextIndex int
+
+// NewMockLink produces an object that conforms to the ipld Link interface.
+func NewMockLink() ipld.Link {
+	nextIndex++
+	return &mockLink{index: nextIndex}
+}
+func (ml *mockLink) Load(context.Context, ipldbridge.LinkContext, ipld.NodeBuilder, ipldbridge.Loader) (ipld.Node, error) {
+	return nil, fmt.Errorf("Cannot load mock link")
+}
+
+func (ml *mockLink) LinkBuilder() ipld.LinkBuilder {
+	return nil
+}
+
+func (ml *mockLink) String() string { return "" }

testbridge/mocknodes.go

@@ -31,17 +31,16 @@ func NewUnencodableSelectorSpec(cidsVisited []cid.Cid) ipld.Node {
 	return &mockSelectorSpec{cidsVisited, false, true}
 }
 
-func (mss *mockSelectorSpec) Kind() ipld.ReprKind { return ipld.ReprKind_Null }
+func (mss *mockSelectorSpec) ReprKind() ipld.ReprKind { return ipld.ReprKind_Null }
 func (mss *mockSelectorSpec) TraverseField(key string) (ipld.Node, error) {
 	return nil, fmt.Errorf("404")
 }
 func (mss *mockSelectorSpec) TraverseIndex(idx int) (ipld.Node, error) {
 	return nil, fmt.Errorf("404")
 }
-func (mss *mockSelectorSpec) Keys() ipld.KeyIterator { return &mockKeyIterator{} }
-func (mss *mockSelectorSpec) KeysImmediate() ([]string, error) {
-	return nil, fmt.Errorf("404")
-}
+func (mss *mockSelectorSpec) ListIterator() ipld.ListIterator { return nil }
+func (mss *mockSelectorSpec) MapIterator() ipld.MapIterator   { return nil }
+
 func (mss *mockSelectorSpec) Length() int                   { return 0 }
 func (mss *mockSelectorSpec) IsNull() bool                  { return true }
 func (mss *mockSelectorSpec) AsBool() (bool, error)         { return false, fmt.Errorf("404") }
@@ -52,12 +51,6 @@ func (mss *mockSelectorSpec) AsBytes() ([]byte, error)      { return nil, fmt.Er
 func (mss *mockSelectorSpec) AsLink() (ipld.Link, error)    { return nil, fmt.Errorf("404") }
 func (mss *mockSelectorSpec) NodeBuilder() ipld.NodeBuilder { return &mockBuilder{} }
 
-type mockKeyIterator struct {
-}
-
-func (mki *mockKeyIterator) Next() (string, error) { return "", fmt.Errorf("404") }
-func (mki *mockKeyIterator) HasNext() bool         { return false }
-
 type mockBlockNode struct {
 	data []byte
 }
@@ -67,17 +60,17 @@ func NewMockBlockNode(data []byte) ipld.Node {
 	return &mockBlockNode{data}
 }
 
-func (mbn *mockBlockNode) Kind() ipld.ReprKind { return ipld.ReprKind_Bytes }
+func (mbn *mockBlockNode) ReprKind() ipld.ReprKind { return ipld.ReprKind_Bytes }
 func (mbn *mockBlockNode) TraverseField(key string) (ipld.Node, error) {
 	return nil, fmt.Errorf("404")
 }
 func (mbn *mockBlockNode) TraverseIndex(idx int) (ipld.Node, error) {
 	return nil, fmt.Errorf("404")
 }
-func (mbn *mockBlockNode) Keys() ipld.KeyIterator { return &mockKeyIterator{} }
-func (mbn *mockBlockNode) KeysImmediate() ([]string, error) {
-	return nil, fmt.Errorf("404")
-}
+
+func (mbn *mockBlockNode) ListIterator() ipld.ListIterator { return nil }
+func (mbn *mockBlockNode) MapIterator() ipld.MapIterator   { return nil }
+
 func (mbn *mockBlockNode) Length() int                   { return 0 }
 func (mbn *mockBlockNode) IsNull() bool                  { return false }
 func (mbn *mockBlockNode) AsBool() (bool, error)         { return false, fmt.Errorf("404") }

testbridge/mockselector.go

@@ -14,7 +14,8 @@ func newMockSelector(mss *mockSelectorSpec) ipldbridge.Selector {
 	return &mockSelector{mss.cidsVisited}
 }
 
-func (ms *mockSelector) Explore(ipld.Node) (ipld.KeyIterator, ipldbridge.Selector) {
-	return nil, ms
+func (ms *mockSelector) Explore(ipld.Node) (ipld.MapIterator, ipld.ListIterator, ipldbridge.Selector) {
+	return nil, nil, ms
 }
+
 func (ms *mockSelector) Decide(ipld.Node) bool { return false }

testbridge/testbridge.go

@@ -10,6 +10,9 @@ import (
 	cid "github.com/ipfs/go-cid"
 	ipldbridge "github.com/ipfs/go-graphsync/ipldbridge"
 	ipld "github.com/ipld/go-ipld-prime"
+	"github.com/ipld/go-ipld-prime/encoding/dagjson"
+	"github.com/ipld/go-ipld-prime/fluent"
+	free "github.com/ipld/go-ipld-prime/impl/free"
 	"github.com/ipld/go-ipld-prime/linking/cid"
 	multihash "github.com/multiformats/go-multihash"
 )
@@ -21,6 +24,17 @@ type mockIPLDBridge struct {
 func NewMockIPLDBridge() ipldbridge.IPLDBridge {
 	return &mockIPLDBridge{}
 }
+func (mb *mockIPLDBridge) BuildNode(buildFn func(ipldbridge.NodeBuilder) ipld.Node) (ipld.Node, error) {
+	var node ipld.Node
+	err := fluent.Recover(func() {
+		nb := fluent.WrapNodeBuilder(free.NodeBuilder())
+		node = buildFn(nb)
+	})
+	if err != nil {
+		return nil, err
+	}
+	return node, nil
+}
 
 func (mb *mockIPLDBridge) ValidateSelectorSpec(cidRootedSelector ipld.Node) []error {
 	spec, ok := cidRootedSelector.(*mockSelectorSpec)
@@ -32,14 +46,22 @@ func (mb *mockIPLDBridge) ValidateSelectorSpec(cidRootedSelector ipld.Node) []er
 
 func (mb *mockIPLDBridge) EncodeNode(node ipld.Node) ([]byte, error) {
 	spec, ok := node.(*mockSelectorSpec)
-	if ok && !spec.failEncode {
-		data, err := json.Marshal(spec.cidsVisited)
-		if err != nil {
-			return nil, err
+	if ok {
+		if !spec.failEncode {
+			data, err := json.Marshal(spec.cidsVisited)
+			if err != nil {
+				return nil, err
+			}
+			return data, nil
 		}
-		return data, nil
+		return nil, fmt.Errorf("format not supported")
+	}
+	var buffer bytes.Buffer
+	err := dagjson.Encoder(node, &buffer)
+	if err != nil {
+		return nil, err
 	}
-	return nil, fmt.Errorf("format not supported")
+	return buffer.Bytes(), nil
 }
 
 func (mb *mockIPLDBridge) DecodeNode(data []byte) (ipld.Node, error) {
@@ -48,7 +70,8 @@ func (mb *mockIPLDBridge) DecodeNode(data []byte) (ipld.Node, error) {
 	if err == nil {
 		return &mockSelectorSpec{cidsVisited, false, false}, nil
 	}
-	return nil, fmt.Errorf("format not supported")
+	reader := bytes.NewReader(data)
+	return dagjson.Decoder(free.NodeBuilder(), reader)
 }
 
 func (mb *mockIPLDBridge) DecodeSelectorSpec(cidRootedSelector ipld.Node) (ipld.Node, ipldbridge.Selector, error) {