aldrin_parser/warning/
non_snake_case_struct_field.rs

1use super::Warning;
2use crate::ast::Ident;
3use crate::diag::{Diagnostic, DiagnosticKind, Formatted, Formatter};
4use crate::validate::Validate;
5use crate::Parsed;
6use heck::ToSnakeCase;
7
8#[derive(Debug)]
9pub struct NonSnakeCaseStructField {
10    schema_name: String,
11    snake_case: String,
12    ident: Ident,
13}
14
15impl NonSnakeCaseStructField {
16    pub(crate) fn validate(ident: &Ident, validate: &mut Validate) {
17        let snake_case = ident.value().to_snake_case();
18
19        if ident.value() != snake_case {
20            validate.add_warning(Self {
21                schema_name: validate.schema_name().to_owned(),
22                snake_case,
23                ident: ident.clone(),
24            });
25        }
26    }
27
28    pub fn snake_case(&self) -> &str {
29        &self.snake_case
30    }
31
32    pub fn ident(&self) -> &Ident {
33        &self.ident
34    }
35}
36
37impl Diagnostic for NonSnakeCaseStructField {
38    fn kind(&self) -> DiagnosticKind {
39        DiagnosticKind::Warning
40    }
41
42    fn schema_name(&self) -> &str {
43        &self.schema_name
44    }
45
46    fn format<'a>(&'a self, parsed: &'a Parsed) -> Formatted<'a> {
47        let mut fmt = Formatter::new(
48            self,
49            format!(
50                "field `{}` should have a snake-case name",
51                self.ident.value()
52            ),
53        );
54
55        if let Some(schema) = parsed.get_schema(&self.schema_name) {
56            fmt.main_block(schema, self.ident.span().from, self.ident.span(), "");
57        }
58
59        fmt.help(format!(
60            "consider renaming field `{}` to `{}`",
61            self.ident.value(),
62            self.snake_case
63        ));
64        fmt.format()
65    }
66}
67
68impl From<NonSnakeCaseStructField> for Warning {
69    fn from(w: NonSnakeCaseStructField) -> Self {
70        Self::NonSnakeCaseStructField(w)
71    }
72}