public function leaveNode(PhpParser\Node $node)
{
if ($node instanceof PhpParser\Node\Stmt\Class_ || $node instanceof PhpParser\Node\Stmt\Trait_) {
$this->m_numEnteredClassesOrTraits--;
} else {
if ($node instanceof PhpParser\Node\Stmt\Interface_) {
$this->m_numEnteredInterfaces--;
} else {
if ($node instanceof PhpParser\Node\Stmt\ClassMethod) {
$numEnteredMethods = $this->m_numEnteredMethods;
$this->m_numEnteredMethods--;
if (!($this->m_numEnteredClassesOrTraits == 1 && $this->m_numEnteredInterfaces == 0 && $numEnteredMethods == 1 && $this->m_numEnteredClosures == 0 && $this->m_numEnteredFunctions == 0)) {
return;
}
$method = $node;
if ($method->isProtected() && !$this->m_wrapProtectedMethods && !$this->m_isTrait || $method->isPrivate() && !$this->m_wrapPrivateMethods && !$this->m_isTrait || $method->isAbstract()) {
return;
}
if (!isset($method->stmts) || CMap::isEmpty($method->stmts)) {
return;
}
$hasParams = false;
$params = CArray::make();
$hasParamsByRef = false;
$paramsByRef = CArray::make();
if (isset($method->params) && !CMap::isEmpty($method->params)) {
$hasParams = true;
$params = CArray::fromPArray($method->params);
$paramsByRef = CArray::filter($params, function ($param) {
return $param->byRef;
});
$hasParamsByRef = !CArray::isEmpty($paramsByRef);
}
$method->stmts[0]->setAttribute("_imFirstStmtInMethodOrFunction", true);
$method->stmts[CMap::length($method->stmts) - 1]->setAttribute("_imLastStmtInMethodOrFunction", true);
$statements = [$method];
$methodFirstLastStmtVisitor = new CMethodOrFunctionFirstLastStmtVisitor($hasParams, $params, $hasParamsByRef, $paramsByRef);
$traverser = new PhpParser\NodeTraverser();
$traverser->addVisitor($methodFirstLastStmtVisitor);
$statements = $traverser->traverse($statements);
$method = $statements[0];
$returnVisitor = new CReturnVisitor($hasParams, $params, $hasParamsByRef, $paramsByRef, $method->byRef, CReturnVisitor::SUBJ_METHOD);
$traverser = new PhpParser\NodeTraverser();
$traverser->addVisitor($returnVisitor);
$statements = $traverser->traverse($statements);
return $statements;
} else {
if ($node instanceof PhpParser\Node\Expr\Closure) {
$this->m_numEnteredClosures--;
} else {
if ($node instanceof PhpParser\Node\Stmt\Function_) {
$this->m_numEnteredFunctions--;
}
}
}
}
}
}
public function testFilter()
{
$array = CArray::fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
$array = CArray::filter($array, function ($element) {
return CMathi::isEven($element);
});
$this->assertTrue(CArray::equals($array, CArray::fromElements(2, 4, 6, 8, 10)));
}
protected static function recurseListItems($directoryPath, $sort)
{
$items = self::listItems($directoryPath, $sort);
$dirs = CArray::filter($items, "CFile::isDirectory");
$dirQty = CArray::length($dirs);
for ($i = 0; $i < $dirQty; $i++) {
CArray::pushArray($items, self::recurseListItems($dirs[$i], $sort));
}
return $items;
}
protected function addHeaderWithoutOverriding($headers, $headerName, $value)
{
$headerLine;
$headerName = CString::trim($headerName);
$value = CString::trim($value);
$foundHeaderPos;
$alreadyExists = CArray::find($headers, $headerName, function ($element0, $element1) {
return CRegex::find($element0, "/^\\h*" . CRegex::enterTd($element1) . "\\h*:/i");
}, $foundHeaderPos);
if (!$alreadyExists) {
$headerLine = "{$headerName}: {$value}";
} else {
// The header already exists. Combine the header values, removing duplicates based on case-insensitive
// equality.
$currValue = CRegex::remove($headers[$foundHeaderPos], "/^.*?:\\h*/");
CArray::remove($headers, $foundHeaderPos);
$values = CString::split("{$currValue}, {$value}", ",");
$len = CArray::length($values);
for ($i = 0; $i < $len; $i++) {
$values[$i] = CString::trim($values[$i]);
}
$values = CArray::filter($values, function ($element) {
return !CString::isEmpty($element);
});
$values = CArray::unique($values, function ($element0, $element1) {
return CString::equalsCi($element0, $element1);
});
$combinedValue = CArray::join($values, ", ");
$headerLine = "{$headerName}: {$combinedValue}";
}
CArray::push($headers, $headerLine);
}
/**
* Filters the elements in an array by calling a function or method on each element and returns a new array with
* only those elements that were let through by the filter.
*
* The array is not modified by this method.
*
* @param callable $filter The function or method to be used for filtering. The filter should take an element as
* a parameter and return `true` if the element should make its way into the resulting array and `false` if not.
*
* @return CArrayObject The filtered array.
*/
public function filter($filter)
{
return self::fromSplArray(CArray::filter($this->m_splArray, $filter));
}
