git.delta.rocks / jrsonnet / refs/commits / 433adfa9b8ae

134134
135fn main_real(opts: Opts) {135fn main_real(opts: Opts) {
136	let evaluator = jrsonnet_evaluator::EvaluationState::default();136	let evaluator = jrsonnet_evaluator::EvaluationState::default();
137	{
137	evaluator.set_max_trace(opts.max_trace);138		let mut settings = evaluator.settings_mut();
138	evaluator.set_max_stack(opts.max_stack);139		settings.max_stack = opts.max_stack;
140		settings.max_trace = opts.max_trace;
139	evaluator.set_import_resolver(Box::new(jrsonnet_evaluator::FileImportResolver {141		settings.import_resolver = Box::new(jrsonnet_evaluator::FileImportResolver {
140		library_paths: opts.jpath.clone(),142			library_paths: opts.jpath.clone(),
141	}));143		});
144	}
142	if !opts.no_stdlib {145	if !opts.no_stdlib {
143		evaluator.with_stdlib();146		evaluator.with_stdlib();
144	}147	}
145	for ExtStr { name, value } in opts.ext_str.iter().cloned() {148	for ExtStr { name, value } in opts.ext_str.iter().cloned() {
146		evaluator.add_ext_var(name.into(), Val::Str(value.into()));149		evaluator
150			.settings_mut()
151			.ext_vars
152			.insert(name.into(), Val::Str(value.into()));
147	}153	}
148	for ExtStr { name, value } in opts.ext_code.iter().cloned() {154	for ExtStr { name, value } in opts.ext_code.iter().cloned() {
149		evaluator.add_ext_var(name.into(), evaluator.parse_evaluate_raw(&value).unwrap());155		evaluator.settings_mut().ext_vars.insert(
156			name.clone().into(),
157			evaluator
158				.parse_evaluate_raw(PathBuf::from(format!("ext_code {}", name)).into(), &value)
159				.unwrap(),
160		);
150	}161	}
184							.unwrap(),195							.unwrap(),
185						);196						);
186					}197					}
187					evaluator.add_global("__tmp__tlf__".into(), Val::Func(f));198					evaluator
199						.settings_mut()
200						.globals
201						.insert("__tmp__tlf__".into(), Val::Func(f));
188					evaluator202					evaluator
189						.evaluate_raw(el!(Expr::Apply(203						.evaluate_raw(el!(Expr::Apply(
190							el!(Expr::Var("__tmp__tlf__".into())),204							el!(Expr::Var("__tmp__tlf__".into())),

136136
137#[test]137#[test]
138fn test() -> Result<()> {138fn test() -> Result<()> {
139	use jrsonnet_parser::*;
140	use crate::val::ValType;139	use crate::val::ValType;
140	use jrsonnet_parser::*;
141	let state = crate::EvaluationState::default();141	let state = crate::EvaluationState::default();
142	let evaluator = state.with_stdlib();142	let evaluator = state.with_stdlib();
143	let ctx = evaluator.create_default_context()?;143	let ctx = evaluator.create_default_context()?;

77
8extern crate test;8extern crate test;
99
10mod builtin;
10mod ctx;11mod ctx;
11mod dynamic;12mod dynamic;
12mod error;13mod error;
15mod import;16mod import;
16mod map;17mod map;
17mod obj;18mod obj;
18mod val;
19pub mod trace;19pub mod trace;
20mod val;
2021
21pub use ctx::*;22pub use ctx::*;
22pub use dynamic::*;23pub use dynamic::*;
27use jrsonnet_parser::*;28use jrsonnet_parser::*;
28pub use obj::*;29pub use obj::*;
29use std::{cell::{Ref, RefCell, RefMut}, collections::HashMap, fmt::Debug, path::PathBuf, rc::Rc};30use std::{
30pub use val::*;31	cell::{Ref, RefCell, RefMut},
32	collections::HashMap,
33	fmt::Debug,
34	path::PathBuf,
35	rc::Rc,
36};
31use trace::{offset_to_location, CodeLocation};37use trace::{offset_to_location, CodeLocation};
38pub use val::*;
3239
33type BindableFn = dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<LazyVal>;40type BindableFn = dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<LazyVal>;
34#[derive(Clone)]41#[derive(Clone)]
355#[cfg(test)]362#[cfg(test)]
356pub mod tests {363pub mod tests {
357	use super::Val;364	use super::Val;
358	use crate::{create_error, EvaluationState, primitive_equals};365	use crate::{create_error, primitive_equals, EvaluationState};
359	use jrsonnet_parser::*;366	use jrsonnet_parser::*;
360	use std::{path::PathBuf, rc::Rc};367	use std::{path::PathBuf, rc::Rc};
361368
371					state.push(378						state.push(
372						&ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),379							&ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),
373						|| "inner".to_owned(),380							|| "inner".to_owned(),
374						|| {381							|| Err(create_error(crate::error::Error::RuntimeError("".into()))),
375							Err(create_error(crate::error::Error::RuntimeError("".into())))
376						},
377					)?;382						)?;
378					Ok(())383						Ok(())
379				},384					},
390			primitive_equals(
391				&state.parse_evaluate_raw(r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#).unwrap(),395			&state
396				.parse_evaluate_raw(
397					Rc::new(PathBuf::from("raw.jsonnet")),
398					r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#
399				)
400				.unwrap(),
398		($str: expr) => {407		($str: expr) => {
399			EvaluationState::default()408			EvaluationState::default()
400				.with_stdlib()409				.with_stdlib()
401				.parse_evaluate_raw($str)410				.parse_evaluate_raw(Rc::new(PathBuf::from("raw.jsonnet")), $str)
402				.unwrap()411				.unwrap()
403		};412		};
404	}413	}
408			evaluator.with_stdlib();417			evaluator.with_stdlib();
409			evaluator.run_in_state(||{418			evaluator.run_in_state(|| {
410				evaluator419				evaluator
411					.parse_evaluate_raw($str)420					.parse_evaluate_raw(Rc::new(PathBuf::from("raw.jsonnet")), $str)
412					.unwrap()421					.unwrap()
413					.into_json(0)422					.into_json(0)
414					.unwrap()423					.unwrap()
415					.replace("\n", "")424					.replace("\n", "")
416			})425				})
417		}}426			}};
418	}427	}
419428
420	/// Asserts given code returns `true`429	/// Asserts given code returns `true`

358			buf.push_str(cur_padding);358			buf.push_str(cur_padding);
359			buf.push('}');359			buf.push('}');
360		}360		}
361		Val::Func(_) | Val::Intristic(_, _) => create_error_result(Error::RuntimeError("tried to manifest function".into()))?,361		Val::Func(_) | Val::Intristic(_, _) => {
362			create_error_result(Error::RuntimeError("tried to manifest function".into()))?
363		}
362		Val::Lazy(_) => unreachable!(),364		Val::Lazy(_) => unreachable!(),
363	};365	};
364	Ok(())366	Ok(())