//! The printer of `@prettier/plugin-xml` (`src/printer.js` and `src/embed.js`). use super::ast::{Attribute, Doctype, Element, External, Item, Prolog, Span, Top, Tree}; use super::{Quotes, Settings, Whitespace, sort}; use crate::doc::{Align, Docs}; use crate::embed::{Embed, Kind as Purpose, Request}; use crate::stack::Stack; use crate::strings; const IGNORE_START: &str = ""; const IGNORE_END: &str = ""; pub(crate) struct Printer<'p, 'a> { pub(crate) tree: &'p Tree, pub(crate) text: &'a str, pub(crate) settings: &'p Settings, pub(crate) docs: &'p mut Docs<'a>, pub(crate) embed: &'p mut dyn Embed, pub(crate) stack: Stack, } /// What comes before the `/>` of an element with no content. #[derive(Clone, Copy)] enum Space { Text(&'static str), Line, Soft, } impl<'a> Printer<'_, 'a> { /// `printDocument`: the parts of the document, each on its own line. pub(crate) fn document(&mut self) { for (index, top) in self.tree.top.iter().enumerate() { if index > 0 { self.docs.hardline(); } match *top { Top::Prolog(prolog) => self.prolog(prolog), Top::Doctype(doctype) => self.doctype(doctype), Top::Item(item) => self.item(item), } } self.docs.hardline(); } fn prolog(&mut self, Prolog { open, attributes }: Prolog) { let group = self.docs.group(); self.span(open); let indent = self.docs.indent(); self.docs.softline(); for (index, attribute) in self.tree.attributes(attributes).iter().enumerate() { if index > 0 { self.docs.line(); } self.attribute(attribute); } self.docs.close(indent); match self.settings.self_closing_space { true => self.docs.line(), false => self.docs.softline(), } self.docs.text("?>"); self.docs.close(group); } fn doctype(&mut self, Doctype { name, external }: Doctype) { let group = self.docs.group(); self.docs.text(" { self.span(keyword); self.indented_line(system); } External::Public { keyword, public, system } => { let inner = self.docs.group(); self.span(keyword); self.indented_line(public); self.docs.close(inner); self.indented_line(system); } } self.docs.close(group); } self.docs.text(">"); self.docs.close(group); } fn indented_line(&mut self, span: Span) { let indent = self.docs.indent(); self.docs.line(); self.span(span); self.docs.close(indent); } fn item(&mut self, item: Item) { match item { Item::Element(id) => self.element(id), Item::Text(span) | Item::Space(span) => self.lines(span.of(self.text)), Item::Reference(span) | Item::CData(span) | Item::Comment(span) | Item::Instruction(span) => { self.span(span) } } } // ───────────────────────────── `printElement` ───────────────────────────── fn element(&mut self, id: u32) { if !self.stack.has_room() { return; } let element = self.tree.elements[id as usize]; if self.settings.format_embedded && self.embedded(&element) { return; } let Some(content) = element.content else { return self.self_closed(&element) }; let items = self.tree.content(content); if items.is_empty() { return self.self_closed(&element); } if !self.is_whitespace_ignorable(&element, items) { let group = self.docs.group(); self.open_tag(&element); let indent = self.docs.indent(); self.content(items); self.docs.close(indent); self.close_tag(&element); return self.docs.close(group); } if self.settings.whitespace == Whitespace::Preserve && items.iter().any(|item| matches!(item, Item::Text(_))) { let group = self.docs.group(); self.open_tag(&element); for &item in items { self.item(item); } self.close_tag(&element); return self.docs.close(group); } self.fragments(&element, items); } /// The content of an element whose whitespace can be ignored, each part on its own line unless it only has text /// and references. fn fragments(&mut self, element: &Element, items: &[Item]) { let fragments: Vec = items.iter().copied().filter(|item| !matches!(item, Item::Space(_))).collect(); let texts = fragments.iter().filter(|item| matches!(item, Item::Text(_))).count(); let references = fragments.iter().filter(|item| matches!(item, Item::Reference(_))).count(); let group = self.docs.group(); match fragments[..] { [] => { self.docs.close(group); return self.self_closed(element); } [only] if texts == 1 => { self.open_tag(element); let indent = self.docs.indent(); self.docs.softline(); self.fragment(only); self.docs.close(indent); self.docs.softline(); } _ => { let spaced = fragments.len() == texts + references; self.open_tag(element); let indent = self.docs.indent(); self.docs.hardline(); let mut last = 0; for (index, &fragment) in fragments.iter().enumerate() { let (start, end) = self.tree.lines(fragment.span(self.tree)); if index > 0 { if start >= last + 2 { self.docs.hardline(); self.docs.hardline(); } else if spaced { self.docs.text(" "); } else { self.docs.hardline(); } } self.fragment(fragment); last = end; } self.docs.close(indent); self.docs.hardline(); } } self.close_tag(element); self.docs.close(group); } fn fragment(&mut self, item: Item) { match item { Item::Text(span) => self.words(span), item => self.item(item), } } /// `printCharDataIgnore`: the text, trimmed, its words filled. The plugin also trims what JavaScript counts as /// whitespace, such as a no-break space, which XML doesn't. fn words(&mut self, span: Span) { let trimmed = span.of(self.text).trim_matches([' ', '\t', '\n']); let group = self.docs.group(); for (index, line) in trimmed.split('\n').enumerate() { if index > 0 { self.docs.literalline(); } let fill = self.docs.fill(); let mut last = 0; for (start, end) in spaces_between_words(line.as_bytes()) { let part = self.docs.part(); self.docs.text(&line[last..start]); self.docs.close(part); let part = self.docs.part(); self.docs.line(); self.docs.close(part); last = end; } let part = self.docs.part(); self.docs.text(&line[last..]); self.docs.close(part); self.docs.close(fill); } self.docs.close(group); } /// `printContent`: the content as it is written, with its ignored ranges as they are written. fn content(&mut self, items: &[Item]) { let group = self.docs.group(); let ranges = ignore_ranges(self.text, items); let mut pending = ranges.iter().peekable(); for &item in items { let start = item.start(self.tree); while let Some(range) = pending.next_if(|range| range.start < start) { self.lines(range.of(self.text)); } if ranges.iter().all(|range| start < range.start || start >= range.end) { self.item(item); } } for range in pending { self.lines(range.of(self.text)); } self.docs.close(group); } /// `isWhitespaceIgnorable` fn is_whitespace_ignorable(&self, element: &Element, items: &[Item]) -> bool { self.settings.whitespace != Whitespace::Strict && element.name.of(self.text) != "xsl:text" && !self.tree.attributes(element.attributes).iter().any(|attribute| { attribute.name.of(self.text) == "xml:space" && unquoted(attribute.value.of(self.text)) == "preserve" }) && !items.iter().any(|item| matches!(item, Item::CData(_))) && ignore_ranges(self.text, items).is_empty() } // ───────────────────────────── tags ───────────────────────────── fn self_closed(&mut self, element: &Element) { let group = self.docs.group(); self.tag_start(element, true); match self.space() { Space::Text(text) => self.docs.text(text), Space::Line => self.docs.line(), Space::Soft => self.docs.softline(), } self.docs.text("/>"); self.docs.close(group); } fn space(&self) -> Space { match (self.settings.bracket_same_line, self.settings.self_closing_space) { (true, true) => Space::Text(" "), (true, false) => Space::Text(""), (false, true) => Space::Line, (false, false) => Space::Soft, } } fn open_tag(&mut self, element: &Element) { let group = self.docs.group(); self.tag_start(element, true); if !self.settings.bracket_same_line { self.docs.softline(); } self.docs.text(">"); self.docs.close(group); } fn close_tag(&mut self, element: &Element) { let group = self.docs.group(); self.docs.text(""); self.docs.close(group); } /// `<`, the name and the attributes. `printElement` sorts them and may put each on its own line; the tag of an /// embedded element does neither. fn tag_start(&mut self, element: &Element, is_printed: bool) { self.docs.text("<"); self.span(element.name); let mut attributes = self.tree.attributes(element.attributes).to_vec(); if attributes.is_empty() { return; } if is_printed && self.settings.sort_attributes { attributes .sort_by(|left, right| sort::attributes(left.name.of(self.text), right.name.of(self.text))); } let hard = is_printed && self.settings.single_attribute_per_line; let indent = self.docs.indent(); self.docs.line(); for (index, attribute) in attributes.iter().enumerate() { if index > 0 { match hard { true => self.docs.hardline(), false => self.docs.line(), } } self.attribute(attribute); } self.docs.close(indent); } fn attribute(&mut self, attribute: &Attribute) { self.span(attribute.name); self.docs.text("="); let value = attribute.value.of(self.text); match self.settings.quotes { Quotes::Preserve => self.docs.text(value), Quotes::Double => self.docs.owned(&format!("\"{}\"", unquoted(value).replace('"', """))), Quotes::Single => self.docs.owned(&format!("'{}'", unquoted(value).replace('\'', "'"))), } } // ───────────────────────────── `embed` ───────────────────────────── /// Prints an element whose content is code in another language, formatted, and returns true. Returns false if it /// isn't one, or if its code isn't formatted. fn embedded(&mut self, element: &Element) -> bool { let Some(language) = self.embedded_language(element) else { return false }; let Some(items) = element.content.map(|range| self.tree.content(range)) else { return false }; let (Some(first), Some(last)) = (items.first(), items.last()) else { return false }; if !items.iter().all(|item| item.is_chardata()) { return false; } let code = &self.text[first.start(self.tree) as usize..last.span(self.tree).end as usize]; let request = Request { code, language, kind: Purpose::Block, indent: 0, width: self.settings.width }; let formatted = self.embed.format(request); let document = match &formatted { Some(_) => None, None => match self.style_sheet(language, code) { Some(document) => Some(document), None => return false, }, }; let group = self.docs.group(); let open = self.docs.group(); self.tag_start(element, false); if !self.settings.bracket_same_line { self.docs.softline(); } self.docs.text(">"); self.docs.close(open); self.docs.literalline(); let root = self.docs.align(Align::Root); match (formatted, document) { (Some(formatted), _) => { let formatted = formatted.trim_end_matches('\n'); for (index, line) in formatted.split('\n').enumerate() { if index > 0 { self.docs.literalline(); } self.docs.owned(line); } } (None, Some(document)) => document.write_lines(self.docs), (None, None) => {} } self.docs.close(root); self.docs.hardline(); self.close_tag(element); self.docs.close(group); true } /// `getParser`, for `