path: root/utils.go

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"io"
	"os/exec"
	"runtime"
	"strconv"
	"strings"
	"unicode/utf8"
	"math/rand"
	"time"
	"path/filepath"
	"archive/tar"
)

const (
	framewidth int = 50
	li  string = "\u2500"
	mli string = "\u2500\u2530\u2500\u2500"   //Masterline -T-
	ssli string = " \u2520\u2500\u2500"	  //Slave Line L__
	sli string = " \u2520\u2500 "		   //Slave Line L_
	nli string = " \u2503  "		   //noone Line |
	fli string = " \u2516\u2500\u2500"	   //Footer Line L
)

var positive = [...]string {"Done","Accomplished","Finished","Congrats","Completed"}
var negative = [...]string {"Failed","Try Again","Sorry","Not Quite Yet","Incomplete"}

func posR() (out string){
	s1 := rand.NewSource(time.Now().UnixNano())
	r1 := rand.New(s1)
	n := r1.Intn(len(positive))
	out = positive[n]
	return
}

func negR() (out string){
	s1 := rand.NewSource(time.Now().UnixNano())
	r1 := rand.New(s1)
	n := r1.Intn(len(negative))
	out = negative[n]
	return
}

func line(aslongas string, hidden bool) (out string) {
	n := utf8.RuneCountInString(aslongas)
	if hidden {
		out = strings.Repeat(" ",n)
	}else{
		out = strings.Repeat(li,n)
	}
	return
}

func sub(text string) (out string) {
	out = ssli +text
	n := utf8.RuneCountInString(out)
	r := framewidth - n
	if r < 1 {
		out = out + li
	}else{
		out = out + strings.Repeat(li,r)
	}
	return
}

func frame(text string, head bool) (out string) {
	if head {
		out = mli + text
	}else{
		out = fli + text
	}
	n := utf8.RuneCountInString(out)
	r := framewidth - n
	if r < 1 {
		out = out + li
	}else{
		out = out + strings.Repeat(li,r)
	}
	if head {
		out = "\n" + out
	//}else{
	//	out = out + "\n"
	}
	return
}

// return the int as a string
func Sint(in int) (string) {
	return fmt.Sprint(in)
}

// return the float as a string
func Sflo(in float64) (string) {
	return fmt.Sprintf("%.2f",in)
}

func getGitTag() string {
	var (
		cmdOut []byte
		err    error
	)
	cmd := "git"
	args := []string{"tag", "--points-at", "HEAD"}
	if cmdOut, err = exec.Command(cmd, args...).Output(); err != nil {
		panic(err)
	}
	return string(cmdOut)
}

//Remove a string from a []string and the int number of strings afterwards
func removeStringFromArray(arr []string, rem string, after int) (out []string) {
	found := false
	i := 0
	for _, st := range arr {
		if found {
			if i < after {
				i++
			} else {
				found = false
			}
		} else {
			if st == rem {
				found = true
			} else {
				out = append(out, st)
			}
		}
	}
	return
}

//Ask a Question an read the answer
func isSure(quest string) bool {
	fmt.Printf("%s (type 'y/Y/yes' to confirm) : ", quest)
	in := bufio.NewReader(os.Stdin)
	line, err := in.ReadString('\n')
	if runtime.GOOS == "windows" {
		line = strings.TrimSuffix(line, "\r\n") //for Windows
	} else {
		line = strings.TrimSuffix(line, "\n")
	}
	checkErr(err)

	if line == "yes" || line == "y" || line == "Y" {
		return true
	} else {
		return false
	}
}

//Test if error is nil and panic if not
//TODO log seperately
func checkErr(err error) {
	if err != nil {
		panic(err)
	}
}

//make One String with Linebreaks out of an input String Array
func StrLines(in []string,border string) (out string) {
	i := 0
	for _, s := range in {
		neu := ""
		if i>0 {
			neu = "\n"
		}
		neu = neu + fmt.Sprintf("%s%s", border, s)
		out = out + neu
		i++
	}
	return
}

//Ask a question return the Answer
func getInput(quest string) string {
	fmt.Print(quest)
	in := bufio.NewReader(os.Stdin)
	line, err := in.ReadString('\n')
	if runtime.GOOS == "windows" {
		line = strings.TrimSuffix(line, "\r\n") //for Windows
	} else {
		line = strings.TrimSuffix(line, "\n")
	}
	checkErr(err)
	return line
}

//show Old Value, Ask Question and Return answer
func getNewInput(quest, old string) string {
	if old != "" {
		fmt.Println("Current:", old)
	}
	fmt.Print(quest)
	in := bufio.NewReader(os.Stdin)
	line, err := in.ReadString('\n')
	if runtime.GOOS == "windows" {
		line = strings.TrimSuffix(line, "\r\n") //for Windows
	} else {
		line = strings.TrimSuffix(line, "\n")
	}
	checkErr(err)
	if line == "" {
		return old
	} else {
		return line
	}
}

func stringArray2String(in []string, delim string) string {
	var out string
	for i, a := range in {
		if i == 0 {
			out = a
		} else {
			out = fmt.Sprintf("%s%s%s", out, delim, a)
		}
	}
	return out
}

func IntArray2String(in []int, delim string) (out string) {
	for i,a := range in {
		if i == 0 {
			out = fmt.Sprintf("%v",a)
		} else {
			out = fmt.Sprintf("%s%s%v", out, delim, a)
		}
	}
	return
}

func String2IntArray(in, delim string) (out []int) {
	read := strings.Split(in, delim)
	for _, s := range read {
		is, err := strconv.Atoi(s)
		checkErr(err)
		out = append(out, is)
	}
	return
}

func string2FloatArray(in string, delim string) (out []float64) {
	read := strings.Split(in, delim)
	for _, s := range read {
		fs, err := strconv.ParseFloat(s, 64)
		checkErr(err)
		out = append(out, fs)
	}
	return
}

// Takes a String and Cuts it into []string elements by delim
func String2StringArray(in string, delim string) (out []string) {
	read := strings.Split(in, delim)
	for _, s := range read {
		out = append(out, s)
	}
	return
}

func RetardRound(x float64) float64 {
	t := math.Trunc(x)
	if math.Abs(x-t) >= 0.5 {
		return t + math.Copysign(1, x)
	}
	return t
}

func Round(x, unit float64) float64 {
	//    return math.Round(x/unit) * unit
	return RetardRound(x/unit) * unit
}

// TEst if two time objects happen on same date
func DateEqual(date1, date2 time.Time) bool {
    y1, m1, d1 := date1.Date()
    y2, m2, d2 := date2.Date()
    return y1 == y2 && m1 == m2 && d1 == d2
}

func cleanString(in string) (out string) {
	work := strings.Replace(in, "/", "-", -1)
	work = strings.Replace(work, "*", "-", -1)
	work = strings.Replace(work, ":", "-", -1)
	work = strings.Replace(work, "<", "-", -1)
	work = strings.Replace(work, ">", "-", -1)
	work = strings.Replace(work, "?", "-", -1)
	work = strings.Replace(work, "|", "-", -1)
	work = strings.Replace(work, "+", "-", -1)
	work = strings.Replace(work, ",", "-", -1)
	work = strings.Replace(work, ";", "-", -1)
	work = strings.Replace(work, "=", "-", -1)
	work = strings.Replace(work, "[", "-", -1)
	out = strings.Replace(work, "]", "-", -1)
	return
}

func sumFloatArray(in []float64) (sum float64) {
	for _, e := range in {
		sum += e
	}
	return
}

func isElement(some int, group []int) bool {
	for _, e := range group {
		if e == some {
			return true
		}
	}
	return false
}

func AddNewElement(base, news []int) (out []int) {
	out = base
	for _,e := range news {
		if !isElement(e,base) {
			out = append(out,e)
		}
	}
	return
}

func removeItems(master, rem []int) []int {
	var out []int
	for _, v := range master {
		if !isElement(v, rem) {
			out = append(out, v)
		}
	}
	return out
}

func IsStrElement(some string, group []string) bool {
	for _, e := range group {
		if e == some {
			return true
		}
	}
	return false
}

func Tar(src string, writers ...io.Writer) error {
	// ensure the src actually exists before trying to tar it
	if _, err := os.Stat(src); err != nil {
		return fmt.Errorf("Unable to tar files - %v", err.Error())
	}
	mw := io.MultiWriter(writers...)

	//gzw := gzip.NewWriter(mw)
	//defer gzw.Close()

	tw := tar.NewWriter(mw)
	defer tw.Close()

	// walk path
	return filepath.Walk(src, func(file string, fi os.FileInfo, err error) error {
		// return on any error
		if err != nil {
			return err
		}
		// create a new dir/file header
		header, err := tar.FileInfoHeader(fi, fi.Name())
		if err != nil {
			return err
		}
		// update the name to correctly reflect the desired destination when untaring
		header.Name = strings.TrimPrefix(strings.Replace(file, src, "", -1), string(filepath.Separator))

		// write the header
		if err := tw.WriteHeader(header); err != nil {
			return err
		}

		// return on non-regular files (thanks to [kumo](https://medium.com/@komuw/just-like-you-did-fbdd7df829d3) for this suggested update)
		if !fi.Mode().IsRegular() {
			return nil
		}

		// open files for taring
		f, err := os.Open(file)
		if err != nil {
			return err
		}
		// copy file data into tar writer
		if _, err := io.Copy(tw, f); err != nil {
			return err
		}

		// manually close here after each file operation; defering would cause each file close
		// to wait until all operations have completed.
		f.Close()

		return nil
	})
}