Merge pull request #87 from github/ref-group-counts

Expand the use of refgroups

Author: mhagger

git-sizer.go

@@ -14,6 +14,7 @@ type ConfigEntry struct {
 }
 
 type Config struct {
+	Prefix  string
 	Entries []ConfigEntry
 }
 
@@ -29,7 +30,9 @@ func (repo *Repository) Config(prefix string) (*Config, error) {
 		return nil, fmt.Errorf("reading git configuration: %w", err)
 	}
 
-	var config Config
+	config := Config{
+		Prefix: prefix,
+	}
 
 	for len(out) > 0 {
 		keyEnd := bytes.IndexByte(out, '\n')
@@ -60,6 +63,15 @@ func (repo *Repository) Config(prefix string) (*Config, error) {
 	return &config, nil
 }
 
+// FullKey returns the full gitconfig key name for the relative key
+// name `key`.
+func (config *Config) FullKey(key string) string {
+	if config.Prefix == "" {
+		return key
+	}
+	return fmt.Sprintf("%s.%s", config.Prefix, key)
+}
+
 // configKeyMatchesPrefix checks whether `key` starts with `prefix` at
 // a component boundary (i.e., at a '.'). If yes, it returns `true`
 // and the part of the key after the prefix; e.g.:

git/gitconfig.go

@@ -5,68 +5,84 @@ import (
 	"strings"
 )
 
-type ReferenceFilter func(refname string) bool
+type ReferenceFilter interface {
+	Filter(refname string) bool
+}
 
-func AllReferencesFilter(_ string) bool {
-	return true
+// Combiner combines two `ReferenceFilter`s into one compound one.
+// `f1` is allowed to be `nil`.
+type Combiner interface {
+	Combine(f1, f2 ReferenceFilter) ReferenceFilter
+	Inverted() Combiner
 }
 
-type Polarity uint8
+type inverse struct {
+	f ReferenceFilter
+}
 
-const (
-	Include Polarity = iota
-	Exclude
-)
+func (f inverse) Filter(refname string) bool {
+	return !f.f.Filter(refname)
+}
 
-func (p Polarity) Inverted() Polarity {
-	switch p {
-	case Include:
-		return Exclude
-	case Exclude:
-		return Include
-	default:
-		// This shouldn't happen:
-		return Exclude
-	}
+type intersection struct {
+	f1, f2 ReferenceFilter
+}
+
+func (f intersection) Filter(refname string) bool {
+	return f.f1.Filter(refname) && f.f2.Filter(refname)
 }
 
-// polarizedFilter is a filter that might match, in which case it
-// includes or excludes the reference (according to its polarity). If
-// it doesn't match, then it doesn't say anything about the reference.
-type polarizedFilter struct {
-	polarity Polarity
-	filter   ReferenceFilter
+// Include is a Combiner that includes the references matched by `f2`.
+// If `f1` is `nil`, it is treated as including nothing.
+type include struct{}
+
+func (_ include) Combine(f1, f2 ReferenceFilter) ReferenceFilter {
+	if f1 == nil {
+		return f2
+	}
+	return union{f1, f2}
 }
 
-// IncludeExcludeFilter is a filter based on a bunch of
-// `polarizedFilter`s. The last one that matches a reference wins. If
-// none match, then the result is based on the polarity of the first
-// polarizedFilter: if it is `Include`, then return `false`; if it is
-// `Exclude`, then return `true`.
-type IncludeExcludeFilter struct {
-	filters []polarizedFilter
+func (_ include) Inverted() Combiner {
+	return Exclude
 }
 
-func (ief *IncludeExcludeFilter) Include(f ReferenceFilter) {
-	ief.filters = append(ief.filters, polarizedFilter{Include, f})
+var Include include
+
+type union struct {
+	f1, f2 ReferenceFilter
 }
 
-func (ief *IncludeExcludeFilter) Exclude(f ReferenceFilter) {
-	ief.filters = append(ief.filters, polarizedFilter{Exclude, f})
+func (f union) Filter(refname string) bool {
+	return f.f1.Filter(refname) || f.f2.Filter(refname)
 }
 
-func (ief *IncludeExcludeFilter) Filter(refname string) bool {
-	for i := len(ief.filters); i > 0; i-- {
-		f := ief.filters[i-1]
-		if !f.filter(refname) {
-			continue
-		}
-		return f.polarity == Include
+// Exclude is a Combiner that excludes the references matched by `f2`.
+// If `f1` is `nil`, it is treated as including everything.
+type exclude struct{}
+
+func (_ exclude) Combine(f1, f2 ReferenceFilter) ReferenceFilter {
+	if f1 == nil {
+		return inverse{f2}
 	}
+	return intersection{f1, inverse{f2}}
+
+}
 
-	return len(ief.filters) == 0 || ief.filters[0].polarity == Exclude
+func (_ exclude) Inverted() Combiner {
+	return include{}
 }
 
+var Exclude exclude
+
+type allReferencesFilter struct{}
+
+func (_ allReferencesFilter) Filter(_ string) bool {
+	return true
+}
+
+var AllReferencesFilter allReferencesFilter
+
 // PrefixFilter returns a `ReferenceFilter` that matches references
 // whose names start with the specified `prefix`, which must match at
 // a component boundary. For example,
@@ -77,16 +93,23 @@ func (ief *IncludeExcludeFilter) Filter(refname string) bool {
 // * Prefix "refs/foo/" matches "refs/foo/bar" but not "refs/foo" or
 //   "refs/foobar".
 func PrefixFilter(prefix string) ReferenceFilter {
-	if strings.HasSuffix(prefix, "/") {
-		return func(refname string) bool {
-			return strings.HasPrefix(refname, prefix)
-		}
+	if prefix == "" {
+		return AllReferencesFilter
 	}
+	return prefixFilter{prefix}
+}
 
-	return func(refname string) bool {
-		return strings.HasPrefix(refname, prefix) &&
-			(len(refname) == len(prefix) || refname[len(prefix)] == '/')
+type prefixFilter struct {
+	prefix string
+}
+
+func (f prefixFilter) Filter(refname string) bool {
+	if strings.HasSuffix(f.prefix, "/") {
+		return strings.HasPrefix(refname, f.prefix)
 	}
+
+	return strings.HasPrefix(refname, f.prefix) &&
+		(len(refname) == len(f.prefix) || refname[len(f.prefix)] == '/')
 }
 
 // RegexpFilter returns a `ReferenceFilter` that matches references
@@ -99,7 +122,13 @@ func RegexpFilter(pattern string) (ReferenceFilter, error) {
 		return nil, err
 	}
 
-	return func(refname string) bool {
-		return re.MatchString(refname)
-	}, nil
+	return regexpFilter{re}, nil
+}
+
+type regexpFilter struct {
+	re *regexp.Regexp
+}
+
+func (f regexpFilter) Filter(refname string) bool {
+	return f.re.MatchString(refname)
 }

git/ref_filter.go

@@ -38,7 +38,11 @@ func TestPrefixFilter(t *testing.T) {
 		t.Run(
 			fmt.Sprintf("prefix '%s', refname '%s'", p.prefix, p.refname),
 			func(t *testing.T) {
-				assert.Equal(t, p.expected, git.PrefixFilter(p.prefix)(p.refname))
+				assert.Equal(
+					t,
+					p.expected,
+					git.PrefixFilter(p.prefix).Filter(p.refname),
+				)
 			},
 		)
 	}
@@ -73,7 +77,11 @@ func TestRegexpFilter(t *testing.T) {
 		t.Run(
 			fmt.Sprintf("pattern '%s', refname '%s'", p.pattern, p.refname),
 			func(t *testing.T) {
-				assert.Equal(t, p.expected, regexpFilter(t, p.pattern)(p.refname))
+				assert.Equal(
+					t,
+					p.expected,
+					regexpFilter(t, p.pattern).Filter(p.refname),
+				)
 			},
 		)
 	}
@@ -82,11 +90,11 @@ func TestRegexpFilter(t *testing.T) {
 func TestIncludeExcludeFilter(t *testing.T) {
 	t.Parallel()
 
-	var filter git.IncludeExcludeFilter
-	filter.Include(git.PrefixFilter("refs/heads"))
-	filter.Exclude(regexpFilter(t, "refs/heads/.*foo.*"))
-	filter.Include(git.PrefixFilter("refs/remotes"))
-	filter.Exclude(git.PrefixFilter("refs/remotes/foo"))
+	var filter git.ReferenceFilter
+	filter = git.Include.Combine(filter, git.PrefixFilter("refs/heads"))
+	filter = git.Exclude.Combine(filter, regexpFilter(t, "refs/heads/.*foo.*"))
+	filter = git.Include.Combine(filter, git.PrefixFilter("refs/remotes"))
+	filter = git.Exclude.Combine(filter, git.PrefixFilter("refs/remotes/foo"))
 
 	for _, p := range []struct {
 		refname  string