util.go

Documentation: github.com/spf13/afero

     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
View as plain text