Balloon\Factory\BalloonFactory

Complexity

Total Complexity

9

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes	6
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	3
A	create()	0	9	2
A	json()	0	8	1
A	yml()	0	13	1
A	getClassName()	0	4	1
A	instantiate()	0	18	1

<?php
namespace Balloon\Factory;

use Balloon\Balloon;
use Balloon\Reader\Factory\FileReaderFactory;
use Balloon\Reader\Factory\IFileReaderFactory;
use Balloon\Reader\IFileReader;
use Balloon\Format\Json;
use Balloon\Format\Yaml;
use Balloon\Mapper\DataMapper;
use Balloon\Mapper\DataMapperDecorator;
use Balloon\Proxy\FileReaderCache;
use Balloon\Proxy\FileReaderProxy;
use ICanBoogie\Inflector;
use JMS\Serializer\Serializer;
use JMS\Serializer\SerializerBuilder;
use Symfony\Component\Yaml\Dumper;
use Symfony\Component\Yaml\Parser;

/**
 * Class BalloonFactory
 * @package Balloon\Factory
 * @author Raphaël Lefebvre <raphael@raphaellefebvre.be>
 */
class BalloonFactory
{
    /**
     * @var IFileReaderFactory
     */
    private $fileReaderBridgeFactory;

    /**
     * @var Serializer
     */
    private $serializer;

    /**
     * @param IFileReaderFactory $fileReaderBridgeFactory

Should the type for parameter $fileReaderBridgeFactory not be null|IFileReaderFactory?

     * @param Serializer $serializer

Should the type for parameter $serializer not be null|Serializer?

     */
    public function __construct(IFileReaderFactory $fileReaderBridgeFactory = null, Serializer $serializer = null)
    {
        $this->fileReaderBridgeFactory = $fileReaderBridgeFactory ? : new FileReaderFactory();
        $this->serializer = $serializer ? : SerializerBuilder::create()->build();
    }

    /**
     * @param string $filePath
     * @param string $className
     * @param string $primaryKey
     * @return Balloon
     */
    public function create($filePath, $className = '', $primaryKey = '')
    {
        $format = pathinfo($filePath, PATHINFO_EXTENSION);
        if(!method_exists($this, $format)){
            throw new \InvalidArgumentException(sprintf('Format %s not supported', $format));
        }

        return $this->$format($filePath, $className, $primaryKey);
    }

    /**
     * @param string $filePath
     * @param string $className
     * @param string $primaryKey
     * @param int $flags

Should the type for parameter $flags not be integer|null?

     * @return Balloon
     */
    public function json($filePath, $className = '', $primaryKey = '', $flags = null)
    {
        return $this->instantiate(
            new Json($this->fileReaderBridgeFactory->create($filePath), $flags),
            $className,
            $primaryKey
        );
    }

    /**
     * @param string $filePath
     * @param string $className
     * @param string $primaryKey
     * @param int $dumpLevel
     * @return Balloon
     */
    public function yml($filePath, $className = '', $primaryKey = '', $dumpLevel = 0)
    {
        return $this->instantiate(
            new Yaml(
                $this->fileReaderBridgeFactory->create($filePath),
                new Parser(),
                new Dumper(),
                $dumpLevel
            ),
            $className,
            $primaryKey
        );
    }

    protected function getClassName()
    {
        return 'Balloon\Balloon';
    }

    /**
     * @param IFileReader $formatDecorator
     * @param string $className
     * @param string $primaryKey
     * @return Balloon
     */
    private function instantiate(IFileReader $formatDecorator, $className, $primaryKey)
    {
        $balloon = $this->getClassName();
        return new $balloon(
            new FileReaderProxy(
                new DataMapperDecorator(
                    $formatDecorator,
                    new DataMapper(
                        $this->serializer,
                        Inflector::get(),
                        $className
                    )
                ),
                new FileReaderCache()
            ),
            $primaryKey
        );
    }
}