Neomerx\JsonApi\Factories\Factory

Complexity

Total Complexity

33

Size/Duplication

Total Lines	356
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	31

Test Coverage

Coverage

100%

Importance

Changes

0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setLogger()	0	4	1
A	createEncoder()	0	8	1
A	createDocument()	0	8	1
A	createError()	0	12	1
A	createReply()	0	4	1
A	createEmptyReply()	0	6	1
A	createParser()	0	8	1
A	createManager()	0	8	1
A	createFrame()	0	4	1
A	createStack()	0	4	1
A	createReplyInterpreter()	0	8	1
A	createParametersAnalyzer()	0	8	1
A	createMediaType()	0	4	1
A	createQueryParameters()	0	17	1
A	createHeaderParameters()	0	4	1
A	createNoContentHeaderParameters()	0	4	1
A	createQueryParametersParser()	0	8	1
A	createHeaderParametersParser()	0	8	1
A	createSortParam()	0	4	1
A	createSupportedExtensions()	0	4	1
A	createAcceptMediaType()	0	10	1
A	createAcceptHeader()	0	4	1
A	createHeadersChecker()	0	4	1
A	createQueryChecker()	0	17	1
A	createContainer()	0	8	1
A	createResourceObject()	0	8	1
A	createRelationshipObject()	0	4	1
A	createLink()	0	4	1
A	createResourceIdentifierSchemaAdapter()	0	4	1
A	createResourceIdentifierContainerAdapter()	0	4	1
A	createIdentitySchema()	0	4	1
A	createCodecMatcher()	0	4	1

<?php namespace Neomerx\JsonApi\Factories;

/**
 * Copyright 2015-2017 info@neomerx.com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use \Closure;
use \Psr\Log\LoggerInterface;
use \Neomerx\JsonApi\Document\Link;
use \Neomerx\JsonApi\Document\Error;
use \Neomerx\JsonApi\Encoder\Encoder;
use \Neomerx\JsonApi\Schema\Container;
use \Neomerx\JsonApi\Document\Document;
use \Neomerx\JsonApi\Codec\CodecMatcher;
use \Neomerx\JsonApi\Encoder\Stack\Stack;
use \Neomerx\JsonApi\Encoder\Parser\Parser;
use \Neomerx\JsonApi\Schema\IdentitySchema;
use \Neomerx\JsonApi\Schema\ResourceObject;
use \Neomerx\JsonApi\Encoder\EncoderOptions;
use \Neomerx\JsonApi\Http\Headers\MediaType;
use \Neomerx\JsonApi\Encoder\Stack\StackFrame;
use \Neomerx\JsonApi\Http\Headers\AcceptHeader;
use \Neomerx\JsonApi\Schema\RelationshipObject;
use \Neomerx\JsonApi\Encoder\Parser\ParserReply;
use \Neomerx\JsonApi\Encoder\Parser\ParserManager;
use \Neomerx\JsonApi\Http\Headers\AcceptMediaType;
use \Neomerx\JsonApi\Http\Headers\HeaderParameters;
use \Neomerx\JsonApi\Encoder\Parser\ParserEmptyReply;
use \Neomerx\JsonApi\Contracts\Document\LinkInterface;
use \Neomerx\JsonApi\Encoder\Parameters\SortParameter;
use \Neomerx\JsonApi\Http\Headers\SupportedExtensions;
use \Neomerx\JsonApi\Http\Query\QueryParametersParser;
use \Neomerx\JsonApi\Encoder\Handlers\ReplyInterpreter;
use \Neomerx\JsonApi\Http\Query\RestrictiveQueryChecker;
use \Neomerx\JsonApi\Contracts\Schema\ContainerInterface;
use \Neomerx\JsonApi\Http\Headers\HeaderParametersParser;
use \Neomerx\JsonApi\Contracts\Document\DocumentInterface;
use \Neomerx\JsonApi\Contracts\Factories\FactoryInterface;
use \Neomerx\JsonApi\Contracts\Codec\CodecMatcherInterface;
use \Neomerx\JsonApi\Encoder\Parameters\EncodingParameters;
use \Neomerx\JsonApi\Encoder\Parameters\ParametersAnalyzer;
use \Neomerx\JsonApi\Http\Headers\RestrictiveHeadersChecker;
use \Neomerx\JsonApi\Schema\ResourceIdentifierSchemaAdapter;
use \Neomerx\JsonApi\Contracts\Http\Headers\HeaderInterface;
use \Neomerx\JsonApi\Contracts\Schema\SchemaProviderInterface;
use \Neomerx\JsonApi\Contracts\Http\Headers\MediaTypeInterface;
use \Neomerx\JsonApi\Schema\ResourceIdentifierContainerAdapter;
use \Neomerx\JsonApi\Contracts\Http\Headers\AcceptHeaderInterface;
use \Neomerx\JsonApi\Contracts\Encoder\Stack\StackReadOnlyInterface;
use \Neomerx\JsonApi\Contracts\Encoder\Parser\ParserManagerInterface;
use \Neomerx\JsonApi\Contracts\Encoder\Stack\StackFrameReadOnlyInterface;
use \Neomerx\JsonApi\Contracts\Encoder\Parameters\EncodingParametersInterface;
use \Neomerx\JsonApi\Contracts\Encoder\Parameters\ParametersAnalyzerInterface;

/**
 * @package Neomerx\JsonApi
 *
 * @SuppressWarnings(PHPMD.TooManyMethods)
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class Factory implements FactoryInterface
{
    /**
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * Constructor.
     */
    public function __construct()
    {
        $this->logger = new ProxyLogger();
    }

    /**
     * @inheritdoc
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger->setLogger($logger);

It seems like you code against a concrete implementation and not the interface Psr\Log\LoggerInterface as the method setLogger() does only exist in the following implementations of said interface: Neomerx\JsonApi\Factories\ProxyLogger.

    }

    /**
     * @inheritdoc
     */
    public function createEncoder(ContainerInterface $container, EncoderOptions $encoderOptions = null)
    {
        $encoder = new Encoder($this, $container, $encoderOptions);

        $encoder->setLogger($this->logger);

        return $encoder;
    }

    /**
     * @inheritdoc
     */
    public function createDocument()
    {
        $document = new Document();

        $document->setLogger($this->logger);

        return $document;
    }

    /**
     * @inheritdoc
     */
    public function createError(
        $idx = null,
        LinkInterface $aboutLink = null,
        $status = null,
        $code = null,
        $title = null,
        $detail = null,
        $source = null,
        array $meta = null
    ) {
        return new Error($idx, $aboutLink, $status, $code, $title, $detail, $source, $meta);
    }
    /**
     * @inheritdoc
     */
    public function createReply($replyType, StackReadOnlyInterface $stack)
    {
        return new ParserReply($replyType, $stack);
    }

    /**
     * @inheritdoc
     */
    public function createEmptyReply(
        $replyType,
        StackReadOnlyInterface $stack
    ) {
        return new ParserEmptyReply($replyType, $stack);
    }

    /**
     * @inheritdoc
     */
    public function createParser(ContainerInterface $container, ParserManagerInterface $manager)
    {
        $parser = new Parser($this, $this, $this, $container, $manager);

        $parser->setLogger($this->logger);

        return $parser;
    }

    /**
     * @inheritdoc
     */
    public function createManager(ParametersAnalyzerInterface $parameterAnalyzer)
    {
        $manager = new ParserManager($parameterAnalyzer);

        $manager->setLogger($this->logger);

        return $manager;
    }

    /**
     * @inheritdoc
     */
    public function createFrame(StackFrameReadOnlyInterface $previous = null)
    {
        return new StackFrame($previous);
    }

    /**
     * @inheritdoc
     */
    public function createStack()
    {
        return new Stack($this);
    }

    /**
     * @inheritdoc
     */
    public function createReplyInterpreter(DocumentInterface $document, ParametersAnalyzerInterface $parameterAnalyzer)
    {
        $interpreter = new ReplyInterpreter($document, $parameterAnalyzer);

        $interpreter->setLogger($this->logger);

        return $interpreter;
    }

    /**
     * @inheritdoc
     */
    public function createParametersAnalyzer(EncodingParametersInterface $parameters, ContainerInterface $container)
    {
        $analyzer = new ParametersAnalyzer($parameters, $container);

        $analyzer->setLogger($this->logger);

        return $analyzer;
    }

    /**
     * @inheritdoc
     */
    public function createMediaType($type, $subType, $parameters = null)
    {
        return new MediaType($type, $subType, $parameters);
    }

    /**
     * @inheritdoc
     */
    public function createQueryParameters(
        $includePaths = null,
        array $fieldSets = null,
        $sortParameters = null,
        array $pagingParameters = null,
        array $filteringParameters = null,
        array $unrecognizedParams = null
    ) {
        return new EncodingParameters(
            $includePaths,
            $fieldSets,
            $sortParameters,
            $pagingParameters,
            $filteringParameters,
            $unrecognizedParams
        );
    }

    /**
     * @inheritdoc
     */
    public function createHeaderParameters($method, AcceptHeaderInterface $accept, HeaderInterface $contentType)
    {
        return new HeaderParameters($method, $accept, $contentType);
    }

    /**
     * @inheritdoc
     */
    public function createNoContentHeaderParameters($method, AcceptHeaderInterface $accept)
    {
        return new HeaderParameters($method, $accept, null);
    }

    /**
     * @inheritdoc
     */
    public function createQueryParametersParser()
    {
        $parser = new QueryParametersParser($this);

        $parser->setLogger($this->logger);

        return $parser;
    }

    /**
     * @inheritdoc
     */
    public function createHeaderParametersParser()
    {
        $parser = new HeaderParametersParser($this);

        $parser->setLogger($this->logger);

        return $parser;
    }

    /**
     * @inheritdoc
     */
    public function createSortParam($sortField, $isAscending)
    {
        return new SortParameter($sortField, $isAscending);
    }

    /**
     * @inheritdoc
     */
    public function createSupportedExtensions($extensions = MediaTypeInterface::NO_EXT)
    {
        return new SupportedExtensions($extensions);
    }

    /**
     * @inheritdoc
     */
    public function createAcceptMediaType(
        $position,
        $type,
        $subType,
        $parameters = null,
        $quality = 1.0,
        $extensions = null
    ) {
        return new AcceptMediaType($position, $type, $subType, $parameters, $quality, $extensions);
    }

    /**
     * @inheritdoc
     */
    public function createAcceptHeader($unsortedMediaTypes)
    {
        return new AcceptHeader($unsortedMediaTypes);
    }

    /**
     * @inheritdoc
     */
    public function createHeadersChecker(CodecMatcherInterface $codecMatcher)
    {
        return new RestrictiveHeadersChecker($codecMatcher);
    }

    /**
     * @inheritdoc
     *
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public function createQueryChecker(
        $allowUnrecognized = true,
        array $includePaths = null,
        array $fieldSetTypes = null,
        array $sortParameters = null,
        array $pagingParameters = null,
        array $filteringParameters = null
    ) {
        return new RestrictiveQueryChecker(
            $allowUnrecognized,
            $includePaths,
            $fieldSetTypes,
            $sortParameters,
            $pagingParameters,
            $filteringParameters
        );
    }

    /**
     * @inheritdoc
     */
    public function createContainer(array $providers = [])
    {
        $container = new Container($this, $providers);

        $container->setLogger($this->logger);

        return $container;
    }

    /**
     * @inheritdoc
     */
    public function createResourceObject(
        SchemaProviderInterface $schema,
        $resource,
        $isInArray,
        $attributeKeysFilter = null
    ) {
        return new ResourceObject($schema, $resource, $isInArray, $attributeKeysFilter);
    }

    /**
     * @inheritdoc
     */
    public function createRelationshipObject($name, $data, $links, $meta, $isShowData, $isRoot)
    {
        return new RelationshipObject($name, $data, $links, $meta, $isShowData, $isRoot);
    }

    /**
     * @inheritdoc
     *
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public function createLink($subHref, $meta = null, $treatAsHref = false)
    {
        return new Link($subHref, $meta, $treatAsHref);
    }

    /**
     * @inheritdoc
     */
    public function createResourceIdentifierSchemaAdapter(SchemaProviderInterface $schema)
    {
        return new ResourceIdentifierSchemaAdapter($this, $schema);
    }

    /**
     * @inheritdoc
     */
    public function createResourceIdentifierContainerAdapter(ContainerInterface $container)
    {
        return new ResourceIdentifierContainerAdapter($this, $container);
    }

    /**
     * @inheritdoc
     */
    public function createIdentitySchema(ContainerInterface $container, $classType, Closure $identityClosure)
    {
        return new IdentitySchema($this, $container, $classType, $identityClosure);
    }

    /**
     * @inheritdoc
     */
    public function createCodecMatcher()
    {
        return new CodecMatcher();
    }
}