x/json2: add Encoder struct, add prettify_json_str
Ned Palacios
parent
63b41e67fa
commit
5a565bdbb2
|
|
@ -3,54 +3,125 @@
|
|||
// that can be found in the LICENSE file.
|
||||
module json2
|
||||
|
||||
import io
|
||||
import strings
|
||||
|
||||
fn write_value(v Any, i int, len int, mut wr strings.Builder) {
|
||||
str := v.json_str()
|
||||
if v is string {
|
||||
wr.write_string('"$str"')
|
||||
} else {
|
||||
wr.write_string(str)
|
||||
}
|
||||
if i >= len - 1 {
|
||||
return
|
||||
}
|
||||
wr.write_byte(`,`)
|
||||
// Encoder encodes the an `Any` type into JSON representation.
|
||||
// It provides parameters in order to change the end result.
|
||||
pub struct Encoder {
|
||||
newline byte
|
||||
newline_spaces_count int
|
||||
escape_utf32 bool = true
|
||||
}
|
||||
|
||||
// str returns the string representation of the `map[string]Any`.
|
||||
[manualfree]
|
||||
pub fn (flds map[string]Any) str() string {
|
||||
mut wr := strings.new_builder(200)
|
||||
wr.write_byte(`{`)
|
||||
mut i := 0
|
||||
for k, v in flds {
|
||||
wr.write_string('"$k":')
|
||||
write_value(v, i, flds.len, mut wr)
|
||||
i++
|
||||
}
|
||||
wr.write_byte(`}`)
|
||||
defer {
|
||||
unsafe { wr.free() }
|
||||
}
|
||||
res := wr.str()
|
||||
return res
|
||||
// byte array versions of the most common tokens/chars
|
||||
// to avoid reallocations
|
||||
const null_in_bytes = 'null'.bytes()
|
||||
|
||||
const true_in_bytes = 'true'.bytes()
|
||||
|
||||
const false_in_bytes = 'false'.bytes()
|
||||
|
||||
const zero_in_bytes = [byte(`0`)]
|
||||
|
||||
const comma_bytes = [byte(`,`)]
|
||||
|
||||
const colon_bytes = [byte(`:`)]
|
||||
|
||||
const space_bytes = [byte(` `)]
|
||||
|
||||
const unicode_escape_chars = [byte(`\\`), `u`]
|
||||
|
||||
const quote_bytes = [byte(`"`)]
|
||||
|
||||
const escaped_chars = [(r'\b').bytes(), (r'\f').bytes(), (r'\n').bytes(),
|
||||
(r'\r').bytes(), (r'\t').bytes()]
|
||||
|
||||
// encode_value encodes an `Any` value to the specific writer.
|
||||
pub fn (e &Encoder) encode_value(f Any, mut wr io.Writer) ? {
|
||||
e.encode_value_with_level(f, 1, mut wr) ?
|
||||
}
|
||||
|
||||
// str returns the string representation of the `[]Any`.
|
||||
[manualfree]
|
||||
pub fn (flds []Any) str() string {
|
||||
mut wr := strings.new_builder(200)
|
||||
wr.write_byte(`[`)
|
||||
for i, v in flds {
|
||||
write_value(v, i, flds.len, mut wr)
|
||||
fn (e &Encoder) encode_newline(level int, mut wr io.Writer) ? {
|
||||
if e.newline != 0 {
|
||||
wr.write([e.newline]) ?
|
||||
for j := 0; j < level * e.newline_spaces_count; j++ {
|
||||
wr.write(json2.space_bytes) ?
|
||||
}
|
||||
}
|
||||
wr.write_byte(`]`)
|
||||
defer {
|
||||
unsafe { wr.free() }
|
||||
}
|
||||
|
||||
fn (e &Encoder) encode_value_with_level(f Any, level int, mut wr io.Writer) ? {
|
||||
match f {
|
||||
string {
|
||||
e.encode_string(f, mut wr) ?
|
||||
}
|
||||
bool {
|
||||
if f == true {
|
||||
wr.write(json2.true_in_bytes) ?
|
||||
} else {
|
||||
wr.write(json2.false_in_bytes) ?
|
||||
}
|
||||
}
|
||||
int, u64, i64 {
|
||||
wr.write(f.str().bytes()) ?
|
||||
}
|
||||
f32, f64 {
|
||||
$if !nofloat ? {
|
||||
str_float := f.str().bytes()
|
||||
wr.write(str_float) ?
|
||||
if str_float[str_float.len - 1] == `.` {
|
||||
wr.write(json2.zero_in_bytes) ?
|
||||
}
|
||||
return
|
||||
}
|
||||
wr.write(json2.zero_in_bytes) ?
|
||||
}
|
||||
map[string]Any {
|
||||
wr.write([byte(`{`)]) ?
|
||||
mut i := 0
|
||||
for k, v in f {
|
||||
e.encode_newline(level, mut wr) ?
|
||||
e.encode_string(k, mut wr) ?
|
||||
wr.write(json2.colon_bytes) ?
|
||||
if e.newline != 0 {
|
||||
wr.write(json2.space_bytes) ?
|
||||
}
|
||||
e.encode_value_with_level(v, level + 1, mut wr) ?
|
||||
if i < f.len - 1 {
|
||||
wr.write(json2.comma_bytes) ?
|
||||
}
|
||||
i++
|
||||
}
|
||||
e.encode_newline(level - 1, mut wr) ?
|
||||
wr.write([byte(`}`)]) ?
|
||||
}
|
||||
[]Any {
|
||||
wr.write([byte(`[`)]) ?
|
||||
for i, v in f {
|
||||
e.encode_newline(level, mut wr) ?
|
||||
e.encode_value_with_level(v, level + 1, mut wr) ?
|
||||
if i < f.len - 1 {
|
||||
wr.write(json2.comma_bytes) ?
|
||||
}
|
||||
}
|
||||
e.encode_newline(level - 1, mut wr) ?
|
||||
wr.write([byte(`]`)]) ?
|
||||
}
|
||||
Null {
|
||||
wr.write(json2.null_in_bytes) ?
|
||||
}
|
||||
}
|
||||
res := wr.str()
|
||||
return res
|
||||
}
|
||||
|
||||
// str returns the JSON string representation of the `map[string]Any` type.
|
||||
pub fn (f map[string]Any) str() string {
|
||||
return Any(f).json_str()
|
||||
}
|
||||
|
||||
// str returns the JSON string representation of the `[]Any` type.
|
||||
pub fn (f []Any) str() string {
|
||||
return Any(f).json_str()
|
||||
}
|
||||
|
||||
// str returns the string representation of the `Any` type. Use the `json_str` method
|
||||
|
|
@ -64,113 +135,101 @@ pub fn (f Any) str() string {
|
|||
}
|
||||
|
||||
// json_str returns the JSON string representation of the `Any` type.
|
||||
pub fn (f Any) json_str() string {
|
||||
match f {
|
||||
string {
|
||||
return json_string(f)
|
||||
}
|
||||
bool, int, u64, i64 {
|
||||
return f.str()
|
||||
}
|
||||
f32 {
|
||||
$if !nofloat ? {
|
||||
str_f32 := f.str()
|
||||
if str_f32.ends_with('.') {
|
||||
return '${str_f32}0'
|
||||
}
|
||||
return str_f32
|
||||
}
|
||||
|
||||
return '0'
|
||||
}
|
||||
f64 {
|
||||
$if !nofloat ? {
|
||||
str_f64 := f.str()
|
||||
if str_f64.ends_with('.') {
|
||||
return '${str_f64}0'
|
||||
}
|
||||
return str_f64
|
||||
}
|
||||
return '0'
|
||||
}
|
||||
map[string]Any {
|
||||
return f.str()
|
||||
}
|
||||
[]Any {
|
||||
return f.str()
|
||||
}
|
||||
Null {
|
||||
return 'null'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// char_len_list is a modified version of builtin.utf8_str_len
|
||||
// that returns an array of character lengths. (e.g "t✔" => [1,2])
|
||||
fn char_len_list(s string) []int {
|
||||
mut l := 1
|
||||
mut ls := []int{}
|
||||
for i := 0; i < s.len; i++ {
|
||||
c := s[i]
|
||||
if (c & (1 << 7)) != 0 {
|
||||
for t := byte(1 << 6); (c & t) != 0; t >>= 1 {
|
||||
l++
|
||||
i++
|
||||
}
|
||||
}
|
||||
ls << l
|
||||
l = 1
|
||||
}
|
||||
return ls
|
||||
}
|
||||
|
||||
const escaped_chars = [r'\b', r'\f', r'\n', r'\r', r'\t']
|
||||
|
||||
// json_string returns the JSON spec-compliant version of the string.
|
||||
[manualfree]
|
||||
fn json_string(s string) string {
|
||||
// not the best implementation but will revisit it soon
|
||||
char_lens := char_len_list(s)
|
||||
mut sb := strings.new_builder(s.len)
|
||||
mut i := 0
|
||||
pub fn (f Any) json_str() string {
|
||||
mut sb := strings.new_builder(4096)
|
||||
defer {
|
||||
unsafe {
|
||||
char_lens.free()
|
||||
// freeing string builder on defer after
|
||||
// returning .str() still isn't working :(
|
||||
// sb.free()
|
||||
unsafe { sb.free() }
|
||||
}
|
||||
mut enc := Encoder{}
|
||||
enc.encode_value(f, mut sb) or { return '' }
|
||||
return sb.str()
|
||||
}
|
||||
|
||||
// prettify_json_str returns the pretty-formatted JSON string representation of the `Any` type.
|
||||
[manualfree]
|
||||
pub fn (f Any) prettify_json_str() string {
|
||||
mut sb := strings.new_builder(4096)
|
||||
defer {
|
||||
unsafe { sb.free() }
|
||||
}
|
||||
mut enc := Encoder{
|
||||
newline: `\n`
|
||||
newline_spaces_count: 4
|
||||
}
|
||||
enc.encode_value(f, mut sb) or { return '' }
|
||||
return sb.str()
|
||||
}
|
||||
|
||||
// CharLengthIterator is an iterator that generates a char
|
||||
// length value of every iteration based on the given text.
|
||||
// (e.g.: "t✔" => [t => 1, ✔ => 2])
|
||||
struct CharLengthIterator {
|
||||
text string
|
||||
mut:
|
||||
idx int
|
||||
}
|
||||
|
||||
fn (mut iter CharLengthIterator) next() ?int {
|
||||
if iter.idx >= iter.text.len {
|
||||
return none
|
||||
}
|
||||
defer {
|
||||
iter.idx++
|
||||
}
|
||||
mut len := 1
|
||||
c := iter.text[iter.idx]
|
||||
if (c & (1 << 7)) != 0 {
|
||||
for t := byte(1 << 6); (c & t) != 0; t >>= 1 {
|
||||
len++
|
||||
iter.idx++
|
||||
}
|
||||
}
|
||||
return len
|
||||
}
|
||||
|
||||
// encode_string returns the JSON spec-compliant version of the string.
|
||||
[manualfree]
|
||||
fn (e &Encoder) encode_string(s string, mut wr io.Writer) ? {
|
||||
mut char_lens := CharLengthIterator{
|
||||
text: s
|
||||
}
|
||||
mut i := 0
|
||||
wr.write(json2.quote_bytes) ?
|
||||
for char_len in char_lens {
|
||||
if char_len == 1 {
|
||||
chr := s[i]
|
||||
if chr in important_escapable_chars {
|
||||
for j := 0; j < important_escapable_chars.len; j++ {
|
||||
if chr == important_escapable_chars[j] {
|
||||
sb.write_string(json2.escaped_chars[j])
|
||||
wr.write(json2.escaped_chars[j]) ?
|
||||
break
|
||||
}
|
||||
}
|
||||
} else if chr == `"` || chr == `/` || chr == `\\` {
|
||||
sb.write_string('\\' + chr.ascii_str())
|
||||
wr.write([byte(`\\`), chr]) ?
|
||||
} else if int(chr) < 0x20 {
|
||||
hex_code := chr.hex()
|
||||
sb.write_string('\\u00$hex_code')
|
||||
hex_code := chr.hex().bytes()
|
||||
wr.write(json2.unicode_escape_chars) ? // \u
|
||||
wr.write(json2.zero_in_bytes) ? // \u0
|
||||
wr.write(json2.zero_in_bytes) ? // \u00
|
||||
wr.write(hex_code) ? // \u00xxxx
|
||||
} else {
|
||||
sb.write_byte(chr)
|
||||
wr.write([byte(chr)]) ?
|
||||
}
|
||||
} else {
|
||||
slice := s[i..i + char_len]
|
||||
hex_code := slice.utf32_code().hex()
|
||||
if hex_code.len < 4 {
|
||||
// an utf8 codepoint
|
||||
sb.write_string(slice)
|
||||
hex_code := slice.utf32_code().hex().bytes()
|
||||
if !e.escape_utf32 || hex_code.len < 4 {
|
||||
// an utf8 codepoint or an unescape utf32
|
||||
wr.write(slice.bytes()) ?
|
||||
} else if hex_code.len == 4 {
|
||||
sb.write_string('\\u$hex_code')
|
||||
wr.write(json2.unicode_escape_chars) ?
|
||||
wr.write(hex_code) ?
|
||||
} else {
|
||||
// TODO: still figuring out what
|
||||
// to do with more than 4 chars
|
||||
sb.write_byte(` `)
|
||||
wr.write(json2.space_bytes) ?
|
||||
}
|
||||
unsafe {
|
||||
slice.free()
|
||||
|
|
@ -179,7 +238,6 @@ fn json_string(s string) string {
|
|||
}
|
||||
i += char_len
|
||||
}
|
||||
str := sb.str()
|
||||
unsafe { sb.free() }
|
||||
return str
|
||||
|
||||
wr.write(json2.quote_bytes) ?
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue