Add chaining methods to formatter for customizable indentation (#248)

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: git-hulk <4987594+git-hulk@users.noreply.github.com>

Author: Copilot

parser/format.go

@@ -21,25 +21,35 @@ type Formatter struct {
 	mode        FormatMode
 	indentLevel int
 	lineStart   bool
+	indent      string
 }
 
 func NewFormatter() *Formatter {
 	return &Formatter{
 		mode:      FormatModeCompact,
 		lineStart: true,
+		indent:    "  ",
 	}
 }
 
-func (f *Formatter) WithBeautify() {
+func (f *Formatter) WithBeautify() *Formatter {
 	f.mode = FormatModeBeautify
+	return f
+}
+
+// WithIndent sets the indentation string used when beautifying SQL.
+// The indent parameter should not be empty to maintain proper formatting.
+func (f *Formatter) WithIndent(indent string) *Formatter {
+	f.indent = indent
+	return f
 }
 
 func (f *Formatter) writeIndentIfNeeded() {
 	if !f.lineStart {
 		return
 	}
 	for i := 0; i < f.indentLevel; i++ {
-		f.builder.WriteString("  ")
+		f.builder.WriteString(f.indent)
 	}
 	f.lineStart = false
 }

parser/format_test.go

@@ -0,0 +1,73 @@
+package parser
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestFormatter_WithBeautify_Chaining(t *testing.T) {
+	// Test that WithBeautify returns the formatter for chaining
+	formatter := NewFormatter().WithBeautify()
+	require.NotNil(t, formatter)
+	require.Equal(t, FormatModeBeautify, formatter.mode)
+}
+
+func TestFormatter_WithIndent_Chaining(t *testing.T) {
+	// Test that WithIndent returns the formatter for chaining
+	formatter := NewFormatter().WithIndent("    ")
+	require.NotNil(t, formatter)
+	require.Equal(t, "    ", formatter.indent)
+}
+
+func TestFormatter_ChainedMethods(t *testing.T) {
+	// Test that methods can be chained together
+	formatter := NewFormatter().WithBeautify().WithIndent("\t")
+	require.NotNil(t, formatter)
+	require.Equal(t, FormatModeBeautify, formatter.mode)
+	require.Equal(t, "\t", formatter.indent)
+}
+
+func TestFormatter_WithIndent_CustomIndentation(t *testing.T) {
+	// Test actual formatting with custom indent using parsed SQL
+	sql := "SELECT col1, col2 FROM table1 WHERE col1 > 10"
+
+	parser := NewParser(sql)
+	stmts, err := parser.ParseStmts()
+	require.NoError(t, err)
+	require.Len(t, stmts, 1)
+
+	// Test with default 2-space indent
+	formatter1 := NewFormatter().WithBeautify()
+	formatter1.WriteExpr(stmts[0])
+	result1 := formatter1.String()
+
+	// Test with 4-space indent
+	formatter2 := NewFormatter().WithBeautify().WithIndent("    ")
+	formatter2.WriteExpr(stmts[0])
+	result2 := formatter2.String()
+
+	// Test with tab indent
+	formatter3 := NewFormatter().WithBeautify().WithIndent("\t")
+	formatter3.WriteExpr(stmts[0])
+	result3 := formatter3.String()
+
+	// Verify all results are different (due to different indentation)
+	require.NotEqual(t, result1, result2)
+	require.NotEqual(t, result1, result3)
+	require.NotEqual(t, result2, result3)
+
+	// Verify they all contain the basic SQL keywords
+	require.Contains(t, result1, "SELECT")
+	require.Contains(t, result2, "SELECT")
+	require.Contains(t, result3, "SELECT")
+	require.Contains(t, result1, "FROM")
+	require.Contains(t, result2, "FROM")
+	require.Contains(t, result3, "FROM")
+}
+
+func TestFormatter_DefaultIndent(t *testing.T) {
+	// Test that default indent is 2 spaces
+	formatter := NewFormatter()
+	require.Equal(t, "  ", formatter.indent)
+}