git.delta.rocks / jrsonnet / refs/commits / 1dbd15d5102e

1pub mod location;1pub mod location;
22
3use clap::Clap;3use clap::Clap;
4use jsonnet_evaluator::{EvaluationState, LocError, StackTrace, Val};4use jsonnet_evaluator::{EvaluationSettings, EvaluationState, LocError, StackTrace, Val};
5use location::{offset_to_location, CodeLocation};5use location::{offset_to_location, CodeLocation};
6use std::env::current_dir;6use std::env::current_dir;
7use std::{path::PathBuf, str::FromStr};7use std::{path::PathBuf, str::FromStr};
111111
112fn main() {112fn main() {
113	let opts: Opts = Opts::parse();113	let opts: Opts = Opts::parse();
114	let evaluator = jsonnet_evaluator::EvaluationState::default();114	let evaluator = jsonnet_evaluator::EvaluationState::new(EvaluationSettings {
115		import_resolver: Box::new(|path| String::from_utf8(std::fs::read(path).unwrap()).unwrap()),
116		..Default::default()
117	});
115	if !opts.no_stdlib {118	if !opts.no_stdlib {
116		evaluator.with_stdlib();119		evaluator.with_stdlib();
117	}120	}

1use crate::{1use crate::{
2	binding, context_creator, create_error, future_wrapper, lazy_val, push, Context,2	binding, context_creator, create_error, future_wrapper, lazy_val, push, with_state, Context,
3	ContextCreator, FuncDesc, LazyBinding, ObjMember, ObjValue, Result, Val,3	ContextCreator, FuncDesc, LazyBinding, ObjMember, ObjValue, Result, Val,
4};4};
5use closure::closure;5use closure::closure;
607				}607				}
608			}608			}
609		}609		}
610		Import(path) => {
611			let mut lib_path = loc
612				.clone()
613				.expect("imports can't be used without loc_data")
614				.0
615				.clone();
616			lib_path.pop();
617			lib_path.push(path);
618			with_state(|s| s.import_file(&lib_path))?
619		}
610		_ => panic!(620		_ => panic!(
611			"evaluation not implemented: {:?}",621			"evaluation not implemented: {:?}",
612			LocExpr(expr.clone(), loc.clone())622			LocExpr(expr.clone(), loc.clone())

50}50}
5151
52pub struct EvaluationSettings {52pub struct EvaluationSettings {
53	max_stack_frames: usize,53	pub max_stack_frames: usize,
54	max_stack_trace_size: usize,54	pub max_stack_trace_size: usize,
55	pub import_resolver: Box<dyn Fn(&PathBuf) -> String>,
55}56}
56impl Default for EvaluationSettings {57impl Default for EvaluationSettings {
57	fn default() -> Self {58	fn default() -> Self {
58		EvaluationSettings {59		EvaluationSettings {
59			max_stack_frames: 200,60			max_stack_frames: 200,
60			max_stack_trace_size: 20,61			max_stack_trace_size: 20,
62			import_resolver: Box::new(|path| {
63				panic!("default EvaluationSettings have no support for import resolution, can't import {:?}", path)
64			}),
61		}65		}
62	}66	}
63}67}
102#[derive(Default, Clone)]106#[derive(Default, Clone)]
103pub struct EvaluationState(Rc<EvaluationStateInternals>);107pub struct EvaluationState(Rc<EvaluationStateInternals>);
104impl EvaluationState {108impl EvaluationState {
109	pub fn new(settings: EvaluationSettings) -> Self {
110		EvaluationState(Rc::new(EvaluationStateInternals {
111			settings,
112			..Default::default()
113		}))
114	}
105	pub fn add_file(&self, name: PathBuf, code: String) -> std::result::Result<(), ParseError> {115	pub fn add_file(&self, name: PathBuf, code: String) -> std::result::Result<(), ParseError> {
106		self.0.files.borrow_mut().insert(116		self.0.files.borrow_mut().insert(
107			name.clone(),117			name.clone(),
137		let ro_map = self.0.files.borrow();147		let ro_map = self.0.files.borrow();
138		ro_map.get(name).map(|value| value.0.clone())148		ro_map.get(name).map(|value| value.0.clone())
139	}149	}
140	pub fn evaluate_file(&self, name: &PathBuf) -> Result<Val> {150	pub fn evaluate_file(&self, name: &PathBuf) -> Result<Val> {
151		self.begin_state();
152		let value = self.evaluate_file_in_current_state(name)?;
153		self.end_state();
154		Ok(value)
155	}
141		self.begin_state();156	pub(crate) fn evaluate_file_in_current_state(&self, name: &PathBuf) -> Result<Val> {
142		let expr: LocExpr = {157		let expr: LocExpr = {
143			let ro_map = self.0.files.borrow();158			let ro_map = self.0.files.borrow();
144			let value = ro_map159			let value = ro_map
159				.2174				.2
160				.replace(value.clone());175				.replace(value.clone());
161		}176		}
177		Ok(value)
178	}
179	pub(crate) fn import_file(&self, path: &PathBuf) -> Result<Val> {
180		if !self.0.files.borrow().contains_key(path) {
181			let file_str = (self.0.settings.import_resolver)(path);
162		self.end_state();182			self.add_file(path.clone(), file_str).unwrap();
183		}
163		Ok(value)184		self.evaluate_file_in_current_state(path)
164	}185	}
165186
166	pub fn parse_evaluate_raw(&self, code: &str) -> Result<Val> {187	pub fn parse_evaluate_raw(&self, code: &str) -> Result<Val> {
167		let parsed = parse(188		let parsed = parse(