FeedIo\Formatter\XmlFormatter

Complexity

Total Complexity

16

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setHeaders()	0	10	2
A	addItem()	0	14	2
A	buildElements()	0	15	3
A	getAllRules()	0	10	2
A	getEmptyDocument()	0	4	1
A	getDocument()	0	6	1
A	toString()	0	6	1
A	toDom()	0	9	1
A	setItems()	0	8	2

<?php
/*
 * This file is part of the feed-io package.
 *
 * (c) Alexandre Debril <alex.debril@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FeedIo\Formatter;

use FeedIo\Feed\NodeInterface;
use FeedIo\FeedInterface;
use FeedIo\Rule\OptionalField;
use FeedIo\RuleSet;
use FeedIo\Standard\XmlAbstract;
use FeedIo\FormatterInterface;

/**
 * Turns a FeedInterface instance into a XML document.
 *
 * Depends on :
 *  - FeedIo\StandardAbstract
 *
 */
class XmlFormatter implements FormatterInterface
{

    /**
     * @var XmlAbstract
     */
    protected $standard;

    /**
     * @param XmlAbstract $standard
     */
    public function __construct(XmlAbstract $standard)
    {
        $this->standard = $standard;
    }

    /**
     * @param  \DOMDocument  $document
     * @param  FeedInterface $feed
     * @return $this
     */
    public function setHeaders(\DOMDocument $document, FeedInterface $feed)
    {
        $rules = $this->standard->getFeedRuleSet();
        $elements = $this->buildElements($rules, $document, $feed);
        foreach ($elements as $element) {
            $this->standard->getMainElement($document)->appendChild($element);
        }

        return $this;
    }

    /**
     * @param  \DOMDocument  $document
     * @param  NodeInterface $node
     * @return $this
     */
    public function addItem(\DOMDocument $document, NodeInterface $node)
    {
        $domItem = $document->createElement($this->standard->getItemNodeName());
        $rules = $this->standard->getItemRuleSet();
        $elements = $this->buildElements($rules, $document, $node);

        foreach ($elements as $element) {
            $domItem->appendChild($element);
        }

        $this->standard->getMainElement($document)->appendChild($domItem);

        return $this;
    }

    /**
     * @param  RuleSet       $ruleSet
     * @param  \DOMDocument  $document
     * @param  NodeInterface $node
     * @return array
     */
    public function buildElements(RuleSet $ruleSet, \DOMDocument $document, NodeInterface $node)
    {
        $rules = $this->getAllRules($ruleSet, $node);
        $elements = array();
        foreach ($rules as $rule) {
            $element = $rule->createElement($document, $node);
            if ($element instanceof \Traversable) {
                $elements = array_merge($elements, iterator_to_array($element));
            } else {
                $elements[] = $element;
            }
        }

        return array_filter($elements);
    }

    /**
     * @param  RuleSet              $ruleSet
     * @param  NodeInterface        $node
     * @return array|\ArrayIterator
     */
    public function getAllRules(RuleSet $ruleSet, NodeInterface $node)
    {
        $rules = $ruleSet->getRules();
        $optionalFields = $node->listElements();
        foreach ($optionalFields as $optionalField) {
            $rules[] = new OptionalField($optionalField);
        }

        return $rules;
    }

    /**
     * @return \DOMDocument
     */
    public function getEmptyDocument()
    {
        return new \DOMDocument('1.0', 'utf-8');
    }

    /**
     * @return \DOMDocument
     */
    public function getDocument()
    {
        $document = $this->getEmptyDocument();

        return $this->standard->format($document);
    }

    /**
     * @param  FeedInterface $feed
     * @return string
     */
    public function toString(FeedInterface $feed)
    {
        $document = $this->toDom($feed);

        return $document->saveXML();
    }

    /**
     * @param  FeedInterface $feed
     * @return \DomDocument
     */
    public function toDom(FeedInterface $feed)
    {
        $document = $this->getDocument();

        $this->setHeaders($document, $feed);
        $this->setItems($document, $feed);

        return $document;
    }

    /**
     * @param  \DOMDocument  $document
     * @param  FeedInterface $feed
     * @return $this
     */
    public function setItems(\DOMDocument $document, FeedInterface $feed)
    {
        foreach ($feed as $item) {
            $this->addItem($document, $item);
        }

        return $this;
    }
}