node.go

package fracturedjson

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"strings"
)

// Kind is the kind of JSON node.
type Kind int

const (
	KindNull Kind = iota
	KindBool
	KindNumber
	KindString
	KindArray
	KindObject
)

// Member is one object property in input order.
type Member struct {
	Name  string
	Value *Node
}

// Node is an ordered JSON AST used by the formatter.
type Node struct {
	Kind       Kind
	Bool       bool
	Number     string
	String     string
	Array      []*Node
	Object     []Member
	Complexity int
}

type parseMeta struct {
	Comments       []string
	LeadingBlanks  int
	TrailingBlanks int
}

func parseJSON(input string, opts Options) (*Node, parseMeta, error) {
	clean, meta, err := preprocessJSONInput(input, opts)
	if err != nil {
		return nil, parseMeta{}, err
	}

	dec := json.NewDecoder(strings.NewReader(clean))
	dec.UseNumber()

	n, err := parseValue(dec)
	if err != nil {
		return nil, parseMeta{}, err
	}

	if _, err := dec.Token(); !errors.Is(err, io.EOF) {
		if err == nil {
			return nil, parseMeta{}, fmt.Errorf("extra content after top-level JSON value")
		}
		return nil, parseMeta{}, err
	}

	computeComplexity(n)
	return n, meta, nil
}

func preprocessJSONInput(input string, opts Options) (string, parseMeta, error) {
	meta := parseMeta{}
	meta.LeadingBlanks = countLeadingBlankLines(input)
	meta.TrailingBlanks = countTrailingBlankLines(input)

	var out strings.Builder
	out.Grow(len(input))

	inString := false
	escaped := false
	for i := 0; i < len(input); i++ {
		ch := input[i]

		if inString {
			out.WriteByte(ch)
			if escaped {
				escaped = false
				continue
			}
			if ch == '\\' {
				escaped = true
				continue
			}
			if ch == '"' {
				inString = false
			}
			continue
		}

		if ch == '"' {
			inString = true
			out.WriteByte(ch)
			continue
		}

		if ch == '/' && i+1 < len(input) {
			next := input[i+1]
			if next == '/' {
				if opts.CommentPolicy == CommentTreatAsError {
					return "", parseMeta{}, fmt.Errorf("comments are not allowed by current CommentPolicy")
				}

				j := i
				for j < len(input) && input[j] != '\n' {
					j++
				}
				comment := input[i:j]
				if opts.CommentPolicy == CommentPreserve {
					meta.Comments = append(meta.Comments, comment)
				}
				for k := i; k < j; k++ {
					out.WriteByte(' ')
				}
				i = j - 1
				continue
			}
			if next == '*' {
				if opts.CommentPolicy == CommentTreatAsError {
					return "", parseMeta{}, fmt.Errorf("comments are not allowed by current CommentPolicy")
				}

				j := i + 2
				for j+1 < len(input) && !(input[j] == '*' && input[j+1] == '/') {
					j++
				}
				if j+1 >= len(input) {
					return "", parseMeta{}, fmt.Errorf("unterminated block comment")
				}
				j += 2
				comment := input[i:j]
				if opts.CommentPolicy == CommentPreserve {
					meta.Comments = append(meta.Comments, comment)
				}
				for k := i; k < j; k++ {
					if input[k] == '\n' {
						out.WriteByte('\n')
					} else {
						out.WriteByte(' ')
					}
				}
				i = j - 1
				continue
			}
		}

		out.WriteByte(ch)
	}

	clean := out.String()
	var err error
	clean, err = applyTrailingCommaPolicy(clean, opts.AllowTrailingCommas)
	if err != nil {
		return "", parseMeta{}, err
	}

	return clean, meta, nil
}

func applyTrailingCommaPolicy(input string, allow bool) (string, error) {
	b := []byte(input)
	inString := false
	escaped := false

	for i := 0; i < len(b); i++ {
		ch := b[i]
		if inString {
			if escaped {
				escaped = false
				continue
			}
			if ch == '\\' {
				escaped = true
				continue
			}
			if ch == '"' {
				inString = false
			}
			continue
		}

		if ch == '"' {
			inString = true
			continue
		}

		if ch != ',' {
			continue
		}

		j := i + 1
		for j < len(b) && (b[j] == ' ' || b[j] == '\t' || b[j] == '\r' || b[j] == '\n') {
			j++
		}
		if j < len(b) && (b[j] == ']' || b[j] == '}') {
			if !allow {
				return "", fmt.Errorf("trailing commas are not allowed by current AllowTrailingCommas setting")
			}
			b[i] = ' '
		}
	}

	return string(b), nil
}

func countLeadingBlankLines(s string) int {
	lines := strings.Split(s, "\n")
	count := 0
	for _, line := range lines {
		if strings.TrimSpace(line) == "" {
			count++
			continue
		}
		break
	}
	return count
}

func countTrailingBlankLines(s string) int {
	lines := strings.Split(s, "\n")
	count := 0
	for i := len(lines) - 1; i >= 0; i-- {
		if strings.TrimSpace(lines[i]) == "" {
			count++
			continue
		}
		break
	}
	return count
}

func parseValue(dec *json.Decoder) (*Node, error) {
	tok, err := dec.Token()
	if err != nil {
		return nil, err
	}

	switch t := tok.(type) {
	case nil:
		return &Node{Kind: KindNull}, nil
	case bool:
		return &Node{Kind: KindBool, Bool: t}, nil
	case string:
		return &Node{Kind: KindString, String: t}, nil
	case json.Number:
		return &Node{Kind: KindNumber, Number: t.String()}, nil
	case json.Delim:
		switch t {
		case '{':
			return parseObject(dec)
		case '[':
			return parseArray(dec)
		default:
			return nil, fmt.Errorf("unexpected delimiter %q", t)
		}
	default:
		return nil, fmt.Errorf("unexpected token type %T", t)
	}
}

func parseObject(dec *json.Decoder) (*Node, error) {
	obj := &Node{Kind: KindObject}
	for dec.More() {
		kTok, err := dec.Token()
		if err != nil {
			return nil, err
		}
		key, ok := kTok.(string)
		if !ok {
			return nil, fmt.Errorf("expected object key string, got %T", kTok)
		}

		value, err := parseValue(dec)
		if err != nil {
			return nil, err
		}
		obj.Object = append(obj.Object, Member{Name: key, Value: value})
	}

	endTok, err := dec.Token()
	if err != nil {
		return nil, err
	}
	if d, ok := endTok.(json.Delim); !ok || d != '}' {
		return nil, fmt.Errorf("expected object close delimiter, got %v", endTok)
	}
	return obj, nil
}

func parseArray(dec *json.Decoder) (*Node, error) {
	arr := &Node{Kind: KindArray}
	for dec.More() {
		v, err := parseValue(dec)
		if err != nil {
			return nil, err
		}
		arr.Array = append(arr.Array, v)
	}

	endTok, err := dec.Token()
	if err != nil {
		return nil, err
	}
	if d, ok := endTok.(json.Delim); !ok || d != ']' {
		return nil, fmt.Errorf("expected array close delimiter, got %v", endTok)
	}
	return arr, nil
}

func computeComplexity(n *Node) int {
	switch n.Kind {
	case KindArray:
		if len(n.Array) == 0 {
			n.Complexity = 0
			return 0
		}
		maxComplexity := 0
		for _, child := range n.Array {
			c := computeComplexity(child)
			if c > maxComplexity {
				maxComplexity = c
			}
		}
		n.Complexity = maxComplexity + 1
		return n.Complexity
	case KindObject:
		if len(n.Object) == 0 {
			n.Complexity = 0
			return 0
		}
		maxComplexity := 0
		for _, member := range n.Object {
			c := computeComplexity(member.Value)
			if c > maxComplexity {
				maxComplexity = c
			}
		}
		n.Complexity = maxComplexity + 1
		return n.Complexity
	default:
		n.Complexity = 0
		return 0
	}
}