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

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -137,15 +137,21 @@
 	StandaloneSuper,
 
 	#[error("can't resolve {1} from {0}")]
-	ImportFileNotFound(PathBuf, String),
+	ImportFileNotFound(SourcePath, String),
+	#[error("can't resolve absolute {0}")]
+	AbsoluteImportFileNotFound(PathBuf),
 	#[error("resolved file not found: {:?}", .0)]
 	ResolvedFileNotFound(SourcePath),
+	#[error("can't import {0}: is a directory")]
+	ImportIsADirectory(SourcePath),
 	#[error("imported file is not valid utf-8: {0:?}")]
 	ImportBadFileUtf8(SourcePath),
 	#[error("import io error: {0}")]
 	ImportIo(String),
-	#[error("tried to import {1} from {0}, but imports is not supported")]
-	ImportNotSupported(PathBuf, PathBuf),
+	#[error("tried to import {1} from {0}, but imports are not supported")]
+	ImportNotSupported(SourcePath, String),
+	#[error("tried to import {0}, but absolute imports are not supported")]
+	AbsoluteImportNotSupported(PathBuf),
 	#[error("can't import from virtual file")]
 	CantImportFromVirtualFile,
 	#[error(

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -630,15 +630,7 @@
 		}
 		i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {
 			let tmp = loc.clone().0;
-			let import_location = tmp
-				.path()
-				.map(|p| {
-					let mut p = p.to_owned();
-					p.pop();
-					p
-				})
-				.unwrap_or_default();
-			let resolved_path = s.resolve_file(&import_location, path as &str)?;
+			let resolved_path = s.resolve_from(tmp.source_path(), path as &str)?;
 			match i {
 				Import(_) => s.push(
 					CallLocation::new(loc),

--- a/crates/jrsonnet-evaluator/src/import.rs
+++ b/crates/jrsonnet-evaluator/src/import.rs
@@ -1,51 +1,60 @@
 use std::{
 	any::Any,
+	cell::RefCell,
+	env::current_dir,
 	fs,
-	io::Read,
+	io::{ErrorKind, Read},
 	path::{Path, PathBuf},
 };
 
 use fs::File;
-use jrsonnet_parser::SourcePath;
+use jrsonnet_parser::{SourceDirectory, SourceFile, SourcePath};
 
 use crate::{
-	error::{Error::*, Result},
+	error::{
+		Error::{self, *},
+		Result,
+	},
 	throw,
 };
 
 /// Implements file resolution logic for `import` and `importStr`
 pub trait ImportResolver {
-	/// Resolves real file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond
+	/// Resolves file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond
 	/// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`
 	/// where `${vendor}` is a library path.
-	fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath>;
+	///
+	/// `from` should only be returned from [`ImportResolver::resolve`], or from other defined file, any other value
+	/// may result in panic
+	fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {
+		throw!(ImportNotSupported(from.clone(), path.into()))
+	}
+	fn resolve_from_default(&self, path: &str) -> Result<SourcePath> {
+		self.resolve_from(&SourcePath::default(), path)
+	}
+	/// Resolves absolute path, doesn't supports jpath and other fancy things
+	fn resolve(&self, path: &Path) -> Result<SourcePath> {
+		throw!(AbsoluteImportNotSupported(path.to_owned()))
+	}
 
 	/// Load resolved file
-	/// This should only be called with value returned from `resolve_file`, this cannot be resolved using associated type,
-	/// as evaluator uses object instead of generic for [`ImportResolver`]
+	/// This should only be called with value returned from [`ImportResolver::resolve_file`]/[`ImportResolver::resolve`],
+	/// this cannot be resolved using associated type, as evaluator uses object instead of generic for [`ImportResolver`]
 	fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>>;
 
-	/// # Safety
-	///
-	/// For use only in bindings, should not be used elsewhere.
-	/// Implementations which are not intended to be used in bindings
-	/// should panic on call to this method.
-	unsafe fn as_any(&self) -> &dyn Any;
+	/// For downcasts
+	fn as_any(&self) -> &dyn Any;
 }
 
 /// Dummy resolver, can't resolve/load any file
 pub struct DummyImportResolver;
 impl ImportResolver for DummyImportResolver {
-	fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath> {
-		throw!(ImportNotSupported(from.into(), path.into()))
-	}
-
 	fn load_file_contents(&self, _resolved: &SourcePath) -> Result<Vec<u8>> {
 		panic!("dummy resolver can't load any file")
 	}
 
-	unsafe fn as_any(&self) -> &dyn Any {
-		panic!("`as_any(&self)` is not supported by dummy resolver")
+	fn as_any(&self) -> &dyn Any {
+		self
 	}
 }
 #[allow(clippy::use_self)]
@@ -60,36 +69,82 @@
 pub struct FileImportResolver {
 	/// Library directories to search for file.
 	/// Referred to as `jpath` in original jsonnet implementation.
-	pub library_paths: Vec<PathBuf>,
+	library_paths: RefCell<Vec<PathBuf>>,
 }
+impl FileImportResolver {
+	pub fn new(jpath: Vec<PathBuf>) -> Self {
+		Self {
+			library_paths: RefCell::new(jpath),
+		}
+	}
+	/// Dynamically add new jpath, used by bindings
+	pub fn add_jpath(&self, path: PathBuf) {
+		self.library_paths.borrow_mut().push(path);
+	}
+}
 impl ImportResolver for FileImportResolver {
-	fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath> {
-		let mut direct = from.to_path_buf();
+	fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {
+		let mut direct = if let Some(f) = from.downcast_ref::<SourceFile>() {
+			let mut o = f.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| Error::ImportIo(e.to_string()))?
+		} else {
+			unreachable!("resolver can't return this path")
+		};
 		direct.push(path);
-		if direct.exists() {
-			Ok(SourcePath::Path(
+		if direct.is_file() {
+			Ok(SourcePath::new(SourceFile::new(
 				direct.canonicalize().map_err(|e| ImportIo(e.to_string()))?,
-			))
+			)))
 		} else {
-			for library_path in &self.library_paths {
+			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(
+					return Ok(SourcePath::new(SourceFile::new(
 						cloned.canonicalize().map_err(|e| ImportIo(e.to_string()))?,
-					));
+					)));
 				}
 			}
-			throw!(ImportFileNotFound(from.to_owned(), path.to_owned()))
+			throw!(ImportFileNotFound(from.clone(), path.to_owned()))
+		}
+	}
+	fn resolve(&self, path: &Path) -> Result<SourcePath> {
+		let meta = match fs::metadata(path) {
+			Ok(v) => v,
+			Err(e) if e.kind() == ErrorKind::NotFound => {
+				throw!(AbsoluteImportFileNotFound(path.to_owned()))
+			}
+			Err(e) => throw!(Error::ImportIo(e.to_string())),
+		};
+		if meta.is_file() {
+			Ok(SourcePath::new(SourceFile::new(
+				path.canonicalize()
+					.map_err(|e| ImportIo(e.to_string()))?
+					.to_owned(),
+			)))
+		} else if meta.is_dir() {
+			Ok(SourcePath::new(SourceDirectory::new(
+				path.canonicalize()
+					.map_err(|e| ImportIo(e.to_string()))?
+					.to_owned(),
+			)))
+		} else {
+			unreachable!("this can't be a symlink")
 		}
 	}
 
 	fn load_file_contents(&self, id: &SourcePath) -> Result<Vec<u8>> {
-		let path = match id {
-			SourcePath::Path(path) => path,
-			_ => {
-				panic!("this resolver can only resolve to path")
-			}
+		let path = if let Some(f) = id.downcast_ref::<SourceFile>() {
+			f.path()
+		} else if id.downcast_ref::<SourceDirectory>().is_some() || id.is_default() {
+			throw!(Error::ImportIsADirectory(id.clone()))
+		} else {
+			unreachable!("other types are not supported in resolve");
 		};
 		let mut file = File::open(path).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
 		let mut out = Vec::new();
@@ -97,7 +152,12 @@
 			.map_err(|e| ImportIo(e.to_string()))?;
 		Ok(out)
 	}
-	unsafe fn as_any(&self) -> &dyn Any {
-		panic!("this resolver can't be used as any")
+
+	fn as_any(&self) -> &dyn Any {
+		self
+	}
+
+	fn resolve_from_default(&self, path: &str) -> Result<SourcePath> {
+		self.resolve_from(&SourcePath::default(), path)
 	}
 }

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -44,7 +44,6 @@
 
 use std::{
 	any::Any,
-	borrow::Cow,
 	cell::{Ref, RefCell, RefMut},
 	collections::HashMap,
 	fmt::{self, Debug},
@@ -103,12 +102,7 @@
 pub trait ContextInitializer {
 	fn initialize(&self, state: State, for_file: Source) -> Context;
 
-	/// # Safety
-	///
-	/// For use only in bindings, should not be used elsewhere.
-	/// Implementations which are not intended to be used in bindings
-	/// should panic on call to this method.
-	unsafe fn as_any(&self) -> &dyn Any;
+	fn as_any(&self) -> &dyn Any;
 }
 
 /// Context initializer, which adds noth
@@ -117,8 +111,8 @@
 	fn initialize(&self, _state: State, _for_file: Source) -> Context {
 		Context::default()
 	}
-	unsafe fn as_any(&self) -> &dyn Any {
-		panic!("`as_any(&self)` is not supported by dummy initializer")
+	fn as_any(&self) -> &dyn Any {
+		self
 	}
 }
 
@@ -343,8 +337,7 @@
 			);
 		}
 		let code = file.string.as_ref().expect("just set");
-		let file_name =
-			Source::new(path.clone(), code.clone()).expect("resolver should return correct name");
+		let file_name = Source::new(path.clone(), code.clone());
 		if file.parsed.is_none() {
 			file.parsed = Some(
 				jrsonnet_parser::parse(
@@ -388,8 +381,14 @@
 			Err(e) => Err(e),
 		}
 	}
-	pub fn import(&self, from: &Path, path: &str) -> Result<Val> {
-		let resolved = self.resolve_file(from, path)?;
+
+	/// Has same semantics as `import 'path'` called from `from` file
+	pub fn import_from(&self, from: &SourcePath, path: &str) -> Result<Val> {
+		let resolved = self.resolve_from(from, path)?;
+		self.import_resolved(resolved)
+	}
+	pub fn import(&self, path: &impl AsRef<Path>) -> Result<Val> {
+		let resolved = self.resolve(path)?;
 		self.import_resolved(resolved)
 	}
 
@@ -532,7 +531,7 @@
 					func.evaluate(
 						self.clone(),
 						self.create_default_context(Source::new_virtual(
-							Cow::Borrowed("<tla>"),
+							"<tla>".into(),
 							IStr::empty(),
 						)),
 						CallLocation::native(),
@@ -565,9 +564,9 @@
 /// Raw methods evaluate passed values but don't perform TLA execution
 impl State {
 	/// Parses and evaluates the given snippet
-	pub fn evaluate_snippet(&self, name: String, code: impl Into<IStr>) -> Result<Val> {
+	pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {
 		let code = code.into();
-		let source = Source::new_virtual(Cow::Owned(name), code.clone());
+		let source = Source::new_virtual(name.into(), code.clone());
 		let parsed = jrsonnet_parser::parse(
 			&code,
 			&ParserSettings {
@@ -596,7 +595,7 @@
 	}
 	pub fn add_tla_code(&self, name: IStr, code: &str) -> Result<()> {
 		let source_name = format!("<top-level-arg:{}>", name);
-		let source = Source::new_virtual(Cow::Owned(source_name), code.into());
+		let source = Source::new_virtual(source_name.into(), code.into());
 		let parsed = jrsonnet_parser::parse(
 			code,
 			&ParserSettings {
@@ -613,12 +612,17 @@
 		Ok(())
 	}
 
-	pub fn resolve_file(&self, from: &Path, path: &str) -> Result<SourcePath> {
-		self.settings()
-			.import_resolver
-			.resolve_file_relative(from, path.as_ref())
+	// Only panics in case of [`ImportResolver`] contract violation
+	#[allow(clippy::missing_panics_doc)]
+	pub fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {
+		self.import_resolver().resolve_from(from, path.as_ref())
 	}
 
+	// Only panics in case of [`ImportResolver`] contract violation
+	#[allow(clippy::missing_panics_doc)]
+	pub fn resolve(&self, path: &impl AsRef<Path>) -> Result<SourcePath> {
+		self.import_resolver().resolve(path.as_ref())
+	}
 	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {
 		Ref::map(self.settings(), |s| &*s.import_resolver)
 	}