Swift_Mime_SimpleHeaderSet

Complexity

Total Complexity

57

Size/Duplication

Total Lines	443
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

79.86%

Importance

Changes	11
Bugs	3	Features	1

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	setCharset()	0	8	2
A	addMailboxHeader()	0	4	1
A	addDateHeader()	0	4	1
A	addTextHeader()	0	4	1
A	addParameterizedHeader()	0	4	1
A	addIdHeader()	0	4	1
A	has()	0	10	2
A	set()	0	4	1
A	get()	0	8	2
A	getAll()	0	18	4
A	remove()	0	12	3
A	removeAll()	0	5	1
A	newInstance()	0	4	1
A	charsetChanged()	0	4	1
A	__toString()	0	4	1
A	_storeHeader()	0	14	3
A	_canSort()	0	4	1
A	_notifyHeadersOfCharset()	0	9	3
A	addPathHeader()	0	4	1
A	listAll()	0	9	2
A	defineOrdering()	0	4	1
A	setAlwaysDisplayed()	0	4	1
B	toString()	0	18	6
B	_sortHeaders()	0	20	9
A	_isDisplayed()	0	8	2
A	__clone()	0	10	3

<?php

/*
 * This file is part of SwiftMailer.
 * (c) 2004-2009 Chris Corbyn
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/**
 * A collection of MIME headers.
 *
 * @author Chris Corbyn
 */
class Swift_Mime_SimpleHeaderSet implements Swift_Mime_HeaderSet

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    /**
     * HeaderFactory
     *
     * @var Swift_Mime_HeaderFactory
     */
    private $_factory;

    /**
     * Collection of set Headers
     *
     * @var array[]
     */
    private $_headers = array();

    /**
     * Field ordering details
     *
     * @var array
     */
    private $_order = array();

    /**
     * List of fields which are required to be displayed
     *
     * @var array
     */
    private $_required = array();

    /**
     * The charset used by Headers
     */
    private $_charset;

    /**
     * Create a new SimpleHeaderSet with the given $factory.
     *
     * @param Swift_Mime_HeaderFactory $factory
     * @param string                   $charset
     */
    public function __construct(Swift_Mime_HeaderFactory $factory, $charset = null)
    {
        $this->_factory = $factory;
        if (isset($charset)) {
            $this->setCharset($charset);
        }
    }

    /**
     * Set the charset used by these headers.
     *
     * @param string $charset
     */
    public function setCharset($charset)
    {
        if ($charset) {
            $this->_charset = $charset;
            $this->_factory->charsetChanged($charset);
            $this->_notifyHeadersOfCharset($charset);
        }
    }

    /**
     * Add a new Mailbox Header with a list of $addresses.
     *
     * @param string       $name
     * @param array|string $addresses
     */
    public function addMailboxHeader($name, $addresses = null)
    {
        $this->_storeHeader($name, $this->_factory->createMailboxHeader($name, $addresses));
    }

    /**
     * Add a new Date header using $timestamp (UNIX time).
     *
     * @param string $name
     * @param int    $timestamp
     */
    public function addDateHeader($name, $timestamp = null)
    {
        $this->_storeHeader($name, $this->_factory->createDateHeader($name, $timestamp));
    }

    /**
     * Add a new basic text header with $name and $value.
     *
     * @param string $name
     * @param string $value
     */
    public function addTextHeader($name, $value = null)
    {
        $this->_storeHeader($name, $this->_factory->createTextHeader($name, $value));
    }

    /**
     * Add a new ParameterizedHeader with $name, $value and $params.
     *
     * @param string $name
     * @param string $value
     * @param array  $params
     */
    public function addParameterizedHeader($name, $value = null, $params = array())
    {
        $this->_storeHeader($name, $this->_factory->createParameterizedHeader($name, $value, $params));
    }

    /**
     * Add a new ID header for Message-ID or Content-ID.
     *
     * @param string       $name
     * @param string|array $ids
     */
    public function addIdHeader($name, $ids = null)
    {
        $this->_storeHeader($name, $this->_factory->createIdHeader($name, $ids));
    }

    /**
     * Add a new Path header with an address (path) in it.
     *
     * @param string $name
     * @param string $path
     */
    public function addPathHeader($name, $path = null)
    {
        $this->_storeHeader($name, $this->_factory->createPathHeader($name, $path));
    }

    /**
     * Returns true if at least one header with the given $name exists.
     *
     * If multiple headers match, the actual one may be specified by $index.
     *
     * @param string $name
     * @param int    $index
     *
     * @return bool
     */
    public function has($name, $index = 0)
    {
        $lowerName = Swift::strtolowerWithStaticCache($name);

        if (isset($this->_headers[$lowerName], $this->_headers[$lowerName][$index])) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Set a header in the HeaderSet.
     *
     * The header may be a previously fetched header via {@link get()} or it may
     * be one that has been created separately.
     *
     * If $index is specified, the header will be inserted into the set at this
     * offset.
     *
     * @param Swift_Mime_Header $header
     * @param int               $index
     */
    public function set(Swift_Mime_Header $header, $index = 0)
    {
        $this->_storeHeader($header->getFieldName(), $header, $index);
    }

    /**
     * Get the header with the given $name.
     *
     * If multiple headers match, the actual one may be specified by $index.
     * Returns NULL if none present.
     *
     * @param string $name
     * @param int    $index
     *
     * @return Swift_Mime_Header
     */
    public function get($name, $index = 0)
    {
        if ($this->has($name, $index)) {
            $lowerName = Swift::strtolowerWithStaticCache($name);

            return $this->_headers[$lowerName][$index];
        }
    }

    /**
     * Get all headers with the given $name.
     *
     * @param string $name
     *
     * @return array
     */
    public function getAll($name = null)
    {
        if (!isset($name)) {
            $headers = array();
            foreach ($this->_headers as $collection) {
                $headers = array_merge($headers, $collection);
            }

            return $headers;
        }

        $lowerName = Swift::strtolowerWithStaticCache($name);
        if (!isset($this->_headers[$lowerName])) {
            return array();
        }

        return $this->_headers[$lowerName];
    }

    /**
     * Return the name of all Headers.
     *
     * @return array
     */
    public function listAll()
    {
        $headers = $this->_headers;
        if ($this->_canSort()) {
            uksort($headers, array($this, '_sortHeaders'));
        }

        return array_keys($headers);
    }

    /**
     * Remove the header with the given $name if it's set.
     *
     * If multiple headers match, the actual one may be specified by $index.
     *
     * @param string $name
     * @param int    $index
     */
    public function remove($name, $index = 0)
    {
        $lowerName = Swift::strtolowerWithStaticCache($name);

        if (isset($this->_headers[$lowerName])) {
            array_splice($this->_headers[$lowerName], $index, 1);

            if (empty($this->_headers[$lowerName])) {
                $this->removeAll($lowerName);
            }
        }
    }

    /**
     * Remove all headers with the given $name.
     *
     * @param string $name
     */
    public function removeAll($name)
    {
        $lowerName = Swift::strtolowerWithStaticCache($name);
        unset($this->_headers[$lowerName]);
    }

    /**
     * Create a new instance of this HeaderSet.
     *
     * @return Swift_Mime_HeaderSet
     */
    public function newInstance()
    {
        return new self($this->_factory);
    }

    /**
     * Define a list of Header names as an array in the correct order.
     *
     * These Headers will be output in the given order where present.
     *
     * @param array $sequence
     */
    public function defineOrdering(array $sequence)
    {
        $this->_order = array_flip(array_map(array('Swift' => 'strtolowerWithStaticCache'), $sequence));
    }

    /**
     * Set a list of header names which must always be displayed when set.
     *
     * Usually headers without a field value won't be output unless set here.
     *
     * @param array $names
     */
    public function setAlwaysDisplayed(array $names)
    {
        $this->_required = array_flip(array_map(array('Swift' => 'strtolowerWithStaticCache'), $names));
    }

    /**
     * Notify this observer that the entity's charset has changed.
     *
     * @param string $charset
     */
    public function charsetChanged($charset)
    {
        $this->setCharset($charset);
    }

    /**
     * Returns a string with a representation of all headers.
     *
     * @return string
     */
    public function toString()
    {
        $string = '';
        $headers = $this->_headers;
        if ($this->_canSort()) {
            uksort($headers, array($this, '_sortHeaders'));
        }
        foreach ($headers as $collection) {
            foreach ($collection as $header) {
                /* @var $header Swift_Mime_Header */
                if ($this->_isDisplayed($header) || $header->getFieldBody() != '') {
                    $string .= $header->toString();
                }
            }
        }

        return $string;
    }

    /**
     * Returns a string representation of this object.
     *
     * @return string
     *
     * @see toString()
     */
    public function __toString()
    {
        return $this->toString();
    }

    /**
     * Save a Header to the internal collection
     *
     * @param string            $name
     * @param Swift_Mime_Header $header
     * @param null|int          $offset
     */
    private function _storeHeader($name, Swift_Mime_Header $header, $offset = null)
    {
        $lowerName = Swift::strtolowerWithStaticCache($name);

        if (!isset($this->_headers[$lowerName])) {
            $this->_headers[$lowerName] = array();
        }

        if (!isset($offset)) {
            $this->_headers[$lowerName][] = $header;
        } else {
            $this->_headers[$lowerName][$offset] = $header;
        }
    }

    /** Test if the headers can be sorted */
    private function _canSort()
    {
        return count($this->_order) > 0;
    }

    /**
     * uksort() algorithm for Header ordering
     *
     * @param string $a
     * @param string $b
     *
     * @return int
     */
    private function _sortHeaders($a, $b)
    {
        $lowerA = Swift::strtolowerWithStaticCache($a);
        $lowerB = Swift::strtolowerWithStaticCache($b);
        $aPos = isset($this->_order[$lowerA]) ? $this->_order[$lowerA] : -1;
        $bPos = isset($this->_order[$lowerB]) ? $this->_order[$lowerB] : -1;

        if (-1 === $aPos && -1 === $bPos) {
            // just be sure to be determinist here
            return $a > $b ? -1 : 1;
        }

        if ($aPos === -1) {
            return 1;
        } elseif ($bPos === -1) {
            return -1;
        }

        return $aPos < $bPos ? -1 : 1;
    }

    /**
     * Test if the given Header is always displayed
     *
     * @param Swift_Mime_Header $header
     *
     * @return bool
     */
    private function _isDisplayed(Swift_Mime_Header $header)
    {
        if (isset($this->_required[Swift::strtolowerWithStaticCache($header->getFieldName())])) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Notify all Headers of the new charset
     *
     * @param $charset
     */
    private function _notifyHeadersOfCharset($charset)
    {
        foreach ($this->_headers as $headerGroup) {
            foreach ($headerGroup as $header) {
                /* @var $header Swift_Mime_Header */
                $header->setCharset($charset);
            }
        }
    }

    /**
     * Make a deep copy of object.
     */
    public function __clone()
    {
        $this->_factory = clone $this->_factory;

        foreach ($this->_headers as $groupKey => $headerGroup) {
            foreach ($headerGroup as $key => $header) {
                $this->_headers[$groupKey][$key] = clone $header;
            }
        }
    }
}