rsread 0.1.4

Fast multi-language code reader: structure tree, syntax highlighting, duplicate detection and Git change markers for Python, Rust, Go and JavaScript
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

//! Language detection: by extension, by `-t` token, or by guessing from content.

use std::path::Path;

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Lang {
    Python,
    Rust,
    Go,
    JavaScript,
}

impl Lang {
    pub fn name(self) -> &'static str {
        match self {
            Lang::Python => "Python",
            Lang::Rust => "Rust",
            Lang::Go => "Go",
            Lang::JavaScript => "JavaScript",
        }
    }

    /// Token understood by syntect's `find_syntax_by_token`.
    pub fn syntax_token(self) -> &'static str {
        match self {
            Lang::Python => "py",
            Lang::Rust => "rs",
            Lang::Go => "go",
            Lang::JavaScript => "js",
        }
    }

    pub fn from_path(path: &Path) -> Option<Lang> {
        let ext = path.extension()?.to_str()?.to_ascii_lowercase();
        Lang::from_token(&ext)
    }

    pub fn from_token(token: &str) -> Option<Lang> {
        match token.trim().to_ascii_lowercase().as_str() {
            "py" | "pyw" | "pyi" | "python" | "python3" => Some(Lang::Python),
            "rs" | "rust" => Some(Lang::Rust),
            "go" | "golang" => Some(Lang::Go),
            "js" | "mjs" | "cjs" | "jsx" | "javascript" | "node" => Some(Lang::JavaScript),
            _ => None,
        }
    }

    /// Heuristic for clipboard / stdin content that has no file name.
    pub fn guess(text: &str) -> Option<Lang> {
        fn score(text: &str, needles: &[&str]) -> usize {
            needles.iter().filter(|n| text.contains(**n)).count()
        }
        let candidates = [
            (
                Lang::Rust,
                score(
                    text,
                    &[
                        "fn ",
                        "impl ",
                        "let mut ",
                        "pub fn",
                        "use std::",
                        "&self",
                        "#[derive",
                        "-> ",
                    ],
                ),
            ),
            (
                Lang::Go,
                score(
                    text,
                    &["package ", "func ", ":= ", "import (", "fmt.", "go func"],
                ),
            ),
            (
                Lang::Python,
                score(
                    text,
                    &[
                        "def ", "import ", "self", "elif ", "__init__", "print(", "class ", "):\n",
                        "None",
                    ],
                ),
            ),
            (
                Lang::JavaScript,
                score(
                    text,
                    &[
                        "function ",
                        "const ",
                        "=> ",
                        "console.log",
                        "require(",
                        "export ",
                        "let ",
                        "var ",
                    ],
                ),
            ),
        ];
        let (lang, best) = candidates
            .iter()
            .copied()
            .max_by_key(|(_, s)| *s)
            .filter(|(_, s)| *s >= 2)?;
        let _ = best;
        Some(lang)
    }
}