tldr-core 0.1.4

Core analysis engine for TLDR code analysis tool
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

//! Soft delete pattern detection
//!
//! Detects fields and patterns related to soft delete:
//! - is_deleted boolean fields
//! - deleted_at timestamp fields
//! - ORM paranoid mode annotations
//! - Query filters on delete fields

use super::signals::PatternSignals;
use crate::types::SoftDeletePattern;

/// Convert signals to soft delete pattern
pub fn signals_to_pattern(
    signals: &PatternSignals,
    evidence_limit: usize,
) -> Option<SoftDeletePattern> {
    let soft_delete = &signals.soft_delete;

    if !soft_delete.has_signals() {
        return None;
    }

    let confidence = soft_delete.calculate_confidence();

    // Collect column names
    let mut column_names = Vec::new();
    if !soft_delete.is_deleted_fields.is_empty() {
        column_names.push("is_deleted".to_string());
    }
    if !soft_delete.deleted_at_fields.is_empty() {
        column_names.push("deleted_at".to_string());
    }

    // Collect evidence (limited)
    let mut evidence = Vec::new();
    evidence.extend(
        soft_delete
            .is_deleted_fields
            .iter()
            .take(evidence_limit)
            .cloned(),
    );
    evidence.extend(
        soft_delete
            .deleted_at_fields
            .iter()
            .take(evidence_limit)
            .cloned(),
    );
    evidence.extend(
        soft_delete
            .delete_query_filters
            .iter()
            .take(evidence_limit)
            .cloned(),
    );
    evidence.extend(
        soft_delete
            .paranoid_annotations
            .iter()
            .take(evidence_limit)
            .cloned(),
    );
    evidence.truncate(evidence_limit);

    Some(SoftDeletePattern {
        detected: true,
        confidence,
        column_names,
        evidence,
    })
}

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

    #[test]
    fn test_no_signals_returns_none() {
        let signals = PatternSignals::default();
        assert!(signals_to_pattern(&signals, 3).is_none());
    }

    #[test]
    fn test_is_deleted_field_detected() {
        let mut signals = PatternSignals::default();
        signals.soft_delete.is_deleted_fields.push(Evidence::new(
            "models/user.py",
            15,
            "is_deleted = Column(Boolean)",
        ));

        let pattern = signals_to_pattern(&signals, 3).unwrap();
        assert!(pattern.detected);
        assert!(pattern.confidence >= 0.4);
        assert!(pattern.column_names.contains(&"is_deleted".to_string()));
    }

    #[test]
    fn test_both_fields_high_confidence() {
        let mut signals = PatternSignals::default();
        signals.soft_delete.is_deleted_fields.push(Evidence::new(
            "models/user.py",
            15,
            "is_deleted = Column(Boolean)",
        ));
        signals.soft_delete.deleted_at_fields.push(Evidence::new(
            "models/user.py",
            16,
            "deleted_at = Column(DateTime)",
        ));

        let pattern = signals_to_pattern(&signals, 3).unwrap();
        assert!(pattern.confidence >= 0.8);
        assert!(pattern.column_names.contains(&"is_deleted".to_string()));
        assert!(pattern.column_names.contains(&"deleted_at".to_string()));
    }
}