Using paths.* methods and structure (almost) everywhere

There are still some helper function to remove from utils packages,
but the increase in readability is already impressive.

There are some minor tweaks and small refactors here and there, but
no substantial changes the code should perform exactly as before.

Author: cmaglie

add_additional_entries_to_context.go

@@ -30,8 +30,6 @@
 package builder
 
 import (
-	"path/filepath"
-
 	"github.com/arduino/arduino-builder/constants"
 	"github.com/arduino/arduino-builder/i18n"
 	"github.com/arduino/arduino-builder/types"
@@ -41,21 +39,21 @@ import (
 type AddAdditionalEntriesToContext struct{}
 
 func (*AddAdditionalEntriesToContext) Run(ctx *types.Context) error {
-	if ctx.BuildPath != "" {
+	if ctx.BuildPath != nil {
 		buildPath := ctx.BuildPath
-		preprocPath, err := filepath.Abs(filepath.Join(buildPath, constants.FOLDER_PREPROC))
+		preprocPath, err := buildPath.Join(constants.FOLDER_PREPROC).Abs()
 		if err != nil {
 			return i18n.WrapError(err)
 		}
-		sketchBuildPath, err := filepath.Abs(filepath.Join(buildPath, constants.FOLDER_SKETCH))
+		sketchBuildPath, err := buildPath.Join(constants.FOLDER_SKETCH).Abs()
 		if err != nil {
 			return i18n.WrapError(err)
 		}
-		librariesBuildPath, err := filepath.Abs(filepath.Join(buildPath, "libraries"))
+		librariesBuildPath, err := buildPath.Join("libraries").Abs()
 		if err != nil {
 			return i18n.WrapError(err)
 		}
-		coreBuildPath, err := filepath.Abs(filepath.Join(buildPath, constants.FOLDER_CORE))
+		coreBuildPath, err := buildPath.Join(constants.FOLDER_CORE).Abs()
 		if err != nil {
 			return i18n.WrapError(err)
 		}
@@ -66,8 +64,8 @@ func (*AddAdditionalEntriesToContext) Run(ctx *types.Context) error {
 		ctx.CoreBuildPath = coreBuildPath
 	}
 
-	if ctx.BuildCachePath != "" {
-		coreBuildCachePath, err := filepath.Abs(filepath.Join(ctx.BuildCachePath, constants.FOLDER_CORE))
+	if ctx.BuildCachePath != nil {
+		coreBuildCachePath, err := ctx.BuildCachePath.Join(constants.FOLDER_CORE).Abs()
 		if err != nil {
 			return i18n.WrapError(err)
 		}

additional_sketch_files_copier.go

@@ -30,12 +30,11 @@
 package builder
 
 import (
+	"bytes"
+
 	"github.com/arduino/arduino-builder/i18n"
 	"github.com/arduino/arduino-builder/types"
-	"github.com/arduino/arduino-builder/utils"
-	"bytes"
-	"io/ioutil"
-	"path/filepath"
+	"github.com/arduino/go-paths-helper"
 )
 
 type AdditionalSketchFilesCopier struct{}
@@ -44,33 +43,30 @@ func (s *AdditionalSketchFilesCopier) Run(ctx *types.Context) error {
 	sketch := ctx.Sketch
 	sketchBuildPath := ctx.SketchBuildPath
 
-	err := utils.EnsureFolderExists(sketchBuildPath)
-	if err != nil {
+	if err := sketchBuildPath.MkdirAll(); err != nil {
 		return i18n.WrapError(err)
 	}
 
-	sketchBasePath := filepath.Dir(sketch.MainFile.Name)
+	sketchBasePath := sketch.MainFile.Name.Parent()
 
 	for _, file := range sketch.AdditionalFiles {
-		relativePath, err := filepath.Rel(sketchBasePath, file.Name)
+		relativePath, err := sketchBasePath.RelTo(file.Name)
 		if err != nil {
 			return i18n.WrapError(err)
 		}
 
-		targetFilePath := filepath.Join(sketchBuildPath, relativePath)
-		err = utils.EnsureFolderExists(filepath.Dir(targetFilePath))
-		if err != nil {
+		targetFilePath := sketchBuildPath.JoinPath(relativePath)
+		if err = targetFilePath.Parent().MkdirAll(); err != nil {
 			return i18n.WrapError(err)
 		}
 
-		bytes, err := ioutil.ReadFile(file.Name)
+		bytes, err := file.Name.ReadFile()
 		if err != nil {
 			return i18n.WrapError(err)
 		}
 
 		if targetFileChanged(bytes, targetFilePath) {
-			err := utils.WriteFileBytes(targetFilePath, bytes)
-			if err != nil {
+			if err := targetFilePath.WriteFile(bytes); err != nil {
 				return i18n.WrapError(err)
 			}
 		}
@@ -79,8 +75,8 @@ func (s *AdditionalSketchFilesCopier) Run(ctx *types.Context) error {
 	return nil
 }
 
-func targetFileChanged(currentBytes []byte, targetFilePath string) bool {
-	oldBytes, err := ioutil.ReadFile(targetFilePath)
+func targetFileChanged(currentBytes []byte, targetFilePath *paths.Path) bool {
+	oldBytes, err := targetFilePath.ReadFile()
 	if err != nil {
 		return true
 	}

arduino-builder/main.go

@@ -40,11 +40,12 @@ import (
 	"strings"
 	"syscall"
 
+	"github.com/arduino/go-paths-helper"
+
 	"github.com/arduino/arduino-builder"
 	"github.com/arduino/arduino-builder/gohasissues"
 	"github.com/arduino/arduino-builder/i18n"
 	"github.com/arduino/arduino-builder/types"
-	"github.com/arduino/arduino-builder/utils"
 	"github.com/arduino/go-properties-map"
 	"github.com/go-errors/errors"
 )
@@ -194,7 +195,7 @@ func main() {
 	if hardwareFolders, err := toSliceOfUnquoted(hardwareFoldersFlag); err != nil {
 		printCompleteError(err)
 	} else if len(hardwareFolders) > 0 {
-		ctx.HardwareFolders = hardwareFolders
+		ctx.HardwareFolders = paths.NewPathList(hardwareFolders...)
 	}
 	if len(ctx.HardwareFolders) == 0 {
 		printErrorMessageAndFlagUsage(errors.New("Parameter '" + FLAG_HARDWARE + "' is mandatory"))
@@ -204,7 +205,7 @@ func main() {
 	if toolsFolders, err := toSliceOfUnquoted(toolsFoldersFlag); err != nil {
 		printCompleteError(err)
 	} else if len(toolsFolders) > 0 {
-		ctx.ToolsFolders = toolsFolders
+		ctx.ToolsFolders = paths.NewPathList(toolsFolders...)
 	}
 	if len(ctx.ToolsFolders) == 0 {
 		printErrorMessageAndFlagUsage(errors.New("Parameter '" + FLAG_TOOLS + "' is mandatory"))
@@ -214,14 +215,14 @@ func main() {
 	if librariesFolders, err := toSliceOfUnquoted(librariesFoldersFlag); err != nil {
 		printCompleteError(err)
 	} else if len(librariesFolders) > 0 {
-		ctx.OtherLibrariesFolders = librariesFolders
+		ctx.OtherLibrariesFolders = paths.NewPathList(librariesFolders...)
 	}
 
 	// FLAG_BUILT_IN_LIBRARIES
 	if librariesBuiltInFolders, err := toSliceOfUnquoted(librariesBuiltInFoldersFlag); err != nil {
 		printCompleteError(err)
 	} else if len(librariesBuiltInFolders) > 0 {
-		ctx.BuiltInLibrariesFolders = librariesBuiltInFolders
+		ctx.BuiltInLibrariesFolders = paths.NewPathList(librariesBuiltInFolders...)
 	}
 
 	// FLAG_PREFS
@@ -242,38 +243,38 @@ func main() {
 	}
 
 	// FLAG_BUILD_PATH
-	buildPath, err := gohasissues.Unquote(*buildPathFlag)
+	buildPathUnquoted, err := gohasissues.Unquote(*buildPathFlag)
 	if err != nil {
 		printCompleteError(err)
 	}
-	if buildPath != "" {
-		_, err := os.Stat(buildPath)
-		if err != nil {
+	buildPath := paths.New(buildPathUnquoted)
+	if buildPath != nil {
+		// TODO: mmmmhhh... this one looks like a bug, why check existence?
+		if _, err := buildPath.Stat(); err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			os.Exit(1)
 		}
 
-		err = utils.EnsureFolderExists(buildPath)
-		if err != nil {
+		if err := buildPath.MkdirAll(); err != nil {
 			printCompleteError(err)
 		}
 	}
 	ctx.BuildPath = buildPath
 
 	// FLAG_BUILD_CACHE
-	buildCachePath, err := gohasissues.Unquote(*buildCachePathFlag)
+	buildCachePathUnquoted, err := gohasissues.Unquote(*buildCachePathFlag)
 	if err != nil {
 		printCompleteError(err)
 	}
-	if buildCachePath != "" {
-		_, err := os.Stat(buildCachePath)
-		if err != nil {
+	buildCachePath := paths.New(buildCachePathUnquoted)
+	if buildCachePath != nil {
+		// TODO: mmmmhhh... this one looks like a bug, why check existence?
+		if _, err := buildCachePath.Stat(); err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			os.Exit(1)
 		}
 
-		err = utils.EnsureFolderExists(buildCachePath)
-		if err != nil {
+		if err := buildCachePath.MkdirAll(); err != nil {
 			printCompleteError(err)
 		}
 	}
@@ -285,12 +286,11 @@ func main() {
 	}
 
 	if flag.NArg() > 0 {
-		sketchLocation := flag.Arg(0)
-		sketchLocation, err := gohasissues.Unquote(sketchLocation)
+		sketchLocationUnquoted, err := gohasissues.Unquote(flag.Arg(0))
 		if err != nil {
 			printCompleteError(err)
 		}
-		ctx.SketchLocation = sketchLocation
+		ctx.SketchLocation = paths.New(sketchLocationUnquoted)
 	}
 
 	if *verboseFlag && *quietFlag {