Merge pull request #84 from github/ref-groups

Allow subsets of references to be defined via gitconfig

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)
+			},
+		)
+	}
+}