14501981872

Committed 16 Apr 2025 08:30PM UTC coverage: 14.129% (+0.7%) from 13.479%

Build # 14501981872

Build Type

push

github

Committed by

web-flow

Commit Message

style(clippy): apply pedantic rules

Refs: #418

Run Details

41 of 345 new or added lines in 46 files covered. (11.88%)

48 existing lines in 25 files now uncovered.

553 of 3914 relevant lines covered (14.13%)

1.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

32.05

/src/types/string.rs

//! Represents a string in the PHP world. Similar to a C string, but is
//! reference counted and contains the length of the string.

use std::{
    borrow::Cow,
    convert::TryFrom,
    ffi::{CStr, CString},
    fmt::Debug,
    ptr, slice,
};

use parking_lot::{const_mutex, Mutex};

use crate::{
    boxed::{ZBox, ZBoxable},
    convert::{FromZval, IntoZval},
    error::{Error, Result},
    ffi::{
        ext_php_rs_is_known_valid_utf8, ext_php_rs_set_known_valid_utf8,
        ext_php_rs_zend_string_init, ext_php_rs_zend_string_release, zend_string,
        zend_string_init_interned,
    },
    flags::DataType,
    macros::try_from_zval,
    types::Zval,
};

/// A borrowed Zend string.
///
/// Although this object does implement [`Sized`], it is in fact not sized. As C
/// cannot represent unsized types, an array of size 1 is used at the end of the
/// type to represent the contents of the string, therefore this type is
/// actually unsized. All constructors return [`ZBox<ZendStr>`], the owned
/// variant.
///
/// Once the `ptr_metadata` feature lands in stable rust, this type can
/// potentially be changed to a DST using slices and metadata. See the tracking issue here: <https://github.com/rust-lang/rust/issues/81513>
pub type ZendStr = zend_string;

// Adding to the Zend interned string hashtable is not atomic and can be
// contested when PHP is compiled with ZTS, so an empty mutex is used to ensure
// no collisions occur on the Rust side. Not much we can do about collisions
// on the PHP side, but some safety is better than none.
static INTERNED_LOCK: Mutex<()> = const_mutex(());

// Clippy complains about there being no `is_empty` function when implementing
// on the alias `ZendStr` :( <https://github.com/rust-lang/rust-clippy/issues/7702>
#[allow(clippy::len_without_is_empty)]
impl ZendStr {
    /// Creates a new Zend string from a slice of bytes.
    ///
    /// # Parameters
    ///
    /// * `str` - String content.
    /// * `persistent` - Whether the string should persist through the request
    ///   boundary.
    ///
    /// # Panics
    ///
    /// Panics if the function was unable to allocate memory for the Zend
    /// string.
    ///
    /// # Safety
    ///
    /// When passing `persistent` as `false`, the caller must ensure that the
    /// object does not attempt to live after the request finishes. When a
    /// request starts and finishes in PHP, the Zend heap is deallocated and a
    /// new one is created, which would leave a dangling pointer in the
    /// [`ZBox`].
    ///
    /// # Example
    ///
    /// ```no_run
    /// use ext_php_rs::types::ZendStr;
    ///
    /// let s = ZendStr::new("Hello, world!", false);
    /// let php = ZendStr::new([80, 72, 80], false);
    /// ```
    pub fn new(str: impl AsRef<[u8]>, persistent: bool) -> ZBox<Self> {
        let s = str.as_ref();
        // TODO: we should handle the special cases when length is either 0 or 1
        // see `zend_string_init_fast()` in `zend_string.h`
        unsafe {
            let ptr = ext_php_rs_zend_string_init(s.as_ptr().cast(), s.len(), persistent)
                .as_mut()
                .expect("Failed to allocate memory for new Zend string");
            ZBox::from_raw(ptr)
        }
    }

    /// Creates a new Zend string from a [`CStr`].
    ///
    /// # Parameters
    ///
    /// * `str` - String content.
    /// * `persistent` - Whether the string should persist through the request
    ///   boundary.
    ///
    /// # Panics
    ///
    /// Panics if the function was unable to allocate memory for the Zend
    /// string.
    ///
    /// # Safety
    ///
    /// When passing `persistent` as `false`, the caller must ensure that the
    /// object does not attempt to live after the request finishes. When a
    /// request starts and finishes in PHP, the Zend heap is deallocated and a
    /// new one is created, which would leave a dangling pointer in the
    /// [`ZBox`].
    ///
    /// # Example
    ///
    /// ```no_run
    /// use ext_php_rs::types::ZendStr;
    /// use std::ffi::CString;
    ///
    /// let c_s = CString::new("Hello world!").unwrap();
    /// let s = ZendStr::from_c_str(&c_s, false);
    /// ```
    #[must_use]
    pub fn from_c_str(str: &CStr, persistent: bool) -> ZBox<Self> {
        unsafe {
            let ptr =
                ext_php_rs_zend_string_init(str.as_ptr(), str.to_bytes().len() as _, persistent);

            ZBox::from_raw(
                ptr.as_mut()
                    .expect("Failed to allocate memory for new Zend string"),
            )
        }
    }

    /// Creates a new interned Zend string from a slice of bytes.
    ///
    /// An interned string is only ever stored once and is immutable. PHP stores
    /// the string in an internal hashtable which stores the interned
    /// strings.
    ///
    /// As Zend hashtables are not thread-safe, a mutex is used to prevent two
    /// interned strings from being created at the same time.
    ///
    /// Interned strings are not used very often. You should almost always use a
    /// regular zend string, except in the case that you know you will use a
    /// string that PHP will already have interned, such as "PHP".
    ///
    /// # Parameters
    ///
    /// * `str` - String content.
    /// * `persistent` - Whether the string should persist through the request
    ///   boundary.
    ///
    /// # Panics
    ///
    /// Panics under the following circumstances:
    ///
    /// * The function used to create interned strings has not been set.
    /// * The function could not allocate enough memory for the Zend string.
    ///
    /// # Safety
    ///
    /// When passing `persistent` as `false`, the caller must ensure that the
    /// object does not attempt to live after the request finishes. When a
    /// request starts and finishes in PHP, the Zend heap is deallocated and a
    /// new one is created, which would leave a dangling pointer in the
    /// [`ZBox`].
    ///
    /// # Example
    ///
    /// ```no_run
    /// use ext_php_rs::types::ZendStr;
    ///
    /// let s = ZendStr::new_interned("PHP", true);
    /// ```
    pub fn new_interned(str: impl AsRef<[u8]>, persistent: bool) -> ZBox<Self> {
        let _lock = INTERNED_LOCK.lock();
        let s = str.as_ref();
        unsafe {
            let init = zend_string_init_interned.expect("`zend_string_init_interned` not ready");
            let ptr = init(s.as_ptr().cast(), s.len() as _, persistent)
                .as_mut()
                .expect("Failed to allocate memory for new Zend string");
            ZBox::from_raw(ptr)
        }
    }

    /// Creates a new interned Zend string from a [`CStr`].
    ///
    /// An interned string is only ever stored once and is immutable. PHP stores
    /// the string in an internal hashtable which stores the interned
    /// strings.
    ///
    /// As Zend hashtables are not thread-safe, a mutex is used to prevent two
    /// interned strings from being created at the same time.
    ///
    /// Interned strings are not used very often. You should almost always use a
    /// regular zend string, except in the case that you know you will use a
    /// string that PHP will already have interned, such as "PHP".
    ///
    /// # Parameters
    ///
    /// * `str` - String content.
    /// * `persistent` - Whether the string should persist through the request
    ///   boundary.
    ///
    /// # Panics
    ///
    /// Panics under the following circumstances:
    ///
    /// * The function used to create interned strings has not been set.
    /// * The function could not allocate enough memory for the Zend string.
    ///
    /// # Safety
    ///
    /// When passing `persistent` as `false`, the caller must ensure that the
    /// object does not attempt to live after the request finishes. When a
    /// request starts and finishes in PHP, the Zend heap is deallocated and a
    /// new one is created, which would leave a dangling pointer in the
    /// [`ZBox`].
    ///
    /// # Example
    ///
    /// ```no_run
    /// use ext_php_rs::types::ZendStr;
    /// use std::ffi::CString;
    ///
    /// let c_s = CString::new("PHP").unwrap();
    /// let s = ZendStr::interned_from_c_str(&c_s, true);
    /// ```
    pub fn interned_from_c_str(str: &CStr, persistent: bool) -> ZBox<Self> {
        let _lock = INTERNED_LOCK.lock();

        unsafe {
            let init = zend_string_init_interned.expect("`zend_string_init_interned` not ready");
            let ptr = init(str.as_ptr(), str.to_bytes().len() as _, persistent);

            ZBox::from_raw(
                ptr.as_mut()
                    .expect("Failed to allocate memory for new Zend string"),
            )
        }
    }

    /// Returns the length of the string.
    ///
    /// # Example
    ///
    /// ```no_run
    /// use ext_php_rs::types::ZendStr;
    ///
    /// let s = ZendStr::new("hello, world!", false);
    /// assert_eq!(s.len(), 13);
    /// ```
    #[must_use]
    pub fn len(&self) -> usize {
        self.len
    }

    /// Returns true if the string is empty, false otherwise.
    ///
    /// # Example
    ///
    /// ```no_run
    /// use ext_php_rs::types::ZendStr;
    ///
    /// let s = ZendStr::new("hello, world!", false);
    /// assert_eq!(s.is_empty(), false);
    /// ```
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Attempts to return a reference to the underlying bytes inside the Zend
    /// string as a [`CStr`].
    ///
    /// # Errors
    ///
    /// Returns an [`Error::InvalidCString`] variant if the string contains null
    /// bytes.
    pub fn as_c_str(&self) -> Result<&CStr> {
        let bytes_with_null =
            unsafe { slice::from_raw_parts(self.val.as_ptr().cast(), self.len() + 1) };
        CStr::from_bytes_with_nul(bytes_with_null).map_err(|_| Error::InvalidCString)
    }

    /// Attempts to return a reference to the underlying bytes inside the Zend
    /// string.
    ///
    /// # Errors
    ///
    /// Returns an [`Error::InvalidUtf8`] variant if the [`str`] contains
    /// non-UTF-8 characters.
    ///
    /// # Example
    ///
    /// ```no_run
    /// use ext_php_rs::types::ZendStr;
    ///
    /// let s = ZendStr::new("hello, world!", false);
    /// assert!(s.as_str().is_ok());
    /// ```
    pub fn as_str(&self) -> Result<&str> {
        if unsafe { ext_php_rs_is_known_valid_utf8(self.as_ptr()) } {
            let str = unsafe { std::str::from_utf8_unchecked(self.as_bytes()) };
            return Ok(str);
        }
        let str = std::str::from_utf8(self.as_bytes()).map_err(|_| Error::InvalidUtf8)?;
        unsafe { ext_php_rs_set_known_valid_utf8(self.as_ptr().cast_mut()) };
        Ok(str)
    }

    /// Returns a reference to the underlying bytes inside the Zend string.
    #[must_use]
    pub fn as_bytes(&self) -> &[u8] {
        unsafe { slice::from_raw_parts(self.val.as_ptr().cast(), self.len()) }
    }

    /// Returns a raw pointer to this object
    #[must_use]
    pub fn as_ptr(&self) -> *const ZendStr {
        ptr::from_ref(self)
    }

    /// Returns a mutable pointer to this object
    pub fn as_mut_ptr(&mut self) -> *mut ZendStr {
        ptr::from_mut(self)
    }
}

unsafe impl ZBoxable for ZendStr {
    fn free(&mut self) {
        unsafe { ext_php_rs_zend_string_release(self) };
    }
}

impl Debug for ZendStr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.as_str().fmt(f)
    }
}

impl AsRef<[u8]> for ZendStr {
    fn as_ref(&self) -> &[u8] {
        self.as_bytes()
    }
}

impl<T> PartialEq<T> for ZendStr
where
    T: AsRef<[u8]>,
{
    fn eq(&self, other: &T) -> bool {
        self.as_ref() == other.as_ref()
    }
}

impl ToOwned for ZendStr {
    type Owned = ZBox<ZendStr>;

    fn to_owned(&self) -> Self::Owned {
        Self::new(self.as_bytes(), false)
    }
}

impl<'a> TryFrom<&'a ZendStr> for &'a CStr {
    type Error = Error;

    fn try_from(value: &'a ZendStr) -> Result<Self> {
        value.as_c_str()
    }
}

impl<'a> TryFrom<&'a ZendStr> for &'a str {
    type Error = Error;

    fn try_from(value: &'a ZendStr) -> Result<Self> {
        value.as_str()
    }
}

impl TryFrom<&ZendStr> for String {
    type Error = Error;

    fn try_from(value: &ZendStr) -> Result<Self> {
        value.as_str().map(ToString::to_string)
    }
}

impl<'a> From<&'a ZendStr> for Cow<'a, ZendStr> {
    fn from(value: &'a ZendStr) -> Self {
        Cow::Borrowed(value)
    }
}

impl From<&CStr> for ZBox<ZendStr> {
    fn from(value: &CStr) -> Self {
        ZendStr::from_c_str(value, false)
    }
}

impl From<CString> for ZBox<ZendStr> {
    fn from(value: CString) -> Self {
        ZendStr::from_c_str(&value, false)
    }
}

impl From<&str> for ZBox<ZendStr> {
    fn from(value: &str) -> Self {
        ZendStr::new(value.as_bytes(), false)
    }
}

impl From<String> for ZBox<ZendStr> {
    fn from(value: String) -> Self {
        ZendStr::new(value.as_str(), false)
    }
}

impl From<ZBox<ZendStr>> for Cow<'_, ZendStr> {
    fn from(value: ZBox<ZendStr>) -> Self {
        Cow::Owned(value)
    }
}

impl From<Cow<'_, ZendStr>> for ZBox<ZendStr> {
    fn from(value: Cow<'_, ZendStr>) -> Self {
        value.into_owned()
    }
}

macro_rules! try_into_zval_str {
    ($type: ty) => {
        impl TryFrom<$type> for Zval {
            type Error = Error;

            fn try_from(value: $type) -> Result<Self> {
                let mut zv = Self::new();
                zv.set_string(&value, false)?;
                Ok(zv)
            }
        }

        impl IntoZval for $type {
            const TYPE: DataType = DataType::String;
            const NULLABLE: bool = false;

            fn set_zval(self, zv: &mut Zval, persistent: bool) -> Result<()> {
                zv.set_string(&self, persistent)
            }
        }
    };
}

try_into_zval_str!(String);
try_into_zval_str!(&str);
try_from_zval!(String, string, String);

impl<'a> FromZval<'a> for &'a str {
    const TYPE: DataType = DataType::String;

    fn from_zval(zval: &'a Zval) -> Option<Self> {
        zval.str()
    }
}

#[cfg(test)]
#[cfg(feature = "embed")]
mod tests {
    use crate::embed::Embed;

    #[test]
    fn test_string() {
        Embed::run(|| {
            let result = Embed::eval("'foo';");

            assert!(result.is_ok());

            let zval = result.as_ref().expect("Unreachable");

            assert!(zval.is_string());
            assert_eq!(zval.string(), Some("foo".to_string()));
        });
    }
}

1	//! Represents a string in the PHP world. Similar to a C string, but is
2	//! reference counted and contains the length of the string.
3
4	use std::{
5	borrow::Cow,
6	convert::TryFrom,
7	ffi::{CStr, CString},
8	fmt::Debug,
9	ptr, slice,
10	};
11
12	use parking_lot::{const_mutex, Mutex};
13
14	use crate::{
15	boxed::{ZBox, ZBoxable},
16	convert::{FromZval, IntoZval},
17	error::{Error, Result},
18	ffi::{
19	ext_php_rs_is_known_valid_utf8, ext_php_rs_set_known_valid_utf8,
20	ext_php_rs_zend_string_init, ext_php_rs_zend_string_release, zend_string,
21	zend_string_init_interned,
22	},
23	flags::DataType,
24	macros::try_from_zval,
25	types::Zval,
26	};
27
28	/// A borrowed Zend string.
29	///
30	/// Although this object does implement [`Sized`], it is in fact not sized. As C
31	/// cannot represent unsized types, an array of size 1 is used at the end of the
32	/// type to represent the contents of the string, therefore this type is
33	/// actually unsized. All constructors return [`ZBox<ZendStr>`], the owned
34	/// variant.
35	///
36	/// Once the `ptr_metadata` feature lands in stable rust, this type can
37	/// potentially be changed to a DST using slices and metadata. See the tracking issue here: <https://github.com/rust-lang/rust/issues/81513>
38	pub type ZendStr = zend_string;
39
40	// Adding to the Zend interned string hashtable is not atomic and can be
41	// contested when PHP is compiled with ZTS, so an empty mutex is used to ensure
42	// no collisions occur on the Rust side. Not much we can do about collisions
43	// on the PHP side, but some safety is better than none.
44	static INTERNED_LOCK: Mutex<()> = const_mutex(());
45
46	// Clippy complains about there being no `is_empty` function when implementing
47	// on the alias `ZendStr` :( <https://github.com/rust-lang/rust-clippy/issues/7702>
48	#[allow(clippy::len_without_is_empty)]
49	impl ZendStr {
50	/// Creates a new Zend string from a slice of bytes.
51	///
52	/// # Parameters
53	///
54	/// * `str` - String content.
55	/// * `persistent` - Whether the string should persist through the request
56	/// boundary.
57	///
58	/// # Panics
59	///
60	/// Panics if the function was unable to allocate memory for the Zend
61	/// string.
62	///
63	/// # Safety
64	///
65	/// When passing `persistent` as `false`, the caller must ensure that the
66	/// object does not attempt to live after the request finishes. When a
67	/// request starts and finishes in PHP, the Zend heap is deallocated and a
68	/// new one is created, which would leave a dangling pointer in the
69	/// [`ZBox`].
70	///
71	/// # Example
72	///
73	/// ```no_run
74	/// use ext_php_rs::types::ZendStr;
75	///
76	/// let s = ZendStr::new("Hello, world!", false);
77	/// let php = ZendStr::new([80, 72, 80], false);
78	/// ```
79	pub fn new(str: impl AsRef<[u8]>, persistent: bool) -> ZBox<Self> {	2✔
80	let s = str.as_ref();	2✔
81	// TODO: we should handle the special cases when length is either 0 or 1
82	// see `zend_string_init_fast()` in `zend_string.h`
83	unsafe {
84	let ptr = ext_php_rs_zend_string_init(s.as_ptr().cast(), s.len(), persistent)	2✔
85	.as_mut()
86	.expect("Failed to allocate memory for new Zend string");
87	ZBox::from_raw(ptr)	2✔
88	}
89	}
90
91	/// Creates a new Zend string from a [`CStr`].
92	///
93	/// # Parameters
94	///
95	/// * `str` - String content.
96	/// * `persistent` - Whether the string should persist through the request
97	/// boundary.
98	///
99	/// # Panics
100	///
101	/// Panics if the function was unable to allocate memory for the Zend
102	/// string.
103	///
104	/// # Safety
105	///
106	/// When passing `persistent` as `false`, the caller must ensure that the
107	/// object does not attempt to live after the request finishes. When a
108	/// request starts and finishes in PHP, the Zend heap is deallocated and a
109	/// new one is created, which would leave a dangling pointer in the
110	/// [`ZBox`].
111	///
112	/// # Example
113	///
114	/// ```no_run
115	/// use ext_php_rs::types::ZendStr;
116	/// use std::ffi::CString;
117	///
118	/// let c_s = CString::new("Hello world!").unwrap();
119	/// let s = ZendStr::from_c_str(&c_s, false);
120	/// ```
121	#[must_use]
UNCOV 122	pub fn from_c_str(str: &CStr, persistent: bool) -> ZBox<Self> {	×
123	unsafe {
124	let ptr =	×
125	ext_php_rs_zend_string_init(str.as_ptr(), str.to_bytes().len() as _, persistent);	×
126
127	ZBox::from_raw(
128	ptr.as_mut()	×
129	.expect("Failed to allocate memory for new Zend string"),	×
130	)
131	}
132	}
133
134	/// Creates a new interned Zend string from a slice of bytes.
135	///
136	/// An interned string is only ever stored once and is immutable. PHP stores
137	/// the string in an internal hashtable which stores the interned
138	/// strings.
139	///
140	/// As Zend hashtables are not thread-safe, a mutex is used to prevent two
141	/// interned strings from being created at the same time.
142	///
143	/// Interned strings are not used very often. You should almost always use a
144	/// regular zend string, except in the case that you know you will use a
145	/// string that PHP will already have interned, such as "PHP".
146	///
147	/// # Parameters
148	///
149	/// * `str` - String content.
150	/// * `persistent` - Whether the string should persist through the request
151	/// boundary.
152	///
153	/// # Panics
154	///
155	/// Panics under the following circumstances:
156	///
157	/// * The function used to create interned strings has not been set.
158	/// * The function could not allocate enough memory for the Zend string.
159	///
160	/// # Safety
161	///
162	/// When passing `persistent` as `false`, the caller must ensure that the
163	/// object does not attempt to live after the request finishes. When a
164	/// request starts and finishes in PHP, the Zend heap is deallocated and a
165	/// new one is created, which would leave a dangling pointer in the
166	/// [`ZBox`].
167	///
168	/// # Example
169	///
170	/// ```no_run
171	/// use ext_php_rs::types::ZendStr;
172	///
173	/// let s = ZendStr::new_interned("PHP", true);
174	/// ```
175	pub fn new_interned(str: impl AsRef<[u8]>, persistent: bool) -> ZBox<Self> {	1✔
176	let _lock = INTERNED_LOCK.lock();	1✔
177	let s = str.as_ref();	1✔
178	unsafe {
179	let init = zend_string_init_interned.expect("`zend_string_init_interned` not ready");	1✔
180	let ptr = init(s.as_ptr().cast(), s.len() as _, persistent)	1✔
181	.as_mut()
182	.expect("Failed to allocate memory for new Zend string");
183	ZBox::from_raw(ptr)	1✔
184	}
185	}
186
187	/// Creates a new interned Zend string from a [`CStr`].
188	///
189	/// An interned string is only ever stored once and is immutable. PHP stores
190	/// the string in an internal hashtable which stores the interned
191	/// strings.
192	///
193	/// As Zend hashtables are not thread-safe, a mutex is used to prevent two
194	/// interned strings from being created at the same time.
195	///
196	/// Interned strings are not used very often. You should almost always use a
197	/// regular zend string, except in the case that you know you will use a
198	/// string that PHP will already have interned, such as "PHP".
199	///
200	/// # Parameters
201	///
202	/// * `str` - String content.
203	/// * `persistent` - Whether the string should persist through the request
204	/// boundary.
205	///
206	/// # Panics
207	///
208	/// Panics under the following circumstances:
209	///
210	/// * The function used to create interned strings has not been set.
211	/// * The function could not allocate enough memory for the Zend string.
212	///
213	/// # Safety
214	///
215	/// When passing `persistent` as `false`, the caller must ensure that the
216	/// object does not attempt to live after the request finishes. When a
217	/// request starts and finishes in PHP, the Zend heap is deallocated and a
218	/// new one is created, which would leave a dangling pointer in the
219	/// [`ZBox`].
220	///
221	/// # Example
222	///
223	/// ```no_run
224	/// use ext_php_rs::types::ZendStr;
225	/// use std::ffi::CString;
226	///
227	/// let c_s = CString::new("PHP").unwrap();
228	/// let s = ZendStr::interned_from_c_str(&c_s, true);
229	/// ```
230	pub fn interned_from_c_str(str: &CStr, persistent: bool) -> ZBox<Self> {	×
231	let _lock = INTERNED_LOCK.lock();	×
232
233	unsafe {
234	let init = zend_string_init_interned.expect("`zend_string_init_interned` not ready");	×
235	let ptr = init(str.as_ptr(), str.to_bytes().len() as _, persistent);	×
236
237	ZBox::from_raw(
238	ptr.as_mut()	×
239	.expect("Failed to allocate memory for new Zend string"),	×
240	)
241	}
242	}
243
244	/// Returns the length of the string.
245	///
246	/// # Example
247	///
248	/// ```no_run
249	/// use ext_php_rs::types::ZendStr;
250	///
251	/// let s = ZendStr::new("hello, world!", false);
252	/// assert_eq!(s.len(), 13);
253	/// ```
254	#[must_use]
255	pub fn len(&self) -> usize {	14✔
256	self.len	14✔
257	}
258
259	/// Returns true if the string is empty, false otherwise.
260	///
261	/// # Example
262	///
263	/// ```no_run
264	/// use ext_php_rs::types::ZendStr;
265	///
266	/// let s = ZendStr::new("hello, world!", false);
267	/// assert_eq!(s.is_empty(), false);
268	/// ```
269	#[must_use]
270	pub fn is_empty(&self) -> bool {	×
271	self.len() == 0	×
272	}
273
274	/// Attempts to return a reference to the underlying bytes inside the Zend
275	/// string as a [`CStr`].
276	///
277	/// # Errors
278	///
279	/// Returns an [`Error::InvalidCString`] variant if the string contains null
280	/// bytes.
281	pub fn as_c_str(&self) -> Result<&CStr> {	×
282	let bytes_with_null =	×
283	unsafe { slice::from_raw_parts(self.val.as_ptr().cast(), self.len() + 1) };	×
284	CStr::from_bytes_with_nul(bytes_with_null).map_err(\|_\| Error::InvalidCString)	×
285	}
286
287	/// Attempts to return a reference to the underlying bytes inside the Zend
288	/// string.
289	///
290	/// # Errors
291	///
292	/// Returns an [`Error::InvalidUtf8`] variant if the [`str`] contains
293	/// non-UTF-8 characters.
294	///
295	/// # Example
296	///
297	/// ```no_run
298	/// use ext_php_rs::types::ZendStr;
299	///
300	/// let s = ZendStr::new("hello, world!", false);
301	/// assert!(s.as_str().is_ok());
302	/// ```
303	pub fn as_str(&self) -> Result<&str> {	14✔
304	if unsafe { ext_php_rs_is_known_valid_utf8(self.as_ptr()) } {	14✔
305	let str = unsafe { std::str::from_utf8_unchecked(self.as_bytes()) };	2✔
306	return Ok(str);	2✔
307	}
308	let str = std::str::from_utf8(self.as_bytes()).map_err(\|_\| Error::InvalidUtf8)?;	12✔
309	unsafe { ext_php_rs_set_known_valid_utf8(self.as_ptr().cast_mut()) };
310	Ok(str)
311	}
312
313	/// Returns a reference to the underlying bytes inside the Zend string.
314	#[must_use]
315	pub fn as_bytes(&self) -> &[u8] {	14✔
316	unsafe { slice::from_raw_parts(self.val.as_ptr().cast(), self.len()) }	14✔
317	}
318
319	/// Returns a raw pointer to this object
320	#[must_use]
321	pub fn as_ptr(&self) -> *const ZendStr {	26✔
322	ptr::from_ref(self)	26✔
323	}
324
325	/// Returns a mutable pointer to this object
326	pub fn as_mut_ptr(&mut self) -> *mut ZendStr {	×
NEW 327	ptr::from_mut(self)	×
328	}
329	}
330
331	unsafe impl ZBoxable for ZendStr {
332	fn free(&mut self) {	×
333	unsafe { ext_php_rs_zend_string_release(self) };	×
334	}
335	}
336
337	impl Debug for ZendStr {
338	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	×
339	self.as_str().fmt(f)	×
340	}
341	}
342
343	impl AsRef<[u8]> for ZendStr {
344	fn as_ref(&self) -> &[u8] {	×
345	self.as_bytes()	×
346	}
347	}
348
349	impl<T> PartialEq<T> for ZendStr
350	where
351	T: AsRef<[u8]>,
352	{
353	fn eq(&self, other: &T) -> bool {	×
354	self.as_ref() == other.as_ref()	×
355	}
356	}
357
358	impl ToOwned for ZendStr {
359	type Owned = ZBox<ZendStr>;
360
361	fn to_owned(&self) -> Self::Owned {	×
362	Self::new(self.as_bytes(), false)	×
363	}
364	}
365
366	impl<'a> TryFrom<&'a ZendStr> for &'a CStr {
367	type Error = Error;
368
369	fn try_from(value: &'a ZendStr) -> Result<Self> {	×
370	value.as_c_str()	×
371	}
372	}
373
374	impl<'a> TryFrom<&'a ZendStr> for &'a str {
375	type Error = Error;
376
377	fn try_from(value: &'a ZendStr) -> Result<Self> {	×
378	value.as_str()	×
379	}
380	}
381
382	impl TryFrom<&ZendStr> for String {
383	type Error = Error;
384
385	fn try_from(value: &ZendStr) -> Result<Self> {	1✔
386	value.as_str().map(ToString::to_string)	1✔
387	}
388	}
389
390	impl<'a> From<&'a ZendStr> for Cow<'a, ZendStr> {
391	fn from(value: &'a ZendStr) -> Self {	×
392	Cow::Borrowed(value)	×
393	}
394	}
395
396	impl From<&CStr> for ZBox<ZendStr> {
397	fn from(value: &CStr) -> Self {	×
398	ZendStr::from_c_str(value, false)	×
399	}
400	}
401
402	impl From<CString> for ZBox<ZendStr> {
403	fn from(value: CString) -> Self {	×
404	ZendStr::from_c_str(&value, false)	×
405	}
406	}
407
408	impl From<&str> for ZBox<ZendStr> {
409	fn from(value: &str) -> Self {	×
410	ZendStr::new(value.as_bytes(), false)	×
411	}
412	}
413
414	impl From<String> for ZBox<ZendStr> {
415	fn from(value: String) -> Self {	×
416	ZendStr::new(value.as_str(), false)	×
417	}
418	}
419
420	impl From<ZBox<ZendStr>> for Cow<'_, ZendStr> {
421	fn from(value: ZBox<ZendStr>) -> Self {	×
422	Cow::Owned(value)	×
423	}
424	}
425
426	impl From<Cow<'_, ZendStr>> for ZBox<ZendStr> {
427	fn from(value: Cow<'_, ZendStr>) -> Self {	×
428	value.into_owned()	×
429	}
430	}
431
432	macro_rules! try_into_zval_str {
433	($type: ty) => {
434	impl TryFrom<$type> for Zval {
435	type Error = Error;
436
437	fn try_from(value: $type) -> Result<Self> {	×
438	let mut zv = Self::new();	×
439	zv.set_string(&value, false)?;	×
440	Ok(zv)	×
441	}
442	}
443
444	impl IntoZval for $type {
445	const TYPE: DataType = DataType::String;
446	const NULLABLE: bool = false;
447
448	fn set_zval(self, zv: &mut Zval, persistent: bool) -> Result<()> {	2✔
449	zv.set_string(&self, persistent)	2✔
450	}
451	}
452	};
453	}
454
455	try_into_zval_str!(String);
456	try_into_zval_str!(&str);
457	try_from_zval!(String, string, String);
458
459	impl<'a> FromZval<'a> for &'a str {
460	const TYPE: DataType = DataType::String;
461
462	fn from_zval(zval: &'a Zval) -> Option<Self> {	×
463	zval.str()	×
464	}
465	}
466
467	#[cfg(test)]
468	#[cfg(feature = "embed")]
469	mod tests {
470	use crate::embed::Embed;
471
472	#[test]
473	fn test_string() {
474	Embed::run(\|\| {
475	let result = Embed::eval("'foo';");
476
477	assert!(result.is_ok());
478
479	let zval = result.as_ref().expect("Unreachable");
480
481	assert!(zval.is_string());
482	assert_eq!(zval.string(), Some("foo".to_string()));
483	});
484	}
485	}

davidcole1340 / ext-php-rs / 14501981872

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous