aldrin_parser/warning/
non_snake_case_schema_name.rs

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