feat: updated path import of definition reader

Author: raphael-goetz

src/flow_validator/mod.rs

@@ -71,7 +71,7 @@ fn verify_data_type_rules(
                 }
             }
             Config::ContainsType(config) => {
-                match apply_contains_type(config, &availabe_data_types, &body) {
+                match apply_contains_type(config, availabe_data_types, &body) {
                     Ok(_) => continue,
                     Err(violation) => {
                         violations.extend(violation.violations);
@@ -89,7 +89,7 @@ fn verify_data_type_rules(
                 };
             }
             Config::ContainsKey(config) => {
-                match apply_contains_key(config, &body, &availabe_data_types) {
+                match apply_contains_key(config, &body, availabe_data_types) {
                     Ok(_) => continue,
                     Err(violation) => {
                         violations.extend(violation.violations);

src/flow_validator/rule/contains_key.rs

@@ -31,7 +31,7 @@ pub fn apply_contains_key(
     let identifier = rule.data_type_identifier;
 
     if let Some(Kind::StructValue(_)) = &body.kind {
-        let value = match expect_kind(&identifier, &body) {
+        let value = match expect_kind(&identifier, body) {
             Some(value) => Value {
                 kind: Some(value.to_owned()),
             },
@@ -46,7 +46,7 @@ pub fn apply_contains_key(
             }
         };
 
-        let data_type = match get_data_type_by_id(&available_data_types, &identifier) {
+        let data_type = match get_data_type_by_id(available_data_types, &identifier) {
             Some(data_type) => data_type,
             None => {
                 let error = MissingDataTypeRuleDefinition {
@@ -59,14 +59,14 @@ pub fn apply_contains_key(
             }
         };
 
-        return verify_data_type_rules(value, data_type, available_data_types);
+        verify_data_type_rules(value, data_type, available_data_types)
     } else {
-        return Err(DataTypeRuleError {
+        Err(DataTypeRuleError {
             violations: vec![DataTypeRuleViolation::ContainsKey(
                 ContainsKeyRuleViolation {
                     missing_key: identifier,
                 },
             )],
-        });
+        })
     }
 }

src/flow_validator/rule/contains_type.rs

@@ -42,7 +42,7 @@ pub fn apply_contains_type(
                 let mut rule_errors: Option<DataTypeRuleError> = None;
 
                 for value in list.values {
-                    match verify_data_type_rules(value, data_type.clone(), &available_data_types) {
+                    match verify_data_type_rules(value, data_type.clone(), available_data_types) {
                         Ok(_) => {}
                         Err(errors) => {
                             rule_errors = Some(errors);

src/flow_validator/rule/number_range.rs

@@ -30,7 +30,7 @@ pub fn apply_number_range(
     };
 
     let result = match kind {
-        Kind::NumberValue(n) => n.clone(),
+        Kind::NumberValue(n) => *n,
         _ => {
             return Err(DataTypeRuleError {
                 violations: vec![DataTypeRuleViolation::RegexTypeNotAccepted(

src/flow_validator/rule/regex.rs

@@ -51,11 +51,11 @@ pub fn apply_regex(rule: DataTypeRegexRuleConfig, body: &Value) -> Result<(), Da
     let regex = regex::Regex::new(rule.pattern.as_str()).unwrap();
 
     if !regex.is_match(&result) {
-        return Err(DataTypeRuleError {
+        Err(DataTypeRuleError {
             violations: vec![DataTypeRuleViolation::Regex(RegexRuleViolation {
                 missing_regex: rule.pattern.clone(),
             })],
-        });
+        })
     } else {
         Ok(())
     }