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};14use jrsonnet_parser::{SourceDefaultIgnoreJpath, SourcePath};1516#[cfg(feature = "mimalloc")]17#[global_allocator]18static GLOBAL: mimallocator::Mimalloc = mimallocator::Mimalloc;1920#[derive(Parser)]21enum SubOpts {22 23 Generate {24 25 shell: Shell,26 },27}2829#[derive(Parser)]30#[clap(next_help_heading = "DEBUG")]31struct DebugOpts {32 33 34 #[clap(long, name = "size")]35 pub os_stack: Option<usize>,36}3738#[derive(Parser)]39#[clap(next_help_heading = "INPUT")]40struct InputOpts {41 42 #[clap(long, short = 'e')]43 pub exec: bool,4445 46 pub input: Option<String>,4748 49 50 #[cfg(feature = "exp-apply")]51 #[clap(long)]52 pub exp_apply: Vec<String>,53}545556#[derive(Parser)]57#[clap(58 args_conflicts_with_subcommands = true,59 disable_version_flag = true,60 version,61 author62)]63struct Opts {64 #[clap(subcommand)]65 sub: Option<SubOpts>,66 67 #[clap(long)]68 version: bool,6970 #[clap(flatten)]71 input: InputOpts,72 #[clap(flatten)]73 misc: MiscOpts,74 #[clap(flatten)]75 tla: TlaOpts,76 #[clap(flatten)]77 std: StdOpts,78 #[clap(flatten)]79 gc: GcOpts,8081 #[clap(flatten)]82 trace: TraceOpts,83 #[clap(flatten)]84 manifest: ManifestOpts,85 #[clap(flatten)]86 output: OutputOpts,87 #[clap(flatten)]88 debug: DebugOpts,89}909192fn main() {93 let opts: Opts = Opts::parse();9495 if opts.version {96 print!("{}", Opts::command().render_version());97 std::process::exit(0)98 }99100 if let Some(sub) = opts.sub {101 match sub {102 SubOpts::Generate { shell } => {103 use clap_complete::generate;104 let app = &mut Opts::command();105 let buf = &mut std::io::stdout();106 generate(shell, app, "jrsonnet", buf);107 std::process::exit(0)108 }109 }110 }111112 let success = if let Some(size) = opts.debug.os_stack {113 std::thread::Builder::new()114 .stack_size(size * 1024 * 1024)115 .spawn(|| main_catch(opts))116 .expect("new thread spawned")117 .join()118 .expect("thread finished successfully")119 } else {120 main_catch(opts)121 };122 if !success {123 std::process::exit(1);124 }125}126127#[derive(thiserror::Error, Debug)]128enum Error {129 130 #[error("evaluation error")]131 Evaluation(JrError),132 #[error("io error")]133 Io(#[from] std::io::Error),134 #[error("input is not utf8 encoded")]135 Utf8(#[from] std::str::Utf8Error),136 #[error("missing input argument")]137 MissingInputArgument,138}139impl From<JrError> for Error {140 fn from(e: JrError) -> Self {141 Self::Evaluation(e)142 }143}144impl From<ErrorKind> for Error {145 fn from(e: ErrorKind) -> Self {146 Self::from(JrError::from(e))147 }148}149150fn main_catch(opts: Opts) -> bool {151 let trace = opts.trace.trace_format();152 if let Err(e) = main_real(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(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 let std = opts.std.context_initializer()?;172173 let mut s = State::builder();174 s.import_resolver(import_resolver).context_initializer(std);175 let s = s.build();176 let _s = s.enter();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_from(&SourcePath::new(SourceDefaultIgnoreJpath), input.as_str())?188 };189190 let tla = opts.tla.tla_opts()?;191 #[allow(192 193 unused_mut,194 clippy::redundant_clone,195 )]196 let mut val = apply_tla(&tla, val)?;197198 #[cfg(feature = "exp-apply")]199 for apply in opts.input.exp_apply {200 use jrsonnet_evaluator::{InitialUnderscore, Thunk};201 val = s.evaluate_snippet_with(202 "<exp_apply>".to_owned(),203 &apply,204 InitialUnderscore(Thunk::evaluated(val)),205 )?;206 }207208 let manifest_format = opts.manifest.manifest_format();209 if let Some(multi) = opts.output.multi {210 if opts.output.create_output_dirs {211 let mut dir = multi.clone();212 dir.pop();213 create_dir_all(dir)?;214 }215 let Val::Obj(obj) = val else {216 bail!(217 "value should be object for --multi manifest, got {}",218 val.value_type()219 )220 };221 for (field, data) in obj.iter(222 #[cfg(feature = "exp-preserve-order")]223 opts.manifest.preserve_order,224 ) {225 let data = data.with_description(|| format!("getting field {field} for manifest"))?;226227 let mut path = multi.clone();228 path.push(&field as &str);229 if opts.output.create_output_dirs {230 let mut dir = path.clone();231 dir.pop();232 create_dir_all(dir)?;233 }234 println!("{}", path.to_str().expect("path"));235 let mut file = File::create(path)?;236 write!(237 file,238 "{}",239 data.manifest(&manifest_format)240 .with_description(|| format!("manifesting {field}"))?,241 )?;242 if manifest_format.file_trailing_newline() {243 writeln!(file)?;244 }245 file.flush()?;246 }247 } else if let Some(path) = opts.output.output_file {248 if opts.output.create_output_dirs {249 let mut dir = path.clone();250 dir.pop();251 create_dir_all(dir)?;252 }253 let mut file = File::create(path)?;254 writeln!(file, "{}", val.manifest(manifest_format)?)?;255 } else {256 let output = val.manifest(manifest_format)?;257 if !output.is_empty() {258 println!("{output}");259 }260 }261262 Ok(())263}