Skip to content

GitLab

A
arduino-cli
Commit f9bf3a8d authored by Matteo Suppo's avatar Matteo Suppo
Browse files
Options

Remove configdir

parent 8659dd26
Hide whitespace changes
Inline Side-by-side
Showing with 20 additions and 365 deletions
Gopkg.lock
View file @ f9bf3a8d
......@@ -274,14 +274,6 @@
revision = "1744e2970ca51c86172c8190fadad617561ed6e7"
version = "v1.0.0"
[[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"
......@@ -458,7 +450,6 @@
"github.com/pkg/errors",
"github.com/pmylund/sortutil",
"github.com/sergi/go-diff/diffmatchpatch",
"github.com/shibukawa/configdir",
"github.com/sirupsen/logrus",
"github.com/spf13/cobra",
"github.com/spf13/cobra/doc",
......
configs/directories.go
View file @ f9bf3a8d
......@@ -24,26 +24,32 @@ import (
"github.com/arduino/go-paths-helper"
"github.com/arduino/go-win32-utils"
"github.com/shibukawa/configdir"
)
// getDefaultConfigFilePath returns the default path for arduino-cli.yaml. It searches the following directories for an existing arduino-cli.yaml 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
// getDefaultConfigFilePath returns the default path for arduino-cli.yaml
func getDefaultConfigFilePath() *paths.Path {
configDirs := configdir.New("arduino", "arduino-cli")
usr, err := user.Current()
if err != nil {
panic(fmt.Errorf("retrieving user home dir: %s", err))
}
arduinoDataDir := paths.New(usr.HomeDir)
// Search for a suitable configuration file
path := configDirs.QueryFolderContainsFile("arduino-cli.yaml")
if path != nil {
return paths.New(path.Path, "arduino-cli.yaml")
switch runtime.GOOS {
case "linux":
arduinoDataDir = arduinoDataDir.Join(".arduino15")
case "darwin":
arduinoDataDir = arduinoDataDir.Join("Library", "arduino15")
case "windows":
localAppDataPath, err := win32.GetLocalAppDataFolder()
if err != nil {
panic(err)
}
arduinoDataDir = paths.New(localAppDataPath).Join("Arduino15")
default:
panic(fmt.Errorf("unsupported OS: %s", runtime.GOOS))
}
// Default to the global configuration
locals := configDirs.QueryFolders(configdir.Global)
return paths.New(locals[0].Path, "arduino-cli.yaml")
return nil
return arduinoDataDir
}
func getDefaultArduinoDataDir() (*paths.Path, error) {
......
vendor/github.com/shibukawa/configdir/LICENSE deleted 100644 → 0
View file @ 8659dd26
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 deleted 100644 → 0
View file @ 8659dd26
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 deleted 100644 → 0
View file @ 8659dd26
// 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 deleted 100644 → 0
View file @ 8659dd26
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 deleted 100644 → 0
View file @ 8659dd26
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 deleted 100644 → 0
View file @ 8659dd26
// +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")
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment