Refactored use of paths.

Author: Horacio Duran

actions/actions.go

@@ -3,18 +3,50 @@ package actions
 import (
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 
 	"github.com/perrito666/goworkon/environment"
 	"github.com/perrito666/goworkon/goinstalls"
 	"github.com/perrito666/goworkon/goswitch"
+	"github.com/perrito666/goworkon/paths"
 	"github.com/pkg/errors"
 )
 
-func configGet(basePath, name string) (environment.Config, error) {
+func globalBins() ([]string, error) {
+	basePath, err := paths.XdgDataConfig()
+	if err != nil {
+		return nil, errors.Wrap(err, "retrieving config files")
+	}
 	cfgs, err := environment.LoadConfig(basePath)
 	if err != nil {
-		return environment.Config{}, errors.WithStack(err)
+		return nil, errors.Wrap(err, "loading configs")
+	}
+	globalBin := []string{}
+	for _, cfg := range cfgs {
+		if cfg.GlobalBin {
+			globalBin = append(globalBin, paths.GoPathBin(cfg.GoPath))
+		}
+	}
+	return globalBin, nil
+
+}
+
+var notFoundRe = regexp.MustCompile("evironment .* not found")
+
+func isNotFound(err error) bool {
+	err = errors.Cause(err)
+	return notFoundRe.MatchString(err.Error())
+}
+
+func configGet(name string) (environment.Config, error) {
+	basePath, err := paths.XdgDataConfig()
+	if err != nil {
+		return environment.Config{}, errors.Wrapf(err, "retrieving config for %q", name)
+	}
+	cfgs, err := environment.LoadConfig(basePath)
+	if err != nil {
+		return environment.Config{}, errors.Wrapf(err, "loading config for %q", name)
 	}
 	env, ok := cfgs[name]
 	if !ok {
@@ -25,46 +57,52 @@ func configGet(basePath, name string) (environment.Config, error) {
 
 // Switch changes the environment to the specified one
 // if it exists, otherwise its a noop and returns error.
-func Switch(basePath, installName string) error {
-	cfgs, err := environment.LoadConfig(basePath)
+func Switch(installName string) error {
+	basePath, err := paths.XdgData()
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.Wrapf(err, "retrieving config for %q", installName)
 	}
-	env, err := configGet(basePath, installName)
+
+	env, err := configGet(installName)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.Wrapf(err, "loading config to switch to %q", installName)
 	}
 
 	settings, err := environment.LoadSettings(basePath)
 	if err != nil {
-		return errors.Wrap(err, "loading settings")
+		return errors.Wrapf(err, "loading settings to switch to %q", installName)
 	}
 
-	extraBins := []string{}
-	for _, cfg := range cfgs {
-		if cfg.GlobalBin {
-			extraBins = append(extraBins, filepath.Join(cfg.GoPath, "bin"))
-		}
+	extraBins, err := globalBins()
+	if err != nil {
+		return errors.Wrap(err, "determining global bin paths")
 	}
-	goswitch.Switch(basePath, env, installName == settings.Default, extraBins)
-
-	return nil
+	return errors.Wrapf(goswitch.Switch(env, installName == settings.Default, extraBins),
+		"switching to environment %q", installName)
 }
 
 // Reset will try toreturn the env to its original state.
 func Reset() error {
 	return goswitch.Reset()
 }
 
-func ensureVersionInstalled(goVersion, basePath, goroot string) (goinstalls.Version, error) {
-	installFolder := filepath.Join(basePath, "installs")
-	goFolder := filepath.Join(installFolder, goVersion)
+func ensureVersionInstalled(goVersion, goroot string) (goinstalls.Version, error) {
+	goFolder, err := paths.XdgDataGoInstallsBinForVerson(goVersion)
+	if err != nil {
+		return goinstalls.Version{}, errors.Wrapf(err, "determining if %q exists", goVersion)
+	}
+	// if the bin folder is not there, the version is not properly
+	// installed.
 	if _, err := os.Stat(goFolder); err == nil {
 		return goinstalls.VersionFromString(goVersion)
 	}
 	versions, err := goinstalls.OnlineAvailableVersions()
 	if err != nil {
-		return goinstalls.Version{}, errors.WithStack(err)
+		return goinstalls.Version{}, errors.Wrap(err, "retrieving available online versions")
+	}
+	installFolder, err := paths.XdgDataGoInstalls()
+	if err != nil {
+		return goinstalls.Version{}, errors.Wrapf(err, "determining go installs folder to install %q", goVersion)
 	}
 	for k, v := range versions {
 		if k.CommonVersionString() == goVersion {
@@ -73,7 +111,7 @@ func ensureVersionInstalled(goVersion, basePath, goroot string) (goinstalls.Vers
 				return k, nil
 			}
 			err = goinstalls.InstallVersion(k, v, installFolder, goroot)
-			return k, errors.WithStack(err)
+			return k, errors.Wrapf(err, "installing go %q", goVersion)
 		}
 	}
 	return goinstalls.Version{}, errors.Errorf("go version %q not found", goVersion)
@@ -83,25 +121,26 @@ func ensureVersionInstalled(goVersion, basePath, goroot string) (goinstalls.Vers
 // Create creates the an environment with the passed name
 // in the passed go version, if it exists its a noop and
 // returns an error.
-func Create(installName, goVersion, basePath, goPath string, settings environment.Settings) error {
-	cfgs, err := environment.LoadConfig(basePath)
-	if err != nil {
-		return errors.WithStack(err)
-	}
-	if _, ok := cfgs[installName]; ok {
-		return nil
+func Create(installName, goVersion, goPath string, settings environment.Settings) error {
+	_, err := configGet(installName)
+	if err != nil && !isNotFound(err) {
+		return errors.Wrapf(err, "determining if environment %q exists", installName)
 	}
-	v, err := ensureVersionInstalled(goVersion, basePath, settings.Goroot)
+	v, err := ensureVersionInstalled(goVersion, settings.Goroot)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.Wrapf(err, "installing go %q to create %q environment", goVersion, installName)
 	}
 	c := environment.Config{
 		Name:      installName,
 		GoVersion: v.String(),
 		GoPath:    goPath,
 	}
-	if err := c.Save(basePath); err != nil {
-		return errors.WithStack(err)
+	configPath, err := paths.XdgDataConfig()
+	if err != nil {
+		return errors.Wrapf(err, "getting config folder to save %q config", installName)
+	}
+	if err := c.Save(configPath); err != nil {
+		return errors.Wrapf(err, "saving %q config", installName)
 	}
 	return nil
 }
@@ -119,25 +158,29 @@ func extractEnvironment(attribute string) (string, string, error) {
 }
 
 // Set sets <attribute> to <value> in the correct setting or returns an error.
-func Set(attribute, value, baseFolder string) error {
+func Set(attribute, value string) error {
 	environmentName, attribute, err := extractEnvironment(attribute)
 	if err != nil {
 		return errors.Errorf("setting %q to %q", attribute, value)
 	}
 	if environmentName != "" {
-		cfg, err := configGet(baseFolder, environmentName)
+		cfg, err := configGet(environmentName)
 		if err != nil {
-			return errors.WithStack(err)
+			return errors.Wrapf(err, "finding config for %q", environmentName)
 		}
-		return errors.Wrapf(cfg.Set(attribute, value, baseFolder), "stting %q to %q", attribute, value)
+		return errors.Wrapf(cfg.Set(attribute, value), "setting %q to %q", attribute, value)
 
 		return errors.New("setting environment attributes is not implemented")
 	}
 
-	settings, err := environment.LoadSettings(baseFolder)
+	settingsFolder, err := paths.XdgData()
+	if err != nil {
+		return errors.Wrapf(err, "determining settings folder to set %q", attribute)
+	}
+	settings, err := environment.LoadSettings(settingsFolder)
 	if err != nil {
 		return errors.Wrap(err, "loading settings")
 	}
 
-	return errors.Wrapf(settings.Set(attribute, value, baseFolder), "setting %q to %q", attribute, value)
+	return errors.Wrapf(settings.Set(attribute, value), "setting %q to %q", attribute, value)
 }

commands.go

@@ -47,11 +47,7 @@ func (c Create) Validate() error {
 
 // Run implements Command.
 func (c Create) Run() error {
-	installFolder, err := xdgData()
-	if err != nil {
-		return errors.WithStack(err)
-	}
-	err = actions.Create(c.environmentName, c.goVersion, installFolder, c.goPath, c.settings)
+	err := actions.Create(c.environmentName, c.goVersion, c.goPath, c.settings)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -78,14 +74,10 @@ func (s Switch) Validate() error {
 
 // Run implements Command.
 func (s Switch) Run() error {
-	installFolder, err := xdgData()
-	if err != nil {
-		return errors.WithStack(err)
-	}
 	if s.environmentName == "" {
 		return actions.Reset()
 	}
-	err = actions.Switch(installFolder, s.environmentName)
+	err := actions.Switch(s.environmentName)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -149,10 +141,5 @@ func (s Set) Validate() error {
 
 // Run implements Command.
 func (s Set) Run() error {
-	dataDir, err := xdgData()
-	if err != nil {
-		return errors.Wrap(err, "getting xdg data dir for \"Set\" command")
-	}
-
-	return errors.WithStack(actions.Set(s.attribute, s.value, dataDir))
+	return errors.WithStack(actions.Set(s.attribute, s.value))
 }

environment/config.go

@@ -29,6 +29,9 @@ type Config struct {
 	GlobalBin bool `json:"globalbin"`
 	// GoPath
 	GoPath string `json:"gopath"`
+
+	// filePath holds the path for this config file.
+	filePath string
 }
 
 func maybeEnsureFolderExists(folder string) error {
@@ -52,7 +55,6 @@ func maybeEnsureFolderExists(folder string) error {
 // Save serializes and writes the Config in a file in the
 // passed folder.
 func (c *Config) Save(baseFolder string) error {
-	baseFolder = filepath.Join(baseFolder, "configs")
 	if err := maybeEnsureFolderExists(baseFolder); err != nil {
 		return errors.WithStack(err)
 	}
@@ -75,7 +77,6 @@ func (c *Config) Save(baseFolder string) error {
 
 // LoadConfig will load Config files in the given location
 func LoadConfig(baseFolder string) (map[string]Config, error) {
-	baseFolder = filepath.Join(baseFolder, "configs")
 	if err := maybeEnsureFolderExists(baseFolder); err != nil {
 		return nil, errors.WithStack(err)
 	}
@@ -94,6 +95,7 @@ func LoadConfig(baseFolder string) (map[string]Config, error) {
 			if err = json.Unmarshal(contents, &c); err != nil {
 				return errors.WithStack(err)
 			}
+			c.filePath = baseFolder
 			allConfigs[c.Name] = c
 			return nil
 		}()
@@ -106,7 +108,11 @@ func LoadConfig(baseFolder string) (map[string]Config, error) {
 
 // Set will set the value of <attribute> to <value> if attribute is a valid
 // member of Config.
-func (c Config) Set(attribute, value, baseFolder string) error {
+func (c Config) Set(attribute, value string) error {
+	if c.filePath == "" {
+		return errors.New("this config neds to be saved before Set can be used.")
+	}
+
 	switch strings.ToLower(attribute) {
 	case "globalbin":
 		if strings.ToLower(value) == "true" {
@@ -119,5 +125,5 @@ func (c Config) Set(attribute, value, baseFolder string) error {
 	default:
 		return errors.Errorf("%q is not a valid setting", attribute)
 	}
-	return errors.WithStack(c.Save(baseFolder))
+	return errors.WithStack(c.Save(c.filePath))
 }

environment/settings.go

@@ -19,6 +19,9 @@ type Settings struct {
 	// Default is the default environment to set, this will behave
 	// a bit differently since its for general use.
 	Default string `json:"default"`
+
+	// filePath holds the path for this settings file.
+	filePath string
 }
 
 // Save serializes and writes the Settings in a file in the
@@ -46,7 +49,11 @@ func (s Settings) Save(baseFolder string) error {
 
 // Set will set the value of <attribute> to <value> if attribute is a valid
 // member of Settings.
-func (s Settings) Set(attribute, value, baseFolder string) error {
+func (s Settings) Set(attribute, value string) error {
+	if s.filePath == "" {
+		return errors.New("these settings neds to be saved before Set can be used")
+	}
+
 	switch strings.ToLower(attribute) {
 	case "goroot":
 		s.Goroot = value
@@ -55,7 +62,7 @@ func (s Settings) Set(attribute, value, baseFolder string) error {
 	default:
 		return errors.Errorf("%q is not a valid setting", attribute)
 	}
-	return errors.WithStack(s.Save(baseFolder))
+	return errors.WithStack(s.Save(s.filePath))
 }
 
 // LoadSettings will load Settings files in the given location
@@ -78,5 +85,6 @@ func LoadSettings(baseFolder string) (Settings, error) {
 	if err := json.Unmarshal(contents, &s); err != nil {
 		return Settings{}, errors.WithStack(err)
 	}
+	s.filePath = baseFolder
 	return s, nil
 }

goswitch/goswitch.go

@@ -3,10 +3,11 @@ package goswitch
 import (
 	"fmt"
 	"os"
-	"path/filepath"
 	"strings"
 
 	"github.com/perrito666/goworkon/environment"
+	"github.com/perrito666/goworkon/paths"
+	"github.com/pkg/errors"
 )
 
 const (
@@ -30,7 +31,7 @@ func setenv(varName, varValue string) string {
 
 // Switch will set the proper environment variables to set an environment
 // as the current running one.
-func Switch(basePath string, cfg environment.Config, isDefault bool, extraBin []string) error {
+func Switch(cfg environment.Config, isDefault bool, extraBin []string) error {
 	pgopath := os.Getenv(PREVGOPATH)
 	ppath := os.Getenv(PREVPATH)
 	pps1 := os.Getenv(PREVPS1)
@@ -41,27 +42,22 @@ func Switch(basePath string, cfg environment.Config, isDefault bool, extraBin []
 	if pgopath == "" && !isDefault {
 		envVars = append(envVars, setenv(PREVGOPATH, gopath))
 	}
-	envVars = append(envVars, setenv(GOPATH, cfg.GoPath))
 	if ppath == "" && !isDefault {
 		envVars = append(envVars, setenv(PREVPATH, path))
 	}
 	if pps1 == "" && !isDefault {
 		envVars = append(envVars, setenv(PREVPS1, fmt.Sprintf("\"%s\"", ps1)))
 	}
-	// TODO(perrito) go throught the environment and remove the path section
-	// that holds the current go install.
-	// Also threat default as a special cookie and make it leave no trace.
 	envVars = append(envVars, setenv(GOPATH, cfg.GoPath))
 	if len(extraBin) > 0 {
 		extraBin = append(extraBin, path)
 		path = strings.Join(extraBin, ":")
 	}
-	newPath := strings.Join([]string{filepath.Join(cfg.GoPath, "bin"),
-		// TODO(perrito) this implies heavy out of band knowledge, lets
-		// store these things somewhere instead or build a unique source
-		// of truth for paths.
-		filepath.Join(basePath,"installs", cfg.GoVersion, "go", "bin"),
-		path}, ":")
+	goInstallsPath, err := paths.XdgDataGoInstallsBinForVerson(cfg.GoVersion)
+	if err != nil {
+		return errors.Wrapf(err, "trying to determine go installs path to switch to %q", cfg.Name)
+	}
+	newPath := paths.PATHInsert(path, paths.GoPathBin(cfg.GoPath), goInstallsPath)
 	envVars = append(envVars, setenv(PATH, newPath))
 	// Default env will
 	if !isDefault {