ruskit 0.1.5

A modern web framework for Rust inspired by Laravel
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

use askama::Template;
use axum::{
    response::{Html, IntoResponse},
    http::StatusCode,
};
use askama_axum::Response;
use std::{sync::OnceLock, cell::RefCell, thread_local};

static GLOBAL_METADATA: OnceLock<Metadata> = OnceLock::new();

thread_local! {
    static LOCAL_METADATA: RefCell<Option<Metadata>> = RefCell::new(None);
}

#[derive(Clone, Debug)]
pub struct Metadata {
    pub title: String,
    pub description: Option<String>,
    pub keywords: Option<String>,
    pub author: Option<String>,
    pub og_title: Option<String>,
    pub og_description: Option<String>,
    pub og_image: Option<String>,
}

impl Default for Metadata {
    fn default() -> Self {
        Self {
            title: "Ruskit".to_string(),
            description: None,
            keywords: None,
            author: None,
            og_title: None,
            og_description: None,
            og_image: None,
        }
    }
}

impl Metadata {
    pub fn new(title: impl Into<String>) -> Self {
        Self {
            title: title.into(),
            ..Default::default()
        }
    }

    pub fn with_description(mut self, description: impl Into<String>) -> Self {
        self.description = Some(description.into());
        self
    }

    pub fn with_keywords(mut self, keywords: impl Into<String>) -> Self {
        self.keywords = Some(keywords.into());
        self
    }

    pub fn with_author(mut self, author: impl Into<String>) -> Self {
        self.author = Some(author.into());
        self
    }

    pub fn with_og_title(mut self, title: impl Into<String>) -> Self {
        self.og_title = Some(title.into());
        self
    }

    pub fn with_og_description(mut self, description: impl Into<String>) -> Self {
        self.og_description = Some(description.into());
        self
    }

    pub fn with_og_image(mut self, image: impl Into<String>) -> Self {
        self.og_image = Some(image.into());
        self
    }
}

pub fn set_global_metadata(metadata: Metadata) {
    let _ = GLOBAL_METADATA.set(metadata);
}

pub fn get_global_metadata() -> &'static Metadata {
    GLOBAL_METADATA.get_or_init(Metadata::default)
}

// Trait for templates with metadata
pub trait HasMetadata: Default {
    fn metadata(&self) -> &'static Metadata {
        LOCAL_METADATA.with(|local| {
            if let Some(metadata) = &*local.borrow() {
                // SAFETY: The metadata lives for the duration of the request
                // and is cleared after the response is sent
                unsafe { std::mem::transmute(metadata) }
            } else {
                get_global_metadata()
            }
        })
    }

    fn with_metadata(metadata: Metadata) -> Self where Self: Sized {
        LOCAL_METADATA.with(|local| {
            *local.borrow_mut() = Some(metadata);
        });
        Self::default()
    }
}

// Implement HasMetadata for all Template types that are unit structs
impl<T: Template> HasMetadata for T where T: Default {}

// Extension trait for Template types
pub trait TemplateExt: Template + HasMetadata + Sized {
    fn into_response(self) -> Response {
        let response = match self.render() {
            Ok(html) => Html(html).into_response().into(),
            Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response().into(),
        };
        // Clear the local metadata after the response is generated
        LOCAL_METADATA.with(|local| {
            *local.borrow_mut() = None;
        });
        response
    }
}

// Implement TemplateExt for all Template types
impl<T: Template + HasMetadata> TemplateExt for T {}