utils.go

package main

import (
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"strings"
)

type CaseInsensitiveReplacerParams struct {
	toReplace   *regexp.Regexp
	replaceWith string
}

func AppendSubstitution(slice *[]Substitution, newItem Substitution) {
	var appears int
	for _, item := range *slice {
		if item.To == newItem.To {
			appears++
		}
	}
	if appears > 0 {
		newItem.Suffix = appears
	}
	*slice = append(*slice, newItem)
}

func ToPathWithSuffix(toPath string, suffix int) string {
	if suffix == 0 {
		return toPath
	}

	dir := filepath.Dir(toPath)
	ext := filepath.Ext(toPath)
	fileName := filepath.Base(toPath)
	fileName = fileName[:len(fileName)-len(ext)]
	newFileName := fmt.Sprintf("%s-%d%s", fileName, suffix, ext)

	return filepath.Join(dir, newFileName)
}

func IsValidExtension(ext string) bool {
	ext = strings.ToLower(ext)
	switch ext {
	case
		".jpg",
		".jpeg",
		".png":
		return true
	}
	return false
}

func AppendPath(slice []string, str string, isRecursive bool) []string {
	var newSlice []string
	keepParent := false
	str = NormalizePath(str)
	for _, s := range slice {
		if (strings.HasPrefix(s, str+"/") && isRecursive) || str == s {
			continue
		}
		if strings.HasPrefix(str, s+"/") {
			keepParent = true
		}
		newSlice = append(newSlice, s)
	}
	if (!keepParent && isRecursive) || !isRecursive {
		newSlice = append(newSlice, str)
	}
	return newSlice
}

func RemovePathsWithCommonParent(paths []string) []string {
	var filteredPaths []string
	seenChild := make(map[string]bool)
	for _, path := range paths {
		isChildPath := false
		for _, otherPath := range paths {
			if path != otherPath && strings.HasPrefix(path, otherPath) {
				isChildPath = true
				break
			}
		}
		if !isChildPath {
			filteredPaths = append(filteredPaths, path)
			seenChild[path] = true
		}
	}
	return filteredPaths
}

func CaseInsensitiveReplacer(toReplace, replaceWith string) *CaseInsensitiveReplacerParams {
	return &CaseInsensitiveReplacerParams{
		toReplace:   regexp.MustCompile("(?i)" + toReplace),
		replaceWith: replaceWith,
	}
}

func (cir *CaseInsensitiveReplacerParams) Replace(str string) string {
	return cir.toReplace.ReplaceAllString(str, cir.replaceWith)
}

func NormalizePath(path string) string {
	return filepath.ToSlash(filepath.Clean(path))
}

func HasLocationPlaceholders(str string) bool {
	re := regexp.MustCompile(`\{location_\w+}`)
	match := re.FindAllString(str, -1)
	return len(match) > 0
}

func UniqueFileName(filePath string) string {
	dir := filepath.Dir(filePath)
	ext := filepath.Ext(filePath)
	base := strings.TrimSuffix(filepath.Base(filePath), ext)

	for {
		if _, err := os.Stat(filePath); os.IsNotExist(err) {
			return filePath
		}
		base = base + " (duplicate)"
		filePath = filepath.Join(dir, base+ext)
	}
}