json_to_properties.go

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"os"
	"sort"
	"strconv"
	"strings"
)

// flatten walks a JSON value and collects scalar paths -> string values.
// Paths are joined with "."; arrays use numeric indices.
func flatten(v any, prefix string, out map[string]string) {
	switch vv := v.(type) {
	case map[string]any:
		for k, val := range vv {
			key := k
			if prefix != "" {
				key = prefix + "." + k
			}
			flatten(val, key, out)
		}
	case []any:
		for i, val := range vv {
			key := strconv.Itoa(i)
			if prefix != "" {
				key = prefix + "." + key
			}
			flatten(val, key, out)
		}
	case nil:
		out[prefix] = ""
	case string:
		out[prefix] = vv
	case float64, bool:
		out[prefix] = fmt.Sprint(vv)
	default:
		// Numbers decoded with UseNumber? Not needed; default fmt ok.
		out[prefix] = fmt.Sprint(vv)
	}
}

// escBackslashes first, then do other replacements on the result.
func escBackslashes(s string) string { return strings.ReplaceAll(s, `\`, `\\`) }

// escKey: similar to the jq version (practical subset):
// - escape backslashes
// - ":" -> "\:"
// - "=" -> "\="
// - if starts with space or '#' or '!' then escape that first char
// - also make control characters visible (\n,\r,\t) just in case
func escKey(s string) string {
	if s == "" {
		return s
	}
	s = escBackslashes(s)
	s = strings.ReplaceAll(s, ":", `\:`)
	s = strings.ReplaceAll(s, "=", `\=`)
	s = strings.ReplaceAll(s, "\n", `\n`)
	s = strings.ReplaceAll(s, "\r", `\r`)
	s = strings.ReplaceAll(s, "\t", `\t`)
	// Escape a leading space, #, or ! to avoid comment/trim semantics
	switch s[0] {
	case ' ', '#', '!':
		s = `\` + s
	}
	return s
}

// escVal: escape backslashes and control characters; if begins with space prefix with "\ "
func escVal(s string) string {
	s = escBackslashes(s)
	s = strings.ReplaceAll(s, "\n", `\n`)
	s = strings.ReplaceAll(s, "\r", `\r`)
	s = strings.ReplaceAll(s, "\t", `\t`)
	if strings.HasPrefix(s, " ") {
		s = `\` + s
	}
	return s
}

func main() {
	var (
		inPath   string
		outPath  string
		prefix   string
		doSort   bool
	)
	flag.StringVar(&inPath, "in", "", "Input Tolgee JSON file (e.g. en.json). If empty, read stdin")
	flag.StringVar(&outPath, "out", "", "Output .properties file (e.g. messages_en.properties). If empty, write to stdout")
	flag.StringVar(&prefix, "prefix", "", "Optional prefix to add to all keys (e.g. app)")
	flag.BoolVar(&doSort, "sort", false, "Sort keys alphabetically for stable output")
	flag.Parse()

	// Read input
	var data []byte
	var err error
	if inPath == "" {
		data, err = io.ReadAll(os.Stdin)
	} else {
		data, err = os.ReadFile(inPath)
	}
	if err != nil {
		fmt.Fprintf(os.Stderr, "read error: %v\n\n", err)
		flag.Usage()
		os.Exit(2)
	}

	// Decode JSON (with decoder to allow comments/extra whitespace if needed)
	dec := json.NewDecoder(bytes.NewReader(data))
	dec.UseNumber()
	var root any
	if err := dec.Decode(&root); err != nil {
		fmt.Fprintf(os.Stderr, "json decode error: %v\n", err)
		os.Exit(1)
	}

	flat := make(map[string]string, 256)
	base := strings.TrimSpace(prefix)
	flatten(root, base, flat)

	// Collect items
	type kv struct{ k, v string }
	items := make([]kv, 0, len(flat))
	for k, v := range flat {
		// Skip empty path (can happen if top-level scalar without prefix)
		if k == "" {
			continue
		}
		items = append(items, kv{k: k, v: v})
	}

	if doSort {
		sort.Slice(items, func(i, j int) bool { return items[i].k < items[j].k })
	}

	// Prepare output
	var b strings.Builder
	if inPath != "" {
		fmt.Fprintf(&b, "# Generated from %s. Do not edit manually.\n", inPath)
	}
	for _, it := range items {
		k := escKey(it.k)
		v := escVal(it.v)
		b.WriteString(k)
		b.WriteByte('=')
		b.WriteString(v)
		b.WriteByte('\n')
	}

	// Write output
	if outPath == "" {
		_, _ = io.WriteString(os.Stdout, b.String())
	} else {
		if err := os.WriteFile(outPath, []byte(b.String()), 0o644); err != nil {
			fmt.Fprintf(os.Stderr, "write error: %v\n", err)
			os.Exit(1)
		}
	}
}