MimeParser::extractPart() - Code Metrics - Inspection of "some code style" - goetas/to-swift-mime-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 891643...c9f30c )

by Asmir
created 2016-11-17 11:35 UTC
MimeParser::extractPart() B

↳ Parent: MimeParser
Complexity

Conditions	5
Paths	5
Size

Total Lines	18
Code Lines	11
Duplication

Lines	6
Ratio	33.33 %
Code Coverage

Tests	13
CRAP Score	5
Importance

Changes
Metric	Value
dl	6
loc	18
ccs	13
cts	13
cp	1
rs	8.8571
c	0
b	0
f	0
cc	5
eloc	11
nc	5
nop	3
crap	5
<?php

namespace Goetas\Mail\ToSwiftMailParser;

use Goetas\Mail\ToSwiftMailParser\Mime\ContentDecoder;
use Goetas\Mail\ToSwiftMailParser\Mime\HeaderDecoder;

class MimeParser
{
    protected $removeHeaders = array("Received", "From", "X-Original-To", "MIME-Version", "Received-SPF", "Delivered-To");
    protected $allowedHeaders = array("return-path", "subject");
    private $cache;
    private $grammar;
    private $contentDecoder;
    private $headerDecoder;

    public function __construct(array $allowedHeaders = array(), array $removeHeaders = array())
    {
        $this->cache = \Swift_DependencyContainer::getInstance()->lookup('cache');
        $this->grammar = \Swift_DependencyContainer::getInstance()->lookup('mime.grammar');
        $this->contentDecoder = new ContentDecoder ();
        $this->headerDecoder = new HeaderDecoder ();

        $this->allowedHeaders = array_merge($this->allowedHeaders, $allowedHeaders);
        $this->removeHeaders = array_merge($this->removeHeaders, $removeHeaders);
    }

    public function parseString($string, $fillHeaders = false, \Swift_Mime_MimeEntity $message = null)
    {
        $fp = fopen("php://memory", "wb");
        fwrite($fp, $string);
        rewind($fp);
        $message = $this->parseStream($fp, $fillHeaders, $message);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        fclose($fp);
        return $message;
    }

    /**
     *
     * @param stream $stream
     * @param boolean $fillHeaders (default to false)
     * @param \Swift_Mime_MimeEntity $message (default to null)
     * @return Swift_Mime_MimeEntity|\Swift_Message
     */
    public function parseStream($stream, $fillHeaders = false, \Swift_Mime_MimeEntity $message = null)
    {
        $partHeaders = $this->extractHeaders($stream);

        $filteredHeaders = $this->filterHeaders($partHeaders);

        $parts = $this->parseParts($stream, $partHeaders);

        if (!$message) {
            $message = new \Swift_Message ();
        }

        $headers = $this->createHeadersSet($filteredHeaders);

        foreach ($headers->getAll() as $name => $header) {
            if ($fillHeaders || in_array(strtolower($header->getFieldName()), $this->allowedHeaders)) {
                $message->getHeaders()->set($header);
            }
        }
        $this->createMessage($parts, $message);

        return $message;
    }

    protected function extractHeaders($stream)
    {
        $headers = array();
        $hName = null;
        while (!feof($stream)) {
            $row = fgets($stream);
            if ($row == "\r\n" || $row == "\n" || $row == "\r") {
                break;
            }
            if (preg_match('/^([a-z0-9\-]+)\s*:(.*)/i', $row, $mch)) {
                $hName = strtolower($mch [1]);
                if (!in_array($hName, array("content-type", "content-transfer-encoding"))) {
                    $hName = $mch [1];
                }
                $row = $mch [2];
            }
            if (empty($hName)) {
                continue;
            }
            $headers [$hName] [] = trim($row);
        }
        foreach ($headers as $header => $values) {
            $headers [$header] = $this->headerDecoder->decode(trim(implode(" ", $values)));
        }
        return $headers;
    }

    private function filterHeaders(array $headers)
    {
        foreach ($headers as $header => $values) {
            if (in_array(strtolower($header), $this->removeHeaders) && !in_array(strtolower($header), $this->allowedHeaders)) {
                unset ($headers [$header]);
            }
        }
        return $headers;
    }

    protected function parseParts($stream, $partHeaders)
    {
        $parts = array();
        $contentType = $this->extractValueHeader($this->getContentType($partHeaders));

        if (stripos($contentType, 'multipart/') !== false) {
            $headerParts = $this->extractHeaderParts($this->getContentType($partHeaders));
            $boundary = $headerParts ["boundary"];
        } else {
            $boundary = null;
        }

        try {
            // body
            $this->extractPart($stream, $boundary, $this->getTransferEncoding($partHeaders));
        } catch (Exception\EndOfPartReachedException $e) {
            $parts = array(
                "type" => $contentType,
                "headers" => $partHeaders,
                "body" => $e->getData(),
                "boundary" => $boundary,
                "parts" => array()
            );
        }

        if ($boundary) {
            while (!feof($stream)) {
                try {
                    $partHeaders = $this->extractHeaders($stream);
                    $childContentType = $this->extractValueHeader($this->getContentType($partHeaders));

                    if (stripos($childContentType, 'multipart/') !== false) {
                        $parts ["parts"] [] = $this->parseParts($stream, $partHeaders);
                        try {
                            $this->extractPart($stream, $boundary, $this->getTransferEncoding($partHeaders));
                        } catch (Exception\EndOfPartReachedException $e) {

                        }
                    } else {
                        $this->extractPart($stream, $boundary, $this->getTransferEncoding($partHeaders));
                    }
                } catch (Exception\EndOfPartReachedException $e) {
                    $parts ["parts"] [] = array(
                        "type" => $childContentType,
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                        "parent-type" => $contentType,
                        "headers" => $partHeaders,
                        "body" => $e->getData(),
                        "parts" => array()
                    );

                    if ($e instanceof Exception\EndOfMultiPartReachedException) {
                        break;
                    }
                }
            }
        }
        return $parts;
    }

    private function extractValueHeader($header)
    {
        $pos = stripos($header, ';');
        if ($pos !== false) {
            return substr($header, 0, $pos);
        } else {
            return $header;
        }
    }

    private function getContentType(array $partHeaders)
    {
        if (array_key_exists('content-type', $partHeaders)) {
            return $partHeaders['content-type'];
        }

        return '';
    }

    private function extractHeaderParts($header)
    {
        if (stripos($header, ';') !== false) {

            $parts = explode(";", $header);
            array_shift($parts);
            $p = array();
            foreach ($parts as $pv) {
                if (!trim($pv)) {
                    continue;
                }
                list ($k, $v) = explode("=", trim($pv), 2);
                $p [$k] = trim($v, '"');
            }
            return $p;
        } else {
            return array();
        }
    }
    protected function extractPart($stream, $boundary, $encoding)
    {
        $rows = array();
        while (!feof($stream)) {
            $row = fgets($stream);

            if ($boundary !== null) {
                if (strpos($row, "--$boundary--") === 0) {

                    throw new Exception\EndOfMultiPartReachedException ($this->contentDecoder->decode(implode("", $rows), $encoding));
                }
                if (strpos($row, "--$boundary") === 0) {

                    throw new Exception\EndOfPartReachedException ($this->contentDecoder->decode(implode("", $rows), $encoding));
                }
            }
            $rows [] = $row;
        }
        throw new Exception\EndOfMultiPartReachedException ($this->contentDecoder->decode(implode("", $rows), $encoding));
    }

    private function getTransferEncoding(array $partHeaders)
    {
        if (array_key_exists('content-transfer-encoding', $partHeaders)) {
            return $partHeaders ['content-transfer-encoding'];
        }

        return '';
    }

    /**
     *
     * @param array $headersRaw
     * @return \Swift_Mime_HeaderSet
     */
    protected function createHeadersSet(array $headersRaw)
    {
        $headers = \Swift_DependencyContainer::getInstance()->lookup('mime.headerset');

        foreach ($headersRaw as $name => $value) {
            switch (strtolower($name)) {
                case "content-type":
                    $parts = $this->extractHeaderParts($value);
                    unset ($parts ["boundary"]);
                    $headers->addParameterizedHeader($name, $this->extractValueHeader($value), $parts);
                    break;
                case "return-path" :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                    if (preg_match_all('/([a-z][a-z0-9_\-\.]*@[a-z0-9\.\-]*\.[a-z]{2,5})/i', $value, $mch)) {
                        foreach ($mch [0] as $k => $mails) {
                            $headers->addPathHeader($name, $mch [1] [$k]);
                        }
                    }
                    break;
                case "date":
                    $headers->addDateHeader($name, strtotime($value));
                    break;
                case "to":
                case "from":
                case "bcc" :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                case "reply-to":
                case "cc":
                    $adresses = array();
                    if (preg_match_all('/(.*?)<([a-z][a-z0-9_\-\.]*@[a-z0-9\.\-]*\.[a-z]{2,5})>\s*[;,]*/i', $value, $mch)) {
                        foreach ($mch [0] as $k => $mail) {
                            if (!$mch [1] [$k]) {
                                $adresses [$mch [2] [$k]] = trim($mch [2] [$k]);
                            } else {
                                $adresses [$mch [2] [$k]] = trim($mch [1] [$k]);
                            }
                        }
                    } elseif (preg_match_all('/([a-z][a-z0-9_\-\.]*@[a-z0-9\.\-]*\.[a-z]{2,5})/i', $value, $mch)) {
                        foreach ($mch [0] as $k => $mails) {
                            $adresses [$mch [1] [$k]] = trim($mch [1] [$k]);
                        }
                    }
                    $headers->addMailboxHeader($name, $adresses);
                    break;
                default:
                    $headers->addTextHeader($name, $value);
                    break;
            }
        }
        return $headers;
    }

    protected function createMessage(array $message, \Swift_Mime_MimeEntity $entity)
    {
        if (stripos($message ["type"], 'multipart/') !== false) {

            if (strpos($message ["type"], '/alternative')) {
                $nestingLevel = \Swift_Mime_MimeEntity::LEVEL_ALTERNATIVE;
            } elseif (strpos($message ["type"], '/related')) {
                $nestingLevel = \Swift_Mime_MimeEntity::LEVEL_RELATED;
            } elseif (strpos($message ["type"], '/mixed')) {
                $nestingLevel = \Swift_Mime_MimeEntity::LEVEL_MIXED;
            }

            $childrens = array();
            foreach ($message ["parts"] as $part) {

                $headers = $this->createHeadersSet($part ["headers"]);
                $encoder = $this->getEncoder($this->getTransferEncoding($part ["headers"]));

                if (stripos($part ["type"], 'multipart/') !== false) {
                    $newEntity = new \Swift_Mime_MimePart ($headers, $encoder, $this->cache, $this->grammar);
                } else {
                    $newEntity = new \Swift_Mime_SimpleMimeEntity ($headers, $encoder, $this->cache, $this->grammar);
                }

                $this->createMessage($part, $newEntity);

                $ref = new \ReflectionObject ($newEntity);
                $m = $ref->getMethod('_setNestingLevel');
                $m->setAccessible(true);
                $m->invoke($newEntity, $nestingLevel);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}

                $childrens [] = $newEntity;
            }

            $entity->setContentType($part ["type"]);
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.
            $entity->setChildren($childrens);
        } else {
            $entity->setBody($message ["body"], $message ["type"]);
        }
    }

    /**
     *
     * @param string $type
     * @return \Swift_Mime_ContentEncoder
     */
    protected function getEncoder($type)
    {
        switch ($type) {
            case "base64" :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                return \Swift_DependencyContainer::getInstance()->lookup('mime.base64contentencoder');
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case "8bit" :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                return \Swift_DependencyContainer::getInstance()->lookup('mime.8bitcontentencoder');
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case "7bit" :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                return \Swift_DependencyContainer::getInstance()->lookup('mime.7bitcontentencoder');
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            default :
switch ($expr) {
    default : //wrong
        doSomething();
        break;
}

switch ($expr) {
    default: //right
        doSomething();
        break;
}
                return \Swift_DependencyContainer::getInstance()->lookup('mime.qpcontentencoder');
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        }
    }

    /**
     *
     * @param string $path
     *            The file containg a MIME message
     * @return \Swift_Message
     */
    public function parseFile($path, $fillHeaders = false, \Swift_Mime_MimeEntity $message = null)
    {
        $fp = fopen($path, "rb");
        $message = $this->parseStream($fp, $fillHeaders, $message);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        fclose($fp);
        return $message;
    }
}

Push — master ( 891643...c9f30c )

MimeParser::extractPart() B

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

goetas / to-swift-mime-parser

Push — master ( 891643...c9f30c )

MimeParser::extractPart() B

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
