feat(is_scalar): Zval::is_scalar() #237

src/types/zval.rs

@@ -62,6 +62,14 @@ impl Zval {
         zval
     }
 
+    /// Creates a zval containing an empty array.
+    #[must_use]
+    pub fn new_array() -> Zval {
+        let mut zval = Zval::new();
+        zval.set_hashtable(ZendHashTable::new());
+        zval
+    }
+
     /// Dereference the zval, if it is a reference.
     #[must_use]
     pub fn dereference(&self) -> &Self {
@@ -488,6 +496,18 @@ impl Zval {
         self.get_type() == DataType::Ptr
     }
 
+    /// Returns true if the zval is a scalar value (integer, float, string, or bool),
+    /// false otherwise.
+    ///
+    /// This is equivalent to PHP's `is_scalar()` function.
+    #[must_use]
+    pub fn is_scalar(&self) -> bool {
+        matches!(
+            self.get_type(),
+            DataType::Long | DataType::Double | DataType::String | DataType::True | DataType::False
+        )
+    }
+
     /// Sets the value of the zval as a string. Returns nothing in a result when
     /// successful.
     ///
@@ -812,4 +832,39 @@ mod tests {
             assert!(zval.is_null());
         });
     }
+
+    #[test]
+    fn test_is_scalar() {
+        Embed::run(|| {
+            // Test scalar types - should return true
+            let mut zval_long = Zval::new();
+            zval_long.set_long(42);
+            assert!(zval_long.is_scalar());
+
+            let mut zval_double = Zval::new();
+            zval_double.set_double(1.5);
+            assert!(zval_double.is_scalar());
+
+            let mut zval_true = Zval::new();
+            zval_true.set_bool(true);
+            assert!(zval_true.is_scalar());
+
+            let mut zval_false = Zval::new();
+            zval_false.set_bool(false);
+            assert!(zval_false.is_scalar());
+
+            let mut zval_string = Zval::new();
+            zval_string
+                .set_string("hello", false)
+                .expect("set_string should succeed");
+            assert!(zval_string.is_scalar());
+
+            // Test non-scalar types - should return false
+            let zval_null = Zval::null();
+            assert!(!zval_null.is_scalar());
+
+            let zval_array = Zval::new_array();
+            assert!(!zval_array.is_scalar());
+        });
+    }
 }

tests/sapi.rs

@@ -166,7 +166,7 @@ fn test_sapi_multithread() {
                     Ok(zval) => {
                         assert!(zval.is_string());
                         let string = zval.string().unwrap();
-                        let output = string.to_string();
+                        let output = string.clone();
                         assert_eq!(output, format!("Hello, thread-{i}!"));
 
                         results.lock().unwrap().push((i, output));