scaffold/main.go

package main

import (
	_ "embed"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"
	"os/user"
	"path/filepath"
	"runtime"
	"strconv"

	"github.com/BurntSushi/toml"
)

//go:embed buildTime.txt
var buildTime string

//go:embed buildVersion.txt
var buildVersion string

type (
	Setup struct {
		Projects_basedir        string
		Module_basepath         string
		Project_dir_permissions string
		Setup_git               bool
		Create_Remote_Repo      bool
		Remote_User             string
		Remote_Location         string
		Remote_Label            string
		Remote_Alt_Label        string
		Commands                [][]string
		Setup_gitea             bool
		Gitea_server_account    string // should be in ~/.ssh/config
		Gitea_ssh_host_label    string
		Gitea_user_account      string
		Remote_Label_gitea      string
	}
	ScaffoldSetup struct {
		TestKey    string
		TestForSSH bool
	}
)

var (
	infoFlag       = flag.Bool("i", false, "Displays the program build information and exits.")
	cloneGiteaFlag = flag.Bool("c", false, "Clone from gitea. scaffold expects it to be an empty repository")
	giteaRepoFlag  = flag.String("g", "", "Specifies a gitea repository to clone from rather than create")
	sep            = "/"
	cfg_dir        = "devel/scaffold" // relative to <USER_CONFIG_DIR>, on linux /home/user/.config
	cfg_filename   = "scaffold-cfg.toml"
	setup          ScaffoldSetup
	npsetup        Setup
	hasSSH         = true
	projType       string
	newProjectName string
)

func main() {

	flag.Parse()

	user_cfg_dir, err := os.UserConfigDir()
	ifFerr("Unable to determine user config directory", err)

	if *infoFlag {
		fmt.Printf("Scaffold version: %s", buildVersion)
		fmt.Printf("Built: %s\n", buildTime)

		fmt.Printf("Running on a %s system.\n", runtime.GOOS)
		fmt.Printf("Arg count: %+v\n", os.Args)
		_ = isSSHAvailable()

		fmt.Printf("Gitea repo: %s\n", *giteaRepoFlag)

		at, err := availableProjectTypes(user_cfg_dir + sep + cfg_dir)
		ifFerr("Unable to get available project types", err)
		fmt.Printf("Avaiable types: %v\n", at)

		fmt.Println("System says -- user config directory: ", user_cfg_dir)

		os.Exit(0)
	}

	// Setup scaffold
	u, err := user.Current()
	ifFerr("Unable to get current user details", err)
	homeDir := u.HomeDir
	scaffold_cfg_dir := user_cfg_dir + sep + cfg_dir
	cfg_file := scaffold_cfg_dir + sep + cfg_filename

	if _, err := os.Stat(scaffold_cfg_dir); err != nil {
		e2 := os.MkdirAll(scaffold_cfg_dir, 0700)
		ifFerr("Unable to create scaffold configuration directory", e2)
	}

	if _, err := os.Stat(cfg_file); err != nil {
		fmt.Println("No scaffold program configuration file found - creating a default file")
		cfgfd, err := os.Create(cfg_file)
		ifFerr("Unable to create scaffold configuration file", err)
		defer cfgfd.Close()

		_, err = cfgfd.WriteString(cfg_content)
		ifFerr("Unable to write scaffold configuration file content", err)
		fmt.Println("Wrote new scaffold configuration file")

		_, err = toml.Decode(cfg_content, &setup)
		ifFerr("[Failed] to parse config file", err)
	} else {
		fmt.Println("found config file")
		_, err = toml.DecodeFile(cfg_file, &setup)
		ifFerr("[Failed] to parse config file", err)
	}

	if setup.TestForSSH {
		hasSSH = isSSHAvailable()
	}

	pts, err := availableProjectTypes(scaffold_cfg_dir)
	ifFerr("Unable to read scaffold config directory contents", err)

	// check command line
	// two forms of command
	if *cloneGiteaFlag {
		if len(os.Args) != 4 {
			leave(prog_help, pts)
		}
		projType = os.Args[2]
		newProjectName = os.Args[3]
		fmt.Printf("Not creating ... cloning %s project %s\n", projType, newProjectName)
	} else {
		if len(os.Args) != 3 {
			leave(prog_help, pts)
		}
		projType = os.Args[1]
		newProjectName = os.Args[2]
	}

	if !knownType(projType, pts) {
		log.Fatalf("Unkown project type: %s\n", projType)
		os.Exit(1)
	}

	has := isConfigAvailable(pts, projType)
	if !has {
		fmt.Printf("No configuration found for project type: %s\n", projType)
		os.Exit(1)
	}
	fmt.Printf("Project type found: %t\n", has)

	projectTypeDir := scaffold_cfg_dir + sep + projType
	projectCfgFile := projectTypeDir + sep + "scaffold-" + projType + ".toml"

	_, err = toml.DecodeFile(projectCfgFile, &npsetup)
	ifFerr("Unable to read configuration for requested project type", err)

	//Setup and Ready to begin

	// Permissions are octal (ugo - user, group, other)
	inval, err := strconv.ParseUint(npsetup.Project_dir_permissions, 8, 64)
	if err != nil {
		inval = 0700
	}

	// make new project directory
	newProjDir := homeDir + sep + npsetup.Projects_basedir + sep + newProjectName

	// Clone or create ??
	if *cloneGiteaFlag {
		bd := homeDir + sep + npsetup.Projects_basedir

		_, err = exec.Command("mkdir", "-p", bd).Output()
		ifFerr("Unable to create projects base directory", err)
		fmt.Println("Made or found projects base directory")

		err = os.Chdir(bd)
		ifFerr("Unable to change into projects basedir: "+bd, err)

		loc := "ssh://" + npsetup.Gitea_ssh_host_label + sep + npsetup.Gitea_user_account + sep + newProjectName + ".git"
		_, err = exec.Command("git", "clone", loc).Output()
		ifFerr("Unable to clone gitea repository at: "+loc, err)
		fmt.Printf("Cloned repository from %s\n", loc)

	} else {
		if _, err = os.Stat(newProjDir); os.IsExist(err) {
			log.Fatalf("Project directory already exists -- %s\n", err)
		}

		err = os.MkdirAll(newProjDir, os.FileMode(inval))
		ifFerr("Unable to create new project directory ", err)
		fmt.Printf("created new project directory: %s\n", newProjDir)
	}

	err = os.Chdir(newProjDir)
	ifFerr("Unable to change into new project directory to continue", err)

	// copy contents from projectType/sample
	err = filepath.Walk(projectTypeDir+sep+"sample", func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() && path == scaffold_cfg_dir {
			return nil
		}
		if info.IsDir() {
			err = os.MkdirAll(info.Name(), os.FileMode(inval))
			ifFerr("Unable to create sub dir "+info.Name(), err)
		} else {
			src, err := os.Open(path)
			ifFerr("Unable to open file for copying: "+path, err)
			defer src.Close()

			dest, err := os.Create(info.Name())
			ifFerr("Unable to make new file: "+info.Name(), err)
			defer dest.Close()

			_, err = io.Copy(dest, src)
			ifFerr("Unable to copy file: "+info.Name(), err)
		}
		return nil
	})
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("Project sample skeleton copied")

	// run your init commands from the projectType/scaffold-<PROJECTTYPE>.toml file

	for _, comm := range npsetup.Commands {
		args := comm[1:]
		if comm[0] == "go" && comm[1] == "mod" && comm[2] == "init" {
			args[2] = args[2] + sep + newProjectName
			//fmt.Printf("executing: %+v -- %+v\n", comm, args)
		}
		_, err = exec.Command(comm[0], args...).Output()
		if err != nil {
			commstring := fmt.Sprintf("Unable to execute command: %+v", comm)
			log.Fatalf("%s -- %s\n", commstring, err)
		}
		fmt.Printf("executing: %+v %+v\n", comm[0], args)
	}

	// setup git and gitea
	if hasSSH && npsetup.Setup_git {
		setupGit(newProjectName)
	}

	fmt.Printf("New %s Project: %s ready\n", projType, newProjectName)
}

func setupGit(anpn string) {
	if !*cloneGiteaFlag {
		// init repo
		_, err := exec.Command("git", "init").Output()
		ifFerr("Unable to initialize git repository", err)
	}

	nifd, err := os.Create(".gitignore")
	ifFerr("Unable to create .gitignore file", err)
	defer nifd.Close()

	var gi_content string
	var gi_in []byte = []byte("bin/")

	gisrc, err := os.Open("GITIGNORE")
	if err == nil { // assume error means there is no source file
		gi_in, err = io.ReadAll(gisrc)
		if err != nil {
			fmt.Println("Unable to read GITIGNORE, using default content")
		}
		gi_content = fmt.Sprintf("%s\n\n%s", anpn, string(gi_in))

		_, err = nifd.WriteString(gi_content)
		ifFerr("Unable to write .gitignore content", err)
		fmt.Println("Wrote .gitignore content")

		// remove GITIGNORE
		err = os.Remove("GITIGNORE")
		if err != nil {
			fmt.Println("Unable to remove GITIGNORE file")
		}
	}
	defer gisrc.Close()

	// stage files
	_, err = exec.Command("git", "add", ".").Output()
	ifFerr("Unable to stage files prior to first commit", err)

	// first commit
	_, err = exec.Command("git", "commit", "-m", "\"Initial Commit\"").Output()
	ifFerr("Unable to make first commit, are your git config --global user.email and user.name set?", err)
	fmt.Println("Made initial commit to local repository")

	if npsetup.Create_Remote_Repo {
		// create remote repo
		acomm := fmt.Sprintf("cd %s && git init --bare %s.git", npsetup.Remote_Location, anpn)
		_, err = exec.Command("ssh", npsetup.Remote_User, acomm).Output()
		ifFerr("Unable to create remote repository", err)
		fmt.Println("Remote repository created")

		// add remote to local repo
		new_remote_repo := npsetup.Remote_User + ":" + npsetup.Remote_Location + "/" + anpn + ".git"
		var rlabel string
		if *cloneGiteaFlag {
			rlabel = npsetup.Remote_Alt_Label
		} else {
			rlabel = npsetup.Remote_Label
		}

		_, err = exec.Command("git", "remote", "add", rlabel, new_remote_repo).Output()
		ifFerr("Unable to set git remote for new repo", err)
		fmt.Println("Added remote repo to git as " + rlabel)

		// push initial commit
		// be sure you have set
		// git config --global init.defaultBranch main
		_, err = exec.Command("git", "push", rlabel, "main").Output()
		ifFerr("Unable to push initial commit to "+rlabel, err)
		fmt.Println("Pushed initial commit to remote")
	}

	if npsetup.Setup_gitea {
		setupGitea(anpn, *cloneGiteaFlag)
	}
}

func setupGitea(npn string, cloned bool) {
	if !cloned {
		// create gitea repo
		grcomm := fmt.Sprintf("%s:%s/%s.git", npsetup.Gitea_ssh_host_label, npsetup.Gitea_user_account, npn)
		_, err := exec.Command("git", "remote", "add", npsetup.Remote_Label_gitea, grcomm).Output()
		ifFerr("Unable to set git remote for new project to gitea", err)
		fmt.Println("Added remote repo to git for gitea as ", npsetup.Remote_Label_gitea)
	}
	var rlabel string
	if *cloneGiteaFlag {
		rlabel = "origin"
	} else {
		rlabel = npsetup.Remote_Label_gitea
	}

	// -u sets upstream tracking
	_, err := exec.Command("git", "push", "-u", rlabel, "main").Output()
	ifFerr("Unable to push new project to gitea", err)
	fmt.Println("Pushed new project to gitea")
}

func leave(ph string, ptypes []string) {
	fmt.Println(ph)
	fmt.Printf("Available project types: %v\n", ptypes)
	os.Exit(1)
}

func knownType(at string, ptypes []string) bool {
	for _, v := range ptypes {
		if v == at {
			return true
		}
	}
	return false
}