CuyZ\Notiz\Core\Definition\DefinitionService

Complexity

Total Complexity

9

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getValidationResult()	0	5	1
A	getDefinition()	0	12	2
A	getDefinitionArray()	0	12	2
A	buildDefinitionObject()	0	15	3

<?php
declare(strict_types=1);

/*
 * Copyright (C)
 * Nathan Boiron <nathan.boiron@gmail.com>
 * Romain Canon <romain.hydrocanon@gmail.com>
 *
 * This file is part of the TYPO3 NotiZ project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace CuyZ\Notiz\Core\Definition;

use CuyZ\Notiz\Core\Definition\Builder\DefinitionBuilder;
use CuyZ\Notiz\Core\Definition\Tree\Definition;
use CuyZ\Notiz\Core\Exception\InvalidDefinitionException;
use CuyZ\Notiz\Service\RuntimeService;
use CuyZ\Notiz\Service\Traits\ExtendedSelfInstantiateTrait;
use Romm\ConfigurationObject\ConfigurationObjectInstance;
use Throwable;
use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Extbase\Error\Result;

The type TYPO3\CMS\Extbase\Error\Result was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Root definition service, that can be used to get the definition object used
 * everywhere in this extension.
 *
 * A validation process is done on the object to check if all its properties and
 * sub-properties are valid. Use the code below to check for errors:
 *
 * ```
 * $validationResult = DefinitionService::get()->getValidationResult();
 *
 * if ($validationResult->hasErrors()) {
 *     // ...
 * } else {
 *     // ...
 * }
 * ```
 *
 * To get the definition object, just use the code below:
 *
 * `DefinitionService::get()->getDefinition()`
 *
 * Please note that if the definition validation failed, an exception will be
 * thrown if you try to access the definition object: you must first check that
 * no errors exist (see above).
 */
class DefinitionService implements SingletonInterface
{
    use ExtendedSelfInstantiateTrait;

    /**
     * @var ConfigurationObjectInstance
     */
    protected $definitionObject;

    /**
     * @var Result
     */
    protected $validationResult;

    /**
     * If an exception/error was thrown during the creation of the definition
     * object, this property is filled with it.
     *
     * @var Throwable
     */
    protected $exception;

    /**
     * @var DefinitionBuilder
     */
    protected $builder;

    /**
     * @var RuntimeService
     */
    protected $runtimeService;

    /**
     * @param DefinitionBuilder $builder
     * @param RuntimeService $runtimeService
     */
    public function __construct(DefinitionBuilder $builder, RuntimeService $runtimeService)
    {
        $this->builder = $builder;
        $this->runtimeService = $runtimeService;
    }

    /**
     * @return Result
     */
    public function getValidationResult(): Result
    {
        $this->buildDefinitionObject();

        return $this->validationResult;
    }

    /**
     * @return Definition
     *
     * @throws InvalidDefinitionException
     */
    public function getDefinition(): Definition
    {
        $this->buildDefinitionObject();

        if ($this->validationResult->hasErrors()) {
            throw InvalidDefinitionException::definitionErrorNoAccess();
        }

        /** @var Definition $definition */
        $definition = $this->definitionObject->getObject();

        return $definition;
    }

    /**
     * Please note that the returned array can not be considered as a valid
     * definition array! You must still check the validation result.
     *
     * @return array
     */
    public function getDefinitionArray(): array
    {
        $this->buildDefinitionObject();

        if ($this->exception) {
            return [];
        }

        /** @var Definition $definition */
        $definition = $this->definitionObject->getObject(true);

        return $definition->toArray();
    }

    /**
     * Calls the builder to get the definition object instance.
     *
     * If an exception/error is thrown during the process, it is catch and added
     * to the runtime service.
     */
    protected function buildDefinitionObject()
    {
        if (null === $this->definitionObject) {
            $this->definitionObject = false;

It seems like false of type false is incompatible with the declared type Romm\ConfigurationObject\ConfigurationObjectInstance of property $definitionObject.

            $exception = null;

The assignment to $exception is dead and can be removed.

            try {
                $this->definitionObject = $this->builder->buildDefinition();
                $this->validationResult = $this->definitionObject->getValidationResult();
            } catch (Throwable $exception) {
                $this->exception = $exception;
                $this->validationResult = new Result;

                $this->runtimeService->setException($exception);
            }
        }
    }
}