path: root/redomod.go

package repostatus

import (
	"bufio"
	"os"
	"path/filepath"
	"strings"

	"go.wit.com/log"
)

// this checks to see if the repo is truly not dependent on _anything_ else
// like spew or lib/widget
func (rs *RepoStatus) CheckPrimativeGoMod() bool {
	log.Log(WARN, "CheckPrimativeGoMod()", rs.realPath.String())
	tmp := filepath.Join(rs.realPath.String(), "go.mod")
	gomod, err := os.Open(tmp)
	if err != nil {
		log.Log(WARN, "missing go.mod", rs.realPath.String())
		rs.goConfig = nil
		return false
	}
	defer gomod.Close()

	scanner := bufio.NewScanner(gomod)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		parts := strings.Split(line, " ")
		log.Log(INFO, "  gomod:", parts)
		if len(parts) >= 1 {
			log.Log(INFO, "  gomod: part[0] =", parts[0])
			if parts[0] == "require" {
				log.Log(INFO, "  should return false here")
				return false
			}

		}
	}
	return true
}

// readGoMod reads and parses the go.sum file (TODO: do the go.mod file)
func (rs *RepoStatus) ReadGoMod() bool {
	if rs.CheckPrimativeGoMod() {
		log.Info("PRIMATIVE repo:", rs.String())
		return true
	}

	tmp := filepath.Join(rs.realPath.String(), "go.sum")
	gosum, err := os.Open(tmp)
	if err != nil {
		log.Log(WARN, "missing go.sum", rs.realPath.String())
		rs.goConfig = nil
		return false
	}
	defer gosum.Close()

	var deps GoConfig
	deps = make(GoConfig)

	scanner := bufio.NewScanner(gosum)
	log.Log(INFO, "gosum:", tmp)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		parts := strings.Split(line, " ")
		if len(parts) == 3 {
			godep := strings.TrimSpace(parts[0])
			version := strings.TrimSpace(parts[1])
			if strings.HasSuffix(version, "/go.mod") {
				version = strings.TrimSuffix(version, "/go.mod")
			}
			currentversion, ok := deps[godep]
			if ok {
				if currentversion != version {
					// ignore these warnings for now
					depname := rs.String()
					if strings.HasPrefix(depname, "go.wit.com") {
						log.Log(INFO, "REPO:", rs.realPath.String())
						log.Log(INFO, "  version mismatch:", godep, version, currentversion)
					} else {
						log.Log(INFO, "REPO:", rs.realPath.String())
						log.Log(INFO, "  version mismatch:", godep, version, currentversion)
					}
				}
			} else {
				deps[godep] = version
				log.Log(INFO, "\t", godep, "=", version)
			}
		} else {
			log.Log(WARN, "\t INVALID:", parts)
		}
	}

	if err := scanner.Err(); err != nil {
		rs.goConfig = nil
		return false
	}

	rs.goConfig = deps
	return true
}

// check if it is safe to remake the go.sum & go.mod files
func (rs *RepoStatus) CheckSafeGoSumRemake() (bool, []string) {
	myGoSumS := rs.goSumStatus.String()
	if rs.ReadGoMod() {
		log.Log(INFO, "parsed go.mod", rs.realPath.String())
	} else {
		log.Log(WARN, "Something went wrong parsing go.mod", rs.realPath.String())
		return false, nil
	}
	log.Log(WARN, "go.sum:", rs.realPath.String())
	var clean []string
	for depname, version := range rs.goConfig {
		if strings.HasSuffix(depname, "/v2") {
			log.Log(WARN, "  FOUND /v2 wierd golang stuff. instead, look for:", depname)
			depname = strings.TrimSuffix(depname, "/v2")
		}
		log.Log(WARN, "  ", depname, version)
		deprs, ok := windowMap[depname]
		if ok {
			if deprs.CheckDirty() {
				log.Log(WARN, "   IS DIRTY", deprs.String())
				clean = append(clean, deprs.String())
			}
			if deprs.readOnly.String() == "true" {
				log.Log(WARN, "   SKIPPING Read Only", deprs.String())
			} else {
				goSumS := deprs.goSumStatus.String()
				log.Log(WARN, "   FOUND", deprs.String(), goSumS)
				username := deprs.mainWorkingName.String()
				userhash, _ := deprs.gitConfig.hashes[username]
				userversion, _ := deprs.gitConfig.versions[userhash]
				log.Log(WARN, "     username :"+username, userhash)
				log.Log(WARN, "     username :"+username, userversion)
				if version == userversion {
					log.Log(WARN, "     USER VERSIONS MATCH", version, userversion, goSumS)
					clean = append(clean, deprs.String())
				} else {
					os.Unsetenv("GO111MODULE")
					log.Log(WARN, "     USER VERSIONS MISMATCH", version, userversion, myGoSumS)
					log.Log(WARN, "     IGNORE UNCHANGED REPO. RUNNING 'go get'", depname, userversion)
					err, output := rs.RunCmd([]string{"go", "get", depname + "@" + userversion})
					log.Log(WARN, "     go get", depname, err, output)
					/*
						switch goSumS {
						case "SAFE":
							log.Log(WARN, "     USER VERSIONS MISMATCH", version, userversion)
							log.Log(WARN, "     IGNORE SAFE REPO")
							err, output := rs.RunCmd([]string{"go", "get", depname + "@" + userversion})
							log.Log(WARN, "     go get", depname, err, output)
						case "CLEAN":
							log.Log(WARN, "     USER VERSIONS MISMATCH", version, userversion)
							log.Log(WARN, "     IGNORE CLEAN REPO")
						case "PRIMATIVE":
							log.Log(WARN, "     USER VERSIONS MISMATCH", version, userversion)
							log.Log(WARN, "     IGNORE PRIMATIVE REPO")
							err, output := rs.RunCmd([]string{"go", "get", depname + "@" + userversion})
							log.Log(WARN, "     go get", depname, err, output)
						default:
							log.Log(WARN, "     USER VERSIONS MISMATCH default", version, userversion)
							clean = append(clean, deprs.String())
							if myGoSumS == "UNCHANGED" {
							}
						}
					*/
				}
			}
		} else {
			// log.Log(WARN, "   NOT FOUND", depname)
			// only fail on our stuff
			if strings.HasPrefix(depname, "go.wit.com") {
				log.Log(WARN, "   go get -v", depname)
				// rs.RunCmd([]string{"go", "get", "-v", depname})
				return false, clean
			}
			// log.Log(WARN, "   NOT FOUND BUT IGNORING FOR NOW")
		}
	}
	if len(clean) == 0 {
		return true, nil
	}
	return false, clean
}

func (rs *RepoStatus) CheckGoSum() (bool, string) {
	if rs.ReadGoMod() {
		log.Log(INFO, "parsed go.mod", rs.realPath.String())
	} else {
		log.Log(WARN, "Something went wrong parsing go.mod", rs.realPath.String())
		return false, ""
	}
	log.Log(WARN, "go.sum:", rs.realPath.String())
	for depname, version := range rs.goConfig {
		if strings.HasSuffix(depname, "/v2") {
			log.Log(WARN, "  FOUND /v2 wierd golang stuff. instead, look for:", depname)
			depname = strings.TrimSuffix(depname, "/v2")
		}
		log.Log(WARN, "  ", depname, version)
		deprs, ok := windowMap[depname]
		if ok {
			if deprs.CheckDirty() {
				log.Log(WARN, "   IS DIRTY", deprs.String())
				return false, ""
			}
			if deprs.readOnly.String() == "true" {
				log.Log(WARN, "   SKIPPING Read Only", deprs.String())
			} else {
				log.Log(WARN, "   FOUND", deprs.String(), deprs.goSumStatus.String())
				username := deprs.mainWorkingName.String()
				userhash, _ := deprs.gitConfig.hashes[username]
				userversion, _ := deprs.gitConfig.versions[userhash]
				log.Log(WARN, "     username :"+username, userhash)
				log.Log(WARN, "     username :"+username, userversion)
				if version == userversion {
					log.Log(WARN, "     USER VERSIONS MATCH", version, userversion)
					if deprs.goSumStatus.String() == "BAD" {
						log.Log(WARN, "     USER VERSION IS BAD!! return false")
						return false, ""
					}
				} else {
					log.Log(WARN, "     USER VERSIONS MISMATCH", version, userversion)
					return false, ""
				}
			}
		} else {
			// log.Log(WARN, "   NOT FOUND", depname)
			if strings.HasSuffix(depname, "/v2") {
				log.Log(WARN, "       FOUND /v2 wierd golang stuff. instead, look for:", depname)
			}
			// only fail on our stuff
			if strings.HasPrefix(depname, "go.wit.com") {
				log.Log(WARN, "   go get -v", depname)
				// rs.RunCmd([]string{"go", "get", "-v", depname})
				return false, depname
			}
			// log.Log(WARN, "   NOT FOUND BUT IGNORING FOR NOW")
		}
	}
	err, output := rs.RunCmd([]string{"git", "branch", "--remotes"})
	if err == nil {
		lines := strings.Split(output, "\n")
		for i, s := range lines {
			log.Log(WARN, "add line", i, s)
		}
	} else {
		log.Log(WARN, "git branch --remotes failed", err)
	}
	return true, ""
}

func (rs *RepoStatus) MakeRedomod() bool {
	var err error
	var b bool
	var output string
	var worked bool = true
	if rs.ReadOnly() {
		log.Log(WARN, "will not go mod redo read only repos", rs.String())
		return false
	}

	os.Unsetenv("GO111MODULE")
	path := rs.realPath.String()
	err, b, output = RunCmd(path, []string{"rm", "-f", "go.mod", "go.sum"})
	if err != nil {
		worked = false
		log.Log(WARN, "rm failed", err, b, output)
	}
	err, b, output = RunCmd(path, []string{"go", "mod", "init"})
	if err != nil {
		worked = false
		log.Log(WARN, "go mod init failed", err, b, output)
	}
	err, b, output = RunCmd(path, []string{"go", "mod", "tidy"})
	if err != nil {
		worked = false
		log.Log(WARN, "go mod tidy failed", err, b, output)
	}
	if worked {
		log.Log(WARN, "MakeRedomod() worked", path)
	} else {
		log.Log(WARN, "MakeRedomod() failed", path)
	}
	return worked
}