git.delta.rocks / jrsonnet / refs/commits / 2cecfb0ba471

55
6use clap::{CommandFactory, Parser};6use clap::{CommandFactory, Parser};
7use clap_complete::Shell;7use clap_complete::Shell;
8use jrsonnet_cli::{ConfigureState, GeneralOpts, ManifestOpts, OutputOpts, TraceOpts};8use jrsonnet_cli::{ManifestOpts, OutputOpts, TraceOpts, MiscOpts, TlaOpts, StdOpts, GcOpts};
9use jrsonnet_evaluator::{9use jrsonnet_evaluator::{
10	apply_tla,10	apply_tla,
11	error::{Error as JrError, ErrorKind},11	error::{Error as JrError, ErrorKind},
60	#[clap(flatten)]60	#[clap(flatten)]
61	input: InputOpts,61	input: InputOpts,
62	#[clap(flatten)]62	#[clap(flatten)]
63	general: GeneralOpts,63	misc: MiscOpts,
64	#[clap(flatten)]
65	tla: TlaOpts,
66	#[clap(flatten)]
67	std: StdOpts,
68	#[clap(flatten)]
69	gc: GcOpts,
6470
65	#[clap(flatten)]71	#[clap(flatten)]
66	trace: TraceOpts,72	trace: TraceOpts,
129	let s = State::default();135	let s = State::default();
130	let trace = opts136	let trace = opts
131		.trace137		.trace
132		.configure(&s)
133		.expect("this configurator doesn't fail");138		.trace_format();
134	if let Err(e) = main_real(&s, opts) {139	if let Err(e) = main_real(&s, opts) {
135		if let Error::Evaluation(e) = e {140		if let Error::Evaluation(e) = e {
136			let mut out = String::new();141			let mut out = String::new();
145}150}
146151
147fn main_real(s: &State, opts: Opts) -> Result<(), Error> {152fn main_real(s: &State, opts: Opts) -> Result<(), Error> {
148	let (tla, _gc_guard) = opts.general.configure(s)?;153	let _gc_leak_guard= opts.gc.leak_on_exit();
154	let _gc_print_stats = opts.gc.stats_printer();
155	let _stack_depth_override = opts.misc.stack_size_override();
156
157	let import_resolver = opts.misc.import_resolver();
158	s.set_import_resolver(import_resolver);
159
149	let manifest_format = opts.manifest.configure(s)?;160	let std = opts.std.context_initializer(s)?;
161	if let Some(std) = std {
162		s.set_context_initializer(std);
163	}
150164
151	let input = opts.input.input.ok_or(Error::MissingInputArgument)?;165	let input = opts.input.input.ok_or(Error::MissingInputArgument)?;
152	let val = if opts.input.exec {166	let val = if opts.input.exec {
160		s.import(&input)?174		s.import(&input)?
161	};175	};
162176
177	let tla = opts.tla.tla_opts()?;
163	let val = apply_tla(s.clone(), &tla, val)?;178	let val = apply_tla(s.clone(), &tla, val)?;
164179
180	let manifest_format = opts.manifest.manifest_format();
165	if let Some(multi) = opts.output.multi {181	if let Some(multi) = opts.output.multi {
166		if opts.output.create_output_dirs {182		if opts.output.create_output_dirs {
167			let mut dir = multi.clone();183			let mut dir = multi.clone();

--- a/crates/jrsonnet-cli/src/lib.rs
+++ b/crates/jrsonnet-cli/src/lib.rs
@@ -6,19 +6,13 @@
 use std::{env, marker::PhantomData, path::PathBuf};
 
 use clap::Parser;
-use jrsonnet_evaluator::{error::Result, stack::set_stack_depth_limit, FileImportResolver, State};
+use jrsonnet_evaluator::{error::Result, stack::{set_stack_depth_limit, StackDepthLimitOverrideGuard, limit_stack_depth}, FileImportResolver, State, ImportResolver};
 use jrsonnet_gcmodule::with_thread_object_space;
 pub use manifest::*;
 pub use stdlib::*;
 pub use tla::*;
 pub use trace::*;
-
-pub trait ConfigureState {
-	type Guards;
 
-	fn configure(&self, s: &State) -> Result<Self::Guards>;
-}
-
 #[derive(Parser)]
 #[clap(next_help_heading = "INPUT")]
 pub struct InputOpts {
@@ -45,50 +39,18 @@
 	#[clap(long, short = 'J')]
 	jpath: Vec<PathBuf>,
 }
-impl ConfigureState for MiscOpts {
-	type Guards = ();
-	fn configure(&self, s: &State) -> Result<Self::Guards> {
+impl MiscOpts {
+	pub fn import_resolver(&self) -> FileImportResolver {
 		let mut library_paths = self.jpath.clone();
 		library_paths.reverse();
 		if let Some(path) = env::var_os("JSONNET_PATH") {
 			library_paths.extend(env::split_paths(path.as_os_str()));
 		}
 
-		s.set_import_resolver(FileImportResolver::new(library_paths));
-
-		set_stack_depth_limit(self.max_stack);
-		Ok(())
+		FileImportResolver::new(library_paths)
 	}
-}
-
-/// General configuration of jsonnet
-#[derive(Parser)]
-#[clap(name = "jrsonnet", version, author)]
-pub struct GeneralOpts {
-	#[clap(flatten)]
-	misc: MiscOpts,
-
-	#[clap(flatten)]
-	tla: TlaOpts,
-	#[clap(flatten)]
-	std: StdOpts,
-
-	#[clap(flatten)]
-	gc: GcOpts,
-}
-
-impl ConfigureState for GeneralOpts {
-	type Guards = (
-		<TlaOpts as ConfigureState>::Guards,
-		<GcOpts as ConfigureState>::Guards,
-	);
-	fn configure(&self, s: &State) -> Result<Self::Guards> {
-		// Configure trace first, because tla-code/ext-code can throw
-		self.misc.configure(s)?;
-		let tla_guards = self.tla.configure(s)?;
-		self.std.configure(s)?;
-		let gc_guards = self.gc.configure(s)?;
-		Ok((tla_guards, gc_guards))
+	pub fn stack_size_override(&self) -> StackDepthLimitOverrideGuard {
+		limit_stack_depth(self.max_stack)
 	}
 }
 
@@ -107,18 +69,14 @@
 	#[clap(long)]
 	gc_collect_before_printing_stats: bool,
 }
-impl ConfigureState for GcOpts {
-	type Guards = (Option<GcStatsPrinter>, Option<LeakSpace>);
-
-	fn configure(&self, _s: &State) -> Result<Self::Guards> {
-		// Constructed structs have side-effects in Drop impl
-		#[allow(clippy::unnecessary_lazy_evaluations)]
-		Ok((
-			self.gc_print_stats.then(|| GcStatsPrinter {
-				collect_before_printing_stats: self.gc_collect_before_printing_stats,
-			}),
-			(!self.gc_collect_on_exit).then(|| LeakSpace(PhantomData)),
-		))
+impl GcOpts {
+	pub fn stats_printer(&self) -> Option<GcStatsPrinter> {
+		self.gc_print_stats.then(|| GcStatsPrinter {
+			collect_before_printing_stats: self.gc_collect_before_printing_stats,
+		})
+	}
+	pub fn leak_on_exit(&self) -> Option<LeakSpace> {
+		(!self.gc_collect_on_exit).then(|| LeakSpace(PhantomData))
 	}
 }
 

--- a/crates/jrsonnet-cli/src/manifest.rs
+++ b/crates/jrsonnet-cli/src/manifest.rs
@@ -8,8 +8,6 @@
 };
 use jrsonnet_stdlib::{TomlFormat, YamlFormat};
 
-use crate::ConfigureState;
-
 #[derive(Clone, ValueEnum)]
 pub enum ManifestFormatName {
 	/// Expect string as output, and write them directly
@@ -41,9 +39,8 @@
 	#[clap(long)]
 	pub preserve_order: bool,
 }
-impl ConfigureState for ManifestOpts {
-	type Guards = Box<dyn ManifestFormat>;
-	fn configure(&self, _s: &State) -> Result<Self::Guards> {
+impl ManifestOpts {
+	pub fn manifest_format(&self) -> Box<dyn ManifestFormat> {
 		let format: Box<dyn ManifestFormat> = if self.string {
 			Box::new(StringFormat)
 		} else {
@@ -68,11 +65,11 @@
 				)),
 			}
 		};
-		Ok(if self.yaml_stream {
+		if self.yaml_stream {
 			Box::new(YamlStreamFormat(format))
 		} else {
 			format
-		})
+		}
 	}
 }
 

--- a/crates/jrsonnet-cli/src/stdlib.rs
+++ b/crates/jrsonnet-cli/src/stdlib.rs
@@ -2,8 +2,7 @@
 
 use clap::Parser;
 use jrsonnet_evaluator::{error::Result, tb, trace::PathResolver, State};
-
-use crate::ConfigureState;
+use jrsonnet_stdlib::ContextInitializer;
 
 #[derive(Clone)]
 pub struct ExtStr {
@@ -82,14 +81,13 @@
 	#[clap(long, name = "name=var code path", number_of_values = 1)]
 	ext_code_file: Vec<ExtFile>,
 }
-impl ConfigureState for StdOpts {
-	type Guards = ();
-	fn configure(&self, s: &State) -> Result<()> {
+impl StdOpts {
+	pub fn context_initializer(&self, s: &State) -> Result<Option<ContextInitializer>> {
 		if self.no_stdlib {
-			return Ok(());
+			return Ok(None);
 		}
 		let ctx =
-			jrsonnet_stdlib::ContextInitializer::new(s.clone(), PathResolver::new_cwd_fallback());
+			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());
 		}
@@ -102,7 +100,6 @@
 		for ext in self.ext_code_file.iter() {
 			ctx.add_ext_code(&ext.name as &str, &ext.value as &str)?;
 		}
-		s.settings_mut().context_initializer = tb!(ctx);
-		Ok(())
+		Ok(Some(ctx))
 	}
 }

--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -7,7 +7,7 @@
 };
 use jrsonnet_parser::{ParserSettings, Source};
 
-use crate::{ConfigureState, ExtFile, ExtStr};
+use crate::{ExtFile, ExtStr};
 
 #[derive(Parser)]
 #[clap(next_help_heading = "TOP LEVEL ARGUMENTS")]
@@ -31,9 +31,8 @@
 	#[clap(long, name = "name=tla code path", number_of_values = 1)]
 	tla_code_file: Vec<ExtFile>,
 }
-impl ConfigureState for TlaOpts {
-	type Guards = GcHashMap<IStr, TlaArg>;
-	fn configure(&self, _s: &State) -> Result<Self::Guards> {
+impl TlaOpts {
+	pub fn tla_opts(&self) -> Result<GcHashMap<IStr, TlaArg>> {
 		let mut out = GcHashMap::new();
 		for (name, value) in self
 			.tla_str

--- a/crates/jrsonnet-cli/src/trace.rs
+++ b/crates/jrsonnet-cli/src/trace.rs
@@ -5,8 +5,6 @@
 	State,
 };
 
-use crate::ConfigureState;
-
 #[derive(PartialEq, Eq, ValueEnum, Clone)]
 pub enum TraceFormatName {
 	/// Only show `filename:line:column`
@@ -26,9 +24,8 @@
 	#[clap(long, short = 't', default_value = "20")]
 	max_trace: usize,
 }
-impl ConfigureState for TraceOpts {
-	type Guards = Box<dyn TraceFormat>;
-	fn configure(&self, _s: &State) -> Result<Self::Guards> {
+impl TraceOpts {
+	pub fn trace_format(&self) -> Box<dyn TraceFormat> {
 		let resolver = PathResolver::new_cwd_fallback();
 		let max_trace = self.max_trace;
 		let format: Box<dyn TraceFormat> = match self
@@ -46,6 +43,6 @@
 				max_trace,
 			}),
 		};
-		Ok(format)
+		format
 	}
 }