vize_patina 0.3.0

Patina - The quality checker for Vize code linting
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
129

//! vue/require-component-is
//!
//! Require `v-bind:is` attribute on `<component>` elements.
//!
//! The `<component>` element is a dynamic component that requires an `is` or
//! `:is` attribute to determine which component to render.
//!
//! ## Examples
//!
//! ### Invalid
//! ```vue
//! <component />
//! <component></component>
//! ```
//!
//! ### Valid
//! ```vue
//! <component :is="currentComponent" />
//! <component is="MyComponent" />
//! ```

use crate::context::LintContext;
use crate::diagnostic::Severity;
use crate::rule::{Rule, RuleCategory, RuleMeta};
use vize_relief::ast::{ElementNode, ExpressionNode, PropNode};

static META: RuleMeta = RuleMeta {
    name: "vue/require-component-is",
    description: "Require `v-bind:is` on `<component>` elements",
    category: RuleCategory::Essential,
    fixable: false,
    default_severity: Severity::Error,
};

#[derive(Default)]
pub struct RequireComponentIs;

impl RequireComponentIs {
    fn has_is_attribute(element: &ElementNode) -> bool {
        for prop in &element.props {
            match prop {
                PropNode::Attribute(attr) => {
                    if attr.name == "is" {
                        return true;
                    }
                }
                PropNode::Directive(dir) => {
                    // Check for :is or v-bind:is
                    if dir.name == "bind" {
                        if let Some(ExpressionNode::Simple(arg)) = &dir.arg {
                            if arg.content == "is" {
                                return true;
                            }
                        }
                    }
                }
            }
        }
        false
    }
}

impl Rule for RequireComponentIs {
    fn meta(&self) -> &'static RuleMeta {
        &META
    }

    fn enter_element<'a>(&self, ctx: &mut LintContext<'a>, element: &ElementNode<'a>) {
        if element.tag.as_str() != "component" {
            return;
        }

        if !Self::has_is_attribute(element) {
            ctx.error_with_help(
                ctx.t("vue/require-component-is.message"),
                &element.loc,
                ctx.t("vue/require-component-is.help"),
            );
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::linter::Linter;
    use crate::rule::RuleRegistry;

    fn create_linter() -> Linter {
        let mut registry = RuleRegistry::new();
        registry.register(Box::new(RequireComponentIs));
        Linter::with_registry(registry)
    }

    #[test]
    fn test_valid_with_bind_is() {
        let linter = create_linter();
        let result = linter.lint_template(r#"<component :is="currentComponent" />"#, "test.vue");
        assert_eq!(result.error_count, 0);
    }

    #[test]
    fn test_valid_with_static_is() {
        let linter = create_linter();
        let result = linter.lint_template(r#"<component is="MyComponent" />"#, "test.vue");
        assert_eq!(result.error_count, 0);
    }

    #[test]
    fn test_invalid_no_is() {
        let linter = create_linter();
        let result = linter.lint_template(r#"<component />"#, "test.vue");
        assert_eq!(result.error_count, 1);
    }

    #[test]
    fn test_invalid_no_is_with_children() {
        let linter = create_linter();
        let result = linter.lint_template(r#"<component>content</component>"#, "test.vue");
        assert_eq!(result.error_count, 1);
    }

    #[test]
    fn test_not_component_tag() {
        let linter = create_linter();
        let result = linter.lint_template(r#"<div></div>"#, "test.vue");
        assert_eq!(result.error_count, 0);
    }
}