pretender 0.10.0

Multi-language structural code-quality checks — complexity, duplication, mutation testing, and CI integration
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

// Plugin infrastructure is not yet wired to production code; allow dead_code
// until the plugin loader is implemented.
#![allow(dead_code)]

use anyhow::{Context, Result};
use serde::Deserialize;
use std::collections::BTreeMap;

#[derive(Debug, Clone, Deserialize)]
pub struct PluginManifest {
    pub name: String,
    pub display_name: String,
    pub extensions: Vec<String>,
    #[serde(default)]
    pub shebangs: Vec<String>,
    pub tree_sitter: TreeSitterSource,
    pub query: String,
    #[serde(default)]
    pub branches: BTreeMap<String, BranchWeights>,
    #[serde(default)]
    pub assertions: Assertions,
    #[serde(default)]
    pub smell_weights: BTreeMap<String, f64>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct TreeSitterSource {
    pub source: String,
    pub rev: String,
}

#[derive(Debug, Clone, Copy, Deserialize)]
pub struct BranchWeights {
    #[serde(default = "default_weight")]
    pub cyclomatic: u32,
    #[serde(default = "default_weight")]
    pub cognitive: u32,
}

fn default_weight() -> u32 {
    1
}

#[derive(Debug, Clone, Default, Deserialize)]
pub struct Assertions {
    #[serde(default)]
    pub patterns: Vec<String>,
}

impl PluginManifest {
    pub fn from_toml(source: &str) -> Result<Self> {
        toml::from_str(source).context("failed to parse plugin manifest")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    const PYTHON_MANIFEST: &str = include_str!("../languages/python/plugin.toml");

    #[test]
    fn parses_python_manifest() {
        let manifest = PluginManifest::from_toml(PYTHON_MANIFEST).expect("parses");
        assert_eq!(manifest.name, "python");
        assert_eq!(manifest.display_name, "Python");
        assert_eq!(manifest.extensions, vec![".py"]);
        assert_eq!(manifest.query, "metrics.scm");
    }

    #[test]
    fn python_manifest_has_branch_weights() {
        let manifest = PluginManifest::from_toml(PYTHON_MANIFEST).unwrap();
        let if_weight = manifest
            .branches
            .get("@branch.if")
            .expect("@branch.if entry present");
        assert_eq!(if_weight.cyclomatic, 1);
        assert_eq!(if_weight.cognitive, 1);
    }

    #[test]
    fn python_manifest_has_assertion_patterns() {
        let manifest = PluginManifest::from_toml(PYTHON_MANIFEST).unwrap();
        assert!(!manifest.assertions.patterns.is_empty());
        assert!(manifest
            .assertions
            .patterns
            .iter()
            .any(|p| p.contains("pytest")));
    }

    #[test]
    fn rejects_invalid_toml() {
        let err = PluginManifest::from_toml("not = valid =").unwrap_err();
        assert!(err.to_string().contains("failed to parse plugin manifest"));
    }

    #[test]
    fn missing_required_field_errors() {
        let toml = r#"
name = "x"
display_name = "X"
extensions = [".x"]
"#;
        assert!(PluginManifest::from_toml(toml).is_err());
    }
}