pkg/fileutils/fileutils.go - third_party/github.com/moby/moby - Git at Google

 package fileutils

 import (
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"text/scanner"

 	"github.com/Sirupsen/logrus"
 )

 // exclusion returns true if the specified pattern is an exclusion
 func exclusion(pattern string) bool {
 	return pattern[0] == '!'
 }

 // empty returns true if the specified pattern is empty
 func empty(pattern string) bool {
 	return pattern == ""
 }

 // CleanPatterns takes a slice of patterns returns a new
 // slice of patterns cleaned with filepath.Clean, stripped
 // of any empty patterns and lets the caller know whether the
 // slice contains any exception patterns (prefixed with !).
 func CleanPatterns(patterns []string) ([]string, [][]string, bool, error) {
 	// Loop over exclusion patterns and:
 	// 1. Clean them up.
 	// 2. Indicate whether we are dealing with any exception rules.
 	// 3. Error if we see a single exclusion marker on its own (!).
 	cleanedPatterns := []string{}
 	patternDirs := [][]string{}
 	exceptions := false
 	for _, pattern := range patterns {
 		// Eliminate leading and trailing whitespace.
 		pattern = strings.TrimSpace(pattern)
 		if empty(pattern) {
 			continue
 		}
 		if exclusion(pattern) {
 			if len(pattern) == 1 {
 				return nil, nil, false, errors.New("Illegal exclusion pattern: !")
 			}
 			exceptions = true
 		}
 		pattern = filepath.Clean(pattern)
 		cleanedPatterns = append(cleanedPatterns, pattern)
 		if exclusion(pattern) {
 			pattern = pattern[1:]
 		}
 		patternDirs = append(patternDirs, strings.Split(pattern, string(os.PathSeparator)))
 	}

 	return cleanedPatterns, patternDirs, exceptions, nil
 }

 // Matches returns true if file matches any of the patterns
 // and isn't excluded by any of the subsequent patterns.
 func Matches(file string, patterns []string) (bool, error) {
 	file = filepath.Clean(file)

 	if file == "." {
 		// Don't let them exclude everything, kind of silly.
 		return false, nil
 	}

 	patterns, patDirs, _, err := CleanPatterns(patterns)
 	if err != nil {
 		return false, err
 	}

 	return OptimizedMatches(file, patterns, patDirs)
 }

 // OptimizedMatches is basically the same as fileutils.Matches() but optimized for archive.go.
 // It will assume that the inputs have been preprocessed and therefore the function
 // doesn't need to do as much error checking and clean-up. This was done to avoid
 // repeating these steps on each file being checked during the archive process.
 // The more generic fileutils.Matches() can't make these assumptions.
 func OptimizedMatches(file string, patterns []string, patDirs [][]string) (bool, error) {
 	matched := false
 	file = filepath.FromSlash(file)
 	parentPath := filepath.Dir(file)
 	parentPathDirs := strings.Split(parentPath, string(os.PathSeparator))

 	for i, pattern := range patterns {
 		negative := false

 		if exclusion(pattern) {
 			negative = true
 			pattern = pattern[1:]
 		}

 		match, err := regexpMatch(pattern, file)
 		if err != nil {
 			return false, fmt.Errorf("Error in pattern (%s): %s", pattern, err)
 		}

 		if !match && parentPath != "." {
 			// Check to see if the pattern matches one of our parent dirs.
 			if len(patDirs[i]) <= len(parentPathDirs) {
 				match, _ = regexpMatch(strings.Join(patDirs[i], string(os.PathSeparator)),
 					strings.Join(parentPathDirs[:len(patDirs[i])], string(os.PathSeparator)))
 			}
 		}

 		if match {
 			matched = !negative
 		}
 	}

 	if matched {
 		logrus.Debugf("Skipping excluded path: %s", file)
 	}

 	return matched, nil
 }

 // regexpMatch tries to match the logic of filepath.Match but
 // does so using regexp logic. We do this so that we can expand the
 // wildcard set to include other things, like "**" to mean any number
 // of directories.  This means that we should be backwards compatible
 // with filepath.Match(). We'll end up supporting more stuff, due to
 // the fact that we're using regexp, but that's ok - it does no harm.
 //
 // As per the comment in golangs filepath.Match, on Windows, escaping
 // is disabled. Instead, '\\' is treated as path separator.
 func regexpMatch(pattern, path string) (bool, error) {
 	regStr := "^"

 	// Do some syntax checking on the pattern.
 	// filepath's Match() has some really weird rules that are inconsistent
 	// so instead of trying to dup their logic, just call Match() for its
 	// error state and if there is an error in the pattern return it.
 	// If this becomes an issue we can remove this since its really only
 	// needed in the error (syntax) case - which isn't really critical.
 	if _, err := filepath.Match(pattern, path); err != nil {
 		return false, err
 	}

 	// Go through the pattern and convert it to a regexp.
 	// We use a scanner so we can support utf-8 chars.
 	var scan scanner.Scanner
 	scan.Init(strings.NewReader(pattern))

 	sl := string(os.PathSeparator)
 	escSL := sl
 	if sl == `\` {
 		escSL += `\`
 	}

 	for scan.Peek() != scanner.EOF {
 		ch := scan.Next()

 		if ch == '*' {
 			if scan.Peek() == '*' {
 				// is some flavor of "**"
 				scan.Next()

 				if scan.Peek() == scanner.EOF {
 					// is "**EOF" - to align with .gitignore just accept all
 					regStr += ".*"
 				} else {
 					// is "**"
 					regStr += "((.*" + escSL + ")|([^" + escSL + "]*))"
 				}

 				// Treat **/ as ** so eat the "/"
 				if string(scan.Peek()) == sl {
 					scan.Next()
 				}
 			} else {
 				// is "*" so map it to anything but "/"
 				regStr += "[^" + escSL + "]*"
 			}
 		} else if ch == '?' {
 			// "?" is any char except "/"
 			regStr += "[^" + escSL + "]"
 		} else if strings.Index(".$", string(ch)) != -1 {
 			// Escape some regexp special chars that have no meaning
 			// in golang's filepath.Match
 			regStr += `\` + string(ch)
 		} else if ch == '\\' {
 			// escape next char. Note that a trailing \ in the pattern
 			// will be left alone (but need to escape it)
 			if sl == `\` {
 				// On windows map "\" to "\\", meaning an escaped backslash,
 				// and then just continue because filepath.Match on
 				// Windows doesn't allow escaping at all
 				regStr += escSL
 				continue
 			}
 			if scan.Peek() != scanner.EOF {
 				regStr += `\` + string(scan.Next())
 			} else {
 				regStr += `\`
 			}
 		} else {
 			regStr += string(ch)
 		}
 	}

 	regStr += "$"

 	res, err := regexp.MatchString(regStr, path)

 	// Map regexp's error to filepath's so no one knows we're not using filepath
 	if err != nil {
 		err = filepath.ErrBadPattern
 	}

 	return res, err
 }

 // CopyFile copies from src to dst until either EOF is reached
 // on src or an error occurs. It verifies src exists and removes
 // the dst if it exists.
 func CopyFile(src, dst string) (int64, error) {
 	cleanSrc := filepath.Clean(src)
 	cleanDst := filepath.Clean(dst)
 	if cleanSrc == cleanDst {
 		return 0, nil
 	}
 	sf, err := os.Open(cleanSrc)
 	if err != nil {
 		return 0, err
 	}
 	defer sf.Close()
 	if err := os.Remove(cleanDst); err != nil && !os.IsNotExist(err) {
 		return 0, err
 	}
 	df, err := os.Create(cleanDst)
 	if err != nil {
 		return 0, err
 	}
 	defer df.Close()
 	return io.Copy(df, sf)
 }

 // ReadSymlinkedDirectory returns the target directory of a symlink.
 // The target of the symbolic link may not be a file.
 func ReadSymlinkedDirectory(path string) (string, error) {
 	var realPath string
 	var err error
 	if realPath, err = filepath.Abs(path); err != nil {
 		return "", fmt.Errorf("unable to get absolute path for %s: %s", path, err)
 	}
 	if realPath, err = filepath.EvalSymlinks(realPath); err != nil {
 		return "", fmt.Errorf("failed to canonicalise path for %s: %s", path, err)
 	}
 	realPathInfo, err := os.Stat(realPath)
 	if err != nil {
 		return "", fmt.Errorf("failed to stat target '%s' of '%s': %s", realPath, path, err)
 	}
 	if !realPathInfo.Mode().IsDir() {
 		return "", fmt.Errorf("canonical path points to a file '%s'", realPath)
 	}
 	return realPath, nil
 }

 // CreateIfNotExists creates a file or a directory only if it does not already exist.
 func CreateIfNotExists(path string, isDir bool) error {
 	if _, err := os.Stat(path); err != nil {
 		if os.IsNotExist(err) {
 			if isDir {
 				return os.MkdirAll(path, 0755)
 			}
 			if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
 				return err
 			}
 			f, err := os.OpenFile(path, os.O_CREATE, 0755)
 			if err != nil {
 				return err
 			}
 			f.Close()
 		}
 	}
 	return nil
 }
	package fileutils

	import (
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"text/scanner"

	"github.com/Sirupsen/logrus"
	)

	// exclusion returns true if the specified pattern is an exclusion
	func exclusion(pattern string) bool {
	return pattern[0] == '!'
	}

	// empty returns true if the specified pattern is empty
	func empty(pattern string) bool {
	return pattern == ""
	}

	// CleanPatterns takes a slice of patterns returns a new
	// slice of patterns cleaned with filepath.Clean, stripped
	// of any empty patterns and lets the caller know whether the
	// slice contains any exception patterns (prefixed with !).
	func CleanPatterns(patterns []string) ([]string, [][]string, bool, error) {
	// Loop over exclusion patterns and:
	// 1. Clean them up.
	// 2. Indicate whether we are dealing with any exception rules.
	// 3. Error if we see a single exclusion marker on its own (!).
	cleanedPatterns := []string{}
	patternDirs := [][]string{}
	exceptions := false
	for _, pattern := range patterns {
	// Eliminate leading and trailing whitespace.
	pattern = strings.TrimSpace(pattern)
	if empty(pattern) {
	continue
	}
	if exclusion(pattern) {
	if len(pattern) == 1 {
	return nil, nil, false, errors.New("Illegal exclusion pattern: !")
	}
	exceptions = true
	}
	pattern = filepath.Clean(pattern)
	cleanedPatterns = append(cleanedPatterns, pattern)
	if exclusion(pattern) {
	pattern = pattern[1:]
	}
	patternDirs = append(patternDirs, strings.Split(pattern, string(os.PathSeparator)))
	}

	return cleanedPatterns, patternDirs, exceptions, nil
	}

	// Matches returns true if file matches any of the patterns
	// and isn't excluded by any of the subsequent patterns.
	func Matches(file string, patterns []string) (bool, error) {
	file = filepath.Clean(file)

	if file == "." {
	// Don't let them exclude everything, kind of silly.
	return false, nil
	}

	patterns, patDirs, _, err := CleanPatterns(patterns)
	if err != nil {
	return false, err
	}

	return OptimizedMatches(file, patterns, patDirs)
	}

	// OptimizedMatches is basically the same as fileutils.Matches() but optimized for archive.go.
	// It will assume that the inputs have been preprocessed and therefore the function
	// doesn't need to do as much error checking and clean-up. This was done to avoid
	// repeating these steps on each file being checked during the archive process.
	// The more generic fileutils.Matches() can't make these assumptions.
	func OptimizedMatches(file string, patterns []string, patDirs [][]string) (bool, error) {
	matched := false
	file = filepath.FromSlash(file)
	parentPath := filepath.Dir(file)
	parentPathDirs := strings.Split(parentPath, string(os.PathSeparator))

	for i, pattern := range patterns {
	negative := false

	if exclusion(pattern) {
	negative = true
	pattern = pattern[1:]
	}

	match, err := regexpMatch(pattern, file)
	if err != nil {
	return false, fmt.Errorf("Error in pattern (%s): %s", pattern, err)
	}

	if !match && parentPath != "." {
	// Check to see if the pattern matches one of our parent dirs.
	if len(patDirs[i]) <= len(parentPathDirs) {
	match, _ = regexpMatch(strings.Join(patDirs[i], string(os.PathSeparator)),
	strings.Join(parentPathDirs[:len(patDirs[i])], string(os.PathSeparator)))
	}
	}

	if match {
	matched = !negative
	}
	}

	if matched {
	logrus.Debugf("Skipping excluded path: %s", file)
	}

	return matched, nil
	}

	// regexpMatch tries to match the logic of filepath.Match but
	// does so using regexp logic. We do this so that we can expand the
	// wildcard set to include other things, like "**" to mean any number
	// of directories. This means that we should be backwards compatible
	// with filepath.Match(). We'll end up supporting more stuff, due to
	// the fact that we're using regexp, but that's ok - it does no harm.
	//
	// As per the comment in golangs filepath.Match, on Windows, escaping
	// is disabled. Instead, '\\' is treated as path separator.
	func regexpMatch(pattern, path string) (bool, error) {
	regStr := "^"

	// Do some syntax checking on the pattern.
	// filepath's Match() has some really weird rules that are inconsistent
	// so instead of trying to dup their logic, just call Match() for its
	// error state and if there is an error in the pattern return it.
	// If this becomes an issue we can remove this since its really only
	// needed in the error (syntax) case - which isn't really critical.
	if _, err := filepath.Match(pattern, path); err != nil {
	return false, err
	}

	// Go through the pattern and convert it to a regexp.
	// We use a scanner so we can support utf-8 chars.
	var scan scanner.Scanner
	scan.Init(strings.NewReader(pattern))

	sl := string(os.PathSeparator)
	escSL := sl
	if sl == `\` {
	escSL += `\`
	}

	for scan.Peek() != scanner.EOF {
	ch := scan.Next()

	if ch == '*' {
	if scan.Peek() == '*' {
	// is some flavor of "**"
	scan.Next()

	if scan.Peek() == scanner.EOF {
	// is "**EOF" - to align with .gitignore just accept all
	regStr += ".*"
	} else {
	// is "**"
	regStr += "((." + escSL + ")\|([^" + escSL + "]))"
	}

	// Treat / as so eat the "/"
	if string(scan.Peek()) == sl {
	scan.Next()
	}
	} else {
	// is "*" so map it to anything but "/"
	regStr += "[^" + escSL + "]*"
	}
	} else if ch == '?' {
	// "?" is any char except "/"
	regStr += "[^" + escSL + "]"
	} else if strings.Index(".$", string(ch)) != -1 {
	// Escape some regexp special chars that have no meaning
	// in golang's filepath.Match
	regStr += `\` + string(ch)
	} else if ch == '\\' {
	// escape next char. Note that a trailing \ in the pattern
	// will be left alone (but need to escape it)
	if sl == `\` {
	// On windows map "\" to "\\", meaning an escaped backslash,
	// and then just continue because filepath.Match on
	// Windows doesn't allow escaping at all
	regStr += escSL
	continue
	}
	if scan.Peek() != scanner.EOF {
	regStr += `\` + string(scan.Next())
	} else {
	regStr += `\`
	}
	} else {
	regStr += string(ch)
	}
	}

	regStr += "$"

	res, err := regexp.MatchString(regStr, path)

	// Map regexp's error to filepath's so no one knows we're not using filepath
	if err != nil {
	err = filepath.ErrBadPattern
	}

	return res, err
	}

	// CopyFile copies from src to dst until either EOF is reached
	// on src or an error occurs. It verifies src exists and removes
	// the dst if it exists.
	func CopyFile(src, dst string) (int64, error) {
	cleanSrc := filepath.Clean(src)
	cleanDst := filepath.Clean(dst)
	if cleanSrc == cleanDst {
	return 0, nil
	}
	sf, err := os.Open(cleanSrc)
	if err != nil {
	return 0, err
	}
	defer sf.Close()
	if err := os.Remove(cleanDst); err != nil && !os.IsNotExist(err) {
	return 0, err
	}
	df, err := os.Create(cleanDst)
	if err != nil {
	return 0, err
	}
	defer df.Close()
	return io.Copy(df, sf)
	}

	// ReadSymlinkedDirectory returns the target directory of a symlink.
	// The target of the symbolic link may not be a file.
	func ReadSymlinkedDirectory(path string) (string, error) {
	var realPath string
	var err error
	if realPath, err = filepath.Abs(path); err != nil {
	return "", fmt.Errorf("unable to get absolute path for %s: %s", path, err)
	}
	if realPath, err = filepath.EvalSymlinks(realPath); err != nil {
	return "", fmt.Errorf("failed to canonicalise path for %s: %s", path, err)
	}
	realPathInfo, err := os.Stat(realPath)
	if err != nil {
	return "", fmt.Errorf("failed to stat target '%s' of '%s': %s", realPath, path, err)
	}
	if !realPathInfo.Mode().IsDir() {
	return "", fmt.Errorf("canonical path points to a file '%s'", realPath)
	}
	return realPath, nil
	}

	// CreateIfNotExists creates a file or a directory only if it does not already exist.
	func CreateIfNotExists(path string, isDir bool) error {
	if _, err := os.Stat(path); err != nil {
	if os.IsNotExist(err) {
	if isDir {
	return os.MkdirAll(path, 0755)
	}
	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
	return err
	}
	f, err := os.OpenFile(path, os.O_CREATE, 0755)
	if err != nil {
	return err
	}
	f.Close()
	}
	}
	return nil
	}