1use std::{2 any::type_name,3 fs,4 io::{self, Write},5 path::PathBuf,6 process,7 rc::Rc,8};910use children::{children_between, trivia_before};11use clap::Parser;12use dprint_core::formatting::{13 condition_helpers::is_multiple_lines, condition_resolvers::true_resolver,14 ConditionResolverContext, LineNumber, PrintItems, PrintOptions,15};16use jrsonnet_rowan_parser::{17 nodes::{18 Arg, ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,19 DestructRest, Expr, ExprBase, FieldName, ForSpec, IfSpec, ImportKind, Literal, Member,20 Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Stmt, Suffix, Text,21 UnaryOperator, Visibility,22 },23 AstNode, AstToken as _, SyntaxToken,24};2526use crate::{27 children::trivia_after,28 comments::{format_comments, CommentLocation},29};3031mod children;32mod comments;33#[cfg(test)]34mod tests;3536pub trait Printable {37 fn print(&self, out: &mut PrintItems);38}3940macro_rules! pi {41 (@i; $($t:tt)*) => {{42 #[allow(unused_mut)]43 let mut o = dprint_core::formatting::PrintItems::new();44 pi!(@s; o: $($t)*);45 o46 }};47 (@s; $o:ident: str($e:expr $(,)?) $($t:tt)*) => {{48 $o.push_str($e);49 pi!(@s; $o: $($t)*);50 }};51 (@s; $o:ident: string($e:expr $(,)?) $($t:tt)*) => {{52 $o.push_string($e);53 pi!(@s; $o: $($t)*);54 }};55 (@s; $o:ident: nl $($t:tt)*) => {{56 $o.push_signal(dprint_core::formatting::Signal::NewLine);57 pi!(@s; $o: $($t)*);58 }};59 (@s; $o:ident: tab $($t:tt)*) => {{60 $o.push_signal(dprint_core::formatting::Signal::Tab);61 pi!(@s; $o: $($t)*);62 }};63 (@s; $o:ident: >i $($t:tt)*) => {{64 $o.push_signal(dprint_core::formatting::Signal::StartIndent);65 pi!(@s; $o: $($t)*);66 }};67 (@s; $o:ident: <i $($t:tt)*) => {{68 $o.push_signal(dprint_core::formatting::Signal::FinishIndent);69 pi!(@s; $o: $($t)*);70 }};71 (@s; $o:ident: info($v:expr) $($t:tt)*) => {{72 $o.push_info($v);73 pi!(@s; $o: $($t)*);74 }};75 (@s; $o:ident: if($s:literal, $cond:expr, $($i:tt)*) $($t:tt)*) => {{76 $o.push_condition(dprint_core::formatting::conditions::if_true(77 $s,78 $cond.clone(),79 {80 let mut o = PrintItems::new();81 p!(o, $($i)*);82 o83 },84 ));85 pi!(@s; $o: $($t)*);86 }};87 (@s; $o:ident: if_else($s:literal, $cond:expr, $($i:tt)*)($($e:tt)+) $($t:tt)*) => {{88 $o.push_condition(dprint_core::formatting::conditions::if_true_or(89 $s,90 $cond.clone(),91 {92 let mut o = PrintItems::new();93 p!(o, $($i)*);94 o95 },96 {97 let mut o = PrintItems::new();98 p!(o, $($e)*);99 o100 },101 ));102 pi!(@s; $o: $($t)*);103 }};104 (@s; $o:ident: if_not($s:literal, $cond:expr, $($e:tt)*) $($t:tt)*) => {{105 $o.push_condition(dprint_core::formatting::conditions::if_true_or(106 $s,107 $cond.clone(),108 {109 let o = PrintItems::new();110 o111 },112 {113 let mut o = PrintItems::new();114 p!(o, $($e)*);115 o116 },117 ));118 pi!(@s; $o: $($t)*);119 }};120 (@s; $o:ident: {$expr:expr} $($t:tt)*) => {{121 $expr.print($o);122 pi!(@s; $o: $($t)*);123 }};124 (@s; $o:ident: items($expr:expr) $($t:tt)*) => {{125 $o.extend($expr);126 pi!(@s; $o: $($t)*);127 }};128 (@s; $o:ident: if ($e:expr)($($then:tt)*) $($t:tt)*) => {{129 if $e {130 pi!(@s; $o: $($then)*);131 }132 pi!(@s; $o: $($t)*);133 }};134 (@s; $o:ident: ifelse ($e:expr)($($then:tt)*)($($else:tt)*) $($t:tt)*) => {{135 if $e {136 pi!(@s; $o: $($then)*);137 } else {138 pi!(@s; $o: $($else)*);139 }140 pi!(@s; $o: $($t)*);141 }};142 (@s; $i:ident:) => {}143}144macro_rules! p {145 ($o:ident, $($t:tt)*) => {146 pi!(@s; $o: $($t)*)147 };148}149pub(crate) use p;150pub(crate) use pi;151152impl<P> Printable for Option<P>153where154 P: Printable,155{156 fn print(&self, out: &mut PrintItems) {157 if let Some(v) = self {158 v.print(out)159 } else {160 p!(161 out,162 string(format!(163 "/*missing {}*/",164 type_name::<P>().replace("jrsonnet_rowan_parser::generated::nodes::", "")165 ),)166 )167 }168 }169}170171impl Printable for SyntaxToken {172 fn print(&self, out: &mut PrintItems) {173 p!(out, string(self.to_string()))174 }175}176177impl Printable for Text {178 fn print(&self, out: &mut PrintItems) {179 p!(out, string(format!("{}", self)))180 }181}182impl Printable for Number {183 fn print(&self, out: &mut PrintItems) {184 p!(out, string(format!("{}", self)))185 }186}187188impl Printable for Name {189 fn print(&self, out: &mut PrintItems) {190 p!(out, { self.ident_lit() })191 }192}193194impl Printable for DestructRest {195 fn print(&self, out: &mut PrintItems) {196 p!(out, str("..."));197 if let Some(name) = self.into() {198 p!(out, { name });199 }200 }201}202203impl Printable for Destruct {204 fn print(&self, out: &mut PrintItems) {205 match self {206 Destruct::DestructFull(f) => {207 p!(out, { f.name() })208 }209 Destruct::DestructSkip(_) => p!(out, str("?")),210 Destruct::DestructArray(a) => {211 p!(out, str("[") >i nl);212 for el in a.destruct_array_parts() {213 match el {214 DestructArrayPart::DestructArrayElement(e) => {215 p!(out, {e.destruct()} str(",") nl)216 }217 DestructArrayPart::DestructRest(d) => {218 p!(out, {d} str(",") nl)219 }220 }221 }222 p!(out, <i str("]"));223 }224 Destruct::DestructObject(o) => {225 p!(out, str("{") >i nl);226 for item in o.destruct_object_fields() {227 p!(out, { item.field() });228 if let Some(des) = item.destruct() {229 p!(out, str(": ") {des})230 }231 if let Some(def) = item.expr() {232 p!(out, str(" = ") {def});233 }234 p!(out, str(",") nl);235 }236 if let Some(rest) = o.destruct_rest() {237 p!(out, {rest} nl)238 }239 p!(out, <i str("}"));240 }241 }242 }243}244245impl Printable for FieldName {246 fn print(&self, out: &mut PrintItems) {247 match self {248 FieldName::FieldNameFixed(f) => {249 if let Some(id) = f.id() {250 p!(out, { id })251 } else if let Some(str) = f.text() {252 p!(out, { str })253 } else {254 p!(out, str("/*missing FieldName*/"))255 }256 }257 FieldName::FieldNameDynamic(d) => {258 p!(out, str("[") {d.expr()} str("]"))259 }260 }261 }262}263264impl Printable for Visibility {265 fn print(&self, out: &mut PrintItems) {266 p!(out, string(self.to_string()))267 }268}269270impl Printable for ObjLocal {271 fn print(&self, out: &mut PrintItems) {272 p!(out, str("local ") {self.bind()})273 }274}275276impl Printable for Assertion {277 fn print(&self, out: &mut PrintItems) {278 p!(out, str("assert ") {self.condition()});279 if self.colon_token().is_some() || self.message().is_some() {280 p!(out, str(": ") {self.message()})281 }282 }283}284285impl Printable for ParamsDesc {286 fn print(&self, out: &mut PrintItems) {287 p!(out, str("(") >i nl);288 for param in self.params() {289 p!(out, { param.destruct() });290 if param.assign_token().is_some() || param.expr().is_some() {291 p!(out, str(" = ") {param.expr()})292 }293 p!(out, str(",") nl)294 }295 p!(out, <i str(")"));296 }297}298impl Printable for ArgsDesc {299 fn print(&self, out: &mut PrintItems) {300 let start = LineNumber::new("start");301 let end = LineNumber::new("end");302 let multi_line = Rc::new(move |condition_context: &mut ConditionResolverContext| {303 is_multiple_lines(condition_context, start, end).map(|v| !v)304 });305 p!(out, str("(") info(start) if("start args", multi_line, >i nl));306 let (children, end_comments) = children_between::<Arg>(307 self.syntax().clone(),308 self.l_paren_token().map(Into::into).as_ref(),309 self.r_paren_token().map(Into::into).as_ref(),310 None,311 );312 let mut args = children.into_iter().peekable();313 while let Some(ele) = args.next() {314 if ele.should_start_with_newline {315 p!(out, nl);316 }317 format_comments(&ele.before_trivia, CommentLocation::AboveItem, out);318 let arg = ele.value;319 if arg.name().is_some() || arg.assign_token().is_some() {320 p!(out, {arg.name()} str(" = "));321 }322 let comma_between = if args.peek().is_some() {323 true_resolver()324 } else {325 multi_line.clone()326 };327 p!(out, {arg.expr()} if("arg comma", comma_between, str(",") if_not("between args", multi_line, str(" "))));328 format_comments(&ele.inline_trivia, CommentLocation::ItemInline, out);329 p!(out, if("between args", multi_line, nl));330 }331 p!(out, if("end args", multi_line, <i info(end)) str(")"));332 }333}334impl Printable for SliceDesc {335 fn print(&self, out: &mut PrintItems) {336 p!(out, str("["));337 if self.from().is_some() {338 p!(out, { self.from() });339 }340 p!(out, str(":"));341 if self.end().is_some() {342 p!(out, { self.end().map(|e| e.expr()) })343 }344 345 if self.step().is_some() {346 p!(out, str(":") {self.step().map(|e|e.expr())});347 }348 p!(out, str("]"));349 }350}351352impl Printable for Member {353 fn print(&self, out: &mut PrintItems) {354 match self {355 Member::MemberBindStmt(b) => {356 p!(out, { b.obj_local() })357 }358 Member::MemberAssertStmt(ass) => {359 p!(out, { ass.assertion() })360 }361 Member::MemberFieldNormal(n) => {362 p!(out, {n.field_name()} if(n.plus_token().is_some())({n.plus_token()}) {n.visibility()} str(" ") {n.expr()})363 }364 Member::MemberFieldMethod(m) => {365 p!(out, {m.field_name()} {m.params_desc()} {m.visibility()} str(" ") {m.expr()})366 }367 }368 }369}370371impl Printable for ObjBody {372 fn print(&self, out: &mut PrintItems) {373 match self {374 ObjBody::ObjBodyComp(l) => {375 let (children, mut end_comments) = children_between::<Member>(376 l.syntax().clone(),377 l.l_brace_token().map(Into::into).as_ref(),378 Some(379 &(l.comp_specs()380 .next()381 .expect("at least one spec is defined")382 .syntax()383 .clone())384 .into(),385 ),386 None,387 );388 let trailing_for_comp = end_comments.extract_trailing();389 p!(out, str("{") >i nl);390 for mem in children.into_iter() {391 if mem.should_start_with_newline {392 p!(out, nl);393 }394 format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);395 p!(out, {mem.value} str(","));396 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);397 p!(out, nl)398 }399400 if end_comments.should_start_with_newline {401 p!(out, nl);402 }403 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);404405 let (compspecs, end_comments) = children_between::<CompSpec>(406 l.syntax().clone(),407 l.member_comps()408 .last()409 .map(|m| m.syntax().clone())410 .map(Into::into)411 .or_else(|| l.l_brace_token().map(Into::into))412 .as_ref(),413 l.r_brace_token().map(Into::into).as_ref(),414 Some(trailing_for_comp),415 );416 for mem in compspecs.into_iter() {417 if mem.should_start_with_newline {418 p!(out, nl);419 }420 format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);421 p!(out, { mem.value });422 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);423 }424 if end_comments.should_start_with_newline {425 p!(out, nl);426 }427 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);428429 p!(out, nl <i str("}"));430 }431 ObjBody::ObjBodyMemberList(l) => {432 let (children, end_comments) = children_between::<Member>(433 l.syntax().clone(),434 l.l_brace_token().map(Into::into).as_ref(),435 l.r_brace_token().map(Into::into).as_ref(),436 None,437 );438 if children.is_empty() && end_comments.is_empty() {439 p!(out, str("{ }"));440 return;441 }442 p!(out, str("{") >i nl);443 for (i, mem) in children.into_iter().enumerate() {444 if mem.should_start_with_newline && i != 0 {445 p!(out, nl);446 }447 format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);448 p!(out, {mem.value} str(","));449 format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);450 p!(out, nl)451 }452453 if end_comments.should_start_with_newline {454 p!(out, nl);455 }456 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);457 p!(out, <i str("}"));458 }459 }460 }461}462impl Printable for UnaryOperator {463 fn print(&self, out: &mut PrintItems) {464 p!(out, string(self.text().to_string()))465 }466}467impl Printable for BinaryOperator {468 fn print(&self, out: &mut PrintItems) {469 p!(out, string(self.text().to_string()))470 }471}472impl Printable for Bind {473 fn print(&self, out: &mut PrintItems) {474 match self {475 Bind::BindDestruct(d) => {476 p!(out, {d.into()} str(" = ") {d.value()})477 }478 Bind::BindFunction(f) => {479 p!(out, {f.name()} {f.params()} str(" = ") {f.value()})480 }481 }482 }483}484impl Printable for Literal {485 fn print(&self, out: &mut PrintItems) {486 p!(out, string(self.syntax().to_string()))487 }488}489impl Printable for ImportKind {490 fn print(&self, out: &mut PrintItems) {491 p!(out, string(self.syntax().to_string()))492 }493}494impl Printable for ForSpec {495 fn print(&self, out: &mut PrintItems) {496 p!(out, str("for ") {self.bind()} str(" in ") {self.expr()})497 }498}499impl Printable for IfSpec {500 fn print(&self, out: &mut PrintItems) {501 p!(out, str("if ") {self.expr()})502 }503}504impl Printable for CompSpec {505 fn print(&self, out: &mut PrintItems) {506 match self {507 CompSpec::ForSpec(f) => f.print(out),508 CompSpec::IfSpec(i) => i.print(out),509 }510 }511}512impl Printable for Expr {513 fn print(&self, out: &mut PrintItems) {514 let (stmts, _ending) = children_between::<Stmt>(515 self.syntax().clone(),516 None,517 self.expr_base()518 .as_ref()519 .map(ExprBase::syntax)520 .cloned()521 .map(Into::into)522 .as_ref(),523 None,524 );525 for stmt in stmts {526 p!(out, { stmt.value });527 }528 p!(out, { self.expr_base() });529 let (suffixes, _ending) = children_between::<Suffix>(530 self.syntax().clone(),531 self.expr_base()532 .as_ref()533 .map(ExprBase::syntax)534 .cloned()535 .map(Into::into)536 .as_ref(),537 None,538 None,539 );540 for suffix in suffixes {541 p!(out, { suffix.value });542 }543 }544}545impl Printable for Suffix {546 fn print(&self, out: &mut PrintItems) {547 match self {548 Suffix::SuffixIndex(i) => {549 if i.question_mark_token().is_some() {550 p!(out, str("?"));551 }552 p!(out, str(".") {i.index()});553 }554 Suffix::SuffixIndexExpr(e) => {555 if e.question_mark_token().is_some() {556 p!(out, str(".?"));557 }558 p!(out, str("[") {e.index()} str("]"))559 }560 Suffix::SuffixSlice(d) => {561 p!(out, { d.slice_desc() })562 }563 Suffix::SuffixApply(a) => {564 p!(out, { a.args_desc() })565 }566 }567 }568}569impl Printable for Stmt {570 fn print(&self, out: &mut PrintItems) {571 match self {572 Stmt::StmtLocal(l) => {573 let (binds, end_comments) = children_between::<Bind>(574 l.syntax().clone(),575 l.local_kw_token().map(Into::into).as_ref(),576 l.semi_token().map(Into::into).as_ref(),577 None,578 );579 if binds.len() == 1 {580 let bind = &binds[0];581 format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);582 p!(out, str("local ") {bind.value});583 584 } else {585 p!(out,str("local") >i nl);586 for bind in binds {587 if bind.should_start_with_newline {588 p!(out, nl);589 }590 format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);591 p!(out, {bind.value} str(","));592 format_comments(&bind.inline_trivia, CommentLocation::ItemInline, out);593 p!(out, nl)594 }595 if end_comments.should_start_with_newline {596 p!(out, nl)597 }598 format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);599 p!(out,<i);600 }601 p!(out,str(";") nl);602 }603 Stmt::StmtAssert(a) => {604 p!(out, {a.assertion()} str(";") nl)605 }606 }607 }608}609impl Printable for ExprBase {610 fn print(&self, out: &mut PrintItems) {611 match self {612 Self::ExprBinary(b) => {613 p!(out, {b.lhs_work()} str(" ") {b.binary_operator()} str(" ") {b.rhs_work()})614 }615 Self::ExprUnary(u) => p!(out, {u.unary_operator()} {u.rhs()}),616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 Self::ExprObjExtend(ex) => {631 p!(out, {ex.lhs_work()} str(" ") {ex.rhs_work()})632 }633 Self::ExprParened(p) => {634 p!(out, str("(") {p.expr()} str(")"))635 }636 Self::ExprString(s) => p!(out, { s.text() }),637 Self::ExprNumber(n) => p!(out, { n.number() }),638 Self::ExprArray(a) => {639 p!(out, str("[") >i nl);640 for el in a.exprs() {641 p!(out, {el} str(",") nl);642 }643 p!(out, <i str("]"));644 }645 Self::ExprObject(obj) => {646 p!(out, { obj.obj_body() })647 }648 Self::ExprArrayComp(arr) => {649 p!(out, str("[") {arr.expr()});650 for spec in arr.comp_specs() {651 p!(out, str(" ") {spec});652 }653 p!(out, str("]"));654 }655 Self::ExprImport(v) => {656 p!(out, {v.import_kind()} str(" ") {v.text()})657 }658 Self::ExprVar(n) => p!(out, { n.name() }),659 660 661 Self::ExprIfThenElse(ite) => {662 p!(out, str("if ") {ite.cond()} str(" then ") {ite.then().map(|t| t.expr())});663 if ite.else_kw_token().is_some() || ite.else_().is_some() {664 p!(out, str(" else ") {ite.else_().map(|t| t.expr())})665 }666 }667 Self::ExprFunction(f) => p!(out, str("function") {f.params_desc()} nl {f.expr()}),668 669 Self::ExprError(e) => p!(out, str("error ") {e.expr()}),670 Self::ExprLiteral(l) => {671 p!(out, { l.literal() })672 }673 }674 }675}676677impl Printable for SourceFile {678 fn print(&self, out: &mut PrintItems) {679 let before = trivia_before(680 self.syntax().clone(),681 self.expr()682 .map(|e| e.syntax().clone())683 .map(Into::into)684 .as_ref(),685 );686 let after = trivia_after(687 self.syntax().clone(),688 self.expr()689 .map(|e| e.syntax().clone())690 .map(Into::into)691 .as_ref(),692 );693 format_comments(&before, CommentLocation::AboveItem, out);694 p!(out, {self.expr()} nl);695 format_comments(&after, CommentLocation::EndOfItems, out)696 }697}698699struct FormatOptions {700 701 indent: u8,702}703fn format(input: &str, opts: &FormatOptions) -> Option<String> {704 let (parsed, errors) = jrsonnet_rowan_parser::parse(input);705 if !errors.is_empty() {706 let mut builder = hi_doc::SnippetBuilder::new(input);707 for error in errors {708 builder709 .error(hi_doc::Text::single(710 format!("{:?}", error.error).chars(),711 Default::default(),712 ))713 .range(714 error.range.start().into()715 ..=(usize::from(error.range.end()) - 1).max(error.range.start().into()),716 )717 .build();718 }719 let snippet = builder.build();720 let ansi = hi_doc::source_to_ansi(&snippet);721 eprintln!("{ansi}");722 723 724 725 726 727 return None;728 }729 Some(dprint_core::formatting::format(730 || {731 let mut out = PrintItems::new();732 parsed.print(&mut out);733 out734 },735 PrintOptions {736 indent_width: if opts.indent == 0 {737 738 3739 } else {740 opts.indent741 },742 max_width: 100,743 use_tabs: opts.indent == 0,744 new_line_text: "\n",745 },746 ))747}748749#[derive(Parser)]750struct Opts {751 752 #[clap(long, short = 'e')]753 exec: bool,754 755 input: String,756 757 758 #[clap(long, short = 'i')]759 in_place: bool,760761 762 #[arg(long)]763 test: bool,764 765 766 767 #[arg(long, default_value = "0")]768 indent: u8,769 770 #[arg(long)]771 hard_tabs: bool,772773 774 775 776 #[arg(long, default_value = "0")]777 conv_limit: usize,778}779780#[derive(thiserror::Error, Debug)]781enum Error {782 #[error("--in-place is incompatible with --exec")]783 InPlaceExec,784 #[error("io: {0}")]785 Io(#[from] io::Error),786 #[error("persist: {0}")]787 Persist(#[from] tempfile::PersistError),788 #[error("parsing failed, refusing to reformat corrupted input")]789 Parse,790}791792fn main_result() -> Result<(), Error> {793 eprintln!("jrsonnet-fmt is a prototype of a jsonnet code formatter, do not expect it to produce meaningful results right now.");794 eprintln!("It is not expected for its output to match other implementations, it will be completly separate implementation with maybe different name.");795 let mut opts = Opts::parse();796 let input = if opts.exec {797 if opts.in_place {798 return Err(Error::InPlaceExec);799 }800 opts.input.clone()801 } else {802 fs::read_to_string(&opts.input)?803 };804805 if opts.indent == 0 {806 807 808 opts.hard_tabs = true;809 }810811 let mut iteration = 0;812 let mut formatted = input.clone();813 let mut tmp;814 815 loop {816 let Some(reformatted) = format(817 &formatted,818 &FormatOptions {819 indent: if opts.indent == 0 || opts.hard_tabs {820 0821 } else {822 opts.indent823 },824 },825 ) else {826 return Err(Error::Parse);827 };828 tmp = reformatted.trim().to_owned();829 if formatted == tmp {830 break;831 }832 formatted = tmp;833 if opts.conv_limit == 0 {834 break;835 }836 iteration += 1;837 if iteration > opts.conv_limit {838 panic!("formatting not converged");839 }840 }841 formatted.push('\n');842 if opts.test && formatted != input {843 process::exit(1);844 }845 if opts.in_place {846 let path = PathBuf::from(opts.input);847 let mut temp = tempfile::NamedTempFile::new_in(path.parent().expect(848 "not failed during read, this path is not a directory, and there is a parent",849 ))?;850 temp.write_all(formatted.as_bytes())?;851 temp.flush()?;852 temp.persist(&path)?;853 } else {854 print!("{formatted}")855 }856 Ok(())857}858859fn main() {860 if let Err(e) = main_result() {861 eprintln!("{e}");862 process::exit(1);863 }864}