pmat 3.30.1

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP)
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

//! TDD test for format_output refactor in symbol_table.rs
//! Autonomous all-night refactoring - complexity 31 → ≤8

use anyhow::Result;

// Mock types for testing
#[derive(Debug)]
struct SymbolTableAnalysis {
    #[allow(dead_code)] // Reserved for future symbol table implementation
    symbols: Vec<Symbol>,
    total_symbols: usize,
}

#[derive(Debug)]
struct Symbol {
    #[allow(dead_code)] // Reserved for future symbol table implementation
    name: String,
    #[allow(dead_code)] // Reserved for future symbol table implementation
    kind: String,
    #[allow(dead_code)] // Reserved for future symbol table implementation
    location: String,
}

#[derive(Debug)]
enum OutputFormat {
    Json,
    Human,
    Markdown,
}

// Mock function signature for testing
fn format_output_mock(analysis: &SymbolTableAnalysis, format: OutputFormat) -> Result<String> {
    match format {
        OutputFormat::Json => Ok(format!(
            r#"{{"total_symbols": {}}}"#,
            analysis.total_symbols
        )),
        OutputFormat::Human => Ok(format!("Total symbols: {}", analysis.total_symbols)),
        OutputFormat::Markdown => Ok(format!("# Symbol Table\nTotal: {}", analysis.total_symbols)),
    }
}

#[test]
fn test_format_output_json() -> Result<()> {
    let analysis = SymbolTableAnalysis {
        symbols: vec![],
        total_symbols: 42,
    };

    let output = format_output_mock(&analysis, OutputFormat::Json)?;
    assert!(output.contains("\"total_symbols\""));
    assert!(output.contains("42"));

    Ok(())
}

#[test]
fn test_format_output_human() -> Result<()> {
    let analysis = SymbolTableAnalysis {
        symbols: vec![],
        total_symbols: 10,
    };

    let output = format_output_mock(&analysis, OutputFormat::Human)?;
    assert!(output.contains("Total symbols"));
    assert!(output.contains("10"));

    Ok(())
}

#[test]
fn test_format_output_markdown() -> Result<()> {
    let analysis = SymbolTableAnalysis {
        symbols: vec![],
        total_symbols: 5,
    };

    let output = format_output_mock(&analysis, OutputFormat::Markdown)?;
    assert!(output.contains("# Symbol Table"));
    assert!(output.contains("5"));

    Ok(())
}