fix: Fixing hcl fmt with --stdin combined with --check and/or --diff (#6726)

* fix: Fixing `hcl fmt` with `--stdin` combined with `--check` and/or `--diff`

* chore: Fix-up due to dynamic anchors

Author: yhakbar

docs/src/data/changelog/v1.1.4/hcl-fmt-stdin-check-and-diff.mdx

@@ -0,0 +1,10 @@
+---
+version: "v1.1.4"
+category: "bug-fixes"
+---
+
+#### `hcl fmt --stdin` honors `--check` and `--diff`
+
+`terragrunt hcl fmt --stdin` ignored `--check` and `--diff`. It printed the reformatted HCL and exited 0 whether or not the input needed formatting.
+
+`--check` now exits with status code 1 when the input needs formatting, and `--diff` prints a unified diff labeled `old/stdin` and `new/stdin`. Neither flag prints the formatted content, so getting that content back means running `--stdin` without them.

docs/src/data/flags/hcl-fmt-stdin.mdx

@@ -13,3 +13,5 @@ Example:
 ```bash
 echo 'locals { foo="bar" }' | terragrunt hcl fmt --stdin
 ```
+
+With [`--check`](/reference/cli/commands/hcl/fmt#check) or [`--diff`](/reference/cli/commands/hcl/fmt#diff), Terragrunt does not print the formatted content. `--check` exits with status code 1 when the input needs formatting, and `--diff` prints a unified diff labeled `old/stdin` and `new/stdin`.

internal/cli/commands/hcl/format/errors.go

@@ -2,7 +2,7 @@ package format
 
 import "fmt"
 
-// FileNeedsFormattingError is an error that is returned when a file needs formatting.
+// FileNeedsFormattingError is returned when HCL input needs formatting.
 type FileNeedsFormattingError struct {
 	Path string
 }

internal/cli/commands/hcl/format/format.go

@@ -50,7 +50,7 @@ func Run(ctx context.Context, l log.Logger, v *venv.Venv, opts *options.Terragru
 			return errors.New("both stdin and path flags are specified")
 		}
 
-		return formatFromStdin(l, v)
+		return formatFromStdin(l, v, opts)
 	}
 
 	if targetFile != "" {
@@ -195,22 +195,42 @@ func RunForFiles(
 	return errors.Join(errs...)
 }
 
-func formatFromStdin(l log.Logger, v *venv.Venv) error {
+func formatFromStdin(l log.Logger, v *venv.Venv, opts *options.TerragruntOptions) error {
+	const stdinPath = "stdin"
+
 	contents, err := io.ReadAll(v.Stdin)
 	if err != nil {
 		l.Errorf("Error reading from stdin: %s", err)
 
 		return fmt.Errorf("error reading from stdin: %w", err)
 	}
 
-	if err = checkErrors(l, v, contents, "stdin"); err != nil {
+	if err = checkErrors(l, v, contents, stdinPath); err != nil {
 		l.Errorf("Error parsing hcl from stdin")
 
 		return fmt.Errorf("error parsing hcl from stdin: %w", err)
 	}
 
 	newContents := hclwrite.Format(contents)
 
+	needsFormatting := !bytes.Equal(newContents, contents)
+
+	if opts.Diff && needsFormatting {
+		if _, err := v.Writers.Writer.Write(bytesDiff(contents, newContents, stdinPath)); err != nil {
+			l.Errorf("Failed to print diff for stdin")
+
+			return err
+		}
+	}
+
+	if opts.Check && needsFormatting {
+		return &FileNeedsFormattingError{Path: stdinPath}
+	}
+
+	if opts.Diff || opts.Check {
+		return nil
+	}
+
 	buf := bufio.NewWriter(v.Writers.Writer)
 
 	if _, err = buf.Write(newContents); err != nil {

internal/cli/commands/hcl/format/format_test.go

@@ -286,22 +286,90 @@ func TestHCLFmtStdin(t *testing.T) {
 	unformatted := onDisk(t, "../../../../../test/fixtures/hclfmt-stdin/terragrunt.hcl")
 	expected := onDisk(t, "../../../../../test/fixtures/hclfmt-stdin/expected.hcl")
 
-	tgOptions, err := options.NewTerragruntOptionsForTest("")
-	require.NoError(t, err)
+	tests := map[string]struct {
+		input               string
+		wantStdout          string
+		wantDiffLines       []string
+		check               bool
+		diff                bool
+		wantNeedsFormatting bool
+	}{
+		"formatted content goes to stdout": {
+			input:      unformatted,
+			wantStdout: expected,
+		},
+		"check reports unformatted input": {
+			input:               unformatted,
+			check:               true,
+			wantNeedsFormatting: true,
+		},
+		"check accepts formatted input": {
+			input: expected,
+			check: true,
+		},
+		"diff shows what would change": {
+			input:         unformatted,
+			diff:          true,
+			wantDiffLines: []string{"--- old/stdin", "+++ new/stdin", "+  foo = \"bar\""},
+		},
+		"diff is empty for formatted input": {
+			input: expected,
+			diff:  true,
+		},
+		"check and diff both apply": {
+			input:               unformatted,
+			check:               true,
+			diff:                true,
+			wantDiffLines:       []string{"--- old/stdin", "+++ new/stdin"},
+			wantNeedsFormatting: true,
+		},
+	}
 
-	var formatted bytes.Buffer
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 
-	// format hcl from stdin
-	tgOptions.HclFromStdin = true
+			tgOptions, err := options.NewTerragruntOptionsForTest("")
+			require.NoError(t, err)
 
-	v := venvtest.New().
-		WithStdin(strings.NewReader(unformatted)).
-		WithWriter(&formatted)
+			tgOptions.HclFromStdin = true
+			tgOptions.Check = tc.check
+			tgOptions.Diff = tc.diff
 
-	err = format.Run(t.Context(), logger.CreateLogger(), v, tgOptions)
-	require.NoError(t, err)
+			var out bytes.Buffer
+
+			v := venvtest.New().
+				WithStdin(strings.NewReader(tc.input)).
+				WithWriter(&out)
+
+			err = format.Run(t.Context(), logger.CreateLogger(), v, tgOptions)
+
+			stdout := out.String()
 
-	assert.Equal(t, expected, formatted.String())
+			for _, want := range tc.wantDiffLines {
+				assert.Contains(t, stdout, want)
+			}
+
+			if len(tc.wantDiffLines) > 0 {
+				assert.NotContains(t, stdout, expected, "--diff prints the diff instead of the formatted content")
+			}
+
+			if len(tc.wantDiffLines) == 0 {
+				assert.Equal(t, tc.wantStdout, stdout)
+			}
+
+			if !tc.wantNeedsFormatting {
+				require.NoError(t, err)
+
+				return
+			}
+
+			var needsFormatting *format.FileNeedsFormattingError
+
+			require.ErrorAs(t, err, &needsFormatting)
+			assert.Equal(t, "stdin", needsFormatting.Path)
+		})
+	}
 }
 
 func TestHCLFmtHeredoc(t *testing.T) {