1pub mod location;23use clap::Clap;4use jsonnet_evaluator::{EvaluationSettings, EvaluationState, LocError, StackTrace, Val};5use jsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParserSettings};6use location::{offset_to_location, CodeLocation};7use std::env::current_dir;8use std::{collections::HashMap, path::PathBuf, rc::Rc, str::FromStr};910enum Format {11 None,12 Json,13 Yaml,14}1516impl FromStr for Format {17 type Err = &'static str;18 fn from_str(s: &str) -> Result<Self, Self::Err> {19 Ok(match s {20 "none" => Format::None,21 "json" => Format::Json,22 "yaml" => Format::Yaml,23 _ => return Err("no such format"),24 })25 }26}2728#[derive(PartialEq)]29enum TraceFormat {30 CppJsonnet,31 GoJsonnet,32 Custom,33}34impl FromStr for TraceFormat {35 type Err = &'static str;36 fn from_str(s: &str) -> Result<Self, Self::Err> {37 Ok(match s {38 "cpp" => TraceFormat::CppJsonnet,39 "go" => TraceFormat::GoJsonnet,40 "default" => TraceFormat::Custom,41 _ => return Err("no such format"),42 })43 }44}4546#[derive(Clone)]47struct ExtStr {48 name: String,49 value: String,50}51impl FromStr for ExtStr {52 type Err = &'static str;53 fn from_str(s: &str) -> Result<Self, Self::Err> {54 let out: Vec<_> = s.split('=').collect();55 match out.len() {56 1 => Ok(ExtStr {57 name: out[0].to_owned(),58 value: std::env::var(out[0]).or(Err("missing env var"))?,59 }),60 2 => Ok(ExtStr {61 name: out[0].to_owned(),62 value: out[1].to_owned(),63 }),64 _ => Err("bad ext-str syntax"),65 }66 }67}6869#[derive(Clap)]70#[clap(version = "0.1.0", author = "Lach <iam@lach.pw>")]71struct Opts {72 #[clap(long, about = "Disable global std variable")]73 no_stdlib: bool,74 #[clap(long, about = "Add external string")]75 ext_str: Vec<ExtStr>,76 #[clap(long, about = "Add external string from code")]77 ext_code: Vec<ExtStr>,78 #[clap(long, about = "Add TLA")]79 tla_str: Vec<ExtStr>,80 #[clap(long, about = "Add TLA from code")]81 tla_code: Vec<ExtStr>,82 #[clap(long, short = "f", default_value = "json", possible_values = &["none", "json", "yaml"], about = "Output format, wraps resulting value to corresponding std.manifest call")]83 format: Format,84 #[clap(long, default_value = "default", possible_values = &["cpp", "go", "default"], about = "Emulated needed stacktrace display")]85 trace_format: TraceFormat,8687 #[clap(88 long,89 short = "s",90 default_value = "200",91 about = "Number of allowed stack frames"92 )]93 max_stack: usize,94 #[clap(95 long,96 short = "t",97 default_value = "20",98 about = "Max length of stack trace before cropping"99 )]100 max_trace: usize,101102 #[clap(long, short = "J", about = "Library search dir")]103 jpath: Vec<PathBuf>,104105 #[clap(106 long,107 default_value = "3",108 about = "When using --format, this option specifies string to pad output with"109 )]110 line_padding: usize,111112 #[clap(about = "File to compile", index = 1)]113 input: String,114}115116fn main() {117 let opts: Opts = Opts::parse();118 let evaluator = jsonnet_evaluator::EvaluationState::new(119 EvaluationSettings {120 max_stack_trace_size: opts.max_trace,121 max_stack_frames: opts.max_stack,122 },123 Box::new(jsonnet_evaluator::FileImportResolver {124 library_paths: opts.jpath.clone(),125 }),126 );127 if !opts.no_stdlib {128 evaluator.with_stdlib();129 }130 for ExtStr { name, value } in opts.ext_str.iter().cloned() {131 evaluator.add_ext_var(name.into(), Val::Str(value.into()));132 }133 for ExtStr { name, value } in opts.ext_code.iter().cloned() {134 evaluator.add_ext_var(name.into(), evaluator.parse_evaluate_raw(&value).unwrap());135 }136 let mut input = current_dir().unwrap();137 input.push(opts.input.clone());138 let code_string = String::from_utf8(std::fs::read(opts.input.clone()).unwrap()).unwrap();139 if let Err(e) = evaluator.add_file(Rc::new(input.clone()), code_string.clone().into()) {140 print_syntax_error(e, &input, &code_string);141 std::process::exit(1);142 }143 let result = evaluator.evaluate_file(&input);144 match result {145 Ok(v) => {146 let v = match v {147 Val::Func(f) => {148 let mut desc_map = HashMap::new();149 for ExtStr { name, value } in opts.tla_str.iter().cloned() {150 desc_map.insert(name, el!(Expr::Str(value.into())));151 }152 for ExtStr { name, value } in opts.tla_code.iter().cloned() {153 desc_map.insert(154 name,155 jsonnet_parser::parse(156 &value,157 &ParserSettings {158 file_name: Rc::new(PathBuf::new()),159 loc_data: false,160 },161 )162 .unwrap(),163 );164 }165 evaluator.add_global("__tmp__tlf__".into(), Val::Func(f));166 evaluator167 .evaluate_raw(el!(Expr::Apply(168 el!(Expr::Var("__tmp__tlf__".into())),169 ArgsDesc(desc_map.into_iter().map(|(k, v)| Arg(Some(k), v)).collect()),170 false,171 )))172 .unwrap()173 }174 v => v,175 };176 let v = evaluator.run_in_state(|| match opts.format {177 Format::Json => Ok(Val::Str(v.into_json(opts.line_padding)?)),178 Format::Yaml => {179 evaluator.add_global("__tmp__to_yaml__".into(), v);180 evaluator.parse_evaluate_raw("std.manifestYamlDoc(__tmp__to_yaml__, \" \")")181 }182 _ => Ok(v),183 });184 let v = match v {185 Ok(v) => v,186 Err(err) => {187 print_error(&err, evaluator, &opts);188 std::process::exit(1);189 }190 };191 match v {192 Val::Str(s) => println!("{}", s),193 Val::Num(n) => println!("{}", n),194 _v => eprintln!(195 "jsonnet output is not a string.\nDid you forgot to set --format, or wrap your data with std.manifestJson?"196 ),197 }198 }199 Err(err) => {200 print_error(&err, evaluator, &opts);201 std::process::exit(1);202 }203 }204}205206fn print_error(err: &LocError, evaluator: EvaluationState, opts: &Opts) {207 println!("Error: {:?}", err.0);208 print_trace(&(err.1), evaluator, &opts);209}210211fn print_syntax_error(error: jsonnet_parser::ParseError, file: &PathBuf, code: &str) {212 use annotate_snippets::{213 display_list::{DisplayList, FormatOptions},214 snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation},215 };216 217 let origin = file.to_str().unwrap();218 let error_message = format!("Expected: {}", error.expected);219 let snippet = Snippet {220 opt: FormatOptions {221 color: true,222 ..Default::default()223 },224 title: Some(Annotation {225 label: Some(&error_message),226 id: None,227 annotation_type: AnnotationType::Error,228 }),229 footer: vec![],230 slices: vec![Slice {231 source: &code,232 line_start: 1,233 origin: Some(origin),234 fold: false,235 annotations: vec![SourceAnnotation {236 label: "At this position",237 annotation_type: AnnotationType::Error,238 range: (error.location.offset, error.location.offset + 1),239 }],240 }],241 };242243 let dl = DisplayList::from(snippet);244 println!("{}", dl);245}246247fn print_trace(trace: &StackTrace, evaluator: EvaluationState, opts: &Opts) {248 use annotate_snippets::{249 display_list::{DisplayList, FormatOptions},250 snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation},251 };252 for item in trace.0.iter() {253 let desc = &item.1;254 let source = item.0.clone();255 let code = evaluator.get_source(&source.0);256 if code.is_none() {257 continue;258 }259 let code = code.unwrap();260 let start_end = offset_to_location(&code, &[source.1, source.2]);261 if opts.trace_format == TraceFormat::Custom {262 let source_fragment: String = code263 .chars()264 .skip(start_end[0].line_start_offset)265 .take(start_end[1].line_end_offset - start_end[0].line_start_offset)266 .collect();267 let snippet = Snippet {268 opt: FormatOptions {269 color: true,270 ..Default::default()271 },272 title: Some(Annotation {273 label: Some(&item.1),274 id: None,275 annotation_type: AnnotationType::Error,276 }),277 footer: vec![],278 slices: vec![Slice {279 source: &source_fragment,280 line_start: start_end[0].line,281 origin: Some(&source.0.to_str().unwrap()),282 fold: false,283 annotations: vec![SourceAnnotation {284 label: desc,285 annotation_type: AnnotationType::Error,286 range: (287 source.1 - start_end[0].line_start_offset,288 source.2 - start_end[0].line_start_offset,289 ),290 }],291 }],292 };293294 let dl = DisplayList::from(snippet);295 println!("{}", dl);296 } else {297 print_jsonnet_pair(298 source.0.to_str().unwrap(),299 &start_end[0],300 &start_end[1],301 opts.trace_format == TraceFormat::GoJsonnet,302 );303 }304 }305}306307fn print_jsonnet_pair(file: &str, start: &CodeLocation, end: &CodeLocation, is_go: bool) {308 if is_go {309 print!(" ");310 } else {311 print!(" ");312 }313 print!("{}:", file);314 if start.line == end.line {315 316 if start.column == end.column || !is_go && start.column + 1 == end.column {317 println!("{}:{}", start.line, end.column)318 } else {319 println!("{}:{}-{}", start.line, start.column, end.column);320 }321 } else {322 println!(323 "({}:{})-({}:{})",324 start.line, end.column, start.line, end.column325 );326 }327}