|
| 1 | +// Copyright 2016 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 internal |
| 6 | + |
| 7 | +import ( |
| 8 | + "os" |
| 9 | + "path/filepath" |
| 10 | + "strings" |
| 11 | + "unicode" |
| 12 | + |
| 13 | + "github.com/pkg/errors" |
| 14 | +) |
| 15 | + |
| 16 | +func IsDir(name string) (bool, error) { |
| 17 | + // TODO: lstat? |
| 18 | + fi, err := os.Stat(name) |
| 19 | + if os.IsNotExist(err) { |
| 20 | + return false, nil |
| 21 | + } |
| 22 | + if err != nil { |
| 23 | + return false, err |
| 24 | + } |
| 25 | + if !fi.IsDir() { |
| 26 | + return false, errors.Errorf("%q is not a directory", name) |
| 27 | + } |
| 28 | + return true, nil |
| 29 | +} |
| 30 | + |
| 31 | +// HasFilepathPrefix will determine if "path" starts with "prefix" from |
| 32 | +// the point of view of a filesystem. |
| 33 | +// |
| 34 | +// Unlike filepath.HasPrefix, this function is path-aware, meaning that |
| 35 | +// it knows that two directories /foo and /foobar are not the same |
| 36 | +// thing, and therefore HasFilepathPrefix("/foobar", "/foo") will return |
| 37 | +// false. |
| 38 | +// |
| 39 | +// This function also handles the case where the involved filesystems |
| 40 | +// are case-insensitive, meaning /foo/bar and /Foo/Bar correspond to the |
| 41 | +// same file. In that situation HasFilepathPrefix("/Foo/Bar", "/foo") |
| 42 | +// will return true. The implementation is *not* OS-specific, so a FAT32 |
| 43 | +// filesystem mounted on Linux will be handled correctly. |
| 44 | +func HasFilepathPrefix(path, prefix string) bool { |
| 45 | + if filepath.VolumeName(path) != filepath.VolumeName(prefix) { |
| 46 | + return false |
| 47 | + } |
| 48 | + |
| 49 | + var dn string |
| 50 | + |
| 51 | + if isDir, err := IsDir(path); err != nil { |
| 52 | + return false |
| 53 | + } else if isDir { |
| 54 | + dn = path |
| 55 | + } else { |
| 56 | + dn = filepath.Dir(path) |
| 57 | + } |
| 58 | + |
| 59 | + dn = strings.TrimSuffix(dn, string(os.PathSeparator)) |
| 60 | + prefix = strings.TrimSuffix(prefix, string(os.PathSeparator)) |
| 61 | + |
| 62 | + dirs := strings.Split(dn, string(os.PathSeparator))[1:] |
| 63 | + prefixes := strings.Split(prefix, string(os.PathSeparator))[1:] |
| 64 | + |
| 65 | + if len(prefixes) > len(dirs) { |
| 66 | + return false |
| 67 | + } |
| 68 | + |
| 69 | + var d, p string |
| 70 | + |
| 71 | + for i := range prefixes { |
| 72 | + // need to test each component of the path for |
| 73 | + // case-sensitiveness because on Unix we could have |
| 74 | + // something like ext4 filesystem mounted on FAT |
| 75 | + // mountpoint, mounted on ext4 filesystem, i.e. the |
| 76 | + // problematic filesystem is not the last one. |
| 77 | + if isCaseSensitiveFilesystem(filepath.Join(d, dirs[i])) { |
| 78 | + d = filepath.Join(d, dirs[i]) |
| 79 | + p = filepath.Join(p, prefixes[i]) |
| 80 | + } else { |
| 81 | + d = filepath.Join(d, strings.ToLower(dirs[i])) |
| 82 | + p = filepath.Join(p, strings.ToLower(prefixes[i])) |
| 83 | + } |
| 84 | + |
| 85 | + if p != d { |
| 86 | + return false |
| 87 | + } |
| 88 | + } |
| 89 | + |
| 90 | + return true |
| 91 | +} |
| 92 | + |
| 93 | +// genTestFilename returns a string with at most one rune case-flipped. |
| 94 | +// |
| 95 | +// The transformation is applied only to the first rune that can be |
| 96 | +// reversibly case-flipped, meaning: |
| 97 | +// |
| 98 | +// * A lowercase rune for which it's true that lower(upper(r)) == r |
| 99 | +// * An uppercase rune for which it's true that upper(lower(r)) == r |
| 100 | +// |
| 101 | +// All the other runes are left intact. |
| 102 | +func genTestFilename(str string) string { |
| 103 | + flip := true |
| 104 | + return strings.Map(func(r rune) rune { |
| 105 | + if flip { |
| 106 | + if unicode.IsLower(r) { |
| 107 | + u := unicode.ToUpper(r) |
| 108 | + if unicode.ToLower(u) == r { |
| 109 | + r = u |
| 110 | + flip = false |
| 111 | + } |
| 112 | + } else if unicode.IsUpper(r) { |
| 113 | + l := unicode.ToLower(r) |
| 114 | + if unicode.ToUpper(l) == r { |
| 115 | + r = l |
| 116 | + flip = false |
| 117 | + } |
| 118 | + } |
| 119 | + } |
| 120 | + return r |
| 121 | + }, str) |
| 122 | +} |
| 123 | + |
| 124 | +// isCaseSensitiveFilesystem determines if the filesystem where dir |
| 125 | +// exists is case sensitive or not. |
| 126 | +// |
| 127 | +// CAVEAT: this function works by taking the last component of the given |
| 128 | +// path and flipping the case of the first letter for which case |
| 129 | +// flipping is a reversible operation (/foo/Bar → /foo/bar), then |
| 130 | +// testing for the existence of the new filename. There are two |
| 131 | +// possibilities: |
| 132 | +// |
| 133 | +// 1. The alternate filename does not exist. We can conclude that the |
| 134 | +// filesystem is case sensitive. |
| 135 | +// |
| 136 | +// 2. The filename happens to exist. We have to test if the two files |
| 137 | +// are the same file (case insensitive file system) or different ones |
| 138 | +// (case sensitive filesystem). |
| 139 | +// |
| 140 | +// If the input directory is such that the last component is composed |
| 141 | +// exclusively of case-less codepoints (e.g. numbers), this function will |
| 142 | +// return false. |
| 143 | +func isCaseSensitiveFilesystem(dir string) bool { |
| 144 | + alt := filepath.Join(filepath.Dir(dir), |
| 145 | + genTestFilename(filepath.Base(dir))) |
| 146 | + |
| 147 | + dInfo, err := os.Stat(dir) |
| 148 | + if err != nil { |
| 149 | + return true |
| 150 | + } |
| 151 | + |
| 152 | + aInfo, err := os.Stat(alt) |
| 153 | + if err != nil { |
| 154 | + return true |
| 155 | + } |
| 156 | + |
| 157 | + return !os.SameFile(dInfo, aInfo) |
| 158 | +} |
0 commit comments