1use std::{2 fs::{create_dir_all, File},3 io::{Read, Write},4};56use clap::{CommandFactory, Parser};7use clap_complete::Shell;8use jrsonnet_cli::{ManifestOpts, OutputOpts, TraceOpts, MiscOpts, TlaOpts, StdOpts, GcOpts};9use jrsonnet_evaluator::{10 apply_tla,11 error::{Error as JrError, ErrorKind},12 throw, 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>,46}474849#[derive(Parser)]50#[clap(51 args_conflicts_with_subcommands = true,52 disable_version_flag = true,53 version,54 author55)]56struct Opts {57 #[clap(subcommand)]58 sub: Option<SubOpts>,5960 #[clap(flatten)]61 input: InputOpts,62 #[clap(flatten)]63 misc: MiscOpts,64 #[clap(flatten)]65 tla: TlaOpts,66 #[clap(flatten)]67 std: StdOpts,68 #[clap(flatten)]69 gc: GcOpts,7071 #[clap(flatten)]72 trace: TraceOpts,73 #[clap(flatten)]74 manifest: ManifestOpts,75 #[clap(flatten)]76 output: OutputOpts,77 #[clap(flatten)]78 debug: DebugOpts,79}8081fn main() {82 let opts: Opts = Opts::parse();8384 if let Some(sub) = opts.sub {85 match sub {86 SubOpts::Generate { shell } => {87 use clap_complete::generate;88 let app = &mut Opts::command();89 let buf = &mut std::io::stdout();90 generate(shell, app, "jrsonnet", buf);91 std::process::exit(0)92 }93 }94 }9596 let success = if let Some(size) = opts.debug.os_stack {97 std::thread::Builder::new()98 .stack_size(size * 1024 * 1024)99 .spawn(|| main_catch(opts))100 .expect("new thread spawned")101 .join()102 .expect("thread finished successfully")103 } else {104 main_catch(opts)105 };106 if !success {107 std::process::exit(1);108 }109}110111#[derive(thiserror::Error, Debug)]112enum Error {113 114 #[error("evaluation error")]115 Evaluation(JrError),116 #[error("io error")]117 Io(#[from] std::io::Error),118 #[error("input is not utf8 encoded")]119 Utf8(#[from] std::str::Utf8Error),120 #[error("missing input argument")]121 MissingInputArgument,122}123impl From<JrError> for Error {124 fn from(e: JrError) -> Self {125 Self::Evaluation(e)126 }127}128impl From<ErrorKind> for Error {129 fn from(e: ErrorKind) -> Self {130 Self::from(JrError::from(e))131 }132}133134fn main_catch(opts: Opts) -> bool {135 let s = State::default();136 let trace = opts137 .trace138 .trace_format();139 if let Err(e) = main_real(&s, opts) {140 if let Error::Evaluation(e) = e {141 let mut out = String::new();142 trace.write_trace(&mut out, &e).expect("format error");143 eprintln!("{out}")144 } else {145 eprintln!("{}", e);146 }147 return false;148 }149 true150}151152fn main_real(s: &State, opts: Opts) -> Result<(), Error> {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();156157 let import_resolver = opts.misc.import_resolver();158 s.set_import_resolver(import_resolver);159160 let std = opts.std.context_initializer(s)?;161 if let Some(std) = std {162 s.set_context_initializer(std);163 }164165 let input = opts.input.input.ok_or(Error::MissingInputArgument)?;166 let val = if opts.input.exec {167 s.evaluate_snippet("<cmdline>".to_owned(), &input as &str)?168 } else if input == "-" {169 let mut input = Vec::new();170 std::io::stdin().read_to_end(&mut input)?;171 let input_str = std::str::from_utf8(&input)?;172 s.evaluate_snippet("<stdin>".to_owned(), input_str)?173 } else {174 s.import(&input)?175 };176177 let tla = opts.tla.tla_opts()?;178 let val = apply_tla(s.clone(), &tla, val)?;179180 let manifest_format = opts.manifest.manifest_format();181 if let Some(multi) = opts.output.multi {182 if opts.output.create_output_dirs {183 let mut dir = multi.clone();184 dir.pop();185 create_dir_all(dir)?;186 }187 let Val::Obj(obj) = val else {188 throw!("value should be object for --multi manifest, got {}", val.value_type())189 };190 for (field, data) in obj.iter(191 #[cfg(feature = "exp-preserve-order")]192 opts.manifest.preserve_order,193 ) {194 let data = data.with_description(|| format!("getting field {field} for manifest"))?;195196 let mut path = multi.clone();197 path.push(&field as &str);198 if opts.output.create_output_dirs {199 let mut dir = path.clone();200 dir.pop();201 create_dir_all(dir)?;202 }203 println!("{}", path.to_str().expect("path"));204 let mut file = File::create(path)?;205 writeln!(206 file,207 "{}",208 data.manifest(&manifest_format)209 .with_description(|| format!("manifesting {field}"))?210 )?;211 }212 } else if let Some(path) = opts.output.output_file {213 if opts.output.create_output_dirs {214 let mut dir = path.clone();215 dir.pop();216 create_dir_all(dir)?;217 }218 let mut file = File::create(path)?;219 writeln!(file, "{}", val.manifest(manifest_format)?)?;220 } else {221 let output = val.manifest(manifest_format)?;222 if !output.is_empty() {223 println!("{}", output);224 }225 }226227 Ok(())228}