helpers.go

package main

import (
	"io/fs"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

func run(hide bool, command string, args ...string) error {
	commandBinaryPath, err := exec.LookPath(command)
	if err != nil {
		return err
	}

	cmd := exec.Command(commandBinaryPath, args...)
	if !hide {
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		cmd.Stdin = os.Stdin
	}

	return cmd.Run()
}

func inserIntoFile(file string, dataToInsert string) error {
	info, err := os.Stat(file)
	if err != nil {
		return err
	}

	data, err := os.ReadFile(file)
	if err != nil {
		return err
	}

	updated := dataToInsert + "\n" + string(data)

	err = os.WriteFile(file, []byte(updated), info.Mode())
	if err != nil {
		return err
	}

	return nil
}

func replaceOnceOpenAndClosingTokens(content string, fromIndex int, openToken, closeToken byte, newOpenToken, newCloseToken byte) (string, int) {
	openIndex := 0
	closeIndex := 0
	found := false
	data := []byte(content)

	// for {
	openIndex, closeIndex, found = findOpenClosingTokens(data, fromIndex, openToken, closeToken)
	if found {
		data[openIndex] = newOpenToken
		data[closeIndex] = newCloseToken
	}

	// else {
	// 	break
	// }
	// }

	return string(data), closeIndex + 1
}

func findOpenClosingTokens(data []byte, startIndex int, openToken, closeToken byte) (int, int, bool) {
	if startIndex < 0 || startIndex >= len(data) {
		return -1, -1, false
	}

	depth := 0
	openTokenIndex := -1
	closeTokenIndex := -1

	for i := startIndex; i < len(data); i++ {
		switch data[i] {
		case openToken:
			depth++
			if openTokenIndex == -1 {
				openTokenIndex = i
			}

		case closeToken:
			depth--
			if depth == 0 {
				closeTokenIndex = i
				return openTokenIndex, closeTokenIndex, true
			}
		}
	}

	return -1, -1, false
}

func strings_IndexFromIndex(originalString, subString string, fromIndex int) int {
	if fromIndex < 0 {
		fromIndex = 0
	}
	if fromIndex >= len(originalString) {
		return -1
	}

	fromIndexString := originalString[fromIndex:]

	idx := strings.Index(fromIndexString, subString)
	if idx == -1 {
		return -1
	}
	return idx + fromIndex
}

func replaceOnceFromIndex(originalString string, fromIndex int, old, new string) string {
	if fromIndex < 0 {
		fromIndex = 0
	}
	if fromIndex > len(originalString) || old == "" {
		return originalString
	}

	idx := strings.Index(originalString[fromIndex:], old)
	if idx == -1 {
		return originalString
	}

	idx += fromIndex
	return originalString[:idx] + new + originalString[idx+len(old):]
}

func saveToFile(file string, data []byte) error {
	return os.WriteFile(file, data, 0644)
}

func copyTree(src fs.FS, srcRoot, dstRoot string) error {
	return fs.WalkDir(src, srcRoot, func(p string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}

		rel, err := filepath.Rel(srcRoot, p)
		if err != nil {
			return err
		}

		outPath := filepath.Join(dstRoot, filepath.FromSlash(rel))

		if d.IsDir() {
			return os.MkdirAll(outPath, 0755)
		}

		data, err := fs.ReadFile(src, p)
		if err != nil {
			return err
		}

		if err := os.MkdirAll(filepath.Dir(outPath), 0755); err != nil {
			return err
		}

		return os.WriteFile(outPath, data, 0644)
	})
}