Remove hardcoded "/"

commands/command.go

@@ -13,8 +13,8 @@ import (
 	"fmt"
 	"io"
 	"reflect"
-	"strings"
 
+	"github.com/ipfs/go-ipfs/path"
 	logging "github.com/ipfs/go-ipfs/vendor/QmQg1J6vikuXF9oDvm4wpdeAUvvkVEKW1EYDw9HhTMnP2b/go-log"
 )
 
@@ -143,16 +143,16 @@ func (c *Command) Call(req Request) Response {
 }
 
 // Resolve gets the subcommands at the given path
-func (c *Command) Resolve(path []string) ([]*Command, error) {
-	cmds := make([]*Command, len(path)+1)
+func (c *Command) Resolve(pth []string) ([]*Command, error) {
+	cmds := make([]*Command, len(pth)+1)
 	cmds[0] = c
 
 	cmd := c
-	for i, name := range path {
+	for i, name := range pth {
 		cmd = cmd.Subcommand(name)
 
 		if cmd == nil {
-			pathS := strings.Join(path[0:i], "/")
+			pathS := path.Join(pth[0:i])
 			return nil, fmt.Errorf("Undefined command: '%s'", pathS)
 		}
 

commands/http/client.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 
 	cmds "github.com/ipfs/go-ipfs/commands"
+	path "github.com/ipfs/go-ipfs/path"
 	config "github.com/ipfs/go-ipfs/repo/config"
 
 	context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
@@ -85,8 +86,8 @@ func (c *client) Send(req cmds.Request) (cmds.Response, error) {
 		reader = strings.NewReader("")
 	}
 
-	path := strings.Join(req.Path(), "/")
-	url := fmt.Sprintf(ApiUrlFormat, c.serverAddress, ApiPath, path, query)
+	pth := path.Join(req.Path())
+	url := fmt.Sprintf(ApiUrlFormat, c.serverAddress, ApiPath, pth, query)
 
 	httpReq, err := http.NewRequest("POST", url, reader)
 	if err != nil {

commands/http/parse.go

@@ -9,31 +9,32 @@ import (
 
 	cmds "github.com/ipfs/go-ipfs/commands"
 	files "github.com/ipfs/go-ipfs/commands/files"
+	path "github.com/ipfs/go-ipfs/path"
 )
 
 // Parse parses the data in a http.Request and returns a command Request object
 func Parse(r *http.Request, root *cmds.Command) (cmds.Request, error) {
 	if !strings.HasPrefix(r.URL.Path, ApiPath) {
 		return nil, errors.New("Unexpected path prefix")
 	}
-	path := strings.Split(strings.TrimPrefix(r.URL.Path, ApiPath+"/"), "/")
+	pth := path.SplitList(strings.TrimPrefix(r.URL.Path, ApiPath+"/"))
 
 	stringArgs := make([]string, 0)
 
-	cmd, err := root.Get(path[:len(path)-1])
+	cmd, err := root.Get(pth[:len(pth)-1])
 	if err != nil {
 		// 404 if there is no command at that path
 		return nil, ErrNotFound
 
-	} else if sub := cmd.Subcommand(path[len(path)-1]); sub == nil {
-		if len(path) <= 1 {
+	} else if sub := cmd.Subcommand(pth[len(pth)-1]); sub == nil {
+		if len(pth) <= 1 {
 			return nil, ErrNotFound
 		}
 
 		// if the last string in the path isn't a subcommand, use it as an argument
 		// e.g. /objects/Qabc12345 (we are passing "Qabc12345" to the "objects" command)
-		stringArgs = append(stringArgs, path[len(path)-1])
-		path = path[:len(path)-1]
+		stringArgs = append(stringArgs, pth[len(pth)-1])
+		pth = pth[:len(pth)-1]
 
 	} else {
 		cmd = sub
@@ -86,7 +87,7 @@ func Parse(r *http.Request, root *cmds.Command) (cmds.Request, error) {
 		}
 	}
 
-	optDefs, err := root.GetOptions(path)
+	optDefs, err := root.GetOptions(pth)
 	if err != nil {
 		return nil, err
 	}
@@ -109,7 +110,7 @@ func Parse(r *http.Request, root *cmds.Command) (cmds.Request, error) {
 		return nil, fmt.Errorf("File argument '%s' is required", requiredFile)
 	}
 
-	req, err := cmds.NewRequest(path, opts, args, f, cmd, optDefs)
+	req, err := cmds.NewRequest(pth, opts, args, f, cmd, optDefs)
 	if err != nil {
 		return nil, err
 	}

core/commands/dht.go

@@ -5,13 +5,13 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"strings"
 	"time"
 
 	key "github.com/ipfs/go-ipfs/blocks/key"
 	cmds "github.com/ipfs/go-ipfs/commands"
 	notif "github.com/ipfs/go-ipfs/notifications"
 	peer "github.com/ipfs/go-ipfs/p2p/peer"
+	path "github.com/ipfs/go-ipfs/path"
 	ipdht "github.com/ipfs/go-ipfs/routing/dht"
 	u "github.com/ipfs/go-ipfs/util"
 )
@@ -599,13 +599,13 @@ PutValue will store the given key value pair in the dht.
 }
 
 func escapeDhtKey(s string) (key.Key, error) {
-	parts := strings.Split(s, "/")
+	parts := path.SplitList(s)
 	switch len(parts) {
 	case 1:
 		return key.B58KeyDecode(s), nil
 	case 3:
 		k := key.B58KeyDecode(parts[2])
-		return key.Key(strings.Join(append(parts[:2], string(k)), "/")), nil
+		return key.Key(path.Join(append(parts[:2], k.String()))), nil
 	default:
 		return "", errors.New("invalid key")
 	}

core/commands/files/files.go

@@ -245,8 +245,7 @@ Examples:
 			res.SetOutput(&FilesLsOutput{listing})
 			return
 		case *mfs.File:
-			parts := strings.Split(path, "/")
-			name := parts[len(parts)-1]
+			_, name := gopath.Split(path)
 			out := &FilesLsOutput{[]mfs.NodeListing{mfs.NodeListing{Name: name, Type: 1}}}
 			res.SetOutput(out)
 			return

core/corehttp/gateway_handler.go

@@ -213,7 +213,7 @@ func (i *gatewayHandler) getOrHeadHandler(w http.ResponseWriter, r *http.Request
 			var backLink string = urlPath
 
 			// don't go further up than /ipfs/$hash/
-			pathSplit := strings.Split(backLink, "/")
+			pathSplit := path.SplitList(backLink)
 			switch {
 			// keep backlink
 			case len(pathSplit) == 3: // url: /ipfs/$hash
@@ -236,7 +236,7 @@ func (i *gatewayHandler) getOrHeadHandler(w http.ResponseWriter, r *http.Request
 				if len(pathSplit) > 5 {
 					// also strip the trailing segment, because it's a backlink
 					backLinkParts := pathSplit[3 : len(pathSplit)-2]
-					backLink += strings.Join(backLinkParts, "/") + "/"
+					backLink += path.Join(backLinkParts) + "/"
 				}
 			}
 
@@ -304,7 +304,7 @@ func (i *gatewayHandler) putHandler(w http.ResponseWriter, r *http.Request) {
 
 	var newPath string
 	if len(rsegs) > 1 {
-		newPath = strings.Join(rsegs[2:], "/")
+		newPath = path.Join(rsegs[2:])
 	}
 
 	var newkey key.Key
@@ -429,7 +429,7 @@ func (i *gatewayHandler) deleteHandler(w http.ResponseWriter, r *http.Request) {
 
 	i.addUserHeaders(w) // ok, _now_ write user's headers.
 	w.Header().Set("IPFS-Hash", key.String())
-	http.Redirect(w, r, ipfsPathPrefix+key.String()+"/"+strings.Join(components[:len(components)-1], "/"), http.StatusCreated)
+	http.Redirect(w, r, gopath.Join(ipfsPathPrefix+key.String(), path.Join(components[:len(components)-1])), http.StatusCreated)
 }
 
 func (i *gatewayHandler) addUserHeaders(w http.ResponseWriter) {

fuse/ipns/ipns_unix.go

@@ -8,7 +8,6 @@ import (
 	"errors"
 	"fmt"
 	"os"
-	"strings"
 
 	fuse "github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse"
 	fs "github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse/fs"
@@ -194,7 +193,7 @@ func (s *Root) Lookup(ctx context.Context, name string) (fs.Node, error) {
 
 	segments := resolved.Segments()
 	if segments[0] == "ipfs" {
-		p := strings.Join(resolved.Segments()[1:], "/")
+		p := path.Join(resolved.Segments()[1:])
 		return &Link{s.IpfsRoot + "/" + p}, nil
 	}
 

merkledag/utils/utils.go

@@ -2,7 +2,6 @@ package dagutils
 
 import (
 	"errors"
-	"strings"
 
 	ds "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
 	syncds "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/sync"
@@ -12,6 +11,7 @@ import (
 	bserv "github.com/ipfs/go-ipfs/blockservice"
 	offline "github.com/ipfs/go-ipfs/exchange/offline"
 	dag "github.com/ipfs/go-ipfs/merkledag"
+	path "github.com/ipfs/go-ipfs/path"
 )
 
 type Editor struct {
@@ -76,8 +76,8 @@ func addLink(ctx context.Context, ds dag.DAGService, root *dag.Node, childname s
 	return root, nil
 }
 
-func (e *Editor) InsertNodeAtPath(ctx context.Context, path string, toinsert *dag.Node, create func() *dag.Node) error {
-	splpath := strings.Split(path, "/")
+func (e *Editor) InsertNodeAtPath(ctx context.Context, pth string, toinsert *dag.Node, create func() *dag.Node) error {
+	splpath := path.SplitList(pth)
 	nd, err := e.insertNodeAtPath(ctx, e.root, splpath, toinsert, create)
 	if err != nil {
 		return err
@@ -130,8 +130,8 @@ func (e *Editor) insertNodeAtPath(ctx context.Context, root *dag.Node, path []st
 	return root, nil
 }
 
-func (e *Editor) RmLink(ctx context.Context, path string) error {
-	splpath := strings.Split(path, "/")
+func (e *Editor) RmLink(ctx context.Context, pth string) error {
+	splpath := path.SplitList(pth)
 	nd, err := e.rmLink(ctx, e.root, splpath)
 	if err != nil {
 		return err

merkledag/utils/utils_test.go

@@ -1,12 +1,12 @@
 package dagutils
 
 import (
-	"strings"
 	"testing"
 
 	key "github.com/ipfs/go-ipfs/blocks/key"
 	dag "github.com/ipfs/go-ipfs/merkledag"
 	mdtest "github.com/ipfs/go-ipfs/merkledag/test"
+	path "github.com/ipfs/go-ipfs/path"
 
 	context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
 )
@@ -43,8 +43,8 @@ func TestAddLink(t *testing.T) {
 	}
 }
 
-func assertNodeAtPath(t *testing.T, ds dag.DAGService, root *dag.Node, path string, exp key.Key) {
-	parts := strings.Split(path, "/")
+func assertNodeAtPath(t *testing.T, ds dag.DAGService, root *dag.Node, pth string, exp key.Key) {
+	parts := path.SplitList(pth)
 	cur := root
 	for _, e := range parts {
 		nxt, err := cur.GetLinkedNode(context.Background(), ds, e)

mfs/mfs_test.go

@@ -8,12 +8,12 @@ import (
 	"io/ioutil"
 	"os"
 	"sort"
-	"strings"
 	"testing"
 
 	ds "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
 	dssync "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/sync"
 	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
+	"github.com/ipfs/go-ipfs/path"
 
 	bstore "github.com/ipfs/go-ipfs/blocks/blockstore"
 	key "github.com/ipfs/go-ipfs/blocks/key"
@@ -43,8 +43,8 @@ func getRandFile(t *testing.T, ds dag.DAGService, size int64) *dag.Node {
 	return nd
 }
 
-func mkdirP(t *testing.T, root *Directory, path string) *Directory {
-	dirs := strings.Split(path, "/")
+func mkdirP(t *testing.T, root *Directory, pth string) *Directory {
+	dirs := path.SplitList(pth)
 	cur := root
 	for _, d := range dirs {
 		n, err := cur.Mkdir(d)
@@ -69,15 +69,15 @@ func mkdirP(t *testing.T, root *Directory, path string) *Directory {
 	return cur
 }
 
-func assertDirAtPath(root *Directory, path string, children []string) error {
-	fsn, err := DirLookup(root, path)
+func assertDirAtPath(root *Directory, pth string, children []string) error {
+	fsn, err := DirLookup(root, pth)
 	if err != nil {
 		return err
 	}
 
 	dir, ok := fsn.(*Directory)
 	if !ok {
-		return fmt.Errorf("%s was not a directory", path)
+		return fmt.Errorf("%s was not a directory", pth)
 	}
 
 	listing, err := dir.List()
@@ -113,13 +113,13 @@ func compStrArrs(a, b []string) bool {
 	return true
 }
 
-func assertFileAtPath(ds dag.DAGService, root *Directory, exp *dag.Node, path string) error {
-	parts := strings.Split(path, "/")
+func assertFileAtPath(ds dag.DAGService, root *Directory, exp *dag.Node, pth string) error {
+	parts := path.SplitList(pth)
 	cur := root
 	for i, d := range parts[:len(parts)-1] {
 		next, err := cur.Child(d)
 		if err != nil {
-			return fmt.Errorf("looking for %s failed: %s", path, err)
+			return fmt.Errorf("looking for %s failed: %s", pth, err)
 		}
 
 		nextDir, ok := next.(*Directory)
@@ -138,7 +138,7 @@ func assertFileAtPath(ds dag.DAGService, root *Directory, exp *dag.Node, path st
 
 	file, ok := finaln.(*File)
 	if !ok {
-		return fmt.Errorf("%s was not a file!", path)
+		return fmt.Errorf("%s was not a file!", pth)
 	}
 
 	out, err := ioutil.ReadAll(file)

mfs/ops.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	dag "github.com/ipfs/go-ipfs/merkledag"
+	path "github.com/ipfs/go-ipfs/path"
 )
 
 // Mv moves the file or directory at 'src' to 'dst'
@@ -99,8 +100,8 @@ func PutNode(r *Root, path string, nd *dag.Node) error {
 
 // Mkdir creates a directory at 'path' under the directory 'd', creating
 // intermediary directories as needed if 'parents' is set to true
-func Mkdir(r *Root, path string, parents bool) error {
-	parts := strings.Split(path, "/")
+func Mkdir(r *Root, pth string, parents bool) error {
+	parts := path.SplitList(pth)
 	if parts[0] == "" {
 		parts = parts[1:]
 	}
@@ -112,7 +113,7 @@ func Mkdir(r *Root, path string, parents bool) error {
 
 	if len(parts) == 0 {
 		// this will only happen on 'mkdir /'
-		return fmt.Errorf("cannot mkdir '%s'", path)
+		return fmt.Errorf("cannot mkdir '%s'", pth)
 	}
 
 	cur := r.GetValue().(*Directory)
@@ -130,7 +131,7 @@ func Mkdir(r *Root, path string, parents bool) error {
 
 		next, ok := fsn.(*Directory)
 		if !ok {
-			return fmt.Errorf("%s was not a directory", strings.Join(parts[:i], "/"))
+			return fmt.Errorf("%s was not a directory", path.Join(parts[:i]))
 		}
 		cur = next
 	}
@@ -156,9 +157,9 @@ func Lookup(r *Root, path string) (FSNode, error) {
 
 // DirLookup will look up a file or directory at the given path
 // under the directory 'd'
-func DirLookup(d *Directory, path string) (FSNode, error) {
-	path = strings.Trim(path, "/")
-	parts := strings.Split(path, "/")
+func DirLookup(d *Directory, pth string) (FSNode, error) {
+	pth = strings.Trim(pth, "/")
+	parts := path.SplitList(pth)
 	if len(parts) == 1 && parts[0] == "" {
 		return d, nil
 	}
@@ -168,7 +169,7 @@ func DirLookup(d *Directory, path string) (FSNode, error) {
 	for i, p := range parts {
 		chdir, ok := cur.(*Directory)
 		if !ok {
-			return nil, fmt.Errorf("cannot access %s: Not a directory", strings.Join(parts[:i+1], "/"))
+			return nil, fmt.Errorf("cannot access %s: Not a directory", path.Join(parts[:i+1]))
 		}
 
 		child, err := chdir.Child(p)