Renamed 'folder' to 'directory'

Fix arduino#106

Author: cmaglie

Gopkg.lock

@@ -45,14 +45,14 @@ import (
 func (pm *PackageManager) LoadHardware(config *configs.Configuration) error {
 	dirs, err := config.HardwareDirectories()
 	if err != nil {
-		return fmt.Errorf("getting hardware folder: %s", err)
+		return fmt.Errorf("getting hardware directory: %s", err)
 	}
 	if err := pm.LoadHardwareFromDirectories(dirs); err != nil {
 		return err
 	}
 	dirs, err = configs.BundleToolsDirectories()
 	if err != nil {
-		return fmt.Errorf("getting hardware folder: %s", err)
+		return fmt.Errorf("getting hardware directory: %s", err)
 	}
 	return pm.LoadToolsFromBundleDirectories(dirs)
 }
@@ -78,10 +78,10 @@ func (pm *PackageManager) LoadHardwareFromDirectory(path *paths.Path) error {
 	if isDir, err := path.IsDir(); err != nil {
 		return fmt.Errorf("reading %s stat info: %s", path, err)
 	} else if !isDir {
-		return fmt.Errorf("%s is not a folder", path)
+		return fmt.Errorf("%s is not a directory", path)
 	}
 
-	// Scan subfolders.
+	// Scan subdirs
 	files, err := path.ReadDir()
 	if err != nil {
 		return fmt.Errorf("reading %s directory: %s", path, err)
@@ -90,9 +90,9 @@ func (pm *PackageManager) LoadHardwareFromDirectory(path *paths.Path) error {
 	for _, packagerPath := range files {
 		packager := packagerPath.Base()
 
-		// First exclude all "tools" folders
+		// First exclude all "tools" directory
 		if packager == "tools" {
-			pm.Log.Infof("Excluding folder: %s", packagerPath)
+			pm.Log.Infof("Excluding directory: %s", packagerPath)
 			continue
 		}
 
@@ -102,7 +102,7 @@ func (pm *PackageManager) LoadHardwareFromDirectory(path *paths.Path) error {
 			return fmt.Errorf("following possible symlink %s: %s", path, err)
 		}
 
-		// There are two possible package folder structures:
+		// There are two possible package directory structures:
 		// - PACKAGER/ARCHITECTURE-1/boards.txt...                   (ex: arduino/avr/...)
 		//   PACKAGER/ARCHITECTURE-2/boards.txt...                   (ex: arduino/sam/...)
 		//   PACKAGER/ARCHITECTURE-3/boards.txt...                   (ex: arduino/samd/...)
@@ -111,11 +111,11 @@ func (pm *PackageManager) LoadHardwareFromDirectory(path *paths.Path) error {
 		//   PACKAGER/hardware/ARCHITECTURE-2/VERSION/boards.txt...  (ex: arduino/hardware/sam/1.6.6/...)
 		//   PACKAGER/hardware/ARCHITECTURE-3/VERSION/boards.txt...  (ex: arduino/hardware/samd/1.6.12/...)
 		//   PACKAGER/tools/...                                      (ex: arduino/tools/...)
-		// in the latter case we just move into "hardware" folder and continue
+		// in the latter case we just move into "hardware" directory and continue
 		var architectureParentPath *paths.Path
 		hardwareSubdirPath := packagerPath.Join("hardware") // ex: .arduino15/packages/arduino/hardware
 		if isDir, _ := hardwareSubdirPath.IsDir(); isDir {
-			// we found the "hardware" folder move down into that
+			// we found the "hardware" directory move down into that
 			architectureParentPath = hardwareSubdirPath // ex: .arduino15/packages/arduino/
 		} else if isDir, _ := packagerPath.IsDir(); isDir {
 			// we are already at the correct level
@@ -130,7 +130,7 @@ func (pm *PackageManager) LoadHardwareFromDirectory(path *paths.Path) error {
 			return fmt.Errorf("loading package %s: %s", packager, err)
 		}
 
-		// Check if we have tools to load, the folder structure is as follows:
+		// Check if we have tools to load, the directory structure is as follows:
 		// - PACKAGER/tools/TOOL-NAME/TOOL-VERSION/... (ex: arduino/tools/bossac/1.7.0/...)
 		toolsSubdirPath := packagerPath.Join("tools")
 		if isDir, _ := toolsSubdirPath.IsDir(); isDir {
@@ -146,18 +146,12 @@ func (pm *PackageManager) LoadHardwareFromDirectory(path *paths.Path) error {
 
 // loadPlatforms load plaftorms from the specified directory assuming that they belongs
 // to the targetPackage object passed as parameter.
-func (pm *PackageManager) loadPlatforms(targetPackage *cores.Package, packageFolder *paths.Path) error {
-	pm.Log.Infof("Loading package %s from: %s", targetPackage.Name, packageFolder)
+func (pm *PackageManager) loadPlatforms(targetPackage *cores.Package, packageDir *paths.Path) error {
+	pm.Log.Infof("Loading package %s from: %s", targetPackage.Name, packageDir)
 
-	// packagePlatformTxt, err := properties.SafeLoad(filepath.Join(folder, constants.FILE_PLATFORM_TXT))
-	// if err != nil {
-	// 	return err
-	// }
-	// targetPackage.Properties.Merge(packagePlatformTxt)
-
-	files, err := packageFolder.ReadDir()
+	files, err := packageDir.ReadDir()
 	if err != nil {
-		return fmt.Errorf("reading directory %s: %s", packageFolder, err)
+		return fmt.Errorf("reading directory %s: %s", packageDir, err)
 	}
 
 	for _, file := range files {
@@ -166,12 +160,12 @@ func (pm *PackageManager) loadPlatforms(targetPackage *cores.Package, packageFol
 			architecure == "platform.txt" { // TODO: Check if this "platform.txt" condition should be here....
 			continue
 		}
-		platformPath := packageFolder.Join(architecure)
+		platformPath := packageDir.Join(architecure)
 		if isDir, _ := platformPath.IsDir(); !isDir {
 			continue
 		}
 
-		// There are two possible platform folder structures:
+		// There are two possible platform directory structures:
 		// - ARCHITECTURE/boards.txt
 		// - ARCHITECTURE/VERSION/boards.txt
 		// We identify them by checking where is the bords.txt file
@@ -202,7 +196,7 @@ func (pm *PackageManager) loadPlatforms(targetPackage *cores.Package, packageFol
 		} else /* !exist */ {
 
 			// case: ARCHITECTURE/VERSION/boards.txt
-			// let's dive into VERSION folders
+			// let's dive into VERSION directories
 
 			platform := targetPackage.GetOrCreatePlatform(architecure)
 			versionDirs, err := platformPath.ReadDir()
@@ -332,7 +326,6 @@ func (pm *PackageManager) loadToolReleasesFromTool(tool *cores.Tool, toolPath *p
 		version := versionPath.Base()
 		if toolReleasePath, err := versionPath.Abs(); err == nil {
 			release := tool.GetOrCreateRelease(version)
-			// TODO: Make Folder a *paths.Path
 			release.InstallDir = toolReleasePath
 			pm.Log.WithField("tool", release).Infof("Loaded tool")
 		} else {
@@ -358,7 +351,7 @@ func (pm *PackageManager) LoadToolsFromBundleDirectory(toolsPath *paths.Path) er
 	// We scan toolsPath content to find a "builtin_tools_versions.txt", if such file exists
 	// then the all the tools are available in the same directory, mixed together, and their
 	// name and version are written in the "builtin_tools_versions.txt" file.
-	// If no "builtin_tools_versions.txt" is found, then the folder structure is the classic
+	// If no "builtin_tools_versions.txt" is found, then the directory structure is the classic
 	// TOOLSPATH/TOOL-NAME/TOOL-VERSION and it will be parsed as such and associated to an
 	// "unnamed" packager.
 

arduino/cores/packagemanager/loader.go

@@ -372,7 +372,7 @@ func (pm *PackageManager) FindToolsRequiredForBoard(board *cores.Board) ([]*core
 	foundTools := map[string]*cores.ToolRelease{}
 
 	// a Platform may not specify required tools (because it's a platform that comes from a
-	// sketchbook/hardware folder without a package_index.json) then add all available tools
+	// sketchbook/hardware dir without a package_index.json) then add all available tools
 	for _, targetPackage := range pm.packages.Packages {
 		for _, tool := range targetPackage.Tools {
 			rel := tool.GetLatestInstalled()

arduino/cores/packagemanager/package_manager.go

@@ -38,9 +38,9 @@ import (
 type LibraryLayout uint16
 
 const (
-	// FlatLayout is a library without a `src` folder
+	// FlatLayout is a library without a `src` directory
 	FlatLayout LibraryLayout = 1 << iota
-	// RecursiveLayout is a library with `src` folder (that allows recursive build)
+	// RecursiveLayout is a library with `src` directory (that allows recursive build)
 	RecursiveLayout
 )
 

arduino/libraries/libraries_layout.go

@@ -58,7 +58,7 @@ func (lm *LibrariesManager) Install(indexLibrary *librariesindex.Release) (*path
 
 	libsDir := lm.getSketchbookLibrariesDir()
 	if libsDir == nil {
-		return nil, fmt.Errorf("sketchbook folder not set")
+		return nil, fmt.Errorf("sketchbook directory not set")
 	}
 
 	libPath := libsDir.Join(utils.SanitizeName(indexLibrary.Library.Name))

arduino/libraries/librariesmanager/install.go

@@ -143,7 +143,7 @@ func (sc *LibrariesManager) AddLibrariesDir(path *paths.Path, location libraries
 	})
 }
 
-// AddPlatformReleaseLibrariesDir add the libraries folder in the
+// AddPlatformReleaseLibrariesDir add the libraries directory in the
 // specified PlatformRelease to the list of directories to scan when
 // searching for libraries.
 func (sc *LibrariesManager) AddPlatformReleaseLibrariesDir(plaftormRelease *cores.PlatformRelease, location libraries.LibraryLocation) {
@@ -186,20 +186,20 @@ func (sc *LibrariesManager) getSketchbookLibrariesDir() *paths.Path {
 // LoadLibrariesFromDir loads all libraries in the given directory. Returns
 // nil if the directory doesn't exists.
 func (sc *LibrariesManager) LoadLibrariesFromDir(librariesDir *LibrariesDir) error {
-	subFolders, err := librariesDir.Path.ReadDir()
+	subDirs, err := librariesDir.Path.ReadDir()
 	if os.IsNotExist(err) {
 		return nil
 	}
 	if err != nil {
 		return fmt.Errorf("reading dir %s: %s", librariesDir.Path, err)
 	}
-	subFolders.FilterDirs()
-	subFolders.FilterOutHiddenFiles()
+	subDirs.FilterDirs()
+	subDirs.FilterOutHiddenFiles()
 
-	for _, subFolder := range subFolders {
-		library, err := libraries.Load(subFolder, librariesDir.Location)
+	for _, subDir := range subDirs {
+		library, err := libraries.Load(subDir, librariesDir.Location)
 		if err != nil {
-			return fmt.Errorf("loading library from %s: %s", subFolder, err)
+			return fmt.Errorf("loading library from %s: %s", subDir, err)
 		}
 		library.ContainerPlatform = librariesDir.PlatformRelease
 		alternatives, ok := sc.Libraries[library.Name]

arduino/libraries/librariesmanager/librariesmanager.go

@@ -32,17 +32,17 @@ package libraries
 // Lint produce warnings about the formal correctness of a Library
 func (l *Library) Lint() ([]string, error) {
 
-	// TODO: check for spurious folders
-	// subFolders, err := ioutil.ReadDir(libraryFolder)
+	// TODO: check for spurious dirs
+	// subDirs, err := ioutil.ReadDir(libraryDir)
 	// if err != nil {
-	// 	return nil, fmt.Errorf("reading dir %s: %s", libraryFolder, err)
+	// 	return nil, fmt.Errorf("reading dir %s: %s", libraryDir, err)
 	// }
-	// 	for _, subFolder := range subFolders {
-	// 		if utils.IsSCCSOrHiddenFile(subFolder) {
-	// 			if !utils.IsSCCSFile(subFolder) && utils.IsHiddenFile(subFolder) {
+	// 	for _, subDir := range subDirs {
+	// 		if utils.IsSCCSOrHiddenFile(subDir) {
+	// 			if !utils.IsSCCSFile(subDir) && utils.IsHiddenFile(subDir) {
 	// 				logger.Fprintln(os.Stdout, "warn",
-	// 					"WARNING: Spurious {0} folder in '{1}' library",
-	// 					filepath.Base(subFolder.Name()), libProperties["name"])
+	// 					"WARNING: Spurious {0} directory in '{1}' library",
+	// 					filepath.Base(subDir.Name()), libProperties["name"])
 	// 			}
 	// 		}
 	// 	}

arduino/libraries/lint.go

@@ -37,23 +37,23 @@ import (
 	properties "github.com/arduino/go-properties-map"
 )
 
-// Load loads a library from the given folder
+// Load loads a library from the given LibraryLocation
 func Load(libDir *paths.Path, location LibraryLocation) (*Library, error) {
 	if exist, _ := libDir.Join("library.properties").Exist(); exist {
 		return makeNewLibrary(libDir, location)
 	}
 	return makeLegacyLibrary(libDir, location)
 }
 
-func addUtilityFolder(library *Library) {
+func addUtilityDirectory(library *Library) {
 	utilitySourcePath := library.InstallDir.Join("utility")
 	if isDir, _ := utilitySourcePath.IsDir(); isDir {
 		library.UtilityDir = utilitySourcePath
 	}
 }
 
-func makeNewLibrary(libraryFolder *paths.Path, location LibraryLocation) (*Library, error) {
-	libProperties, err := properties.Load(libraryFolder.Join("library.properties").String())
+func makeNewLibrary(libraryDir *paths.Path, location LibraryLocation) (*Library, error) {
+	libProperties, err := properties.Load(libraryDir.Join("library.properties").String())
 	if err != nil {
 		return nil, fmt.Errorf("loading library.properties: %s", err)
 	}
@@ -70,14 +70,14 @@ func makeNewLibrary(libraryFolder *paths.Path, location LibraryLocation) (*Libra
 
 	library := &Library{}
 	library.Location = location
-	library.InstallDir = libraryFolder
-	if exist, _ := libraryFolder.Join("src").Exist(); exist {
+	library.InstallDir = libraryDir
+	if exist, _ := libraryDir.Join("src").Exist(); exist {
 		library.Layout = RecursiveLayout
-		library.SourceDir = libraryFolder.Join("src")
+		library.SourceDir = libraryDir.Join("src")
 	} else {
 		library.Layout = FlatLayout
-		library.SourceDir = libraryFolder
-		addUtilityFolder(library)
+		library.SourceDir = libraryDir
+		addUtilityDirectory(library)
 	}
 
 	if libProperties["architectures"] == "" {
@@ -99,7 +99,7 @@ func makeNewLibrary(libraryFolder *paths.Path, location LibraryLocation) (*Libra
 	}
 	library.License = libProperties["license"]
 
-	library.Name = libraryFolder.Base()
+	library.Name = libraryDir.Base()
 	library.RealName = strings.TrimSpace(libProperties["name"])
 	library.Version = strings.TrimSpace(libProperties["version"])
 	library.Author = strings.TrimSpace(libProperties["author"])
@@ -126,6 +126,6 @@ func makeLegacyLibrary(path *paths.Path, location LibraryLocation) (*Library, er
 		Architectures: []string{"*"},
 		IsLegacy:      true,
 	}
-	addUtilityFolder(library)
+	addUtilityDirectory(library)
 	return library, nil
 }

arduino/libraries/loader.go

@@ -9,13 +9,13 @@ import (
 )
 
 // Install installs the resource in three steps:
-// - the archive is unpacked in a temporary subfolder of tempPath
-// - there should be only one root folder in the unpacked content
-// - the only root folder is moved/renamed to/as the destination directory
+// - the archive is unpacked in a temporary subdir of tempPath
+// - there should be only one root dir in the unpacked content
+// - the only root dir is moved/renamed to/as the destination directory
 // Note that tempPath and destDir must be on the same filesystem partition
 // otherwise the last step will fail.
 func (release *DownloadResource) Install(downloadDir, tempPath, destDir *paths.Path) error {
-	// Create a temporary folder to extract package
+	// Create a temporary dir to extract package
 	if err := tempPath.MkdirAll(); err != nil {
 		return fmt.Errorf("creating temp dir for extraction: %s", err)
 	}

arduino/resources/install.go

@@ -54,7 +54,10 @@ const (
 	ErrNoConfigFile
 	ErrBadCall
 	ErrNetwork
-	ErrCoreConfig // Represents an error in the cli core config, for example some basic files shipped with the installation are missing, or cannot create or get basic folder vital for the CLI to work.
+	// ErrCoreConfig represents an error in the cli core config, for example some basic
+	// files shipped with the installation are missing, or cannot create or get basic
+	// directories vital for the CLI to work.
+	ErrCoreConfig
 	ErrBadArgument
 
 	Version = "0.1.0-alpha.preview"

commands/commands.go

@@ -285,7 +285,7 @@ func TestCoreDownload(t *testing.T) {
 	defer makeTempDataDir(t)()
 	defer makeTempSketchbookDir(t)()
 
-	// Set staging folder to a temporary folder
+	// Set staging dir to a temporary dir
 	tmp, err := ioutil.TempDir(os.TempDir(), "test")
 	require.NoError(t, err, "making temporary staging dir")
 	defer os.RemoveAll(tmp)