rustfmt_nightly/
string.rs

Help
1// Format string literals.
2
3use regex::Regex;
4use unicode_properties::{GeneralCategory, UnicodeGeneralCategory};
5use unicode_segmentation::UnicodeSegmentation;
6
7use crate::config::Config;
8use crate::shape::Shape;
9use crate::utils::{unicode_str_width, wrap_str};
10
11const MIN_STRING: usize = 10;
12
13/// Describes the layout of a piece of text.
14pub(crate) struct StringFormat<'a> {
15    /// The opening sequence of characters for the piece of text
16    pub(crate) opener: &'a str,
17    /// The closing sequence of characters for the piece of text
18    pub(crate) closer: &'a str,
19    /// The opening sequence of characters for a line
20    pub(crate) line_start: &'a str,
21    /// The closing sequence of characters for a line
22    pub(crate) line_end: &'a str,
23    /// The allocated box to fit the text into
24    pub(crate) shape: Shape,
25    /// Trim trailing whitespaces
26    pub(crate) trim_end: bool,
27    pub(crate) config: &'a Config,
28}
29
30impl<'a> StringFormat<'a> {
31    pub(crate) fn new(shape: Shape, config: &'a Config) -> StringFormat<'a> {
32        StringFormat {
33            opener: "\"",
34            closer: "\"",
35            line_start: " ",
36            line_end: "\\",
37            shape,
38            trim_end: false,
39            config,
40        }
41    }
42
43    /// Returns the maximum number of graphemes that is possible on a line while taking the
44    /// indentation into account.
45    ///
46    /// If we cannot put at least a single character per line, the rewrite won't succeed.
47    fn max_width_with_indent(&self) -> Option<usize> {
48        Some(
49            self.shape
50                .width
51                .checked_sub(self.opener.len() + self.line_end.len() + 1)?
52                + 1,
53        )
54    }
55
56    /// Like max_width_with_indent but the indentation is not subtracted.
57    /// This allows to fit more graphemes from the string on a line when
58    /// SnippetState::EndWithLineFeed.
59    fn max_width_without_indent(&self) -> Option<usize> {
60        self.config.max_width().checked_sub(self.line_end.len())
61    }
62}
63
64pub(crate) fn rewrite_string<'a>(
65    orig: &str,
66    fmt: &StringFormat<'a>,
67    newline_max_chars: usize,
68) -> Option<String> {
69    let max_width_with_indent = fmt.max_width_with_indent()?;
70    let max_width_without_indent = fmt.max_width_without_indent()?;
71    let indent_with_newline = fmt.shape.indent.to_string_with_newline(fmt.config);
72    let indent_without_newline = fmt.shape.indent.to_string(fmt.config);
73
74    // Strip line breaks.
75    // With this regex applied, all remaining whitespaces are significant
76    let strip_line_breaks_re = Regex::new(r"([^\\](\\\\)*)\\[\n\r][[:space:]]*").unwrap();
77    let stripped_str = strip_line_breaks_re.replace_all(orig, "$1");
78
79    let graphemes = UnicodeSegmentation::graphemes(&*stripped_str, false).collect::<Vec<&str>>();
80
81    // `cur_start` is the position in `orig` of the start of the current line.
82    let mut cur_start = 0;
83    let mut result = String::with_capacity(
84        stripped_str
85            .len()
86            .checked_next_power_of_two()
87            .unwrap_or(usize::MAX),
88    );
89    result.push_str(fmt.opener);
90
91    // Snip a line at a time from `stripped_str` until it is used up. Push the snippet
92    // onto result.
93    let mut cur_max_width = max_width_with_indent;
94    let is_bareline_ok = fmt.line_start.is_empty() || is_whitespace(fmt.line_start);
95    loop {
96        // All the input starting at cur_start fits on the current line
97        if graphemes_width(&graphemes[cur_start..]) <= cur_max_width {
98            for (i, grapheme) in graphemes[cur_start..].iter().enumerate() {
99                if is_new_line(grapheme) {
100                    // take care of blank lines
101                    result = trim_end_but_line_feed(fmt.trim_end, result);
102                    result.push('\n');
103                    if !is_bareline_ok && cur_start + i + 1 < graphemes.len() {
104                        result.push_str(&indent_without_newline);
105                        result.push_str(fmt.line_start);
106                    }
107                } else {
108                    result.push_str(grapheme);
109                }
110            }
111            result = trim_end_but_line_feed(fmt.trim_end, result);
112            break;
113        }
114
115        // The input starting at cur_start needs to be broken
116        match break_string(
117            cur_max_width,
118            fmt.trim_end,
119            fmt.line_end,
120            &graphemes[cur_start..],
121        ) {
122            SnippetState::LineEnd(line, len) => {
123                result.push_str(&line);
124                result.push_str(fmt.line_end);
125                result.push_str(&indent_with_newline);
126                result.push_str(fmt.line_start);
127                cur_max_width = newline_max_chars;
128                cur_start += len;
129            }
130            SnippetState::EndWithLineFeed(line, len) => {
131                if line == "\n" && fmt.trim_end {
132                    result = result.trim_end().to_string();
133                }
134                result.push_str(&line);
135                if is_bareline_ok {
136                    // the next line can benefit from the full width
137                    cur_max_width = max_width_without_indent;
138                } else {
139                    result.push_str(&indent_without_newline);
140                    result.push_str(fmt.line_start);
141                    cur_max_width = max_width_with_indent;
142                }
143                cur_start += len;
144            }
145            SnippetState::EndOfInput(line) => {
146                result.push_str(&line);
147                break;
148            }
149        }
150    }
151
152    result.push_str(fmt.closer);
153    wrap_str(result, fmt.config.max_width(), fmt.shape)
154}
155
156/// Returns the index to the end of the URL if the split at index of the given string includes a
157/// URL or alike. Otherwise, returns `None`.
158fn detect_url(s: &[&str], index: usize) -> Option<usize> {
159    let start = match s[..=index].iter().rposition(|g| is_whitespace(g)) {
160        Some(pos) => pos + 1,
161        None => 0,
162    };
163    // 8 = minimum length for a string to contain a URL
164    if s.len() < start + 8 {
165        return None;
166    }
167    let split = s[start..].concat();
168    if split.contains("https://")
169        || split.contains("http://")
170        || split.contains("ftp://")
171        || split.contains("file://")
172    {
173        match s[index..].iter().position(|g| is_whitespace(g)) {
174            Some(pos) => Some(index + pos - 1),
175            None => Some(s.len() - 1),
176        }
177    } else {
178        None
179    }
180}
181
182/// Trims whitespaces to the right except for the line feed character.
183fn trim_end_but_line_feed(trim_end: bool, result: String) -> String {
184    let whitespace_except_line_feed = |c: char| c.is_whitespace() && c != '\n';
185    if trim_end && result.ends_with(whitespace_except_line_feed) {
186        result
187            .trim_end_matches(whitespace_except_line_feed)
188            .to_string()
189    } else {
190        result
191    }
192}
193
194/// Result of breaking a string so it fits in a line and the state it ended in.
195/// The state informs about what to do with the snippet and how to continue the breaking process.
196#[derive(Debug, PartialEq)]
197enum SnippetState {
198    /// The input could not be broken and so rewriting the string is finished.
199    EndOfInput(String),
200    /// The input could be broken and the returned snippet should be ended with a
201    /// `[StringFormat::line_end]`. The next snippet needs to be indented.
202    ///
203    /// The returned string is the line to print out and the number is the length that got read in
204    /// the text being rewritten. That length may be greater than the returned string if trailing
205    /// whitespaces got trimmed.
206    LineEnd(String, usize),
207    /// The input could be broken but a newline is present that cannot be trimmed. The next snippet
208    /// to be rewritten *could* use more width than what is specified by the given shape. For
209    /// example with a multiline string, the next snippet does not need to be indented, allowing
210    /// more characters to be fit within a line.
211    ///
212    /// The returned string is the line to print out and the number is the length that got read in
213    /// the text being rewritten.
214    EndWithLineFeed(String, usize),
215}
216
217fn not_whitespace_except_line_feed(g: &str) -> bool {
218    is_new_line(g) || !is_whitespace(g)
219}
220
221/// Break the input string at a boundary character around the offset `max_width`. A boundary
222/// character is either a punctuation or a whitespace.
223/// FIXME(issue#3281): We must follow UAX#14 algorithm instead of this.
224fn break_string(max_width: usize, trim_end: bool, line_end: &str, input: &[&str]) -> SnippetState {
225    let break_at = |index /* grapheme at index is included */| {
226        // Take in any whitespaces to the left/right of `input[index]` while
227        // preserving line feeds
228        let index_minus_ws = input[0..=index]
229            .iter()
230            .rposition(|grapheme| not_whitespace_except_line_feed(grapheme))
231            .unwrap_or(index);
232        // Take into account newlines occurring in input[0..=index], i.e., the possible next new
233        // line. If there is one, then text after it could be rewritten in a way that the available
234        // space is fully used.
235        for (i, grapheme) in input[0..=index].iter().enumerate() {
236            if is_new_line(grapheme) {
237                if i <= index_minus_ws {
238                    let mut line = &input[0..i].concat()[..];
239                    if trim_end {
240                        line = line.trim_end();
241                    }
242                    return SnippetState::EndWithLineFeed(format!("{}\n", line), i + 1);
243                }
244                break;
245            }
246        }
247
248        let mut index_plus_ws = index;
249        for (i, grapheme) in input[index + 1..].iter().enumerate() {
250            if !trim_end && is_new_line(grapheme) {
251                return SnippetState::EndWithLineFeed(
252                    input[0..=index + 1 + i].concat(),
253                    index + 2 + i,
254                );
255            } else if not_whitespace_except_line_feed(grapheme) {
256                index_plus_ws = index + i;
257                break;
258            }
259        }
260
261        if trim_end {
262            SnippetState::LineEnd(input[0..=index_minus_ws].concat(), index_plus_ws + 1)
263        } else {
264            SnippetState::LineEnd(input[0..=index_plus_ws].concat(), index_plus_ws + 1)
265        }
266    };
267
268    // find a first index where the unicode width of input[0..x] become > max_width
269    let max_width_index_in_input = {
270        let mut cur_width = 0;
271        let mut cur_index = 0;
272        for (i, grapheme) in input.iter().enumerate() {
273            cur_width += unicode_str_width(grapheme);
274            cur_index = i;
275            if cur_width > max_width {
276                break;
277            }
278        }
279        cur_index
280    };
281    if max_width_index_in_input == 0 {
282        return SnippetState::EndOfInput(input.concat());
283    }
284
285    // Find the position in input for breaking the string
286    if line_end.is_empty()
287        && trim_end
288        && !is_whitespace(input[max_width_index_in_input - 1])
289        && is_whitespace(input[max_width_index_in_input])
290    {
291        // At a breaking point already
292        // The line won't invalidate the rewriting because:
293        // - no extra space needed for the line_end character
294        // - extra whitespaces to the right can be trimmed
295        return break_at(max_width_index_in_input - 1);
296    }
297    if let Some(url_index_end) = detect_url(input, max_width_index_in_input) {
298        let index_plus_ws = url_index_end
299            + input[url_index_end..]
300                .iter()
301                .skip(1)
302                .position(|grapheme| not_whitespace_except_line_feed(grapheme))
303                .unwrap_or(0);
304        return if trim_end {
305            SnippetState::LineEnd(input[..=url_index_end].concat(), index_plus_ws + 1)
306        } else {
307            SnippetState::LineEnd(input[..=index_plus_ws].concat(), index_plus_ws + 1)
308        };
309    }
310
311    match input[0..max_width_index_in_input]
312        .iter()
313        .rposition(|grapheme| is_whitespace(grapheme))
314    {
315        // Found a whitespace and what is on its left side is big enough.
316        Some(index) if index >= MIN_STRING => break_at(index),
317        // No whitespace found, try looking for a punctuation instead
318        _ => match (0..max_width_index_in_input)
319            .rev()
320            .skip_while(|pos| !is_valid_linebreak(input, *pos))
321            .next()
322        {
323            // Found a punctuation and what is on its left side is big enough.
324            Some(index) if index >= MIN_STRING => break_at(index),
325            // Either no boundary character was found to the left of `input[max_chars]`, or the line
326            // got too small. We try searching for a boundary character to the right.
327            _ => match (max_width_index_in_input..input.len())
328                .skip_while(|pos| !is_valid_linebreak(input, *pos))
329                .next()
330            {
331                // A boundary was found after the line limit
332                Some(index) => break_at(index),
333                // No boundary to the right, the input cannot be broken
334                None => SnippetState::EndOfInput(input.concat()),
335            },
336        },
337    }
338}
339
340fn is_valid_linebreak(input: &[&str], pos: usize) -> bool {
341    let is_whitespace = is_whitespace(input[pos]);
342    if is_whitespace {
343        return true;
344    }
345    let is_punctuation = is_punctuation(input[pos]);
346    if is_punctuation && !is_part_of_type(input, pos) {
347        return true;
348    }
349    false
350}
351
352fn is_part_of_type(input: &[&str], pos: usize) -> bool {
353    input.get(pos..=pos + 1) == Some(&[":", ":"])
354        || input.get(pos.saturating_sub(1)..=pos) == Some(&[":", ":"])
355}
356
357fn is_new_line(grapheme: &str) -> bool {
358    let bytes = grapheme.as_bytes();
359    bytes.starts_with(b"\n") || bytes.starts_with(b"\r\n")
360}
361
362fn is_whitespace(grapheme: &str) -> bool {
363    grapheme.chars().all(char::is_whitespace)
364}
365
366fn is_punctuation(grapheme: &str) -> bool {
367    grapheme
368        .chars()
369        .all(|c| c.general_category() == GeneralCategory::OtherPunctuation)
370}
371
372fn graphemes_width(graphemes: &[&str]) -> usize {
373    graphemes.iter().map(|s| unicode_str_width(s)).sum()
374}
375
376#[cfg(test)]
377mod test {
378    use super::{SnippetState, StringFormat, break_string, detect_url, rewrite_string};
379    use crate::config::Config;
380    use crate::shape::{Indent, Shape};
381    use unicode_segmentation::UnicodeSegmentation;
382
383    #[test]
384    fn issue343() {
385        let config = Default::default();
386        let fmt = StringFormat::new(Shape::legacy(2, Indent::empty()), &config);
387        rewrite_string("eq_", &fmt, 2);
388    }
389
390    #[test]
391    fn line_break_at_valid_points_test() {
392        let string = "[TheName](Dont::break::my::type::That::would::be::very::nice) break here";
393        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
394        assert_eq!(
395            break_string(20, false, "", &graphemes[..]),
396            SnippetState::LineEnd(
397                "[TheName](Dont::break::my::type::That::would::be::very::nice) ".to_string(),
398                62
399            )
400        );
401    }
402
403    #[test]
404    fn should_break_on_whitespace() {
405        let string = "Placerat felis. Mauris porta ante sagittis purus.";
406        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
407        assert_eq!(
408            break_string(20, false, "", &graphemes[..]),
409            SnippetState::LineEnd("Placerat felis. ".to_string(), 16)
410        );
411        assert_eq!(
412            break_string(20, true, "", &graphemes[..]),
413            SnippetState::LineEnd("Placerat felis.".to_string(), 16)
414        );
415    }
416
417    #[test]
418    fn should_break_on_punctuation() {
419        let string = "Placerat_felis._Mauris_porta_ante_sagittis_purus.";
420        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
421        assert_eq!(
422            break_string(20, false, "", &graphemes[..]),
423            SnippetState::LineEnd("Placerat_felis.".to_string(), 15)
424        );
425    }
426
427    #[test]
428    fn should_break_forward() {
429        let string = "Venenatis_tellus_vel_tellus. Aliquam aliquam dolor at justo.";
430        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
431        assert_eq!(
432            break_string(20, false, "", &graphemes[..]),
433            SnippetState::LineEnd("Venenatis_tellus_vel_tellus. ".to_string(), 29)
434        );
435        assert_eq!(
436            break_string(20, true, "", &graphemes[..]),
437            SnippetState::LineEnd("Venenatis_tellus_vel_tellus.".to_string(), 29)
438        );
439    }
440
441    #[test]
442    fn nothing_to_break() {
443        let string = "Venenatis_tellus_vel_tellus";
444        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
445        assert_eq!(
446            break_string(20, false, "", &graphemes[..]),
447            SnippetState::EndOfInput("Venenatis_tellus_vel_tellus".to_string())
448        );
449    }
450
451    #[test]
452    fn significant_whitespaces() {
453        let string = "Neque in sem.      \n      Pellentesque tellus augue.";
454        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
455        assert_eq!(
456            break_string(15, false, "", &graphemes[..]),
457            SnippetState::EndWithLineFeed("Neque in sem.      \n".to_string(), 20)
458        );
459        assert_eq!(
460            break_string(25, false, "", &graphemes[..]),
461            SnippetState::EndWithLineFeed("Neque in sem.      \n".to_string(), 20)
462        );
463
464        assert_eq!(
465            break_string(15, true, "", &graphemes[..]),
466            SnippetState::LineEnd("Neque in sem.".to_string(), 19)
467        );
468        assert_eq!(
469            break_string(25, true, "", &graphemes[..]),
470            SnippetState::EndWithLineFeed("Neque in sem.\n".to_string(), 20)
471        );
472    }
473
474    #[test]
475    fn big_whitespace() {
476        let string = "Neque in sem.            Pellentesque tellus augue.";
477        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
478        assert_eq!(
479            break_string(20, false, "", &graphemes[..]),
480            SnippetState::LineEnd("Neque in sem.            ".to_string(), 25)
481        );
482        assert_eq!(
483            break_string(20, true, "", &graphemes[..]),
484            SnippetState::LineEnd("Neque in sem.".to_string(), 25)
485        );
486    }
487
488    #[test]
489    fn newline_in_candidate_line() {
490        let string = "Nulla\nconsequat erat at massa. Vivamus id mi.";
491
492        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
493        assert_eq!(
494            break_string(25, false, "", &graphemes[..]),
495            SnippetState::EndWithLineFeed("Nulla\n".to_string(), 6)
496        );
497        assert_eq!(
498            break_string(25, true, "", &graphemes[..]),
499            SnippetState::EndWithLineFeed("Nulla\n".to_string(), 6)
500        );
501
502        let mut config: Config = Default::default();
503        config.set().max_width(27);
504        let fmt = StringFormat::new(Shape::legacy(25, Indent::empty()), &config);
505        let rewritten_string = rewrite_string(string, &fmt, 27);
506        assert_eq!(
507            rewritten_string,
508            Some("\"Nulla\nconsequat erat at massa. \\\n Vivamus id mi.\"".to_string())
509        );
510    }
511
512    #[test]
513    fn last_line_fit_with_trailing_whitespaces() {
514        let string = "Vivamus id mi.  ";
515        let config: Config = Default::default();
516        let mut fmt = StringFormat::new(Shape::legacy(25, Indent::empty()), &config);
517
518        fmt.trim_end = true;
519        let rewritten_string = rewrite_string(string, &fmt, 25);
520        assert_eq!(rewritten_string, Some("\"Vivamus id mi.\"".to_string()));
521
522        fmt.trim_end = false; // default value of trim_end
523        let rewritten_string = rewrite_string(string, &fmt, 25);
524        assert_eq!(rewritten_string, Some("\"Vivamus id mi.  \"".to_string()));
525    }
526
527    #[test]
528    fn last_line_fit_with_newline() {
529        let string = "Vivamus id mi.\nVivamus id mi.";
530        let config: Config = Default::default();
531        let fmt = StringFormat {
532            opener: "",
533            closer: "",
534            line_start: "// ",
535            line_end: "",
536            shape: Shape::legacy(100, Indent::from_width(&config, 4)),
537            trim_end: true,
538            config: &config,
539        };
540
541        let rewritten_string = rewrite_string(string, &fmt, 100);
542        assert_eq!(
543            rewritten_string,
544            Some("Vivamus id mi.\n    // Vivamus id mi.".to_string())
545        );
546    }
547
548    #[test]
549    fn overflow_in_non_string_content() {
550        let comment = "Aenean metus.\nVestibulum ac lacus. Vivamus porttitor";
551        let config: Config = Default::default();
552        let fmt = StringFormat {
553            opener: "",
554            closer: "",
555            line_start: "// ",
556            line_end: "",
557            shape: Shape::legacy(30, Indent::from_width(&config, 8)),
558            trim_end: true,
559            config: &config,
560        };
561
562        assert_eq!(
563            rewrite_string(comment, &fmt, 30),
564            Some(
565                "Aenean metus.\n        // Vestibulum ac lacus. Vivamus\n        // porttitor"
566                    .to_string()
567            )
568        );
569    }
570
571    #[test]
572    fn overflow_in_non_string_content_with_line_end() {
573        let comment = "Aenean metus.\nVestibulum ac lacus. Vivamus porttitor";
574        let config: Config = Default::default();
575        let fmt = StringFormat {
576            opener: "",
577            closer: "",
578            line_start: "// ",
579            line_end: "@",
580            shape: Shape::legacy(30, Indent::from_width(&config, 8)),
581            trim_end: true,
582            config: &config,
583        };
584
585        assert_eq!(
586            rewrite_string(comment, &fmt, 30),
587            Some(
588                "Aenean metus.\n        // Vestibulum ac lacus. Vivamus@\n        // porttitor"
589                    .to_string()
590            )
591        );
592    }
593
594    #[test]
595    fn blank_line_with_non_empty_line_start() {
596        let config: Config = Default::default();
597        let mut fmt = StringFormat {
598            opener: "",
599            closer: "",
600            line_start: "// ",
601            line_end: "",
602            shape: Shape::legacy(30, Indent::from_width(&config, 4)),
603            trim_end: true,
604            config: &config,
605        };
606
607        let comment = "Aenean metus. Vestibulum\n\nac lacus. Vivamus porttitor";
608        assert_eq!(
609            rewrite_string(comment, &fmt, 30),
610            Some(
611                "Aenean metus. Vestibulum\n    //\n    // ac lacus. Vivamus porttitor".to_string()
612            )
613        );
614
615        fmt.shape = Shape::legacy(15, Indent::from_width(&config, 4));
616        let comment = "Aenean\n\nmetus. Vestibulum ac lacus. Vivamus porttitor";
617        assert_eq!(
618            rewrite_string(comment, &fmt, 15),
619            Some(
620                r#"Aenean
621    //
622    // metus. Vestibulum
623    // ac lacus. Vivamus
624    // porttitor"#
625                    .to_string()
626            )
627        );
628    }
629
630    #[test]
631    fn retain_blank_lines() {
632        let config: Config = Default::default();
633        let fmt = StringFormat {
634            opener: "",
635            closer: "",
636            line_start: "// ",
637            line_end: "",
638            shape: Shape::legacy(20, Indent::from_width(&config, 4)),
639            trim_end: true,
640            config: &config,
641        };
642
643        let comment = "Aenean\n\nmetus. Vestibulum ac lacus.\n\n";
644        assert_eq!(
645            rewrite_string(comment, &fmt, 20),
646            Some(
647                "Aenean\n    //\n    // metus. Vestibulum ac\n    // lacus.\n    //\n".to_string()
648            )
649        );
650
651        let comment = "Aenean\n\nmetus. Vestibulum ac lacus.\n";
652        assert_eq!(
653            rewrite_string(comment, &fmt, 20),
654            Some("Aenean\n    //\n    // metus. Vestibulum ac\n    // lacus.\n".to_string())
655        );
656
657        let comment = "Aenean\n        \nmetus. Vestibulum ac lacus.";
658        assert_eq!(
659            rewrite_string(comment, &fmt, 20),
660            Some("Aenean\n    //\n    // metus. Vestibulum ac\n    // lacus.".to_string())
661        );
662    }
663
664    #[test]
665    fn boundary_on_edge() {
666        let config: Config = Default::default();
667        let mut fmt = StringFormat {
668            opener: "",
669            closer: "",
670            line_start: "// ",
671            line_end: "",
672            shape: Shape::legacy(13, Indent::from_width(&config, 4)),
673            trim_end: true,
674            config: &config,
675        };
676
677        let comment = "Aenean metus. Vestibulum ac lacus.";
678        assert_eq!(
679            rewrite_string(comment, &fmt, 13),
680            Some("Aenean metus.\n    // Vestibulum ac\n    // lacus.".to_string())
681        );
682
683        fmt.trim_end = false;
684        let comment = "Vestibulum ac lacus.";
685        assert_eq!(
686            rewrite_string(comment, &fmt, 13),
687            Some("Vestibulum \n    // ac lacus.".to_string())
688        );
689
690        fmt.trim_end = true;
691        fmt.line_end = "\\";
692        let comment = "Vestibulum ac lacus.";
693        assert_eq!(
694            rewrite_string(comment, &fmt, 13),
695            Some("Vestibulum\\\n    // ac lacus.".to_string())
696        );
697    }
698
699    #[test]
700    fn detect_urls() {
701        let string = "aaa http://example.org something";
702        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
703        assert_eq!(detect_url(&graphemes, 8), Some(21));
704
705        let string = "https://example.org something";
706        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
707        assert_eq!(detect_url(&graphemes, 0), Some(18));
708
709        let string = "aaa ftp://example.org something";
710        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
711        assert_eq!(detect_url(&graphemes, 8), Some(20));
712
713        let string = "aaa file://example.org something";
714        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
715        assert_eq!(detect_url(&graphemes, 8), Some(21));
716
717        let string = "aaa http not an url";
718        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
719        assert_eq!(detect_url(&graphemes, 6), None);
720
721        let string = "aaa file://example.org";
722        let graphemes = UnicodeSegmentation::graphemes(&*string, false).collect::<Vec<&str>>();
723        assert_eq!(detect_url(&graphemes, 8), Some(21));
724    }
725}
rustfmt_nightly/string.rs

rustfmt_nightly/
string.rs
