git.delta.rocks / jrsonnet / refs/commits / 6a58b0ec3386

5use jsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParserSettings};5use jsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParserSettings};
6use location::{offset_to_location, CodeLocation};6use location::{offset_to_location, CodeLocation};
7use std::env::current_dir;7use std::env::current_dir;
8use std::{collections::HashMap, path::PathBuf, str::FromStr, rc::Rc};8use std::{collections::HashMap, path::PathBuf, rc::Rc, str::FromStr};
99
10enum Format {10enum Format {
11	None,11	None,
173				}173				}
174				v => v,174				v => v,
175			};175			};
176			let v = match opts.format {176			let v = evaluator.run_in_state(|| match opts.format {
177				Format::Json => {177				Format::Json => Ok(Val::Str(v.into_json(opts.line_padding)?)),
178					if opts.no_stdlib {
179						evaluator.with_stdlib();
180					}
181					evaluator.add_global("__tmp__to_json__".into(), v);
182					let v = evaluator.parse_evaluate_raw(&format!(
183						"std.manifestJsonEx(__tmp__to_json__, \"{}\")",
184						" ".repeat(opts.line_padding),
185					));
186					match v {
187						Ok(v) => v,
188						Err(err) => {
189							print_error(&err, evaluator, &opts);
190							std::process::exit(1);
191						}
192					}
193				}
194				Format::Yaml => {178				Format::Yaml => {
195					if opts.no_stdlib {
196						evaluator.with_stdlib();
197					}
198					evaluator.add_global("__tmp__to_yaml__".into(), v);179					evaluator.add_global("__tmp__to_yaml__".into(), v);
199					let v = evaluator180					evaluator.parse_evaluate_raw("std.manifestYamlDoc(__tmp__to_yaml__, \"  \")")
200						.parse_evaluate_raw("std.manifestYamlDoc(__tmp__to_yaml__, \"  \")");
201					match v {
202						Ok(v) => v,
203						Err(err) => {
204							print_error(&err, evaluator, &opts);
205							std::process::exit(1);
206						}
207					}
208				}181				}
209				_ => v,182				_ => Ok(v),
210			};183			});
184			let v = match v {
185				Ok(v) => v,
186				Err(err) => {
187					print_error(&err, evaluator, &opts);
188					std::process::exit(1);
189				}
190			};
211			match v {191			match v {
212				Val::Str(s) => println!("{}", s),192				Val::Str(s) => println!("{}", s),
213				Val::Num(n) => println!("{}", n),193				Val::Num(n) => println!("{}", n),

--- a/crates/jsonnet-evaluator/src/evaluate.rs
+++ b/crates/jsonnet-evaluator/src/evaluate.rs
@@ -668,6 +668,7 @@
 						) {
 							Val::Arr(Rc::new(
 								arr.iter()
+									.cloned()
 									.filter(|e| {
 										predicate
 											.evaluate_values(context.clone(), &[e.clone()])
@@ -675,7 +676,6 @@
 											.try_cast_bool("filter predicate")
 											.unwrap()
 									})
-									.cloned()
 									.collect(),
 							))
 						} else {

--- a/crates/jsonnet-evaluator/src/lib.rs
+++ b/crates/jsonnet-evaluator/src/lib.rs
@@ -296,7 +296,7 @@
 		Err(LocError(err, self.stack_trace()))
 	}
 
-	fn run_in_state<T>(&self, f: impl FnOnce() -> T) -> T {
+	pub fn run_in_state<T>(&self, f: impl FnOnce() -> T) -> T {
 		EVAL_STATE.with(|v| {
 			let has_state = v.borrow().is_some();
 			if !has_state {
@@ -364,14 +364,11 @@
 		($str: expr) => {{
 			let evaluator = EvaluationState::default();
 			evaluator.with_stdlib();
-			let val = evaluator.parse_evaluate_raw($str).unwrap();
-			evaluator.add_global("__tmp__to_yaml__".into(), val);
 			evaluator
-				.parse_evaluate_raw("std.manifestJsonEx(__tmp__to_yaml__, \"\")")
+				.parse_evaluate_raw($str)
 				.unwrap()
-				.try_cast_str("there should be json string")
+				.into_json(0)
 				.unwrap()
-				.clone()
 				.replace("\n", "")
 			}};
 	}

--- a/crates/jsonnet-evaluator/src/val.rs
+++ b/crates/jsonnet-evaluator/src/val.rs
@@ -1,9 +1,9 @@
 use crate::{
 	create_error, evaluate,
 	function::{inline_parse_function_call, place_args},
-	with_state, Context, Error, ObjValue, Result,
+	Context, Error, ObjValue, Result,
 };
-use jsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};
+use jsonnet_parser::{ArgsDesc, LocExpr, ParamsDesc};
 use std::{
 	cell::RefCell,
 	fmt::{Debug, Display},
@@ -170,6 +170,11 @@
 			Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,
 		})
 	}
+	#[cfg(feature = "faster")]
+	pub fn into_json(self, padding: usize) -> Result<Rc<str>> {
+		manifest_json_ex(&self, &" ".repeat(padding)).map(|s| s.into())
+	}
+	#[cfg(not(feature = "faster"))]
 	pub fn into_json(self, padding: usize) -> Result<Rc<str>> {
 		with_state(|s| {
 			let ctx = s