Move DependencyMap to spaghetti-analyzer

Author: ole108

data/data.go

@@ -3,8 +3,6 @@ package data
 import (
 	"fmt"
 	"regexp"
-	"sort"
-	"strings"
 )
 
 // PkgType can be one of: Standard, Tool, DB or God
@@ -21,12 +19,6 @@ const (
 var typeLetters = []rune("STDG")
 var typeFormats = []string{"", "_", "`", "**"}
 
-// PkgImports contains the package type and the imported internal packages with their types.
-type PkgImports struct {
-	PkgType PkgType
-	Imports map[string]PkgType
-}
-
 // TypeLetter returns the type letter associated with package type t ('S', 'T',
 // 'D' or 'G').
 func TypeLetter(t PkgType) rune {
@@ -57,73 +49,6 @@ type Pattern struct {
 	DollarIdxs []int
 }
 
-// DependencyMap is mapping importing package to imported packages.
-// importingPackageName -> (importedPackageNames -> PkgType)
-// An imported package name could be added multiple times to the same importing
-// package name due to test packages.
-type DependencyMap map[string]PkgImports
-
-// SortedPkgNames returns the sorted keys (package names) of the dependency map.
-func (dm DependencyMap) SortedPkgNames() []string {
-	names := make([]string, 0, len(dm))
-	for pkg := range dm {
-		names = append(names, pkg)
-	}
-	sort.Strings(names)
-	return names
-}
-
-// FilterDepMap filters allMap to contain only packages matching idx and its transitive
-// dependencies.  Entries matching other indices in links are filtered, too.
-func FilterDepMap(allMap DependencyMap, idx int, links PatternList) DependencyMap {
-	if idx < 0 || len(links) == 0 {
-		return allMap
-	}
-
-	fltrMap := make(DependencyMap, len(allMap))
-	for pkg := range allMap {
-		if i := DocMatchStringIndex(pkg, links); i >= 0 && i == idx {
-			copyDepsRecursive(allMap, pkg, fltrMap, links, idx)
-		}
-	}
-	return fltrMap
-}
-func copyDepsRecursive(
-	allMap DependencyMap,
-	startPkg string,
-	fltrMap DependencyMap,
-	links PatternList,
-	idx int,
-) {
-	if i := DocMatchStringIndex(startPkg, links); i >= 0 && i != idx {
-		return
-	}
-	imps, ok := allMap[startPkg]
-	if !ok {
-		return
-	}
-	fltrMap[startPkg] = imps
-	for pkg := range imps.Imports {
-		copyDepsRecursive(allMap, pkg, fltrMap, links, idx)
-	}
-}
-
-// PkgForPattern returns the (parent) package of the given package pattern.
-// If pkg doesn't contain any wildcard '*' the whole string is returned.
-// Otherwise everything up to the last '/' before the wildcard or
-// the empty string if there is no '/' before it.
-func PkgForPattern(pkg string) string {
-	i := strings.IndexRune(pkg, '*')
-	if i < 0 {
-		return pkg
-	}
-	i = strings.LastIndex(pkg[:i], "/")
-	if i > 0 {
-		return pkg[:i]
-	}
-	return ""
-}
-
 // RegexpForPattern converts the given pattern including wildcards and variables
 // into a proper regular expression that can be used for matching.
 func RegexpForPattern(pattern string, allowDollar EnumDollar, maxDollar int,

data/data_test.go

@@ -2,276 +2,11 @@ package data_test
 
 import (
 	"reflect"
-	"sort"
-	"strings"
 	"testing"
 
 	"github.com/flowdev/spaghetti-cutter/data"
 )
 
-func TestDependencyMapSortedPkgNames(t *testing.T) {
-	givenDepMap := map[string]data.PkgImports{
-		"b":  data.PkgImports{},
-		"a":  data.PkgImports{},
-		"aa": data.PkgImports{},
-		"b ": data.PkgImports{},
-		"a ": data.PkgImports{},
-	}
-	expectedNames := []string{"a", "a ", "aa", "b", "b "}
-
-	actualNames := data.DependencyMap(givenDepMap).SortedPkgNames()
-	if len(actualNames) != len(givenDepMap) {
-		t.Errorf("expected %d names, actual %d",
-			len(givenDepMap), len(actualNames))
-	}
-	if !reflect.DeepEqual(actualNames, expectedNames) {
-		t.Errorf("expected names to be %q, got %q", expectedNames, actualNames)
-	}
-}
-
-func TestFilterDepMap(t *testing.T) {
-	manyLinks, err := data.NewSimplePatternList([]string{"a", "b/c/d", "e**", "f/**"}, "test")
-	if err != nil {
-		t.Fatalf("got unexpected error: %v", err)
-	}
-	bigDepMap := data.DependencyMap{
-		"a": data.PkgImports{
-			PkgType: data.TypeGod,
-			Imports: map[string]data.PkgType{
-				"b/c/d":   data.TypeTool,
-				"epsilon": data.TypeTool,
-				"escher":  data.TypeTool,
-				"z":       data.TypeDB,
-				"f":       data.TypeStandard,
-			},
-		},
-		"z": data.PkgImports{
-			PkgType: data.TypeDB,
-			Imports: map[string]data.PkgType{
-				"b/c/d":   data.TypeTool,
-				"epsilon": data.TypeTool,
-				"escher":  data.TypeTool,
-				"x":       data.TypeDB,
-			},
-		},
-		"x": data.PkgImports{
-			PkgType: data.TypeDB,
-			Imports: map[string]data.PkgType{
-				"b/c/d":  data.TypeTool,
-				"escher": data.TypeTool,
-			},
-		},
-		"m": data.PkgImports{
-			PkgType: data.TypeStandard,
-			Imports: map[string]data.PkgType{
-				"b/c/d": data.TypeTool,
-				"x":     data.TypeDB,
-			},
-		},
-		"f": data.PkgImports{
-			PkgType: data.TypeStandard,
-			Imports: map[string]data.PkgType{
-				"f/g": data.TypeStandard,
-				"f/h": data.TypeStandard,
-				"f/i": data.TypeStandard,
-			},
-		},
-		"f/g": data.PkgImports{
-			PkgType: data.TypeStandard,
-			Imports: map[string]data.PkgType{
-				"f/j":    data.TypeStandard,
-				"escher": data.TypeTool,
-				"x":      data.TypeDB,
-			},
-		},
-		"f/h": data.PkgImports{
-			PkgType: data.TypeStandard,
-			Imports: map[string]data.PkgType{
-				"x": data.TypeDB,
-				"m": data.TypeStandard,
-			},
-		},
-		"f/i": data.PkgImports{
-			PkgType: data.TypeStandard,
-			Imports: map[string]data.PkgType{
-				"escher": data.TypeTool,
-			},
-		},
-	}
-	t.Logf("bigDepMap:\n%s", prettyPrint(bigDepMap))
-
-	specs := []struct {
-		name           string
-		givenIdx       int
-		givenLinks     data.PatternList
-		expectedDepMap string
-	}{
-		{
-			name:           "negative-index",
-			givenIdx:       -123,
-			givenLinks:     manyLinks,
-			expectedDepMap: prettyPrint(bigDepMap),
-		}, {
-			name:           "no-links",
-			givenIdx:       0,
-			givenLinks:     data.PatternList{},
-			expectedDepMap: prettyPrint(bigDepMap),
-		}, {
-			name:           "no-wildcard-leave-package",
-			givenIdx:       1,
-			givenLinks:     manyLinks,
-			expectedDepMap: ``,
-		}, {
-			name:       "no-wildcard-tree",
-			givenIdx:   0,
-			givenLinks: manyLinks,
-			expectedDepMap: `a [G] imports: b/c/d [T]
-a [G] imports: epsilon [T]
-a [G] imports: escher [T]
-a [G] imports: f [S]
-a [G] imports: z [D]
-x [D] imports: b/c/d [T]
-x [D] imports: escher [T]
-z [D] imports: b/c/d [T]
-z [D] imports: epsilon [T]
-z [D] imports: escher [T]
-z [D] imports: x [D]`,
-		}, {
-			name:           "wildcard-leave-packages",
-			givenIdx:       2,
-			givenLinks:     manyLinks,
-			expectedDepMap: ``,
-		}, {
-			name:       "wildcard-tree",
-			givenIdx:   3,
-			givenLinks: manyLinks,
-			expectedDepMap: `f [S] imports: f/g [S]
-f [S] imports: f/h [S]
-f [S] imports: f/i [S]
-f/g [S] imports: escher [T]
-f/g [S] imports: f/j [S]
-f/g [S] imports: x [D]
-f/h [S] imports: m [S]
-f/h [S] imports: x [D]
-f/i [S] imports: escher [T]
-m [S] imports: b/c/d [T]
-m [S] imports: x [D]
-x [D] imports: b/c/d [T]
-x [D] imports: escher [T]`,
-		},
-	}
-
-	for _, spec := range specs {
-		t.Run(spec.name, func(t *testing.T) {
-			actualDepMap := data.FilterDepMap(bigDepMap, spec.givenIdx, spec.givenLinks)
-			sDeps := prettyPrint(actualDepMap)
-			if sDeps != spec.expectedDepMap {
-				failWithDiff(t, spec.expectedDepMap, sDeps)
-			}
-		})
-	}
-}
-func prettyPrint(deps data.DependencyMap) string {
-	sb := strings.Builder{}
-
-	for _, pkg := range deps.SortedPkgNames() {
-		imps := deps[pkg]
-		pkgTypeRune := data.TypeLetter(imps.PkgType)
-
-		for _, imp := range sortedImpNames(imps.Imports) {
-			sb.WriteString(pkg)
-			sb.WriteString(" [")
-			sb.WriteRune(pkgTypeRune)
-			sb.WriteString("] imports: ")
-			sb.WriteString(imp)
-			sb.WriteString(" [")
-			sb.WriteRune(data.TypeLetter(imps.Imports[imp]))
-			sb.WriteString("]\n")
-		}
-	}
-
-	return sb.String()
-}
-func failWithDiff(t *testing.T, expected, actual string) {
-	exps := strings.Split(expected, "\n")
-	acts := strings.Split(actual, "\n")
-
-	i := 0
-	j := 0
-	n := len(exps) - 1
-	m := len(acts) - 1
-	if n >= 0 && exps[n] == "" {
-		n--
-	}
-	if m >= 0 && acts[m] == "" {
-		m--
-	}
-	for i <= n && j <= m {
-		if exps[i] < acts[j] {
-			t.Errorf("expected but missing:  %s", exps[i])
-			i++
-		} else if exps[i] == acts[j] {
-			i++
-			j++
-		} else if exps[i] > acts[j] {
-			t.Errorf("actual but unexpected: %s", acts[j])
-			j++
-		}
-	}
-	for ; i <= n; i++ {
-		t.Errorf("expected but missing:  %s", exps[i])
-	}
-	for ; j <= m; j++ {
-		t.Errorf("actual but unexpected: %s", acts[j])
-	}
-}
-func sortedImpNames(imps map[string]data.PkgType) []string {
-	names := make([]string, 0, len(imps))
-	for imp := range imps {
-		names = append(names, imp)
-	}
-	sort.Strings(names)
-	return names
-}
-
-func TestPkgForPattern(t *testing.T) {
-	specs := []struct {
-		name         string
-		givenPattern string
-		expectedPkg  string
-	}{
-		{
-			name:         "no-wildcard",
-			givenPattern: "abc/def/ghi",
-			expectedPkg:  "abc/def/ghi",
-		}, {
-			name:         "one-simple-wildcard",
-			givenPattern: "abc/def/*",
-			expectedPkg:  "abc/def",
-		}, {
-			name:         "one-middle-wildcard",
-			givenPattern: "abc/def/gh*i",
-			expectedPkg:  "abc/def",
-		}, {
-			name:         "many-wildcards",
-			givenPattern: "abc/d**e*f/*",
-			expectedPkg:  "abc",
-		}, {
-			name:         "no-slash",
-			givenPattern: "abc*",
-			expectedPkg:  "",
-		},
-	}
-	for _, spec := range specs {
-		t.Run(spec.name, func(t *testing.T) {
-			actualPkg := data.PkgForPattern(spec.givenPattern)
-			if actualPkg != spec.expectedPkg {
-				t.Errorf("expected package %q, actual %q", spec.expectedPkg, actualPkg)
-			}
-		})
-	}
-}
-
 func TestRegexpForPattern(t *testing.T) {
 	specs := []struct {
 		name             string