freeman 0.1.0

A terminal-based API testing tool - like Postman, but for your terminal
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

//! Laravel source code parser (PHP)

use crate::discovery::models::{AuthRequirement, DiscoveredEndpoint, Framework, WorkspaceProject};
use regex::Regex;
use std::fs;
use std::path::Path;
use std::sync::OnceLock;

pub fn parse_php_routes(project_root: &Path) -> Vec<DiscoveredEndpoint> {
    let mut endpoints = Vec::new();

    // Check main route files
    for route_file in ["routes/api.php", "routes/web.php"] {
        let path = project_root.join(route_file);
        if path.exists() {
            if let Ok(content) = fs::read_to_string(&path) {
                endpoints.extend(parse_laravel_file(&content, &path));
            }
        }
    }

    endpoints
}

fn parse_laravel_file(content: &str, file_path: &Path) -> Vec<DiscoveredEndpoint> {
    static ROUTE_RE: OnceLock<Regex> = OnceLock::new();

    // Route::get(...) or ->get(...)
    let route_re = ROUTE_RE.get_or_init(|| {
        Regex::new(r#"(?:Route::|->)(get|post|put|patch|delete|any)\s*\(\s*['"]([^'"]+)['"]"#)
            .unwrap()
    });

    let mut endpoints = Vec::new();

    for (line_num, line) in content.lines().enumerate() {
        if let Some(caps) = route_re.captures(line) {
            let method = caps
                .get(1)
                .map(|m| m.as_str().to_uppercase())
                .unwrap_or("GET".to_string());
            let path = caps.get(2).map(|m| m.as_str()).unwrap_or("");

            let mut endpoint = DiscoveredEndpoint::new(&method, path);
            endpoint.source_file = Some(file_path.to_path_buf());
            endpoint.line_number = Some(line_num + 1);

            // Basic auth detection
            if line.contains("auth:sanctum") || line.contains("auth:api") {
                endpoint.auth = AuthRequirement::Bearer;
            }

            endpoints.push(endpoint);
        }
    }

    endpoints
}

pub fn load_laravel_project(project_root: &Path) -> WorkspaceProject {
    let mut project = WorkspaceProject::new(project_root.to_path_buf());
    project.framework = Framework::Laravel;
    project.endpoints = parse_php_routes(project_root);
    project.base_url = Some("http://localhost:8000".to_string());
    project
}

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

    #[test]
    fn test_parse_laravel() {
        let content = r#"
            Route::get('/user', function (Request $request) {
                return $request->user();
            });
            Route::post('login', [AuthController::class, 'login']);
            Route::middleware('auth:sanctum')->get('/profile', [ProfileController::class, 'show']);
        "#;

        let endpoints = parse_laravel_file(content, Path::new("routes/api.php"));
        assert_eq!(endpoints.len(), 3);

        let get_user = endpoints.iter().find(|e| e.path == "/user").unwrap();
        assert_eq!(get_user.method, "GET");

        let login = endpoints.iter().find(|e| e.path == "login").unwrap();
        assert_eq!(login.method, "POST");

        let profile = endpoints.iter().find(|e| e.path == "/profile").unwrap();
        assert_eq!(profile.method, "GET");
        assert!(matches!(profile.auth, AuthRequirement::Bearer));
    }
}