difftreelog
feat TLA support
in: master
2 files changed
cmds/jrsonnet/src/main.rsdiffbeforeafterboth1pub mod location;23use clap::Clap;4use jsonnet_evaluator::{EvaluationSettings, EvaluationState, LocError, StackTrace, Val};5use location::{offset_to_location, CodeLocation};6use std::env::current_dir;7use std::{path::PathBuf, str::FromStr};89enum Format {10 None,11 Json,12 Yaml,13}1415impl FromStr for Format {16 type Err = &'static str;17 fn from_str(s: &str) -> Result<Self, Self::Err> {18 Ok(match s {19 "none" => Format::None,20 "json" => Format::Json,21 "yaml" => Format::Yaml,22 _ => return Err("no such format"),23 })24 }25}2627#[derive(PartialEq)]28enum TraceFormat {29 CppJsonnet,30 GoJsonnet,31 Custom,32}33impl FromStr for TraceFormat {34 type Err = &'static str;35 fn from_str(s: &str) -> Result<Self, Self::Err> {36 Ok(match s {37 "cpp" => TraceFormat::CppJsonnet,38 "go" => TraceFormat::GoJsonnet,39 "default" => TraceFormat::Custom,40 _ => return Err("no such format"),41 })42 }43}4445#[derive(Clone)]46struct ExtStr {47 name: String,48 value: String,49}50impl FromStr for ExtStr {51 type Err = &'static str;52 fn from_str(s: &str) -> Result<Self, Self::Err> {53 let out: Vec<_> = s.split('=').collect();54 match out.len() {55 1 => Ok(ExtStr {56 name: out[0].to_owned(),57 value: std::env::var(out[0]).or(Err("missing env var"))?,58 }),59 2 => Ok(ExtStr {60 name: out[0].to_owned(),61 value: out[1].to_owned(),62 }),63 _ => Err("bad ext-str syntax"),64 }65 }66}6768#[derive(Clap)]69#[clap(version = "0.1.0", author = "Lach <iam@lach.pw>")]70struct Opts {71 #[clap(long, about = "Disable global std variable")]72 no_stdlib: bool,73 #[clap(long, about = "Add external string")]74 ext_str: Vec<ExtStr>,75 #[clap(long, about = "Add external string from code")]76 ext_code: Vec<ExtStr>,77 #[clap(long, about = "Add TLA")]78 tla_str: Vec<ExtStr>,79 #[clap(long, about = "Add TLA from code")]80 tla_code: Vec<ExtStr>,81 #[clap(long, short = "f", default_value = "json", possible_values = &["none", "json", "yaml"], about = "Output format, wraps resulting value to corresponding std.manifest call")]82 format: Format,83 #[clap(long, default_value = "default", possible_values = &["cpp", "go", "default"], about = "Emulated needed stacktrace display")]84 trace_format: TraceFormat,8586 #[clap(87 long,88 short = "s",89 default_value = "200",90 about = "Number of allowed stack frames"91 )]92 max_stack: usize,93 #[clap(94 long,95 short = "t",96 default_value = "20",97 about = "Max length of stack trace before cropping"98 )]99 max_trace: usize,100101 #[clap(102 long,103 default_value = "3",104 about = "When using --format, this option specifies string to pad output with"105 )]106 line_padding: usize,107108 #[clap(about = "File to compile", index = 1)]109 input: String,110}111112fn main() {113 let opts: Opts = Opts::parse();114 let evaluator = jsonnet_evaluator::EvaluationState::new(EvaluationSettings {115 import_resolver: Box::new(|path| String::from_utf8(std::fs::read(path).unwrap()).unwrap()),116 ..Default::default()117 });118 if !opts.no_stdlib {119 evaluator.with_stdlib();120 }121 for ExtStr { name, value } in opts.ext_str.iter().cloned() {122 evaluator.add_ext_var(name, Val::Str(value));123 }124 for ExtStr { name, value } in opts.ext_code.iter().cloned() {125 evaluator.add_ext_var(name, evaluator.parse_evaluate_raw(&value).unwrap());126 }127 let mut input = current_dir().unwrap();128 input.push(opts.input.clone());129 let code_string = String::from_utf8(std::fs::read(opts.input.clone()).unwrap()).unwrap();130 if let Err(e) = evaluator.add_file(input.clone(), code_string.clone()) {131 print_syntax_error(e, &input, &code_string);132 std::process::exit(1);133 }134 let result = evaluator.evaluate_file(&input);135 match result {136 Ok(v) => {137 let v = match opts.format {138 Format::Json => {139 if opts.no_stdlib {140 evaluator.with_stdlib();141 }142 evaluator.add_global("__tmp__to_json__".to_owned(), v);143 let v = evaluator.parse_evaluate_raw(&format!(144 "std.manifestJsonEx(__tmp__to_json__, \"{}\")",145 " ".repeat(opts.line_padding),146 ));147 match v {148 Ok(v) => v,149 Err(err) => {150 print_error(&err, evaluator, &opts);151 std::process::exit(1);152 }153 }154 }155 Format::Yaml => {156 if opts.no_stdlib {157 evaluator.with_stdlib();158 }159 evaluator.add_global("__tmp__to_yaml__".to_owned(), v);160 let v = evaluator161 .parse_evaluate_raw("std.manifestYamlDoc(__tmp__to_yaml__, \" \")");162 match v {163 Ok(v) => v,164 Err(err) => {165 print_error(&err, evaluator, &opts);166 std::process::exit(1);167 }168 }169 }170 _ => v,171 };172 match v {173 Val::Str(s) => println!("{}", s),174 Val::Num(n) => println!("{}", n),175 _v => eprintln!(176 "jsonnet output is not a string.\nDid you forgot to set --format, or wrap your data with std.manifestJson?"177 ),178 }179 }180 Err(err) => {181 print_error(&err, evaluator, &opts);182 std::process::exit(1);183 }184 }185}186187fn print_error(err: &LocError, evaluator: EvaluationState, opts: &Opts) {188 println!("Error: {:?}", err.0);189 print_trace(&(err.1), evaluator, &opts);190}191192fn print_syntax_error(error: jsonnet_parser::ParseError, file: &PathBuf, code: &str) {193 use annotate_snippets::{194 display_list::{DisplayList, FormatOptions},195 snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation},196 };197 //&("Expected: ".to_owned() + error.expected)198 let origin = file.to_str().unwrap();199 let error_message = format!("Expected: {}", error.expected);200 let snippet = Snippet {201 opt: FormatOptions {202 color: true,203 ..Default::default()204 },205 title: Some(Annotation {206 label: Some(&error_message),207 id: None,208 annotation_type: AnnotationType::Error,209 }),210 footer: vec![],211 slices: vec![Slice {212 source: &code,213 line_start: 1,214 origin: Some(origin),215 fold: false,216 annotations: vec![SourceAnnotation {217 label: "At this position",218 annotation_type: AnnotationType::Error,219 range: (error.location.offset, error.location.offset + 1),220 }],221 }],222 };223224 let dl = DisplayList::from(snippet);225 println!("{}", dl);226}227228fn print_trace(trace: &StackTrace, evaluator: EvaluationState, opts: &Opts) {229 use annotate_snippets::{230 display_list::{DisplayList, FormatOptions},231 snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation},232 };233 for item in trace.0.iter() {234 let desc = &item.1;235 if (item.0).1.is_none() {236 continue;237 }238 let source = (item.0).1.clone().unwrap();239 let code = evaluator.get_source(&source.0);240 if code.is_none() {241 continue;242 }243 let code = code.unwrap();244 let start_end = offset_to_location(&code, &[source.1, source.2]);245 if opts.trace_format == TraceFormat::Custom {246 let source_fragment: String = code247 .chars()248 .skip(start_end[0].line_start_offset)249 .take(start_end[1].line_end_offset - start_end[0].line_start_offset)250 .collect();251 let snippet = Snippet {252 opt: FormatOptions {253 color: true,254 ..Default::default()255 },256 title: Some(Annotation {257 label: Some(&item.1),258 id: None,259 annotation_type: AnnotationType::Error,260 }),261 footer: vec![],262 slices: vec![Slice {263 source: &source_fragment,264 line_start: start_end[0].line,265 origin: Some(&source.0.to_str().unwrap()),266 fold: false,267 annotations: vec![SourceAnnotation {268 label: desc,269 annotation_type: AnnotationType::Error,270 range: (271 source.1 - start_end[0].line_start_offset,272 source.2 - start_end[0].line_start_offset,273 ),274 }],275 }],276 };277278 let dl = DisplayList::from(snippet);279 println!("{}", dl);280 } else {281 print_jsonnet_pair(282 source.0.to_str().unwrap(),283 &start_end[0],284 &start_end[1],285 opts.trace_format == TraceFormat::GoJsonnet,286 );287 }288 }289}290291fn print_jsonnet_pair(file: &str, start: &CodeLocation, end: &CodeLocation, is_go: bool) {292 if is_go {293 print!(" ");294 } else {295 print!(" ");296 }297 print!("{}:", file);298 if start.line == end.line {299 // IDK why, but this is the behavior original jsonnet cpp impl shows300 if start.column == end.column || !is_go && start.column + 1 == end.column {301 println!("{}:{}", start.line, end.column)302 } else {303 println!("{}:{}-{}", start.line, start.column, end.column);304 }305 } else {306 println!(307 "({}:{})-({}:{})",308 start.line, end.column, start.line, end.column309 );310 }311}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, 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(103 long,104 default_value = "3",105 about = "When using --format, this option specifies string to pad output with"106 )]107 line_padding: usize,108109 #[clap(about = "File to compile", index = 1)]110 input: String,111}112113fn main() {114 let opts: Opts = Opts::parse();115 let evaluator = jsonnet_evaluator::EvaluationState::new(EvaluationSettings {116 import_resolver: Box::new(|path| String::from_utf8(std::fs::read(path).unwrap()).unwrap()),117 ..Default::default()118 });119 if !opts.no_stdlib {120 evaluator.with_stdlib();121 }122 for ExtStr { name, value } in opts.ext_str.iter().cloned() {123 evaluator.add_ext_var(name, Val::Str(value));124 }125 for ExtStr { name, value } in opts.ext_code.iter().cloned() {126 evaluator.add_ext_var(name, evaluator.parse_evaluate_raw(&value).unwrap());127 }128 let mut input = current_dir().unwrap();129 input.push(opts.input.clone());130 let code_string = String::from_utf8(std::fs::read(opts.input.clone()).unwrap()).unwrap();131 if let Err(e) = evaluator.add_file(input.clone(), code_string.clone()) {132 print_syntax_error(e, &input, &code_string);133 std::process::exit(1);134 }135 let result = evaluator.evaluate_file(&input);136 match result {137 Ok(v) => {138 let v = match v {139 Val::Func(f) => {140 let mut desc_map = HashMap::new();141 for ExtStr { name, value } in opts.tla_str.iter().cloned() {142 desc_map.insert(name, el!(Expr::Str(value)));143 }144 for ExtStr { name, value } in opts.tla_code.iter().cloned() {145 desc_map.insert(146 name,147 jsonnet_parser::parse(148 &value,149 &ParserSettings {150 file_name: PathBuf::new(),151 loc_data: false,152 },153 )154 .unwrap(),155 );156 }157 evaluator.add_global("__tmp__tlf__".to_owned(), Val::Func(f));158 evaluator159 .evaluate_raw(el!(Expr::Apply(160 el!(Expr::Var("__tmp__tlf__".to_owned())),161 ArgsDesc(desc_map.into_iter().map(|(k, v)| Arg(Some(k), v)).collect()),162 false,163 )))164 .unwrap()165 }166 v => v,167 };168 let v = match opts.format {169 Format::Json => {170 if opts.no_stdlib {171 evaluator.with_stdlib();172 }173 evaluator.add_global("__tmp__to_json__".to_owned(), v);174 let v = evaluator.parse_evaluate_raw(&format!(175 "std.manifestJsonEx(__tmp__to_json__, \"{}\")",176 " ".repeat(opts.line_padding),177 ));178 match v {179 Ok(v) => v,180 Err(err) => {181 print_error(&err, evaluator, &opts);182 std::process::exit(1);183 }184 }185 }186 Format::Yaml => {187 if opts.no_stdlib {188 evaluator.with_stdlib();189 }190 evaluator.add_global("__tmp__to_yaml__".to_owned(), v);191 let v = evaluator192 .parse_evaluate_raw("std.manifestYamlDoc(__tmp__to_yaml__, \" \")");193 match v {194 Ok(v) => v,195 Err(err) => {196 print_error(&err, evaluator, &opts);197 std::process::exit(1);198 }199 }200 }201 _ => v,202 };203 match v {204 Val::Str(s) => println!("{}", s),205 Val::Num(n) => println!("{}", n),206 _v => eprintln!(207 "jsonnet output is not a string.\nDid you forgot to set --format, or wrap your data with std.manifestJson?"208 ),209 }210 }211 Err(err) => {212 print_error(&err, evaluator, &opts);213 std::process::exit(1);214 }215 }216}217218fn print_error(err: &LocError, evaluator: EvaluationState, opts: &Opts) {219 println!("Error: {:?}", err.0);220 print_trace(&(err.1), evaluator, &opts);221}222223fn print_syntax_error(error: jsonnet_parser::ParseError, file: &PathBuf, code: &str) {224 use annotate_snippets::{225 display_list::{DisplayList, FormatOptions},226 snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation},227 };228 //&("Expected: ".to_owned() + error.expected)229 let origin = file.to_str().unwrap();230 let error_message = format!("Expected: {}", error.expected);231 let snippet = Snippet {232 opt: FormatOptions {233 color: true,234 ..Default::default()235 },236 title: Some(Annotation {237 label: Some(&error_message),238 id: None,239 annotation_type: AnnotationType::Error,240 }),241 footer: vec![],242 slices: vec![Slice {243 source: &code,244 line_start: 1,245 origin: Some(origin),246 fold: false,247 annotations: vec![SourceAnnotation {248 label: "At this position",249 annotation_type: AnnotationType::Error,250 range: (error.location.offset, error.location.offset + 1),251 }],252 }],253 };254255 let dl = DisplayList::from(snippet);256 println!("{}", dl);257}258259fn print_trace(trace: &StackTrace, evaluator: EvaluationState, opts: &Opts) {260 use annotate_snippets::{261 display_list::{DisplayList, FormatOptions},262 snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation},263 };264 for item in trace.0.iter() {265 let desc = &item.1;266 if (item.0).1.is_none() {267 continue;268 }269 let source = (item.0).1.clone().unwrap();270 let code = evaluator.get_source(&source.0);271 if code.is_none() {272 continue;273 }274 let code = code.unwrap();275 let start_end = offset_to_location(&code, &[source.1, source.2]);276 if opts.trace_format == TraceFormat::Custom {277 let source_fragment: String = code278 .chars()279 .skip(start_end[0].line_start_offset)280 .take(start_end[1].line_end_offset - start_end[0].line_start_offset)281 .collect();282 let snippet = Snippet {283 opt: FormatOptions {284 color: true,285 ..Default::default()286 },287 title: Some(Annotation {288 label: Some(&item.1),289 id: None,290 annotation_type: AnnotationType::Error,291 }),292 footer: vec![],293 slices: vec![Slice {294 source: &source_fragment,295 line_start: start_end[0].line,296 origin: Some(&source.0.to_str().unwrap()),297 fold: false,298 annotations: vec![SourceAnnotation {299 label: desc,300 annotation_type: AnnotationType::Error,301 range: (302 source.1 - start_end[0].line_start_offset,303 source.2 - start_end[0].line_start_offset,304 ),305 }],306 }],307 };308309 let dl = DisplayList::from(snippet);310 println!("{}", dl);311 } else {312 print_jsonnet_pair(313 source.0.to_str().unwrap(),314 &start_end[0],315 &start_end[1],316 opts.trace_format == TraceFormat::GoJsonnet,317 );318 }319 }320}321322fn print_jsonnet_pair(file: &str, start: &CodeLocation, end: &CodeLocation, is_go: bool) {323 if is_go {324 print!(" ");325 } else {326 print!(" ");327 }328 print!("{}:", file);329 if start.line == end.line {330 // IDK why, but this is the behavior original jsonnet cpp impl shows331 if start.column == end.column || !is_go && start.column + 1 == end.column {332 println!("{}:{}", start.line, end.column)333 } else {334 println!("{}:{}-{}", start.line, start.column, end.column);335 }336 } else {337 println!(338 "({}:{})-({}:{})",339 start.line, end.column, start.line, end.column340 );341 }342}crates/jsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jsonnet-evaluator/src/lib.rs
+++ b/crates/jsonnet-evaluator/src/lib.rs
@@ -191,9 +191,14 @@
file_name: PathBuf::from("raw.jsonnet"),
loc_data: true,
},
- );
+ )
+ .unwrap();
+ self.evaluate_raw(parsed)
+ }
+
+ pub fn evaluate_raw(&self, code: LocExpr) -> Result<Val> {
self.begin_state();
- let value = evaluate(self.create_default_context()?, &parsed.unwrap());
+ let value = evaluate(self.create_default_context()?, &code);
self.end_state();
value
}