// Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package path implements utility routines for manipulating slash-separated // paths. // // The path package should only be used for paths separated by forward // slashes, such as the paths in URLs. This package does not deal with // Windows paths with drive letters or backslashes; to manipulate // operating system paths, use the [path/filepath] package. package path import "internal/bytealg" // A lazybuf is a lazily constructed path buffer. // It supports append, reading previously appended bytes, // and retrieving the final string. It does not allocate a buffer // to hold the output until that output diverges from s. type lazybuf struct { s string buf []byte w int } func (b *lazybuf) index(i int) byte { if b.buf != nil { return b.buf[i] } return b.s[i] } func (b *lazybuf) append(c byte) { if b.buf == nil { if b.w < len(b.s) && b.s[b.w] == c { b.w++ return } b.buf = make([]byte, len(b.s)) copy(b.buf, b.s[:b.w]) } b.buf[b.w] = c b.w++ } func (b *lazybuf) string() string { if b.buf == nil { return b.s[:b.w] } return string(b.buf[:b.w]) } // Clean returns the shortest path name equivalent to path // by purely lexical processing. It applies the following rules // iteratively until no further processing can be done: // // 1. Replace multiple slashes with a single slash. // 2. Eliminate each . path name element (the current directory). // 3. Eliminate each inner .. path name element (the parent directory) // along with the non-.. element that precedes it. // 4. Eliminate .. elements that begin a rooted path: // that is, replace "/.." by "/" at the beginning of a path. // // The returned path ends in a slash only if it is the root "/". // // If the result of this process is an empty string, Clean // returns the string ".". // // See also Rob Pike, “Lexical File Names in Plan 9 or // Getting Dot-Dot Right,” // https://9p.io/sys/doc/lexnames.html func Clean(path string) string { if path == "" { return "." } rooted := path[0] == '/' n := len(path) // Invariants: // reading from path; r is index of next byte to process. // writing to buf; w is index of next byte to write. // dotdot is index in buf where .. must stop, either because // it is the leading slash or it is a leading ../../.. prefix. out := lazybuf{s: path} r, dotdot := 0, 0 if rooted { out.append('/') r, dotdot = 1, 1 } for r < n { switch { case path[r] == '/': // empty path element r++ case path[r] == '.' && (r+1 == n || path[r+1] == '/'): // . element r++ case path[r] == '.' && path[r+1] == '.' && (r+2 == n || path[r+2] == '/'): // .. element: remove to last / r += 2 switch { case out.w > dotdot: // can backtrack out.w-- for out.w > dotdot && out.index(out.w) != '/' { out.w-- } case !rooted: // cannot backtrack, but not rooted, so append .. element. if out.w > 0 { out.append('/') } out.append('.') out.append('.') dotdot = out.w } default: // real path element. // add slash if needed if rooted && out.w != 1 || !rooted && out.w != 0 { out.append('/') } // copy element for ; r < n && path[r] != '/'; r++ { out.append(path[r]) } } } // Turn empty string into "." if out.w == 0 { return "." } return out.string() } // Split splits path immediately following the final slash, // separating it into a directory and file name component. // If there is no slash in path, Split returns an empty dir and // file set to path. // The returned values have the property that path = dir+file. func Split(path string) (dir, file string) { i := bytealg.LastIndexByteString(path, '/') return path[:i+1], path[i+1:] } // Join joins any number of path elements into a single path, // separating them with slashes. Empty elements are ignored. // The result is Cleaned. However, if the argument list is // empty or all its elements are empty, Join returns // an empty string. func Join(elem ...string) string { size := 0 for _, e := range elem { size += len(e) } if size == 0 { return "" } buf := make([]byte, 0, size+len(elem)-1) for _, e := range elem { if len(buf) > 0 || e != "" { if len(buf) > 0 { buf = append(buf, '/') } buf = append(buf, e...) } } return Clean(string(buf)) } // Ext returns the file name extension used by path. // The extension is the suffix beginning at the final dot // in the final slash-separated element of path; // it is empty if there is no dot. func Ext(path string) string { for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- { if path[i] == '.' { return path[i:] } } return "" } // Base returns the last element of path. // Trailing slashes are removed before extracting the last element. // If the path is empty, Base returns ".". // If the path consists entirely of slashes, Base returns "/". func Base(path string) string { if path == "" { return "." } // Strip trailing slashes. for len(path) > 0 && path[len(path)-1] == '/' { path = path[0 : len(path)-1] } // Find the last element if i := bytealg.LastIndexByteString(path, '/'); i >= 0 { path = path[i+1:] } // If empty now, it had only slashes. if path == "" { return "/" } return path } // IsAbs reports whether the path is absolute. func IsAbs(path string) bool { return len(path) > 0 && path[0] == '/' } // Dir returns all but the last element of path, typically the path's directory. // After dropping the final element using [Split], the path is Cleaned and trailing // slashes are removed. // If the path is empty, Dir returns ".". // If the path consists entirely of slashes followed by non-slash bytes, Dir // returns a single slash. In any other case, the returned path does not end in a // slash. func Dir(path string) string { dir, _ := Split(path) return Clean(dir) }