new uru PATH handling

uru_pathmunge.go

package main

import (
	"errors"
	"fmt"
	"os"
	"runtime"
	"strings"
)

const (
	URU_WIN_VOL       = `C:`
	URU_RUBY_PATH     = `/fake/ruby/bin`
	URU_GEM_PATH      = `/fake/.gem/ruby/2.2.0/bin`
	URU_USER_PATH_MOD = `/fake/tool/bin`
)

var (
	canary = []string{`_U1_`, `_U2_`}
)

// Confirm that both canaries exist on PATH and data exists between them
func isUruPath() bool {
	path := os.Getenv(`PATH`)
	if path != "" {
		u1 := strings.Index(path, canary[0])
		u2 := strings.Index(path, canary[1])

		return (u1 != -1) && (u2 != -1) && (u2 > u1)
	}

	return false
}

// Scans PATH for canaries and returns everything between canary[0]
// and canary[1], inclusive.
func getUruHunk(path string) (string, error) {
	u1 := strings.Index(path, canary[0])
	u2 := strings.Index(path, canary[1])
	if (u1 != -1) && (u2 != -1) && (u2 > u1) {
		return path[u1 : u2+len(canary[1])], nil
	}

	return "", errors.New("[ERROR] unable to extract uru hunk from PATH")
}

func addUruPath(basePath string) (uruPath string, err error) {
	// TODO check for existing uru hunk; remove if present before proceeding
	var pathAdd []string
	if runtime.GOOS == `windows` {
		pathAdd = []string{
			canary[0],
			fmt.Sprintf("%s%s", URU_WIN_VOL, URU_GEM_PATH),
			fmt.Sprintf("%s%s", URU_WIN_VOL, URU_RUBY_PATH),
			canary[1],
		}
	} else {
		pathAdd = []string{canary[0], URU_GEM_PATH, URU_RUBY_PATH, canary[1]}
	}
	newPath := strings.Join(append(pathAdd, basePath), string(os.PathListSeparator))
	if err := os.Setenv(`PATH`, newPath); err != nil {
		return "", errors.New("[ERROR] unable to prefix PATH with uru hunk")
	}

	return strings.Join(pathAdd, string(os.PathListSeparator)), nil
}

func addUserPathMod(basePath string) error {
	var pathAdd []string
	if runtime.GOOS == `windows` {
		pathAdd = []string{fmt.Sprintf("%s%s", URU_WIN_VOL, URU_USER_PATH_MOD)}
	} else {
		pathAdd = []string{URU_USER_PATH_MOD}
	}
	newPath := strings.Join(append(pathAdd, basePath), string(os.PathListSeparator))
	if err := os.Setenv(`PATH`, newPath); err != nil {
		return errors.New("[ERROR] unable to prefix PATH envar with user mod")
	}

	return nil
}

func rmUruPath(uruPath, basePath string) error {
	sep := string(os.PathListSeparator)
	uruStartsPath := strings.HasPrefix(basePath, canary[0])

	var splitStr string
	if uruStartsPath {
		splitStr = fmt.Sprintf("%s%s", uruPath, sep)
	} else {
		splitStr = fmt.Sprintf("%s%s%s", sep, uruPath, sep)
	}

	p := strings.Split(basePath, splitStr)

	var newPath string
	if uruStartsPath {
		newPath = p[1]
	} else {
		newPath = strings.Join(p, sep)
	}
	if err := os.Setenv(`PATH`, newPath); err != nil {
		return errors.New("[ERROR] unable to set uru free PATH envar")
	}

	return nil
}

func main() {
	fmt.Println("---> capturing user's original base PATH")
	basePath := os.Getenv(`PATH`)
	fmt.Printf("Base PATH = %s\n\n", basePath)

	fmt.Println("---> enhancing base PATH with uru path hunk")
	uruHunk, err := addUruPath(basePath)
	if err != nil {
		panic(err)
	}
	fmt.Println("Uru path hunk =", uruHunk)
	uruPath := os.Getenv(`PATH`)
	fmt.Printf("Uru enhanced PATH = %s\n\n", uruPath)

	fmt.Println("---> removing uru path hunk from base PATH")
	h, err := getUruHunk(uruPath)
	if err != nil {
		panic(err)
	}
	err = rmUruPath(h, uruPath)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Clean PATH = %s\n\n", os.Getenv(`PATH`))

	fmt.Println("---> prefixing uru PATH with user mods")
	err = addUserPathMod(uruPath)
	if err != nil {
		panic(err)
	}
	userPath := os.Getenv(`PATH`)
	fmt.Printf("User PATH = %s\n\n", userPath)

	h, err = getUruHunk(uruPath)
	if err != nil {
		panic(err)
	}
	fmt.Println("---> removing uru path hunk from user PATH")
	err = rmUruPath(h, userPath)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Final PATH = %s\n", os.Getenv(`PATH`))
}