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 s = State::default();151 let trace = opts.trace.trace_format();152 if let Err(e) = main_real(&s, opts) {153 if let Error::Evaluation(e) = e {154 let mut out = String::new();155 trace.write_trace(&mut out, &e).expect("format error");156 eprintln!("{out}");157 } else {158 eprintln!("{e}");159 }160 return false;161 }162 true163}164165fn main_real(s: &State, opts: Opts) -> Result<(), Error> {166 let _gc_leak_guard = opts.gc.leak_on_exit();167 let _gc_print_stats = opts.gc.stats_printer();168 let _stack_depth_override = opts.misc.stack_size_override();169170 let import_resolver = opts.misc.import_resolver();171 s.set_import_resolver(import_resolver);172173 let std = opts.std.context_initializer(s)?;174 if let Some(std) = std {175 s.set_context_initializer(std);176 }177178 let input = opts.input.input.ok_or(Error::MissingInputArgument)?;179 let val = if opts.input.exec {180 s.evaluate_snippet("<cmdline>".to_owned(), &input as &str)?181 } else if input == "-" {182 let mut input = Vec::new();183 std::io::stdin().read_to_end(&mut input)?;184 let input_str = std::str::from_utf8(&input)?;185 s.evaluate_snippet("<stdin>".to_owned(), input_str)?186 } else {187 s.import(&input)?188 };189190 let tla = opts.tla.tla_opts()?;191 #[allow(unused_mut)]192 let mut val = apply_tla(s.clone(), &tla, val)?;193194 #[cfg(feature = "exp-apply")]195 for apply in opts.input.exp_apply {196 use jrsonnet_evaluator::{InitialUnderscore, Thunk};197 val = s.evaluate_snippet_with(198 "<exp_apply>".to_owned(),199 &apply,200 InitialUnderscore(Thunk::evaluated(val)),201 )?;202 }203204 let manifest_format = opts.manifest.manifest_format();205 if let Some(multi) = opts.output.multi {206 if opts.output.create_output_dirs {207 let mut dir = multi.clone();208 dir.pop();209 create_dir_all(dir)?;210 }211 let Val::Obj(obj) = val else {212 bail!(213 "value should be object for --multi manifest, got {}",214 val.value_type()215 )216 };217 for (field, data) in obj.iter(218 #[cfg(feature = "exp-preserve-order")]219 opts.manifest.preserve_order,220 ) {221 let data = data.with_description(|| format!("getting field {field} for manifest"))?;222223 let mut path = multi.clone();224 path.push(&field as &str);225 if opts.output.create_output_dirs {226 let mut dir = path.clone();227 dir.pop();228 create_dir_all(dir)?;229 }230 println!("{}", path.to_str().expect("path"));231 let mut file = File::create(path)?;232 write!(233 file,234 "{}",235 data.manifest(&manifest_format)236 .with_description(|| format!("manifesting {field}"))?,237 )?;238 if manifest_format.file_trailing_newline() {239 writeln!(file)?;240 }241 file.flush()?;242 }243 } else if let Some(path) = opts.output.output_file {244 if opts.output.create_output_dirs {245 let mut dir = path.clone();246 dir.pop();247 create_dir_all(dir)?;248 }249 let mut file = File::create(path)?;250 writeln!(file, "{}", val.manifest(manifest_format)?)?;251 } else {252 let output = val.manifest(manifest_format)?;253 if !output.is_empty() {254 println!("{output}");255 }256 }257258 Ok(())259}