Mdiyakov\DoctrineSolrBundle\Config\Config

Complexity

Total Complexity

16

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getIndexedEntities()	0	3	1
A	getSolariumClient()	0	3	2
A	getSchemaByName()	0	7	2
A	__construct()	0	27	3
A	getIndexedClasses()	0	3	1
A	getFilters()	0	3	1
A	getClientByEntityClass()	0	3	2
A	getEntityConfig()	0	3	2
A	getSchemaByEntityClass()	0	7	2

<?php

namespace Mdiyakov\DoctrineSolrBundle\Config;

use Mdiyakov\DoctrineSolrBundle\Schema\Schema;

class Config
{

    /**
     * @var \string[][]
     */
    private $indexedEntities;

    /**
     * @var Schema[]
     */
    private $entitySchemaMap = [];

    /**
     * @var string[]
     */
    private $entitiesClasses = [];

    /**
     * @var Schema[]
     */
    private $schemes = [];

    /**
     * @var array|\string[][]
     */
    private $filters = [];

    /**
     * @var array
     */
    private $entitiesConfigMap = [];

    /**
     * @var \string[]
     */
    private $solariumClients;

    /**
     * @param string[][] $indexedEntities
     * @param string[][] $schemes
     * @param string[][] $filters
     * @param string[] $solariumClients
     */
    public function __construct($indexedEntities, $schemes, $filters, $solariumClients)
    {
        $configValidator = new ConfigValidator();
        foreach ($indexedEntities as $entityConfig) {
            $schemaName = $entityConfig['schema'];
            $configValidator->validate($entityConfig, $schemes, $filters, $solariumClients);

$entityConfig of type string[] is incompatible with the type array<mixed,string[]> expected by parameter $entityConfig of Mdiyakov\DoctrineSolrBundle\Config\ConfigValidator::validate().

            /** todo should be moved to some SchemaProvider class */
            if (!isset($this->schemes[$schemaName])) {
                $schema = new Schema(
                    $schemaName,
                    $schemes[$schemaName]['client'],
                    $schemes[$schemaName]['document_unique_field'],

$schemes[$schemaName]['document_unique_field'] of type string is incompatible with the type string[] expected by parameter $documentUniqueFieldConfig of Mdiyakov\DoctrineSolrBundle\Schema\Schema::__construct().

                    $schemes[$schemaName]['fields'],

$schemes[$schemaName]['fields'] of type string is incompatible with the type array<mixed,string[]> expected by parameter $fieldsConfig of Mdiyakov\DoctrineSolrBundle\Schema\Schema::__construct().

                    $schemes[$schemaName]['config_entity_fields']

$schemes[$schemaName]['config_entity_fields'] of type string is incompatible with the type array<mixed,string[]> expected by parameter $configEntityFields of Mdiyakov\DoctrineSolrBundle\Schema\Schema::__construct().

                );
                $this->schemes[$schemaName] = $schema;
            }

            $this->entitySchemaMap[$entityConfig['class']] = $schema;

The variable $schema does not seem to be defined for all execution paths leading up to this point.

            $this->entitiesClasses[$entityConfig['class']] = true;
            $this->entitiesConfigMap[$entityConfig['class']] = $entityConfig;
        }

        $this->filters = $filters;
        $this->indexedEntities = $indexedEntities;

It seems like $indexedEntities of type array<mixed,string[]> is incompatible with the declared type array<mixed,string[]> of property $indexedEntities.

        $this->solariumClients = $solariumClients;

It seems like $solariumClients of type string[] is incompatible with the declared type string[] of property $solariumClients.

    }

    /**
     * @param string $class
     * @return Schema|null
     */
    public function getSchemaByEntityClass($class)
    {
        if (array_key_exists($class, $this->entitySchemaMap)) {
            return $this->entitySchemaMap[$class];
        }

        return null;
    }


    /**
     * @param string $schemaName
     * @return Schema|null
     */
    public function getSchemaByName($schemaName)
    {
        if (array_key_exists($schemaName, $this->schemes)) {
            return $this->schemes[$schemaName];
        }

        return null;
    }

    /**
     * @param string $class
     * @return string|null
     *
     */
    public function getClientByEntityClass($class)
    {
        return array_key_exists($class, $this->entityClientMap) ? $this->entityClientMap[$class] : null;

The property entityClientMap does not exist on Mdiyakov\DoctrineSolrBundle\Config\Config. Did you maybe forget to declare it?

    }

    /**
     * @param $class
     * @return null|\string[][]
     */
    public function getEntityConfig($class)
    {
        return array_key_exists($class, $this->entitiesConfigMap) ? $this->entitiesConfigMap[$class] : null;
    }

    /**
     * @return string[]
     */
    public function getIndexedClasses()
    {
        return array_keys($this->entitiesClasses);
    }

    /**
     * @return array
     */
    public function getIndexedEntities()
    {
        return $this->indexedEntities;
    }

    /**
     * @return array|\string[][]
     */
    public function getFilters()
    {
        return $this->filters;
    }

    /**
     * @param string $clientName
     * @return null|string
     */
    public function getSolariumClient($clientName)
    {
        return  (array_key_exists($clientName, $this->solariumClients)) ? $this->solariumClients[$clientName] : null;

The expression return array_key_exists($clientName, $this->solariumClients) ? $this->solariumClients[$clientName] : null also could return the type string which is incompatible with the documented return type null|string.

    }
}