[WIP] Here's the new PackageManager

Author: lorenzo-biava

commands/board/attach.go

@@ -84,6 +84,7 @@ func runAttachCommand(cmd *cobra.Command, args []string) {
 
 	time.Sleep(duration)
 
+	// FIXME: Replace with the PackageManager
 	homeFolder, err := configs.ArduinoHomeFolder.Get()
 	if err != nil {
 		formatter.PrintError(err, "Cannot Parse Board Index file.")
@@ -145,6 +146,7 @@ func runAttachCommand(cmd *cobra.Command, args []string) {
 	formatter.PrintResult("BOARD ATTACHED.")
 }
 
+// FIXME: Those should probably go in a "BoardManager" pkg or something
 // findSerialConnectedBoard find the board which is connected to the specified URI via serial port, using a monitor and a set of Boards
 // for the matching.
 func findSerialConnectedBoard(bs boards.Boards, monitor *discovery.Monitor, deviceURI *url.URL) *boards.Board {

commands/board/list.go

@@ -39,6 +39,7 @@ var listCommand = &cobra.Command{
 // runListCommand detects and lists the connected arduino boards
 // (either via serial or network ports).
 func runListCommand(cmd *cobra.Command, args []string) {
+	// FIXME: Replace with the PackageManager
 	packageFolder, err := configs.PackagesFolder.Get()
 	if err != nil {
 		formatter.PrintError(err, "Cannot Parse Board Index file.")

commands/compile/compile.go

@@ -117,6 +117,7 @@ func run(cmd *cobra.Command, args []string) {
 		}
 	}
 
+	// FIXME: Replace with the PackageManager
 	isCtagsInstalled, err := cores.IsToolInstalled(packageName, "ctags")
 	if err != nil {
 		formatter.PrintError(err, "Cannot check ctags installation.")
@@ -195,6 +196,7 @@ func run(cmd *cobra.Command, args []string) {
 		formatter.PrintError(err, "Cannot get the core version.")
 		os.Exit(commands.ErrBadCall)
 	}
+	// FIXME: this is building the CommandLine to run the builder; we should move it to a "cores.compute" pkg
 	// Add dependency tools paths to build properties with versions corresponding to specific core version.
 	var packageIndex packageindex.Index
 	packageindex.LoadIndex(&packageIndex)

commands/config/init.go

@@ -85,6 +85,7 @@ func runInitCommand(cmd *cobra.Command, args []string) {
 	logrus.Info("Done")
 }
 
+// FIXME: is this any useful?
 // ConfigsFromQuestions asks some questions to the user to properly initialize configs.
 // It does not have much sense to use it in JSON formatting, though.
 func configsFromQuestions() {

commands/core/args.go

@@ -78,6 +78,7 @@ func parsePlatformReferenceArgs(args []string) []platformReference {
 	return ret
 }
 
+// FIXME: Replace move to the PackageManager
 // findItemsToDownload takes a set of platformReference and returns a set of items to download and
 // a set of outputs for non existing platforms.
 func findItemsToDownload(sc *cores.Packages, items []platformReference) ([]*cores.PlatformRelease, []*cores.ToolRelease, []output.ProcessResult) {

commands/core/core.go

@@ -55,6 +55,8 @@ var command = &cobra.Command{
 	Example: "arduino core update-index # to update the package index file.",
 }
 
+// FIXME: Move to the PackageManager
+
 // getInstalledCores gets the installed cores and puts them in the output struct.
 func getInstalledCores(packageName string, cores *[]output.InstalledStuff) {
 	getInstalledStuff(cores, configs.CoresFolder(packageName))
@@ -118,6 +120,5 @@ func getPackagesStatusContext() (*cores.Packages, error) {
 		return &status, nil
 	}
 
-	status := index.CreateStatusContext()
-	return &status, nil
+	return index.CreateStatusContext(), nil
 }

commands/core/download.go

@@ -40,6 +40,7 @@ import (
 	"github.com/bcmi-labs/arduino-cli/cores"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+	"github.com/bcmi-labs/arduino-cli/cores/packagemanager"
 )
 
 func init() {
@@ -75,6 +76,22 @@ func runDownloadCommand(cmd *cobra.Command, args []string) {
 		Tools: []output.ProcessResult{},
 	}
 
+	// FIXME: that's just a PoC; please have mercy...
+	fmt.Printf("TESTING THE FLUENT PKGMGR\n")
+
+	_, err = packagemanager.PackageManager().AddDefaultPackageIndex()
+	fmt.Printf("Loading default package index, error: %v\n", err)
+
+	tool, err := packagemanager.PackageManager().Package("not-found").Tool("avrdude").IsInstalled()
+	fmt.Printf("Tool status: %s, %v\n", tool, err)
+
+	tool, err = packagemanager.PackageManager().Package("arduino").Tool("not-found").IsInstalled()
+	fmt.Printf("Tool status: %s, %v\n", tool, err)
+
+	tool, err = packagemanager.PackageManager().Package("arduino").Tool("avrdude").IsInstalled()
+	fmt.Printf("Tool status: %s, %v\n", tool, err)
+
+
 	downloadToolsArchives(toolsToDownload, &outputResults)
 
 	downloadPlatformArchives(coresToDownload, &outputResults)
@@ -83,6 +100,9 @@ func runDownloadCommand(cmd *cobra.Command, args []string) {
 	logrus.Info("Done")
 }
 
+// FIXME: Move to the PackageManager and look for a way to uncouple of the printing logic
+// All this stuff is pkgmgr responsibility for sure
+
 func downloadToolsArchives(tools []*cores.ToolRelease, results *output.CoreProcessResults) {
 	downloads := map[string]*releases.DownloadResource{}
 	for _, tool := range tools {

commands/core/install.go

@@ -69,6 +69,7 @@ func runInstallCommand(cmd *cobra.Command, args []string) {
 
 	logrus.Info("Preparing download")
 
+	// FIXME: Isn't this the same code as in core/download.go? Should be refactored
 	coresToDownload, toolsToDownload, failOutputs := findItemsToDownload(status, parsePlatformReferenceArgs(args))
 	failOutputsCount := len(failOutputs)
 	outputResults := output.CoreProcessResults{

commands/core/list.go

@@ -75,6 +75,7 @@ func runListCommand(cmd *cobra.Command, args []string) {
 		os.Exit(commands.ErrCoreConfig)
 	}
 
+	// FIXME: Use the PackageManager instead
 	pkgs := output.InstalledPackageList{
 		InstalledPackages: make([]output.InstalledPackage, 0, 10),
 	}

common/formatter/pretty_print/pretty_print_core.go

@@ -34,11 +34,12 @@ import (
 	"github.com/bcmi-labs/arduino-cli/cores"
 	"github.com/bcmi-labs/arduino-cli/cores/packageindex"
 	"github.com/bcmi-labs/arduino-cli/task"
+	"github.com/bcmi-labs/arduino-cli/cores/packagemanager"
 )
 
 // DownloadCoreFileIndex shows info regarding the download of a missing (or corrupted) file index of core packages.
 func DownloadCoreFileIndex() task.Task {
-	return DownloadFileIndex(packageindex.DownloadPackagesFile)
+	return DownloadFileIndex(packagemanager.PackageManager().DownloadPackagesFile)
 }
 
 // CorruptedCoreIndexFix pretty prints messages regarding corrupted index fixes of cores.

cores/common.go

@@ -38,6 +38,7 @@ import (
 	"github.com/bcmi-labs/arduino-cli/configs"
 )
 
+// FIXME: Move all of these to PackageManager().Tools().isInstalled() or something like that
 // IsCoreInstalled detects if a core has been installed.
 func IsCoreInstalled(packageName string, name string) (bool, error) {
 	location, err := configs.CoresFolder(packageName).Get()

cores/packageindex/index.go

@@ -110,13 +110,12 @@ type indexHelp struct {
 }
 
 // CreateStatusContext creates a status context from index data.
-func (index Index) CreateStatusContext() cores.Packages {
-	res := cores.Packages{
-		Packages: map[string]*cores.Package{},
-	}
+func (index Index) CreateStatusContext() *cores.Packages {
+	res := cores.NewPackages()
+
 	for _, p := range index.Packages {
 		res.Packages[p.Name] = p.extractPackage()
-		res.Packages[p.Name].Packages = &res
+		res.Packages[p.Name].Packages = res
 	}
 	return res
 }

cores/packagemanager/package_manager.go

@@ -0,0 +1,144 @@
+package packagemanager
+
+import (
+	"sync"
+
+	"github.com/bcmi-labs/arduino-cli/cores/packageindex"
+	"fmt"
+	"github.com/bcmi-labs/arduino-cli/cores"
+	"github.com/bcmi-labs/arduino-cli/configs"
+	"os"
+	"path/filepath"
+	"github.com/juju/errors"
+)
+
+var packageManagerInstance *packageManager
+var once sync.Once
+
+// PackageManager defines the superior oracle which understands all about
+// Arduino Packages, how to parse them, download, and so on.
+//
+// The manager also keeps track of the status of the Packages (their Platform Releases, actually)
+// installed in the system.
+type packageManager struct {
+	/* FIXME
+
+		What's the typical flow?
+
+		You start by downloading AN PackageIndex (remember: multiple repositories are allowed??)
+	*/
+
+	packages *cores.Packages
+}
+
+// PackageManager return the instance of the PackageManager
+// yeah, that's a singleton by the way...
+func PackageManager() *packageManager {
+	once.Do(func() {
+		// TODO: why not just use the Go pkg init()?
+		packageManagerInstance = &packageManager{}
+		// TODO: perhaps directly use the loading from PackagesIndex file?
+		packageManagerInstance.packages = cores.NewPackages()
+	})
+
+	fmt.Println("==> Cool! You're using my new singleton PackageManager.")
+
+	return packageManagerInstance
+}
+
+// FIXME add an handler to be invoked on each verbose operation, in order to let commands display results through the formatter
+// as for the progress bars during download
+
+// FIXME this is currently hard-coded with the default PackageIndex and won't merge or check existing Packages!!
+func (pm *packageManager) AddDefaultPackageIndex() (*packageManager, error) {
+	var index packageindex.Index
+	err := packageindex.LoadIndex(&index)
+	if err != nil {
+		//TODO: The original version would automatically fix corrupted index?
+		/*status, err := prettyPrints.CorruptedCoreIndexFix(index)
+		if err != nil {
+			return pm, err
+		}
+		pm.packages = &status
+		return pm, nil*/
+
+		return pm, errors.Annotate(err, fmt.Sprintf("failed to load the package index, is probably corrupted" ))
+	}
+
+	// TODO: if this really is a singleton, a lock is needed :(
+	pm.packages = index.CreateStatusContext()
+	return pm, nil
+}
+
+// TODO: implement the generic version (with merge)
+/*func (pm *packageManager) AddPackageIndex() *packageManager {
+
+}*/
+
+// DownloadPackagesFile downloads the core packages index file from Arduino repository.
+func (pm *packageManager) DownloadPackagesFile() error {
+	return packageindex.DownloadPackagesFile()
+}
+
+func (pm *packageManager) Package(name string) *packageActions {
+	//TODO: perhaps these 2 structure should be merged? cores.Packages vs pkgmgr??
+	var err error
+	thePackage := pm.packages.Packages[name]
+	if thePackage == nil {
+		err = fmt.Errorf("package '%s' not found", name)
+	}
+	return &packageActions{
+		aPackage:     thePackage,
+		forwardError: err,
+	}
+}
+
+type packageActions struct {
+	aPackage     *cores.Package
+	forwardError error
+}
+
+func (pa *packageActions) Tool(name string) *toolActions {
+	var tool *cores.Tool
+	err := pa.forwardError
+	if err == nil {
+		tool = pa.aPackage.Tools[name]
+
+		if tool == nil {
+			err = fmt.Errorf("tool '%s' not found in package '%s'", name, pa.aPackage.Name)
+		}
+	}
+	return &toolActions{
+		tool:         tool,
+		forwardError: err,
+	}
+}
+
+type toolActions struct{
+	tool         *cores.Tool
+	forwardError error
+}
+
+func (ta *toolActions) Get() (*cores.Tool, error) {
+	err := ta.forwardError
+	if err == nil {
+		return ta.tool, nil
+	}
+	return nil, err
+}
+
+func (ta *toolActions) IsInstalled() (bool, error) {
+	err := ta.forwardError
+	if err == nil {
+		location, err := configs.ToolsFolder(ta.tool.Package.Name).Get()
+		if err != nil {
+			return false, err
+		}
+		_, err = os.Stat(filepath.Join(location, ta.tool.Name))
+		if !os.IsNotExist(err) {
+			return true, nil
+		}
+		return false, nil
+	}
+	return false, err
+}

cores/status.go

@@ -33,7 +33,7 @@ import (
 	"errors"
 	"fmt"
 
-	properties "github.com/arduino/go-properties-map"
+	"github.com/arduino/go-properties-map"
 	"github.com/pmylund/sortutil"
 )
 
@@ -44,6 +44,12 @@ type Packages struct {
 	Properties properties.Map `json:"-"` // TODO: used to add "ctags" properties, TO BE REMOVED
 }
 
+func NewPackages() *Packages {
+	return &Packages{
+		Packages: map[string]*Package{},
+	}
+}
+
 // Package represents a package in the system.
 type Package struct {
 	Name       string               // Name of the package.
@@ -52,7 +58,7 @@ type Package struct {
 	Email      string               // Email of maintainer.
 	Platforms  map[string]*Platform // The platforms in the system.
 	Tools      map[string]*Tool     // The tools in the system.
-	Packages   *Packages            `json:"-"`
+	Packages   *Packages `json:"-"`
 }
 
 // Names returns the array containing the name of the packages.