lexa-framework-macro 0.2.5

Framework web backend personnel par dessus Axum.
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

// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
// ┃ Copyright: (c) 2023, Mike 'PhiSyX' S. (https://github.com/PhiSyX)         ┃
// ┃ SPDX-License-Identifier: MPL-2.0                                          ┃
// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
// ┃                                                                           ┃
// ┃  This Source Code Form is subject to the terms of the Mozilla Public      ┃
// ┃  License, v. 2.0. If a copy of the MPL was not distributed with this      ┃
// ┃  file, You can obtain one at https://mozilla.org/MPL/2.0/.                ┃
// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

use std::{error, fmt};

use lexa_syn::field;
use syn::__private::quote::{quote, quote_spanned};
use syn::__private::{Span, TokenStream, TokenStream2};
use syn::spanned::Spanned;

// ---- //
// Type //
// ---- //

pub type ViewDeriveParserInput = syn::ItemStruct;
type Result<'err, T> = std::result::Result<T, ViewDeriveParserError>;

// --------- //
// Structure //
// --------- //

pub struct ViewDerive {
	item_struct: ViewDeriveParserInput,
}

#[derive(Debug)]
pub struct ViewDeriveParserError {
	span: syn::__private::Span,
	kind: ErrorDeriveParserErrorKind,
}

// ----------- //
// Énumération //
// ----------- //

#[derive(Debug)]
pub enum ErrorDeriveParserErrorKind {
	IsNotNamedOrUnitStruct,
}

// -------------- //
// Implémentation // -> Interface
// -------------- //

impl lexa_syn::Parser for ViewDerive {
	type Err<'err> = ViewDeriveParserError;
	type Input = ViewDeriveParserInput;

	fn new(input: Self::Input) -> Self {
		Self { item_struct: input }
	}

	fn analyze(&self) -> Result<'_, TokenStream> {
		if !field::is_named_fields(&self.item_struct.fields)
			&& !field::is_unit_fields(&self.item_struct.fields)
		{
			return Err(ViewDeriveParserError {
				span: self.item_struct.span(),
				kind: ErrorDeriveParserErrorKind::IsNotNamedOrUnitStruct,
			});
		}

		let item_struct_name = &self.item_struct.ident;
		let output = quote! {
			impl lexa_framework::http::response::IntoResponse for #item_struct_name {
				fn into_response(self) -> lexa_framework::http::response::Response {
					use lexa_framework::view::ViewInterface;
					lexa_framework::http::response::Html(
						self.render().to_string()
					).into_response()
				}
			}

			impl From<#item_struct_name> for
				lexa_framework::http::body::Full<
					lexa_framework::http::body::Bytes
				>
			{
				fn from(s: #item_struct_name) -> Self {
					use lexa_framework::view::ViewInterface;
					Self::from(s.render().to_string())
				}
			}
		};

		let output = <TokenStream2 as Into<TokenStream>>::into(output);
		Ok(output)
	}
}

impl<'err> lexa_syn::ParserError<'err> for ViewDeriveParserError {
	fn compile_error(self) -> TokenStream {
		let err_s = self.to_string();
		let tokens = quote_spanned! {
			self.span() => compile_error!(#err_s);
		};
		TokenStream::from(tokens)
	}

	fn span(self) -> Span {
		self.span
	}
}

impl error::Error for ViewDeriveParserError {}

impl fmt::Display for ViewDeriveParserError {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		let err_s = match self.kind {
			| ErrorDeriveParserErrorKind::IsNotNamedOrUnitStruct => {
				String::from(
					"ne supporte que les structures de champs nommés ou les \
					 structures unitaires.",
				)
			}
		};

		write!(f, "#[derive(View)]: {}", err_s)
	}
}