grepdef 3.5.0

Quick search for symbol definitions in various programming languages
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use grepdef::{Args, FileType, SearchResult, Searcher};

pub fn make_args(
    query: String,
    file_path: Option<String>,
    file_type_string: Option<String>,
) -> Args {
    Args {
        query,
        file_path: match file_path {
            Some(file_path) => Some(file_path.split_whitespace().map(String::from).collect()),
            None => None,
        },
        file_type: file_type_string,
        line_number: true,
        limit: None,
        search_method: None,
        debug: false,
        no_color: false,
        color: None,
        threads: None,
        format: None,
    }
}

pub fn do_search(args: Args) -> Vec<SearchResult> {
    let searcher = Searcher::new(args).unwrap();
    searcher.search().expect("Search failed for test")
}

pub fn do_search_callback(args: Args) -> Vec<SearchResult> {
    let searcher = Searcher::new(args).unwrap();
    let mut results = vec![];
    searcher
        .search_callback(|l| results.push(l))
        .expect("Search failed for test");
    results
}

pub fn do_search_format(args: Args) -> Vec<String> {
    let searcher = Searcher::new(args).unwrap();
    searcher
        .search_and_format()
        .expect("Search failed for test")
}

pub fn do_search_format_callback(args: Args) -> Vec<String> {
    let searcher = Searcher::new(args).unwrap();
    let mut results = vec![];
    searcher
        .search_and_format_callback(|l| results.push(l))
        .expect("Search failed for test");
    results
}

pub fn get_default_fixture_for_file_type_string(file_type_string: &str) -> Result<String, String> {
    match file_type_string {
        "js" => Ok(String::from("./tests/fixtures/by-language/js-fixture.js")),
        "ts" => Ok(String::from("./tests/fixtures/by-language/ts-fixture.ts")),
        "jsx" => Ok(String::from("./tests/fixtures/by-language/jsx-fixture.jsx")),
        "tsx" => Ok(String::from("./tests/fixtures/by-language/tsx-fixture.tsx")),
        "php" => Ok(String::from("./tests/fixtures/by-language/php-fixture.php")),
        "rs" => Ok(String::from("./tests/fixtures/by-language/rs-fixture.rs")),
        "py" => Ok(String::from("./tests/fixtures/by-language/py-fixture.py")),
        "rb" => Ok(String::from("./tests/fixtures/by-language/rb-fixture.rb")),
        _ => {
            let file_type = FileType::from_string(file_type_string);
            match file_type {
                Ok(file_type) => {
                    return get_default_fixture_for_file_type_string(file_type.to_string().as_str())
                }
                Err(_) => {
                    return Err(format!(
                        "No fixture found for file type '{}'",
                        file_type_string
                    ));
                }
            }
        }
    }
}

pub fn get_expected_text_line_for_test_search(
    file_type_string: &str,
) -> Result<(String, usize), String> {
    match file_type_string {
        "js" => Ok((String::from("function parseQuery() {"), 7)),
        "ts" => Ok((String::from("function parseQueryTS(): string {"), 7)),
        "jsx" => Ok((String::from("function parseQuery() {"), 7)),
        "tsx" => Ok((String::from("function parseQueryTS(): string {"), 7)),
        "php" => Ok((String::from("function parseQuery() {"), 6)),
        "rs" => Ok((String::from("pub fn query_db() -> bool {}"), 1)),
        "py" => Ok((String::from("def parse_query(query):"), 1)),
        "rb" => Ok((String::from("def parse_query(query)"), 1)),
        _ => {
            let file_type = FileType::from_string(file_type_string);
            match file_type {
                Ok(file_type) => {
                    return get_expected_text_line_for_test_search(file_type.to_string().as_str())
                }
                Err(_) => {
                    return Err(format!(
                        "No expected text found for file type '{}'",
                        file_type_string
                    ));
                }
            }
        }
    }
}

pub fn get_expected_search_result_for_file_type(file_type_string: &str) -> SearchResult {
    let (text, line_number) = get_expected_text_line_for_test_search(file_type_string).unwrap();
    SearchResult {
        event_type: grepdef::SearchEventType::NONE,
        file_path: get_default_fixture_for_file_type_string(file_type_string).unwrap(),
        line_number: Some(line_number),
        text,
    }
}