Change the directory of the configuration files

If you install the arduino cli, the default directory
of the configuration file is the location of the executable
This is not an ideal configuration for linux or windows

With this commit the configuration file is searched in the
default configuration folder for each system

Gopkg.lock

@@ -266,6 +266,14 @@
   revision = "55d61fa8aa702f59229e6cff85793c22e580eaf5"
   version = "v1.5.1"
 
+[[projects]]
+  branch = "master"
+  digest = "1:8209ed8bf2336848aa760c11e809f93ba96fffa64d3c2948e970a362a46e534b"
+  name = "github.com/shibukawa/configdir"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e180dbdc8da04c4fa04272e875ce64949f38bd3e"
+
 [[projects]]
   digest = "1:9e9193aa51197513b3abcb108970d831fbcf40ef96aa845c4f03276e1fa316d2"
   name = "github.com/sirupsen/logrus"
@@ -441,6 +449,7 @@
     "github.com/mitchellh/go-homedir",
     "github.com/pkg/errors",
     "github.com/pmylund/sortutil",
+    "github.com/shibukawa/configdir",
     "github.com/sirupsen/logrus",
     "github.com/spf13/cobra",
     "github.com/spf13/cobra/doc",

README.md

@@ -295,7 +295,7 @@ Flags:
   -h, --help   help for core
 
 Global Flags:
-      --config-file string   The custom config file (if not specified ./.cli-config.yml will be used). (default "/home/megabug/Workspace/go/src/github.com/arduino/arduino-cli/.cli-config.yml")
+      --config-file string   The custom config file (if not specified the default one will be used). (example  "/home/megabug/.config/arduino/arduino-cli/.cli-config.yml")
       --debug                Enables debug output (super verbose, used to debug the CLI).
       --format string        The output format, can be [text|json]. (default "text")
 

commands/config/init.go

@@ -65,7 +65,14 @@ func runInitCommand(cmd *cobra.Command, args []string) {
 	if filepath == "" {
 		filepath = commands.Config.ConfigFile.String()
 	}
-	err := commands.Config.SaveToYAML(filepath)
+
+	err := os.MkdirAll(commands.Config.ConfigFile.Parent().String(), 0766)
+	if err != nil {
+		formatter.PrintError(err, "Cannot create config file.")
+		os.Exit(commands.ErrGeneric)
+	}
+
+	err = commands.Config.SaveToYAML(filepath)
 	if err != nil {
 		formatter.PrintError(err, "Cannot create config file.")
 		os.Exit(commands.ErrGeneric)

commands/root/root.go

@@ -56,7 +56,7 @@ func Init() *cobra.Command {
 	}
 	command.PersistentFlags().BoolVar(&commands.GlobalFlags.Debug, "debug", false, "Enables debug output (super verbose, used to debug the CLI).")
 	command.PersistentFlags().StringVar(&commands.GlobalFlags.Format, "format", "text", "The output format, can be [text|json].")
-	command.PersistentFlags().StringVar(&yamlConfigFile, "config-file", "", "The custom config file (if not specified ./.cli-config.yml will be used).")
+	command.PersistentFlags().StringVar(&yamlConfigFile, "config-file", "", "The custom config file (if not specified the default will be used).")
 	command.AddCommand(board.InitCommand())
 	command.AddCommand(compile.InitCommand())
 	command.AddCommand(config.InitCommand())

configs/directories.go

@@ -19,23 +19,31 @@ package configs
 
 import (
 	"fmt"
-	"os"
 	"os/user"
 	"runtime"
 
 	"github.com/arduino/go-paths-helper"
-
 	"github.com/arduino/go-win32-utils"
+	"github.com/shibukawa/configdir"
 )
 
-// getDefaultConfigFilePath returns the default path for .cli-config.yml,
-// this is the directory where the arduino-cli executable resides.
+// getDefaultConfigFilePath returns the default path for .cli-config.yml. It searches the following directories for an existing .cli-config.yml file:
+// - User level configuration folder(e.g. $HOME/.config/<vendor-name>/<application-name>/setting.json in Linux)
+// - System level configuration folder(e.g. /etc/xdg/<vendor-name>/<application-name>/setting.json in Linux)
+// If it doesn't find one, it defaults to the user level configuration folder
 func getDefaultConfigFilePath() *paths.Path {
-	executablePath, err := os.Executable()
-	if err != nil {
-		executablePath = "."
+	configDirs := configdir.New("arduino", "arduino-cli")
+
+	// Search for a suitable configuration file
+	path := configDirs.QueryFolderContainsFile(".cli-config.yml")
+	if path != nil {
+		return paths.New(path.Path, ".cli-config.yml")
 	}
-	return paths.New(executablePath).Parent().Join(".cli-config.yml")
+	// Default to the global configuration
+	locals := configDirs.QueryFolders(configdir.Global)
+	return paths.New(locals[0].Path, ".cli-config.yml")
+
+	return nil
 }
 
 func getDefaultArduinoDataDir() (*paths.Path, error) {

vendor/github.com/shibukawa/configdir/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2016 shibukawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/shibukawa/configdir/README.rst

+configdir for Golang
+=====================
+
+Multi platform library of configuration directory for Golang.
+
+This library helps to get regular directories for configuration files or cache files that matches target operationg system's convention.
+
+It assumes the following folders are standard paths of each environment:
+
+.. list-table::
+   :header-rows: 1
+
+   - * 
+     * Windows:
+     * Linux/BSDs:
+     * MacOSX:
+   - * System level configuration folder
+     * ``%PROGRAMDATA%`` (``C:\\ProgramData``)
+     * ``${XDG_CONFIG_DIRS}`` (``/etc/xdg``)
+     * ``/Library/Application Support``
+   - * User level configuration folder
+     * ``%APPDATA%`` (``C:\\Users\\<User>\\AppData\\Roaming``)
+     * ``${XDG_CONFIG_HOME}`` (``${HOME}/.config``)
+     * ``${HOME}/Library/Application Support``
+   - * User wide cache folder
+     * ``%LOCALAPPDATA%`` ``(C:\\Users\\<User>\\AppData\\Local)``
+     * ``${XDG_CACHE_HOME}`` (``${HOME}/.cache``)
+     * ``${HOME}/Library/Caches``
+
+Examples
+------------
+
+Getting Configuration
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+``configdir.ConfigDir.QueryFolderContainsFile()`` searches files in the following order:
+
+* Local path (if you add the path via LocalPath parameter)
+* User level configuration folder(e.g. ``$HOME/.config/<vendor-name>/<application-name>/setting.json`` in Linux)
+* System level configuration folder(e.g. ``/etc/xdg/<vendor-name>/<application-name>/setting.json`` in Linux)
+
+``configdir.Config`` provides some convenient methods(``ReadFile``, ``WriteFile`` and so on).
+
+.. code-block:: go
+
+   var config Config
+
+   configDirs := configdir.New("vendor-name", "application-name")
+   // optional: local path has the highest priority
+   configDirs.LocalPath, _ = filepath.Abs(".")
+   folder := configDirs.QueryFolderContainsFile("setting.json")
+   if folder != nil {
+       data, _ := folder.ReadFile("setting.json")
+       json.Unmarshal(data, &config)
+   } else {
+       config = DefaultConfig
+   }
+
+Write Configuration
+~~~~~~~~~~~~~~~~~~~~~~
+
+When storing configuration, get configuration folder by using ``configdir.ConfigDir.QueryFolders()`` method.
+
+.. code-block:: go
+
+   configDirs := configdir.New("vendor-name", "application-name")
+
+   var config Config
+   data, _ := json.Marshal(&config)
+
+   // Stores to local folder
+   folders := configDirs.QueryFolders(configdir.Local)
+   folders[0].WriteFile("setting.json", data)
+
+   // Stores to user folder
+   folders = configDirs.QueryFolders(configdir.Global)
+   folders[0].WriteFile("setting.json", data)
+
+   // Stores to system folder
+   folders = configDirs.QueryFolders(configdir.System)
+   folders[0].WriteFile("setting.json", data)
+
+Getting Cache Folder
+~~~~~~~~~~~~~~~~~~~~~~
+
+It is similar to the above example, but returns cache folder.
+
+.. code-block:: go
+
+   configDirs := configdir.New("vendor-name", "application-name")
+   cache := configDirs.QueryCacheFolder()
+
+   resp, err := http.Get("http://examples.com/sdk.zip")
+   if err != nil {
+       log.Fatal(err)
+   }
+   defer resp.Body.Close()
+   body, err := ioutil.ReadAll(resp.Body)
+
+   cache.WriteFile("sdk.zip", body)
+
+Document
+------------
+
+https://godoc.org/github.com/shibukawa/configdir
+
+License
+------------
+
+MIT
+

vendor/github.com/shibukawa/configdir/config.go

+// configdir provides access to configuration folder in each platforms.
+//
+// System wide configuration folders:
+//
+//   - Windows: %PROGRAMDATA% (C:\ProgramData)
+//   - Linux/BSDs: ${XDG_CONFIG_DIRS} (/etc/xdg)
+//   - MacOSX: "/Library/Application Support"
+//
+// User wide configuration folders:
+//
+//   - Windows: %APPDATA% (C:\Users\<User>\AppData\Roaming)
+//   - Linux/BSDs: ${XDG_CONFIG_HOME} (${HOME}/.config)
+//   - MacOSX: "${HOME}/Library/Application Support"
+//
+// User wide cache folders:
+//
+//   - Windows: %LOCALAPPDATA% (C:\Users\<User>\AppData\Local)
+//   - Linux/BSDs: ${XDG_CACHE_HOME} (${HOME}/.cache)
+//   - MacOSX: "${HOME}/Library/Caches"
+//
+// configdir returns paths inside the above folders.
+
+package configdir
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+)
+
+type ConfigType int
+
+const (
+	System ConfigType = iota
+	Global
+	All
+	Existing
+	Local
+	Cache
+)
+
+// Config represents each folder
+type Config struct {
+	Path string
+	Type ConfigType
+}
+
+func (c Config) Open(fileName string) (*os.File, error) {
+	return os.Open(filepath.Join(c.Path, fileName))
+}
+
+func (c Config) Create(fileName string) (*os.File, error) {
+	err := c.CreateParentDir(fileName)
+	if err != nil {
+		return nil, err
+	}
+	return os.Create(filepath.Join(c.Path, fileName))
+}
+
+func (c Config) ReadFile(fileName string) ([]byte, error) {
+	return ioutil.ReadFile(filepath.Join(c.Path, fileName))
+}
+
+// CreateParentDir creates the parent directory of fileName inside c. fileName
+// is a relative path inside c, containing zero or more path separators.
+func (c Config) CreateParentDir(fileName string) error {
+	return os.MkdirAll(filepath.Dir(filepath.Join(c.Path, fileName)), 0755)
+}
+
+func (c Config) WriteFile(fileName string, data []byte) error {
+	err := c.CreateParentDir(fileName)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(filepath.Join(c.Path, fileName), data, 0644)
+}
+
+func (c Config) MkdirAll() error {
+	return os.MkdirAll(c.Path, 0755)
+}
+
+func (c Config) Exists(fileName string) bool {
+	_, err := os.Stat(filepath.Join(c.Path, fileName))
+	return !os.IsNotExist(err)
+}
+
+// ConfigDir keeps setting for querying folders.
+type ConfigDir struct {
+	VendorName      string
+	ApplicationName string
+	LocalPath       string
+}
+
+func New(vendorName, applicationName string) ConfigDir {
+	return ConfigDir{
+		VendorName:      vendorName,
+		ApplicationName: applicationName,
+	}
+}
+
+func (c ConfigDir) joinPath(root string) string {
+	if c.VendorName != "" && hasVendorName {
+		return filepath.Join(root, c.VendorName, c.ApplicationName)
+	}
+	return filepath.Join(root, c.ApplicationName)
+}
+
+func (c ConfigDir) QueryFolders(configType ConfigType) []*Config {
+	if configType == Cache {
+		return []*Config{c.QueryCacheFolder()}
+	}
+	var result []*Config
+	if c.LocalPath != "" && configType != System && configType != Global {
+		result = append(result, &Config{
+			Path: c.LocalPath,
+			Type: Local,
+		})
+	}
+	if configType != System && configType != Local {
+		result = append(result, &Config{
+			Path: c.joinPath(globalSettingFolder),
+			Type: Global,
+		})
+	}
+	if configType != Global && configType != Local {
+		for _, root := range systemSettingFolders {
+			result = append(result, &Config{
+				Path: c.joinPath(root),
+				Type: System,
+			})
+		}
+	}
+	if configType != Existing {
+		return result
+	}
+	var existing []*Config
+	for _, entry := range result {
+		if _, err := os.Stat(entry.Path); !os.IsNotExist(err) {
+			existing = append(existing, entry)
+		}
+	}
+	return existing
+}
+
+func (c ConfigDir) QueryFolderContainsFile(fileName string) *Config {
+	configs := c.QueryFolders(Existing)
+	for _, config := range configs {
+		if _, err := os.Stat(filepath.Join(config.Path, fileName)); !os.IsNotExist(err) {
+			return config
+		}
+	}
+	return nil
+}
+
+func (c ConfigDir) QueryCacheFolder() *Config {
+	return &Config{
+		Path: c.joinPath(cacheFolder),
+		Type: Cache,
+	}
+}

vendor/github.com/shibukawa/configdir/config_darwin.go

+package configdir
+
+import "os"
+
+var hasVendorName = true
+var systemSettingFolders = []string{"/Library/Application Support"}
+var globalSettingFolder = os.Getenv("HOME") + "/Library/Application Support"
+var cacheFolder = os.Getenv("HOME") + "/Library/Caches"

vendor/github.com/shibukawa/configdir/config_windows.go

+package configdir
+
+import "os"
+
+var hasVendorName = true
+var systemSettingFolders = []string{os.Getenv("PROGRAMDATA")}
+var globalSettingFolder = os.Getenv("APPDATA")
+var cacheFolder = os.Getenv("LOCALAPPDATA")

vendor/github.com/shibukawa/configdir/config_xdg.go

+// +build !windows,!darwin
+
+package configdir
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+var hasVendorName = true
+var systemSettingFolders []string
+var globalSettingFolder string
+var cacheFolder string
+
+func init() {
+	if os.Getenv("XDG_CONFIG_HOME") != "" {
+		globalSettingFolder = os.Getenv("XDG_CONFIG_HOME")
+	} else {
+		globalSettingFolder = filepath.Join(os.Getenv("HOME"), ".config")
+	}
+	if os.Getenv("XDG_CONFIG_DIRS") != "" {
+		systemSettingFolders = strings.Split(os.Getenv("XDG_CONFIG_DIRS"), ":")
+	} else {
+		systemSettingFolders = []string{"/etc/xdg"}
+	}
+	if os.Getenv("XDG_CACHE_HOME") != "" {
+		cacheFolder = os.Getenv("XDG_CACHE_HOME")
+	} else {
+		cacheFolder = filepath.Join(os.Getenv("HOME"), ".cache")
+	}
+}