refactor: use descriptable String() methods instead of Fingerprint()

Author: michenriksen

filter.go

@@ -1,7 +1,7 @@
 package pkgdmp
 
 import (
-	"hash/fnv"
+	"fmt"
 	"regexp"
 	"sort"
 	"strings"
@@ -95,13 +95,10 @@ type SymbolFilter interface {
 	// the filter's logic and configuration.
 	Include(Symbol) bool
 
-	// Fingerprint should return a 64-bit FNV-1a hash of the filter and its
-	// configuration.
+	// String should return a string representation of the filter.
 	//
-	// This method is intended for testing purposes.
-	//
-	// See: https://pkg.go.dev/hash/fnv
-	Fingerprint() uint64
+	// This method is mainly intended for testing purposes.
+	String() string
 }
 
 // FilterUnexported creates a filter that determines whether to include or
@@ -122,12 +119,8 @@ func (f *filterUnexported) Include(s Symbol) bool {
 	return f.action == Include || s.IsExported()
 }
 
-func (f *filterUnexported) Fingerprint() uint64 {
-	h := fnv.New64a()
-	h.Write([]byte("filterUnexported"))
-	h.Sum([]byte(f.action.String()))
-
-	return h.Sum64()
+func (f *filterUnexported) String() string {
+	return fmt.Sprintf("filterUnexported(action=%s)", f.action)
 }
 
 // FilterSymbolTypes creates a filter function that determines whether to
@@ -164,11 +157,7 @@ func (f *filterSymbolTypes) Include(s Symbol) bool {
 	return !ok
 }
 
-func (f *filterSymbolTypes) Fingerprint() uint64 {
-	h := fnv.New64a()
-	h.Write([]byte("filterSymbolTypes"))
-	h.Write([]byte(f.action.String()))
-
+func (f *filterSymbolTypes) String() string {
 	sts := make([]string, 0, len(f.stMap))
 
 	for st := range f.stMap {
@@ -177,28 +166,26 @@ func (f *filterSymbolTypes) Fingerprint() uint64 {
 
 	sort.Strings(sts)
 
-	h.Sum([]byte(strings.Join(sts, "")))
-
-	return h.Sum64()
+	return fmt.Sprintf("filterSymbolTypes(action=%s,symbolTypes=%s)", f.action, strings.Join(sts, ","))
 }
 
 // FilterSymbolTypes creates a filter function that determines whether to
 // include or exclude symbols with matching idents.
 func FilterMatchingIdents(action FilterAction, p *regexp.Regexp) SymbolFilter {
-	return &filterMatchingIdents{action: action, p: p}
+	return &filterMatchingIdents{action: action, pattern: p}
 }
 
 type filterMatchingIdents struct {
-	p      *regexp.Regexp
-	action FilterAction
+	pattern *regexp.Regexp
+	action  FilterAction
 }
 
 func (f *filterMatchingIdents) Include(s Symbol) bool {
 	if isUnfilterable(s) {
 		return true
 	}
 
-	match := f.p.MatchString(s.Ident())
+	match := f.pattern.MatchString(s.Ident())
 
 	if f.action == Include {
 		return match
@@ -207,14 +194,8 @@ func (f *filterMatchingIdents) Include(s Symbol) bool {
 	return !match
 }
 
-func (f *filterMatchingIdents) Fingerprint() uint64 {
-	h := fnv.New64a()
-
-	h.Write([]byte("filterMatchingIdents"))
-	h.Write([]byte(f.action.String()))
-	h.Sum([]byte(f.p.String()))
-
-	return h.Sum64()
+func (f *filterMatchingIdents) String() string {
+	return fmt.Sprintf("filterMatchingIdents(action=%s,pattern=%s)", f.action, f.pattern)
 }
 
 // FilterPackages creates a filter function that determines whether to include
@@ -248,12 +229,7 @@ func (f *filterPackages) Include(s Symbol) bool {
 	return !ok
 }
 
-func (f *filterPackages) Fingerprint() uint64 {
-	h := fnv.New64a()
-
-	h.Write([]byte("filterPackages"))
-	h.Write([]byte(f.action.String()))
-
+func (f *filterPackages) String() string {
 	names := make([]string, 0, len(f.pkgMap))
 
 	for n := range f.pkgMap {
@@ -262,9 +238,7 @@ func (f *filterPackages) Fingerprint() uint64 {
 
 	sort.Strings(names)
 
-	h.Sum([]byte(strings.Join(names, "")))
-
-	return h.Sum64()
+	return fmt.Sprintf("filterPackages(action=%s,names=%s)", f.action, strings.Join(names, ","))
 }
 
 func isUnfilterable(s Symbol) bool {

internal/cli/flags.go

@@ -360,17 +360,20 @@ func usage() {
 
 func strToSymbolTypes(list string) ([]pkgdmp.SymbolType, error) {
 	ss := strings.Split(list, ",")
-	res := make([]pkgdmp.SymbolType, len(ss))
+	res := make([]pkgdmp.SymbolType, 0, len(ss))
 
-	for i, s := range ss {
+	for _, s := range ss {
 		s = strings.TrimSpace(strings.ToLower(s))
+		if s == "" {
+			continue
+		}
 
 		st, ok := symbolTypeMap[s]
 		if !ok {
 			return nil, fmt.Errorf("unsupported symbol type string: %q", s)
 		}
 
-		res[i] = st
+		res = append(res, st)
 	}
 
 	return res, nil

internal/cli/flags_test.go

@@ -80,25 +80,35 @@ func TestParseFlags(t *testing.T) {
 
 func TestParserOptsFromCfg(t *testing.T) {
 	tt := []struct {
-		name                string
-		cfg                 *cli.Config
-		wantOptFingerprints []uint64
-		wantErrRegexp       *regexp.Regexp
+		name          string
+		cfg           *cli.Config
+		wantOpts      []string
+		wantErrRegexp *regexp.Regexp
 	}{
 		{
-			name:                "default config",
-			cfg:                 &cli.Config{},
-			wantOptFingerprints: []uint64{2070688686324183492},
+			name: "default config",
+			cfg:  &cli.Config{},
+			wantOpts: []string{
+				"symbolFilters(filters=filterUnexported(action=Exclude))",
+			},
 		},
 		{
-			name:                "full docs and exclude interfaces",
-			cfg:                 &cli.Config{FullDocs: true, Exclude: "interface"},
-			wantOptFingerprints: []uint64{14695981039346656037, 4573527031645899146},
+			name: "full docs and exclude interfaces",
+			cfg:  &cli.Config{FullDocs: true, Exclude: "interface"},
+			wantOpts: []string{
+				"fullDocs",
+				"symbolFilters(filters=filterUnexported(action=Exclude),filterSymbolTypes(action=Exclude,symbolTypes=SymbolInterfaceType))",
+			},
 		},
 		{
-			name:                "match and exclude patterns",
-			cfg:                 &cli.Config{Matching: `^FooBa(r|z)`, ExcludeMatching: `(Hello|Hi)World`},
-			wantOptFingerprints: []uint64{14104148152248147676},
+			name: "match and exclude patterns",
+			cfg:  &cli.Config{Matching: `^FooBa(r|z)`, ExcludeMatching: `(Hello|Hi)World`},
+			wantOpts: []string{
+				"symbolFilters(filters=" +
+					"filterUnexported(action=Exclude)," +
+					"filterMatchingIdents(action=Include,pattern=^FooBa(r|z))," +
+					"filterMatchingIdents(action=Exclude,pattern=(Hello|Hi)World))",
+			},
 		},
 		{
 			name:          "invalid match regexp",
@@ -116,20 +126,20 @@ func TestParserOptsFromCfg(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			opts, err := cli.ParserOptsFromCfg(tc.cfg)
 
-			if fpLen := len(tc.wantOptFingerprints); fpLen != 0 {
+			if wOptsLen := len(tc.wantOpts); wOptsLen != 0 {
 				optsLen := len(opts)
 
-				if optsLen != fpLen {
-					t.Fatalf("expected option length to be %d, but got %d", fpLen, optsLen)
+				if optsLen != wOptsLen {
+					t.Fatalf("expected option length to be %d, but got %d", wOptsLen, optsLen)
 				}
 
 				for i, opt := range opts {
-					wantFp := tc.wantOptFingerprints[i]
-					actualFp := opt.Fingerprint()
+					wantOpt := tc.wantOpts[i]
+					actualOpt := opt.String()
 
-					if actualFp != wantFp {
-						t.Fatalf("expected option at index %d to have fingerprint %d, but has %d",
-							i, wantFp, actualFp,
+					if actualOpt != wantOpt {
+						t.Fatalf("expected option at index %d to be:\n\n%s\n\nbut is:\n\n%s\n\n",
+							i, wantOpt, actualOpt,
 						)
 					}
 				}

parse.go

@@ -5,7 +5,6 @@ import (
 	"go/ast"
 	"go/doc"
 	"go/token"
-	"hash/fnv"
 	"strings"
 )
 
@@ -19,13 +18,10 @@ var typeNames = map[token.Token]string{
 
 // ParserOption configures a [Parser].
 type ParserOption interface {
-	// Fingerprint should return a 64-bit FNV-1a hash of the option and its
-	// configuration.
+	// String should return a string representation of the option.
 	//
-	// This method is intended for testing purposes.
-	//
-	// See: https://pkg.go.dev/hash/fnv
-	Fingerprint() uint64
+	// This method is mainly intended for testing purposes.
+	String() string
 
 	apply(*Parser) error
 }
@@ -361,64 +357,52 @@ func WithFullDocs() ParserOption {
 
 type fullDocs struct{}
 
+func (*fullDocs) String() string {
+	return "fullDocs"
+}
+
 func (*fullDocs) apply(p *Parser) error {
 	p.fullDocs = true
 	return nil
 }
 
-func (*fullDocs) Fingerprint() uint64 {
-	h := fnv.New64a()
-
-	h.Sum([]byte("fullDocs"))
-
-	return h.Sum64()
-}
-
 // WithNoDocs configures a [Parser] to not include any doc comments for symbols.
 func WithNoDocs() ParserOption {
 	return &noDocs{}
 }
 
 type noDocs struct{}
 
+func (*noDocs) String() string {
+	return "noDocs"
+}
+
 func (*noDocs) apply(p *Parser) error {
 	p.noDocs = true
 	return nil
 }
 
-func (*noDocs) Fingerprint() uint64 {
-	h := fnv.New64a()
-
-	h.Sum([]byte("noDocs"))
-
-	return h.Sum64()
-}
-
 // WithSymbolFilters configures a [Parser] to filter package symbols with
 // provided filter functions.
 func WithSymbolFilters(filters ...SymbolFilter) ParserOption {
-	return &symbolFilters{f: filters}
+	return &symbolFilters{filters: filters}
 }
 
 type symbolFilters struct {
-	f []SymbolFilter
-}
-
-func (sf *symbolFilters) apply(p *Parser) error {
-	p.filters = sf.f
-	return nil
+	filters []SymbolFilter
 }
 
-func (sf *symbolFilters) Fingerprint() uint64 {
-	h := fnv.New64a()
-
-	h.Sum([]byte("symbolFilters"))
+func (sf *symbolFilters) String() string {
+	filters := make([]string, 0, len(sf.filters))
 
-	sum := h.Sum64()
-
-	for _, f := range sf.f {
-		sum += f.Fingerprint()
+	for _, f := range sf.filters {
+		filters = append(filters, f.String())
 	}
 
-	return sum
+	return fmt.Sprintf("symbolFilters(filters=%s)", strings.Join(filters, ","))
+}
+
+func (sf *symbolFilters) apply(p *Parser) error {
+	p.filters = sf.filters
+	return nil
 }