1use anyhow::{anyhow, Context, Result};
2use smallvec::SmallVec;
3use std::{collections::BTreeMap, ops::Range};
4
5#[derive(Clone, Debug, Default, PartialEq)]
6pub struct Snippet {
7 pub text: String,
8 pub tabstops: Vec<TabStop>,
9}
10
11type TabStop = SmallVec<[Range<isize>; 2]>;
12
13impl Snippet {
14 pub fn parse(source: &str) -> Result<Self> {
15 let mut text = String::with_capacity(source.len());
16 let mut tabstops = BTreeMap::new();
17 parse_snippet(source, false, &mut text, &mut tabstops)
18 .context("failed to parse snippet")?;
19
20 let len = text.len() as isize;
21 let final_tabstop = tabstops.remove(&0);
22 let mut tabstops = tabstops.into_values().collect::<Vec<_>>();
23
24 if let Some(final_tabstop) = final_tabstop {
25 tabstops.push(final_tabstop);
26 } else {
27 let end_tabstop = [len..len].into_iter().collect();
28 if !tabstops.last().map_or(false, |t| *t == end_tabstop) {
29 tabstops.push(end_tabstop);
30 }
31 }
32
33 Ok(Snippet { text, tabstops })
34 }
35}
36
37fn parse_snippet<'a>(
38 mut source: &'a str,
39 nested: bool,
40 text: &mut String,
41 tabstops: &mut BTreeMap<usize, TabStop>,
42) -> Result<&'a str> {
43 loop {
44 match source.chars().next() {
45 None => return Ok(""),
46 Some('$') => {
47 source = parse_tabstop(&source[1..], text, tabstops)?;
48 }
49 Some('\\') => {
50 // As specified in the LSP spec (`Grammar` section),
51 // backslashes can escape some characters:
52 // https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#snippet_syntax
53 source = &source[1..];
54 if let Some(c) = source.chars().next() {
55 if c == '$' || c == '\\' || c == '}' {
56 text.push(c);
57 // All escapable characters are 1 byte long:
58 source = &source[1..];
59 } else {
60 text.push('\\');
61 }
62 } else {
63 text.push('\\');
64 }
65 }
66 Some('}') => {
67 if nested {
68 return Ok(source);
69 } else {
70 text.push('}');
71 source = &source[1..];
72 }
73 }
74 Some(_) => {
75 let chunk_end = source.find(['}', '$', '\\']).unwrap_or(source.len());
76 let (chunk, rest) = source.split_at(chunk_end);
77 text.push_str(chunk);
78 source = rest;
79 }
80 }
81 }
82}
83
84fn parse_tabstop<'a>(
85 mut source: &'a str,
86 text: &mut String,
87 tabstops: &mut BTreeMap<usize, TabStop>,
88) -> Result<&'a str> {
89 let tabstop_start = text.len();
90 let tabstop_index;
91 if source.starts_with('{') {
92 let (index, rest) = parse_int(&source[1..])?;
93 tabstop_index = index;
94 source = rest;
95
96 if source.starts_with(':') {
97 source = parse_snippet(&source[1..], true, text, tabstops)?;
98 }
99
100 if source.starts_with('}') {
101 source = &source[1..];
102 } else {
103 return Err(anyhow!("expected a closing brace"));
104 }
105 } else {
106 let (index, rest) = parse_int(source)?;
107 tabstop_index = index;
108 source = rest;
109 }
110
111 tabstops
112 .entry(tabstop_index)
113 .or_default()
114 .push(tabstop_start as isize..text.len() as isize);
115 Ok(source)
116}
117
118fn parse_int(source: &str) -> Result<(usize, &str)> {
119 let len = source
120 .find(|c: char| !c.is_ascii_digit())
121 .unwrap_or(source.len());
122 if len == 0 {
123 return Err(anyhow!("expected an integer"));
124 }
125 let (prefix, suffix) = source.split_at(len);
126 Ok((prefix.parse()?, suffix))
127}
128
129#[cfg(test)]
130mod tests {
131 use super::*;
132
133 #[test]
134 fn test_snippet_without_tabstops() {
135 let snippet = Snippet::parse("one-two-three").unwrap();
136 assert_eq!(snippet.text, "one-two-three");
137 assert_eq!(tabstops(&snippet), &[vec![13..13]]);
138 }
139
140 #[test]
141 fn test_snippet_with_tabstops() {
142 let snippet = Snippet::parse("one$1two").unwrap();
143 assert_eq!(snippet.text, "onetwo");
144 assert_eq!(tabstops(&snippet), &[vec![3..3], vec![6..6]]);
145
146 // Multi-digit numbers
147 let snippet = Snippet::parse("one$123-$99-two").unwrap();
148 assert_eq!(snippet.text, "one--two");
149 assert_eq!(tabstops(&snippet), &[vec![4..4], vec![3..3], vec![8..8]]);
150 }
151
152 #[test]
153 fn test_snippet_with_last_tabstop_at_end() {
154 let snippet = Snippet::parse(r#"foo.$1"#).unwrap();
155
156 // If the final tabstop is already at the end of the text, don't insert
157 // an additional tabstop at the end.
158 assert_eq!(snippet.text, r#"foo."#);
159 assert_eq!(tabstops(&snippet), &[vec![4..4]]);
160 }
161
162 #[test]
163 fn test_snippet_with_explicit_final_tabstop() {
164 let snippet = Snippet::parse(r#"<div class="$1">$0</div>"#).unwrap();
165
166 // If the final tabstop is explicitly specified via '$0', then
167 // don't insert an additional tabstop at the end.
168 assert_eq!(snippet.text, r#"<div class=""></div>"#);
169 assert_eq!(tabstops(&snippet), &[vec![12..12], vec![14..14]]);
170 }
171
172 #[test]
173 fn test_snippet_with_placeholders() {
174 let snippet = Snippet::parse("one${1:two}three${2:four}").unwrap();
175 assert_eq!(snippet.text, "onetwothreefour");
176 assert_eq!(
177 tabstops(&snippet),
178 &[vec![3..6], vec![11..15], vec![15..15]]
179 );
180 }
181
182 #[test]
183 fn test_snippet_with_nested_placeholders() {
184 let snippet = Snippet::parse(
185 "for (${1:var ${2:i} = 0; ${2:i} < ${3:${4:array}.length}; ${2:i}++}) {$0}",
186 )
187 .unwrap();
188 assert_eq!(snippet.text, "for (var i = 0; i < array.length; i++) {}");
189 assert_eq!(
190 tabstops(&snippet),
191 &[
192 vec![5..37],
193 vec![9..10, 16..17, 34..35],
194 vec![20..32],
195 vec![20..25],
196 vec![40..40],
197 ]
198 );
199 }
200
201 #[test]
202 fn test_snippet_parsing_with_escaped_chars() {
203 let snippet = Snippet::parse("\"\\$schema\": $1").unwrap();
204 assert_eq!(snippet.text, "\"$schema\": ");
205 assert_eq!(tabstops(&snippet), &[vec![11..11]]);
206
207 let snippet = Snippet::parse("{a\\}").unwrap();
208 assert_eq!(snippet.text, "{a}");
209 assert_eq!(tabstops(&snippet), &[vec![3..3]]);
210
211 // backslash not functioning as an escape
212 let snippet = Snippet::parse("a\\b").unwrap();
213 assert_eq!(snippet.text, "a\\b");
214 assert_eq!(tabstops(&snippet), &[vec![3..3]]);
215
216 // first backslash cancelling escaping that would
217 // have happened with second backslash
218 let snippet = Snippet::parse("one\\\\$1two").unwrap();
219 assert_eq!(snippet.text, "one\\two");
220 assert_eq!(tabstops(&snippet), &[vec![4..4], vec![7..7]]);
221 }
222
223 fn tabstops(snippet: &Snippet) -> Vec<Vec<Range<isize>>> {
224 snippet.tabstops.iter().map(|t| t.to_vec()).collect()
225 }
226}