validateFlags function

Author: qkniep

src/lib.rs

@@ -1,6 +1,6 @@
 mod validator;
 
-pub use validator::ESRegexValidator;
+pub use validator::EcmaRegexValidator;
 
 #[cfg(test)]
 mod tests {

src/validator.rs

@@ -1,7 +1,10 @@
 // Copyright (C) 2020 Quentin M. Kniep <[email protected]>
 // Distributed under terms of the MIT license.
 
-enum ESVersion {
+use std::collections::HashSet;
+
+#[derive(Debug, Ord, PartialOrd, Eq, PartialEq)]
+enum EcmaVersion {
     ES5,
     ES2015,
     ES2016,
@@ -12,18 +15,56 @@ enum ESVersion {
     ES2021,
 }
 
-pub struct ESRegexValidator {
-    es_version: ESVersion,
+#[derive(Debug)]
+pub struct EcmaRegexValidator {
+    ecma_version: EcmaVersion,
 }
 
-impl ESRegexValidator {
-    fn new(es_version: ESVersion) -> Self {
-        ESRegexValidator {
-            es_version
+impl EcmaRegexValidator {
+    fn new(ecma_version: EcmaVersion) -> Self {
+        EcmaRegexValidator {
+            ecma_version
         }
     }
 
-    fn validate(&self, regex: &str) {
+    fn validatePattern(&self, pattern: &str, ) -> bool {
+        return true;
+    }
+
+    ///
+    fn validateFlags(&self, flags: &str) -> bool {
+        let mut existing_flags = HashSet::<char>::new();
+        let mut global = false;
+        let mut ignore_case = false;
+        let mut multiline = false;
+        let mut sticky = false;
+        let mut unicode = false;
+        let mut dot_all = false;
+
+        for flag in flags.chars() {
+            if existing_flags.contains(&flag) {
+                return false;  // duplicate flag
+            }
+            existing_flags.insert(flag);
+
+            if flag == 'g' {
+                global = true;
+            } else if flag == 'i' {
+                ignore_case = true;
+            } else if flag == 'm' {
+                multiline = true;
+            } else if flag == 'u' && self.ecma_version >= EcmaVersion::ES2015 {
+                unicode = true;
+            } else if flag == 'y' && self.ecma_version >= EcmaVersion::ES2015 {
+                sticky = true;
+            } else if flag == 's' && self.ecma_version >= EcmaVersion::ES2018 {
+                dot_all = true;
+            } else {
+                return false;  // invalid flag
+            }
+        }
+
+        return true;
     }
 }
 
@@ -33,6 +74,10 @@ mod tests {
     use super::*;
 
     #[test]
-    fn it_works() {
+    fn validate_flags() {
+        let validator = EcmaRegexValidator::new(EcmaVersion::ES2018);
+        assert_eq!(validator.validateFlags("gimuys"), true);
+        assert_eq!(validator.validateFlags("gimgu"), false);
+        assert_eq!(validator.validateFlags("gimuf"), false);
     }
 }