darklua 0.19.0

Transform Lua scripts
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

use crate::nodes::{AssignmentKind, Block, FunctionAssignment, VariableAssignment};
use crate::process::{DefaultVisitor, NodeProcessor, NodeVisitor};
use crate::rules::{
    Context, FlawlessRule, RuleConfiguration, RuleConfigurationError, RuleMetadata, RuleProperties,
};

use serde::ser::{Serialize, Serializer};

use super::verify_no_rule_properties;

#[derive(Debug, Default)]
struct Processor;

impl NodeProcessor for Processor {
    fn process_local_assign_statement(&mut self, assign: &mut VariableAssignment) {
        assign.set_assignment_kind(AssignmentKind::Local);
    }

    fn process_local_function_statement(&mut self, function: &mut FunctionAssignment) {
        function.set_assignment_kind(AssignmentKind::Local);
    }
}

pub const MAKE_ASSIGNMENT_LOCAL_RULE_NAME: &str = "make_assignment_local";

/// A rule that converts Luau `const` assignments into `local` assignments.
#[derive(Debug, Default, PartialEq, Eq)]
pub struct MakeAssignmentLocal {
    metadata: RuleMetadata,
}

impl FlawlessRule for MakeAssignmentLocal {
    fn flawless_process(&self, block: &mut Block, _: &Context) {
        let mut processor = Processor;
        DefaultVisitor::visit_block(block, &mut processor);
    }
}

impl RuleConfiguration for MakeAssignmentLocal {
    fn configure(&mut self, properties: RuleProperties) -> Result<(), RuleConfigurationError> {
        verify_no_rule_properties(&properties)?;

        Ok(())
    }

    fn get_name(&self) -> &'static str {
        MAKE_ASSIGNMENT_LOCAL_RULE_NAME
    }

    fn serialize_to_properties(&self) -> RuleProperties {
        RuleProperties::new()
    }

    fn set_metadata(&mut self, metadata: RuleMetadata) {
        self.metadata = metadata;
    }

    fn metadata(&self) -> &RuleMetadata {
        &self.metadata
    }
}

impl Serialize for MakeAssignmentLocal {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(MAKE_ASSIGNMENT_LOCAL_RULE_NAME)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    use crate::rules::Rule;

    use insta::assert_json_snapshot;

    fn new_rule() -> MakeAssignmentLocal {
        MakeAssignmentLocal::default()
    }

    #[test]
    fn serialize_default_rule() {
        assert_json_snapshot!(new_rule(), @r###""make_assignment_local""###);
    }

    #[test]
    fn configure_with_extra_field_error() {
        let result = json5::from_str::<Box<dyn Rule>>(
            r#"{
            rule: 'make_assignment_local',
            prop: "something",
        }"#,
        );
        insta::assert_snapshot!(result.unwrap_err().to_string(), @"unexpected field 'prop' at line 1 column 1")
    }
}