marauders 0.0.13

A tool for hand-crafted mutation analysis and management
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub enum Language {
    Rocq,
    Haskell,
    Racket,
    Rust,
    OCaml,
    Python,
    #[serde(untagged)]
    Custom(CustomLanguage),
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct CustomLanguage {
    pub name: String,
    pub extension: String,
    pub comment_begin: String,
    pub comment_end: String,
    pub mutation_marker: String,
}

impl Language {
    pub fn file_extension(&self) -> &str {
        match self {
            Language::Rocq => "v",
            Language::Haskell => "hs",
            Language::Racket => "rkt",
            Language::Rust => "rs",
            Language::OCaml => "ml",
            Language::Python => "py",
            Language::Custom(custom) => custom.extension.as_str(),
        }
    }

    pub fn extension_to_language(
        ext: &str,
        custom_languages: &Vec<CustomLanguage>,
    ) -> Option<Language> {
        match ext {
            "v" => Some(Language::Rocq),
            "hs" => Some(Language::Haskell),
            "rkt" => Some(Language::Racket),
            "rs" => Some(Language::Rust),
            "ml" => Some(Language::OCaml),
            "py" => Some(Language::Python),
            _ => {
                for custom in custom_languages {
                    if custom.extension == ext {
                        return Some(Language::Custom(custom.clone()));
                    }
                }
                None
            }
        }
    }

    pub fn name_to_language(
        name: &str,
        custom_languages: &Vec<CustomLanguage>,
    ) -> Option<Language> {
        match name.to_lowercase().as_str() {
            "rocq" => Some(Language::Rocq),
            "haskell" => Some(Language::Haskell),
            "racket" => Some(Language::Racket),
            "rust" => Some(Language::Rust),
            "ocaml" => Some(Language::OCaml),
            "python" => Some(Language::Python),
            _ => {
                for custom in custom_languages {
                    if custom.name == name {
                        return Some(Language::Custom(custom.clone()));
                    }
                }
                log::warn!("unknown language: {}", name);
                None
            }
        }
    }

    pub fn comment_begin(&self) -> String {
        match self {
            Language::Rocq => "(*".to_string(),
            Language::Haskell => "{-".to_string(),
            Language::Racket => "#|".to_string(),
            Language::Rust => "/*".to_string(),
            Language::OCaml => "(*".to_string(),
            Language::Python => r#"""""#.to_string(),
            Language::Custom(custom) => custom.comment_begin.clone(),
        }
    }

    pub fn comment_end(&self) -> String {
        match self {
            Language::Rocq => "*)".to_string(),
            Language::Haskell => "-}".to_string(),
            Language::Racket => "|#".to_string(),
            Language::Rust => "*/".to_string(),
            Language::OCaml => "*)".to_string(),
            Language::Custom(custom) => custom.comment_end.clone(),
            Language::Python => r#"""""#.to_string(),
        }
    }

    pub fn variation_begin(&self, name: &str) -> String {
        format!(
            r"{}{} {}{}",
            self.comment_begin(),
            self.mutation_marker(),
            name,
            self.comment_end()
        )
    }

    pub fn variation_end(&self) -> String {
        format!(
            "{} {}{}",
            self.comment_begin(),
            self.mutation_marker(),
            self.comment_end()
        )
    }

    pub fn variant_header_begin(&self) -> String {
        format!(
            "{}{}{}",
            self.comment_begin(),
            self.mutation_marker(),
            self.mutation_marker()
        )
    }

    pub fn variant_header_end(&self) -> String {
        self.comment_end()
    }

    pub fn variant_body_begin(&self) -> String {
        format!("{}{}", self.comment_begin(), self.mutation_marker())
    }

    pub fn variant_body_end(&self) -> String {
        self.comment_end()
    }

    pub fn mutation_marker(&self) -> &str {
        match self {
            Language::Rocq
            | Language::Haskell
            | Language::Racket
            | Language::OCaml
            | Language::Python => "!",
            Language::Rust => "|",
            Language::Custom(custom_language) => custom_language.mutation_marker.as_str(),
        }
    }
}