repostatus/unix.go

package repostatus

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"
	"time"

	"github.com/go-cmd/cmd"
	"go.wit.com/lib/gui/shell"
	"go.wit.com/log"
)

/*
func run(path string, thing string, cmdline string) string {
	parts := strings.Split(cmdline, " ")
	// Create the command
	cmd := exec.Command(thing, parts...)

	// Set the working directory
	cmd.Dir = path

	// Execute the command
	output, err := cmd.CombinedOutput()
	tmp := string(output)
	tmp = strings.TrimSpace(tmp)

	if err != nil {
		log.Log(WARN, "run()", path, thing, cmdline, "=", tmp)
		log.Error(err, "cmd error'd out", parts)
		return ""
	}

	// Print the output
	log.Log(INFO, "run()", path, thing, cmdline, "=", tmp)
	return tmp
}
*/

// goes in one directory so it gets remote branch names
func listFiles(directory string) []string {
	var files []string
	fileInfo, err := os.ReadDir(directory)
	if err != nil {
		log.Error(err)
		return nil
	}

	for _, file := range fileInfo {
		if file.IsDir() {
			dirname := file.Name()
			newdir, _ := os.ReadDir(directory + "/" + dirname)
			for _, file := range newdir {
				if !file.IsDir() {
					files = append(files, dirname+"/"+file.Name())
				}
			}
		} else {
			files = append(files, file.Name())
		}
	}

	return files
}

func normalizeVersion(s string) string {
	// reg, err := regexp.Compile("[^a-zA-Z0-9]+")
	parts := strings.Split(s, "-")
	if len(parts) == 0 {
		return ""
	}
	reg, err := regexp.Compile("[^0-9.]+")
	if err != nil {
		log.Log(WARN, "normalizeVersion() regexp.Compile() ERROR =", err)
		return parts[0]
	}
	clean := reg.ReplaceAllString(parts[0], "")
	log.Log(INFO, "normalizeVersion() s =", clean)
	return clean
}

func splitVersion(version string) (a, b, c string) {
	tmp := normalizeVersion(version)
	parts := strings.Split(tmp, ".")
	switch len(parts) {
	case 1:
		return parts[0], "", ""
	case 2:
		return parts[0], parts[1], ""
	default:
		return parts[0], parts[1], parts[2]
	}
}

func (rs *RepoStatus) Run(cmd []string) cmd.Status {
	path := rs.realPath.String()
	r := shell.PathRun(path, cmd)
	output := strings.Join(r.Stdout, "\n")
	if r.Error != nil {
		log.Log(WARN, "cmd:", cmd)
		log.Log(WARN, "ouptput:", output)
		log.Log(WARN, "failed with error:", r.Error)
	}
	return r
}

// Set the path to the package
func getfiles(pathToPackage string) {
	// List files in the directory
	err := filepath.Walk(pathToPackage, nil) // compiles but crashes
	if err == nil {
		log.Log(INFO, "directory ok", pathToPackage)
	} else {
		log.Warn("directory wrong", pathToPackage)
	}
}

func IsDirectory(path string) bool {
	info, err := os.Stat(path)
	if err != nil {
		return false
	}
	return info.IsDir()
}

func (rs *RepoStatus) Exists(filename string) bool {
	if rs == nil {
		log.Warn("rs == nil for Exists()")
		panic(-1)
	}
	testf := filepath.Join(rs.Path(), filename)
	if Exists(testf) {
		return true
	}
	return false
}

func (rs *RepoStatus) mtime(filename string) (time.Time, error) {
	pathf := filepath.Join(rs.Path(), filename)
	statf, err := os.Stat(pathf)
	if err == nil {
		return statf.ModTime(), nil
	}
	log.Log(REPOWARN, "mtime() error", pathf, err)
	return time.Now(), err
}

// returns true if the file exists
func Exists(file string) bool {
	_, err := os.Stat(file)
	if err != nil {
		return false
	}
	return true
}

func getDurationStamp(t time.Time) string {

	// Get the current time
	currentTime := time.Now()

	// Calculate the duration between t current time
	duration := currentTime.Sub(t)

	return formatDuration(duration)
}

func formatDuration(d time.Duration) string {
	seconds := int(d.Seconds()) % 60
	minutes := int(d.Minutes()) % 60
	hours := int(d.Hours()) % 24
	days := int(d.Hours()) / 24
	years := int(d.Hours()) / (24 * 365)

	result := ""
	if years > 0 {
		result += fmt.Sprintf("%dy ", years)
		return result
	}
	if days > 0 {
		result += fmt.Sprintf("%dd ", days)
		return result
	}
	if hours > 0 {
		result += fmt.Sprintf("%dh ", hours)
		return result
	}
	if minutes > 0 {
		result += fmt.Sprintf("%dm ", minutes)
		return result
	}
	if seconds > 0 {
		result += fmt.Sprintf("%ds", seconds)
	}
	return result
}

func (rs *RepoStatus) XtermNohup(cmdline string) {
	shell.XtermCmd(rs.Path(), []string{cmdline})
}
func (rs *RepoStatus) Xterm(cmdline string) {
	shell.XtermCmd(rs.Path(), []string{cmdline})
}
func (rs *RepoStatus) XtermWait(cmdline string) {
	shell.XtermCmdWait(rs.Path(), []string{cmdline})
}

func (rs *RepoStatus) XtermBash(args []string) {
	var argsX = []string{"-geometry", "120x40"}
	tmp := strings.Join(args, " ") + ";bash"
	argsX = append(argsX, "-e", "bash", "-c", tmp)
	argsX = append(argsX, args...)
	log.Info("xterm cmd=", argsX)
	// set less to not exit on small diff's
	os.Setenv("LESS", "-+F -+X -R")
	cmd := exec.Command("xterm", argsX...)
	path := rs.realPath.String()
	cmd.Dir = path
	if err := cmd.Run(); err != nil {
		log.Log(WARN, "xterm.Run() failed")
		log.Log(WARN, "path =", path)
		log.Log(WARN, "cmd = xterm", argsX)
	} else {
		log.Log(WARN, "xterm.Run() worked")
		log.Log(WARN, "path =", path)
		log.Log(WARN, "cmd = xterm", argsX)
	}
}

func (rs *RepoStatus) DoAll(all [][]string) bool {
	for _, cmd := range all {
		log.Log(WARN, "doAll() RUNNING: cmd =", cmd)
		r := rs.Run(cmd)
		if r.Error != nil {
			log.Log(WARN, "doAll() err =", r.Error)
			log.Log(WARN, "doAll() out =", r.Stdout)
			return false
		}
	}
	return true
}