Hhxsv5\LaravelS\Illuminate\Laravel

Complexity

Total Complexity

44

Size/Duplication

Total Lines	250
Duplicated Lines	0 %

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getRawGlobals()	0	3	1
A	configureLumen()	0	20	4
A	createStaticResponse()	0	6	1
A	isLumen()	0	3	1
A	fireEvent()	0	5	2
A	lookupIndex()	0	10	3
A	saveSession()	0	4	2
A	bindRequest()	0	3	1
A	clean()	0	3	1
A	__construct()	0	9	3
A	prepareLaravel()	0	10	1
B	handleDynamic()	0	43	8
A	autoload()	0	7	2
A	handleStatic()	0	20	5
A	createAppKernel()	0	24	5
A	bindSwoole()	0	4	1
A	saveSnapshot()	0	8	3

<?php

namespace Hhxsv5\LaravelS\Illuminate;

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;
use Symfony\Component\HttpFoundation\StreamedResponse;

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

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

    /**@var ReflectionApp */
    protected $reflectionApp;

    /**@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 = [];

    /**@var CleanerManager */
    protected $cleanerManager;

    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();

        $this->reflectionApp = new ReflectionApp($this->app);

        $this->saveSnapshot();

        // Create cleaner manager
        $this->cleanerManager = new CleanerManager($this->app, $this->conf);
    }

    protected function saveSnapshot()
    {
        $this->snapshotApp = clone $this->app;

        $instances = $this->reflectionApp->instances();

        foreach ($instances as $key => $value) {
            $this->snapshotApp->offsetSet($key, is_object($value) ? clone $value : $value);
        }
    }

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

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

        // Load all Configurations for Lumen
        if ($this->isLumen()) {
            $this->configureLumen($app);
        }

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

        return [$app, $kernel];
    }

    protected function configureLumen(Container $app)
    {
        $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);

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

        }
    }

    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->isLumen()) {
            $response = $this->app->dispatch($request);

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

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

            $this->reflectionApp->callTerminableMiddleware($response);
        } else {
            $response = $this->kernel->handle($request);
            if ($response instanceof StreamedResponse) {

$response is never a sub-type of Symfony\Component\HttpFoundation\StreamedResponse.

                $content = '';
                $response = $response->sendContent();
            } else {
                $content = $response->getContent();
            }
            $this->kernel->terminate($request, $response);
        }

        // prefer content in response, secondly ob
        if (strlen($content) === 0 && ob_get_length() > 0) {
            $obContent = ob_get_contents();
            if ($response instanceof StreamedResponse) {
                $reflect = new \ReflectionClass(StreamedResponse::class);
                $contentProperty = $reflect->getProperty('content');
                $contentProperty->setAccessible(true);
                $contentProperty->setValue($response, $obContent);
            } else {
                $response->setContent($obContent);
            }
        }

        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;
    }

    public function clean()
    {
        $this->cleanerManager->clean($this->snapshotApp, $this->reflectionApp);
    }

    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 saveSession()
    {
        if ($this->app->offsetExists('session')) {
            $this->app['session']->save();
        }
    }

    protected function isLumen()
    {
        return $this->conf['is_lumen'];
    }
}