Make it possible to define reference groups via gitconfig

Add a way to define groups of reference names via gitconfig, using
include/exclude rules like those supported on the command line. This
allows gitconfig like

    [refgroup "normal"]
            include = refs/heads
            include = refs/tags
            excludeRegexp = refs/tags/release-.*

and then `git sizer --refgroup=normal`, to include "normal" branches
and tags but not release tags in the analysis.

Author: mhagger

git-sizer.go

@@ -63,6 +63,11 @@ const Usage = `usage: git-sizer [OPTS]
                                PREFIX (e.g., '--exclude=refs/changes')
       --exclude-regexp REGEXP  don't process references matching the specified
                                regular expression
+      --refgroup=NAME          process reference in group defined by gitconfig:
+                               'refgroup.NAME.include',
+                               'refgroup.NAME.includeRegexp',
+                               'refgroup.NAME.exclude', and
+                               'refgroup.NAME.excludeRegexp' as above.
       --show-refs              show which refs are being included/excluded
 
  Prefixes must match at a boundary; for example 'refs/foo' matches
@@ -178,6 +183,70 @@ func (v *filterValue) Type() string {
 	}
 }
 
+type filterGroupValue struct {
+	filter *git.IncludeExcludeFilter
+	repo   *git.Repository
+}
+
+func (v *filterGroupValue) Set(name string) error {
+	// At this point, it is not yet certain that the command was run
+	// inside a Git repository. If not, ignore this option (the
+	// command will error out anyway).
+	if v.repo == nil {
+		fmt.Fprintf(
+			os.Stderr,
+			"warning: not in Git repository; ignoring '--refgroup' option.\n",
+		)
+		return nil
+	}
+
+	config, err := v.repo.Config(fmt.Sprintf("refgroup.%s", name))
+	if err != nil {
+		return err
+	}
+	for _, entry := range config.Entries {
+		switch entry.Key {
+		case "include":
+			v.filter.Include(git.PrefixFilter(entry.Value))
+		case "includeregexp":
+			filter, err := git.RegexpFilter(entry.Value)
+			if err != nil {
+				return fmt.Errorf(
+					"invalid regular expression for 'refgroup.%s.%s': %w",
+					name, entry.Key, err,
+				)
+			}
+			v.filter.Include(filter)
+		case "exclude":
+			v.filter.Exclude(git.PrefixFilter(entry.Value))
+		case "excluderegexp":
+			filter, err := git.RegexpFilter(entry.Value)
+			if err != nil {
+				return fmt.Errorf(
+					"invalid regular expression for 'refgroup.%s.%s': %w",
+					name, entry.Key, err,
+				)
+			}
+			v.filter.Exclude(filter)
+		default:
+			// Ignore unrecognized keys.
+		}
+	}
+	return nil
+}
+
+func (v *filterGroupValue) Get() interface{} {
+	return nil
+}
+
+func (v *filterGroupValue) String() string {
+	return ""
+}
+
+func (v *filterGroupValue) Type() string {
+	return "name"
+}
+
 func main() {
 	err := mainImplementation(os.Args[1:])
 	if err != nil {
@@ -197,6 +266,13 @@ func mainImplementation(args []string) error {
 	var filter git.IncludeExcludeFilter
 	var showRefs bool
 
+	// Try to open the repository, but it's not an error yet if this
+	// fails, because the user might only be asking for `--help`.
+	repo, repoErr := git.NewRepository(".")
+	if repoErr == nil {
+		defer repo.Close()
+	}
+
 	flags := pflag.NewFlagSet("git-sizer", pflag.ContinueOnError)
 	flags.Usage = func() {
 		fmt.Print(Usage)
@@ -279,6 +355,11 @@ func mainImplementation(args []string) error {
 	)
 	flag.NoOptDefVal = "true"
 
+	flag = flags.VarPF(
+		&filterGroupValue{&filter, repo}, "refgroup", "",
+		"process references in refgroup defined by gitconfig",
+	)
+
 	flags.VarP(
 		sizes.NewThresholdFlagValue(&threshold, 0),
 		"verbose", "v", "report all statistics, whether concerning or not",
@@ -359,11 +440,9 @@ func mainImplementation(args []string) error {
 		return errors.New("excess arguments")
 	}
 
-	repo, err := git.NewRepository(".")
-	if err != nil {
-		return fmt.Errorf("couldn't open Git repository: %s", err)
+	if repoErr != nil {
+		return fmt.Errorf("couldn't open Git repository: %s", repoErr)
 	}
-	defer repo.Close()
 
 	if jsonOutput {
 		if !flags.Changed("json-version") {

git/gitconfig.go

@@ -2,10 +2,92 @@ package git
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"strconv"
+	"strings"
 )
 
+type ConfigEntry struct {
+	Key   string
+	Value string
+}
+
+type Config struct {
+	Entries []ConfigEntry
+}
+
+// Config returns the entries from gitconfig. If `prefix` is provided,
+// then only include entries in that section, which must match the at
+// a component boundary (as defined by `configKeyMatchesPrefix()`),
+// and strip off the prefix in the keys that are returned.
+func (repo *Repository) Config(prefix string) (*Config, error) {
+	cmd := repo.gitCommand("config", "--list", "-z")
+
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("reading git configuration: %w", err)
+	}
+
+	var config Config
+
+	for len(out) > 0 {
+		keyEnd := bytes.IndexByte(out, '\n')
+		if keyEnd == -1 {
+			return nil, errors.New("invalid output from 'git config'")
+		}
+		key := string(out[:keyEnd])
+		out = out[keyEnd+1:]
+		valueEnd := bytes.IndexByte(out, 0)
+		if valueEnd == -1 {
+			return nil, errors.New("invalid output from 'git config'")
+		}
+		value := string(out[:valueEnd])
+		out = out[valueEnd+1:]
+
+		ok, rest := configKeyMatchesPrefix(key, prefix)
+		if !ok {
+			continue
+		}
+
+		entry := ConfigEntry{
+			Key:   rest,
+			Value: value,
+		}
+		config.Entries = append(config.Entries, entry)
+	}
+
+	return &config, nil
+}
+
+// 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.:
+//
+//     configKeyMatchesPrefix("foo.bar", "foo") → true, "bar"
+//     configKeyMatchesPrefix("foo.bar", "foo.") → true, "bar"
+//     configKeyMatchesPrefix("foo.bar", "foo.bar") → true, ""
+//     configKeyMatchesPrefix("foo.bar", "foo.bar.") → false, ""
+func configKeyMatchesPrefix(key, prefix string) (bool, string) {
+	if prefix == "" {
+		return true, key
+	}
+	if !strings.HasPrefix(key, prefix) {
+		return false, ""
+	}
+
+	if prefix[len(prefix)-1] == '.' {
+		return true, key[len(prefix):]
+	}
+	if len(key) == len(prefix) {
+		return true, ""
+	}
+	if key[len(prefix)] == '.' {
+		return true, key[len(prefix)+1:]
+	}
+	return false, ""
+}
+
 func (repo *Repository) ConfigStringDefault(key string, defaultValue string) (string, error) {
 	cmd := repo.gitCommand(
 		"config",

git/gitconfig_test.go

@@ -0,0 +1,36 @@
+package git
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConfigKeyMatchesPrefix(t *testing.T) {
+	for _, p := range []struct {
+		key, prefix    string
+		expectedBool   bool
+		expectedString string
+	}{
+		{"foo.bar", "", true, "foo.bar"},
+		{"foo.bar", "foo", true, "bar"},
+		{"foo.bar", "foo.", true, "bar"},
+		{"foo.bar", "foo.bar", true, ""},
+		{"foo.bar", "foo.bar.", false, ""},
+		{"foo.bar", "foo.bar.baz", false, ""},
+		{"foo.bar", "foo.barbaz", false, ""},
+		{"foo.bar.baz", "foo.bar", true, "baz"},
+		{"foo.barbaz", "foo.bar", false, ""},
+		{"foo.bar", "bar", false, ""},
+	} {
+		t.Run(
+			fmt.Sprintf("TestConfigKeyMatchesPrefix(%q, %q)", p.key, p.prefix),
+			func(t *testing.T) {
+				ok, s := configKeyMatchesPrefix(p.key, p.prefix)
+				assert.Equal(t, p.expectedBool, ok)
+				assert.Equal(t, p.expectedString, s)
+			},
+		)
+	}
+}

git_sizer_test.go

@@ -193,22 +193,22 @@ func TestRefSelections(t *testing.T) {
 
 		refname string
 	}{
-		//          1111111
-		//01234567890123456
-		{"+ + + + + + +   +", "refs/barfoo"},
-		{"+ + + + + + +++  ", "refs/foo"},
-		{"+ + + + + + +   +", "refs/foobar"},
-		{"++  + + + +++   +", "refs/heads/foo"},
-		{"++  + + + ++    +", "refs/heads/master"},
-		{"+ + + ++  +      ", "refs/notes/discussion"},
-		{"+ + ++  + +      ", "refs/remotes/origin/master"},
-		{"+ + ++  + + +   +", "refs/remotes/upstream/foo"},
-		{"+ + ++  + +      ", "refs/remotes/upstream/master"},
-		{"+ + + + ++       ", "refs/stash"},
-		{"+ ++  + + +++   +", "refs/tags/foolish"},
-		{"+ ++  + + ++    +", "refs/tags/other"},
-		{"+ ++  + + ++   + ", "refs/tags/release-1"},
-		{"+ ++  + + ++   + ", "refs/tags/release-2"},
+		//          111111111
+		//0123456789012345678
+		{"+ + + + + + +   + +", "refs/barfoo"},
+		{"+ + + + + + +++    ", "refs/foo"},
+		{"+ + + + + + +   + +", "refs/foobar"},
+		{"++  + + + +++   +++", "refs/heads/foo"},
+		{"++  + + + ++    +++", "refs/heads/master"},
+		{"+ + + ++  +        ", "refs/notes/discussion"},
+		{"+ + ++  + +        ", "refs/remotes/origin/master"},
+		{"+ + ++  + + +   + +", "refs/remotes/upstream/foo"},
+		{"+ + ++  + +        ", "refs/remotes/upstream/master"},
+		{"+ + + + ++         ", "refs/stash"},
+		{"+ ++  + + +++   + +", "refs/tags/foolish"},
+		{"+ ++  + + ++    + +", "refs/tags/other"},
+		{"+ ++  + + ++   +   ", "refs/tags/release-1"},
+		{"+ ++  + + ++   +   ", "refs/tags/release-2"},
 	}
 
 	// computeExpectations assembles and returns the results expected
@@ -269,8 +269,9 @@ func TestRefSelections(t *testing.T) {
 	require.NoError(t, err)
 
 	for i, p := range []struct {
-		name string
-		args []string
+		name   string
+		args   []string
+		config [][2]string
 	}{
 		{ // 0
 			name: "no arguments",
@@ -346,10 +347,46 @@ func TestRefSelections(t *testing.T) {
 				"--exclude-regexp", "refs/tags/release-.*",
 			},
 		},
+		{ // 17
+			name: "branches-refgroup",
+			args: []string{"--refgroup=mygroup"},
+			config: [][2]string{
+				{"include", "refs/heads"},
+			},
+		},
+		{ // 18
+			name: "combination-refgroup",
+			args: []string{"--refgroup=mygroup"},
+			config: [][2]string{
+				{"include", "refs/heads"},
+				{"include", "refs/tags"},
+				{"exclude", "refs/heads/foo"},
+				{"includeRegexp", ".*foo.*"},
+				{"exclude", "refs/foo"},
+				{"excludeRegexp", "refs/tags/release-.*"},
+			},
+		},
 	} {
 		t.Run(
 			p.name,
 			func(t *testing.T) {
+				if len(p.config) != 0 {
+					for _, c := range p.config {
+						cmd := gitCommand(
+							t, path,
+							"config", "--add", fmt.Sprintf("refgroup.mygroup.%s", c[0]), c[1],
+						)
+						err := cmd.Run()
+						require.NoError(t, err)
+					}
+					defer func() {
+						cmd := gitCommand(
+							t, path, "config", "--remove-section", "refgroup.mygroup",
+						)
+						err := cmd.Run()
+						require.NoError(t, err)
+					}()
+				}
 				args := []string{"--show-refs", "--no-progress", "--json", "--json-version=2"}
 				args = append(args, p.args...)
 				cmd := exec.Command(executable, args...)