refactor: return remainder from ResolvePath

hacdias · hacdias · commit 6338df4fca12 · 2023-09-07T10:38:15.000+02:00
diff --git a/client/rpc/apifile.go b/client/rpc/apifile.go
@@ -17,7 +17,7 @@ const forwardSeekLimit = 1 << 14 // 16k
 func (api *UnixfsAPI) Get(ctx context.Context, p path.Path) (files.Node, error) {
 	if p.Namespace().Mutable() { // use resolved path in case we are dealing with IPNS / MFS
 		var err error
-		p, err = api.core().ResolvePath(ctx, p)
+		p, _, err = api.core().ResolvePath(ctx, p)
 		if err != nil {
 			return nil, err
 		}
diff --git a/client/rpc/dht.go b/client/rpc/dht.go
@@ -42,7 +42,7 @@ func (api *DhtAPI) FindProviders(ctx context.Context, p path.Path, opts ...caopt
 		return nil, err
 	}
 
-	rp, err := api.core().ResolvePath(ctx, p)
+	rp, _, err := api.core().ResolvePath(ctx, p)
 	if err != nil {
 		return nil, err
 	}
@@ -98,7 +98,7 @@ func (api *DhtAPI) Provide(ctx context.Context, p path.Path, opts ...caopts.DhtP
 		return err
 	}
 
-	rp, err := api.core().ResolvePath(ctx, p)
+	rp, _, err := api.core().ResolvePath(ctx, p)
 	if err != nil {
 		return err
 	}
diff --git a/client/rpc/path.go b/client/rpc/path.go
@@ -8,35 +8,38 @@ import (
 	ipld "github.com/ipfs/go-ipld-format"
 )
 
-func (api *HttpApi) ResolvePath(ctx context.Context, p path.Path) (path.ImmutablePath, error) {
+func (api *HttpApi) ResolvePath(ctx context.Context, p path.Path) (path.ImmutablePath, []string, error) {
 	var out struct {
 		Cid     cid.Cid
 		RemPath string
 	}
 
-	// TODO: this is hacky, fixing https://github.com/ipfs/go-ipfs/issues/5703 would help
-
 	var err error
 	if p.Namespace() == path.IPNSNamespace {
 		if p, err = api.Name().Resolve(ctx, p.String()); err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
 
 	if err := api.Request("dag/resolve", p.String()).Exec(ctx, &out); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	p, err = path.NewPathFromSegments(p.Namespace().String(), out.Cid.String(), out.RemPath)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
+	}
+
+	imPath, err := path.NewImmutablePath(p)
+	if err != nil {
+		return nil, nil, err
 	}
 
-	return path.NewImmutablePath(p)
+	return imPath, path.StringToSegments(out.RemPath), nil
 }
 
 func (api *HttpApi) ResolveNode(ctx context.Context, p path.Path) (ipld.Node, error) {
-	rp, err := api.ResolvePath(ctx, p)
+	rp, _, err := api.ResolvePath(ctx, p)
 	if err != nil {
 		return nil, err
 	}
diff --git a/core/commands/block.go b/core/commands/block.go
@@ -270,7 +270,7 @@ It takes a list of CIDs to remove from the local datastore..
 				return err
 			}
 
-			rp, err := api.ResolvePath(req.Context, p)
+			rp, _, err := api.ResolvePath(req.Context, p)
 			if err != nil {
 				return err
 			}
diff --git a/core/commands/dag/get.go b/core/commands/dag/get.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io"
 
+	"github.com/ipfs/boxo/path"
 	ipldlegacy "github.com/ipfs/go-ipld-legacy"
 	"github.com/ipfs/kubo/core/commands/cmdenv"
 	"github.com/ipfs/kubo/core/commands/cmdutils"
@@ -33,7 +34,7 @@ func dagGet(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) e
 		return err
 	}
 
-	rp, err := api.ResolvePath(req.Context, p)
+	rp, remainder, err := api.ResolvePath(req.Context, p)
 	if err != nil {
 		return err
 	}
@@ -50,8 +51,8 @@ func dagGet(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) e
 
 	finalNode := universal.(ipld.Node)
 
-	if len(rp.Remainder()) > 0 {
-		remainderPath := ipld.ParsePath(rp.Remainder())
+	if len(remainder) > 0 {
+		remainderPath := ipld.ParsePath(path.SegmentsToString(remainder...))
 
 		finalNode, err = traversal.Get(finalNode, remainderPath)
 		if err != nil {
diff --git a/core/commands/dag/resolve.go b/core/commands/dag/resolve.go
@@ -1,6 +1,7 @@
 package dagcmd
 
 import (
+	"github.com/ipfs/boxo/path"
 	"github.com/ipfs/kubo/core/commands/cmdenv"
 	"github.com/ipfs/kubo/core/commands/cmdutils"
 
@@ -18,13 +19,13 @@ func dagResolve(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environmen
 		return err
 	}
 
-	rp, err := api.ResolvePath(req.Context, p)
+	rp, remainder, err := api.ResolvePath(req.Context, p)
 	if err != nil {
 		return err
 	}
 
 	return cmds.EmitOnce(res, &ResolveOutput{
 		Cid:     rp.Cid(),
-		RemPath: rp.Remainder(),
+		RemPath: path.SegmentsToString(remainder...),
 	})
 }
diff --git a/core/commands/dag/stat.go b/core/commands/dag/stat.go
@@ -33,11 +33,11 @@ func dagStat(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment)
 		if err != nil {
 			return err
 		}
-		rp, err := api.ResolvePath(req.Context, p)
+		rp, remainder, err := api.ResolvePath(req.Context, p)
 		if err != nil {
 			return err
 		}
-		if len(rp.Remainder()) > 0 {
+		if len(remainder) > 0 {
 			return fmt.Errorf("cannot return size for anything other than a DAG with a root CID")
 		}
 
diff --git a/core/commands/object/object.go b/core/commands/object/object.go
@@ -143,7 +143,7 @@ multihash. Provided for legacy reasons. Use 'ipfs dag get' instead.
 			return err
 		}
 
-		rp, err := api.ResolvePath(req.Context, path)
+		rp, _, err := api.ResolvePath(req.Context, path)
 		if err != nil {
 			return err
 		}
diff --git a/core/commands/pin/pin.go b/core/commands/pin/pin.go
@@ -189,7 +189,7 @@ func pinAddMany(ctx context.Context, api coreiface.CoreAPI, enc cidenc.Encoder,
 			return nil, err
 		}
 
-		rp, err := api.ResolvePath(ctx, p)
+		rp, _, err := api.ResolvePath(ctx, p)
 		if err != nil {
 			return nil, err
 		}
@@ -252,7 +252,7 @@ ipfs pin ls -t indirect <cid>
 				return err
 			}
 
-			rp, err := api.ResolvePath(req.Context, p)
+			rp, _, err := api.ResolvePath(req.Context, p)
 			if err != nil {
 				return err
 			}
@@ -468,7 +468,7 @@ func pinLsKeys(req *cmds.Request, typeStr string, api coreiface.CoreAPI, emit fu
 			return err
 		}
 
-		rp, err := api.ResolvePath(req.Context, p)
+		rp, _, err := api.ResolvePath(req.Context, p)
 		if err != nil {
 			return err
 		}
@@ -594,11 +594,11 @@ pin.
 		}
 
 		// Resolve the paths ahead of time so we can return the actual CIDs
-		from, err := api.ResolvePath(req.Context, fromPath)
+		from, _, err := api.ResolvePath(req.Context, fromPath)
 		if err != nil {
 			return err
 		}
-		to, err := api.ResolvePath(req.Context, toPath)
+		to, _, err := api.ResolvePath(req.Context, toPath)
 		if err != nil {
 			return err
 		}
diff --git a/core/commands/pin/remotepin.go b/core/commands/pin/remotepin.go
@@ -162,7 +162,7 @@ NOTE: a comma-separated notation is supported in CLI for convenience:
 			return err
 		}
 
-		rp, err := api.ResolvePath(ctx, p)
+		rp, _, err := api.ResolvePath(ctx, p)
 		if err != nil {
 			return err
 		}
diff --git a/core/commands/refs.go b/core/commands/refs.go
@@ -175,7 +175,7 @@ func objectsForPaths(ctx context.Context, n iface.CoreAPI, paths []string) ([]ci
 		if err != nil {
 			return nil, err
 		}
-		o, err := n.ResolvePath(ctx, p)
+		o, _, err := n.ResolvePath(ctx, p)
 		if err != nil {
 			return nil, err
 		}
diff --git a/core/commands/resolve.go b/core/commands/resolve.go
@@ -134,15 +134,15 @@ Resolve the value of an IPFS DAG path:
 		}
 
 		// else, ipfs path or ipns with recursive flag
-		rp, err := api.ResolvePath(req.Context, p)
+		rp, remainder, err := api.ResolvePath(req.Context, p)
 		if err != nil {
 			return err
 		}
 
 		// Trick to encode path with correct encoding.
 		encodedPath := "/" + rp.Namespace().String() + "/" + enc.Encode(rp.Cid())
-		if remainder := rp.Remainder(); remainder != "" {
-			encodedPath += "/" + remainder
+		if len(remainder) != 0 {
+			encodedPath += path.SegmentsToString(remainder...)
 		}
 
 		// Ensure valid and sanitized.
diff --git a/core/coreapi/block.go b/core/coreapi/block.go
@@ -74,7 +74,7 @@ func (api *BlockAPI) Put(ctx context.Context, src io.Reader, opts ...caopts.Bloc
 func (api *BlockAPI) Get(ctx context.Context, p path.Path) (io.Reader, error) {
 	ctx, span := tracing.Span(ctx, "CoreAPI.BlockAPI", "Get", trace.WithAttributes(attribute.String("path", p.String())))
 	defer span.End()
-	rp, err := api.core().ResolvePath(ctx, p)
+	rp, _, err := api.core().ResolvePath(ctx, p)
 	if err != nil {
 		return nil, err
 	}
@@ -91,7 +91,7 @@ func (api *BlockAPI) Rm(ctx context.Context, p path.Path, opts ...caopts.BlockRm
 	ctx, span := tracing.Span(ctx, "CoreAPI.BlockAPI", "Rm", trace.WithAttributes(attribute.String("path", p.String())))
 	defer span.End()
 
-	rp, err := api.core().ResolvePath(ctx, p)
+	rp, _, err := api.core().ResolvePath(ctx, p)
 	if err != nil {
 		return err
 	}
@@ -132,7 +132,7 @@ func (api *BlockAPI) Stat(ctx context.Context, p path.Path) (coreiface.BlockStat
 	ctx, span := tracing.Span(ctx, "CoreAPI.BlockAPI", "Stat", trace.WithAttributes(attribute.String("path", p.String())))
 	defer span.End()
 
-	rp, err := api.core().ResolvePath(ctx, p)
+	rp, _, err := api.core().ResolvePath(ctx, p)
 	if err != nil {
 		return nil, err
 	}
diff --git a/core/coreapi/dht.go b/core/coreapi/dht.go
@@ -53,7 +53,7 @@ func (api *DhtAPI) FindProviders(ctx context.Context, p path.Path, opts ...caopt
 		return nil, err
 	}
 
-	rp, err := api.core().ResolvePath(ctx, p)
+	rp, _, err := api.core().ResolvePath(ctx, p)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func (api *DhtAPI) Provide(ctx context.Context, path path.Path, opts ...caopts.D
 		return err
 	}
 
-	rp, err := api.core().ResolvePath(ctx, path)
+	rp, _, err := api.core().ResolvePath(ctx, path)
 	if err != nil {
 		return err
 	}
diff --git a/core/coreapi/path.go b/core/coreapi/path.go
@@ -22,7 +22,7 @@ func (api *CoreAPI) ResolveNode(ctx context.Context, p path.Path) (ipld.Node, er
 	ctx, span := tracing.Span(ctx, "CoreAPI", "ResolveNode", trace.WithAttributes(attribute.String("path", p.String())))
 	defer span.End()
 
-	rp, err := api.ResolvePath(ctx, p)
+	rp, _, err := api.ResolvePath(ctx, p)
 	if err != nil {
 		return nil, err
 	}
@@ -36,19 +36,19 @@ func (api *CoreAPI) ResolveNode(ctx context.Context, p path.Path) (ipld.Node, er
 
 // ResolvePath resolves the path `p` using Unixfs resolver, returns the
 // resolved path.
-func (api *CoreAPI) ResolvePath(ctx context.Context, p path.Path) (path.ImmutablePath, error) {
+func (api *CoreAPI) ResolvePath(ctx context.Context, p path.Path) (path.ImmutablePath, []string, error) {
 	ctx, span := tracing.Span(ctx, "CoreAPI", "ResolvePath", trace.WithAttributes(attribute.String("path", p.String())))
 	defer span.End()
 
 	p, err := resolve.ResolveIPNS(ctx, api.namesys, p)
 	if err == resolve.ErrNoNamesys {
-		return nil, coreiface.ErrOffline
+		return nil, nil, coreiface.ErrOffline
 	} else if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	if p.Namespace() != path.IPFSNamespace && p.Namespace() != path.IPLDNamespace {
-		return nil, fmt.Errorf("unsupported path namespace: %s", p.Namespace().String())
+		return nil, nil, fmt.Errorf("unsupported path namespace: %s", p.Namespace().String())
 	}
 
 	var resolver ipfspathresolver.Resolver
@@ -58,18 +58,23 @@ func (api *CoreAPI) ResolvePath(ctx context.Context, p path.Path) (path.Immutabl
 		resolver = api.unixFSPathResolver
 	}
 
-	node, rest, err := resolver.ResolveToLastNode(ctx, p)
+	node, remainder, err := resolver.ResolveToLastNode(ctx, p)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	segments := []string{p.Namespace().String(), node.String()}
-	segments = append(segments, rest...)
+	segments = append(segments, remainder...)
 
 	p, err = path.NewPathFromSegments(segments...)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
+	}
+
+	imPath, err := path.NewImmutablePath(p)
+	if err != nil {
+		return nil, nil, err
 	}
 
-	return path.NewImmutablePath(p)
+	return imPath, remainder, nil
 }
diff --git a/core/coreapi/pin.go b/core/coreapi/pin.go
@@ -74,7 +74,7 @@ func (api *PinAPI) IsPinned(ctx context.Context, p path.Path, opts ...caopts.Pin
 	ctx, span := tracing.Span(ctx, "CoreAPI.PinAPI", "IsPinned", trace.WithAttributes(attribute.String("path", p.String())))
 	defer span.End()
 
-	resolved, err := api.core().ResolvePath(ctx, p)
+	resolved, _, err := api.core().ResolvePath(ctx, p)
 	if err != nil {
 		return "", false, fmt.Errorf("error resolving path: %s", err)
 	}
@@ -99,7 +99,7 @@ func (api *PinAPI) Rm(ctx context.Context, p path.Path, opts ...caopts.PinRmOpti
 	ctx, span := tracing.Span(ctx, "CoreAPI.PinAPI", "Rm", trace.WithAttributes(attribute.String("path", p.String())))
 	defer span.End()
 
-	rp, err := api.core().ResolvePath(ctx, p)
+	rp, _, err := api.core().ResolvePath(ctx, p)
 	if err != nil {
 		return err
 	}
@@ -136,12 +136,12 @@ func (api *PinAPI) Update(ctx context.Context, from path.Path, to path.Path, opt
 
 	span.SetAttributes(attribute.Bool("unpin", settings.Unpin))
 
-	fp, err := api.core().ResolvePath(ctx, from)
+	fp, _, err := api.core().ResolvePath(ctx, from)
 	if err != nil {
 		return err
 	}
 
-	tp, err := api.core().ResolvePath(ctx, to)
+	tp, _, err := api.core().ResolvePath(ctx, to)
 	if err != nil {
 		return err
 	}
diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod
@@ -7,7 +7,7 @@ go 1.20
 replace github.com/ipfs/kubo => ./../../..
 
 require (
-	github.com/ipfs/boxo v0.12.1-0.20230906083417-32140848b581
+	github.com/ipfs/boxo v0.12.1-0.20230907083618-c4cf7d4b34d4
 	github.com/ipfs/kubo v0.0.0-00010101000000-000000000000
 	github.com/libp2p/go-libp2p v0.30.0
 	github.com/multiformats/go-multiaddr v0.11.0
diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum
@@ -300,8 +300,8 @@ github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/ipfs/bbloom v0.0.4 h1:Gi+8EGJ2y5qiD5FbsbpX/TMNcJw8gSqr7eyjHa4Fhvs=
 github.com/ipfs/bbloom v0.0.4/go.mod h1:cS9YprKXpoZ9lT0n/Mw/a6/aFV6DTjTLYHeA+gyqMG0=
-github.com/ipfs/boxo v0.12.1-0.20230906083417-32140848b581 h1:kJbzfNofJ8r36W8QFVp9lw+A7bUjF5D8XN+lxIff7sc=
-github.com/ipfs/boxo v0.12.1-0.20230906083417-32140848b581/go.mod h1:btrtHy0lmO1ODMECbbEY1pxNtrLilvKSYLoGQt1yYCk=
+github.com/ipfs/boxo v0.12.1-0.20230907083618-c4cf7d4b34d4 h1:XFUhiibJrvMinJRE+gja1OIGdP1kIWvAyHpA0t3DzFg=
+github.com/ipfs/boxo v0.12.1-0.20230907083618-c4cf7d4b34d4/go.mod h1:btrtHy0lmO1ODMECbbEY1pxNtrLilvKSYLoGQt1yYCk=
 github.com/ipfs/go-bitfield v1.1.0 h1:fh7FIo8bSwaJEh6DdTWbCeZ1eqOaOkKFI74SCnsWbGA=
 github.com/ipfs/go-bitfield v1.1.0/go.mod h1:paqf1wjq/D2BBmzfTVFlJQ9IlFOZpg422HL0HqsGWHU=
 github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY=
diff --git a/go.mod b/go.mod
diff --git a/go.sum b/go.sum
diff --git a/test/dependencies/go.mod b/test/dependencies/go.mod
diff --git a/test/dependencies/go.sum b/test/dependencies/go.sum

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ const forwardSeekLimit = 1 << 14 // 16k`
`17`	`17`	`func (api *UnixfsAPI) Get(ctx context.Context, p path.Path) (files.Node, error) {`
`18`	`18`	`if p.Namespace().Mutable() { // use resolved path in case we are dealing with IPNS / MFS`
`19`	`19`	`var err error`
`20`		`- p, err = api.core().ResolvePath(ctx, p)`
	`20`	`+ p, _, err = api.core().ResolvePath(ctx, p)`
`21`	`21`	`if err != nil {`
`22`	`22`	`return nil, err`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ func (api *DhtAPI) FindProviders(ctx context.Context, p path.Path, opts ...caopt`
`42`	`42`	`return nil, err`
`43`	`43`	`}`
`44`	`44`
`45`		`- rp, err := api.core().ResolvePath(ctx, p)`
	`45`	`+ rp, _, err := api.core().ResolvePath(ctx, p)`
`46`	`46`	`if err != nil {`
`47`	`47`	`return nil, err`
`48`	`48`	`}`
`@@ -98,7 +98,7 @@ func (api *DhtAPI) Provide(ctx context.Context, p path.Path, opts ...caopts.DhtP`
`98`	`98`	`return err`
`99`	`99`	`}`
`100`	`100`
`101`		`- rp, err := api.core().ResolvePath(ctx, p)`
	`101`	`+ rp, _, err := api.core().ResolvePath(ctx, p)`
`102`	`102`	`if err != nil {`
`103`	`103`	`return err`
`104`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,35 +8,38 @@ import (`
`8`	`8`	`ipld "github.com/ipfs/go-ipld-format"`
`9`	`9`	`)`
`10`	`10`
`11`		`-func (api *HttpApi) ResolvePath(ctx context.Context, p path.Path) (path.ImmutablePath, error) {`
	`11`	`+func (api *HttpApi) ResolvePath(ctx context.Context, p path.Path) (path.ImmutablePath, []string, error) {`
`12`	`12`	`var out struct {`
`13`	`13`	`Cid cid.Cid`
`14`	`14`	`RemPath string`
`15`	`15`	`}`
`16`	`16`
`17`		`- // TODO: this is hacky, fixing https://github.com/ipfs/go-ipfs/issues/5703 would help`
`18`		`-`
`19`	`17`	`var err error`
`20`	`18`	`if p.Namespace() == path.IPNSNamespace {`
`21`	`19`	`if p, err = api.Name().Resolve(ctx, p.String()); err != nil {`
`22`		`- return nil, err`
	`20`	`+ return nil, nil, err`
`23`	`21`	`}`
`24`	`22`	`}`
`25`	`23`
`26`	`24`	`if err := api.Request("dag/resolve", p.String()).Exec(ctx, &out); err != nil {`
`27`		`- return nil, err`
	`25`	`+ return nil, nil, err`
`28`	`26`	`}`
`29`	`27`
`30`	`28`	`p, err = path.NewPathFromSegments(p.Namespace().String(), out.Cid.String(), out.RemPath)`
`31`	`29`	`if err != nil {`
`32`		`- return nil, err`
	`30`	`+ return nil, nil, err`
	`31`	`+ }`
	`32`	`+`
	`33`	`+ imPath, err := path.NewImmutablePath(p)`
	`34`	`+ if err != nil {`
	`35`	`+ return nil, nil, err`
`33`	`36`	`}`
`34`	`37`
`35`		`- return path.NewImmutablePath(p)`
	`38`	`+ return imPath, path.StringToSegments(out.RemPath), nil`
`36`	`39`	`}`
`37`	`40`
`38`	`41`	`func (api *HttpApi) ResolveNode(ctx context.Context, p path.Path) (ipld.Node, error) {`
`39`		`- rp, err := api.ResolvePath(ctx, p)`
	`42`	`+ rp, _, err := api.ResolvePath(ctx, p)`
`40`	`43`	`if err != nil {`
`41`	`44`	`return nil, err`
`42`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -270,7 +270,7 @@ It takes a list of CIDs to remove from the local datastore..`
`270`	`270`	`return err`
`271`	`271`	`}`
`272`	`272`
`273`		`- rp, err := api.ResolvePath(req.Context, p)`
	`273`	`+ rp, _, err := api.ResolvePath(req.Context, p)`
`274`	`274`	`if err != nil {`
`275`	`275`	`return err`
`276`	`276`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`package dagcmd`
`2`	`2`
`3`	`3`	`import (`
	`4`	`+ "github.com/ipfs/boxo/path"`
`4`	`5`	`"github.com/ipfs/kubo/core/commands/cmdenv"`
`5`	`6`	`"github.com/ipfs/kubo/core/commands/cmdutils"`
`6`	`7`
`@@ -18,13 +19,13 @@ func dagResolve(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environmen`
`18`	`19`	`return err`
`19`	`20`	`}`
`20`	`21`
`21`		`- rp, err := api.ResolvePath(req.Context, p)`
	`22`	`+ rp, remainder, err := api.ResolvePath(req.Context, p)`
`22`	`23`	`if err != nil {`
`23`	`24`	`return err`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`return cmds.EmitOnce(res, &ResolveOutput{`
`27`	`28`	`Cid: rp.Cid(),`
`28`		`- RemPath: rp.Remainder(),`
	`29`	`+ RemPath: path.SegmentsToString(remainder...),`
`29`	`30`	`})`
`30`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,11 +33,11 @@ func dagStat(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment)`
`33`	`33`	`if err != nil {`
`34`	`34`	`return err`
`35`	`35`	`}`
`36`		`- rp, err := api.ResolvePath(req.Context, p)`
	`36`	`+ rp, remainder, err := api.ResolvePath(req.Context, p)`
`37`	`37`	`if err != nil {`
`38`	`38`	`return err`
`39`	`39`	`}`
`40`		`- if len(rp.Remainder()) > 0 {`
	`40`	`+ if len(remainder) > 0 {`
`41`	`41`	`return fmt.Errorf("cannot return size for anything other than a DAG with a root CID")`
`42`	`42`	`}`
`43`	`43`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ multihash. Provided for legacy reasons. Use 'ipfs dag get' instead.`
`143`	`143`	`return err`
`144`	`144`	`}`
`145`	`145`
`146`		`- rp, err := api.ResolvePath(req.Context, path)`
	`146`	`+ rp, _, err := api.ResolvePath(req.Context, path)`
`147`	`147`	`if err != nil {`
`148`	`148`	`return err`
`149`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ func pinAddMany(ctx context.Context, api coreiface.CoreAPI, enc cidenc.Encoder,`
`189`	`189`	`return nil, err`
`190`	`190`	`}`
`191`	`191`
`192`		`- rp, err := api.ResolvePath(ctx, p)`
	`192`	`+ rp, _, err := api.ResolvePath(ctx, p)`
`193`	`193`	`if err != nil {`
`194`	`194`	`return nil, err`
`195`	`195`	`}`
`@@ -252,7 +252,7 @@ ipfs pin ls -t indirect <cid>`
`252`	`252`	`return err`
`253`	`253`	`}`
`254`	`254`
`255`		`- rp, err := api.ResolvePath(req.Context, p)`
	`255`	`+ rp, _, err := api.ResolvePath(req.Context, p)`
`256`	`256`	`if err != nil {`
`257`	`257`	`return err`
`258`	`258`	`}`
`@@ -468,7 +468,7 @@ func pinLsKeys(req *cmds.Request, typeStr string, api coreiface.CoreAPI, emit fu`
`468`	`468`	`return err`
`469`	`469`	`}`
`470`	`470`
`471`		`- rp, err := api.ResolvePath(req.Context, p)`
	`471`	`+ rp, _, err := api.ResolvePath(req.Context, p)`
`472`	`472`	`if err != nil {`
`473`	`473`	`return err`
`474`	`474`	`}`
`@@ -594,11 +594,11 @@ pin.`
`594`	`594`	`}`
`595`	`595`
`596`	`596`	`// Resolve the paths ahead of time so we can return the actual CIDs`
`597`		`- from, err := api.ResolvePath(req.Context, fromPath)`
	`597`	`+ from, _, err := api.ResolvePath(req.Context, fromPath)`
`598`	`598`	`if err != nil {`
`599`	`599`	`return err`
`600`	`600`	`}`
`601`		`- to, err := api.ResolvePath(req.Context, toPath)`
	`601`	`+ to, _, err := api.ResolvePath(req.Context, toPath)`
`602`	`602`	`if err != nil {`
`603`	`603`	`return err`
`604`	`604`	`}`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,7 @@ NOTE: a comma-separated notation is supported in CLI for convenience:`
`162`	`162`	`return err`
`163`	`163`	`}`
`164`	`164`
`165`		`- rp, err := api.ResolvePath(ctx, p)`
	`165`	`+ rp, _, err := api.ResolvePath(ctx, p)`
`166`	`166`	`if err != nil {`
`167`	`167`	`return err`
`168`	`168`	`}`