path/filepath: Split should trim trailing path separator else a Split stalemate occurs.

[odeke-em]

1. What version of Go are you using (go version)?
2. What operating system and processor architecture are you using?

go version go1.2.1 linux/386
Linux emmanuel-HP-G50-Notebook-PC 3.13.0-39-generic #66-Ubuntu SMP Tue Oct 28 13:31:23 UTC 2014 i686 athlon i686 GNU/Linux

go version go1.3 darwin/amd64
Darwin 14.1.0 Darwin Kernel Version 14.1.0: Mon Dec 22 23:10:38 PST 2014; root:xnu-2782.10.72~2/RELEASE_X86_64 x86_64

filepath.Split returns a dir and base when given a path 'p'. If the path has no trailing separator, it behaves as expected producing dir and base. If p has a trailing path separator e.g 'p/', filepath.Split should return 'p' as the dir, and '' as the base. However, filepath.Split always returns the original value as the dir and '' as the base value, instead of 'p', '' e.g in http://play.golang.org/p/fswqGij8Hu

This behaviour causes an infinite loop when walking up a path. My use case is trying to find the least non existant path starting from the end of a path. In the code excerpt below:

• The first function is my work-around to solve the problem by always trimming the excess '/'.
• The second function illustrates the issue and never exits since it is stuck at the original path being the dir.
• Assumption is that a "" signifies no existant path was found.

package main

import (
    "fmt"
    "os"
    "path/filepath"
    "strings"
)

var PathSeparator = fmt.Sprintf("%c", os.PathSeparator)

func leastNonExistantRootPatched(p string) string {
    last := ""
    for p != "" {
        fInfo, _ := os.Stat(p)
        if fInfo != nil {
            break
        }
        last = p
        p, _ = filepath.Split(strings.TrimRight(p, PathSeparator))
        fmt.Println("Still spinning: ", p)
    }
    return last
}

func leastNonExistantRootInfinite(p string) string {
    last := ""
    for p != "" {
        fInfo, _ := os.Stat(p)
        if fInfo != nil {
            break
        }
        last = p
        p, _ = filepath.Split(p)
        fmt.Println("Still spinning: ", p)
    }
    return last
}

func main() {
    leastNonExistantRootPatched("/mnt/ghosting/symver/projects/gophers/alophering/change.go")
    leastNonExistantRootInfinite("/mnt/ghosting/symver/projects/gophers/alophering/change.go/")
}

Please contrast this with the behaviour of Python

>>> import os
>>> os.path.split('/mnt/ghosting/gophers/alophering/change.go/')
('/mnt/ghosting/gophers/alophering/change.go', '') # Notice the trailing slash was removed
>>> os.path.split('/mnt/ghosting/gophers/alophering/change.go')
('/mnt/ghosting/gophers/alophering', 'change.go')

[minux]

If you want to walk a path, use filepath.Dir.

Note that the document of filepath.Split makes the behavior very clear:
Split splits path immediately following the final Separator, separating it into a directory and file name component. If there is no Separator in path, Split returns an empty dir and file set to path. The returned values have the property that path = dir+file.

Note the last sentence.

[odeke-em]

So what happens when I want to extract a dir as well as file from a path that may contain a trailing '/'? Would I have to first TrimRight for every string or instead perform two separate calls?

dir, file := filepath.Dir(p), filepath.Base(p)

I see your response directly helps with walking but the last sentence doesn't fit my issue which is that the dir and file should then be extracted. In the original examples, if I wanted dir, file, I would still be stuck in that infinite loop, something a user that hasn't investigated this issue would not be aware of unless they performed a trim or two separate function calls.

[adg]

We cannot change the semantics of filepath.Split now. https://golang.org/doc/go1compat

[mattn]

Call filepath.Clean before filepath.Split to remove last slash.

http://play.golang.org/p/bHy-iM-zM-

[odeke-em]

@adg alright, but if there was a way of letting some folks know about it. I realize that it isn't Go's behavior to make the transition from other languages to using Go intuitive, and probably change semantics just for that case since Go has its own docs and specs. However, it took me a lot of hours and a couple of bugs reported in a program that I am using this for, for me to investigate it. I was expecting filepath.Split to be deterministic the way other languages have it, regardless of whether there was a trailing '/' or not.
@mattn sounds like a plan. I was actually doing a strings.Trim*.

Correction: * Go's responsibility instead of Go's behavior.

[adg]

I sent a change to add an example for the Spit function to make its behaviour more obvious:
https://go-review.googlesource.com/5416

[odeke-em]

Thank you @adg. At least this example will leave a hint.