Struct FileDebtMetrics 

pub struct FileDebtMetrics {

    pub path: PathBuf,
    pub total_lines: usize,
    pub function_count: usize,
    pub class_count: usize,
    pub avg_complexity: f64,
    pub max_complexity: u32,
    pub total_complexity: u32,
    pub coverage_percent: f64,
    pub uncovered_lines: usize,
    pub god_object_indicators: GodObjectIndicators,
    pub function_scores: Vec<f64>,
    pub god_object_type: Option<GodObjectType>,
    pub file_type: Option<FileType>,
}

Fields

path: PathBuf

total_lines: usize

function_count: usize

class_count: usize

avg_complexity: f64

max_complexity: u32

total_complexity: u32

coverage_percent: f64

uncovered_lines: usize

god_object_indicators: GodObjectIndicators

function_scores: Vec<f64>

god_object_type: Option<GodObjectType>

The specific type of god object detected (if any).

This field contains the classification of god object patterns:

• GodModule: A module with too many related structs/types that should be split
• TraditionalGodObject: A single class/struct with too many responsibilities
• Boilerplate: Repetitive code that should be macro-ified (NOT a god object)
• Registry: A lookup table or mapping structure (NOT a god object)

This type is used to determine the appropriate recommendation, following this precedence:

1. Boilerplate → recommend macros/codegen
2. Registry → recommend keeping as-is or data-driven approach
3. TraditionalGodObject → recommend extracting classes/modules
4. GodModule → recommend splitting into multiple modules
5. None → use general refactoring recommendations based on size/complexity

file_type: Option<FileType>

File type classification for context-aware thresholds (spec 135)

Implementations

impl FileDebtMetrics

pub fn calculate_score(&self) -> f64

pub fn get_score_factors(&self) -> FileScoreFactors

Extract individual scoring factors for display purposes.

This method decomposes the opaque score calculation from calculate_score() into individual factors that can be shown to users for transparency.

Returns

FileScoreFactors containing:

• All 6 multiplicative factors (size, complexity, coverage, density, god object, function)
• Basis values used to calculate each factor
• Contextual information for display (e.g., whether flagged as god object)

Example

let mut metrics = FileDebtMetrics::default();
metrics.total_lines = 400;
metrics.coverage_percent = 0.75;
let factors = metrics.get_score_factors();
println!("Coverage factor: {:.2} ({:.0}% coverage)",
         factors.coverage_factor,
         factors.coverage_percent * 100.0);

pub fn generate_recommendation(&self) -> String

Generate a recommendation for addressing this file’s technical debt.

This function uses a precedence-based strategy to select the most appropriate recommendation type, checking patterns in this order:

1. Boilerplate Pattern (highest priority)

   • Detected when file has many repetitive trait implementations
   • Recommendation: Use macros or code generation to reduce repetition
   • Example: ripgrep’s flags/defs.rs with 888 Flag trait implementations

2. Registry Pattern

   • Detected when file is primarily a lookup table or data mapping
   • Recommendation: Keep as-is or convert to data-driven approach
   • Example: Error code registries, configuration tables

3. God Object

   • Detected when file has too many responsibilities (via god_object_indicators)
   • Recommendation: Split into multiple focused modules
   • Context-specific advice based on file type (parser, cache, analyzer, etc.)

4. Large File (>500 lines)

   • Recommendation: Extract complex functions to reduce size

5. Complex Functions (avg complexity >10)

   • Recommendation: Simplify logic, extract helper functions

6. Low Coverage (<50%)

   • Recommendation: Add tests for uncovered code

The precedence ensures that boilerplate files don’t get incorrectly flagged as god objects requiring module splitting.

Trait Implementations

impl Clone for FileDebtMetrics

fn clone(&self) -> FileDebtMetrics

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FileDebtMetrics

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FileDebtMetrics

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FileDebtMetrics

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FileDebtMetrics

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.