JDecool\JsonFeed\Reader\Version1\FeedReader

Complexity

Total Complexity

32

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	8	2
A	__construct()	0	4	1
A	readFromJson()	0	9	2
B	readFeedNode()	0	29	6
C	readItemNode()	0	31	8
A	readAuthorNode()	0	15	4
A	readHubNode()	0	7	3
B	readAttachmentNode()	0	20	6

<?php

namespace JDecool\JsonFeed\Reader\Version1;

use DateTime;
use InvalidArgumentException;
use JDecool\JsonFeed\Attachment;
use JDecool\JsonFeed\Author;
use JDecool\JsonFeed\Feed;
use JDecool\JsonFeed\Hub;
use JDecool\JsonFeed\Item;
use JDecool\JsonFeed\Reader\ReaderInterface;
use Symfony\Component\PropertyAccess\PropertyAccess;

class FeedReader implements ReaderInterface
{
    /** @var \Symfony\Component\PropertyAccess\PropertyAccessor */
    private $accessor;

    /** @var FeedReader */
    private static $instance;

    /**
     * Create reader instance
     *
     * @return FeedReader
     */
    public static function create()
    {
        if (null === self::$instance) {
            self::$instance = new self;
        }

        return self::$instance;
    }

    /**
     * Constructor
     */
    private function __construct()
    {
        $this->accessor = PropertyAccess::createPropertyAccessor();
    }

    /**
     * {@inheritdoc}
     */
    public function readFromJson($json)
    {
        $content = json_decode($json, true);
        if (!is_array($content)) {
            throw new InvalidArgumentException('Invalid JSONFeed string');
        }

        return $this->readFeedNode($content);
    }

    /**
     * Browse feed node
     *
     * @param array $content
     * @return Feed
     */
    private function readFeedNode(array $content)
    {
        $feed = new Feed('');

        foreach ($content as $key => $value) {
            if ('version' === $key) {
                continue;
            }

            switch ($key) {
                case 'author':
                    $feed->setAuthor($this->readAuthorNode($value));
                    break;

                case 'hubs':
                    $feed->setHubs(array_map([$this, 'readHubNode'], $value));
                    break;

                case 'items':
                    $feed->setItems(array_map([$this, 'readItemNode'], $value));
                    break;

                default:
                    $this->accessor->setValue($feed, $key, $value);
            }
        }

        return $feed;

The expression return $feed; of type object|array is incompatible with the return type documented by JDecool\JsonFeed\Reader\Version1\FeedReader::readFeedNode of type JDecool\JsonFeed\Feed as it can also be of type array which is not included in this return type.

    }

    /**
     * Browse item node
     *
     * @param array $content
     * @return Item
     */
    private function readItemNode(array $content)
    {
        $id = isset($content['id']) ? $content['id'] : '';

        $item = new Item($id);
        foreach ($content as $key => $value) {
            if ('id' === $key) {
                continue;
            }

            switch ($key) {
                case 'attachments':
                    $item->setAttachments(array_map([$this, 'readAttachmentNode'], $value));
                    break;

                case 'author':
                    $item->setAuthor($this->readAuthorNode($value));
                    break;

                case 'date_published':
                case 'date_modified':
                    $this->accessor->setValue($item, $key, new DateTime($value));
                    break;

                default:
                    $this->accessor->setValue($item, $key, $value);
            }
        }

        return $item;

The expression return $item; of type object|array is incompatible with the return type documented by JDecool\JsonFeed\Reader\Version1\FeedReader::readItemNode of type JDecool\JsonFeed\Item as it can also be of type array which is not included in this return type.

    }

    /**
     * Browse author node
     *
     * @param array $content
     * @return Author
     */
    private function readAuthorNode(array $content)
    {
        $name = (isset($content['name'])) ? $content['name'] : '';

        $author = new Author($name);
        foreach ($content as $key => $value) {
            if ('name' === $key) {
                continue;
            }

            $this->accessor->setValue($author, $key, $value);
        }

        return $author;

The expression return $author; of type object|array is incompatible with the return type documented by JDecool\JsonFeed\Reader\Version1\FeedReader::readAuthorNode of type JDecool\JsonFeed\Author as it can also be of type array which is not included in this return type.

    }

    /**
     * Browse hub node
     *
     * @param array $content
     * @return Hub
     */
    private function readHubNode(array $content)
    {
        $type = isset($content['type']) ? $content['type'] : '';
        $url = isset($content['url']) ? $content['url'] : '';

        return new Hub($type, $url);
    }

    /**
     * Browse attachment node
     *
     * @param array $content
     * @return Attachment
     */
    private function readAttachmentNode(array $content)
    {
        $url = isset($content['url']) ? $content['url'] : '';
        $mimeType = isset($content['mime_type']) ? $content['mime_type'] : '';

        $attachment = new Attachment($url, $mimeType);
        foreach ($content as $key => $value) {
            switch ($key) {
                case 'size_in_bytes':
                    $attachment->setSize($value);
                    break;

                case 'duration_in_seconds':
                    $attachment->setDuration($value);
                    break;
            }
        }

        return $attachment;
    }
}