Initial project import

tools/v/vlib/yaml/emit.v

@@ -0,0 +1,204 @@
+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')
+		}
+	}
+}