formatter_test.go

package fracturedjson

import (
	"encoding/json"
	"os"
	"path/filepath"
	"testing"
)

type fileCase struct {
	Name    string      `json:"name"`
	Before  string      `json:"before"`
	After   string      `json:"after"`
	Options caseOptions `json:"options"`
}

type caseOptions struct {
	MaxTotalLineLength         *int   `json:"maxTotalLineLength"`
	MaxInlineComplexity        *int   `json:"maxInlineComplexity"`
	MaxTableRowComplexity      *int   `json:"maxTableRowComplexity"`
	AlwaysExpandDepth          *int   `json:"alwaysExpandDepth"`
	SimpleBracketPadding       *bool  `json:"simpleBracketPadding"`
	ColonBeforePropNamePadding *bool  `json:"colonBeforePropNamePadding"`
	AllowTrailingCommas        *bool  `json:"allowTrailingCommas"`
	PreserveBlankLines         *bool  `json:"preserveBlankLines"`
	CommentPolicy              string `json:"commentPolicy"`
	NumberListAlignment        string `json:"numberListAlignment"`
	JSONEolStyle               string `json:"jsonEolStyle"`
}

func TestWikiGoldenCases(t *testing.T) {
	casesPath := filepath.Join("testdata", "cases.json")
	rawCases, err := os.ReadFile(casesPath)
	if err != nil {
		t.Fatalf("failed to read %s: %v", casesPath, err)
	}

	var cases []fileCase
	if err := json.Unmarshal(rawCases, &cases); err != nil {
		t.Fatalf("failed to parse %s: %v", casesPath, err)
	}

	for _, tc := range cases {
		tc := tc
		t.Run(tc.Name, func(t *testing.T) {
			beforePath := filepath.Join("testdata", tc.Before)
			afterPath := filepath.Join("testdata", tc.After)

			before, err := os.ReadFile(beforePath)
			if err != nil {
				t.Fatalf("failed to read %s: %v", beforePath, err)
			}
			expected, err := os.ReadFile(afterPath)
			if err != nil {
				t.Fatalf("failed to read %s: %v", afterPath, err)
			}

			f := NewFormatter()
			applyCaseOptions(&f.Options, tc.Options)

			out, err := f.Reformat(string(before), 0)
			if err != nil {
				t.Fatalf("reformat failed: %v", err)
			}

			exp := string(expected)
			if out != exp && out+"\n" != exp {
				if !(f.Options.CommentPolicy == CommentPreserve && normalizeOutsideStrings(out) == normalizeOutsideStrings(exp)) {
					t.Fatalf("output mismatch\nexpected:\n%s\nactual:\n%s", exp, out+"\n")
				}
			}
		})
	}
}

func normalizeOutsideStrings(s string) string {
	b := make([]rune, 0, len(s))
	inString := false
	escaped := false
	for _, r := range s {
		if inString {
			b = append(b, r)
			if escaped {
				escaped = false
				continue
			}
			if r == '\\' {
				escaped = true
				continue
			}
			if r == '"' {
				inString = false
			}
			continue
		}

		if r == '"' {
			inString = true
			b = append(b, r)
			continue
		}

		if r == ' ' || r == '\t' || r == '\n' || r == '\r' {
			continue
		}
		b = append(b, r)
	}
	return string(b)
}

func applyCaseOptions(o *Options, c caseOptions) {
	if c.MaxTotalLineLength != nil {
		o.MaxTotalLineLength = *c.MaxTotalLineLength
	}
	if c.MaxInlineComplexity != nil {
		o.MaxInlineComplexity = *c.MaxInlineComplexity
	}
	if c.MaxTableRowComplexity != nil {
		o.MaxTableRowComplexity = *c.MaxTableRowComplexity
	}
	if c.AlwaysExpandDepth != nil {
		o.AlwaysExpandDepth = *c.AlwaysExpandDepth
	}
	if c.SimpleBracketPadding != nil {
		o.SimpleBracketPadding = *c.SimpleBracketPadding
	}
	if c.ColonBeforePropNamePadding != nil {
		o.ColonBeforePropNamePadding = *c.ColonBeforePropNamePadding
	}
	if c.AllowTrailingCommas != nil {
		o.AllowTrailingCommas = *c.AllowTrailingCommas
	}
	if c.PreserveBlankLines != nil {
		o.PreserveBlankLines = *c.PreserveBlankLines
	}

	switch c.CommentPolicy {
	case "preserve", "PRESERVE":
		o.CommentPolicy = CommentPreserve
	case "remove", "REMOVE":
		o.CommentPolicy = CommentRemove
	case "error", "ERROR", "treataserror", "TreatAsError", "":
		o.CommentPolicy = CommentTreatAsError
	}

	switch c.NumberListAlignment {
	case "left", "LEFT":
		o.NumberListAlignment = NumberLeft
	case "right", "RIGHT":
		o.NumberListAlignment = NumberRight
	case "decimal", "DECIMAL", "":
		o.NumberListAlignment = NumberDecimal
	case "normalize", "NORMALIZE":
		o.NumberListAlignment = NumberNormalize
	}

	switch c.JSONEolStyle {
	case "lf", "LF":
		o.JsonEolStyle = EolLF
	case "crlf", "CRLF":
		o.JsonEolStyle = EolCRLF
	case "default", "DEFAULT", "":
		o.JsonEolStyle = EolDefault
	}
}