MultiPart::getChildCount() - Code Metrics - Inspection of "2.0" - zbateson/mail-mime-parser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#171)

by Zaahid

created 2021-08-23 02:11 UTC

MultiPart::getChildCount() A

↳ Parent: MultiPart

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
cc	1
nc	1
nop	1
crap	1

<?php
/**
 * This file is part of the ZBateson\MailMimeParser project.
 *
 * @license http://opensource.org/licenses/bsd-license.php BSD
 */
namespace ZBateson\MailMimeParser\Message;

use ZBateson\MailMimeParser\MailMimeParser;
use ZBateson\MailMimeParser\Message\PartStreamContainer;
use ZBateson\MailMimeParser\Message\PartFilter;
use Iterator;
use AppendIterator;
use ArrayIterator;
use RecursiveIteratorIterator;

/**
 * A message part that contains children.
 *
 * @author Zaahid Bateson
 */
abstract class MultiPart extends MessagePart implements IMultiPart
{
    /**
     * @var PartChildrenContainer child part container
     */
    protected $partChildrenContainer;

    public function __construct(
        IMimePart $parent = null,
        PartStreamContainer $streamContainer = null,
        PartChildrenContainer $partChildrenContainer = null
    ) {
        parent::__construct($streamContainer, $parent);
        parent::__construct(/** @scrutinizer ignore-type */ $streamContainer, $parent);
        if ($partChildrenContainer === null) {
            $di = MailMimeParser::getDependencyContainer();
            $partChildrenContainer = $di['ZBateson\MailMimeParser\Message\PartChildrenContainer'];
        }
        $this->partChildrenContainer = $partChildrenContainer;
    }

    private function getAllPartsIterator()
    {
        $iter = new AppendIterator();
        $iter->append(new ArrayIterator([ $this ]));
        $iter->append(new RecursiveIteratorIterator($this->partChildrenContainer, RecursiveIteratorIterator::SELF_FIRST));
        return $iter;
    }

    private function iteratorFindAt(Iterator $iter, $index, $fnFilter = null)
    {
        $pos = 0;
        foreach ($iter as $part) {
            if (($fnFilter === null || $fnFilter($part))) {
                if ($index === $pos) {
                    return $part;
                }
                ++$pos;
            }
        }
    }

    public function getPart($index, $fnFilter = null)
    {
        return $this->iteratorFindAt(
            $this->getAllPartsIterator(),
            $index,
            $fnFilter
        );
    }

    public function getAllParts($fnFilter = null)
    {
        $array = iterator_to_array($this->getAllPartsIterator(), false);
        if ($fnFilter !== null) {
            return array_values(array_filter($array, $fnFilter));
        }
        return $array;
    }

    public function getPartCount($fnFilter = null)
    {
        return count($this->getAllParts($fnFilter));
    }

    public function getChild($index, $fnFilter = null)
    {
        return $this->iteratorFindAt(
            $this->partChildrenContainer,
            $index,
            $fnFilter
        );
    }

    public function getChildIterator()
    {
        return $this->partChildrenContainer;
    }

    public function getChildParts($fnFilter = null)
    {
        $array = iterator_to_array($this->partChildrenContainer, false);
        if ($fnFilter !== null) {
            return array_values(array_filter($array, $fnFilter));
        }
        return $array;
    }

    public function getChildCount($fnFilter = null)
    {
        return count($this->getChildParts($fnFilter));
    }

    public function getPartByMimeType($mimeType, $index = 0)
    {
        return $this->getPart($index, PartFilter::fromContentType($mimeType));
    }

    public function getAllPartsByMimeType($mimeType)
    {
        return $this->getAllParts(PartFilter::fromContentType($mimeType));
    }

    public function getCountOfPartsByMimeType($mimeType)
    {
        return $this->getPartCount(PartFilter::fromContentType($mimeType));
    }

    public function getPartByContentId($contentId)
    {
        $sanitized = preg_replace('/^\s*<|>\s*$/', '', $contentId);
        return $this->getPart(0, function (IMessagePart $part) use ($sanitized) {
            $cid = $part->getContentId();
            return ($cid !== null && strcasecmp($cid, $sanitized) === 0);
        });
    }

    public function addChild(IMessagePart $part, $position = null)
    {
        if ($part !== $this) {

            $part->parent = $this;

            $this->partChildrenContainer->add($part, $position);
            $this->notify();
        }
    }

    public function removePart(IMessagePart $part)
    {
        $parent = $part->getParent();
        if ($this !== $parent && $parent !== null) {
            return $parent->removePart($part);
        } else {
            $position = $this->partChildrenContainer->remove($part);
            if ($position !== null) {

                $this->notify();
            }
            return $position;
        }
    }

    public function removeAllParts($fnFilter = null)
    {
        $parts = $this->getAllParts($fnFilter);
        $count = count($parts);
        foreach ($parts as $part) {
            if ($part === $this) {
                --$count;
                continue;
            }
            $this->removePart($part);
        }
        return $count;
    }
}


zbateson / mail-mime-parser

Pull Request — master (#171)

MultiPart::getChildCount() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like