libgo/go/path/path.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // Package path implements utility routines for manipulating slash-separated
   6 // paths.
   7 //
   8 // The path package should only be used for paths separated by forward
   9 // slashes, such as the paths in URLs. This package does not deal with
  10 // Windows paths with drive letters or backslashes; to manipulate
  11 // operating system paths, use the path/filepath package.
  12 package path
  13
  14 // A lazybuf is a lazily constructed path buffer.
  15 // It supports append, reading previously appended bytes,
  16 // and retrieving the final string. It does not allocate a buffer
  17 // to hold the output until that output diverges from s.
  18 type lazybuf struct {
  19         s   string
  20         buf []byte
  21         w   int
  22 }
  23
  24 func (b *lazybuf) index(i int) byte {
  25         if b.buf != nil {
  26                 return b.buf[i]
  27         }
  28         return b.s[i]
  29 }
  30
  31 func (b *lazybuf) append(c byte) {
  32         if b.buf == nil {
  33                 if b.w < len(b.s) && b.s[b.w] == c {
  34                         b.w++
  35                         return
  36                 }
  37                 b.buf = make([]byte, len(b.s))
  38                 copy(b.buf, b.s[:b.w])
  39         }
  40         b.buf[b.w] = c
  41         b.w++
  42 }
  43
  44 func (b *lazybuf) string() string {
  45         if b.buf == nil {
  46                 return b.s[:b.w]
  47         }
  48         return string(b.buf[:b.w])
  49 }
  50
  51 // Clean returns the shortest path name equivalent to path
  52 // by purely lexical processing. It applies the following rules
  53 // iteratively until no further processing can be done:
  54 //
  55 //      1. Replace multiple slashes with a single slash.
  56 //      2. Eliminate each . path name element (the current directory).
  57 //      3. Eliminate each inner .. path name element (the parent directory)
  58 //         along with the non-.. element that precedes it.
  59 //      4. Eliminate .. elements that begin a rooted path:
  60 //         that is, replace "/.." by "/" at the beginning of a path.
  61 //
  62 // The returned path ends in a slash only if it is the root "/".
  63 //
  64 // If the result of this process is an empty string, Clean
  65 // returns the string ".".
  66 //
  67 // See also Rob Pike, ``Lexical File Names in Plan 9 or
  68 // Getting Dot-Dot Right,''
  69 // https://9p.io/sys/doc/lexnames.html
  70 func Clean(path string) string {
  71         if path == "" {
  72                 return "."
  73         }
  74
  75         rooted := path[0] == '/'
  76         n := len(path)
  77
  78         // Invariants:
  79         //      reading from path; r is index of next byte to process.
  80         //      writing to buf; w is index of next byte to write.
  81         //      dotdot is index in buf where .. must stop, either because
  82         //              it is the leading slash or it is a leading ../../.. prefix.
  83         out := lazybuf{s: path}
  84         r, dotdot := 0, 0
  85         if rooted {
  86                 out.append('/')
  87                 r, dotdot = 1, 1
  88         }
  89
  90         for r < n {
  91                 switch {
  92                 case path[r] == '/':
  93                         // empty path element
  94                         r++
  95                 case path[r] == '.' && (r+1 == n || path[r+1] == '/'):
  96                         // . element
  97                         r++
  98                 case path[r] == '.' && path[r+1] == '.' && (r+2 == n || path[r+2] == '/'):
  99                         // .. element: remove to last /
 100                         r += 2
 101                         switch {
 102                         case out.w > dotdot:
 103                                 // can backtrack
 104                                 out.w--
 105                                 for out.w > dotdot && out.index(out.w) != '/' {
 106                                         out.w--
 107                                 }
 108                         case !rooted:
 109                                 // cannot backtrack, but not rooted, so append .. element.
 110                                 if out.w > 0 {
 111                                         out.append('/')
 112                                 }
 113                                 out.append('.')
 114                                 out.append('.')
 115                                 dotdot = out.w
 116                         }
 117                 default:
 118                         // real path element.
 119                         // add slash if needed
 120                         if rooted && out.w != 1 || !rooted && out.w != 0 {
 121                                 out.append('/')
 122                         }
 123                         // copy element
 124                         for ; r < n && path[r] != '/'; r++ {
 125                                 out.append(path[r])
 126                         }
 127                 }
 128         }
 129
 130         // Turn empty string into "."
 131         if out.w == 0 {
 132                 return "."
 133         }
 134
 135         return out.string()
 136 }
 137
 138 // lastSlash(s) is strings.LastIndex(s, "/") but we can't import strings.
 139 func lastSlash(s string) int {
 140         i := len(s) - 1
 141         for i >= 0 && s[i] != '/' {
 142                 i--
 143         }
 144         return i
 145 }
 146
 147 // Split splits path immediately following the final slash,
 148 // separating it into a directory and file name component.
 149 // If there is no slash in path, Split returns an empty dir and
 150 // file set to path.
 151 // The returned values have the property that path = dir+file.
 152 func Split(path string) (dir, file string) {
 153         i := lastSlash(path)
 154         return path[:i+1], path[i+1:]
 155 }
 156
 157 // Join joins any number of path elements into a single path,
 158 // separating them with slashes. Empty elements are ignored.
 159 // The result is Cleaned. However, if the argument list is
 160 // empty or all its elements are empty, Join returns
 161 // an empty string.
 162 func Join(elem ...string) string {
 163         size := 0
 164         for _, e := range elem {
 165                 size += len(e)
 166         }
 167         if size == 0 {
 168                 return ""
 169         }
 170         buf := make([]byte, 0, size+len(elem)-1)
 171         for _, e := range elem {
 172                 if len(buf) > 0 || e != "" {
 173                         if len(buf) > 0 {
 174                                 buf = append(buf, '/')
 175                         }
 176                         buf = append(buf, e...)
 177                 }
 178         }
 179         return Clean(string(buf))
 180 }
 181
 182 // Ext returns the file name extension used by path.
 183 // The extension is the suffix beginning at the final dot
 184 // in the final slash-separated element of path;
 185 // it is empty if there is no dot.
 186 func Ext(path string) string {
 187         for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- {
 188                 if path[i] == '.' {
 189                         return path[i:]
 190                 }
 191         }
 192         return ""
 193 }
 194
 195 // Base returns the last element of path.
 196 // Trailing slashes are removed before extracting the last element.
 197 // If the path is empty, Base returns ".".
 198 // If the path consists entirely of slashes, Base returns "/".
 199 func Base(path string) string {
 200         if path == "" {
 201                 return "."
 202         }
 203         // Strip trailing slashes.
 204         for len(path) > 0 && path[len(path)-1] == '/' {
 205                 path = path[0 : len(path)-1]
 206         }
 207         // Find the last element
 208         if i := lastSlash(path); i >= 0 {
 209                 path = path[i+1:]
 210         }
 211         // If empty now, it had only slashes.
 212         if path == "" {
 213                 return "/"
 214         }
 215         return path
 216 }
 217
 218 // IsAbs reports whether the path is absolute.
 219 func IsAbs(path string) bool {
 220         return len(path) > 0 && path[0] == '/'
 221 }
 222
 223 // Dir returns all but the last element of path, typically the path's directory.
 224 // After dropping the final element using Split, the path is Cleaned and trailing
 225 // slashes are removed.
 226 // If the path is empty, Dir returns ".".
 227 // If the path consists entirely of slashes followed by non-slash bytes, Dir
 228 // returns a single slash. In any other case, the returned path does not end in a
 229 // slash.
 230 func Dir(path string) string {
 231         dir, _ := Split(path)
 232         return Clean(dir)
 233 }