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)