Merge pull request #1039 from BrynCooke/scientific-notation

(fix) Support numeric uppercase exponent

Author: schungx

src/tokenizer.rs

@@ -1823,21 +1823,21 @@ fn get_next_token_inner(
                             }
                         }
                         #[cfg(not(feature = "no_float"))]
-                        'e' if !_has_e && radix_base.is_none() => {
+                        ch @ ('e' | 'E') if !_has_e && radix_base.is_none() => {
                             stream.get_next().unwrap();
 
                             // Check if followed by digits or +/-
                             match stream.peek_next() {
-                                // digits after e - accept the e (no decimal points allowed)
+                                // digits after e/E - accept as 'e' (no decimal points allowed)
                                 Some('0'..='9') => {
-                                    result.push_str("e");
+                                    result.push('e');
                                     pos.advance();
                                     _has_e = true;
                                     _has_period = true;
                                 }
-                                // +/- after e - accept the e and the sign (no decimal points allowed)
+                                // +/- after e/E - accept as 'e' and the sign (no decimal points allowed)
                                 Some('+' | '-') => {
-                                    result.push_str("e");
+                                    result.push('e');
                                     pos.advance();
                                     result.push(stream.get_next().unwrap());
                                     pos.advance();
@@ -1846,7 +1846,7 @@ fn get_next_token_inner(
                                 }
                                 // Not a floating-point number
                                 _ => {
-                                    stream.unget('e');
+                                    stream.unget(ch);
                                     break;
                                 }
                             }

tests/float.rs

@@ -21,6 +21,11 @@ fn test_float_scientific() {
     assert!(engine.eval::<bool>("123.456 == 1.23456e+2").unwrap());
     assert!(engine.eval::<bool>("123.456 == 123456e-3").unwrap());
 
+    // Test uppercase 'E' as well
+    assert!(engine.eval::<bool>("123.456 == 1.23456E2").unwrap());
+    assert!(engine.eval::<bool>("123.456 == 1.23456E+2").unwrap());
+    assert!(engine.eval::<bool>("123.456 == 123456E-3").unwrap());
+
     let _ = engine.compile("123.456e1.23").unwrap_err();
 }
 

tests/parse_json.rs

@@ -45,6 +45,37 @@ mod without_metadata {
         assert_eq!(address["street"].clone().into_immutable_string().expect("address.street should exist"), "10 Downing Street");
     }
 
+    #[test]
+    #[cfg(not(feature = "no_function"))]
+    #[cfg(not(feature = "no_object"))]
+    #[cfg(not(feature = "no_float"))]
+    fn test_parse_json_scientific_notation() {
+        let engine = Engine::new();
+        let mut scope = Scope::new();
+
+        let map = engine
+            .eval_with_scope::<Map>(
+                &mut scope,
+                r#"
+                parse_json("{\
+                    \"positive_exp\": 1.23e4,\
+                    \"negative_exp\": 1.5e-5,\
+                    \"capital_e\": 2.5E+10,\
+                    \"integer_exp\": 3e2,\
+                    \"zero_exp\": 4.2e0\
+                }")
+            "#,
+            )
+            .unwrap();
+
+        assert_eq!(map.len(), 5);
+        assert_eq!(map["positive_exp"].as_float().expect("positive_exp should exist"), 1.23e4);
+        assert_eq!(map["negative_exp"].as_float().expect("negative_exp should exist"), 1.5e-5);
+        assert_eq!(map["capital_e"].as_float().expect("capital_e should exist"), 2.5E+10);
+        assert_eq!(map["integer_exp"].as_float().expect("integer_exp should exist"), 3e2);
+        assert_eq!(map["zero_exp"].as_float().expect("zero_exp should exist"), 4.2e0);
+    }
+
     #[test]
     #[cfg(feature = "no_index")]
     #[cfg(not(feature = "no_object"))]
@@ -140,6 +171,37 @@ mod with_metadata {
         assert_eq!(address["street"].clone().into_immutable_string().expect("address.street should exist"), "10 Downing Street");
     }
 
+    #[test]
+    #[cfg(not(feature = "no_function"))]
+    #[cfg(not(feature = "no_object"))]
+    #[cfg(not(feature = "no_float"))]
+    fn test_parse_json_scientific_notation() {
+        let engine = Engine::new();
+        let mut scope = Scope::new();
+
+        let map = engine
+            .eval_with_scope::<Map>(
+                &mut scope,
+                r#"
+                parse_json("{\
+                    \"positive_exp\": 1.23e4,\
+                    \"negative_exp\": 1.5e-5,\
+                    \"capital_e\": 2.5E+10,\
+                    \"integer_exp\": 3e2,\
+                    \"zero_exp\": 4.2e0\
+                }")
+            "#,
+            )
+            .unwrap();
+
+        assert_eq!(map.len(), 5);
+        assert_eq!(map["positive_exp"].as_float().expect("positive_exp should exist"), 1.23e4);
+        assert_eq!(map["negative_exp"].as_float().expect("negative_exp should exist"), 1.5e-5);
+        assert_eq!(map["capital_e"].as_float().expect("capital_e should exist"), 2.5E+10);
+        assert_eq!(map["integer_exp"].as_float().expect("integer_exp should exist"), 3e2);
+        assert_eq!(map["zero_exp"].as_float().expect("zero_exp should exist"), 4.2e0);
+    }
+
     #[test]
     #[cfg(feature = "no_index")]
     #[cfg(not(feature = "no_object"))]