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

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -4,19 +4,18 @@
 	any::Any,
 	cell::RefCell,
 	collections::HashMap,
+	env::current_dir,
 	ffi::{c_void, CStr, CString},
-	fs::File,
-	io::Read,
 	os::raw::{c_char, c_int},
-	path::{Path, PathBuf},
+	path::PathBuf,
 	ptr::null_mut,
 };
 
 use jrsonnet_evaluator::{
 	error::{Error::*, Result},
-	throw, ImportResolver, State,
+	throw, FileImportResolver, ImportResolver, State,
 };
-use jrsonnet_parser::SourcePath;
+use jrsonnet_parser::{SourceDirectory, SourceFile, SourcePath};
 
 pub type JsonnetImportCallback = unsafe extern "C" fn(
 	ctx: *mut c_void,
@@ -33,25 +32,31 @@
 	out: RefCell<HashMap<SourcePath, Vec<u8>>>,
 }
 impl ImportResolver for CallbackImportResolver {
-	fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath> {
-		let base = CString::new(from.to_str().unwrap()).unwrap().into_raw();
-		let rel = CString::new(path).unwrap().into_raw();
+	fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {
+		let base = if let Some(p) = from.downcast_ref::<SourceFile>() {
+			let mut o = p.path().to_owned();
+			o.pop();
+			o
+		} else if let Some(d) = from.downcast_ref::<SourceDirectory>() {
+			d.path().to_owned()
+		} else if from.is_default() {
+			current_dir().map_err(|e| ImportIo(e.to_string()))?
+		} else {
+			unreachable!("can't resolve this path");
+		};
+		let base = unsafe { crate::unparse_path(&base) };
+		let rel = CString::new(path).unwrap();
 		let found_here: *mut c_char = null_mut();
 		let mut success: i32 = 0;
 		let result_ptr = unsafe {
 			(self.cb)(
 				self.ctx,
-				base,
-				rel,
+				base.as_ptr(),
+				rel.as_ptr(),
 				&mut (found_here as *const _),
 				&mut success,
 			)
 		};
-		// Release memory occipied by arguments passed
-		unsafe {
-			let _ = CString::from_raw(base);
-			let _ = CString::from_raw(rel);
-		}
 		let result_raw = unsafe { CStr::from_ptr(result_ptr) };
 		let result_str = result_raw.to_str().unwrap();
 		assert!(success == 0 || success == 1);
@@ -62,7 +67,9 @@
 		}
 
 		let found_here_raw = unsafe { CStr::from_ptr(found_here) };
-		let found_here_buf = SourcePath::Path(PathBuf::from(found_here_raw.to_str().unwrap()));
+		let found_here_buf = SourcePath::new(SourceFile::new(PathBuf::from(
+			found_here_raw.to_str().unwrap(),
+		)));
 		unsafe {
 			let _ = CString::from_raw(found_here);
 		}
@@ -79,12 +86,14 @@
 		Ok(self.out.borrow().get(resolved).unwrap().clone())
 	}
 
-	unsafe fn as_any(&self) -> &dyn Any {
+	fn as_any(&self) -> &dyn Any {
 		self
 	}
 }
 
 /// # Safety
+///
+/// Caller should pass correct callback function
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_import_callback(
 	vm: &State,
@@ -96,54 +105,11 @@
 		ctx,
 		out: RefCell::new(HashMap::new()),
 	}))
-}
-
-/// Standard FS import resolver
-#[derive(Default)]
-pub struct NativeImportResolver {
-	library_paths: RefCell<Vec<PathBuf>>,
-}
-impl NativeImportResolver {
-	fn add_jpath(&self, path: PathBuf) {
-		self.library_paths.borrow_mut().push(path);
-	}
 }
-impl ImportResolver for NativeImportResolver {
-	fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath> {
-		let mut new_path = from.to_owned();
-		new_path.push(path);
-		if new_path.exists() {
-			Ok(SourcePath::Path(new_path))
-		} else {
-			for library_path in self.library_paths.borrow().iter() {
-				let mut cloned = library_path.clone();
-				cloned.push(path);
-				if cloned.exists() {
-					return Ok(SourcePath::Path(cloned));
-				}
-			}
-			throw!(ImportFileNotFound(from.to_owned(), path.to_owned()))
-		}
-	}
-	fn load_file_contents(&self, id: &SourcePath) -> Result<Vec<u8>> {
-		let path = match id {
-			SourcePath::Path(path) => path,
-			_ => unreachable!("NativeImportResolver::resolve_file may only return plain paths"),
-		};
-		let mut file = File::open(path).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
-		let mut out = Vec::new();
-		file.read_to_end(&mut out)
-			.map_err(|e| ImportIo(e.to_string()))?;
-		Ok(out)
-	}
-	unsafe fn as_any(&self) -> &dyn Any {
-		self
-	}
-}
 
 /// # Safety
 ///
-/// This function is safe, if received v is a pointer to normal C string
+/// Caller should pass correct path: it should contain correct utf-8, and be \0-terminated
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_jpath_add(vm: &State, v: *const c_char) {
 	let cstr = CStr::from_ptr(v);
@@ -151,7 +117,7 @@
 	let any_resolver = vm.import_resolver();
 	let resolver = any_resolver
 		.as_any()
-		.downcast_ref::<NativeImportResolver>()
+		.downcast_ref::<FileImportResolver>()
 		.expect("jpaths are not compatible with callback imports!");
 	resolver.add_jpath(path);
 }

--- a/cmds/jrsonnet/Cargo.toml
+++ b/cmds/jrsonnet/Cargo.toml
@@ -19,6 +19,8 @@
 ]
 # Destructuring of locals
 exp-destruct = ["jrsonnet-evaluator/exp-destruct"]
+# std.thisFile support
+legacy-this-file = ["jrsonnet-cli/legacy-this-file"]
 
 [dependencies]
 jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.4.2" }

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -1,5 +1,4 @@
 use std::{
-	env::current_dir,
 	fs::{create_dir_all, File},
 	io::{Read, Write},
 };
@@ -140,7 +139,7 @@
 		let input_str = std::str::from_utf8(&input)?;
 		s.evaluate_snippet("<stdin>".to_owned(), input_str)?
 	} else {
-		s.import(&current_dir().expect("cwd"), &input)?
+		s.import(&input)?
 	};
 
 	let val = s.with_tla(val)?;

--- a/crates/jrsonnet-cli/Cargo.toml
+++ b/crates/jrsonnet-cli/Cargo.toml
@@ -15,6 +15,7 @@
     "jrsonnet-evaluator/exp-serde-preserve-order",
     "jrsonnet-stdlib/exp-serde-preserve-order",
 ]
+legacy-this-file = ["jrsonnet-stdlib/legacy-this-file"]
 
 [dependencies]
 jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.4.2", features = [

--- a/crates/jrsonnet-cli/src/lib.rs
+++ b/crates/jrsonnet-cli/src/lib.rs
@@ -51,7 +51,7 @@
 			library_paths.extend(env::split_paths(path.as_os_str()));
 		}
 
-		s.set_import_resolver(Box::new(FileImportResolver { library_paths }));
+		s.set_import_resolver(Box::new(FileImportResolver::new(library_paths)));
 
 		s.set_max_stack(self.max_stack);
 		Ok(())

--- a/crates/jrsonnet-cli/src/stdlib.rs
+++ b/crates/jrsonnet-cli/src/stdlib.rs
@@ -1,7 +1,7 @@
 use std::{fs::read_to_string, str::FromStr};
 
 use clap::Parser;
-use jrsonnet_evaluator::{error::Result, State};
+use jrsonnet_evaluator::{error::Result, trace::PathResolver, State};
 
 use crate::ConfigureState;
 
@@ -110,7 +110,8 @@
 		if self.no_stdlib {
 			return Ok(());
 		}
-		let ctx = jrsonnet_stdlib::ContextInitializer::new(s.clone());
+		let ctx =
+			jrsonnet_stdlib::ContextInitializer::new(s.clone(), PathResolver::new_cwd_fallback());
 		for ext in self.ext_str.iter() {
 			ctx.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
 		}

--- a/crates/jrsonnet-cli/src/trace.rs
+++ b/crates/jrsonnet-cli/src/trace.rs
@@ -42,11 +42,7 @@
 }
 impl ConfigureState for TraceOpts {
 	fn configure(&self, s: &State) -> Result<()> {
-		let resolver = if let Ok(dir) = std::env::current_dir() {
-			PathResolver::Relative(dir)
-		} else {
-			PathResolver::Absolute
-		};
+		let resolver = PathResolver::new_cwd_fallback();
 		match self
 			.trace_format
 			.as_ref()

--- a/crates/jrsonnet-interner/src/inner.rs
+++ b/crates/jrsonnet-interner/src/inner.rs
@@ -84,7 +84,9 @@
 		unsafe { Self::new_raw(str.as_bytes(), true) }
 	}
 
-	pub const fn as_slice(&self) -> &[u8] {
+	// `slice::from_raw_parts` is not yet stabilized
+	#[allow(clippy::missing_const_for_fn)]
+	pub fn as_slice(&self) -> &[u8] {
 		let header = Self::header(self);
 		// SAFETY: data is not null, and it is correctly initialized
 		let size = unsafe { (*header).size };
@@ -99,7 +101,7 @@
 
 	/// # Safety
 	/// Data should be checked to be utf8 via [`check_utf8`] first
-	pub const unsafe fn as_str_unchecked(&self) -> &str {
+	pub unsafe fn as_str_unchecked(&self) -> &str {
 		// SAFETY: data is checked
 		unsafe { str::from_utf8_unchecked(self.as_slice()) }
 	}

--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -133,7 +133,7 @@
 	}
 
 	#[must_use]
-	pub const fn as_slice(&self) -> &[u8] {
+	pub fn as_slice(&self) -> &[u8] {
 		self.0.as_slice()
 	}
 }

--- a/crates/jrsonnet-stdlib/build.rs
+++ b/crates/jrsonnet-stdlib/build.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Cow, env, fs::File, io::Write, path::Path};
+use std::{env, fs::File, io::Write, path::Path};
 
 use jrsonnet_parser::{parse, ParserSettings, Source};
 use structdump::CodegenResult;
@@ -8,7 +8,7 @@
 		include_str!("./src/std.jsonnet"),
 		&ParserSettings {
 			file_name: Source::new_virtual(
-				Cow::Borrowed("<std>"),
+				"<std>".into(),
 				include_str!("./src/std.jsonnet").into(),
 			),
 		},

--- a/crates/jrsonnet-stdlib/src/expr.rs
+++ b/crates/jrsonnet-stdlib/src/expr.rs
@@ -1,7 +1,7 @@
 use jrsonnet_parser::LocExpr;
 
 mod structdump_import {
-	pub(super) use std::{borrow::Cow, option::Option, rc::Rc, vec};
+	pub(super) use std::{option::Option, rc::Rc, vec};
 
 	pub(super) use jrsonnet_parser::*;
 }

1use std::{1use std::{
2	borrow::Cow,
3	cell::{Ref, RefCell, RefMut},2	cell::{Ref, RefCell, RefMut},
4	collections::HashMap,3	collections::HashMap,
5	rc::Rc,4	rc::Rc,
10	function::{builtin::Builtin, ArgLike, CallLocation, FuncVal, TlaArg},9	function::{builtin::Builtin, ArgLike, CallLocation, FuncVal, TlaArg},
11	gc::{GcHashMap, TraceBox},10	gc::{GcHashMap, TraceBox},
12	tb, throw_runtime,11	tb, throw_runtime,
12	trace::PathResolver,
13	typed::{Any, Either, Either2, Either4, VecVal, M1},13	typed::{Any, Either, Either2, Either4, VecVal, M1},
14	val::{equals, ArrValue},14	val::{equals, ArrValue},
15	Context, ContextBuilder, IStr, ObjValue, ObjValueBuilder, State, Thunk, Val,15	Context, ContextBuilder, IStr, ObjValue, ObjValueBuilder, State, Thunk, Val,
184	fn print_trace(&self, s: State, loc: CallLocation, value: IStr);184	fn print_trace(&self, s: State, loc: CallLocation, value: IStr);
185}185}
186186
187pub struct StdTracePrinter;187pub struct StdTracePrinter {
188	resolver: PathResolver,
189}
190impl StdTracePrinter {
191	pub fn new(resolver: PathResolver) -> Self {
192		Self { resolver }
193	}
194}
188impl TracePrinter for StdTracePrinter {195impl TracePrinter for StdTracePrinter {
189	fn print_trace(&self, _s: State, loc: CallLocation, value: IStr) {196	fn print_trace(&self, _s: State, loc: CallLocation, value: IStr) {
190		eprint!("TRACE:");197		eprint!("TRACE:");
191		if let Some(loc) = loc.0 {198		if let Some(loc) = loc.0 {
192			let locs = loc.0.map_source_locations(&[loc.1]);199			let locs = loc.0.map_source_locations(&[loc.1]);
193			eprint!(" {}:{}", loc.0.short_display(), locs[0].line);200			eprint!(
201				" {}:{}",
202				match loc.0.source_path().path() {
203					Some(p) => self.resolver.resolve(p),
204					None => loc.0.source_path().to_string(),
205				},
206				locs[0].line
207			);
194		}208		}
195		eprintln!(" {}", value);209		eprintln!(" {}", value);
196	}210	}
197}211}
198212
199pub struct Settings {213pub struct Settings {
200	/// Used for `std.extVar`214	/// Used for `std.extVar`
201	pub ext_vars: HashMap<IStr, TlaArg>,215	pub ext_vars: HashMap<IStr, TlaArg>,
202	/// Used for `std.native`216	/// Used for `std.native`
205	pub globals: GcHashMap<IStr, Thunk<Val>>,219	pub globals: GcHashMap<IStr, Thunk<Val>>,
206	/// Used for `std.trace`220	/// Used for `std.trace`
207	pub trace_printer: Box<dyn TracePrinter>,221	pub trace_printer: Box<dyn TracePrinter>,
208}222	/// Used for `std.thisFile`
209
210impl Default for Settings {
211	fn default() -> Self {
212		Self {
213			ext_vars: Default::default(),
214			ext_natives: Default::default(),223	pub path_resolver: PathResolver,
215			globals: Default::default(),224}
216			trace_printer: Box::new(StdTracePrinter),
217		}
218	}
219}
220225
221pub fn extvar_source(name: &str, code: impl Into<IStr>) -> Source {226pub fn extvar_source(name: &str, code: impl Into<IStr>) -> Source {
222	let source_name = format!("<extvar:{}>", name);227	let source_name = format!("<extvar:{}>", name);
223	Source::new_virtual(Cow::Owned(source_name), code.into())228	Source::new_virtual(source_name.into(), code.into())
224}229}
225230
226pub struct ContextInitializer {231pub struct ContextInitializer {
233	settings: Rc<RefCell<Settings>>,238	settings: Rc<RefCell<Settings>>,
234}239}
235impl ContextInitializer {240impl ContextInitializer {
236	pub fn new(s: State) -> Self {241	pub fn new(s: State, resolver: PathResolver) -> Self {
237		let settings = Rc::new(RefCell::new(Settings::default()));242		let settings = Settings {
243			ext_vars: Default::default(),
244			ext_natives: Default::default(),
245			globals: Default::default(),
246			trace_printer: Box::new(StdTracePrinter::new(resolver.clone())),
247			path_resolver: resolver,
248		};
249		let settings = Rc::new(RefCell::new(settings));
238		Self {250		Self {
239			#[cfg(not(feature = "legacy-this-file"))]251			#[cfg(not(feature = "legacy-this-file"))]
240			context: {252			context: {
313			.hide()325			.hide()
314			.value(326			.value(
315				s,327				s,
316				Val::Str(328				Val::Str(match source.source_path().path() {
317					source
318						.path()329					Some(p) => self.settings().path_resolver.resolve(p).into(),
319						.map(|p| p.display().to_string())
320						.unwrap_or_else(String::new)
321						.into(),330					None => source.source_path().to_string().into(),
322				),331				}),
323			)332			)
324			.expect("this object builder is empty");333			.expect("this object builder is empty");
325		let stdlib_with_this_file = builder.build();334		let stdlib_with_this_file = builder.build();
329			"std".into(),338			"std".into(),
330			Thunk::evaluated(Val::Obj(stdlib_with_this_file)),339			Thunk::evaluated(Val::Obj(stdlib_with_this_file)),
331		);340		);
332		for (k, v) in &self.settings().globals {341		for (k, v) in self.settings().globals.iter() {
333			context.bind(k.clone(), v.clone())342			context.bind(k.clone(), v.clone());
334		}343		}
335		context.build()344		context.build()
336	}345	}
337	unsafe fn as_any(&self) -> &dyn std::any::Any {346	fn as_any(&self) -> &dyn std::any::Any {
338		self347		self
339	}348	}
340}349}
540549
541impl StateExt for State {550impl StateExt for State {
542	fn with_stdlib(&self) {551	fn with_stdlib(&self) {
543		let initializer = ContextInitializer::new(self.clone());552		let initializer = ContextInitializer::new(self.clone(), PathResolver::new_cwd_fallback());
544		self.settings_mut().context_initializer = Box::new(initializer)553		self.settings_mut().context_initializer = Box::new(initializer)
545	}554	}
546	fn add_global(&self, name: IStr, value: Thunk<Val>) {555	fn add_global(&self, name: IStr, value: Thunk<Val>) {
547		// Safety:
548		unsafe { self.settings().context_initializer.as_any() }556		self.settings()
557			.context_initializer
558			.as_any()
549			.downcast_ref::<ContextInitializer>()559			.downcast_ref::<ContextInitializer>()

--- a/crates/jrsonnet-stdlib/src/std.jsonnet
+++ b/crates/jrsonnet-stdlib/src/std.jsonnet
@@ -2,7 +2,7 @@
   local std = self,
   local id = std.id,
 
-  thisFile:: error 'std.thisFile is deprecated, to enable its support in jrsonnet - recompile it with "legacy-this-file" support. This will slow down stdlib caching a bit, though',
+  thisFile:: error 'std.thisFile is deprecated, to enable its support in jrsonnet - recompile it with "legacy-this-file" support.\nThis will slow down stdlib caching a bit, though',
 
   toString(a):: '' + a,
 

--- a/tests/tests/golden.rs
+++ b/tests/tests/golden.rs
@@ -21,7 +21,7 @@
 	common::with_test(&s);
 	s.set_import_resolver(Box::new(FileImportResolver::default()));
 
-	let v = match s.import(root, &file.display().to_string()) {
+	let v = match s.import(file) {
 		Ok(v) => v,
 		Err(e) => return s.stringify_err(&e),
 	};

--- a/tests/tests/suite.rs
+++ b/tests/tests/suite.rs
@@ -21,7 +21,7 @@
 	common::with_test(&s);
 	s.set_import_resolver(Box::new(FileImportResolver::default()));
 
-	match s.import(root, &file.display().to_string()) {
+	match s.import(file) {
 		Ok(Val::Bool(true)) => {}
 		Ok(Val::Bool(false)) => panic!("test {} returned false", file.display()),
 		Ok(_) => panic!("test {} returned wrong type as result", file.display()),