Terranet\Administrator\Providers\ContainersServiceProvider

Complexity

Total Complexity

14

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	1	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	registerAdminAnnotations()	0	9	1
A	registerAdminConfig()	0	6	1
A	register()	0	6	2
A	hp$0 ➔ registerAdminTranslations()	0	44	2
	registerAdminSchema()	0	11	?
	registerAdminModel()	0	10	?
	registerAdminTranslations()	0	44	?
A	hp$0 ➔ registerAdminModel()	0	10	3
	registerAdminResource()	0	12	?
A	hp$0 ➔ readonly()	0	7	2
A	hp$0 ➔ setReadonly()	0	5	1
A	hp$0 ➔ registerAdminSchema()	0	11	2
A	hp$0 ➔ registerAdminResource()	0	12	3
A	hp$0 ➔ __construct()	0	3	1

<?php

namespace Terranet\Administrator\Providers;

use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\SimpleAnnotationReader;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Illuminate\Config\Repository as Config;

The type Illuminate\Config\Repository was not found. Maybe you did not declare it correctly or list all dependencies?

use Illuminate\Foundation\Application;

The type Illuminate\Foundation\Application was not found. Maybe you did not declare it correctly or list all dependencies?

use Illuminate\Routing\Router;
use Illuminate\Support\ServiceProvider;
use Terranet\Administrator\Architect;
use Terranet\Administrator\Contracts\Services\Finder;
use Terranet\Administrator\Schema;
use Terranet\Localizer\Locale;

class ContainersServiceProvider extends ServiceProvider
{
    protected $containers = [
        'AdminConfig' => 'scaffold.config',
        'AdminResource' => 'scaffold.module',
        'AdminModel' => 'scaffold.model',
        'AdminSchema' => 'scaffold.schema',
        'AdminTranslations' => 'scaffold.translations',
        'AdminAnnotations' => 'scaffold.annotations',
    ];

    public function register()
    {
        foreach (array_keys($this->containers) as $container) {
            $method = "register{$container}";

            \call_user_func_array([$this, $method], []);
        }
    }

    protected function registerAdminAnnotations()
    {
        $this->app->singleton('scaffold.annotations', function () {
            AnnotationRegistry::registerUniqueLoader('class_exists');

The function Doctrine\Common\Annotations\AnnotationRegistry::registerUniqueLoader() has been deprecated: this method is deprecated and will be removed in doctrine/annotations 2.0

            $reader = new SimpleAnnotationReader();
            $reader->addNamespace('\\Terranet\\Administrator\\Annotations');

            return $reader;
        });
    }

    protected function registerAdminConfig()
    {
        $this->app->singleton('scaffold.config', function ($app) {
            $config = $app['config']['administrator'];

            return new Config((array) $config);
        });
    }

    protected function registerAdminTranslations()
    {
        // Draft: Mui configuration
        // Goal: sometimes there is a case when few content managers (admins) override the same translatable content (files, db, etc...)
        // This service allows to make some locales readonly:
        //  1. they are available in UI in order to preserve the context
        //  2. they are protected from saving process
        // Making locale(s) Readonly remains for Dev's side: the recommended way - use a custom Middleware.
        // ex.: app('scaffold.translations')->setReadonly([1, 2, 3])
        $this->app->singleton('scaffold.translations', function ($app) {
            return new class() {
                protected $readonly = [];

                public function __construct()
                {
                    $this->setReadonly(config('administrator.translations.readonly', []));

The function config was not found. Maybe you did not declare it correctly or list all dependencies?

                }

                /**
                 * Set ReadOnly locales.
                 *
                 * @param  array  $readonly
                 * @return self
                 */
                public function setReadonly(array $readonly = []): self
                {
                    $this->readonly = (array) $readonly;

                    return $this;
                }

                /**
                 * Check if a Locale is ReadOnly.
                 *
                 * @param $locale
                 * @return bool
                 */
                public function readonly($locale)
                {
                    if ($locale instanceof Locale) {
                        $locale = $locale->id();
                    }

                    return \in_array((int) $locale, $this->readonly, true);
                }
            };
        });
    }

    protected function registerAdminResource()
    {
        $this->app->singleton('scaffold.module', function (Application $app) {
            /** @var Router $router */
            $router = $app['router']->current();

            if (in_array($router->getName(), ['scaffold.settings.edit', 'scaffold.settings.update'], true)) {
                return Architect::resourceForKey('settings');
            }

            if ($key = $router->parameter('module')) {
                return Architect::resourceForKey($key);

It seems like $key can also be of type Illuminate\Routing\RouteRegistrar; however, parameter $url of Terranet\Administrator\Architect::resourceForKey() does only seem to accept string, maybe add an additional type check?

            }
        });
    }

    protected function registerAdminModel()
    {
        $this->app->singleton('scaffold.model', function (Application $app) {
            /** @var int $id */
            $id = (int) $app['router']->current()->parameter('id');

            /** @var Finder $finder */
            $finder = app('scaffold.module')->finder();

The function app was not found. Maybe you did not declare it correctly or list all dependencies?

            if ($id && $finder) {
                return $finder->find($id);
            }
        });
    }

    protected function registerAdminSchema()
    {
        $this->app->singleton('scaffold.schema', function (Application $app) {
            /** @var AbstractSchemaManager $schema */
            if ($schema = $app['db']->connection()->getDoctrineSchemaManager()) {
                // fix dbal missing types
                $platform = $schema->getDatabasePlatform();
                $platform->registerDoctrineTypeMapping('enum', 'string');
                $platform->registerDoctrineTypeMapping('set', 'string');

                return new Schema($schema);
            }
        });
    }
}