nextcloud-route-extractor 0.1.3

Extract routes from nextcloud apps
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

use crate::attribute_routes::extract_attribute_routes;
use crate::routes_php::extract_routes_php;
use glob::{glob, GlobError, Paths, Pattern};
use std::fs::read_to_string;
use std::path::{Path, PathBuf};
use thiserror::Error;

mod attribute_routes;
mod route;
mod routes_php;

pub use route::*;

pub fn core_routes(path: &str) -> Result<AppRoutes, Error> {
    let mut result = AppRoutes {
        routes: vec![
            Route {
                url: "/core/ajax/update.php".into(),
                name: "core#ajax_update".into(),
                ..Route::default()
            },
            Route {
                url: "/heartbeat".into(),
                name: "core#heartbeat".into(),
                ..Route::default()
            },
        ],
        ocs: vec![],
    };

    let controller_paths = glob(&format!(
        "{}/core/Controller/*Controller.php",
        Pattern::escape(path)
    ))
    .unwrap();
    for routes in extract_controllers(controller_paths) {
        let routes = routes?;
        result.routes.extend_from_slice(&routes.routes);
        result.ocs.extend_from_slice(&routes.ocs);
    }
    Ok(result)
}

pub fn app_routes(path: &str) -> Result<AppRoutes, Error> {
    let routes_php_path = <str as AsRef<Path>>::as_ref(path).join("appinfo/routes.php");
    let mut result = if routes_php_path.exists() {
        let routes_php = read_to_string(&routes_php_path).map_err(|error| Error::Read {
            path: routes_php_path.clone(),
            error,
        })?;
        extract_routes_php(&routes_php_path, &routes_php)
    } else {
        AppRoutes::default()
    };

    let controller_paths = glob(&format!(
        "{}/lib/Controller/*Controller.php",
        Pattern::escape(path)
    ))
    .unwrap();
    for routes in extract_controllers(controller_paths) {
        let routes = routes?;
        result.routes.extend_from_slice(&routes.routes);
        result.ocs.extend_from_slice(&routes.ocs);
    }
    Ok(result)
}

fn extract_controllers(paths: Paths) -> impl Iterator<Item = Result<AppRoutes, Error>> {
    paths.map(|controller_path| {
        let controller_path = controller_path.map_err(Error::Glob)?;
        let controller_code = read_to_string(&controller_path).map_err(|error| Error::Read {
            path: controller_path,
            error,
        })?;
        Ok(extract_attribute_routes(&controller_code))
    })
}

#[derive(Debug, Error)]
pub enum Error {
    #[error("Failed to read {path}: {error:#}")]
    Read {
        path: PathBuf,
        error: std::io::Error,
    },
    #[error("Failed to find controller paths: {0:#}")]
    Glob(GlobError),
}