neti 1.6.6

High-integrity code quality governance and transactional change management for AI-assisted development
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

use serde::Serialize;
use std::collections::{HashMap, HashSet};

/// Represents a cohesion and coupling scope (Class, Struct+Impl, Enum).
#[derive(Debug, Clone, Serialize)]
pub struct Scope {
    name: String,
    row: usize,
    is_enum: bool,
    fields: HashMap<String, FieldInfo>,
    methods: HashMap<String, Method>,
    derives: HashSet<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct FieldInfo {
    pub name: String,
    pub is_public: bool,
}

impl FieldInfo {
    #[must_use]
    pub fn new(name: &str, is_public: bool) -> Self {
        Self {
            name: name.to_string(),
            is_public,
        }
    }
}

/// Represents a method within a scope.
#[derive(Debug, Clone, Serialize)]
pub struct Method {
    pub name: String,
    /// Fields accessed by this method
    pub field_access: HashSet<String>,
    /// Other methods in the same scope called by this method (Cohesion)
    pub internal_calls: HashSet<String>,
    /// Calls to things outside this scope (Coupling/SFOUT)
    pub external_calls: HashSet<String>,
    /// Human-understandability score
    pub cognitive_complexity: usize,
    /// Does the method mutate state? (&mut self)
    pub is_mutable: bool,
}

impl Method {
    #[must_use]
    pub fn new(name: &str, complexity: usize, is_mutable: bool) -> Self {
        Self {
            name: name.to_string(),
            field_access: HashSet::new(),
            internal_calls: HashSet::new(),
            external_calls: HashSet::new(),
            cognitive_complexity: complexity,
            is_mutable,
        }
    }
}

impl Scope {
    #[must_use]
    pub fn new(name: &str, row: usize) -> Self {
        Self {
            name: name.to_string(),
            row,
            is_enum: false,
            fields: HashMap::new(),
            methods: HashMap::new(),
            derives: HashSet::new(),
        }
    }

    #[must_use]
    pub fn new_enum(name: &str, row: usize) -> Self {
        Self {
            name: name.to_string(),
            row,
            is_enum: true,
            fields: HashMap::new(),
            methods: HashMap::new(),
            derives: HashSet::new(),
        }
    }

    #[must_use]
    pub fn name(&self) -> &str {
        &self.name
    }
    #[must_use]
    pub fn row(&self) -> usize {
        self.row
    }
    #[must_use]
    pub fn is_enum(&self) -> bool {
        self.is_enum
    }
    #[must_use]
    pub fn fields(&self) -> &HashMap<String, FieldInfo> {
        &self.fields
    }
    #[must_use]
    pub fn methods(&self) -> &HashMap<String, Method> {
        &self.methods
    }
    #[must_use]
    pub fn derives(&self) -> &HashSet<String> {
        &self.derives
    }

    #[must_use]
    pub fn has_derives(&self) -> bool {
        !self.derives.is_empty()
    }

    pub fn add_field(&mut self, name: String, info: FieldInfo) {
        self.fields.insert(name, info);
    }

    // UPDATED: Now takes Method by value, handles key cloning internally
    pub fn add_method(&mut self, method: Method) {
        self.methods.insert(method.name.clone(), method);
    }

    pub fn add_derive(&mut self, derive: String) {
        self.derives.insert(derive);
    }

    #[must_use]
    pub fn has_behavior(&self) -> bool {
        self.methods
            .values()
            .any(|m| m.cognitive_complexity > 0 || m.is_mutable)
    }

    /// Unified record validator to ensure cross-field consistency and struct cohesion.
    #[must_use]
    pub fn validate_record(&self) -> bool {
        !self.name.is_empty()
            && (self.row > 0 || self.is_enum)
            && self.fields.len() + self.methods.len() + self.derives.len() < usize::MAX
    }
}