ZBateson\MailMimeParser\Message\MultiPart

Complexity

Total Complexity

31

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Test Coverage

Coverage

97.5%

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getAllPartsByMimeType()	0	3	1
A	getAllPartsIterator()	0	6	1
A	getChildParts()	0	7	2
A	getPartCount()	0	3	1
A	getAllParts()	0	7	2
A	getCountOfPartsByMimeType()	0	3	1
A	__construct()	0	11	2
A	iteratorFindAt()	0	9	5
A	getChild()	0	6	1
A	getPart()	0	6	1
A	getChildCount()	0	3	1
A	getChildIterator()	0	3	1
A	getPartByMimeType()	0	3	1
A	getPartByContentId()	0	6	2
A	removePart()	0	11	4
A	addChild()	0	6	2
A	removeAllParts()	0	12	3

<?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);

It seems like $streamContainer can also be of type null; however, parameter $streamContainer of ZBateson\MailMimeParser\Message\MessagePart::__construct() does only seem to accept ZBateson\MailMimeParser\Message\PartStreamContainer, maybe add an additional type check?

        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) {

The condition $part !== $this is always true.

            $part->parent = $this;

Accessing parent on the interface ZBateson\MailMimeParser\Message\IMessagePart suggest that you code against a concrete implementation. How about adding an instanceof check?

            $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) {

The condition $position !== null is always true.

                $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;
    }
}