feat: crawl /etc/paths.d for more sources

Author: d-led

common/nix_candidate_source.go

@@ -25,7 +25,8 @@ func NewNixCandidateSource(fs Filesystem, key string) CandidateSource {
 		sources: map[string]*PathSetIn{},
 		key:     key,
 	}
-	res.precompute()
+	res.crawlKnownPaths()
+	res.crawlPathLists()
 	return res
 }
 
@@ -37,7 +38,7 @@ func (s *NixCandidateSource) WhereSet(somePath string) *PathSetIn {
 	return s.sources[normalizedPath]
 }
 
-func (s *NixCandidateSource) precompute() {
+func (s *NixCandidateSource) crawlKnownPaths() {
 	ForEachKnownPath(func(originalSource, expandedSource string) {
 		// try getting the contents
 		input, err := readAllText(expandedSource)
@@ -58,23 +59,7 @@ func (s *NixCandidateSource) precompute() {
 				if s.key == x.Name.Value {
 					harvestedPaths := s.harvestPaths(input[x.Value.Pos().Offset():x.Value.End().Offset()])
 					for _, harvestedPath := range harvestedPaths {
-						foundNormalizedPath := s.fs.GetAbsolutePath(harvestedPath)
-						sourcesForPath := s.sources[foundNormalizedPath]
-						if sourcesForPath == nil {
-							sourcesForPath = &PathSetIn{
-								What:     Location{harvestedPath, foundNormalizedPath},
-								WhereSet: []Location{},
-							}
-						}
-						sourcesForPath.WhereSet = appendIfNotInSlice(
-							sourcesForPath.WhereSet,
-							Location{
-								originalSource,
-								expandedSource,
-							}, func(a, b Location) bool {
-								return a.Expanded == b.Expanded && a.Original == b.Original
-							})
-						s.sources[foundNormalizedPath] = sourcesForPath
+						s.tryUpdatePathMap(harvestedPath, originalSource, expandedSource)
 					}
 				}
 			}
@@ -83,6 +68,35 @@ func (s *NixCandidateSource) precompute() {
 	})
 }
 
+func (s *NixCandidateSource) tryUpdatePathMap(harvestedPath string, originalSource string, expandedSource string) {
+	foundNormalizedPath := s.fs.GetAbsolutePath(harvestedPath)
+	sourcesForPath := s.sources[foundNormalizedPath]
+	if sourcesForPath == nil {
+		sourcesForPath = &PathSetIn{
+			What:     Location{harvestedPath, foundNormalizedPath},
+			WhereSet: []Location{},
+		}
+	}
+	sourcesForPath.WhereSet = appendIfNotInSlice(
+		sourcesForPath.WhereSet,
+		Location{
+			originalSource,
+			expandedSource,
+		}, func(a, b Location) bool {
+			return a.Expanded == b.Expanded && a.Original == b.Original
+		})
+	s.sources[foundNormalizedPath] = sourcesForPath
+}
+
+func (s *NixCandidateSource) crawlPathLists() {
+	if runtime.GOOS == "windows" {
+		return
+	}
+	ForEachPathsDPath(func(source, path string) {
+		s.tryUpdatePathMap(path, source, source)
+	})
+}
+
 // input is some path definition
 func (s *NixCandidateSource) harvestPaths(input string) []string {
 	input = strings.TrimSpace(input)

common/paths_f_source.go

@@ -0,0 +1,35 @@
+package common
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const pathListsDir = "/etc/paths.d/"
+
+func ForEachPathsDPath(fn func(source string, path string)) {
+	_ = filepath.Walk(pathListsDir,
+		func(path string, info os.FileInfo, err error) error {
+			if err != nil || info.IsDir() {
+				return nil
+			}
+			input, err := readAllText(path)
+			if err != nil {
+				log.Print(err)
+				return nil
+			}
+
+			lines := strings.Split(string(input), "\n")
+			for _, line := range lines {
+				trimmedPath := strings.TrimSpace(line)
+				if trimmedPath == "" {
+					continue
+				}
+				fn(path, trimmedPath)
+			}
+			return nil
+		},
+	)
+}

common/results_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func Test_empty_results_cannot_be_summarized(t *testing.T) {
-	sut := NewResultsCalculator(&mockFilesystem{}, &mockValueSource{})
+	sut := NewCustomResultsCalculator(&mockFilesystem{}, &mockValueSource{}, &mockCandidateSource{})
 	_, err := sut.CalculateResults()
 	assert.Error(t, err)
 }
@@ -22,10 +22,10 @@ func Test_duplicates_have_correct_ids(t *testing.T) {
 	mockFs.On("GetAbsolutePath", mock.Anything).Return("a")
 	mockFs.On("PathStatus", mock.Anything).Return(true, true)
 
-	sut := NewResultsCalculator(mockFs, &mockValueSource{values_: []string{
+	sut := NewCustomResultsCalculator(mockFs, &mockValueSource{values_: []string{
 		"a",
 		"a",
-	}})
+	}}, &mockCandidateSource{})
 	rows, err := sut.CalculateResults()
 	require.NoError(t, err)
 	require.Len(t, rows, 2)
@@ -54,10 +54,10 @@ func Test_no_duplicates(t *testing.T) {
 	mockFs.On("GetAbsolutePath", "b").Return("b")
 	mockFs.On("PathStatus", mock.Anything).Return(true, true)
 
-	sut := NewResultsCalculator(mockFs, &mockValueSource{values_: []string{
+	sut := NewCustomResultsCalculator(mockFs, &mockValueSource{values_: []string{
 		"a",
 		"b",
-	}})
+	}}, &mockCandidateSource{})
 	rows, _ := sut.CalculateResults()
 	assert.Empty(t, rows[0].Duplicates)
 	assert.Empty(t, rows[1].Duplicates)