Handle extensions as a bundle

Author: remear

.gitignore

@@ -18,3 +18,4 @@
 main
 
 bedrock-cli_*_*
+build

cmd/bundle_install.go

@@ -1,12 +1,14 @@
 package cmd
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/bedrock-env/bedrock-cli/extensions"
+	"github.com/bedrock-env/bedrock-cli/helpers"
 	"github.com/spf13/cobra"
 	"io/ioutil"
+	"os"
 	"path/filepath"
-	"strings"
 )
 
 var OverwriteFiles bool
@@ -16,31 +18,85 @@ var installCmd = &cobra.Command{
 	Short: "Install the Bedrock extension bundle",
 	Long: "Install the Bedrock extensions listed in the bundle file",
 	Run: func(cmd *cobra.Command, args []string) {
-		bundle := LoadBundle()
+		BundleInstall()
+	},
+}
+
+func BundleInstall() {
+	RemoveOldBundle()
+	EnsureBundleDir()
+
+	desiredBundle := LoadBundle()
+
+	var bundle []extensions.Extension
+
+	for _, e := range desiredBundle {
+		result := e.Install(extensions.InstallOptions{OverwriteFiles: OverwriteFiles, BedrockDir: helpers.BedrockDir })
 
-		for _, e := range bundle {
-			e.Install(extensions.InstallOptions{OverwriteFiles: OverwriteFiles, BedrockDir: BedrockDir })
+		if result {
+			bundle = append(bundle, e)
 		}
-	},
+	}
+
+	var bundleData string
+	for _, e := range bundle {
+		bundleData = fmt.Sprintf("%s%s\n", bundleData, e.BasePath)
+	}
+
+	ioutil.WriteFile(filepath.Join(helpers.BedrockDir, "bundle", "load"), []byte(bundleData), 0744)
 }
 
 func LoadBundle() []extensions.Extension {
-	b, err := ioutil.ReadFile(filepath.Join(BedrockDir, "bundle"))
+	data, err := ioutil.ReadFile(filepath.Join(helpers.BedrockDir, "bundle.json"))
 	if err != nil {
 		fmt.Println(err)
+		os.Exit(1)
 	}
 
-	bundleList := strings.Split(strings.TrimSpace(string(b)), "\n")
-	var bundle []extensions.Extension
+	var bundleConfig []map[string]string
+	json.Unmarshal([]byte(data), &bundleConfig)
 
-	for _, e := range bundleList {
-		extension := extensions.Extension{ Name: e }.Load(packageManager)
+	fmt.Println(bundleConfig)
+	var bundle []extensions.Extension
+	for _, element := range bundleConfig {
+		fmt.Println(element)
+		extension := extensions.Extension{
+			Name: element["name"],
+			Branch: element["branch"],
+			Git: element["git"],
+			Tag: element["tag"],
+			Ref: element["ref"],
+			Path: element["path"],
+		}.Load(packageManager, extensions.InstallOptions{BedrockDir: helpers.BedrockDir })
 		bundle = append(bundle, extension)
 	}
 
+	fmt.Println(bundle)
 	return bundle
 }
 
+func RemoveOldBundle() {
+	bundlePath := filepath.Join(helpers.BedrockDir, "bundle")
+
+	if !helpers.Exists(bundlePath) {
+		return
+	}
+
+	err := os.RemoveAll(bundlePath)
+	if err != nil {
+		fmt.Println("Unable to remove old bundle at", bundlePath)
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+func EnsureBundleDir() {
+	bundlePath := filepath.Join(helpers.BedrockDir, "bundle")
+
+	if !helpers.Exists(bundlePath) {
+		_ = os.Mkdir(bundlePath, 0744)
+	}
+}
+
 func init() {
 	bundleCmd.AddCommand(installCmd)
 	installCmd.PersistentFlags().BoolVar(&OverwriteFiles, "overwrite",

cmd/root.go

@@ -14,7 +14,6 @@ const configFileName string = ".bedrock.json"
 const minZSHVersion = "5.0"
 
 var packageManager string
-var BedrockDir string
 
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
@@ -26,23 +25,23 @@ examples and usage of using your application. For example:
 Cobra is a CLI library for Go that empowers applications.
 This application is a tool to generate the needed files
 to quickly create a Cobra application.`,
-	// Uncomment the following line if your bare application
-	// has an action associated with it:
-	//Run: func(cmd *cobra.Command, args []string) {
-	//	// viper.Set("param1", "value1")
-	//	fmt.Println("Pkg Manager:", packageManager)
-	//	fmt.Println("author:", author)
-	//	//package_managers.InstallPackage("foo")
-	//	// package_manager_provider.InstallPackages("foo")
-	//},
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
 // This is called by main.main(). It only needs to happen once to the rootCmd.
 func Execute() {
 	var configPath = filepath.Join(helpers.Home, configFileName)
 
-	if firstRun(configPath) {
+	checkFirstRun(configPath)
+
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func checkFirstRun(configPath string) {
+	if !helpers.Exists(configPath) {
 		fmt.Println("It looks like this might be the first time Bedrock has been run.")
 		fmt.Print("Checking Bedrock requirements...\n\n")
 		if !meetRequirements() {
@@ -52,11 +51,6 @@ func Execute() {
 	}
 
 	viper.WriteConfigAs(configPath)
-
-	if err := rootCmd.Execute(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
 }
 
 func init() {
@@ -65,7 +59,8 @@ func init() {
 	rootCmd.PersistentFlags().StringVar(&packageManager, "package-manager", helpers.DefaultPkgManager(), "Desired package manager")
 	viper.BindPFlag("package-manager", rootCmd.PersistentFlags().Lookup("package-manager"))
 
-	rootCmd.PersistentFlags().StringVar(&BedrockDir, "bedrockdir", filepath.Join(helpers.Home, ".bedrock"), "The Bedrock base directory")
+	// NOTE: Not everything reads from this yet
+	rootCmd.PersistentFlags().StringVar(&helpers.BedrockDir, "bedrockdir", filepath.Join(helpers.Home, ".bedrock"), "The Bedrock base directory")
 	viper.BindPFlag("bedrockdir", rootCmd.PersistentFlags().Lookup("bedrockdir"))
 }
 
@@ -84,7 +79,7 @@ func meetRequirements() bool {
 
 func zshDetected() bool {
 	detected := false
-	result, err := helpers.ExecuteInShell("zsh", "echo $ZSH_VERSION")
+	result, err := helpers.ExecuteCommandInShell("zsh", "echo $ZSH_VERSION")
 
 	if err == nil {
 		zshVersion, _ := version.NewVersion(result)
@@ -99,12 +94,4 @@ func zshDetected() bool {
 	fmt.Printf("%s\u0078%s ZSH %s was not detected\n", helpers.ColorRed, helpers.ColorReset, minZSHVersion)
 
 	return detected
-}
-
-//func checkPackageManager() {
-//
-//}
-
-func firstRun(configPath string) bool {
-	return !helpers.Exists(configPath)
 }

cmd/version.go

@@ -17,13 +17,11 @@ package cmd
 
 import (
 	"fmt"
-
 	"github.com/spf13/cobra"
 )
 
 const VERSION = "0.0.1"
 
-// versionCmd represents the version command
 var versionCmd = &cobra.Command{
 	Use:   "version",
 	Short: "A brief description of your command",
@@ -34,7 +32,7 @@ Cobra is a CLI library for Go that empowers applications.
 This application is a tool to generate the needed files
 to quickly create a Cobra application.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("Bedrock", VERSION)
+		fmt.Fprintln(cmd.OutOrStdout(), "Bedrock", VERSION)
 	},
 }
 

cmd/version_test.go

@@ -0,0 +1,43 @@
+package cmd
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+var out io.Writer = os.Stdout
+
+func TestVersion(t *testing.T) {
+	out, err := executeCommand(rootCmd, "version")
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	result := strings.TrimSpace(string(out))
+	expected := "Bedrock " + VERSION
+	if result != expected {
+		t.Fatalf("expected \"%s\" got \"%s\"", expected, result)
+	}
+}
+
+func executeCommand(root *cobra.Command, args ...string) (output string, err error) {
+	_, output, err = executeCommandC(root, args...)
+	return output, err
+}
+
+func executeCommandC(root *cobra.Command, args ...string) (c *cobra.Command, output string, err error) {
+	buf := new(bytes.Buffer)
+	root.SetOut(buf)
+	root.SetErr(buf)
+	root.SetArgs(args)
+
+	c, err = root.ExecuteC()
+
+	return c, buf.String(), err
+}

extensions/extension_manager.go

@@ -14,6 +14,11 @@ import (
 
 type Extension struct {
 	Name string
+	Git string
+	Branch string
+	Ref string
+	Tag string
+	Path string
 	InstallSteps []InstallStep
 	Files []File
 	PostInstallMessages []string
@@ -70,9 +75,18 @@ type InstallOptions struct {
 	BedrockDir string
 }
 
-func (e Extension) Load(pkgm string) Extension {
-	e.BasePath = filepath.Join(helpers.Home, ".bedrock", "extensions", e.Name)
+func (e Extension) Load(pkgm string, options InstallOptions) Extension {
+	_ = e.GetSource(options)
+	bundlePath := filepath.Join(helpers.Home, ".bedrock", "bundle")
+
+	if len(e.Path) > 0 {
+		e.BasePath = helpers.ExpandPath(e.Path)
+	} else {
+		e.BasePath = filepath.Join(bundlePath, e.Name)
+	}
+
 	extension := LoadManifest(e, pkgm)
+	fmt.Print(extension)
 
 	return extension
 }
@@ -101,7 +115,7 @@ func LoadManifest(e Extension, pkgm string) Extension {
 	return e
 }
 
-func (e Extension) Install(options InstallOptions) {
+func (e Extension) Install(options InstallOptions) bool {
 	installResult := e.RunInstallSteps(options)
 	syncResult := e.SyncFiles(options)
 
@@ -118,12 +132,51 @@ func (e Extension) Install(options InstallOptions) {
 			}
 		}
 		fmt.Println(e.Name, "-", helpers.ColorGreen + "succeeded" + helpers.ColorReset)
+
+		return true
 	} else {
 		fmt.Println(e.Name, "-", helpers.ColorRed + "failed" + helpers.ColorReset)
 	}
+
+	return false
+}
+
+func (e Extension) GetSource(options InstallOptions) bool {
+	if len(e.Path) > 0 {
+		return true
+	}
+
+	if e.Git == "" {
+		e.Git = fmt.Sprintf("https://github.com/bedrock-env/%s.git", e.Name)
+	}
+
+	fmt.Println("Branch", e.Branch)
+	fmt.Println("Ref", e.Ref == "")
+	fmt.Println("Tag", e.Tag)
+	command := fmt.Sprintf("git -C %s clone %s %s", filepath.Join(options.BedrockDir, "bundle"), e.Git, e.Name)
+	var checkoutTarget string
+
+	switch {
+	case e.Branch != "":
+		checkoutTarget = e.Branch
+	case e.Ref != "":
+		checkoutTarget = e.Ref
+	case e.Tag != "":
+		checkoutTarget = e.Tag
+	}
+	if len(checkoutTarget) > 0  {
+		command = fmt.Sprintf("%s && git -C %s checkout %s",
+			command,filepath.Join(options.BedrockDir, "bundle", e.Name), checkoutTarget)
+	}
+
+	fmt.Println("command", command)
+	helpers.ExecuteCommandInShell("zsh", command)
+
+	return false
 }
 
 func (e Extension) RunInstallSteps(options InstallOptions) bool {
+	fmt.Println("Install steps:", e.InstallSteps)
 	if len(e.InstallSteps) == 0 {
 		return true
 	}

helpers/command.go

@@ -6,14 +6,17 @@ import (
 )
 
 func ExecuteCommand(binary string, command string) (string, error) {
-	args := strings.Split(command, " ")
-	out, err := exec.Command(binary, args...).CombinedOutput()
+	return ExecuteCommandWithArgs(binary, strings.Split(command, " "))
+}
+
+func ExecuteCommandWithArgs(binary string, command []string) (string, error) {
+	out, err := exec.Command(binary, command...).CombinedOutput()
 
 	return string(out), err
 }
 
-func ExecuteInShell(shell string, command string) (string, error) {
+func ExecuteCommandInShell(shell string, command string) (string, error) {
 	out, err := exec.Command(shell, "-c", command).CombinedOutput()
 
 	return strings.TrimSpace(string(out)), err
-}
+}