git-sizer.go

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"os"
	"runtime/pprof"
	"strconv"
	"time"

	"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/meter"
	"github.com/github/git-sizer/sizes"
)

const usage = `usage: git-sizer [OPTS] [ROOT...]

 Scan objects in your Git repository and emit statistics about them.

      --threshold THRESHOLD    minimum level of concern (i.e., number of stars)
                               that should be reported. Default:
                               '--threshold=1'. Can be set via gitconfig:
                               'sizer.threshold'.
  -v, --verbose                report all statistics, whether concerning or
                               not; equivalent to '--threshold=0
      --no-verbose             equivalent to '--threshold=1'
      --critical               only report critical statistics; equivalent
                               to '--threshold=30'
      --names=[none|hash|full] display names of large objects in the specified
                               style. Values:
                               * 'none' - omit footnotes entirely
                               * 'hash' - show only the SHA-1s of objects
                               * 'full' - show full names
                               Default is '--names=full'. Can be set via
                               gitconfig: 'sizer.names'.
  -j, --json                   output results in JSON format
      --json-version=[1|2]     choose which JSON format version to output.
                               Default: --json-version=1. Can be set via
                               gitconfig: 'sizer.jsonVersion'.
      --[no-]progress          report (don't report) progress to stderr. Can
                               be set via gitconfig: 'sizer.progress'.
      --version                only report the git-sizer version number

 Object selection:

 git-sizer traverses through your Git history to find objects to
 process. By default, it processes all objects that are reachable from
 any reference. You can tell it to process only some of your
 references; see "Reference selection" below.

 If explicit ROOTs are specified on the command line, each one should
 be a string that 'git rev-parse' can convert into a single Git object
 ID, like 'main', 'main~:src', or an abbreviated SHA-1. See
 git-rev-parse(1) for details. In that case, git-sizer also treats
 those objects as starting points for its traversal, and also includes
 the Git objects that are reachable from those roots in the analysis.

 As a special case, if one or more ROOTs are specified on the command
 line but _no_ reference selection options, then _only_ the specified
 ROOTs are traversed, and no references.

 Reference selection:

 The following options can be used to limit which references to
 process. The last rule matching a reference determines whether that
 reference is processed.

      --[no-]branches          process [don't process] branches
      --[no-]tags              process [don't process] tags
      --[no-]remotes           process [don't process] remote-tracking
                               references
      --[no-]notes             process [don't process] git-notes references
      --[no-]stash             process [don't process] refs/stash
      --include PREFIX, --exclude PREFIX
                               process [don't process] references with the
                               specified PREFIX (e.g.,
                               '--include=refs/remotes/origin')
      --include /REGEXP/, --exclude /REGEXP/
                               process [don't process] references matching the
                               specified regular expression (e.g.,
                               '--include=refs/tags/release-.*')
      --include @REFGROUP, --exclude @REFGROUP
                               process [don't process] references in the
                               specified reference group (see below)
      --show-refs              show which refs are being included/excluded

 PREFIX must match at a boundary; for example 'refs/foo' matches
 'refs/foo' and 'refs/foo/bar' but not 'refs/foobar'.

 REGEXP patterns must match the full reference name.

 REFGROUP can be the name of a predefined reference group ('branches',
 'tags', 'remotes', 'pulls', 'changes', 'notes', or 'stash'), or one
 defined via gitconfig settings like the following (the
 include/exclude settings can be repeated):

   * 'refgroup.REFGROUP.name=NAME'
   * 'refgroup.REFGROUP.include=PREFIX'
   * 'refgroup.REFGROUP.includeRegexp=REGEXP'
   * 'refgroup.REFGROUP.exclude=PREFIX'
   * 'refgroup.REFGROUP.excludeRegexp=REGEXP'

`

var ReleaseVersion string
var BuildVersion string

func main() {
	ctx := context.Background()

	err := mainImplementation(ctx, os.Stdout, os.Stderr, os.Args[1:])
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: %s\n", err)
		os.Exit(1)
	}
}

func mainImplementation(ctx context.Context, stdout, stderr io.Writer, args []string) error {
	var nameStyle sizes.NameStyle = sizes.NameStyleFull
	var cpuprofile string
	var jsonOutput bool
	var jsonVersion int
	var threshold sizes.Threshold = 1
	var progress bool
	var version bool
	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.NewRepositoryFromPath(".")

	flags := pflag.NewFlagSet("git-sizer", pflag.ContinueOnError)
	flags.Usage = func() {
		fmt.Fprint(stdout, usage)
	}

	flags.VarP(
		sizes.NewThresholdFlagValue(&threshold, 0),
		"verbose", "v", "report all statistics, whether concerning or not",
	)
	flags.Lookup("verbose").NoOptDefVal = "true"

	flags.Var(
		sizes.NewThresholdFlagValue(&threshold, 1),
		"no-verbose", "report statistics that are at all concerning",
	)
	flags.Lookup("no-verbose").NoOptDefVal = "true"

	flags.Var(
		&threshold, "threshold",
		"minimum level of concern (i.e., number of stars) that should be\n"+
			"                              reported",
	)

	flags.Var(
		sizes.NewThresholdFlagValue(&threshold, 30),
		"critical", "only report critical statistics",
	)
	flags.Lookup("critical").NoOptDefVal = "true"

	flags.Var(
		&nameStyle, "names",
		"display names of large objects in the specified `style`:\n"+
			"        --names=none            omit footnotes entirely\n"+
			"        --names=hash            show only the SHA-1s of objects\n"+
			"        --names=full            show full names",
	)

	flags.BoolVarP(&jsonOutput, "json", "j", false, "output results in JSON format")
	flags.IntVar(&jsonVersion, "json-version", 1, "JSON format version to output (1 or 2)")

	defaultProgress := false
	if f, ok := stderr.(*os.File); ok {
		atty, err := isatty.Isatty(f.Fd())
		if err == nil && atty {
			defaultProgress = true
		}
	}

	flags.BoolVar(&progress, "progress", defaultProgress, "report progress to stderr")
	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")
	if err := flags.MarkHidden("cpuprofile"); err != nil {
		return fmt.Errorf("marking option hidden: %w", err)
	}

	var configger refopts.Configger
	if repo != nil {
		configger = repo
	}

	rgb, err := refopts.NewRefGroupBuilder(configger)
	if err != nil {
		return err
	}

	rgb.AddRefopts(flags)

	flags.BoolVar(&showRefs, "show-refs", false, "list the references being processed")

	flags.SortFlags = false

	err = flags.Parse(args)
	if err != nil {
		if errors.Is(err, pflag.ErrHelp) {
			return nil
		}
		return err
	}

	if cpuprofile != "" {
		f, err := os.Create(cpuprofile)
		if err != nil {
			return fmt.Errorf("couldn't set up cpuprofile file: %w", err)
		}
		if err := pprof.StartCPUProfile(f); err != nil {
			return fmt.Errorf("starting CPU profiling: %w", err)
		}
		defer pprof.StopCPUProfile()
	}

	if version {
		if ReleaseVersion != "" {
			fmt.Fprintf(stdout, "git-sizer release %s\n", ReleaseVersion)
		} else {
			fmt.Fprintf(stdout, "git-sizer build %s\n", BuildVersion)
		}
		return nil
	}

	if repoErr != nil {
		return fmt.Errorf("couldn't open Git repository: %w", repoErr)
	}

	if jsonOutput {
		if !flags.Changed("json-version") {
			v, err := repo.ConfigIntDefault("sizer.jsonVersion", jsonVersion)
			if err != nil {
				return err
			}
			jsonVersion = v
			if !(jsonVersion == 1 || jsonVersion == 2) {
				return fmt.Errorf("JSON version (read from gitconfig) must be 1 or 2")
			}
		} else if !(jsonVersion == 1 || jsonVersion == 2) {
			return fmt.Errorf("JSON version must be 1 or 2")
		}
	}

	if !flags.Changed("threshold") &&
		!flags.Changed("verbose") &&
		!flags.Changed("no-verbose") &&
		!flags.Changed("critical") {
		s, err := repo.ConfigStringDefault("sizer.threshold", fmt.Sprintf("%g", threshold))
		if err != nil {
			return err
		}
		v, err := strconv.ParseFloat(s, 64)
		if err != nil {
			return fmt.Errorf("parsing gitconfig value for 'sizer.threshold': %w", err)
		}
		threshold = sizes.Threshold(v)
	}

	if !flags.Changed("names") {
		s, err := repo.ConfigStringDefault("sizer.names", "full")
		if err != nil {
			return err
		}
		err = nameStyle.Set(s)
		if err != nil {
			return fmt.Errorf("parsing gitconfig value for 'sizer.names': %w", err)
		}
	}

	if !flags.Changed("progress") && !flags.Changed("no-progress") {
		v, err := repo.ConfigBoolDefault("sizer.progress", progress)
		if err != nil {
			return fmt.Errorf("parsing gitconfig value for 'sizer.progress': %w", err)
		}
		progress = v
	}

	rg, err := rgb.Finish(len(flags.Args()) == 0)
	if err != nil {
		return err
	}

	if showRefs {
		fmt.Fprintf(stderr, "References (included references marked with '+'):\n")
		rg = refopts.NewShowRefGrouper(rg, stderr)
	}

	var progressMeter meter.Progress = meter.NoProgressMeter
	if progress {
		progressMeter = meter.NewProgressMeter(stderr, 100*time.Millisecond)
	}

	refRoots, err := sizes.CollectReferences(ctx, repo, rg)
	if err != nil {
		return fmt.Errorf("determining which reference to scan: %w", err)
	}

	roots := make([]sizes.Root, 0, len(refRoots)+len(flags.Args()))
	for _, refRoot := range refRoots {
		roots = append(roots, refRoot)
	}

	for _, arg := range flags.Args() {
		oid, err := repo.ResolveObject(arg)
		if err != nil {
			return fmt.Errorf("resolving command-line argument %q: %w", arg, err)
		}
		roots = append(roots, sizes.NewExplicitRoot(arg, oid))
	}

	historySize, err := sizes.ScanRepositoryUsingGraph(
		ctx, repo, roots, nameStyle, progressMeter,
	)
	if err != nil {
		return fmt.Errorf("error scanning repository: %w", err)
	}

	if jsonOutput {
		var j []byte
		var err error
		switch jsonVersion {
		case 1:
			j, err = json.MarshalIndent(historySize, "", "    ")
		case 2:
			j, err = historySize.JSON(rg.Groups(), threshold, nameStyle)
		default:
			return fmt.Errorf("JSON version must be 1 or 2")
		}
		if err != nil {
			return fmt.Errorf("could not convert %v to json: %w", historySize, err)
		}
		fmt.Fprintf(stdout, "%s\n", j)
	} else {
		if _, err := io.WriteString(
			stdout, historySize.TableString(rg.Groups(), threshold, nameStyle),
		); err != nil {
			return fmt.Errorf("writing output: %w", err)
		}
	}

	return nil
}