Add options for seeing which files were formatted (#249)

* Add options for seeing which files were formatted

This PR adds two features for keeping track of which files were edited
by yamlfmt:

`-verbose`, `-v`: When formatting with verbose mode on, the modified
paths will be printed.

`-debug diffs`: When formatting with `diffs` debug code, all formatting
diffs will be printed.

Additionally:

* Fixed the `tempfile` bug that wouldn't replicate subdirectories
  properly
* Added `-q` short version of the `-quiet` flag

* fix integration tests

Author: braydonk

Makefile

@@ -41,7 +41,7 @@ integrationtest_stdout:
 .PHONY: integrationtest_update
 integrationtest_update:
 	$(MAKE) build
-	go test -tags=integration_test ./integrationtest/command -update
+	go test -tags=integration_test -v ./integrationtest/command -update
 
 .PHONY: command_test_case
 command_test_case:

cmd/yamlfmt/flags.go

@@ -37,6 +37,9 @@ operation without performing it.`)
 	flagPrintConf         *bool   = flag.Bool("print_conf", false, "Print config")
 	flagDoublestar        *bool   = flag.Bool("dstar", false, "Use doublestar globs for include and exclude")
 	flagQuiet             *bool   = flag.Bool("quiet", false, "Print minimal output to stdout")
+	flagQuietShort        *bool   = flag.Bool("q", false, "Print minimal output to stdout")
+	flagVerbose           *bool   = flag.Bool("verbose", false, "Print additional output to stdout.")
+	flagVerboseShort      *bool   = flag.Bool("v", false, "Print additional output to stdout.")
 	flagContinueOnError   *bool   = flag.Bool("continue_on_error", false, "Continue to format files that didn't fail instead of exiting with code 1.")
 	flagGitignoreExcludes *bool   = flag.Bool("gitignore_excludes", false, "Use a gitignore file for excludes")
 	flagGitignorePath     *string = flag.String("gitignore_path", ".gitignore", "Path to gitignore file to use")

cmd/yamlfmt/main.go

@@ -55,7 +55,8 @@ func run() error {
 	c := &command.Command{
 		Operation: getOperationFromFlag(),
 		Registry:  getFullRegistry(),
-		Quiet:     *flagQuiet,
+		Quiet:     *flagQuiet || *flagQuietShort,
+		Verbose:   *flagVerbose || *flagVerboseShort,
 	}
 
 	configData := map[string]any{}

command/command.go

@@ -57,6 +57,7 @@ type Command struct {
 	Registry  *yamlfmt.Registry
 	Config    *Config
 	Quiet     bool
+	Verbose   bool
 }
 
 func (c *Command) Run() error {
@@ -74,6 +75,7 @@ func (c *Command) Run() error {
 		LineSepCharacter: lineSepChar,
 		Formatter:        formatter,
 		Quiet:            c.Quiet,
+		Verbose:          c.Verbose,
 		ContinueOnError:  c.Config.ContinueOnError,
 		OutputFormat:     c.Config.OutputFormat,
 	}

docs/command-usage.md

@@ -59,15 +59,16 @@ All flags must be specified **before** any path arguments.
 
 These flags adjust the command's mode of operation. All of these flags are booleans.
 
-| Name          | Flag          | Example                     | Description                                               |
-| :------------ | :------------ | :-------------------------- | :-------------------------------------------------------- |
-| Help          | `-help`       | `yamlfmt -help`             | Print the command usage information.                      |
-| Print Version | `-version`    | `yamlfmt -version`          | Print the yamlfmt version.                                |
-| Print Config  | `-print_conf` | `yamlfmt -print_conf`       | Print the merged configuration to use.                    |
-| Dry Run       | `-dry`        | `yamlfmt -dry .`            | Use [Dry Run](#dry-run) mode                              |
-| Lint          | `-lint`       | `yamlfmt -lint .`           | Use [Lint](#lint) mode                                    |
-| Quiet Mode    | `-quiet`      | `yamlfmt -dry -quiet .`     | Use quiet mode. Only has effect in Dry Run or Lint modes. |
-| Read Stdin    | `-in`         | `cat x.yaml \| yamlfmt -in` | Read input from stdin and output result to stdout.        |
+| Name          | Flag             | Example                     | Description                                               |
+| :------------ | :--------------- | :-------------------------- | :-------------------------------------------------------- |
+| Help          | `-help`          | `yamlfmt -help`             | Print the command usage information.                      |
+| Print Version | `-version`       | `yamlfmt -version`          | Print the yamlfmt version.                                |
+| Print Config  | `-print_conf`    | `yamlfmt -print_conf`       | Print the merged configuration to use.                    |
+| Dry Run       | `-dry`           | `yamlfmt -dry .`            | Use [Dry Run](#dry-run) mode                              |
+| Lint          | `-lint`          | `yamlfmt -lint .`           | Use [Lint](#lint) mode                                    |
+| Read Stdin    | `-in`            | `cat x.yaml \| yamlfmt -in` | Read input from stdin and output result to stdout.        |
+| Quiet Mode    | `-quiet`, `-q`   | `yamlfmt -dry -q .`         | Use quiet mode. Only has effect in Dry Run or Lint modes. |
+| Verbose Mode  | `-verbose`, `-v` | `yamlfmt -v .`              | Use verbose mode. Only has effect in Format mode.         |
 
 ### Configuration Flags
 
@@ -111,5 +112,7 @@ Debug logging can be enabled through the `-debug` [array flag](#string-array-fla
     - Log the details for the path discovery process. Use it to debug your include/exclude patterns.
 * `config`
     - Log the details for the configuration loading process. Use it to figure out which config file yamlfmt uses and why.
+* `diffs`
+    - Log each diff for all formatted files.
 * `all`
     - Enable all available debug codes.

engine.go

@@ -17,6 +17,7 @@ package yamlfmt
 import (
 	"fmt"
 	"os"
+	"slices"
 
 	"github.com/google/yamlfmt/internal/collections"
 	"github.com/google/yamlfmt/internal/multilinediff"
@@ -88,7 +89,9 @@ func (fds FileDiffs) Add(diff *FileDiff) error {
 
 func (fds FileDiffs) StrOutput() string {
 	result := ""
-	for _, fd := range fds {
+	sortedPaths := fds.sortedPaths()
+	for _, path := range sortedPaths {
+		fd := fds[path]
 		if fd.Diff.Changed() {
 			result += fd.StrOutput()
 		}
@@ -98,7 +101,9 @@ func (fds FileDiffs) StrOutput() string {
 
 func (fds FileDiffs) StrOutputQuiet() string {
 	result := ""
-	for _, fd := range fds {
+	sortedPaths := fds.sortedPaths()
+	for _, path := range sortedPaths {
+		fd := fds[path]
 		if fd.Diff.Changed() {
 			result += fd.StrOutputQuiet()
 		}
@@ -125,3 +130,12 @@ func (fds FileDiffs) ChangedCount() int {
 	}
 	return changed
 }
+
+func (fds FileDiffs) sortedPaths() []string {
+	pathKeys := []string{}
+	for path := range fds {
+		pathKeys = append(pathKeys, path)
+	}
+	slices.Sort(pathKeys)
+	return pathKeys
+}

engine/consecutive_engine.go

@@ -19,15 +19,17 @@ import (
 	"os"
 
 	"github.com/google/yamlfmt"
+	"github.com/google/yamlfmt/internal/logger"
 )
 
 // Engine that will process each file one by one consecutively.
 type ConsecutiveEngine struct {
 	LineSepCharacter string
 	Formatter        yamlfmt.Formatter
-	Quiet            bool
 	ContinueOnError  bool
 	OutputFormat     EngineOutputFormat
+	Quiet            bool
+	Verbose          bool
 }
 
 func (e *ConsecutiveEngine) FormatContent(content []byte) ([]byte, error) {
@@ -36,6 +38,13 @@ func (e *ConsecutiveEngine) FormatContent(content []byte) ([]byte, error) {
 
 func (e *ConsecutiveEngine) Format(paths []string) (fmt.Stringer, error) {
 	formatDiffs, formatErrs := e.formatAll(paths)
+
+	// Debug format diff output.
+	logger.Debug(
+		logger.DebugCodeDiffs,
+		fmt.Sprintf("The following files were modified:\n%s", formatDiffs.StrOutput()),
+	)
+
 	if len(formatErrs) > 0 {
 		if e.ContinueOnError {
 			fmt.Print(formatErrs)
@@ -44,7 +53,11 @@ func (e *ConsecutiveEngine) Format(paths []string) (fmt.Stringer, error) {
 			return nil, formatErrs
 		}
 	}
-	return nil, formatDiffs.ApplyAll()
+	applyErr := formatDiffs.ApplyAll()
+	if applyErr != nil {
+		return nil, applyErr
+	}
+	return getEngineOutput(e.OutputFormat, yamlfmt.OperationFormat, formatDiffs, e.Quiet, e.Verbose)
 }
 
 func (e *ConsecutiveEngine) Lint(paths []string) (fmt.Stringer, error) {
@@ -55,7 +68,7 @@ func (e *ConsecutiveEngine) Lint(paths []string) (fmt.Stringer, error) {
 	if formatDiffs.ChangedCount() == 0 {
 		return nil, nil
 	}
-	return getEngineOutput(e.OutputFormat, yamlfmt.OperationLint, formatDiffs, e.Quiet)
+	return getEngineOutput(e.OutputFormat, yamlfmt.OperationLint, formatDiffs, e.Quiet, e.Verbose)
 }
 
 func (e *ConsecutiveEngine) DryRun(paths []string) (fmt.Stringer, error) {
@@ -66,7 +79,7 @@ func (e *ConsecutiveEngine) DryRun(paths []string) (fmt.Stringer, error) {
 	if formatDiffs.ChangedCount() == 0 {
 		return nil, nil
 	}
-	return getEngineOutput(e.OutputFormat, yamlfmt.OperationDry, formatDiffs, e.Quiet)
+	return getEngineOutput(e.OutputFormat, yamlfmt.OperationDry, formatDiffs, e.Quiet, e.Verbose)
 }
 
 func (e *ConsecutiveEngine) formatAll(paths []string) (yamlfmt.FileDiffs, FormatErrors) {

engine/output.go

@@ -32,10 +32,10 @@ const (
 	EngineOutputGitlab    EngineOutputFormat = "gitlab"
 )
 
-func getEngineOutput(t EngineOutputFormat, operation yamlfmt.Operation, files yamlfmt.FileDiffs, quiet bool) (fmt.Stringer, error) {
+func getEngineOutput(t EngineOutputFormat, operation yamlfmt.Operation, files yamlfmt.FileDiffs, quiet bool, verbose bool) (fmt.Stringer, error) {
 	switch t {
 	case EngineOutputDefault:
-		return engineOutput{Operation: operation, Files: files, Quiet: quiet}, nil
+		return engineOutput{Operation: operation, Files: files, Quiet: quiet, Verbose: verbose}, nil
 	case EngineOutputSingeLine:
 		return engineOutputSingleLine{Operation: operation, Files: files, Quiet: quiet}, nil
 	case EngineOutputGitlab:
@@ -49,11 +49,21 @@ type engineOutput struct {
 	Operation yamlfmt.Operation
 	Files     yamlfmt.FileDiffs
 	Quiet     bool
+	Verbose   bool
 }
 
 func (eo engineOutput) String() string {
 	var msg string
 	switch eo.Operation {
+	case yamlfmt.OperationFormat:
+		// Formatting only produces output in verbose mode.
+		if !eo.Verbose {
+			return ""
+		}
+
+		msg = "The following files were modified:\n"
+		msg += eo.Files.StrOutputQuiet()
+		return msg
 	case yamlfmt.OperationLint:
 		msg = "The following formatting differences were found:"
 		if eo.Quiet {
@@ -65,7 +75,7 @@ func (eo engineOutput) String() string {
 				msg = "The following files would be formatted:"
 			}
 		} else {
-			return "No files will formatted."
+			return "No files will be formatted."
 		}
 	}
 	var result string

integrationtest/command/command_test.go

@@ -187,3 +187,19 @@ func TestForceFlowStyle(t *testing.T) {
 		Update:  *updateFlag,
 	}.Run(t)
 }
+
+func TestVerboseFormat(t *testing.T) {
+	TestCase{
+		Dir:     "verbose_format",
+		Command: yamlfmtWithArgs("-v ."),
+		Update:  *updateFlag,
+	}.Run(t)
+}
+
+func TestDebugDiffs(t *testing.T) {
+	TestCase{
+		Dir:     "debug_diffs",
+		Command: yamlfmtWithArgs("-debug diffs ."),
+		Update:  *updateFlag,
+	}.Run(t)
+}

integrationtest/command/testcase.go

@@ -29,8 +29,8 @@ import (
 )
 
 const (
-	stdoutGoldenFile = "stdout.txt"
-	stderrGoldenFile = "stderr.txt"
+	stdoutGoldenFileName = "stdout.txt"
+	stderrGoldenFileName = "stderr.txt"
 )
 
 type TestCase struct {
@@ -39,6 +39,8 @@ type TestCase struct {
 	IsError    bool
 	Update     bool
 	ShowStdout bool
+
+	tempDir string
 }
 
 func (tc TestCase) Run(t *testing.T) {
@@ -48,16 +50,16 @@ func (tc TestCase) Run(t *testing.T) {
 
 func (tc TestCase) run(t *testing.T) {
 	// Replicate the "before" directory in the test temp directory.
-	tempDir := t.TempDir()
-	paths, err := tempfile.ReplicateDirectory(tc.testFolderBeforePath(), tempDir)
+	tc.tempDir = t.TempDir()
+	paths, err := tempfile.ReplicateDirectory(tc.testFolderBeforePath(), tc.tempDir)
 	assert.NilErr(t, err)
 	err = paths.CreateAll()
 	assert.NilErr(t, err)
 
 	// Run the command for the test in the temp directory.
 	var stdoutBuf bytes.Buffer
 	var stderrBuf bytes.Buffer
-	cmd := tc.command(tempDir, &stdoutBuf, &stderrBuf)
+	cmd := tc.command(&stdoutBuf, &stderrBuf)
 	err = cmd.Run()
 	if tc.IsError {
 		assert.NotNilErr(t, err)
@@ -71,15 +73,15 @@ func (tc TestCase) run(t *testing.T) {
 	assert.NilErr(t, err)
 	err = tc.goldenStderr(stderrBuf.Bytes())
 	assert.NilErr(t, err)
-	err = tc.goldenAfter(tempDir)
+	err = tc.goldenAfter(tc.tempDir)
 	assert.NilErr(t, err)
 }
 
 func (tc TestCase) testFolderBeforePath() string {
 	return tc.testdataDirPath() + "/before"
 }
 
-func (tc TestCase) command(wd string, stdoutBuf *bytes.Buffer, stderrBuf *bytes.Buffer) *exec.Cmd {
+func (tc TestCase) command(stdoutBuf *bytes.Buffer, stderrBuf *bytes.Buffer) *exec.Cmd {
 	cmdArgs := []string{}
 	for _, arg := range strings.Split(tc.Command, " ") {
 		// This is to handle potential typos in args with extra spaces.
@@ -92,7 +94,7 @@ func (tc TestCase) command(wd string, stdoutBuf *bytes.Buffer, stderrBuf *bytes.
 		Args:   cmdArgs,    // Args needs to be an array of everything including the command
 		Stdout: stdoutBuf,
 		Stderr: stderrBuf,
-		Dir:    wd,
+		Dir:    tc.tempDir,
 	}
 }
 
@@ -102,10 +104,14 @@ func (tc TestCase) goldenStdout(stdoutResult []byte) error {
 		return nil
 	}
 	goldenCtx := tempfile.GoldenCtx{
-		Dir:    tc.testFolderStdoutPath(),
-		Update: tc.Update,
+		GoldenDir: tc.testFolderStdoutPath(),
+		ResultDir: tc.tempDir,
+		Update:    tc.Update,
 	}
-	return goldenCtx.CompareGoldenFile(stdoutGoldenFile, stdoutResult)
+	return goldenCtx.CompareGoldenFile(
+		filepath.Join(tc.tempDir, stdoutGoldenFileName),
+		stdoutResult,
+	)
 }
 
 func (tc TestCase) goldenStderr(stderrResult []byte) error {
@@ -114,16 +120,21 @@ func (tc TestCase) goldenStderr(stderrResult []byte) error {
 		return nil
 	}
 	goldenCtx := tempfile.GoldenCtx{
-		Dir:    tc.testFolderStdoutPath(),
-		Update: tc.Update,
+		GoldenDir: tc.testFolderStdoutPath(),
+		ResultDir: tc.tempDir,
+		Update:    tc.Update,
 	}
-	return goldenCtx.CompareGoldenFile(stderrGoldenFile, stderrResult)
+	return goldenCtx.CompareGoldenFile(
+		filepath.Join(tc.tempDir, stderrGoldenFileName),
+		stderrResult,
+	)
 }
 
 func (tc TestCase) goldenAfter(wd string) error {
 	goldenCtx := tempfile.GoldenCtx{
-		Dir:    tc.testFolderAfterPath(),
-		Update: tc.Update,
+		GoldenDir: tc.testFolderAfterPath(),
+		ResultDir: tc.tempDir,
+		Update:    tc.Update,
 	}
 	return goldenCtx.CompareDirectory(wd)
 }