difftreelog
refactor extrace trace format to separate crate
in: master
4 files changed
cmds/jrsonnet/Cargo.tomldiffbeforeafterboth--- a/cmds/jrsonnet/Cargo.toml
+++ b/cmds/jrsonnet/Cargo.toml
@@ -11,11 +11,9 @@
[dependencies]
jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "1.0.0" }
jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "1.0.0" }
-annotate-snippets = "0.8.0"
+jrsonnet-trace = { path = "../../crates/jrsonnet-trace", version = "1.0.0" }
# TODO: Fix mimalloc compile errors, and use them
mimallocator = "0.1.3"
[dependencies.clap]
version = "3.0.0-beta.1"
-default-features = false
-features = ["std", "derive"]
cmds/jrsonnet/src/main.rsdiffbeforeafterboth1use clap::Clap;2use jrsonnet_evaluator::Val;3use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParserSettings};4use jrsonnet_trace::{CompactFormat, ExplainingFormat, PathResolver, TraceFormat};5use std::env::current_dir;6use std::{collections::HashMap, path::PathBuf, rc::Rc, str::FromStr};78#[global_allocator]9static GLOBAL: mimallocator::Mimalloc = mimallocator::Mimalloc;1011enum Format {12 None,13 Json,14 Yaml,15}1617impl FromStr for Format {18 type Err = &'static str;19 fn from_str(s: &str) -> Result<Self, Self::Err> {20 Ok(match s {21 "none" => Format::None,22 "json" => Format::Json,23 "yaml" => Format::Yaml,24 _ => return Err("no such format"),25 })26 }27}2829#[derive(PartialEq)]30enum TraceFormatName {31 Compact,32 Explaining,33}34impl FromStr for TraceFormatName {35 type Err = &'static str;36 fn from_str(s: &str) -> Result<Self, Self::Err> {37 Ok(match s {38 "compact" => TraceFormatName::Compact,39 "explaining" => TraceFormatName::Explaining,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(name = "jrsonnet", version, author)]70pub struct Opts {71 #[clap(long, about = "Disable global std variable")]72 no_stdlib: bool,73 #[clap(long, about = "Add external string", number_of_values = 1)]74 ext_str: Vec<ExtStr>,75 #[clap(long, about = "Add external string from code", number_of_values = 1)]76 ext_code: Vec<ExtStr>,77 #[clap(long, about = "Add TLA", number_of_values = 1)]78 tla_str: Vec<ExtStr>,79 #[clap(long, about = "Add TLA from code", number_of_values = 1)]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 = "compact", possible_values = &["compact", "explaining"], about = "Choose format of displayed stacktraces")]84 trace_format: TraceFormatName,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 about = "Required os stack size, probally you shouldn't change it"104 )]105 thread_stack_size: Option<usize>,106107 #[clap(long, short = "J", about = "Library search dir")]108 jpath: Vec<PathBuf>,109110 #[clap(111 long,112 default_value = "3",113 about = "When using --format, this option specifies string to pad output with"114 )]115 line_padding: usize,116117 #[clap(about = "File to compile")]118 input: String,119}120121fn main() {122 let opts: Opts = Opts::parse();123 if let Some(size) = opts.thread_stack_size {124 std::thread::Builder::new()125 .stack_size(size * 1024 * 1024)126 .spawn(|| main_real(opts))127 .unwrap()128 .join()129 .unwrap();130 } else {131 main_real(opts)132 }133}134135fn main_real(opts: Opts) {136 let evaluator = jrsonnet_evaluator::EvaluationState::default();137 evaluator.set_max_trace(opts.max_trace);138 evaluator.set_max_stack(opts.max_stack);139 evaluator.set_import_resolver(Box::new(jrsonnet_evaluator::FileImportResolver {140 library_paths: opts.jpath.clone(),141 }));142 if !opts.no_stdlib {143 evaluator.with_stdlib();144 }145 for ExtStr { name, value } in opts.ext_str.iter().cloned() {146 evaluator.add_ext_var(name.into(), Val::Str(value.into()));147 }148 for ExtStr { name, value } in opts.ext_code.iter().cloned() {149 evaluator.add_ext_var(name.into(), evaluator.parse_evaluate_raw(&value).unwrap());150 }151152 let resolver = PathResolver::Relative(std::env::current_dir().unwrap());153 let trace_format: Box<dyn TraceFormat> = match opts.trace_format {154 TraceFormatName::Compact => Box::new(CompactFormat { resolver }),155 TraceFormatName::Explaining => Box::new(ExplainingFormat { resolver }),156 };157158 let mut input = current_dir().unwrap();159 input.push(opts.input.clone());160 let code_string = String::from_utf8(std::fs::read(opts.input.clone()).unwrap()).unwrap();161 if let Err(e) = evaluator.add_file(Rc::new(input.clone()), code_string.into()) {162 trace_format.print_trace(&evaluator, &e).unwrap();163 std::process::exit(1);164 }165 let result = evaluator.evaluate_file(&input);166 match result {167 Ok(v) => {168 let v = match v {169 Val::Func(f) => {170 let mut desc_map = HashMap::new();171 for ExtStr { name, value } in opts.tla_str.iter().cloned() {172 desc_map.insert(name, el!(Expr::Str(value.into())));173 }174 for ExtStr { name, value } in opts.tla_code.iter().cloned() {175 desc_map.insert(176 name,177 jrsonnet_parser::parse(178 &value,179 &ParserSettings {180 file_name: Rc::new(PathBuf::new()),181 loc_data: false,182 },183 )184 .unwrap(),185 );186 }187 evaluator.add_global("__tmp__tlf__".into(), Val::Func(f));188 evaluator189 .evaluate_raw(el!(Expr::Apply(190 el!(Expr::Var("__tmp__tlf__".into())),191 ArgsDesc(desc_map.into_iter().map(|(k, v)| Arg(Some(k), v)).collect()),192 false,193 )))194 .unwrap()195 }196 v => v,197 };198 let v = evaluator.run_in_state(|| match opts.format {199 Format::Json => Ok(Val::Str(v.into_json(opts.line_padding)?)),200 Format::Yaml => Ok(Val::Str(v.into_yaml(opts.line_padding)?)),201 _ => Ok(v),202 });203 let v = match v {204 Ok(v) => v,205 Err(err) => {206 trace_format.print_trace(&evaluator, &err).unwrap();207 std::process::exit(1);208 }209 };210 match v {211 Val::Str(s) => println!("{}", s),212 Val::Num(n) => println!("{}", n),213 _v => eprintln!(214 "jsonnet output is not a string.\nDid you forgot to set --format, or wrap your data with std.manifestJson?"215 ),216 }217 }218 Err(err) => {219 trace_format.print_trace(&evaluator, &err).unwrap();220 std::process::exit(1);221 }222 }223}crates/jrsonnet-trace/Cargo.tomldiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-trace/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "jrsonnet-trace"
+version = "1.0.0"
+authors = ["Лач <iam@lach.pw>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+jrsonnet-evaluator = { path = "../jrsonnet-evaluator", version = "1.0.0" }
+jrsonnet-parser = { path = "../jrsonnet-parser", version = "1.0.0" }
+pathdiff = "0.2.0"
+annotate-snippets = "0.9.0"
crates/jrsonnet-trace/src/lib.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-trace/src/lib.rs
@@ -0,0 +1,176 @@
+use jrsonnet_evaluator::{
+ trace::{offset_to_location, CodeLocation},
+ EvaluationState, LocError,
+};
+use std::path::PathBuf;
+
+/// How paths should be displayed
+pub enum PathResolver {
+ /// Only filename will be shown
+ FileName,
+ /// Absolute path of file
+ Absolute,
+ /// Relative path from base directory
+ Relative(PathBuf),
+}
+
+impl PathResolver {
+ pub fn resolve(&self, from: &PathBuf) -> String {
+ match self {
+ PathResolver::FileName => from.file_name().unwrap().to_string_lossy().into_owned(),
+ PathResolver::Absolute => from.to_string_lossy().into_owned(),
+ PathResolver::Relative(base) => {
+ if from.is_relative() {
+ return from.to_string_lossy().into_owned();
+ }
+ pathdiff::diff_paths(from, base)
+ .unwrap()
+ .to_string_lossy()
+ .into_owned()
+ }
+ }
+ }
+}
+
+/// Implements trace to string pretty-printing
+pub trait TraceFormat {
+ fn write_trace(
+ &self,
+ out: &mut dyn std::io::Write,
+ evaluation_state: &EvaluationState,
+ error: &LocError,
+ ) -> Result<(), std::io::Error>;
+ fn print_trace(
+ &self,
+ evaluation_state: &EvaluationState,
+ error: &LocError,
+ ) -> Result<(), std::io::Error> {
+ self.write_trace(&mut std::io::stdout(), evaluation_state, error)
+ }
+}
+
+fn print_code_location(
+ out: &mut impl std::fmt::Write,
+ start: &CodeLocation,
+ end: &CodeLocation,
+) -> Result<(), std::fmt::Error> {
+ if start.line == end.line {
+ if start.column == end.column {
+ write!(out, "{}:{}", start.line, end.column - 1)?;
+ } else {
+ write!(out, "{}:{}-{}", start.line, start.column - 1, end.column)?;
+ }
+ } else {
+ write!(
+ out,
+ "{}:{}-{}:{}",
+ start.line,
+ end.column - 1,
+ start.line,
+ end.column
+ )?;
+ }
+ Ok(())
+}
+
+/// vanilla jsonnet like formatting
+pub struct CompactFormat {
+ pub resolver: PathResolver,
+}
+
+impl TraceFormat for CompactFormat {
+ fn write_trace(
+ &self,
+ out: &mut dyn std::io::Write,
+ evaluation_state: &EvaluationState,
+ error: &LocError,
+ ) -> Result<(), std::io::Error> {
+ writeln!(out, "{:?}", error.0)?;
+ let file_names = (error.1)
+ .0
+ .iter()
+ .map(|el| {
+ let resolved_path = self.resolver.resolve(&(el.0).0);
+ // TODO: Process all trace elements first
+ let location =
+ evaluation_state.map_source_locations(&(el.0).0, &[(el.0).1, (el.0).2]);
+ (resolved_path, location)
+ })
+ .map(|(mut n, location)| {
+ use std::fmt::Write;
+ write!(n, ":").unwrap();
+ print_code_location(&mut n, &location[0], &location[1]).unwrap();
+ n
+ })
+ .collect::<Vec<_>>();
+ let align = file_names.iter().map(|e| e.len()).max().unwrap_or(0);
+ for (i, (el, file)) in (error.1).0.iter().zip(file_names).enumerate() {
+ if i != 0 {
+ writeln!(out)?;
+ }
+ write!(out, "{:<w$}: {}", file, el.1, w = align)?;
+ }
+ Ok(())
+ }
+}
+
+/// rustc-like trace displaying
+pub struct ExplainingFormat {
+ pub resolver: PathResolver,
+}
+impl TraceFormat for ExplainingFormat {
+ fn write_trace(
+ &self,
+ out: &mut dyn std::io::Write,
+ evaluation_state: &EvaluationState,
+ error: &LocError,
+ ) -> Result<(), std::io::Error> {
+ use annotate_snippets::{
+ display_list::{DisplayList, FormatOptions},
+ snippet::{AnnotationType, Slice, Snippet, SourceAnnotation},
+ };
+ writeln!(out, "{:?}", error.0)?;
+ let trace = &error.1;
+ for item in trace.0.iter() {
+ let desc = &item.1;
+ let source = item.0.clone();
+ let start_end = evaluation_state.map_source_locations(&source.0, &[source.1, source.2]);
+
+ let source_fragment: String = evaluation_state
+ .get_source(&source.0)
+ .unwrap()
+ .chars()
+ .skip(start_end[0].line_start_offset)
+ .take(start_end[1].line_end_offset - start_end[0].line_start_offset)
+ .collect();
+
+ let origin = self.resolver.resolve(&source.0);
+ let snippet = Snippet {
+ opt: FormatOptions {
+ color: true,
+ ..Default::default()
+ },
+ title: None,
+ footer: vec![],
+ slices: vec![Slice {
+ source: &source_fragment,
+ line_start: start_end[0].line,
+ origin: Some(&origin),
+ fold: false,
+ annotations: vec![SourceAnnotation {
+ label: desc,
+ annotation_type: AnnotationType::Error,
+ range: (
+ source.1 - start_end[0].line_start_offset,
+ source.2 - start_end[0].line_start_offset,
+ ),
+ }],
+ }],
+ };
+
+ let dl = DisplayList::from(snippet);
+ writeln!(out, "{}", dl)?;
+ }
+ Ok(())
+ }
+}