+35 -15

internal/core/adt/expr.go

reviewed

··· 980 980 Value Value // Could become Value later, using disjunctions for defaults. 981 981 } 982 982 983 983 + // Kind returns the kind mask of this parameter. 983 984 func (p Param) Kind() Kind { 984 985 return p.Value.Kind() 985 986 } 986 987 988 988 + // Default reports the default value for this Param or nil if there is none. 987 989 func (p Param) Default() Value { 988 990 d, ok := p.Value.(*Disjunction) 989 991 if !ok || d.NumDefaults != 1 { ··· 1009 1011 return &BuiltinValidator{Builtin: x} 1010 1012 } 1011 1013 1012 1012 - func (x *Builtin) IsValidator(numArgs int) bool { 1013 1013 - return len(x.Params)-1 == numArgs && x.Result&^BoolKind == 0 1014 1014 + // IsValidator reports whether b should be interpreted as a Validator for the 1015 1015 + // given number of arguments. 1016 1016 + func (b *Builtin) IsValidator(numArgs int) bool { 1017 1017 + return numArgs == len(b.Params)-1 && 1018 1018 + b.Result&^BoolKind == 0 && 1019 1019 + b.Params[numArgs].Default() == nil 1014 1020 } 1015 1021 1016 1022 func bottom(v Value) *Bottom { ··· 1040 1046 args = append(args, v) 1041 1047 } 1042 1048 for i, a := range args { 1043 1043 - if x.Params[i].Kind() != BottomKind { 1044 1044 - if b := bottom(a); b != nil { 1045 1045 - return b 1049 1049 + if x.Params[i].Kind() == BottomKind { 1050 1050 + continue 1051 1051 + } 1052 1052 + if b := bottom(a); b != nil { 1053 1053 + return b 1054 1054 + } 1055 1055 + if k := kind(a); x.Params[i].Kind()&k == BottomKind { 1056 1056 + code := EvalError 1057 1057 + b, _ := args[i].(*Bottom) 1058 1058 + if b != nil { 1059 1059 + code = b.Code 1046 1060 } 1047 1047 - if k := kind(a); x.Params[i].Kind()&k == BottomKind { 1048 1048 - code := EvalError 1049 1049 - b, _ := args[i].(*Bottom) 1050 1050 - if b != nil { 1051 1051 - code = b.Code 1052 1052 - } 1053 1053 - c.addErrf(code, pos(a), 1054 1054 - "cannot use %s (type %s) as %s in argument %d to %s", 1055 1055 - a, k, x.Params[i].Kind(), i+1, fun) 1056 1056 - return nil 1061 1061 + c.addErrf(code, pos(a), 1062 1062 + "cannot use %s (type %s) as %s in argument %d to %s", 1063 1063 + a, k, x.Params[i].Kind(), i+1, fun) 1064 1064 + return nil 1065 1065 + } 1066 1066 + v := x.Params[i].Value 1067 1067 + if _, ok := v.(*BasicType); !ok { 1068 1068 + env := c.Env(0) 1069 1069 + x := &BinaryExpr{Op: AndOp, X: v, Y: a} 1070 1070 + n := &Vertex{Conjuncts: []Conjunct{{env, x, 0}}} 1071 1071 + c.Unifier.Unify(c, n, Finalized) 1072 1072 + if _, ok := n.BaseValue.(*Bottom); ok { 1073 1073 + c.addErrf(0, pos(a), 1074 1074 + "cannot use %s as %s in argument %d to %s", 1075 1075 + a, v, i+1, fun) 1057 1076 } 1077 1077 + args[i] = n 1058 1078 } 1059 1079 } 1060 1080 return x.Func(c, args)

+5 -13

pkg/internal/builtin.go

reviewed

··· 55 55 } 56 56 57 57 type Param struct { 58 58 - Kind adt.Kind 59 59 - Value adt.Value // input constraint 60 60 - Default adt.Value // may be nil 58 58 + Kind adt.Kind 59 59 + Value adt.Value // input constraint (may be nil) 61 60 } 62 61 63 62 type Package struct { ··· 112 111 func toBuiltin(ctx *adt.OpContext, b *Builtin) *adt.Builtin { 113 112 params := make([]adt.Param, len(b.Params)) 114 113 for i, p := range b.Params { 115 115 - // TODO: use Value. 116 116 - params[i].Value = &adt.BasicType{K: p.Kind} 117 117 - if p.Default != nil { 118 118 - params[i].Value = &adt.Disjunction{ 119 119 - NumDefaults: 1, 120 120 - Values: []*adt.Vertex{ 121 121 - adt.ToVertex(p.Default), 122 122 - adt.ToVertex(params[i].Value), 123 123 - }, 124 124 - } 114 114 + params[i].Value = p.Value 115 115 + if params[i].Value == nil { 116 116 + params[i].Value = &adt.BasicType{K: p.Kind} 125 117 } 126 118 } 127 119

-28

pkg/path/manual.go

reviewed

··· 1 1 - // Copyright 2018 The CUE Authors 2 2 - // 3 3 - // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 - // you may not use this file except in compliance with the License. 5 5 - // You may obtain a copy of the License at 6 6 - // 7 7 - // http://www.apache.org/licenses/LICENSE-2.0 8 8 - // 9 9 - // Unless required by applicable law or agreed to in writing, software 10 10 - // distributed under the License is distributed on an "AS IS" BASIS, 11 11 - // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 - // See the License for the specific language governing permissions and 13 13 - // limitations under the License. 14 14 - 15 15 - package path 16 16 - 17 17 - import "path" 18 18 - 19 19 - var split = path.Split 20 20 - 21 21 - // Split splits path immediately following the final slash and returns them as 22 22 - // the list [dir, file], separating it into a directory and file name component. 23 23 - // If there is no slash in path, Split returns an empty dir and file set to 24 24 - // path. The returned values have the property that path = dir+file. 25 25 - func Split(path string) []string { 26 26 - file, dir := split(path) 27 27 - return []string{file, dir} 28 28 - }

+362 -55

pkg/path/path.go

reviewed

··· 1 1 - // Copyright 2020 The CUE Authors 1 1 + // Copyright 2020 CUE Authors 2 2 // 3 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 // you may not use this file except in compliance with the License. ··· 12 12 // See the License for the specific language governing permissions and 13 13 // limitations under the License. 14 14 15 15 - // Copyright 2018 The Go Authors. All rights reserved. 15 15 + // Copyright 2009 The Go Authors. All rights reserved. 16 16 // Use of this source code is governed by a BSD-style 17 17 // license that can be found in the LICENSE file. 18 18 19 19 - //go:generate go run cuelang.org/go/internal/cmd/qgo -exclude=Split,Join extract path 19 19 + // Package filepath implements utility routines for manipulating filename paths 20 20 + // in a way compatible with the target operating system-defined file paths. 21 21 + // 22 22 + // The filepath package uses either forward slashes or backslashes, 23 23 + // depending on the operating system. To process paths such as URLs 24 24 + // that always use forward slashes regardless of the operating 25 25 + // system, see the path package. 26 26 + package path 27 27 + 28 28 + import ( 29 29 + "errors" 30 30 + "strings" 31 31 + ) 32 32 + 33 33 + // A lazybuf is a lazily constructed path buffer. 34 34 + // It supports append, reading previously appended bytes, 35 35 + // and retrieving the final string. It does not allocate a buffer 36 36 + // to hold the output until that output diverges. 37 37 + type lazybuf struct { 38 38 + path string 39 39 + buf []byte 40 40 + w int 41 41 + volAndPath string 42 42 + volLen int 43 43 + } 20 44 21 21 - package path 45 45 + func (b *lazybuf) index(i int) byte { 46 46 + if b.buf != nil { 47 47 + return b.buf[i] 48 48 + } 49 49 + return b.path[i] 50 50 + } 22 51 23 23 - import "path" 52 52 + func (b *lazybuf) append(c byte) { 53 53 + if b.buf == nil { 54 54 + if b.w < len(b.path) && b.path[b.w] == c { 55 55 + b.w++ 56 56 + return 57 57 + } 58 58 + b.buf = make([]byte, len(b.path)) 59 59 + copy(b.buf, b.path[:b.w]) 60 60 + } 61 61 + b.buf[b.w] = c 62 62 + b.w++ 63 63 + } 24 64 25 25 - // Match reports whether name matches the shell pattern. 26 26 - // The pattern syntax is: 27 27 - // 28 28 - // pattern: 29 29 - // { term } 30 30 - // term: 31 31 - // '*' matches any sequence of non-/ characters 32 32 - // '?' matches any single non-/ character 33 33 - // '[' [ '^' ] { character-range } ']' 34 34 - // character class (must be non-empty) 35 35 - // c matches character c (c != '*', '?', '\\', '[') 36 36 - // '\\' c matches character c 37 37 - // 38 38 - // character-range: 39 39 - // c matches character c (c != '\\', '-', ']') 40 40 - // '\\' c matches character c 41 41 - // lo '-' hi matches character c for lo <= c <= hi 42 42 - // 43 43 - // Match requires pattern to match all of name, not just a substring. 44 44 - // The only possible returned error is ErrBadPattern, when pattern 45 45 - // is malformed. 46 46 - // 47 47 - func Match(pattern, name string) (matched bool, err error) { 48 48 - return path.Match(pattern, name) 65 65 + func (b *lazybuf) string() string { 66 66 + if b.buf == nil { 67 67 + return b.volAndPath[:b.volLen+b.w] 68 68 + } 69 69 + return b.volAndPath[:b.volLen] + string(b.buf[:b.w]) 49 70 } 50 71 51 72 // Clean returns the shortest path name equivalent to path 52 52 - // by purely lexical processing. It applies the following rules 73 73 + // by purely lexical processing. The default value for os is Unix. 74 74 + // It applies the following rules 53 75 // iteratively until no further processing can be done: 54 76 // 55 55 - // 1. Replace multiple slashes with a single slash. 77 77 + // 1. Replace multiple Separator elements with a single one. 56 78 // 2. Eliminate each . path name element (the current directory). 57 79 // 3. Eliminate each inner .. path name element (the parent directory) 58 80 // along with the non-.. element that precedes it. 59 81 // 4. Eliminate .. elements that begin a rooted path: 60 60 - // that is, replace "/.." by "/" at the beginning of a path. 82 82 + // that is, replace "/.." by "/" at the beginning of a path, 83 83 + // assuming Separator is '/'. 61 84 // 62 62 - // The returned path ends in a slash only if it is the root "/". 85 85 + // The returned path ends in a slash only if it represents a root directory, 86 86 + // such as "/" on Unix or `C:\` on Windows. 87 87 + // 88 88 + // Finally, any occurrences of slash are replaced by Separator. 63 89 // 64 90 // If the result of this process is an empty string, Clean 65 91 // returns the string ".". ··· 67 93 // See also Rob Pike, ``Lexical File Names in Plan 9 or 68 94 // Getting Dot-Dot Right,'' 69 95 // https://9p.io/sys/doc/lexnames.html 70 70 - func Clean(path string) string { return pathClean(path) } 96 96 + func Clean(path string, os OS) string { 97 97 + return clean(path, getOS(os)) 98 98 + } 99 99 + 100 100 + func clean(path string, os os) string { 101 101 + originalPath := path 102 102 + volLen := os.volumeNameLen(path) 103 103 + path = path[volLen:] 104 104 + if path == "" { 105 105 + if volLen > 1 && originalPath[1] != ':' { 106 106 + // should be UNC 107 107 + return fromSlash(originalPath, os) 108 108 + } 109 109 + return originalPath + "." 110 110 + } 111 111 + rooted := os.IsPathSeparator(path[0]) 112 112 + 113 113 + // Invariants: 114 114 + // reading from path; r is index of next byte to process. 115 115 + // writing to buf; w is index of next byte to write. 116 116 + // dotdot is index in buf where .. must stop, either because 117 117 + // it is the leading slash or it is a leading ../../.. prefix. 118 118 + n := len(path) 119 119 + out := lazybuf{path: path, volAndPath: originalPath, volLen: volLen} 120 120 + r, dotdot := 0, 0 121 121 + if rooted { 122 122 + out.append(os.Separator) 123 123 + r, dotdot = 1, 1 124 124 + } 125 125 + 126 126 + for r < n { 127 127 + switch { 128 128 + case os.IsPathSeparator(path[r]): 129 129 + // empty path element 130 130 + r++ 131 131 + case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])): 132 132 + // . element 133 133 + r++ 134 134 + case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])): 135 135 + // .. element: remove to last separator 136 136 + r += 2 137 137 + switch { 138 138 + case out.w > dotdot: 139 139 + // can backtrack 140 140 + out.w-- 141 141 + for out.w > dotdot && !os.IsPathSeparator(out.index(out.w)) { 142 142 + out.w-- 143 143 + } 144 144 + case !rooted: 145 145 + // cannot backtrack, but not rooted, so append .. element. 146 146 + if out.w > 0 { 147 147 + out.append(os.Separator) 148 148 + } 149 149 + out.append('.') 150 150 + out.append('.') 151 151 + dotdot = out.w 152 152 + } 153 153 + default: 154 154 + // real path element. 155 155 + // add slash if needed 156 156 + if rooted && out.w != 1 || !rooted && out.w != 0 { 157 157 + out.append(os.Separator) 158 158 + } 159 159 + // copy element 160 160 + for ; r < n && !os.IsPathSeparator(path[r]); r++ { 161 161 + out.append(path[r]) 162 162 + } 163 163 + } 164 164 + } 165 165 + 166 166 + // Turn empty string into "." 167 167 + if out.w == 0 { 168 168 + out.append('.') 169 169 + } 170 170 + 171 171 + return fromSlash(out.string(), os) 172 172 + } 173 173 + 174 174 + // ToSlash returns the result of replacing each separator character 175 175 + // in path with a slash ('/') character. Multiple separators are 176 176 + // replaced by multiple slashes. 177 177 + func ToSlash(path string, os OS) string { 178 178 + return toSlash(path, getOS(os)) 179 179 + } 180 180 + 181 181 + func toSlash(path string, os os) string { 182 182 + if os.Separator == '/' { 183 183 + return path 184 184 + } 185 185 + return strings.ReplaceAll(path, string(os.Separator), "/") 186 186 + } 187 187 + 188 188 + // FromSlash returns the result of replacing each slash ('/') character 189 189 + // in path with a separator character. Multiple slashes are replaced 190 190 + // by multiple separators. 191 191 + func FromSlash(path string, os OS) string { 192 192 + return fromSlash(path, getOS(os)) 193 193 + } 194 194 + 195 195 + func fromSlash(path string, os os) string { 196 196 + if os.Separator == '/' { 197 197 + return path 198 198 + } 199 199 + return strings.ReplaceAll(path, "/", string(os.Separator)) 200 200 + } 201 201 + 202 202 + // SplitList splits a list of paths joined by the OS-specific ListSeparator, 203 203 + // usually found in PATH or GOPATH environment variables. 204 204 + // Unlike strings.Split, SplitList returns an empty slice when passed an empty 205 205 + // string. 206 206 + func SplitList(path string, os OS) []string { 207 207 + return getOS(os).splitList(path) 208 208 + } 209 209 + 210 210 + // Split splits path immediately following the final slash and returns them as 211 211 + // the list [dir, file], separating it into a directory and file name component. 212 212 + // If there is no slash in path, Split returns an empty dir and file set to 213 213 + // path. The returned values have the property that path = dir+file. 214 214 + // The default value for os is Unix. 215 215 + func Split(path string, os OS) []string { 216 216 + x := getOS(os) 217 217 + vol := volumeName(path, x) 218 218 + i := len(path) - 1 219 219 + for i >= len(vol) && !x.IsPathSeparator(path[i]) { 220 220 + i-- 221 221 + } 222 222 + return []string{path[:i+1], path[i+1:]} 223 223 + } 71 224 72 72 - var pathClean = path.Clean 225 225 + // Join joins any number of path elements into a single path, 226 226 + // separating them with an OS specific Separator. Empty elements 227 227 + // are ignored. The result is Cleaned. However, if the argument 228 228 + // list is empty or all its elements are empty, Join returns 229 229 + // an empty string. 230 230 + // On Windows, the result will only be a UNC path if the first 231 231 + // non-empty element is a UNC path. 232 232 + // The default value for os is Unix. 233 233 + func Join(elem []string, os OS) string { 234 234 + return getOS(os).join(elem) 235 235 + } 73 236 74 237 // Ext returns the file name extension used by path. 75 238 // The extension is the suffix beginning at the final dot 76 76 - // in the final slash-separated element of path; 77 77 - // it is empty if there is no dot. 78 78 - func Ext(path string) string { return pathExt(path) } 239 239 + // in the final element of path; it is empty if there is 240 240 + // no dot. The default value for os is Unix. 241 241 + func Ext(path string, os OS) string { 242 242 + x := getOS(os) 243 243 + for i := len(path) - 1; i >= 0 && !x.IsPathSeparator(path[i]); i-- { 244 244 + if path[i] == '.' { 245 245 + return path[i:] 246 246 + } 247 247 + } 248 248 + return "" 249 249 + } 79 250 80 80 - var pathExt = path.Ext 251 251 + // Resolve reports the path of sub relative to dir. If sub is an absolute path, 252 252 + // or if dir is empty, it will return sub. If sub is empty, it will return dir. 253 253 + // Resolve calls Clean on the result. The default value for os is Unix. 254 254 + func Resolve(dir, sub string, os OS) string { 255 255 + x := getOS(os) 256 256 + if x.IsAbs(sub) { 257 257 + return clean(sub, x) 258 258 + } 259 259 + dir = clean(dir, x) 260 260 + return x.join([]string{dir, sub}) 261 261 + } 262 262 + 263 263 + // Rel returns a relative path that is lexically equivalent to targpath when 264 264 + // joined to basepath with an intervening separator. That is, 265 265 + // Join(basepath, Rel(basepath, targpath)) is equivalent to targpath itself. 266 266 + // On success, the returned path will always be relative to basepath, 267 267 + // even if basepath and targpath share no elements. 268 268 + // An error is returned if targpath can't be made relative to basepath or if 269 269 + // knowing the current working directory would be necessary to compute it. 270 270 + // Rel calls Clean on the result. The default value for os is Unix. 271 271 + func Rel(basepath, targpath string, os OS) (string, error) { 272 272 + x := getOS(os) 273 273 + baseVol := volumeName(basepath, x) 274 274 + targVol := volumeName(targpath, x) 275 275 + base := clean(basepath, x) 276 276 + targ := clean(targpath, x) 277 277 + if x.sameWord(targ, base) { 278 278 + return ".", nil 279 279 + } 280 280 + base = base[len(baseVol):] 281 281 + targ = targ[len(targVol):] 282 282 + if base == "." { 283 283 + base = "" 284 284 + } 285 285 + // Can't use IsAbs - `\a` and `a` are both relative in Windows. 286 286 + baseSlashed := len(base) > 0 && base[0] == x.Separator 287 287 + targSlashed := len(targ) > 0 && targ[0] == x.Separator 288 288 + if baseSlashed != targSlashed || !x.sameWord(baseVol, targVol) { 289 289 + return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath) 290 290 + } 291 291 + // Position base[b0:bi] and targ[t0:ti] at the first differing elements. 292 292 + bl := len(base) 293 293 + tl := len(targ) 294 294 + var b0, bi, t0, ti int 295 295 + for { 296 296 + for bi < bl && base[bi] != x.Separator { 297 297 + bi++ 298 298 + } 299 299 + for ti < tl && targ[ti] != x.Separator { 300 300 + ti++ 301 301 + } 302 302 + if !x.sameWord(targ[t0:ti], base[b0:bi]) { 303 303 + break 304 304 + } 305 305 + if bi < bl { 306 306 + bi++ 307 307 + } 308 308 + if ti < tl { 309 309 + ti++ 310 310 + } 311 311 + b0 = bi 312 312 + t0 = ti 313 313 + } 314 314 + if base[b0:bi] == ".." { 315 315 + return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath) 316 316 + } 317 317 + if b0 != bl { 318 318 + // Base elements left. Must go up before going down. 319 319 + seps := strings.Count(base[b0:bl], string(x.Separator)) 320 320 + size := 2 + seps*3 321 321 + if tl != t0 { 322 322 + size += 1 + tl - t0 323 323 + } 324 324 + buf := make([]byte, size) 325 325 + n := copy(buf, "..") 326 326 + for i := 0; i < seps; i++ { 327 327 + buf[n] = x.Separator 328 328 + copy(buf[n+1:], "..") 329 329 + n += 3 330 330 + } 331 331 + if t0 != tl { 332 332 + buf[n] = x.Separator 333 333 + copy(buf[n+1:], targ[t0:]) 334 334 + } 335 335 + return string(buf), nil 336 336 + } 337 337 + return targ[t0:], nil 338 338 + } 81 339 82 340 // Base returns the last element of path. 83 83 - // Trailing slashes are removed before extracting the last element. 341 341 + // Trailing path separators are removed before extracting the last element. 84 342 // If the path is empty, Base returns ".". 85 85 - // If the path consists entirely of slashes, Base returns "/". 86 86 - func Base(path string) string { return pathBase(path) } 87 87 - 88 88 - var pathBase = path.Base 89 89 - 90 90 - // IsAbs reports whether the path is absolute. 91 91 - func IsAbs(path string) bool { return pathIsAbs(path) } 92 92 - 93 93 - var pathIsAbs = path.IsAbs 343 343 + // If the path consists entirely of separators, Base returns a single separator. 344 344 + // The default value for os is Unix. 345 345 + func Base(path string, os OS) string { 346 346 + x := getOS(os) 347 347 + if path == "" { 348 348 + return "." 349 349 + } 350 350 + // Strip trailing slashes. 351 351 + for len(path) > 0 && x.IsPathSeparator(path[len(path)-1]) { 352 352 + path = path[0 : len(path)-1] 353 353 + } 354 354 + // Throw away volume name 355 355 + path = path[x.volumeNameLen(path):] 356 356 + // Find the last element 357 357 + i := len(path) - 1 358 358 + for i >= 0 && !x.IsPathSeparator(path[i]) { 359 359 + i-- 360 360 + } 361 361 + if i >= 0 { 362 362 + path = path[i+1:] 363 363 + } 364 364 + // If empty now, it had only slashes. 365 365 + if path == "" { 366 366 + return string(x.Separator) 367 367 + } 368 368 + return path 369 369 + } 94 370 95 371 // Dir returns all but the last element of path, typically the path's directory. 96 96 - // After dropping the final element using Split, the path is Cleaned and trailing 372 372 + // After dropping the final element, Dir calls Clean on the path and trailing 97 373 // slashes are removed. 98 374 // If the path is empty, Dir returns ".". 99 99 - // If the path consists entirely of slashes followed by non-slash bytes, Dir 100 100 - // returns a single slash. In any other case, the returned path does not end in a 101 101 - // slash. 102 102 - func Dir(path string) string { return pathDir(path) } 375 375 + // If the path consists entirely of separators, Dir returns a single separator. 376 376 + // The returned path does not end in a separator unless it is the root directory. 377 377 + // The default value for os is Unix. 378 378 + func Dir(path string, os OS) string { 379 379 + x := getOS(os) 380 380 + vol := volumeName(path, x) 381 381 + i := len(path) - 1 382 382 + for i >= len(vol) && !x.IsPathSeparator(path[i]) { 383 383 + i-- 384 384 + } 385 385 + dir := clean(path[len(vol):i+1], x) 386 386 + if dir == "." && len(vol) > 2 { 387 387 + // must be UNC 388 388 + return vol 389 389 + } 390 390 + return vol + dir 391 391 + } 103 392 104 104 - var pathDir = path.Dir 393 393 + // IsAbs reports whether the path is absolute. The default value for os is Unix. 394 394 + // Note that because IsAbs has a default value, it cannot be used as 395 395 + // a validator. 396 396 + func IsAbs(path string, os OS) bool { 397 397 + return getOS(os).IsAbs(path) 398 398 + } 399 399 + 400 400 + // VolumeName returns leading volume name. 401 401 + // Given "C:\foo\bar" it returns "C:" on Windows. 402 402 + // Given "\\host\share\foo" it returns "\\host\share". 403 403 + // On other platforms it returns "". 404 404 + // The default value for os is Windows. 405 405 + func VolumeName(path string, os OS) string { 406 406 + return volumeName(path, getOS(os)) 407 407 + } 408 408 + 409 409 + func volumeName(path string, os os) string { 410 410 + return path[:os.volumeNameLen(path)] 411 411 + }

+184 -20

pkg/path/pkg.go

reviewed

··· 1 1 - // Code generated by go generate. DO NOT EDIT. 2 2 - 3 3 - //go:generate rm pkg.go 4 4 - //go:generate go run ../gen/gen.go 1 1 + // Copyright 2020 CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 5 14 6 15 package path 7 16 ··· 16 25 17 26 var _ = adt.TopKind // in case the adt package isn't used 18 27 28 28 + var ( 29 29 + osRequired = &adt.Disjunction{ 30 30 + Values: allOS, 31 31 + } 32 32 + 33 33 + unixDefault = &adt.Disjunction{ 34 34 + NumDefaults: 1, 35 35 + Values: allOS, 36 36 + } 37 37 + 38 38 + // windowsDefault is the default for VolumeName. 39 39 + windowsDefault = &adt.Disjunction{ 40 40 + NumDefaults: 1, 41 41 + Values: append([]*adt.Vertex{ 42 42 + newStr("windows"), 43 43 + newStr("unix"), 44 44 + newStr("plan9")}, unixOS...), 45 45 + } 46 46 + 47 47 + allOS = append([]*adt.Vertex{ 48 48 + newStr("unix"), 49 49 + newStr("windows"), 50 50 + newStr("plan9"), 51 51 + }, unixOS...) 52 52 + 53 53 + // These all fall back to unix 54 54 + unixOS = []*adt.Vertex{ 55 55 + newStr("aix"), 56 56 + newStr("android"), 57 57 + newStr("darwin"), 58 58 + newStr("dragonfly"), 59 59 + newStr("freebsd"), 60 60 + newStr("hurd"), 61 61 + newStr("illumos"), 62 62 + newStr("ios"), 63 63 + newStr("js"), 64 64 + newStr("linux"), 65 65 + newStr("nacl"), 66 66 + newStr("netbsd"), 67 67 + newStr("openbsd"), 68 68 + newStr("solaris"), 69 69 + newStr("zos"), 70 70 + } 71 71 + ) 72 72 + 73 73 + func newStr(s string) *adt.Vertex { 74 74 + v := &adt.Vertex{} 75 75 + v.SetValue(nil, adt.Finalized, &adt.String{Str: s}) 76 76 + return v 77 77 + } 78 78 + 19 79 var pkg = &internal.Package{ 80 80 + CUE: `{ 81 81 + Unix: "unix" 82 82 + Windows: "windows" 83 83 + Plan9: "plan9" 84 84 + }`, 20 85 Native: []*internal.Builtin{{ 21 86 Name: "Split", 22 87 Params: []internal.Param{ 23 88 {Kind: adt.StringKind}, 89 89 + {Kind: adt.StringKind, Value: unixDefault}, 24 90 }, 25 91 Result: adt.ListKind, 26 92 Func: func(c *internal.CallCtxt) { 27 27 - path := c.String(0) 93 93 + path, os := c.String(0), c.String(1) 28 94 if c.Do() { 29 29 - c.Ret = Split(path) 95 95 + c.Ret = Split(path, OS(os)) 30 96 } 31 97 }, 32 98 }, { 33 33 - Name: "Match", 99 99 + Name: "SplitList", 34 100 Params: []internal.Param{ 35 101 {Kind: adt.StringKind}, 102 102 + {Kind: adt.StringKind, Value: osRequired}, 103 103 + }, 104 104 + Result: adt.ListKind, 105 105 + Func: func(c *internal.CallCtxt) { 106 106 + path, os := c.String(0), c.String(1) 107 107 + if c.Do() { 108 108 + c.Ret = SplitList(path, OS(os)) 109 109 + } 110 110 + }, 111 111 + }, { 112 112 + Name: "Join", 113 113 + Params: []internal.Param{ 114 114 + {Kind: adt.ListKind}, 115 115 + {Kind: adt.StringKind, Value: unixDefault}, 116 116 + }, 117 117 + Result: adt.StringKind, 118 118 + Func: func(c *internal.CallCtxt) { 119 119 + list, os := c.StringList(0), c.String(1) 120 120 + if c.Do() { 121 121 + c.Ret = Join(list, OS(os)) 122 122 + } 123 123 + }, 124 124 + }, { 125 125 + Name: "Match", 126 126 + Params: []internal.Param{ 36 127 {Kind: adt.StringKind}, 128 128 + {Kind: adt.StringKind, Value: unixDefault}, 37 129 }, 38 130 Result: adt.BoolKind, 39 131 Func: func(c *internal.CallCtxt) { 40 40 - pattern, name := c.String(0), c.String(1) 132 132 + pattern, name, os := c.String(0), c.String(1), c.String(2) 41 133 if c.Do() { 42 42 - c.Ret, c.Err = Match(pattern, name) 134 134 + c.Ret, c.Err = Match(pattern, name, OS(os)) 43 135 } 44 136 }, 45 137 }, { 46 138 Name: "Clean", 47 139 Params: []internal.Param{ 48 140 {Kind: adt.StringKind}, 141 141 + {Kind: adt.StringKind, Value: unixDefault}, 49 142 }, 50 143 Result: adt.StringKind, 51 144 Func: func(c *internal.CallCtxt) { 52 52 - path := c.String(0) 145 145 + path, os := c.String(0), c.String(1) 146 146 + if c.Do() { 147 147 + c.Ret = Clean(path, OS(os)) 148 148 + } 149 149 + }, 150 150 + }, { 151 151 + Name: "ToSlash", 152 152 + Params: []internal.Param{ 153 153 + {Kind: adt.StringKind}, 154 154 + {Kind: adt.StringKind, Value: osRequired}, 155 155 + }, 156 156 + Result: adt.StringKind, 157 157 + Func: func(c *internal.CallCtxt) { 158 158 + path, os := c.String(0), c.String(1) 159 159 + if c.Do() { 160 160 + c.Ret = ToSlash(path, OS(os)) 161 161 + } 162 162 + }, 163 163 + }, { 164 164 + Name: "FromSlash", 165 165 + Params: []internal.Param{ 166 166 + {Kind: adt.StringKind}, 167 167 + {Kind: adt.StringKind, Value: osRequired}, 168 168 + }, 169 169 + Result: adt.StringKind, 170 170 + Func: func(c *internal.CallCtxt) { 171 171 + path, os := c.String(0), c.String(1) 53 172 if c.Do() { 54 54 - c.Ret = Clean(path) 173 173 + c.Ret = FromSlash(path, OS(os)) 55 174 } 56 175 }, 57 176 }, { 58 177 Name: "Ext", 59 178 Params: []internal.Param{ 60 179 {Kind: adt.StringKind}, 180 180 + {Kind: adt.StringKind, Value: unixDefault}, 61 181 }, 62 182 Result: adt.StringKind, 63 183 Func: func(c *internal.CallCtxt) { 64 64 - path := c.String(0) 184 184 + path, os := c.String(0), c.String(1) 65 185 if c.Do() { 66 66 - c.Ret = Ext(path) 186 186 + c.Ret = Ext(path, OS(os)) 187 187 + } 188 188 + }, 189 189 + }, { 190 190 + Name: "Resolve", 191 191 + Params: []internal.Param{ 192 192 + {Kind: adt.StringKind}, 193 193 + {Kind: adt.StringKind}, 194 194 + {Kind: adt.StringKind, Value: unixDefault}, 195 195 + }, 196 196 + Result: adt.StringKind, 197 197 + Func: func(c *internal.CallCtxt) { 198 198 + dir, sub, os := c.String(0), c.String(1), c.String(2) 199 199 + if c.Do() { 200 200 + c.Ret = Resolve(dir, sub, OS(os)) 201 201 + } 202 202 + }, 203 203 + }, { 204 204 + Name: "Rel", 205 205 + Params: []internal.Param{ 206 206 + {Kind: adt.StringKind}, 207 207 + {Kind: adt.StringKind}, 208 208 + {Kind: adt.StringKind, Value: unixDefault}, 209 209 + }, 210 210 + Result: adt.StringKind, 211 211 + Func: func(c *internal.CallCtxt) { 212 212 + base, target, os := c.String(0), c.String(1), c.String(2) 213 213 + if c.Do() { 214 214 + c.Ret, c.Err = Rel(base, target, OS(os)) 67 215 } 68 216 }, 69 217 }, { 70 218 Name: "Base", 71 219 Params: []internal.Param{ 72 220 {Kind: adt.StringKind}, 221 221 + {Kind: adt.StringKind, Value: unixDefault}, 73 222 }, 74 223 Result: adt.StringKind, 75 224 Func: func(c *internal.CallCtxt) { 76 76 - path := c.String(0) 225 225 + path, os := c.String(0), c.String(1) 226 226 + if c.Do() { 227 227 + c.Ret = Base(path, OS(os)) 228 228 + } 229 229 + }, 230 230 + }, { 231 231 + Name: "Dir", 232 232 + Params: []internal.Param{ 233 233 + {Kind: adt.StringKind}, 234 234 + {Kind: adt.StringKind, Value: unixDefault}, 235 235 + }, 236 236 + Result: adt.StringKind, 237 237 + Func: func(c *internal.CallCtxt) { 238 238 + path, os := c.String(0), c.String(1) 77 239 if c.Do() { 78 78 - c.Ret = Base(path) 240 240 + c.Ret = Dir(path, OS(os)) 79 241 } 80 242 }, 81 243 }, { 82 244 Name: "IsAbs", 83 245 Params: []internal.Param{ 84 246 {Kind: adt.StringKind}, 247 247 + {Kind: adt.StringKind, Value: unixDefault}, 85 248 }, 86 249 Result: adt.BoolKind, 87 250 Func: func(c *internal.CallCtxt) { 88 88 - path := c.String(0) 251 251 + path, os := c.String(0), c.String(1) 89 252 if c.Do() { 90 90 - c.Ret = IsAbs(path) 253 253 + c.Ret = IsAbs(path, OS(os)) 91 254 } 92 255 }, 93 256 }, { 94 94 - Name: "Dir", 257 257 + Name: "VolumeName", 95 258 Params: []internal.Param{ 96 259 {Kind: adt.StringKind}, 260 260 + {Kind: adt.StringKind, Value: windowsDefault}, 97 261 }, 98 262 Result: adt.StringKind, 99 263 Func: func(c *internal.CallCtxt) { 100 100 - path := c.String(0) 264 264 + path, os := c.String(0), c.String(1) 101 265 if c.Do() { 102 102 - c.Ret = Dir(path) 266 266 + c.Ret = VolumeName(path, OS(os)) 103 267 } 104 268 }, 105 269 }},

+28

pkg/path/testdata/error.txtar

reviewed

··· 1 1 + // Copyright 2020 CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 14 14 + 15 15 + -- in.cue -- 16 16 + import "path" 17 17 + 18 18 + joinOK: path.Join(["a", "b"], "aix") 19 19 + joinErr: path.Join(["a", "b"], "foo") 20 20 + -- out/path -- 21 21 + Errors: 22 22 + joinErr: cannot use "foo" as *"unix" | "windows" | "plan9" | "aix" | "android" | "darwin" | "dragonfly" | "freebsd" | "hurd" | "illumos" | "ios" | "js" | "linux" | "nacl" | "netbsd" | "openbsd" | "solaris" | "zos" in argument 2 to path.Join: 23 23 + ./in.cue:4:32 24 24 + 25 25 + Result: 26 26 + joinOK: "a/b" 27 27 + joinErr: _|_ // joinErr: cannot use "foo" as *"unix" | "windows" | "plan9" | "aix" | "android" | "darwin" | "dragonfly" | "freebsd" | "hurd" | "illumos" | "ios" | "js" | "linux" | "nacl" | "netbsd" | "openbsd" | "solaris" | "zos" in argument 2 to path.Join (and 1 more errors) 28 28 +

pkg/path/testdata/example_nix_test.go pkg/path/example_nix_test.go

reviewed

pkg/path/testdata/example_test.go pkg/path/example_test.go

reviewed

+205

pkg/path/testdata/join.txtar

reviewed

··· 1 1 + // Copyright 2020 CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 14 14 + 15 15 + 16 16 + -- in.cue -- 17 17 + import "path" 18 18 + 19 19 + joinSingle: path.Join(["a", "b"]) 20 20 + joinSingle: "a/b" 21 21 + 22 22 + Join: unix: _ 23 23 + Join: windows: _ 24 24 + 25 25 + Join: [OS=string]: [...{ 26 26 + arg: [...string] 27 27 + 28 28 + out: path.Join(arg, OS) 29 29 + }] 30 30 + 31 31 + Join: [_]: [ 32 32 + {arg: ["a", "b"]}, 33 33 + {arg: ["a/b", "c/d"]}, 34 34 + 35 35 + {arg: ["/"]}, 36 36 + {arg: ["a"]}, 37 37 + 38 38 + {arg: ["a", "b"]}, 39 39 + {arg: ["a", ""]}, 40 40 + {arg: ["", "b"]}, 41 41 + {arg: ["/", "a"]}, 42 42 + {arg: ["/", "a/b"]}, 43 43 + {arg: ["/", ""]}, 44 44 + {arg: ["//", "a"]}, 45 45 + 46 46 + {arg: ["directory", "file"]}, 47 47 + 48 48 + {arg: [#"C:\Windows\"#, #"System32"#]}, 49 49 + {arg: [#"C:\Windows\"#, #""#]}, 50 50 + {arg: [#"C:\"#, #"Windows"#]}, 51 51 + {arg: [#"C:"#, #"a\b"#]}, 52 52 + {arg: [#"C:"#, #"a"#, #"b"#]}, 53 53 + {arg: [#"C:"#, #""#, #""#, #"b"#]}, 54 54 + {arg: [#"C:"#, #""#]}, 55 55 + {arg: [#"C:"#, #""#, #""#]}, 56 56 + {arg: [#"C:."#, #"a"#]}, 57 57 + {arg: [#"C:a"#, #"b"#]}, 58 58 + {arg: [#"\\host\share"#, #"foo"#]}, 59 59 + ] 60 60 + 61 61 + -- out/path -- 62 62 + joinSingle: "a/b" 63 63 + Join: { 64 64 + unix: [{ 65 65 + arg: ["a", "b"] 66 66 + out: "a/b" 67 67 + }, { 68 68 + arg: ["a/b", "c/d"] 69 69 + out: "a/b/c/d" 70 70 + }, { 71 71 + arg: ["/"] 72 72 + out: "/" 73 73 + }, { 74 74 + arg: ["a"] 75 75 + out: "a" 76 76 + }, { 77 77 + arg: ["a", "b"] 78 78 + out: "a/b" 79 79 + }, { 80 80 + arg: ["a", ""] 81 81 + out: "a" 82 82 + }, { 83 83 + arg: ["", "b"] 84 84 + out: "b" 85 85 + }, { 86 86 + arg: ["/", "a"] 87 87 + out: "/a" 88 88 + }, { 89 89 + arg: ["/", "a/b"] 90 90 + out: "/a/b" 91 91 + }, { 92 92 + arg: ["/", ""] 93 93 + out: "/" 94 94 + }, { 95 95 + arg: ["//", "a"] 96 96 + out: "/a" 97 97 + }, { 98 98 + arg: ["directory", "file"] 99 99 + out: "directory/file" 100 100 + }, { 101 101 + arg: [#"C:\Windows\"#, #"System32"#] 102 102 + out: "C:\\Windows\\/System32" 103 103 + }, { 104 104 + arg: [#"C:\Windows\"#, #""#] 105 105 + out: "C:\\Windows\\" 106 106 + }, { 107 107 + arg: [#"C:\"#, #"Windows"#] 108 108 + out: "C:\\/Windows" 109 109 + }, { 110 110 + arg: [#"C:"#, #"a\b"#] 111 111 + out: "C:/a\\b" 112 112 + }, { 113 113 + arg: [#"C:"#, #"a"#, #"b"#] 114 114 + out: "C:/a/b" 115 115 + }, { 116 116 + arg: [#"C:"#, #""#, #""#, #"b"#] 117 117 + out: "C:/b" 118 118 + }, { 119 119 + arg: [#"C:"#, #""#] 120 120 + out: "C:" 121 121 + }, { 122 122 + arg: [#"C:"#, #""#, #""#] 123 123 + out: "C:" 124 124 + }, { 125 125 + arg: [#"C:."#, #"a"#] 126 126 + out: "C:./a" 127 127 + }, { 128 128 + arg: [#"C:a"#, #"b"#] 129 129 + out: "C:a/b" 130 130 + }, { 131 131 + arg: [#"\\host\share"#, #"foo"#] 132 132 + out: "\\\\host\\share/foo" 133 133 + }] 134 134 + windows: [{ 135 135 + arg: ["a", "b"] 136 136 + out: "a\\b" 137 137 + }, { 138 138 + arg: ["a/b", "c/d"] 139 139 + out: "a\\b\\c\\d" 140 140 + }, { 141 141 + arg: ["/"] 142 142 + out: "\\" 143 143 + }, { 144 144 + arg: ["a"] 145 145 + out: "a" 146 146 + }, { 147 147 + arg: ["a", "b"] 148 148 + out: "a\\b" 149 149 + }, { 150 150 + arg: ["a", ""] 151 151 + out: "a" 152 152 + }, { 153 153 + arg: ["", "b"] 154 154 + out: "b" 155 155 + }, { 156 156 + arg: ["/", "a"] 157 157 + out: "\\a" 158 158 + }, { 159 159 + arg: ["/", "a/b"] 160 160 + out: "\\a\\b" 161 161 + }, { 162 162 + arg: ["/", ""] 163 163 + out: "\\" 164 164 + }, { 165 165 + arg: ["//", "a"] 166 166 + out: "\\a" 167 167 + }, { 168 168 + arg: ["directory", "file"] 169 169 + out: "directory\\file" 170 170 + }, { 171 171 + arg: [#"C:\Windows\"#, #"System32"#] 172 172 + out: "C:\\Windows\\System32" 173 173 + }, { 174 174 + arg: [#"C:\Windows\"#, #""#] 175 175 + out: "C:\\Windows" 176 176 + }, { 177 177 + arg: [#"C:\"#, #"Windows"#] 178 178 + out: "C:\\Windows" 179 179 + }, { 180 180 + arg: [#"C:"#, #"a\b"#] 181 181 + out: "C:a\\b" 182 182 + }, { 183 183 + arg: [#"C:"#, #"a"#, #"b"#] 184 184 + out: "C:a\\b" 185 185 + }, { 186 186 + arg: [#"C:"#, #""#, #""#, #"b"#] 187 187 + out: "C:b" 188 188 + }, { 189 189 + arg: [#"C:"#, #""#] 190 190 + out: "C:." 191 191 + }, { 192 192 + arg: [#"C:"#, #""#, #""#] 193 193 + out: "C:." 194 194 + }, { 195 195 + arg: [#"C:."#, #"a"#] 196 196 + out: "C:a" 197 197 + }, { 198 198 + arg: [#"C:a"#, #"b"#] 199 199 + out: "C:a\\b" 200 200 + }, { 201 201 + arg: [#"\\host\share"#, #"foo"#] 202 202 + out: "\\\\host\\share\\foo" 203 203 + }] 204 204 + } 205 205 +

pkg/path/testdata/match.go pkg/path/match.go

reviewed

pkg/path/testdata/match_test.go pkg/path/match_test.go

reviewed

+1

pkg/path/testdata/os.go pkg/path/os.go

reviewed

··· 14 14 15 15 package path 16 16 17 17 + // OS must be a valid runtime.GOOS value or "unix". 17 18 type OS string 18 19 19 20 const (

+504

pkg/path/testdata/os.txtar

reviewed

··· 1 1 + // Copyright 2020 CUE Authors 2 2 + // 3 3 + // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 + // you may not use this file except in compliance with the License. 5 5 + // You may obtain a copy of the License at 6 6 + // 7 7 + // http://www.apache.org/licenses/LICENSE-2.0 8 8 + // 9 9 + // Unless required by applicable law or agreed to in writing, software 10 10 + // distributed under the License is distributed on an "AS IS" BASIS, 11 11 + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 + // See the License for the specific language governing permissions and 13 13 + // limitations under the License. 14 14 + 15 15 + 16 16 + -- in.cue -- 17 17 + import "path" 18 18 + 19 19 + #OSes: [path.Unix, path.Windows, path.Plan9] 20 20 + #AnyOS: or(#OSes) 21 21 + 22 22 + // Test these OSes for all tests below. 23 23 + { 24 24 + [string]: { 25 25 + unix: _ 26 26 + plan9: _ 27 27 + windows: _ 28 28 + } 29 29 + } 30 30 + 31 31 + Split: [OS=#AnyOS]: [ARG=string]: path.Split(ARG, OS) 32 32 + Split: default: [ARG=string]: path.Split(ARG) 33 33 + Split: default: Split.unix 34 34 + Split: [_]: { 35 35 + "/foo/bar/baz": _ 36 36 + "a/b": _ 37 37 + "//host/share/foo": _ 38 38 + #"\\host\share\foo"#: _ 39 39 + "c:/foo/bar": _ 40 40 + #"c:\foo\bar"#: _ 41 41 + } 42 42 + 43 43 + SplitList: [OS=string]: [ARG=string]: path.SplitList(ARG, OS) 44 44 + SplitList: [_]: { 45 45 + "a:b": _ 46 46 + "a\u0000b": _ 47 47 + "a;b": _ 48 48 + } 49 49 + 50 50 + Clean: [OS=#AnyOS]: [ARG=string]: path.Clean(ARG, OS) 51 51 + Clean: default: [ARG=string]: path.Clean(ARG) 52 52 + Clean: default: Clean.unix 53 53 + Clean: [_]: { 54 54 + "abc//def//ghi": _ 55 55 + #"c:\abc\def\..\.."#: _ 56 56 + } 57 57 + 58 58 + Slash: [OS=string]: [ARG=string]: { 59 59 + to: path.ToSlash(ARG, OS) 60 60 + from: path.FromSlash(ARG, OS) 61 61 + 62 62 + // should roundtrip 63 63 + to: path.ToSlash(from, OS) 64 64 + from: path.FromSlash(to, OS) 65 65 + } 66 66 + Slash: [_]: { 67 67 + "": _ 68 68 + "/": _ 69 69 + "/a/b": _ 70 70 + "/a//b": _ 71 71 + } 72 72 + 73 73 + Ext: [OS=#AnyOS]: [ARG=string]: path.Ext(ARG, OS) 74 74 + Ext: default: [ARG=string]: path.Ext(ARG) 75 75 + Ext: default: Ext.unix 76 76 + Ext: [_]: { 77 77 + // Same for all OS-es 78 78 + "path.go": ".go" 79 79 + "path.pb.go": ".go" 80 80 + "a.dir/b": "" 81 81 + "a.dir/b.go": ".go" 82 82 + "a.dir/": "" 83 83 + 84 84 + // Differs on Windows. 85 85 + "a.dir\\foo": _ 86 86 + } 87 87 + 88 88 + Resolve: [OS=#AnyOS]: [A1=_]: [A2=_]: path.Resolve(A1, A2, OS) 89 89 + Resolve: default: [A1=_]: [A2=_]: path.Resolve(A1, A2) 90 90 + Resolve: default: Resolve.unix 91 91 + Resolve: [_]: { 92 92 + "a/b/c": "d/e": _ 93 93 + "/a/b": "/c/d": _ 94 94 + "c:/a": #"d:\"#: _ 95 95 + 96 96 + "//home/user/foo": "bar": _ 97 97 + "//home/user/foo": "//other/abs/foo": _ 98 98 + } 99 99 + 100 100 + IsAbs: [OS=#AnyOS]: [ARG=string]: path.IsAbs(ARG, OS) 101 101 + IsAbs: default: [ARG=string]: path.IsAbs(ARG) 102 102 + IsAbs: default: IsAbs.unix 103 103 + IsAbs: [_]: { 104 104 + "": _ 105 105 + "/a": _ 106 106 + "a": _ 107 107 + "c:": _ 108 108 + "c:/": _ 109 109 + "c:\\": _ 110 110 + 111 111 + "//home/user/foo": _ 112 112 + } 113 113 + 114 114 + 115 115 + Volume: [OS=string]: [ARG=string]: path.VolumeName(ARG, OS) 116 116 + Volume: [!="windows"]: [string]: "" // non-windows is always "" 117 117 + Volume: [_]: { 118 118 + "c:/foo/bar": _ 119 119 + "c:": _ 120 120 + "2:": _ 121 121 + "": _ 122 122 + 123 123 + #"\\\host"#: _ 124 124 + #"\\\host\"#: _ 125 125 + #"\\\host\share"#: _ 126 126 + #"\\\host\\share"#: _ 127 127 + #"\\host"#: _ 128 128 + #"//host"#: _ 129 129 + #"\\host\"#: _ 130 130 + #"//host/"#: _ 131 131 + #"\\host\share"#: _ 132 132 + #"//host/share"#: _ 133 133 + #"\\host\share\"#: _ 134 134 + #"//host/share/"#: _ 135 135 + #"\\host\share\foo"#: _ 136 136 + #"//host/share/foo"#: _ 137 137 + 138 138 + #"\\host\share\\foo\\\bar\\\\baz"#: _ 139 139 + #"//host/share//foo///bar////baz"#: _ 140 140 + #"\\host\share\foo\..\bar"#: _ 141 141 + #"//host/share/foo/../bar"#: _ 142 142 + } 143 143 + 144 144 + -- out/path -- 145 145 + #OSes: ["unix", "windows", "plan9"] 146 146 + #AnyOS: "unix" | "windows" | "plan9" 147 147 + Split: { 148 148 + unix: { 149 149 + "/foo/bar/baz": ["/foo/bar/", "baz"] 150 150 + "a/b": ["a/", "b"] 151 151 + "//host/share/foo": ["//host/share/", "foo"] 152 152 + "\\\\host\\share\\foo": ["", "\\\\host\\share\\foo"] 153 153 + "c:/foo/bar": ["c:/foo/", "bar"] 154 154 + "c:\\foo\\bar": ["", "c:\\foo\\bar"] 155 155 + } 156 156 + plan9: { 157 157 + "/foo/bar/baz": ["/foo/bar/", "baz"] 158 158 + "a/b": ["a/", "b"] 159 159 + "//host/share/foo": ["//host/share/", "foo"] 160 160 + "\\\\host\\share\\foo": ["", "\\\\host\\share\\foo"] 161 161 + "c:/foo/bar": ["c:/foo/", "bar"] 162 162 + "c:\\foo\\bar": ["", "c:\\foo\\bar"] 163 163 + } 164 164 + default: { 165 165 + "/foo/bar/baz": ["/foo/bar/", "baz"] 166 166 + "a/b": ["a/", "b"] 167 167 + "//host/share/foo": ["//host/share/", "foo"] 168 168 + "\\\\host\\share\\foo": ["", "\\\\host\\share\\foo"] 169 169 + "c:/foo/bar": ["c:/foo/", "bar"] 170 170 + "c:\\foo\\bar": ["", "c:\\foo\\bar"] 171 171 + } 172 172 + windows: { 173 173 + "/foo/bar/baz": ["/foo/bar/", "baz"] 174 174 + "a/b": ["a/", "b"] 175 175 + "//host/share/foo": ["//host/share/", "foo"] 176 176 + "\\\\host\\share\\foo": ["\\\\host\\share\\", "foo"] 177 177 + "c:/foo/bar": ["c:/foo/", "bar"] 178 178 + "c:\\foo\\bar": ["c:\\foo\\", "bar"] 179 179 + } 180 180 + } 181 181 + SplitList: { 182 182 + unix: { 183 183 + "a:b": ["a", "b"] 184 184 + "a\u0000b": ["a\u0000b"] 185 185 + "a;b": ["a;b"] 186 186 + } 187 187 + plan9: { 188 188 + "a:b": ["a:b"] 189 189 + "a\u0000b": ["a", "b"] 190 190 + "a;b": ["a;b"] 191 191 + } 192 192 + windows: { 193 193 + "a:b": ["a:b"] 194 194 + "a\u0000b": ["a\u0000b"] 195 195 + "a;b": ["a", "b"] 196 196 + } 197 197 + } 198 198 + Clean: { 199 199 + unix: { 200 200 + "abc//def//ghi": "abc/def/ghi" 201 201 + "c:\\abc\\def\\..\\..": "c:\\abc\\def\\..\\.." 202 202 + } 203 203 + plan9: { 204 204 + "abc//def//ghi": "abc/def/ghi" 205 205 + "c:\\abc\\def\\..\\..": "c:\\abc\\def\\..\\.." 206 206 + } 207 207 + default: { 208 208 + "abc//def//ghi": "abc/def/ghi" 209 209 + "c:\\abc\\def\\..\\..": "c:\\abc\\def\\..\\.." 210 210 + } 211 211 + windows: { 212 212 + "abc//def//ghi": "abc\\def\\ghi" 213 213 + "c:\\abc\\def\\..\\..": "c:\\" 214 214 + } 215 215 + } 216 216 + Slash: { 217 217 + unix: { 218 218 + "": { 219 219 + // should roundtrip 220 220 + to: "" 221 221 + from: "" 222 222 + } 223 223 + "/": { 224 224 + // should roundtrip 225 225 + to: "/" 226 226 + from: "/" 227 227 + } 228 228 + "/a/b": { 229 229 + // should roundtrip 230 230 + to: "/a/b" 231 231 + from: "/a/b" 232 232 + } 233 233 + "/a//b": { 234 234 + // should roundtrip 235 235 + to: "/a//b" 236 236 + from: "/a//b" 237 237 + } 238 238 + } 239 239 + plan9: { 240 240 + "": { 241 241 + // should roundtrip 242 242 + to: "" 243 243 + from: "" 244 244 + } 245 245 + "/": { 246 246 + // should roundtrip 247 247 + to: "/" 248 248 + from: "/" 249 249 + } 250 250 + "/a/b": { 251 251 + // should roundtrip 252 252 + to: "/a/b" 253 253 + from: "/a/b" 254 254 + } 255 255 + "/a//b": { 256 256 + // should roundtrip 257 257 + to: "/a//b" 258 258 + from: "/a//b" 259 259 + } 260 260 + } 261 261 + windows: { 262 262 + "": { 263 263 + // should roundtrip 264 264 + to: "" 265 265 + from: "" 266 266 + } 267 267 + "/": { 268 268 + // should roundtrip 269 269 + to: "/" 270 270 + from: "\\" 271 271 + } 272 272 + "/a/b": { 273 273 + // should roundtrip 274 274 + to: "/a/b" 275 275 + from: "\\a\\b" 276 276 + } 277 277 + "/a//b": { 278 278 + // should roundtrip 279 279 + to: "/a//b" 280 280 + from: "\\a\\\\b" 281 281 + } 282 282 + } 283 283 + } 284 284 + Ext: { 285 285 + unix: { 286 286 + // Same for all OS-es 287 287 + "path.go": ".go" 288 288 + "path.pb.go": ".go" 289 289 + "a.dir/b": "" 290 290 + "a.dir/b.go": ".go" 291 291 + "a.dir/": "" 292 292 + 293 293 + // Differs on Windows. 294 294 + "a.dir\\foo": ".dir\\foo" 295 295 + } 296 296 + plan9: { 297 297 + // Same for all OS-es 298 298 + "path.go": ".go" 299 299 + "path.pb.go": ".go" 300 300 + "a.dir/b": "" 301 301 + "a.dir/b.go": ".go" 302 302 + "a.dir/": "" 303 303 + 304 304 + // Differs on Windows. 305 305 + "a.dir\\foo": ".dir\\foo" 306 306 + } 307 307 + default: { 308 308 + // Same for all OS-es 309 309 + "path.go": ".go" 310 310 + "path.pb.go": ".go" 311 311 + "a.dir/b": "" 312 312 + "a.dir/b.go": ".go" 313 313 + "a.dir/": "" 314 314 + 315 315 + // Differs on Windows. 316 316 + "a.dir\\foo": ".dir\\foo" 317 317 + } 318 318 + windows: { 319 319 + // Same for all OS-es 320 320 + "path.go": ".go" 321 321 + "path.pb.go": ".go" 322 322 + "a.dir/b": "" 323 323 + "a.dir/b.go": ".go" 324 324 + "a.dir/": "" 325 325 + 326 326 + // Differs on Windows. 327 327 + "a.dir\\foo": "" 328 328 + } 329 329 + } 330 330 + Resolve: { 331 331 + unix: { 332 332 + "a/b/c": { 333 333 + "d/e": "a/b/c/d/e" 334 334 + } 335 335 + "/a/b": { 336 336 + "/c/d": "/c/d" 337 337 + } 338 338 + "c:/a": { 339 339 + "d:\\": "c:/a/d:\\" 340 340 + } 341 341 + "//home/user/foo": { 342 342 + bar: "/home/user/foo/bar" 343 343 + "//other/abs/foo": "/other/abs/foo" 344 344 + } 345 345 + } 346 346 + plan9: { 347 347 + "a/b/c": { 348 348 + "d/e": "a/b/c/d/e" 349 349 + } 350 350 + "/a/b": { 351 351 + "/c/d": "/c/d" 352 352 + } 353 353 + "c:/a": { 354 354 + "d:\\": "c:/a/d:\\" 355 355 + } 356 356 + "//home/user/foo": { 357 357 + bar: "/home/user/foo/bar" 358 358 + "//other/abs/foo": "/other/abs/foo" 359 359 + } 360 360 + } 361 361 + default: { 362 362 + "a/b/c": { 363 363 + "d/e": "a/b/c/d/e" 364 364 + } 365 365 + "/a/b": { 366 366 + "/c/d": "/c/d" 367 367 + } 368 368 + "c:/a": { 369 369 + "d:\\": "c:/a/d:\\" 370 370 + } 371 371 + "//home/user/foo": { 372 372 + bar: "/home/user/foo/bar" 373 373 + "//other/abs/foo": "/other/abs/foo" 374 374 + } 375 375 + } 376 376 + windows: { 377 377 + "a/b/c": { 378 378 + "d/e": "a\\b\\c\\d\\e" 379 379 + } 380 380 + "/a/b": { 381 381 + "/c/d": "\\a\\b\\c\\d" 382 382 + } 383 383 + "c:/a": { 384 384 + "d:\\": "d:\\" 385 385 + } 386 386 + "//home/user/foo": { 387 387 + bar: "\\\\home\\user\\foo\\bar" 388 388 + "//other/abs/foo": "\\\\other\\abs\\foo" 389 389 + } 390 390 + } 391 391 + } 392 392 + IsAbs: { 393 393 + unix: { 394 394 + "": false 395 395 + "/a": true 396 396 + a: false 397 397 + "c:": false 398 398 + "c:/": false 399 399 + "c:\\": false 400 400 + "//home/user/foo": true 401 401 + } 402 402 + plan9: { 403 403 + "": false 404 404 + "/a": true 405 405 + a: false 406 406 + "c:": false 407 407 + "c:/": false 408 408 + "c:\\": false 409 409 + "//home/user/foo": true 410 410 + } 411 411 + default: { 412 412 + "": false 413 413 + "/a": true 414 414 + a: false 415 415 + "c:": false 416 416 + "c:/": false 417 417 + "c:\\": false 418 418 + "//home/user/foo": true 419 419 + } 420 420 + windows: { 421 421 + "": false 422 422 + "/a": false 423 423 + a: false 424 424 + "c:": false 425 425 + "c:/": true 426 426 + "c:\\": true 427 427 + "//home/user/foo": true 428 428 + } 429 429 + } 430 430 + Volume: { 431 431 + unix: { 432 432 + "c:/foo/bar": "" 433 433 + "c:": "" 434 434 + "2:": "" 435 435 + "": "" 436 436 + "\\\\\\host": "" 437 437 + "\\\\\\host\\": "" 438 438 + "\\\\\\host\\share": "" 439 439 + "\\\\\\host\\\\share": "" 440 440 + "\\\\host": "" 441 441 + "//host": "" 442 442 + "\\\\host\\": "" 443 443 + "//host/": "" 444 444 + "\\\\host\\share": "" 445 445 + "//host/share": "" 446 446 + "\\\\host\\share\\": "" 447 447 + "//host/share/": "" 448 448 + "\\\\host\\share\\foo": "" 449 449 + "//host/share/foo": "" 450 450 + "\\\\host\\share\\\\foo\\\\\\bar\\\\\\\\baz": "" 451 451 + "//host/share//foo///bar////baz": "" 452 452 + "\\\\host\\share\\foo\\..\\bar": "" 453 453 + "//host/share/foo/../bar": "" 454 454 + } 455 455 + plan9: { 456 456 + "c:/foo/bar": "" 457 457 + "c:": "" 458 458 + "2:": "" 459 459 + "": "" 460 460 + "\\\\\\host": "" 461 461 + "\\\\\\host\\": "" 462 462 + "\\\\\\host\\share": "" 463 463 + "\\\\\\host\\\\share": "" 464 464 + "\\\\host": "" 465 465 + "//host": "" 466 466 + "\\\\host\\": "" 467 467 + "//host/": "" 468 468 + "\\\\host\\share": "" 469 469 + "//host/share": "" 470 470 + "\\\\host\\share\\": "" 471 471 + "//host/share/": "" 472 472 + "\\\\host\\share\\foo": "" 473 473 + "//host/share/foo": "" 474 474 + "\\\\host\\share\\\\foo\\\\\\bar\\\\\\\\baz": "" 475 475 + "//host/share//foo///bar////baz": "" 476 476 + "\\\\host\\share\\foo\\..\\bar": "" 477 477 + "//host/share/foo/../bar": "" 478 478 + } 479 479 + windows: { 480 480 + "c:/foo/bar": "c:" 481 481 + "c:": "c:" 482 482 + "2:": "" 483 483 + "": "" 484 484 + "\\\\\\host": "" 485 485 + "\\\\\\host\\": "" 486 486 + "\\\\\\host\\share": "" 487 487 + "\\\\\\host\\\\share": "" 488 488 + "\\\\host": "" 489 489 + "//host": "" 490 490 + "\\\\host\\": "" 491 491 + "//host/": "" 492 492 + "\\\\host\\share": "\\\\host\\share" 493 493 + "//host/share": "//host/share" 494 494 + "\\\\host\\share\\": "\\\\host\\share" 495 495 + "//host/share/": "//host/share" 496 496 + "\\\\host\\share\\foo": "\\\\host\\share" 497 497 + "//host/share/foo": "//host/share" 498 498 + "\\\\host\\share\\\\foo\\\\\\bar\\\\\\\\baz": "\\\\host\\share" 499 499 + "//host/share//foo///bar////baz": "//host/share" 500 500 + "\\\\host\\share\\foo\\..\\bar": "\\\\host\\share" 501 501 + "//host/share/foo/../bar": "//host/share" 502 502 + } 503 503 + } 504 504 +

-414

pkg/path/testdata/path.go

reviewed

··· 1 1 - // Copyright 2020 CUE Authors 2 2 - // 3 3 - // Licensed under the Apache License, Version 2.0 (the "License"); 4 4 - // you may not use this file except in compliance with the License. 5 5 - // You may obtain a copy of the License at 6 6 - // 7 7 - // http://www.apache.org/licenses/LICENSE-2.0 8 8 - // 9 9 - // Unless required by applicable law or agreed to in writing, software 10 10 - // distributed under the License is distributed on an "AS IS" BASIS, 11 11 - // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 12 - // See the License for the specific language governing permissions and 13 13 - // limitations under the License. 14 14 - 15 15 - // Copyright 2009 The Go Authors. All rights reserved. 16 16 - // Use of this source code is governed by a BSD-style 17 17 - // license that can be found in the LICENSE file. 18 18 - 19 19 - // Package filepath implements utility routines for manipulating filename paths 20 20 - // in a way compatible with the target operating system-defined file paths. 21 21 - // 22 22 - // The filepath package uses either forward slashes or backslashes, 23 23 - // depending on the operating system. To process paths such as URLs 24 24 - // that always use forward slashes regardless of the operating 25 25 - // system, see the path package. 26 26 - package path 27 27 - 28 28 - import ( 29 29 - "errors" 30 30 - "strings" 31 31 - ) 32 32 - 33 33 - // A lazybuf is a lazily constructed path buffer. 34 34 - // It supports append, reading previously appended bytes, 35 35 - // and retrieving the final string. It does not allocate a buffer 36 36 - // to hold the output until that output diverges from s. 37 37 - type lazybuf struct { 38 38 - path string 39 39 - buf []byte 40 40 - w int 41 41 - volAndPath string 42 42 - volLen int 43 43 - } 44 44 - 45 45 - func (b *lazybuf) index(i int) byte { 46 46 - if b.buf != nil { 47 47 - return b.buf[i] 48 48 - } 49 49 - return b.path[i] 50 50 - } 51 51 - 52 52 - func (b *lazybuf) append(c byte) { 53 53 - if b.buf == nil { 54 54 - if b.w < len(b.path) && b.path[b.w] == c { 55 55 - b.w++ 56 56 - return 57 57 - } 58 58 - b.buf = make([]byte, len(b.path)) 59 59 - copy(b.buf, b.path[:b.w]) 60 60 - } 61 61 - b.buf[b.w] = c 62 62 - b.w++ 63 63 - } 64 64 - 65 65 - func (b *lazybuf) string() string { 66 66 - if b.buf == nil { 67 67 - return b.volAndPath[:b.volLen+b.w] 68 68 - } 69 69 - return b.volAndPath[:b.volLen] + string(b.buf[:b.w]) 70 70 - } 71 71 - 72 72 - // const ( 73 73 - // Separator = os.PathSeparator 74 74 - // ListSeparator = os.PathListSeparator 75 75 - // ) 76 76 - 77 77 - // Clean returns the shortest path name equivalent to path 78 78 - // by purely lexical processing. The default value for os is Unix. 79 79 - // It applies the following rules 80 80 - // iteratively until no further processing can be done: 81 81 - // 82 82 - // 1. Replace multiple Separator elements with a single one. 83 83 - // 2. Eliminate each . path name element (the current directory). 84 84 - // 3. Eliminate each inner .. path name element (the parent directory) 85 85 - // along with the non-.. element that precedes it. 86 86 - // 4. Eliminate .. elements that begin a rooted path: 87 87 - // that is, replace "/.." by "/" at the beginning of a path, 88 88 - // assuming Separator is '/'. 89 89 - // 90 90 - // The returned path ends in a slash only if it represents a root directory, 91 91 - // such as "/" on Unix or `C:\` on Windows. 92 92 - // 93 93 - // Finally, any occurrences of slash are replaced by Separator. 94 94 - // 95 95 - // If the result of this process is an empty string, Clean 96 96 - // returns the string ".". 97 97 - // 98 98 - // See also Rob Pike, ``Lexical File Names in Plan 9 or 99 99 - // Getting Dot-Dot Right,'' 100 100 - // https://9p.io/sys/doc/lexnames.html 101 101 - func Clean(path string, os OS) string { 102 102 - return clean(path, getOS(os)) 103 103 - } 104 104 - 105 105 - func clean(path string, os os) string { 106 106 - originalPath := path 107 107 - volLen := os.volumeNameLen(path) 108 108 - path = path[volLen:] 109 109 - if path == "" { 110 110 - if volLen > 1 && originalPath[1] != ':' { 111 111 - // should be UNC 112 112 - return fromSlash(originalPath, os) 113 113 - } 114 114 - return originalPath + "." 115 115 - } 116 116 - rooted := os.IsPathSeparator(path[0]) 117 117 - 118 118 - // Invariants: 119 119 - // reading from path; r is index of next byte to process. 120 120 - // writing to buf; w is index of next byte to write. 121 121 - // dotdot is index in buf where .. must stop, either because 122 122 - // it is the leading slash or it is a leading ../../.. prefix. 123 123 - n := len(path) 124 124 - out := lazybuf{path: path, volAndPath: originalPath, volLen: volLen} 125 125 - r, dotdot := 0, 0 126 126 - if rooted { 127 127 - out.append(os.Separator) 128 128 - r, dotdot = 1, 1 129 129 - } 130 130 - 131 131 - for r < n { 132 132 - switch { 133 133 - case os.IsPathSeparator(path[r]): 134 134 - // empty path element 135 135 - r++ 136 136 - case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])): 137 137 - // . element 138 138 - r++ 139 139 - case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])): 140 140 - // .. element: remove to last separator 141 141 - r += 2 142 142 - switch { 143 143 - case out.w > dotdot: 144 144 - // can backtrack 145 145 - out.w-- 146 146 - for out.w > dotdot && !os.IsPathSeparator(out.index(out.w)) { 147 147 - out.w-- 148 148 - } 149 149 - case !rooted: 150 150 - // cannot backtrack, but not rooted, so append .. element. 151 151 - if out.w > 0 { 152 152 - out.append(os.Separator) 153 153 - } 154 154 - out.append('.') 155 155 - out.append('.') 156 156 - dotdot = out.w 157 157 - } 158 158 - default: 159 159 - // real path element. 160 160 - // add slash if needed 161 161 - if rooted && out.w != 1 || !rooted && out.w != 0 { 162 162 - out.append(os.Separator) 163 163 - } 164 164 - // copy element 165 165 - for ; r < n && !os.IsPathSeparator(path[r]); r++ { 166 166 - out.append(path[r]) 167 167 - } 168 168 - } 169 169 - } 170 170 - 171 171 - // Turn empty string into "." 172 172 - if out.w == 0 { 173 173 - out.append('.') 174 174 - } 175 175 - 176 176 - return fromSlash(out.string(), os) 177 177 - } 178 178 - 179 179 - // ToSlash returns the result of replacing each separator character 180 180 - // in path with a slash ('/') character. Multiple separators are 181 181 - // replaced by multiple slashes. 182 182 - func ToSlash(path string, os OS) string { 183 183 - return toSlash(path, getOS(os)) 184 184 - } 185 185 - 186 186 - func toSlash(path string, os os) string { 187 187 - if os.Separator == '/' { 188 188 - return path 189 189 - } 190 190 - return strings.ReplaceAll(path, string(os.Separator), "/") 191 191 - } 192 192 - 193 193 - // FromSlash returns the result of replacing each slash ('/') character 194 194 - // in path with a separator character. Multiple slashes are replaced 195 195 - // by multiple separators. 196 196 - func FromSlash(path string, os OS) string { 197 197 - return fromSlash(path, getOS(os)) 198 198 - } 199 199 - 200 200 - func fromSlash(path string, os os) string { 201 201 - if os.Separator == '/' { 202 202 - return path 203 203 - } 204 204 - return strings.ReplaceAll(path, "/", string(os.Separator)) 205 205 - } 206 206 - 207 207 - // SplitList splits a list of paths joined by the OS-specific ListSeparator, 208 208 - // usually found in PATH or GOPATH environment variables. 209 209 - // Unlike strings.Split, SplitList returns an empty slice when passed an empty 210 210 - // string. 211 211 - func SplitList(path string, os OS) []string { 212 212 - return getOS(os).splitList(path) 213 213 - } 214 214 - 215 215 - // Split splits path immediately following the final slash and returns them as 216 216 - // the list [dir, file], separating it into a directory and file name component. 217 217 - // If there is no slash in path, Split returns an empty dir and file set to 218 218 - // path. The returned values have the property that path = dir+file. 219 219 - // The default value for os is Unix. 220 220 - func Split(path string, os OS) []string { 221 221 - x := getOS(os) 222 222 - vol := volumeName(path, x) 223 223 - i := len(path) - 1 224 224 - for i >= len(vol) && !x.IsPathSeparator(path[i]) { 225 225 - i-- 226 226 - } 227 227 - return []string{path[:i+1], path[i+1:]} 228 228 - } 229 229 - 230 230 - // Join joins any number of path elements into a single path, 231 231 - // separating them with an OS specific Separator. Empty elements 232 232 - // are ignored. The result is Cleaned. However, if the argument 233 233 - // list is empty or all its elements are empty, Join returns 234 234 - // an empty string. 235 235 - // On Windows, the result will only be a UNC path if the first 236 236 - // non-empty element is a UNC path. 237 237 - // The default value for os is Unix. 238 238 - func Join(elem []string, os OS) string { 239 239 - return getOS(os).join(elem) 240 240 - } 241 241 - 242 242 - // Ext returns the file name extension used by path. 243 243 - // The extension is the suffix beginning at the final dot 244 244 - // in the final element of path; it is empty if there is 245 245 - // no dot. The default value for os is Unix. 246 246 - func Ext(path string, os OS) string { 247 247 - x := getOS(os) 248 248 - for i := len(path) - 1; i >= 0 && !x.IsPathSeparator(path[i]); i-- { 249 249 - if path[i] == '.' { 250 250 - return path[i:] 251 251 - } 252 252 - } 253 253 - return "" 254 254 - } 255 255 - 256 256 - // Resolve reports the path of sub relative to dir. If sub is an absolute path, 257 257 - // or if dir is empty, it will return sub. If sub is empty, it will return dir. 258 258 - // Resolve calls Clean on the result. The default value for os is Unix. 259 259 - func Resolve(dir, sub string, os OS) string { 260 260 - x := getOS(os) 261 261 - if x.IsAbs(sub) { 262 262 - return clean(sub, x) 263 263 - } 264 264 - dir = clean(dir, x) 265 265 - return x.join([]string{dir, sub}) 266 266 - } 267 267 - 268 268 - // Rel returns a relative path that is lexically equivalent to targpath when 269 269 - // joined to basepath with an intervening separator. That is, 270 270 - // Join(basepath, Rel(basepath, targpath)) is equivalent to targpath itself. 271 271 - // On success, the returned path will always be relative to basepath, 272 272 - // even if basepath and targpath share no elements. 273 273 - // An error is returned if targpath can't be made relative to basepath or if 274 274 - // knowing the current working directory would be necessary to compute it. 275 275 - // Rel calls Clean on the result. The default value for os is Unix. 276 276 - func Rel(basepath, targpath string, os OS) (string, error) { 277 277 - x := getOS(os) 278 278 - baseVol := volumeName(basepath, x) 279 279 - targVol := volumeName(targpath, x) 280 280 - base := clean(basepath, x) 281 281 - targ := clean(targpath, x) 282 282 - if x.sameWord(targ, base) { 283 283 - return ".", nil 284 284 - } 285 285 - base = base[len(baseVol):] 286 286 - targ = targ[len(targVol):] 287 287 - if base == "." { 288 288 - base = "" 289 289 - } 290 290 - // Can't use IsAbs - `\a` and `a` are both relative in Windows. 291 291 - baseSlashed := len(base) > 0 && base[0] == x.Separator 292 292 - targSlashed := len(targ) > 0 && targ[0] == x.Separator 293 293 - if baseSlashed != targSlashed || !x.sameWord(baseVol, targVol) { 294 294 - return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath) 295 295 - } 296 296 - // Position base[b0:bi] and targ[t0:ti] at the first differing elements. 297 297 - bl := len(base) 298 298 - tl := len(targ) 299 299 - var b0, bi, t0, ti int 300 300 - for { 301 301 - for bi < bl && base[bi] != x.Separator { 302 302 - bi++ 303 303 - } 304 304 - for ti < tl && targ[ti] != x.Separator { 305 305 - ti++ 306 306 - } 307 307 - if !x.sameWord(targ[t0:ti], base[b0:bi]) { 308 308 - break 309 309 - } 310 310 - if bi < bl { 311 311 - bi++ 312 312 - } 313 313 - if ti < tl { 314 314 - ti++ 315 315 - } 316 316 - b0 = bi 317 317 - t0 = ti 318 318 - } 319 319 - if base[b0:bi] == ".." { 320 320 - return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath) 321 321 - } 322 322 - if b0 != bl { 323 323 - // Base elements left. Must go up before going down. 324 324 - seps := strings.Count(base[b0:bl], string(x.Separator)) 325 325 - size := 2 + seps*3 326 326 - if tl != t0 { 327 327 - size += 1 + tl - t0 328 328 - } 329 329 - buf := make([]byte, size) 330 330 - n := copy(buf, "..") 331 331 - for i := 0; i < seps; i++ { 332 332 - buf[n] = x.Separator 333 333 - copy(buf[n+1:], "..") 334 334 - n += 3 335 335 - } 336 336 - if t0 != tl { 337 337 - buf[n] = x.Separator 338 338 - copy(buf[n+1:], targ[t0:]) 339 339 - } 340 340 - return string(buf), nil 341 341 - } 342 342 - return targ[t0:], nil 343 343 - } 344 344 - 345 345 - // Base returns the last element of path. 346 346 - // Trailing path separators are removed before extracting the last element. 347 347 - // If the path is empty, Base returns ".". 348 348 - // If the path consists entirely of separators, Base returns a single separator. 349 349 - // The default value for os is Unix. 350 350 - func Base(path string, os OS) string { 351 351 - x := getOS(os) 352 352 - if path == "" { 353 353 - return "." 354 354 - } 355 355 - // Strip trailing slashes. 356 356 - for len(path) > 0 && x.IsPathSeparator(path[len(path)-1]) { 357 357 - path = path[0 : len(path)-1] 358 358 - } 359 359 - // Throw away volume name 360 360 - path = path[x.volumeNameLen(path):] 361 361 - // Find the last element 362 362 - i := len(path) - 1 363 363 - for i >= 0 && !x.IsPathSeparator(path[i]) { 364 364 - i-- 365 365 - } 366 366 - if i >= 0 { 367 367 - path = path[i+1:] 368 368 - } 369 369 - // If empty now, it had only slashes. 370 370 - if path == "" { 371 371 - return string(x.Separator) 372 372 - } 373 373 - return path 374 374 - } 375 375 - 376 376 - // Dir returns all but the last element of path, typically the path's directory. 377 377 - // After dropping the final element, Dir calls Clean on the path and trailing 378 378 - // slashes are removed. 379 379 - // If the path is empty, Dir returns ".". 380 380 - // If the path consists entirely of separators, Dir returns a single separator. 381 381 - // The returned path does not end in a separator unless it is the root directory. 382 382 - // The default value for os is Unix. 383 383 - func Dir(path string, os OS) string { 384 384 - x := getOS(os) 385 385 - vol := volumeName(path, x) 386 386 - i := len(path) - 1 387 387 - for i >= len(vol) && !x.IsPathSeparator(path[i]) { 388 388 - i-- 389 389 - } 390 390 - dir := clean(path[len(vol):i+1], x) 391 391 - if dir == "." && len(vol) > 2 { 392 392 - // must be UNC 393 393 - return vol 394 394 - } 395 395 - return vol + dir 396 396 - } 397 397 - 398 398 - // IsAbs reports whether the path is absolute. The default value for os is Unix. 399 399 - func IsAbs(path string, os OS) bool { 400 400 - return getOS(os).IsAbs(path) 401 401 - } 402 402 - 403 403 - // VolumeName returns leading volume name. 404 404 - // Given "C:\foo\bar" it returns "C:" on Windows. 405 405 - // Given "\\host\share\foo" it returns "\\host\share". 406 406 - // On other platforms it returns "". 407 407 - // The default value for os is Windows. 408 408 - func VolumeName(path string, os OS) string { 409 409 - return volumeName(path, getOS(os)) 410 410 - } 411 411 - 412 412 - func volumeName(path string, os os) string { 413 413 - return path[:os.volumeNameLen(path)] 414 414 - }

pkg/path/testdata/path_nix.go pkg/path/path_nix.go

reviewed

pkg/path/testdata/path_p9.go pkg/path/path_p9.go

reviewed

pkg/path/testdata/path_test.go pkg/path/path_test.go

reviewed

pkg/path/testdata/path_win.go pkg/path/path_win.go

reviewed

pkg/path/testdata/path_windows_test.go pkg/path/path_windows_test.go

reviewed

pkg/path/testdata/pathtxtar_test.go pkg/path/pathtxtar_test.go

reviewed