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

Test Failed

Pull Request — master (#171)

by Zaahid

created 2021-06-04 17:33 UTC

MultiPart::addChild() A

↳ Parent: MultiPart

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	4
c	1
b	0
f	0
nc	2
nop	2
dl	0
loc	6
rs	10

<?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 MultiPart mime part.
 *
 * @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;
    }

    public function isMultiPart()
    {
        // casting to bool, preg_match returns 1 for true
        return (bool) (preg_match(
            '~multipart/.*~i',
            $this->getContentType()
        ));
    }

    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) {
            return strcasecmp($part->getContentId(), $sanitized) === 0;
            return strcasecmp(/** @scrutinizer ignore-type */ $part->getContentId(), $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)
    {
        foreach ($this->getAllParts($fnFilter) as $part) {
            if ($part === $this) {
                continue;
            }
            $this->removePart($part);
        }
    }
}


zbateson / mail-mime-parser

Pull Request — master (#171)

MultiPart::addChild() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like