Use libraryresolver to resolve libraries

Author: cmaglie

libraries_loader.go

@@ -33,6 +33,7 @@ import (
 	"os"
 
 	"github.com/bcmi-labs/arduino-cli/arduino/libraries/librariesmanager"
+	"github.com/bcmi-labs/arduino-cli/arduino/libraries/librariesresolver"
 
 	"github.com/arduino/arduino-builder/i18n"
 	"github.com/arduino/arduino-builder/types"
@@ -89,22 +90,11 @@ func (s *LibrariesLoader) Run(ctx *types.Context) error {
 		}
 	}
 
-	headerToLibraries := make(map[string][]*libraries.Library)
-	for _, lib := range lm.Libraries {
-		for _, library := range lib.Alternatives {
-			headers, err := library.SrcFolder.ReadDir()
-			if err != nil {
-				return i18n.WrapError(err)
-			}
-			headers.FilterSuffix(".h", ".hpp", ".hh")
-			for _, header := range headers {
-				headerFileName := header.Base()
-				headerToLibraries[headerFileName] = append(headerToLibraries[headerFileName], library)
-			}
-		}
+	resolver := librariesresolver.NewCppResolver()
+	if err := resolver.ScanFromLibrariesManager(lm); err != nil {
+		return i18n.WrapError(err)
 	}
-
-	ctx.HeaderToLibraries = headerToLibraries
+	ctx.LibrariesResolver = resolver
 
 	return nil
 }

phases/libraries_builder.go

@@ -71,7 +71,7 @@ func (s *LibrariesBuilder) Run(ctx *types.Context) error {
 	return nil
 }
 
-func fixLDFLAGforPrecompiledLibraries(ctx *types.Context, libs []*libraries.Library) error {
+func fixLDFLAGforPrecompiledLibraries(ctx *types.Context, libs libraries.List) error {
 
 	for _, library := range libs {
 		if library.Precompiled {
@@ -96,7 +96,7 @@ func fixLDFLAGforPrecompiledLibraries(ctx *types.Context, libs []*libraries.Libr
 	return nil
 }
 
-func compileLibraries(ctx *types.Context, libraries []*libraries.Library, buildPath *paths.Path, buildProperties properties.Map, includes []string) (paths.PathList, error) {
+func compileLibraries(ctx *types.Context, libraries libraries.List, buildPath *paths.Path, buildProperties properties.Map, includes []string) (paths.PathList, error) {
 	objectFiles := paths.NewPathList()
 	for _, library := range libraries {
 		libraryObjectFiles, err := compileLibrary(ctx, library, buildPath, buildProperties, includes)

resolve_library.go

@@ -30,98 +30,44 @@
 package builder
 
 import (
-	"path/filepath"
-	"strings"
+	"fmt"
 
-	"github.com/arduino/arduino-builder/constants"
 	"github.com/arduino/arduino-builder/types"
-	"github.com/arduino/arduino-builder/utils"
-	"github.com/bcmi-labs/arduino-cli/arduino/cores"
 	"github.com/bcmi-labs/arduino-cli/arduino/libraries"
 )
 
 func ResolveLibrary(ctx *types.Context, header string) *libraries.Library {
-	headerToLibraries := ctx.HeaderToLibraries
-	platforms := []*cores.PlatformRelease{ctx.ActualPlatform, ctx.TargetPlatform}
-	libraryResolutionResults := ctx.LibrariesResolutionResults
+	resolver := ctx.LibrariesResolver
 	importedLibraries := ctx.ImportedLibraries
 
-	libs := append([]*libraries.Library{}, headerToLibraries[header]...)
+	candidates := resolver.AlternativesFor(header)
+	fmt.Printf("ResolveLibrary(%s)\n", header)
+	fmt.Printf("  -> candidates: %s\n", candidates)
 
-	if libs == nil || len(libs) == 0 {
+	if candidates == nil || len(candidates) == 0 {
 		return nil
 	}
 
-	if importedLibraryContainsOneOfCandidates(importedLibraries, libs) {
-		return nil
-	}
-
-	if len(libs) == 1 {
-		return libs[0]
-	}
-
-	reverse(libs)
-
-	var library *libraries.Library
-
-	for _, platform := range platforms {
-		if platform != nil {
-			library = findBestLibraryWithHeader(header, librariesCompatibleWithPlatform(libs, platform, true))
+	for _, candidate := range candidates {
+		if importedLibraries.Contains(candidate) {
+			return nil
 		}
 	}
 
-	if library == nil {
-		library = findBestLibraryWithHeader(header, libs)
-	}
-
-	if library == nil {
-		// reorder libraries to promote fully compatible ones
-		for _, platform := range platforms {
-			if platform != nil {
-				libs = append(librariesCompatibleWithPlatform(libs, platform, false), libs...)
-			}
-		}
-		library = libs[0]
+	selected := resolver.ResolveFor(header, ctx.TargetPlatform.Platform.Architecture)
+	if alreadyImported := importedLibraries.FindByName(selected.Name); alreadyImported != nil {
+		selected = alreadyImported
 	}
 
-	library = useAlreadyImportedLibraryWithSameNameIfExists(library, importedLibraries)
-
-	libraryResolutionResults[header] = types.LibraryResolutionResult{
-		Library:          library,
-		NotUsedLibraries: filterOutLibraryFrom(libs, library),
+	ctx.LibrariesResolutionResults[header] = types.LibraryResolutionResult{
+		Library:          selected,
+		NotUsedLibraries: filterOutLibraryFrom(candidates, selected),
 	}
 
-	return library
-}
-
-//facepalm. sort.Reverse needs an Interface that implements Len/Less/Swap. It's a slice! What else for reversing it?!?
-func reverse(data []*libraries.Library) {
-	for i, j := 0, len(data)-1; i < j; i, j = i+1, j-1 {
-		data[i], data[j] = data[j], data[i]
-	}
+	return selected
 }
 
-func importedLibraryContainsOneOfCandidates(imported []*libraries.Library, candidates []*libraries.Library) bool {
-	for _, i := range imported {
-		for _, j := range candidates {
-			if i == j {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func useAlreadyImportedLibraryWithSameNameIfExists(library *libraries.Library, imported []*libraries.Library) *libraries.Library {
-	for _, lib := range imported {
-		if lib.Name == library.Name {
-			return lib
-		}
-	}
-	return library
-}
-
-func filterOutLibraryFrom(libs []*libraries.Library, libraryToRemove *libraries.Library) []*libraries.Library {
+func filterOutLibraryFrom(libs libraries.List, libraryToRemove *libraries.Library) libraries.List {
 	filteredOutLibraries := []*libraries.Library{}
 	for _, lib := range libs {
 		if lib != libraryToRemove {
@@ -130,107 +76,3 @@ func filterOutLibraryFrom(libs []*libraries.Library, libraryToRemove *libraries.
 	}
 	return filteredOutLibraries
 }
-
-func libraryCompatibleWithPlatform(library *libraries.Library, platform *cores.PlatformRelease) (bool, bool) {
-	if len(library.Architectures) == 0 {
-		return true, true
-	}
-	if utils.SliceContains(library.Architectures, constants.LIBRARY_ALL_ARCHS) {
-		return true, true
-	}
-	return utils.SliceContains(library.Architectures, platform.Platform.Architecture), false
-}
-
-func libraryCompatibleWithAllPlatforms(library *libraries.Library) bool {
-	if utils.SliceContains(library.Architectures, constants.LIBRARY_ALL_ARCHS) {
-		return true
-	}
-	return false
-}
-
-func librariesCompatibleWithPlatform(libs []*libraries.Library, platform *cores.PlatformRelease, reorder bool) []*libraries.Library {
-	var compatibleLibraries []*libraries.Library
-	for _, library := range libs {
-		compatible, generic := libraryCompatibleWithPlatform(library, platform)
-		if compatible {
-			if !generic && len(compatibleLibraries) != 0 && libraryCompatibleWithAllPlatforms(compatibleLibraries[0]) && reorder == true {
-				//priority inversion
-				compatibleLibraries = append([]*libraries.Library{library}, compatibleLibraries...)
-			} else {
-				compatibleLibraries = append(compatibleLibraries, library)
-			}
-		}
-	}
-
-	return compatibleLibraries
-}
-
-func findBestLibraryWithHeader(header string, libs []*libraries.Library) *libraries.Library {
-	headerName := strings.Replace(header, filepath.Ext(header), constants.EMPTY_STRING, -1)
-
-	var library *libraries.Library
-	for _, headerName := range []string{headerName, strings.ToLower(headerName)} {
-		library = findLibWithName(headerName, libs)
-		if library != nil {
-			return library
-		}
-		library = findLibWithName(headerName+"-master", libs)
-		if library != nil {
-			return library
-		}
-		library = findLibWithNameStartingWith(headerName, libs)
-		if library != nil {
-			return library
-		}
-		library = findLibWithNameEndingWith(headerName, libs)
-		if library != nil {
-			return library
-		}
-		library = findLibWithNameContaining(headerName, libs)
-		if library != nil {
-			return library
-		}
-	}
-
-	return nil
-}
-
-func findLibWithName(name string, libraries []*libraries.Library) *libraries.Library {
-	for _, library := range libraries {
-		if simplifyName(library.Name) == simplifyName(name) {
-			return library
-		}
-	}
-	return nil
-}
-
-func findLibWithNameStartingWith(name string, libraries []*libraries.Library) *libraries.Library {
-	for _, library := range libraries {
-		if strings.HasPrefix(simplifyName(library.Name), simplifyName(name)) {
-			return library
-		}
-	}
-	return nil
-}
-
-func findLibWithNameEndingWith(name string, libraries []*libraries.Library) *libraries.Library {
-	for _, library := range libraries {
-		if strings.HasSuffix(simplifyName(library.Name), simplifyName(name)) {
-			return library
-		}
-	}
-	return nil
-}
-
-func findLibWithNameContaining(name string, libraries []*libraries.Library) *libraries.Library {
-	for _, library := range libraries {
-		if strings.Contains(simplifyName(library.Name), simplifyName(name)) {
-			return library
-		}
-	}
-	return nil
-}
-
-func simplifyName(name string) string {
-	return strings.ToLower(strings.Replace(name, "_", " ", -1))
-}

resolve_library_test.go

@@ -142,7 +142,7 @@ func DownloadCoresAndToolsAndLibraries(t *testing.T) {
 		Library{Name: "Bridge", Version: "1.6.1"},
 		Library{Name: "CapacitiveSensor", Version: "0.5.0", VersionInLibProperties: "0.5"},
 		Library{Name: "Ethernet", Version: "1.1.1"},
-		Library{Name: "Robot IR Remote", Version: "1.0.2"},
+		Library{Name: "Robot IR Remote", Version: "2.0.0"},
 		Library{Name: "FastLED", Version: "3.1.0"},
 	}
 

test/helper_tools_downloader.go

@@ -168,11 +168,8 @@ func TestIncludesToIncludeFoldersANewLibrary(t *testing.T) {
 	defer buildPath.RemoveAll()
 
 	commands := []types.Command{
-
 		&builder.ContainerSetupHardwareToolsLibsSketchAndProps{},
-
 		&builder.ContainerMergeCopySketchFiles{},
-
 		&builder.ContainerFindIncludes{},
 	}