15788182852

Committed 20 Jun 2025 09:32PM UTC coverage: 22.034%. Remained the same

Build # 15788182852

Build Type

Pull #460

github

Committed by

web-flow

Commit Message

Merge d4fc01bb5 into 660f308c0

Pull Request Pull Request #460: chore(clippy): flowing lifetimes warning and clippy::mut_from_ref

Run Details

6 of 56 new or added lines in 13 files covered. (10.71%)

3 existing lines in 2 files now uncovered.

871 of 3953 relevant lines covered (22.03%)

2.35 hits per line

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

0.0

/src/types/iterable.rs

use super::array::Iter as ZendHashTableIter;
use super::iterator::Iter as ZendIteratorIter;
use crate::convert::FromZval;
use crate::flags::DataType;
use crate::types::{ZendHashTable, ZendIterator, Zval};

/// This type represents a PHP iterable, which can be either an array or an
/// object implementing the Traversable interface.
#[derive(Debug)]
pub enum Iterable<'a> {
    /// Iterable is an Array
    Array(&'a ZendHashTable),
    /// Iterable is a Traversable
    Traversable(&'a mut ZendIterator),
}

impl Iterable<'_> {
    /// Creates a new rust iterator from a PHP iterable.
    /// May return None if a Traversable cannot be rewound.
    // TODO: Check iter not returning iterator
    #[allow(clippy::iter_not_returning_iterator)]
    pub fn iter(&mut self) -> Option<Iter<'_>> {
        match self {
            Iterable::Array(array) => Some(Iter::Array(array.iter())),
            Iterable::Traversable(traversable) => Some(Iter::Traversable(traversable.iter()?)),
        }
    }
}

// TODO: Implement `iter_mut`
#[allow(clippy::into_iter_without_iter)]
impl<'a> IntoIterator for &'a mut Iterable<'a> {
    type Item = (Zval, &'a Zval);
    type IntoIter = Iter<'a>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter().expect("Could not rewind iterator!")
    }
}

impl<'a> FromZval<'a> for Iterable<'a> {
    const TYPE: DataType = DataType::Iterable;

    fn from_zval(zval: &'a Zval) -> Option<Self> {
        if let Some(array) = zval.array() {
            return Some(Iterable::Array(array));
        }

        if let Some(traversable) = zval.traversable() {
            return Some(Iterable::Traversable(traversable));
        }

        None
    }
}

/// Rust iterator over a PHP iterable.
pub enum Iter<'a> {
    Array(ZendHashTableIter<'a>),
    Traversable(ZendIteratorIter<'a>),
}

impl<'a> Iterator for Iter<'a> {
    type Item = (Zval, &'a Zval);

    fn next(&mut self) -> Option<Self::Item> {
        match self {
            Iter::Array(array) => array.next_zval(),
            Iter::Traversable(traversable) => traversable.next(),
        }
    }
}

1	use super::array::Iter as ZendHashTableIter;
2	use super::iterator::Iter as ZendIteratorIter;
3	use crate::convert::FromZval;
4	use crate::flags::DataType;
5	use crate::types::{ZendHashTable, ZendIterator, Zval};
6
7	/// This type represents a PHP iterable, which can be either an array or an
8	/// object implementing the Traversable interface.
9	#[derive(Debug)]
10	pub enum Iterable<'a> {
11	/// Iterable is an Array
12	Array(&'a ZendHashTable),
13	/// Iterable is a Traversable
14	Traversable(&'a mut ZendIterator),
15	}
16
17	impl Iterable<'_> {
18	/// Creates a new rust iterator from a PHP iterable.
19	/// May return None if a Traversable cannot be rewound.
20	// TODO: Check iter not returning iterator
21	#[allow(clippy::iter_not_returning_iterator)]
NEW 22	pub fn iter(&mut self) -> Option<Iter<'_>> {	×
23	match self {	×
24	Iterable::Array(array) => Some(Iter::Array(array.iter())),	×
25	Iterable::Traversable(traversable) => Some(Iter::Traversable(traversable.iter()?)),	×
26	}
27	}
28	}
29
30	// TODO: Implement `iter_mut`
31	#[allow(clippy::into_iter_without_iter)]
32	impl<'a> IntoIterator for &'a mut Iterable<'a> {
33	type Item = (Zval, &'a Zval);
34	type IntoIter = Iter<'a>;
35
36	fn into_iter(self) -> Self::IntoIter {	×
37	self.iter().expect("Could not rewind iterator!")	×
38	}
39	}
40
41	impl<'a> FromZval<'a> for Iterable<'a> {
42	const TYPE: DataType = DataType::Iterable;
43
44	fn from_zval(zval: &'a Zval) -> Option<Self> {	×
45	if let Some(array) = zval.array() {	×
46	return Some(Iterable::Array(array));	×
47	}
48
49	if let Some(traversable) = zval.traversable() {	×
50	return Some(Iterable::Traversable(traversable));	×
51	}
52
53	None	×
54	}
55	}
56
57	/// Rust iterator over a PHP iterable.
58	pub enum Iter<'a> {
59	Array(ZendHashTableIter<'a>),
60	Traversable(ZendIteratorIter<'a>),
61	}
62
63	impl<'a> Iterator for Iter<'a> {
64	type Item = (Zval, &'a Zval);
65
66	fn next(&mut self) -> Option<Self::Item> {	×
67	match self {	×
68	Iter::Array(array) => array.next_zval(),	×
69	Iter::Traversable(traversable) => traversable.next(),	×
70	}
71	}
72	}

davidcole1340 / ext-php-rs / 15788182852

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