git.delta.rocks / jrsonnet / refs/commits / ec8bd188aadf

101	D::deserialize(value)101	D::deserialize(value)
102}102}
103103
104pub fn serialize_value_pretty(value: Value) -> Result<String, Error> {104pub fn serialize_value_pretty(value: Value) -> String {
105	to_string::write_nix(&value)105	to_string::write_nix(&value)
106}106}
107107
108pub fn serialize<S: Serialize>(value: S) -> Result<String, Error> {108pub fn serialize<S: Serialize>(value: S) -> Result<String, Error> {
109	let value: Value = value.serialize(MySerialize)?;109	let value: Value = value.serialize(MySerialize)?;
110	serialize_value_pretty(value)110	Ok(serialize_value_pretty(value))
111}111}
112112
113#[test]113#[test]

1use crate::{Error, Value};1use crate::Value;
2use dprint_core::formatting::{
3	condition_resolvers, conditions, format, ConditionResolverContext, Info, PrintItems,
4	PrintOptions, Signal,
5};
26
3fn write_nix_obj_key_buf(7fn write_nix_obj_key_buf(k: &str, v: &Value, out: &mut PrintItems) {
4	k: &str,
5	v: &Value,
6	out: &mut String,
7	indent: &mut String,
8) -> Result<(), Error> {
9	use std::fmt::Write;
10	write!(out, "{}", k)?;8	out.push_str(k);
11	match v {9	match v {
12		Value::Object(o) if o.len() == 1 => {10		Value::Object(o) if o.len() == 1 => {
13			let (k, v) = o.iter().next().unwrap();11			let (k, v) = o.iter().next().unwrap();
12
14			write!(out, ".")?;13			out.push_str(".");
15			write_nix_obj_key_buf(k, v, out, indent)?;14			write_nix_obj_key_buf(k, v, out);
16		}15		}
17		v => {16		v => {
18			write!(out, " = ")?;17			out.push_str(" = ");
19			write_nix_buf(v, out, indent)?;18			write_nix_buf(v, out);
20			writeln!(out, ";")?;19			out.push_str(";");
21		}20		}
22	}21	}
23	Ok(())
24}22}
2523
26fn write_nix_buf(value: &Value, out: &mut String, indent: &mut String) -> Result<(), Error> {24fn write_nix_buf(value: &Value, out: &mut PrintItems) {
27	use std::fmt::Write;
28	match value {25	match value {
29		Value::Null => write!(out, "null")?,26		Value::Null => out.push_str("null"),
30		Value::Boolean(v) => write!(out, "{:?}", v)?,27		Value::Boolean(v) => out.push_str(if *v { "true" } else { "false" }),
31		Value::Number(n) => write!(out, "{}", n)?,28		Value::Number(n) => out.push_str(&format!("{}", n)),
32		Value::String(s) => write!(out, "{:?}", s)?,29		Value::String(s) => out.push_str(&format!("{:?}", s)),
33		Value::Array(a) => {30		Value::Array(a) => {
34			if a.is_empty() {31			if a.is_empty() {
35				write!(out, "[ ]")?;32				out.push_str("[ ]");
36			} else {33			} else {
34				let start_info = Info::new("start");
37				writeln!(out, "[")?;35				let end_info = Info::new("end");
38				let old_len = indent.len();36				let is_multiple_lines = move |ctx: &mut ConditionResolverContext| {
37					condition_resolvers::is_multiple_lines(ctx, &start_info, &end_info)
38				};
39				indent.push_str("  ");39				out.push_str("[");
40				out.push_info(start_info);
41				out.push_signal(Signal::StartIndent);
42				out.push_condition(conditions::if_true_or(
43					"array start",
44					is_multiple_lines.clone(),
45					Signal::NewLine.into(),
46					Signal::SpaceOrNewLine.into(),
47				));
40				for item in a {48				for item in a {
41					write!(out, "{}", indent)?;
42					write_nix_buf(item, out, indent)?;49					write_nix_buf(item, out);
43					writeln!(out)?;50					out.push_condition(conditions::if_true_or(
51						"element separator",
52						is_multiple_lines.clone(),
53						Signal::NewLine.into(),
54						Signal::SpaceOrNewLine.into(),
55					));
44				}56				}
45				indent.truncate(old_len);57				out.push_signal(Signal::FinishIndent);
46				write!(out, "{}]", indent)?;58				out.push_info(end_info);
59				out.push_str("]");
47			}60			}
48		}61		}
49		Value::Object(obj) => {62		Value::Object(obj) => {
50			if obj.is_empty() {63			if obj.is_empty() {
51				write!(out, "{{ }}")?;64				out.push_str("{ }")
52			} else {65			} else {
66				let start_info = Info::new("start");
53				writeln!(out, "{{")?;67				let end_info = Info::new("end");
54				let old_len = indent.len();68				let is_multiple_lines = move |ctx: &mut ConditionResolverContext| {
69					condition_resolvers::is_multiple_lines(ctx, &start_info, &end_info)
70				};
55				indent.push_str("  ");71				out.push_str("{");
72				out.push_info(start_info);
73				out.push_signal(Signal::StartIndent);
74				out.push_condition(conditions::if_true_or(
75					"object start",
76					is_multiple_lines.clone(),
77					Signal::NewLine.into(),
78					Signal::SpaceOrNewLine.into(),
79				));
56				for (k, v) in obj {80				for (k, v) in obj {
57					write!(out, "{}", indent)?;81					write_nix_obj_key_buf(k, v, out);
58					write_nix_obj_key_buf(k, v, out, indent)?;82					out.push_condition(conditions::if_true_or(
83						"element separator",
84						is_multiple_lines.clone(),
85						Signal::NewLine.into(),
86						Signal::SpaceOrNewLine.into(),
87					));
59				}88				}
60				indent.truncate(old_len);89				out.push_signal(Signal::FinishIndent);
61				write!(out, "{}}}", indent)?;90				out.push_info(end_info);
91				out.push_str("}");
62			}92			}
63		}93		}
64	};94	};
65	Ok(())
66}95}
6796
68pub fn write_nix(value: &Value) -> Result<String, Error> {97pub fn write_nix(value: &Value) -> String {
69	let mut out = String::new();98	format(
99		|| {
70	let mut indent = String::new();100			let mut items = PrintItems::new();
71101			write_nix_buf(value, &mut items);
102			items
103		},
104		PrintOptions {
72	write_nix_buf(value, &mut out, &mut indent)?;105			max_width: 120,
73	Ok(out)106			use_tabs: false,
107			indent_width: 2,
108			new_line_text: "\n",
109		},
110	)
74}111}
75112