ferrous-forge 1.9.6

System-wide Rust development standards enforcer
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

//! Code context extraction utilities for AI analysis
//!
//! This module provides functions to extract contextual information from code,
//! including surrounding code, function signatures, imports, and error handling patterns.

use super::types::{CodeContext, ErrorHandlingStyle};

/// Extract code context around a violation line
pub fn extract_code_context(line_number: usize, content: &str) -> CodeContext {
    let lines: Vec<&str> = content.lines().collect();
    let context_start = line_number.saturating_sub(10);
    let context_end = (line_number + 10).min(lines.len());

    let surrounding_code = lines[context_start..context_end]
        .iter()
        .map(|s| s.to_string())
        .collect();

    let imports = extract_imports(content);
    let (function_name, function_signature, return_type) =
        extract_function_info(&lines, line_number);
    let is_async = function_signature
        .as_ref()
        .map(|s| s.contains("async"))
        .unwrap_or(false);
    let is_generic = function_signature
        .as_ref()
        .map(|s| s.contains('<'))
        .unwrap_or(false);
    let trait_impl = detect_trait_impl(content, line_number);
    let error_handling_style = detect_error_handling_style(&imports, content);

    CodeContext {
        function_name,
        function_signature,
        return_type,
        is_async,
        is_generic,
        trait_impl,
        surrounding_code,
        imports,
        error_handling_style,
    }
}

/// Extract all import statements from the file content
///
/// Identifies lines starting with "use " and collects them as import statements.
fn extract_imports(content: &str) -> Vec<String> {
    content
        .lines()
        .filter(|line| line.trim().starts_with("use "))
        .map(|s| s.to_string())
        .collect()
}

/// Extract function information for the context of a given line
///
/// Searches backwards from the violation line to find the containing function,
/// extracting its name, signature, and return type.
///
/// Returns a tuple of (`function_name`, `function_signature`, `return_type`)
fn extract_function_info(
    lines: &[&str],
    line_number: usize,
) -> (Option<String>, Option<String>, Option<String>) {
    for i in (0..line_number).rev() {
        if let Some(line) = lines.get(i)
            && line.contains("fn ")
            && !line.trim().starts_with("//")
        {
            let signature = line.trim().to_string();
            let name = signature
                .split("fn ")
                .nth(1)
                .and_then(|s| s.split('(').next())
                .map(|s| s.trim().to_string());
            let return_type = if signature.contains("->") {
                signature.split("->").nth(1).map(|s| s.trim().to_string())
            } else {
                None
            };
            return (name, Some(signature), return_type);
        }
    }
    (None, None, None)
}

/// Detect the error handling style used in the code
pub fn detect_error_handling_style(imports: &[String], content: &str) -> ErrorHandlingStyle {
    if imports.iter().any(|i| i.contains("anyhow")) || content.contains("anyhow::Result") {
        ErrorHandlingStyle::AnyhowResult
    } else if content.contains("Result<") && !content.contains("std::result::Result") {
        ErrorHandlingStyle::CustomResult
    } else if content.contains("Result<") {
        ErrorHandlingStyle::StdResult
    } else if content.contains("Option<") {
        ErrorHandlingStyle::OptionBased
    } else if content.contains("panic!") || content.contains(".unwrap()") {
        ErrorHandlingStyle::Panic
    } else {
        ErrorHandlingStyle::Unknown
    }
}

/// Detect if a line is within a trait implementation block
///
/// Searches backwards from the given line to find an "impl...for" statement,
/// which indicates the code is part of a trait implementation.
fn detect_trait_impl(content: &str, line: usize) -> Option<String> {
    let lines: Vec<&str> = content.lines().collect();
    for i in (0..line.min(lines.len())).rev() {
        if lines[i].contains("impl") && lines[i].contains("for") {
            return Some(lines[i].trim().to_string());
        }
    }
    None
}