internal/refopts: new package

Move some reference option related code to a separate internal
package.

Author: mhagger

git-sizer.go

@@ -9,11 +9,12 @@ import (
 	"runtime/pprof"
 	"strconv"
 
+	"github.com/spf13/pflag"
+
 	"github.com/github/git-sizer/git"
+	"github.com/github/git-sizer/internal/refopts"
 	"github.com/github/git-sizer/isatty"
 	"github.com/github/git-sizer/sizes"
-
-	"github.com/spf13/pflag"
 )
 
 const Usage = `usage: git-sizer [OPTS]
@@ -79,150 +80,6 @@ const Usage = `usage: git-sizer [OPTS]
 var ReleaseVersion string
 var BuildVersion string
 
-type filterValue struct {
-	// filter is the filter that will be modified if this option
-	// is used.
-	filter *git.ReferenceFilter
-
-	// combiner specifies how the filter generated by this option
-	// is combined with the existing filter; i.e., does it cause
-	// the matching references to be included or excluded?
-	combiner git.Combiner
-
-	// pattern, if it is set, is the pattern (prefix or regexp) to
-	// be matched. If it is not set, then the user must supply the
-	// pattern.
-	pattern string
-
-	// regexp specifies whether `pattern` should be interpreted as
-	// a regexp (as opposed to a prefix).
-	regexp bool
-}
-
-func (v *filterValue) Set(s string) error {
-	var filter git.ReferenceFilter
-	combiner := v.combiner
-
-	var pattern string
-	if v.pattern != "" {
-		// The pattern is fixed for this option:
-		pattern = v.pattern
-
-		// It's not really expected, but if the user supplied a
-		// `false` boolean value, invert the polarity:
-		b, err := strconv.ParseBool(s)
-		if err != nil {
-			return err
-		}
-		if !b {
-			combiner = combiner.Inverted()
-		}
-	} else {
-		// The user must supply the pattern.
-		pattern = s
-	}
-
-	if v.regexp {
-		var err error
-		filter, err = git.RegexpFilter(pattern)
-		if err != nil {
-			return fmt.Errorf("invalid regexp: %q", s)
-		}
-	} else {
-		filter = git.PrefixFilter(pattern)
-	}
-
-	*v.filter = combiner.Combine(*v.filter, filter)
-
-	return nil
-}
-
-func (v *filterValue) Get() interface{} {
-	return nil
-}
-
-func (v *filterValue) String() string {
-	return ""
-}
-
-func (v *filterValue) Type() string {
-	if v.pattern != "" {
-		return "bool"
-	} else if v.regexp {
-		return "regexp"
-	} else {
-		return "prefix"
-	}
-}
-
-type filterGroupValue struct {
-	filter *git.ReferenceFilter
-	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 = git.Include.Combine(
-				*v.filter, 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 = git.Include.Combine(*v.filter, filter)
-		case "exclude":
-			*v.filter = git.Exclude.Combine(
-				*v.filter, 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 = git.Exclude.Combine(*v.filter, 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 {
@@ -239,8 +96,6 @@ func mainImplementation(args []string) error {
 	var threshold sizes.Threshold = 1
 	var progress bool
 	var version bool
-	var filter git.ReferenceFilter
-	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`.
@@ -254,88 +109,6 @@ func mainImplementation(args []string) error {
 		fmt.Print(Usage)
 	}
 
-	flags.Var(
-		&filterValue{&filter, git.Include, "", false}, "include",
-		"include specified references",
-	)
-	flags.Var(
-		&filterValue{&filter, git.Include, "", true}, "include-regexp",
-		"include references matching the specified regular expression",
-	)
-	flags.Var(
-		&filterValue{&filter, git.Exclude, "", false}, "exclude",
-		"exclude specified references",
-	)
-	flags.Var(
-		&filterValue{&filter, git.Exclude, "", true}, "exclude-regexp",
-		"exclude references matching the specified regular expression",
-	)
-
-	flag := flags.VarPF(
-		&filterValue{&filter, git.Include, "refs/heads", false}, "branches", "",
-		"process all branches",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Exclude, "refs/heads", false}, "no-branches", "",
-		"exclude all branches",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Include, "refs/tags", false}, "tags", "",
-		"process all tags",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Exclude, "refs/tags", false}, "no-tags", "",
-		"exclude all tags",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Include, "refs/remotes", false}, "remotes", "",
-		"process all remote-tracking references",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Exclude, "refs/remotes", false}, "no-remotes", "",
-		"exclude all remote-tracking references",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Include, "refs/notes", false}, "notes", "",
-		"process all git-notes references",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Exclude, "refs/notes", false}, "no-notes", "",
-		"exclude all git-notes references",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Include, "refs/stash", true}, "stash", "",
-		"process refs/stash",
-	)
-	flag.NoOptDefVal = "true"
-
-	flag = flags.VarPF(
-		&filterValue{&filter, git.Exclude, "refs/stash", true}, "no-stash", "",
-		"exclude refs/stash",
-	)
-	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",
@@ -376,14 +149,20 @@ func mainImplementation(args []string) error {
 		atty = false
 	}
 	flags.BoolVar(&progress, "progress", atty, "report progress to stderr")
-	flags.BoolVar(&showRefs, "show-refs", false, "list the references being processed")
 	flags.BoolVar(&version, "version", false, "report the git-sizer version number")
 	flags.Var(&NegatedBoolValue{&progress}, "no-progress", "suppress progress output")
 	flags.Lookup("no-progress").NoOptDefVal = "true"
 
 	flags.StringVar(&cpuprofile, "cpuprofile", "", "write cpu profile to file")
 	flags.MarkHidden("cpuprofile")
 
+	var rgb refopts.RefGroupBuilder
+	var configger refopts.Configger
+	if repo != nil {
+		configger = repo
+	}
+	rgb.AddRefopts(flags, configger)
+
 	flags.SortFlags = false
 
 	err = flags.Parse(args)
@@ -469,20 +248,12 @@ func mainImplementation(args []string) error {
 		progress = v
 	}
 
-	if filter == nil {
-		filter = git.AllReferencesFilter
-	}
-
-	if showRefs {
-		fmt.Fprintf(os.Stderr, "References (included references marked with '+'):\n")
-		filter = showRefFilter{filter}
-	}
-
-	rg := refGrouper{
-		filter: filter,
+	rg, err := rgb.Finish()
+	if err != nil {
+		return err
 	}
 
-	historySize, err := sizes.ScanRepositoryUsingGraph(repo, &rg, nameStyle, progress)
+	historySize, err := sizes.ScanRepositoryUsingGraph(repo, rg, nameStyle, progress)
 	if err != nil {
 		return fmt.Errorf("error scanning repository: %s", err)
 	}
@@ -511,29 +282,3 @@ func mainImplementation(args []string) error {
 
 	return nil
 }
-
-type refGrouper struct {
-	filter git.ReferenceFilter
-}
-
-func (rg *refGrouper) Categorize(refname string) (bool, []sizes.RefGroupSymbol) {
-	return rg.filter.Filter(refname), nil
-}
-
-func (rg *refGrouper) Groups() []sizes.RefGroup {
-	return nil
-}
-
-type showRefFilter struct {
-	f git.ReferenceFilter
-}
-
-func (f showRefFilter) Filter(refname string) bool {
-	b := f.f.Filter(refname)
-	if b {
-		fmt.Fprintf(os.Stderr, "+ %s\n", refname)
-	} else {
-		fmt.Fprintf(os.Stderr, "  %s\n", refname)
-	}
-	return b
-}