1use std::{2 fs::{create_dir_all, File},3 io::{Read, Write},4};56use clap::{CommandFactory, Parser};7use clap_complete::Shell;8use jrsonnet_cli::{GcOpts, ManifestOpts, MiscOpts, OutputOpts, StdOpts, TlaOpts, TraceOpts};9use jrsonnet_evaluator::{10 apply_tla, bail,11 error::{Error as JrError, ErrorKind},12 ResultExt, State, Val,13};1415#[cfg(feature = "mimalloc")]16#[global_allocator]17static GLOBAL: mimallocator::Mimalloc = mimallocator::Mimalloc;1819#[derive(Parser)]20enum SubOpts {21 22 Generate {23 24 shell: Shell,25 },26}2728#[derive(Parser)]29#[clap(next_help_heading = "DEBUG")]30struct DebugOpts {31 32 33 #[clap(long, name = "size")]34 pub os_stack: Option<usize>,35}3637#[derive(Parser)]38#[clap(next_help_heading = "INPUT")]39struct InputOpts {40 41 #[clap(long, short = 'e')]42 pub exec: bool,4344 45 pub input: Option<String>,4647 48 49 #[cfg(feature = "exp-apply")]50 #[clap(long)]51 pub exp_apply: Vec<String>,52}535455#[derive(Parser)]56#[clap(57 args_conflicts_with_subcommands = true,58 disable_version_flag = true,59 version,60 author61)]62struct Opts {63 #[clap(subcommand)]64 sub: Option<SubOpts>,65 66 #[clap(long)]67 version: bool,6869 #[clap(flatten)]70 input: InputOpts,71 #[clap(flatten)]72 misc: MiscOpts,73 #[clap(flatten)]74 tla: TlaOpts,75 #[clap(flatten)]76 std: StdOpts,77 #[clap(flatten)]78 gc: GcOpts,7980 #[clap(flatten)]81 trace: TraceOpts,82 #[clap(flatten)]83 manifest: ManifestOpts,84 #[clap(flatten)]85 output: OutputOpts,86 #[clap(flatten)]87 debug: DebugOpts,88}899091fn main() {92 let opts: Opts = Opts::parse();9394 if opts.version {95 print!("{}", Opts::command().render_version());96 std::process::exit(0)97 }9899 if let Some(sub) = opts.sub {100 match sub {101 SubOpts::Generate { shell } => {102 use clap_complete::generate;103 let app = &mut Opts::command();104 let buf = &mut std::io::stdout();105 generate(shell, app, "jrsonnet", buf);106 std::process::exit(0)107 }108 }109 }110111 let success = if let Some(size) = opts.debug.os_stack {112 std::thread::Builder::new()113 .stack_size(size * 1024 * 1024)114 .spawn(|| main_catch(opts))115 .expect("new thread spawned")116 .join()117 .expect("thread finished successfully")118 } else {119 main_catch(opts)120 };121 if !success {122 std::process::exit(1);123 }124}125126#[derive(thiserror::Error, Debug)]127enum Error {128 129 #[error("evaluation error")]130 Evaluation(JrError),131 #[error("io error")]132 Io(#[from] std::io::Error),133 #[error("input is not utf8 encoded")]134 Utf8(#[from] std::str::Utf8Error),135 #[error("missing input argument")]136 MissingInputArgument,137}138impl From<JrError> for Error {139 fn from(e: JrError) -> Self {140 Self::Evaluation(e)141 }142}143impl From<ErrorKind> for Error {144 fn from(e: ErrorKind) -> Self {145 Self::from(JrError::from(e))146 }147}148149fn main_catch(opts: Opts) -> bool {150 let trace = opts.trace.trace_format();151 if let Err(e) = main_real(opts) {152 if let Error::Evaluation(e) = e {153 let mut out = String::new();154 trace.write_trace(&mut out, &e).expect("format error");155 eprintln!("{out}");156 } else {157 eprintln!("{e}");158 }159 return false;160 }161 true162}163164fn main_real(opts: Opts) -> Result<(), Error> {165 let _gc_leak_guard = opts.gc.leak_on_exit();166 let _gc_print_stats = opts.gc.stats_printer();167 let _stack_depth_override = opts.misc.stack_size_override();168169 let import_resolver = opts.misc.import_resolver();170 let std = opts.std.context_initializer()?;171172 let mut s = State::builder();173 s.import_resolver(import_resolver).context_initializer(std);174 let s = s.build();175176 let input = opts.input.input.ok_or(Error::MissingInputArgument)?;177 let val = if opts.input.exec {178 s.evaluate_snippet("<cmdline>".to_owned(), &input as &str)?179 } else if input == "-" {180 let mut input = Vec::new();181 std::io::stdin().read_to_end(&mut input)?;182 let input_str = std::str::from_utf8(&input)?;183 s.evaluate_snippet("<stdin>".to_owned(), input_str)?184 } else {185 s.import(input.as_str())?186 };187188 let tla = opts.tla.tla_opts()?;189 #[allow(190 191 unused_mut,192 clippy::redundant_clone,193 )]194 let mut val = apply_tla(s.clone(), &tla, val)?;195196 #[cfg(feature = "exp-apply")]197 for apply in opts.input.exp_apply {198 use jrsonnet_evaluator::{InitialUnderscore, Thunk};199 val = s.evaluate_snippet_with(200 "<exp_apply>".to_owned(),201 &apply,202 InitialUnderscore(Thunk::evaluated(val)),203 )?;204 }205206 let manifest_format = opts.manifest.manifest_format();207 if let Some(multi) = opts.output.multi {208 if opts.output.create_output_dirs {209 let mut dir = multi.clone();210 dir.pop();211 create_dir_all(dir)?;212 }213 let Val::Obj(obj) = val else {214 bail!(215 "value should be object for --multi manifest, got {}",216 val.value_type()217 )218 };219 for (field, data) in obj.iter(220 #[cfg(feature = "exp-preserve-order")]221 opts.manifest.preserve_order,222 ) {223 let data = data.with_description(|| format!("getting field {field} for manifest"))?;224225 let mut path = multi.clone();226 path.push(&field as &str);227 if opts.output.create_output_dirs {228 let mut dir = path.clone();229 dir.pop();230 create_dir_all(dir)?;231 }232 println!("{}", path.to_str().expect("path"));233 let mut file = File::create(path)?;234 write!(235 file,236 "{}",237 data.manifest(&manifest_format)238 .with_description(|| format!("manifesting {field}"))?,239 )?;240 if manifest_format.file_trailing_newline() {241 writeln!(file)?;242 }243 file.flush()?;244 }245 } else if let Some(path) = opts.output.output_file {246 if opts.output.create_output_dirs {247 let mut dir = path.clone();248 dir.pop();249 create_dir_all(dir)?;250 }251 let mut file = File::create(path)?;252 writeln!(file, "{}", val.manifest(manifest_format)?)?;253 } else {254 let output = val.manifest(manifest_format)?;255 if !output.is_empty() {256 println!("{output}");257 }258 }259260 Ok(())261}