// All returns whatever the path matches all of the patterns.
// pattern errors are ignored.
func All(path string, patterns ...string) bool {
for _, pattern := range patterns {
if match, _ := doublestar.Match(pattern, path); !match {
return false
}
}
return true
}
func matchAny(path string, patterns []string) (bool, error) {
for _, pattern := range patterns {
match, err := doublestar.Match(pattern, filepath.ToSlash(path))
if err != nil {
return false, fmt.Errorf("Error matching pattern '%s': %s", pattern, err)
} else if match {
return true, nil
}
}
return false, nil
}
// Determine if a file should be included, based on the given exclude paths.
func shouldInclude(file string, excludePatterns []string, log termlog.Logger) bool {
for _, pattern := range excludePatterns {
match, err := doublestar.Match(pattern, file)
if err != nil {
log.Warn("Error matching pattern '%s': %s", pattern, err)
} else if match {
return false
}
}
return true
}
// Parse the files transforming them into a byte string and inserting the file
// into a map of files
func (c *Custom) Parse(files *map[string]*file.File, dirs **dir.Dir, config *SharedConfig) error {
to := *files
dirList := *dirs
for _, customFile := range c.Files {
customFile = utils.FixPath(customFile)
walkErr := filepath.Walk(customFile, func(fpath string, info os.FileInfo, err error) error {
if err != nil {
return err
}
// only files will be processed
if info.IsDir() {
return nil
}
var fixedPath string
if c.Base != "" {
// remove base and inserts prefix
fixedPath = strings.Replace(
utils.FixPath(fpath),
utils.FixPath(c.Base),
utils.FixPath(c.Prefix),
1) // once
} else {
fixedPath = utils.FixPath(fpath)
}
// check for excluded files
for _, excludedFile := range c.Exclude {
m, err := doublestar.Match(c.Prefix+excludedFile, fixedPath)
if err != nil {
return err
}
if m {
return nil
}
}
// FIXME
// prevent including itself (destination file or dir)
if info.Name() == config.Output {
return nil
}
/*if info.Name() == cfg.Output { ||
info.Name() == path.Base(path.Dir(jsonFile)) {
return nil
}*/
// get file's content
content, err := ioutil.ReadFile(fpath)
if err != nil {
return err
}
// loop through replace list
for _, r := range c.Replace {
// check if path matches the pattern from property: file
matched, err := doublestar.Match(c.Prefix+r.File, fixedPath)
if err != nil {
return err
}
if matched {
for pattern, word := range r.Replace {
content = []byte(strings.Replace(string(content), pattern, word, -1))
}
}
}
// it's way faster to use a buffer as string than use string
var buf bytes.Buffer
buf.WriteString(`[]byte("`)
f := file.NewFile()
// compress the content
if config.Compression.Options != nil {
content, err = config.Compression.Compress(content)
if err != nil {
return err
}
}
// it's way faster to loop and slice a string than a byte array
h := hex.EncodeToString(content)
// loop through hex string, at each 2 chars
// it's added into a byte array -> []byte{0x61 ,...}
for i := 0; i < len(h); i += 2 {
buf.WriteString(`\x` + h[i:i+2])
}
f.Data = buf.String() + `")`
f.Name = info.Name()
f.Path = fixedPath
// insert dir to dirlist so it can be created on b0x's init()
dirList.Insert(path.Dir(fixedPath))
// insert file into file list
to[fixedPath] = f
return nil
})
if walkErr != nil {
return walkErr
}
}
return nil
}
func Good(patterns ...string) error {
for _, p := range patterns {
if _, err := doublestar.Match(p, ""); err != nil {
return err
}
}
return nil
}