Hhxsv5\LaravelS\Illuminate\Laravel

Complexity

Total Complexity

48

Size/Duplication

Total Lines	258
Duplicated Lines	0 %

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getRawGlobals()	0	3	1
B	cleanProviders()	0	20	7
A	make()	0	3	1
A	createStaticResponse()	0	6	1
A	fireEvent()	0	5	2
A	lookupIndex()	0	10	3
A	bindRequest()	0	3	1
A	saveSession()	0	4	2
A	clean()	0	9	2
B	handleDynamic()	0	34	6
A	autoload()	0	7	2
A	handleStatic()	0	20	5
A	bindSwoole()	0	4	1
A	__construct()	0	9	3
A	prepareLaravel()	0	5	1
B	createAppKernel()	0	58	10

<?php

namespace Hhxsv5\LaravelS\Illuminate;

use Hhxsv5\LaravelS\Illuminate\Cleaners\CleanerInterface;
use Illuminate\Container\Container;
use Illuminate\Contracts\Console\Kernel as ConsoleKernel;
use Illuminate\Contracts\Http\Kernel as HttpKernel;
use Illuminate\Http\Request as IlluminateRequest;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpFoundation\Response as SymfonyResponse;

class Laravel
{
    /**@var Container */
    protected $app;

    /**@var Container */
    protected $snapshotApp;

    /**@var HttpKernel */
    protected $kernel;

    /**@var array */
    protected $conf = [];

    /**@var array */
    protected static $staticBlackList = [
        '/index.php'  => 1,
        '/.htaccess'  => 1,
        '/web.config' => 1,
    ];

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

    public function __construct(array $conf = [])
    {
        $this->conf = $conf;

        // Merge $_ENV $_SERVER
        $server = isset($this->conf['_SERVER']) ? $this->conf['_SERVER'] : [];
        $env = isset($this->conf['_ENV']) ? $this->conf['_ENV'] : [];
        $this->rawGlobals['_SERVER'] = array_merge($_SERVER, $server);
        $this->rawGlobals['_ENV'] = array_merge($_ENV, $env);
    }

    public function prepareLaravel()
    {

        list($this->app, $this->kernel) = $this->createAppKernel();
        list($this->snapshotApp,) = $this->createAppKernel();
    }

    public function createAppKernel()
    {
        // Register autoload
        static::autoload($this->conf['root_path']);

        // Make kernel for Laravel
        $kernel = null;
        $app = require $this->conf['root_path'] . '/bootstrap/app.php';
        if (!$this->conf['is_lumen']) {
            $kernel = $app->make(HttpKernel::class);
        }

        // Load all Configurations for Lumen
        if ($this->conf['is_lumen']) {
            $cfgPaths = [
                // Framework default configuration
                $this->conf['root_path'] . '/vendor/laravel/lumen-framework/config/',
                // App configuration
                $this->conf['root_path'] . '/config/',
            ];
            $keys = [];
            foreach ($cfgPaths as $cfgPath) {
                $configs = (array)glob($cfgPath . '*.php');
                foreach ($configs as $config) {
                    $config = substr(basename($config), 0, -4);
                    $keys[$config] = $config;
                }
            }
            foreach ($keys as $key) {
                $app->configure($key);
            }
        }

        // Boot
        if ($this->conf['is_lumen']) {
            if (method_exists($app, 'boot')) {
                $app->boot();
            }
        } else {
            $app->make(ConsoleKernel::class)->bootstrap();
        }

        // Bind singleton cleaners
        foreach ($this->conf['cleaners'] as $cleaner) {
            $app->singleton($cleaner, function ($app) use ($cleaner) {

The parameter $app is not used and could be removed.

                if (!isset(class_implements($cleaner)[CleanerInterface::class])) {
                    throw new \InvalidArgumentException(sprintf(
                            '%s must implement the interface %s',
                            $cleaner,
                            CleanerInterface::class
                        )
                    );
                }
                return new $cleaner();
            });
        }

        return [$app, $kernel];
    }

    public static function autoload($rootPath)
    {
        $autoload = $rootPath . '/bootstrap/autoload.php';
        if (file_exists($autoload)) {
            require_once $autoload;
        } else {
            require_once $rootPath . '/vendor/autoload.php';
        }
    }

    public function getRawGlobals()
    {
        return $this->rawGlobals;
    }

    public function handleDynamic(IlluminateRequest $request)
    {
        ob_start();

        if ($this->conf['is_lumen']) {
            $response = $this->app->dispatch($request);

The method dispatch() does not exist on Illuminate\Container\Container.

            if ($response instanceof SymfonyResponse) {
                $content = $response->getContent();
            } else {
                $content = (string)$response;
            }

            $laravelReflect = new \ReflectionObject($this->app);
            $middleware = $laravelReflect->getProperty('middleware');
            $middleware->setAccessible(true);
            if (!empty($middleware->getValue($this->app))) {
                $callTerminableMiddleware = $laravelReflect->getMethod('callTerminableMiddleware');
                $callTerminableMiddleware->setAccessible(true);
                $callTerminableMiddleware->invoke($this->app, $response);
            }
        } else {
            $response = $this->kernel->handle($request);
            $content = $response->getContent();
            $this->kernel->terminate($request, $response);
        }

        // prefer content in response, secondly ob
        if (strlen($content) === 0 && ob_get_length() > 0) {
            $response->setContent(ob_get_contents());
        }

        ob_end_clean();

        return $response;
    }

    public function handleStatic(IlluminateRequest $request)
    {
        $uri = $request->getRequestUri();
        if (isset(self::$staticBlackList[$uri])) {
            return false;
        }

        $publicPath = $this->conf['static_path'];
        $requestFile = $publicPath . $uri;
        if (is_file($requestFile)) {
            return $this->createStaticResponse($requestFile, $request);
        } elseif (is_dir($requestFile)) {
            $indexFile = $this->lookupIndex($requestFile);
            if ($indexFile === false) {
                return false;
            } else {
                return $this->createStaticResponse($indexFile, $request);
            }
        } else {
            return false;
        }
    }

    protected function lookupIndex($folder)
    {
        $folder = rtrim($folder, '/') . '/';
        foreach (['index.html', 'index.htm'] as $index) {
            $tmpFile = $folder . $index;
            if (is_file($tmpFile)) {
                return $tmpFile;
            }
        }
        return false;
    }

    public function createStaticResponse($requestFile, IlluminateRequest $request)
    {
        $response = new BinaryFileResponse($requestFile);
        $response->prepare($request);
        $response->isNotModified($request);
        return $response;
    }

    protected function cleanProviders(array $providers, $force = false)
    {
        if ($this->conf['is_lumen']) {
            $laravelReflect = new \ReflectionObject($this->app);
            $loadedProviders = $laravelReflect->getProperty('loadedProviders');
            $loadedProviders->setAccessible(true);
            $oldLoadedProviders = $loadedProviders->getValue($this->app);
        }

        foreach ($providers as $provider) {
            if ($force || class_exists($provider, false)) {
                if ($this->conf['is_lumen']) {
                    unset($oldLoadedProviders[get_class(new $provider($this->app))]);
                }
                $this->app->register($provider, [], true);

The method register() does not exist on Illuminate\Container\Container. Are you sure you never get this type here, but always one of the subclasses?

            }
        }

        if ($this->conf['is_lumen']) {
            $loadedProviders->setValue($this->app, $oldLoadedProviders);

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

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

        }
    }

    public function clean()
    {
        foreach ($this->conf['cleaners'] as $cleanerCls) {
            /**@var CleanerInterface $cleaner */
            $cleaner = $this->app->make($cleanerCls);
            $cleaner->clean($this->app, $this->snapshotApp);
        }

        $this->cleanProviders($this->conf['register_providers']);
    }

    public function fireEvent($name, array $params = [])
    {
        $params[] = $this->app;
        return method_exists($this->app['events'], 'dispatch') ?
            $this->app['events']->dispatch($name, $params) : $this->app['events']->fire($name, $params);

The method dispatch() does not exist on Illuminate\Events\Dispatcher.

    }

    public function bindRequest(IlluminateRequest $request)
    {
        $this->app->instance('request', $request);
    }

    public function bindSwoole($swoole)
    {
        $this->app->singleton('swoole', function () use ($swoole) {
            return $swoole;
        });
    }

    public function make($abstract, array $parameters = [])
    {
        return $this->app->make($abstract, $parameters);
    }

    public function saveSession()
    {
        if ($this->app->offsetExists('session')) {
            $this->app['session']->save();
        }
    }
}