agila_open_tool/tools/v/vlib/yaml/emit.v

module yaml

import strings

// write_spaces appends `n` spaces to `sb`.
fn write_spaces(mut sb strings.Builder, n int) {
	for _ in 0 .. n {
		sb.write_u8(` `)
	}
}

// emit_yaml_any streams `value` into `sb` as block-style YAML.
fn emit_yaml_any(mut sb strings.Builder, value Any, indent int) {
	match value {
		map[string]Any { emit_yaml_map(mut sb, value, indent) }
		[]Any { emit_yaml_array(mut sb, value, indent) }
		else { emit_yaml_scalar(mut sb, value) }
	}
}

// emit_yaml_map writes `value` as a block-style YAML mapping. An empty map
// is emitted as the inline `{}` form; otherwise each key is JSON-quoted (see
// `write_json_escaped_string`) and nested containers indent one level deeper.
fn emit_yaml_map(mut sb strings.Builder, value map[string]Any, indent int) {
	if value.len == 0 {
		sb.write_string('{}')
		return
	}
	mut first := true
	for key, item in value {
		if !first {
			sb.write_u8(`\n`)
		}
		first = false
		write_spaces(mut sb, indent)
		write_json_escaped_string(mut sb, key)
		match item {
			map[string]Any, []Any {
				sb.write_u8(`:`)
				sb.write_u8(`\n`)
				emit_yaml_any(mut sb, item, indent + 2)
			}
			else {
				sb.write_string(': ')
				emit_yaml_scalar(mut sb, item)
			}
		}
	}
}

// emit_yaml_array writes `value` as a block-style YAML sequence. An empty
// array is emitted as the inline `[]` form; otherwise each item is prefixed
// with `- ` and nested containers indent one level deeper.
fn emit_yaml_array(mut sb strings.Builder, value []Any, indent int) {
	if value.len == 0 {
		sb.write_string('[]')
		return
	}
	mut first := true
	for item in value {
		if !first {
			sb.write_u8(`\n`)
		}
		first = false
		write_spaces(mut sb, indent)
		match item {
			map[string]Any, []Any {
				sb.write_u8(`-`)
				sb.write_u8(`\n`)
				emit_yaml_any(mut sb, item, indent + 2)
			}
			else {
				sb.write_string('- ')
				emit_yaml_scalar(mut sb, item)
			}
		}
	}
}

// emit_yaml_scalar writes `value` as a single YAML scalar token: strings go
// through `write_json_escaped_string`, booleans / numbers / null print their
// literal form. The container branch is type-required by V's exhaustive
// `match` over `Any` but is unreachable: `emit_yaml_any` routes maps and
// arrays to their dedicated emitters before falling back here.
fn emit_yaml_scalar(mut sb strings.Builder, value Any) {
	match value {
		string { write_json_escaped_string(mut sb, value) }
		bool { sb.write_string(if value { 'true' } else { 'false' }) }
		f64 { sb.write_string(value.str()) }
		i64 { sb.write_string(value.str()) }
		int { sb.write_string(value.str()) }
		u64 { sb.write_string(value.str()) }
		Null { sb.write_string('null') }
		[]Any, map[string]Any { emit_yaml_any(mut sb, value, 0) }
	}
}

// write_json_escaped_string writes `value` as a JSON string literal directly
// into `sb`. Matches `json2.encode`'s rules: standard short escapes for control
// chars, `\u00XX` for the rest below 0x20, and UTF-8 bytes passed through
// verbatim (no per-byte `\uXXXX` re-escape). Passes safe runs through in bulk
// via `write_string` on the original slice — the overwhelmingly common case for
// human YAML — and only switches to per-byte handling at escape boundaries.
fn write_json_escaped_string(mut sb strings.Builder, value string) {
	sb.write_u8(`"`)
	mut start := 0
	for i := 0; i < value.len; i++ {
		c := value[i]
		if c >= 0x20 && c != `"` && c != `\\` {
			continue
		}
		if start < i {
			sb.write_string(value[start..i])
		}
		match c {
			`"` {
				sb.write_string('\\"')
			}
			`\\` {
				sb.write_string('\\\\')
			}
			`\n` {
				sb.write_string('\\n')
			}
			`\r` {
				sb.write_string('\\r')
			}
			`\t` {
				sb.write_string('\\t')
			}
			`\b` {
				sb.write_string('\\b')
			}
			`\f` {
				sb.write_string('\\f')
			}
			else {
				sb.write_string('\\u00')
				hex := '0123456789abcdef'
				sb.write_u8(hex[(c >> 4) & 0xf])
				sb.write_u8(hex[c & 0xf])
			}
		}

		start = i + 1
	}
	if start < value.len {
		sb.write_string(value[start..])
	}
	sb.write_u8(`"`)
}

// emit_any_as_json writes `a` as a compact JSON document.
fn emit_any_as_json(mut sb strings.Builder, a Any) {
	match a {
		map[string]Any {
			sb.write_u8(`{`)
			mut first := true
			for key, value in a {
				if !first {
					sb.write_u8(`,`)
				}
				first = false
				write_json_escaped_string(mut sb, key)
				sb.write_u8(`:`)
				emit_any_as_json(mut sb, value)
			}
			sb.write_u8(`}`)
		}
		[]Any {
			sb.write_u8(`[`)
			mut first := true
			for value in a {
				if !first {
					sb.write_u8(`,`)
				}
				first = false
				emit_any_as_json(mut sb, value)
			}
			sb.write_u8(`]`)
		}
		string {
			write_json_escaped_string(mut sb, a)
		}
		bool {
			sb.write_string(if a { 'true' } else { 'false' })
		}
		f64 {
			sb.write_string(a.str())
		}
		i64 {
			sb.write_string(a.str())
		}
		int {
			sb.write_string(a.str())
		}
		u64 {
			sb.write_string(a.str())
		}
		Null {
			sb.write_string('null')
		}
	}
}