Kernel::securityEnabled() - Code Metrics - Inspection of "[feature] add Symfony 6 support (#64)" - zenstruck/browser - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — 1.x ( a4b838...b15378 )

by Kevin
created 2021-11-19 18:54 UTC
Kernel::securityEnabled() A

↳ Parent: Kernel
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	3
rs	10
<?php

namespace Zenstruck\Browser\Tests\Fixture;

use Psr\Log\NullLogger;
use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
use Symfony\Bundle\SecurityBundle\SecurityBundle;
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Kernel as BaseKernel;
use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
use Symfony\Component\Routing\RouteCollectionBuilder;
use Symfony\Component\Security\Core\User\InMemoryUser;
use Symfony\Component\Security\Core\User\UserInterface;

/**
 * @author Kevin Bond <[email protected]>
 */
final class Kernel extends BaseKernel
{
    use MicroKernelTrait;


    public function page1(): Response
    {
        return new Response(\file_get_contents(__DIR__.'/files/page1.html'));
    }

    public function page2(): Response
    {
        return new Response('success');
    }

    public function text(): Response
    {
        return new Response('text content', 200, ['Content-Type' => 'text/plain']);
    }

    public function javascript(): Response
    {
        return new Response(\file_get_contents(__DIR__.'/files/javascript.html'));
    }

    public function xml(): Response
    {
        return new Response(\file_get_contents(__DIR__.'/files/xml.xml'), 200, ['Content-Type' => 'text/xml']);
    }

    public function submitForm(Request $request): JsonResponse
    {
        $files = \array_map(
            static function($value) {
                if (\is_array($value)) {
                    return \array_map(fn(UploadedFile $file) => $file->getClientOriginalName(), $value);
                }

                return $value instanceof UploadedFile ? $value->getClientOriginalName() : null;
            },
            $request->files->all()
        );

        return new JsonResponse(\array_merge(
            $request->request->all(),
            \array_filter($files)
        ));
    }

    public function httpMethod(Request $request): Response
    {
        return new JsonResponse([
            'method' => $request->getMethod(),
            'headers' => $request->headers->all(),
            'query' => $request->query->all(),
            'attributes' => $request->attributes->all(),
            'files' => $request->files->all(),
            'server' => $request->server->all(),
            'request' => $request->request->all(),
            'content' => $request->getContent(),
            'ajax' => $request->isXmlHttpRequest(),
        ]);
    }

    public function json(Request $request): JsonResponse
    {
        return new JsonResponse(
            $request->getContent(),
            200,
            ['Content-Type' => $request->query->get('content-type', 'application/json')],
            true
        );
    }

    public function exception(): void
    {
        throw new \Exception('exception thrown');
    }

    public function redirect1(): RedirectResponse
    {
        return new RedirectResponse('/redirect2');
    }

    public function redirect2(): RedirectResponse
    {
        return new RedirectResponse('/redirect3');
    }

    public function redirect3(): RedirectResponse
    {
        return new RedirectResponse('/page1');
    }

    public function user(?UserInterface $user = null): Response
    {
        if ($user) {
            $username = \method_exists($user, 'getUserIdentifier') ? $user->getUserIdentifier() : $user->getUsername();
            $username = \method_exists($user, 'getUserIdentifier') ? $user->getUserIdentifier() : /** @scrutinizer ignore-deprecated */ $user->getUsername();
        }

        return new Response($user ? "user: {$username}/{$user->getPassword()}" : 'anon');

    }

    public function registerBundles(): iterable
    {
        yield new FrameworkBundle();
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}

        if (self::securityEnabled()) {
            yield new SecurityBundle();
        }
    }

    public static function securityEnabled(): bool
    {
        return self::VERSION_ID >= 50300;
    }

    protected function configureContainer(ContainerBuilder $c, LoaderInterface $loader): void
    protected function configureContainer(ContainerBuilder $c, /** @scrutinizer ignore-unused */ LoaderInterface $loader): void
    {
        $c->loadFromExtension('framework', [
            'secret' => 'S3CRET',
            'router' => ['utf8' => true],
            'test' => true,
            'profiler' => ['enabled' => true, 'collect' => true],
        ]);
        $c->register('logger', NullLogger::class); // disable logging

        if (self::securityEnabled()) {
            $c->loadFromExtension('security', [
                'enable_authenticator_manager' => true,
                'password_hashers' => [InMemoryUser::class => 'plaintext'],
                'providers' => ['users' => ['memory' => ['users' => ['kevin' => ['password' => 'pass']]]]],
                'firewalls' => ['main' => []],
            ]);

            $c->loadFromExtension('framework', [
                'session' => ['storage_factory_id' => 'session.storage.factory.mock_file'],
            ]);
        }
    }

    /**
     * @param RouteCollectionBuilder|RoutingConfigurator $routes
     */
    protected function configureRoutes($routes): void
    {
        if ($routes instanceof RouteCollectionBuilder) {
            $routes->add('/page1', 'kernel::page1');
            $routes->add('/page2', 'kernel::page2');
            $routes->add('/text', 'kernel::text');
            $routes->add('/submit-form', 'kernel::submitForm');
            $routes->add('/http-method', 'kernel::httpMethod');
            $routes->add('/exception', 'kernel::exception');
            $routes->add('/redirect1', 'kernel::redirect1');
            $routes->add('/redirect2', 'kernel::redirect2');
            $routes->add('/redirect3', 'kernel::redirect3');
            $routes->add('/json', 'kernel::json');
            $routes->add('/xml', 'kernel::xml');
            $routes->add('/javascript', 'kernel::javascript');
            $routes->add('/user', 'kernel::user');

            return;
        }

        $routes->add('page1', '/page1')->controller('kernel::page1');
        $routes->add('page2', '/page2')->controller('kernel::page2');
        $routes->add('text', '/text')->controller('kernel::text');
        $routes->add('submit-form', '/submit-form')->controller('kernel::submitForm');
        $routes->add('http-method', '/http-method')->controller('kernel::httpMethod');
        $routes->add('exception', '/exception')->controller('kernel::exception');
        $routes->add('redirect1', '/redirect1')->controller('kernel::redirect1');
        $routes->add('redirect2', '/redirect2')->controller('kernel::redirect2');
        $routes->add('redirect3', '/redirect3')->controller('kernel::redirect3');
        $routes->add('json', '/json')->controller('kernel::json');
        $routes->add('xml', '/xml')->controller('kernel::xml');
        $routes->add('javascript', '/javascript')->controller('kernel::javascript');
        $routes->add('user', '/user')->controller('kernel::user');
    }
}

zenstruck / browser

Push — 1.x ( a4b838...b15378 )

Kernel::securityEnabled() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
