Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

16.0 KB
Raw Blame
use std::io::{self, BufReader, Cursor};

use collections::HashMap;
use fs::FakeFs;
use futures::FutureExt as _;
use language::Buffer;
use project::{
    Project,
    search::{MatchPositionHint, SearchQuery},
};
use serde_json::json;
use text::Rope;
use util::{
    path,
    paths::{PathMatcher, PathStyle},
    rel_path::RelPath,
};

use crate::init_test;

#[test]
fn path_matcher_creation_for_valid_paths() {
    for valid_path in [
        "file",
        "Cargo.toml",
        ".DS_Store",
        "~/dir/another_dir/",
        "./dir/file",
        "dir/[a-z].txt",
    ] {
        let path_matcher = PathMatcher::new(&[valid_path.to_owned()], PathStyle::local())
            .unwrap_or_else(|e| panic!("Valid path {valid_path} should be accepted, but got: {e}"));
        assert!(
            path_matcher.is_match(&RelPath::new(valid_path.as_ref(), PathStyle::local()).unwrap()),
            "Path matcher for valid path {valid_path} should match itself"
        )
    }
}

#[test]
fn path_matcher_creation_for_globs() {
    for invalid_glob in ["dir/[].txt", "dir/[a-z.txt", "dir/{file"] {
        match PathMatcher::new(&[invalid_glob.to_owned()], PathStyle::local()) {
            Ok(_) => panic!("Invalid glob {invalid_glob} should not be accepted"),
            Err(_expected) => {}
        }
    }

    for valid_glob in [
        "dir/?ile",
        "dir/*.txt",
        "dir/**/file",
        "dir/[a-z].txt",
        "{dir,file}",
    ] {
        match PathMatcher::new(&[valid_glob.to_owned()], PathStyle::local()) {
            Ok(_expected) => {}
            Err(e) => panic!("Valid glob should be accepted, but got: {e}"),
        }
    }
}

#[test]
fn test_case_sensitive_pattern_items() {
    let case_sensitive = false;
    let search_query = SearchQuery::regex(
        "test\\C",
        false,
        case_sensitive,
        false,
        false,
        Default::default(),
        Default::default(),
        false,
        None,
    )
    .expect("Should be able to create a regex SearchQuery");

    assert_eq!(
        search_query.case_sensitive(),
        true,
        "Case sensitivity should be enabled when \\C pattern item is present in the query."
    );

    let case_sensitive = true;
    let search_query = SearchQuery::regex(
        "test\\c",
        true,
        case_sensitive,
        false,
        false,
        Default::default(),
        Default::default(),
        false,
        None,
    )
    .expect("Should be able to create a regex SearchQuery");

    assert_eq!(
        search_query.case_sensitive(),
        false,
        "Case sensitivity should be disabled when \\c pattern item is present, even if initially set to true."
    );

    let case_sensitive = false;
    let search_query = SearchQuery::regex(
        "test\\c\\C",
        false,
        case_sensitive,
        false,
        false,
        Default::default(),
        Default::default(),
        false,
        None,
    )
    .expect("Should be able to create a regex SearchQuery");

    assert_eq!(
        search_query.case_sensitive(),
        true,
        "Case sensitivity should be enabled when \\C is the last pattern item, even after a \\c."
    );

    let case_sensitive = false;
    let search_query = SearchQuery::regex(
        "tests\\\\C",
        false,
        case_sensitive,
        false,
        false,
        Default::default(),
        Default::default(),
        false,
        None,
    )
    .expect("Should be able to create a regex SearchQuery");

    assert_eq!(
        search_query.case_sensitive(),
        false,
        "Case sensitivity should not be enabled when \\C pattern item is preceded by a backslash."
    );
}

#[gpui::test]
async fn test_multiline_regex_crlf(cx: &mut gpui::TestAppContext) {
    let search_query = SearchQuery::regex(
        "^hello$\r?\n",
        false,
        false,
        false,
        false,
        Default::default(),
        Default::default(),
        false,
        None,
    )
    .expect("Should be able to create a regex SearchQuery");

    let text = Rope::from("hello\r\nworld\r\nhello\r\nworld");
    let snapshot = cx
        .update(|app| Buffer::build_snapshot(text, None, None, None, app))
        .await;

    let results = search_query.search(&snapshot, None).await;
    assert_eq!(results, vec![0..7, 14..21]);
}

#[gpui::test]
async fn test_multiline_regex(cx: &mut gpui::TestAppContext) {
    let search_query = SearchQuery::regex(
        "^hello$\n",
        false,
        false,
        false,
        false,
        Default::default(),
        Default::default(),
        false,
        None,
    )
    .expect("Should be able to create a regex SearchQuery");

    let text = Rope::from("hello\nworld\nhello\nworld");
    let snapshot = cx
        .update(|app| Buffer::build_snapshot(text, None, None, None, app))
        .await;

    let results = search_query.search(&snapshot, None).await;
    assert_eq!(results, vec![0..6, 12..18]);
}

#[gpui::test]
async fn regex_with_eol_detects_lines() {
    let re = SearchQuery::regex(
        "Bool$",
        false,
        false,
        false,
        false,
        PathMatcher::default(),
        PathMatcher::default(),
        false,
        None,
    )
    .unwrap();
    let input = " Bool\nsomething else";
    let result = re
        .detect(&mut BufReader::new(input.as_bytes()))
        .await
        .unwrap();
    assert!(result.is_some());
}

#[gpui::test]
async fn multi_line_regex_detects_matches() {
    let re = SearchQuery::regex(
        "Bool$\nbool",
        false,
        false,
        false,
        false,
        PathMatcher::default(),
        PathMatcher::default(),
        false,
        None,
    )
    .unwrap();
    let input = " Bool\nbool";
    let result = re
        .detect(&mut BufReader::new(input.as_bytes()))
        .await
        .unwrap();
    assert!(result.is_some());
}

#[test]
fn detect_reports_line_across_block_boundaries() {
    let line_len = 1000;
    let filler = format!("{}\n", "x".repeat(line_len - 1));
    let mut text = filler.repeat(70);
    let needle_line = text.lines().count();
    text.push_str("prefix needle suffix\n");
    text.push_str(&filler.repeat(3));

    for (query, case_sensitive) in [("needle", true), ("NEEDLE", false), ("x\nx", true)] {
        let query = SearchQuery::text(
            query,
            false,
            case_sensitive,
            false,
            PathMatcher::default(),
            PathMatcher::default(),
            false,
            None,
        )
        .unwrap();
        let mut input = reader(text.as_bytes());
        assert!(query.detect(&mut input).now_or_never().is_none());
        assert_eq!(input.inner.position(), 64 * 1024);
        let hint = smol::block_on(query.detect(&mut reader(text.as_bytes()))).unwrap();
        let expected = if query.as_str().contains('\n') {
            MatchPositionHint::default()
        } else {
            MatchPositionHint::Line(needle_line as u32)
        };
        assert_eq!(hint, Some(expected), "{:?}", query.as_str());

        if !query.as_str().contains('\n') {
            let mut invalid = format!("needle{}", "x".repeat(128 * 1024)).into_bytes();
            invalid.push(0xff);
            let error = smol::block_on(query.detect(&mut reader(&invalid))).unwrap_err();
            assert_eq!(
                error.downcast_ref::<io::Error>().map(|error| error.kind()),
                Some(io::ErrorKind::InvalidData)
            );
        }
    }

    let query = SearchQuery::text(
        "absent",
        false,
        true,
        false,
        PathMatcher::default(),
        PathMatcher::default(),
        false,
        None,
    )
    .unwrap();
    assert_eq!(
        smol::block_on(query.detect(&mut reader(text.as_bytes()))).unwrap(),
        None
    );

    let mut invalid = text.into_bytes();
    invalid.extend_from_slice(b"\xff\xfe tail\n");
    let error = smol::block_on(query.detect(&mut reader(&invalid))).unwrap_err();
    assert_eq!(
        error.downcast_ref::<io::Error>().map(|error| error.kind()),
        Some(io::ErrorKind::InvalidData)
    );
}

#[test]
fn detect_handles_block_boundary_splits() {
    const BLOCK_BYTES: usize = 64 * 1024;
    let needle = "néédle";
    for split in 1..needle.len() {
        let mut text = "a".repeat(BLOCK_BYTES - split);
        text.push_str(needle);
        text.push_str("\ntail\n");
        for case_sensitive in [true, false] {
            let query = SearchQuery::text(
                needle,
                false,
                case_sensitive,
                false,
                PathMatcher::default(),
                PathMatcher::default(),
                false,
                None,
            )
            .unwrap();
            let expected = if query.is_regex() {
                MatchPositionHint::ByteOffset(BLOCK_BYTES - split)
            } else {
                MatchPositionHint::Line(0)
            };
            let mut input = reader(text.as_bytes());
            assert!(query.detect(&mut input).now_or_never().is_none());
            assert_eq!(input.inner.position(), BLOCK_BYTES as u64);
            assert_eq!(
                smol::block_on(query.detect(&mut reader(text.as_bytes()))).unwrap(),
                Some(expected),
                "split = {split}, case_sensitive = {case_sensitive}"
            );
        }
    }

    let needle = (0..9000)
        .map(|index| format!("{index:08x}"))
        .collect::<String>();
    let query = SearchQuery::text(
        &needle,
        false,
        true,
        false,
        PathMatcher::default(),
        PathMatcher::default(),
        false,
        None,
    )
    .unwrap();
    let text = format!("ignored\n{}x\n{needle}", &needle[..BLOCK_BYTES - 1]);
    for max_read in [257, BLOCK_BYTES] {
        let mut input = reader(text.as_bytes());
        input.max_read = max_read;
        assert!(query.detect(&mut input).now_or_never().is_none());
        assert_eq!(input.inner.position(), max_read as u64);
        let mut input = reader(text.as_bytes());
        input.max_read = max_read;
        assert_eq!(
            smol::block_on(query.detect(&mut input)).unwrap(),
            Some(MatchPositionHint::Line(2)),
        );
    }

    let query = SearchQuery::text(
        "absent",
        false,
        true,
        false,
        PathMatcher::default(),
        PathMatcher::default(),
        false,
        None,
    )
    .unwrap();
    let emoji = "\u{1f600}";
    for split in 1..emoji.len() {
        let mut text = "a".repeat(BLOCK_BYTES - split).into_bytes();
        text.extend_from_slice(emoji.as_bytes());
        text.extend_from_slice(b"\nline\n");
        assert_eq!(
            smol::block_on(query.detect(&mut reader(&text))).unwrap(),
            None,
            "split = {split}"
        );
        let mut matched_text = text.clone();
        matched_text[..query.as_str().len()].copy_from_slice(query.as_str().as_bytes());
        matched_text.push(0xff);
        assert_eq!(
            smol::block_on(query.detect(&mut reader(&matched_text))).unwrap(),
            Some(MatchPositionHint::Line(0)),
            "matched split = {split}"
        );
        text.truncate(BLOCK_BYTES - split + 2);
        let error = smol::block_on(query.detect(&mut reader(&text))).unwrap_err();
        assert_eq!(
            error.downcast_ref::<io::Error>().map(|error| error.kind()),
            Some(io::ErrorKind::InvalidData),
            "truncated split = {split}"
        );
    }
}

#[test]
fn detect_validates_matching_line_before_io_errors() {
    let query = SearchQuery::text(
        "n",
        false,
        true,
        false,
        PathMatcher::default(),
        PathMatcher::default(),
        false,
        None,
    )
    .unwrap();
    let found = Ok(Some(MatchPositionHint::Line(0)));
    let invalid = Err(io::ErrorKind::InvalidData);
    let failed = Err(io::ErrorKind::Other);
    for (bytes, at_eof, at_error) in [
        (b"".as_slice(), Ok(None), failed),
        (b"n", found, failed),
        (b"n\xff", invalid, failed),
        (b"\xff\nn", invalid, invalid),
        (b"n\xff\n", invalid, invalid),
        (b"n\n\xff", found, found),
        (b"n\xf0\x9f", invalid, failed),
        (b"n\n\xf0\x9f", found, found),
        (
            "x\n😀n".as_bytes(),
            Ok(Some(MatchPositionHint::Line(1))),
            failed,
        ),
    ] {
        for terminal_error in [None, Some(io::ErrorKind::Other)] {
            for max_read in [1, 64 * 1024] {
                let mut input = reader(bytes);
                input.max_read = max_read;
                input.terminal_error = terminal_error;
                let actual = smol::block_on(query.detect(&mut input))
                    .map_err(|error| error.downcast_ref::<io::Error>().unwrap().kind());
                let expected = if terminal_error.is_some() {
                    at_error
                } else {
                    at_eof
                };
                assert_eq!(
                    actual, expected,
                    "{bytes:?}, {terminal_error:?}, {max_read}"
                );
            }
        }
    }
}

#[gpui::test]
async fn searches_legacy_text_after_utf8_prefixes(cx: &mut gpui::TestAppContext) {
    init_test(cx);

    for (text, encoding, needle) in [
        (
            format!("é\n{} où voilà un garçon à la maison ", "x".repeat(1021)),
            encoding_rs::WINDOWS_1252,
            "é",
        ),
        (
            format!(
                "é\n©{}{}",
                "x".repeat(70000),
                " déjà été à côté français ".repeat(1000)
            ),
            encoding_rs::WINDOWS_1252,
            "©",
        ),
        (
            format!(
                "\x1b[0m{}{}©",
                "x".repeat(1024 * 1024),
                " déjà été à côté français ".repeat(1000)
            ),
            encoding_rs::WINDOWS_1252,
            "©",
        ),
        (
            format!(
                "я{}{}ЖЕТОН",
                "x".repeat(1024 * 1024),
                "Съешь же ещё этих мягких французских булок, да выпей чаю.\n".repeat(1000)
            ),
            encoding_rs::WINDOWS_1251,
            "ЖЕТОН",
        ),
    ] {
        let (bytes, _, had_errors) = encoding.encode(&text);
        assert!(!had_errors);
        let expected = text
            .match_indices(needle)
            .map(|(offset, matched)| offset..offset + matched.len())
            .collect::<Vec<_>>();
        let fs = FakeFs::new(cx.executor());
        fs.insert_tree(path!("/dir"), json!({})).await;
        fs.insert_file(path!("/dir/legacy.txt"), bytes.into_owned())
            .await;
        let project = Project::test(fs, [path!("/dir").as_ref()], cx).await;
        let query = SearchQuery::text(
            needle,
            false,
            true,
            false,
            PathMatcher::default(),
            PathMatcher::default(),
            false,
            None,
        )
        .unwrap();
        assert_eq!(
            super::search(&project, query, cx).await.unwrap(),
            HashMap::from_iter(
                (!expected.is_empty()).then(|| (path!("dir/legacy.txt").to_string(), expected))
            ),
        );
    }
}

fn reader(bytes: &[u8]) -> InterruptingReader {
    InterruptingReader {
        inner: Cursor::new(bytes.to_vec()),
        interrupt_next_read: false,
        max_read: usize::MAX,
        terminal_error: None,
    }
}

struct InterruptingReader {
    inner: Cursor<Vec<u8>>,
    interrupt_next_read: bool,
    max_read: usize,
    terminal_error: Option<io::ErrorKind>,
}

impl io::Read for InterruptingReader {
    fn read(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
        self.interrupt_next_read = !self.interrupt_next_read;
        if self.interrupt_next_read {
            Err(io::Error::from(io::ErrorKind::Interrupted))
        } else {
            let length = buffer.len().min(self.max_read);
            let read = self.inner.read(&mut buffer[..length])?;
            if read == 0
                && !buffer.is_empty()
                && let Some(error) = self.terminal_error
            {
                return Err(io::Error::from(error));
            }
            Ok(read)
        }
    }
}