MimeParser::canParse() - Code Metrics - Inspection of "Fix tests" - zbateson/mail-mime-parser - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — 2.0 ( 0b4092...91a8b2 )

by Zaahid
created 2021-08-18 20:41 UTC
MimeParser::canParse() A

↳ Parent: MimeParser
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	1
c	0
b	0
f	0
dl	0
loc	3
rs	10
cc	1
nc	1
nop	1
<?php
/**
 * This file is part of the ZBateson\MailMimeParser project.
 *
 * @license http://opensource.org/licenses/bsd-license.php BSD
 */
namespace ZBateson\MailMimeParser\Parser;

use ZBateson\MailMimeParser\Message\PartHeaderContainer;
use ZBateson\MailMimeParser\Message\Factory\PartHeaderContainerFactory;
use ZBateson\MailMimeParser\Parser\Proxy\ParserMessageProxyFactory;
use ZBateson\MailMimeParser\Parser\Proxy\ParserMimePartProxyFactory;
use ZBateson\MailMimeParser\Parser\Proxy\ParserMimePartProxy;
use ZBateson\MailMimeParser\Parser\Proxy\ParserPartProxy;

/**
 * Reads the content of a mime part.
 *
 * @author Zaahid Bateson
 */
class MimeParser extends AbstractParser
{
    /**
     * @var PartBuilderFactory
     */
    protected $partBuilderFactory;

    /**
     * @var PartHeaderContainerFactory
     */
    protected $partHeaderContainerFactory;

    /**
     * @var HeaderParser
     */
    protected $headerParser;

    public function __construct(
        ParserMessageProxyFactory $parserMessageProxyFactory,
        ParserMimePartProxyFactory $parserMimePartProxyFactory,
        PartBuilderFactory $pbf,
        PartHeaderContainerFactory $phcf,
        HeaderParser $hp
    ) {
        parent::__construct($parserMessageProxyFactory, $parserMimePartProxyFactory);
        $this->partBuilderFactory = $pbf;
        $this->partHeaderContainerFactory = $phcf;
        $this->headerParser = $hp;
    }

    public function canParse(PartBuilder $part)
    {
        return $part->isMime();
    }

    /**
     * 
     * @param resource $handle
     * @return string
     */
    private function readBoundaryLine($handle, ParserMimePartProxy $proxy)
    {
        $size = 2048;
        $isCut = false;
        $line = fgets($handle, $size);
        while (strlen($line) === $size - 1 && substr($line, -1) !== "\n") {
            $line = fgets($handle, $size);
            $isCut = true;
        }
        $ret = rtrim($line, "\r\n");
        $proxy->setLastLineEndingLength(strlen($line) - strlen($ret));
        return ($isCut) ? '' : $ret;
    }

    /**
     * Reads lines from the passed $handle, calling
     * $partBuilder->setEndBoundaryFound with the passed line until it returns
     * true or the stream is at EOF.
     *
     * setEndBoundaryFound returns true if the passed line matches a boundary
     * for the $partBuilder itself or any of its parents.
     *
     * Once a boundary is found, setStreamPartAndContentEndPos is called with
     * the passed $handle's read pos before the boundary and its line separator
     * were read.
     *
     * @param PartBuilder $partBuilder
     */
    private function findContentBoundary(ParserMimePartProxy $proxy)
    {
        $handle = $proxy->getMessageResourceHandle();
        // last separator before a boundary belongs to the boundary, and is not
        // part of the current part
        while (!feof($handle)) {
        while (!feof(/** @scrutinizer ignore-type */ $handle)) {
            $endPos = ftell($handle) - $proxy->getLastLineEndingLength();
            $endPos = ftell(/** @scrutinizer ignore-type */ $handle) - $proxy->getLastLineEndingLength();
            $line = $this->readBoundaryLine($handle, $proxy);
            $line = $this->readBoundaryLine(/** @scrutinizer ignore-type */ $handle, $proxy);
            if (substr($line, 0, 2) === '--' && $proxy->setEndBoundaryFound($line)) {
                $proxy->setStreamPartAndContentEndPos($endPos);
                return;
            }
        }
        $proxy->setStreamPartAndContentEndPos(ftell($handle));
        $proxy->setEof();
    }

    public function parseContent(ParserPartProxy $proxy)
    {
        $proxy->setStreamContentStartPos($proxy->getMessageResourceHandlePos());
        $this->findContentBoundary($proxy);
    }

    /**
     * Checks if the new child part is just content past the end boundary
     *
     * @param ParserProxy $proxy
filter:
    dependency_paths: ["lib/*"]
     * @param PartBuilder $parent
     * @param PartBuilder $child
     */
    private function createPart(PartHeaderContainer $headerContainer, PartBuilder $child)
    {
        $parentProxy = $child->getParent();
        if ($parentProxy === null || !$parentProxy->isEndBoundaryFound()) {
        if ($parentProxy === null || !$parentProxy->/** @scrutinizer ignore-call */ isEndBoundaryFound()) {
            $this->headerParser->parse(
                $child->getMessageResourceHandle(),
                /** @scrutinizer ignore-type */ $child->getMessageResourceHandle(),
                $headerContainer
            );
            $parserProxy = $this->parserManager->createParserProxyFor($child);
            return $parserProxy;
        } else {
            // reads content past an end boundary if there is any
            $parserProxy = $this->parserPartProxyFactory->newInstance($child, $this);
            $this->parseContent($parserProxy);
            return null;
        }
    }

    /**
     * Returns true if there are more parts
     *
     * @param PartBuilder $partBuilder
     * @return ParserPartProxy
     */
    public function parseNextChild(ParserMimePartProxy $proxy)
    {
        if ($proxy->isParentBoundaryFound()) {
            return null;
        }
        $headerContainer = $this->partHeaderContainerFactory->newInstance();
        $child = $this->partBuilderFactory->newChildPartBuilder($headerContainer, $proxy);
        return $this->createPart($headerContainer, $child);
    }
}

zbateson / mail-mime-parser

Push — 2.0 ( 0b4092...91a8b2 )

MimeParser::canParse() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
