// install the given version into the environment creating a Symlink to it
func (e *Environment) Install(ver string) error {
if !cache.AlreadyCompiled(ver) {
if err := cache.Compile(ver, false, false); err != nil {
fmt.Println("while installing:", err)
return err
}
}
path := filepath.Join(cache.CacheDirectory(), ver)
if _, err := os.Stat(path); err != nil {
path = filepath.Join(cache.CacheDirectory(), fmt.Sprintf("go%s", ver))
}
link := func() error {
return os.Symlink(path, filepath.Join(e.VenGO_PATH, "lib"))
}
if err := link(); err != nil {
if os.IsExist(err) {
os.Remove(filepath.Join(e.VenGO_PATH, "lib"))
if err := link(); err != nil {
fmt.Println("while creating symlink:", err)
return err
}
} else {
fmt.Println("while creating symlink:", err)
return err
}
}
return nil
}
// run the uninstall command
func runUninstall(cmd *Command, args ...string) {
if len(args) == 0 {
cmd.DisplayUsageAndExit()
}
version := args[0]
activeEnv := os.Getenv("VENGO_ENV")
if activeEnv != "" {
if err := checkEnvironment(version, activeEnv); err != nil {
fmt.Println("error:", err)
fmt.Printf("%s: execute 'deactivate' before call this command\n", suggest)
os.Exit(2)
}
}
versionPath := filepath.Join(cache.CacheDirectory(), version)
if _, err := os.Stat(versionPath); err != nil {
log.Println(err)
if os.IsNotExist(err) {
fmt.Printf("%s is not a Go installed version...\n", version)
fmt.Printf("%s: try with 'vengo list'\n", suggest)
os.Exit(2)
}
log.Fatal(err)
}
err := os.RemoveAll(versionPath)
if err == nil {
fmt.Printf("%s has been uninstalled\n", utils.Ok(version))
}
log.Fatal(err)
}
// run the migrate command
func runMigrate(cmd *Command, args ...string) {
if len(args) < 2 {
cmd.DisplayUsageAndExit()
}
environName := args[0]
goVersion := args[1]
if os.Getenv("VENGO_ENV") == environName {
fmt.Println(
"error:", fmt.Sprintf("%s is currently in use as the active environment"))
fmt.Printf("%s: execute 'deactivate' before call this command\n", suggest)
os.Exit(2)
}
envPath := filepath.Join(os.Getenv("VENGO_HOME"), environName)
if _, err := os.Stat(envPath); err != nil {
fmt.Printf("%s is no a VenGO environment...\n", environName)
fmt.Println(err)
os.Exit(2)
}
fmt.Print("Checking installed Go versions...")
if !env.LookupInstalledVersion(goVersion) {
fmt.Println(utils.Fail("✖"))
fmt.Println(fmt.Sprintf(
"sorry vengo can't perform the operation because %s is %s",
goVersion, utils.Fail("not installed")))
fmt.Printf("%s: run 'vengo install %s'\n", suggest, goVersion)
os.Exit(2)
}
fmt.Println(utils.Ok("✔"))
library := filepath.Join(envPath, "lib")
installed, _ := os.Readlink(library)
if installed == goVersion {
fmt.Printf("%s in use Go version is already %s, skipping...", environName, installed)
os.Exit(0)
}
fmt.Printf("unlinking previous %s Go version from %s...", installed, environName)
if err := os.Remove(library); err != nil {
fmt.Println(utils.Fail("✖"))
fmt.Println(err)
os.Exit(2)
}
fmt.Println(utils.Ok("✔"))
fmt.Printf("Linking Go version %s...", goVersion)
path := filepath.Join(cache.CacheDirectory(), goVersion)
err := os.Symlink(path, filepath.Join(envPath, "lib"))
if err != nil {
fmt.Println(utils.Fail("✖"))
fmt.Println(err)
os.Exit(2)
}
fmt.Println(utils.Ok("✔"))
fmt.Println("Done. You may want to run 'go build -a ./... in $GOPATH")
os.Exit(0)
}
// generates the output for the list command
func (l *List) display(versions map[string][]string) (string, error) {
output := []string{}
if l.DisplayAs == Text {
if l.ShowBoth || l.ShowInstalled {
output = append(output, utils.Ok("Installed"))
for _, v := range versions["installed"] {
_, err := os.Stat(
filepath.Join(cache.CacheDirectory(), v, ".vengo-manifest"))
check := utils.Ok("✔")
if err != nil {
check = utils.Fail("✖")
}
output = append(output, fmt.Sprintf(" %s %s", v, check))
}
}
if l.ShowBoth || l.ShowNotInstalled {
output = append(output, utils.Ok("Available for Installation"))
output = append(output, versions["available"]...)
}
return strings.Join(output, "\n"), nil
}
if l.DisplayAs == Json {
jsonData := &BriefJSON{[]string{}, []string{}}
if l.ShowBoth || l.ShowInstalled {
for _, v := range versions["installed"] {
v := strings.TrimLeft(v, " ")
jsonData.Installed = append(jsonData.Installed, v)
}
}
if l.ShowBoth || l.ShowNotInstalled {
for _, v := range versions["available"] {
v := strings.TrimLeft(v, " ")
jsonData.Available = append(jsonData.Available, v)
}
}
data, err := json.Marshal(jsonData)
return string(data), err
}
return "", fmt.Errorf("List.DisplayAs is not set to a valid value!")
}
os.RemoveAll(e.VenGO_PATH)
})
})
Describe("Install", func() {
It("Will create a symboolic link into VenGO_PATH", func() {
Expect(cache.CacheDownloadGit("1.3.2")).To(Succeed())
name := "goTest"
prompt := "(gotest)"
e := env.NewEnvironment(name, prompt)
err := e.Generate()
Expect(err).ToNot(HaveOccurred())
Expect(e.Install("1.3.2")).To(Succeed())
os.RemoveAll(filepath.Join(cache.CacheDirectory(), "go1.3.2"))
})
})
}
Describe("NewPackage", func() {
It("Will return a configured package", func() {
options := func(p *env.Package) {
p.Name = "Test"
p.Url = "github.com/VenGO/test"
p.Installed = true
p.Vcs = "git"
}
pkg := env.NewPackage(options)
Expect(pkg).ToNot(BeNil())
// check if we are running on travis
// NOTE: this will return false positives in the home directory of anyone
// that is called travis and his home is "travis" or contains "travis", sorry
func runningOnTravis() bool {
c := cache.CacheDirectory()
return strings.Contains(c, "travis")
}
re = regexp.MustCompile("/home/([a-z0-9]+)/.cache/VenGO")
}
if runtime.GOOS == "darwin" {
re = regexp.MustCompile(
"/Users/([a-zA-Z0-9]+)/Library/Caches/VenGO")
}
if runtime.GOOS == "windows" {
re = regexp.MustCompile(
"\\Users\\([a-zA-Z0-9]+)\\AppData\\VenGO")
}
})
It("Should Match", func() {
Expect(re.MatchString(cache.CacheDirectory())).To(BeTrue())
})
})
Describe("Checksum return an error if version is not supported", func() {
It("Should be empty string and formatted error", func() {
sha1, err := cache.Checksum("1.0")
Expect(sha1).To(BeEmpty())
Expect(err).ToNot(BeNil())
})
})
Describe("Checksum returns the right sha1 string", func() {
Context("With version 1.2.2", func() {
It("Should return 3ce0ac4db434fc1546fec074841ff40dc48c1167", func() {
It("Create and return a configured list", func() {
showBoth := func(l *commands.List) {
l.ShowBoth = true
}
l := commands.NewList(showBoth)
Expect(l).ToNot(BeNil())
Expect(l.ShowBoth).To(BeTrue())
})
})
Describe("List", func() {
Describe("Run", func() {
var renamed bool = false
BeforeEach(func() {
if _, err := os.Stat(filepath.Join(cache.CacheDirectory())); err == nil {
rename := filepath.Join(cache.CacheDirectory(), "..", "Real-VenGO")
Expect(os.Rename(cache.CacheDirectory(), rename)).To(Succeed())
Expect(os.MkdirAll(cache.CacheDirectory(), 0755)).To(Succeed())
renamed = true
}
})
AfterEach(func() {
if renamed {
rename := filepath.Join(cache.CacheDirectory(), "..", "Real-VenGO")
Expect(os.RemoveAll(cache.CacheDirectory())).To(Succeed())
Expect(os.Rename(rename, cache.CacheDirectory())).To(Succeed())
}
})