util.go raw
1 // Copyright ©2015 Steve Francia <spf@spf13.com>
2 // Portions Copyright ©2015 The Hugo Authors
3 // Portions Copyright 2016-present Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16
17 package afero
18
19 import (
20 "bytes"
21 "fmt"
22 "io"
23 "os"
24 "path/filepath"
25 "strings"
26 "unicode"
27
28 "golang.org/x/text/runes"
29 "golang.org/x/text/transform"
30 "golang.org/x/text/unicode/norm"
31 )
32
33 // Filepath separator defined by os.Separator.
34 const FilePathSeparator = string(filepath.Separator)
35
36 // Takes a reader and a path and writes the content
37 func (a Afero) WriteReader(path string, r io.Reader) (err error) {
38 return WriteReader(a.Fs, path, r)
39 }
40
41 func WriteReader(fs Fs, path string, r io.Reader) (err error) {
42 dir, _ := filepath.Split(path)
43 ospath := filepath.FromSlash(dir)
44
45 if ospath != "" {
46 err = fs.MkdirAll(ospath, 0o777) // rwx, rw, r
47 if err != nil {
48 if err != os.ErrExist {
49 return err
50 }
51 }
52 }
53
54 file, err := fs.Create(path)
55 if err != nil {
56 return
57 }
58 defer file.Close()
59
60 _, err = io.Copy(file, r)
61 return
62 }
63
64 // Same as WriteReader but checks to see if file/directory already exists.
65 func (a Afero) SafeWriteReader(path string, r io.Reader) (err error) {
66 return SafeWriteReader(a.Fs, path, r)
67 }
68
69 func SafeWriteReader(fs Fs, path string, r io.Reader) (err error) {
70 dir, _ := filepath.Split(path)
71 ospath := filepath.FromSlash(dir)
72
73 if ospath != "" {
74 err = fs.MkdirAll(ospath, 0o777) // rwx, rw, r
75 if err != nil {
76 return
77 }
78 }
79
80 exists, err := Exists(fs, path)
81 if err != nil {
82 return
83 }
84 if exists {
85 return fmt.Errorf("%v already exists", path)
86 }
87
88 file, err := fs.Create(path)
89 if err != nil {
90 return
91 }
92 defer file.Close()
93
94 _, err = io.Copy(file, r)
95 return
96 }
97
98 func (a Afero) GetTempDir(subPath string) string {
99 return GetTempDir(a.Fs, subPath)
100 }
101
102 // GetTempDir returns the default temp directory with trailing slash
103 // if subPath is not empty then it will be created recursively with mode 777 rwx rwx rwx
104 func GetTempDir(fs Fs, subPath string) string {
105 addSlash := func(p string) string {
106 if FilePathSeparator != p[len(p)-1:] {
107 p = p + FilePathSeparator
108 }
109 return p
110 }
111 dir := addSlash(os.TempDir())
112
113 if subPath != "" {
114 // preserve windows backslash :-(
115 if FilePathSeparator == "\\" {
116 subPath = strings.Replace(subPath, "\\", "____", -1)
117 }
118 dir = dir + UnicodeSanitize((subPath))
119 if FilePathSeparator == "\\" {
120 dir = strings.Replace(dir, "____", "\\", -1)
121 }
122
123 if exists, _ := Exists(fs, dir); exists {
124 return addSlash(dir)
125 }
126
127 err := fs.MkdirAll(dir, 0o777)
128 if err != nil {
129 panic(err)
130 }
131 dir = addSlash(dir)
132 }
133 return dir
134 }
135
136 // Rewrite string to remove non-standard path characters
137 func UnicodeSanitize(s string) string {
138 source := []rune(s)
139 target := make([]rune, 0, len(source))
140
141 for _, r := range source {
142 if unicode.IsLetter(r) ||
143 unicode.IsDigit(r) ||
144 unicode.IsMark(r) ||
145 r == '.' ||
146 r == '/' ||
147 r == '\\' ||
148 r == '_' ||
149 r == '-' ||
150 r == '%' ||
151 r == ' ' ||
152 r == '#' {
153 target = append(target, r)
154 }
155 }
156
157 return string(target)
158 }
159
160 // Transform characters with accents into plain forms.
161 func NeuterAccents(s string) string {
162 t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
163 result, _, _ := transform.String(t, string(s))
164
165 return result
166 }
167
168 func (a Afero) FileContainsBytes(filename string, subslice []byte) (bool, error) {
169 return FileContainsBytes(a.Fs, filename, subslice)
170 }
171
172 // Check if a file contains a specified byte slice.
173 func FileContainsBytes(fs Fs, filename string, subslice []byte) (bool, error) {
174 f, err := fs.Open(filename)
175 if err != nil {
176 return false, err
177 }
178 defer f.Close()
179
180 return readerContainsAny(f, subslice), nil
181 }
182
183 func (a Afero) FileContainsAnyBytes(filename string, subslices [][]byte) (bool, error) {
184 return FileContainsAnyBytes(a.Fs, filename, subslices)
185 }
186
187 // Check if a file contains any of the specified byte slices.
188 func FileContainsAnyBytes(fs Fs, filename string, subslices [][]byte) (bool, error) {
189 f, err := fs.Open(filename)
190 if err != nil {
191 return false, err
192 }
193 defer f.Close()
194
195 return readerContainsAny(f, subslices...), nil
196 }
197
198 // readerContains reports whether any of the subslices is within r.
199 func readerContainsAny(r io.Reader, subslices ...[]byte) bool {
200 if r == nil || len(subslices) == 0 {
201 return false
202 }
203
204 largestSlice := 0
205
206 for _, sl := range subslices {
207 if len(sl) > largestSlice {
208 largestSlice = len(sl)
209 }
210 }
211
212 if largestSlice == 0 {
213 return false
214 }
215
216 bufflen := largestSlice * 4
217 halflen := bufflen / 2
218 buff := make([]byte, bufflen)
219 var err error
220 var n, i int
221
222 for {
223 i++
224 if i == 1 {
225 n, err = io.ReadAtLeast(r, buff[:halflen], halflen)
226 } else {
227 if i != 2 {
228 // shift left to catch overlapping matches
229 copy(buff[:], buff[halflen:])
230 }
231 n, err = io.ReadAtLeast(r, buff[halflen:], halflen)
232 }
233
234 if n > 0 {
235 for _, sl := range subslices {
236 if bytes.Contains(buff, sl) {
237 return true
238 }
239 }
240 }
241
242 if err != nil {
243 break
244 }
245 }
246 return false
247 }
248
249 func (a Afero) DirExists(path string) (bool, error) {
250 return DirExists(a.Fs, path)
251 }
252
253 // DirExists checks if a path exists and is a directory.
254 func DirExists(fs Fs, path string) (bool, error) {
255 fi, err := fs.Stat(path)
256 if err == nil && fi.IsDir() {
257 return true, nil
258 }
259 if os.IsNotExist(err) {
260 return false, nil
261 }
262 return false, err
263 }
264
265 func (a Afero) IsDir(path string) (bool, error) {
266 return IsDir(a.Fs, path)
267 }
268
269 // IsDir checks if a given path is a directory.
270 func IsDir(fs Fs, path string) (bool, error) {
271 fi, err := fs.Stat(path)
272 if err != nil {
273 return false, err
274 }
275 return fi.IsDir(), nil
276 }
277
278 func (a Afero) IsEmpty(path string) (bool, error) {
279 return IsEmpty(a.Fs, path)
280 }
281
282 // IsEmpty checks if a given file or directory is empty.
283 func IsEmpty(fs Fs, path string) (bool, error) {
284 if b, _ := Exists(fs, path); !b {
285 return false, fmt.Errorf("%q path does not exist", path)
286 }
287 fi, err := fs.Stat(path)
288 if err != nil {
289 return false, err
290 }
291 if fi.IsDir() {
292 f, err := fs.Open(path)
293 if err != nil {
294 return false, err
295 }
296 defer f.Close()
297 list, err := f.Readdir(-1)
298 if err != nil {
299 return false, err
300 }
301 return len(list) == 0, nil
302 }
303 return fi.Size() == 0, nil
304 }
305
306 func (a Afero) Exists(path string) (bool, error) {
307 return Exists(a.Fs, path)
308 }
309
310 // Check if a file or directory exists.
311 func Exists(fs Fs, path string) (bool, error) {
312 _, err := fs.Stat(path)
313 if err == nil {
314 return true, nil
315 }
316 if os.IsNotExist(err) {
317 return false, nil
318 }
319 return false, err
320 }
321
322 func FullBaseFsPath(basePathFs *BasePathFs, relativePath string) string {
323 combinedPath := filepath.Join(basePathFs.path, relativePath)
324 if parent, ok := basePathFs.source.(*BasePathFs); ok {
325 return FullBaseFsPath(parent, combinedPath)
326 }
327
328 return combinedPath
329 }
330