first release for the Run Framework

Author: baselrabia

.gitignore

@@ -0,0 +1 @@
+/vendor/

composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "php-run/framework",
+    "description": "Run is a nano-API framework for building awesome small productive and scalable web apps.",
+    "license": "MIT",
+    "autoload": {
+        "psr-4": {
+            "Run\\": "src/"
+        },
+        "files": [
+            "src/Steps/Helper/helpers.php"
+        ]
+    },
+    "authors": [
+        {
+            "name": "baselrabia",
+            "email": "baselrabia@gmail.com"
+        }
+    ],
+    "minimum-stability": "stable",
+    "require": {
+        "symfony/console": "^5.4",
+        "symfony/var-dumper": "^5.4",
+        "illuminate/events": "^9.30",
+        "illuminate/routing": "^9.30",
+        "illuminate/config": "^9.30",
+        "illuminate/container": "^9.30",
+        "laravel-zero/foundation": "^9.26",
+        "filp/whoops": "^2.14",
+        "vlucas/phpdotenv": "^5.4",
+        "illuminate/filesystem": "^9.30",
+        "illuminate/log": "^9.30"
+    }
+}

src/Application.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Run;
+
+use Illuminate\Container\Container;
+use Illuminate\Events\EventServiceProvider;
+use Illuminate\Filesystem\Filesystem;
+use Illuminate\Foundation\Application as BaseApplication;
+use Illuminate\Foundation\PackageManifest;
+use Illuminate\Log\LogServiceProvider;
+use Illuminate\Routing\RoutingServiceProvider;
+
+class Application extends BaseApplication
+{
+
+
+    /**
+     * Create a new Run application instance.
+     *
+     * @param  string|null  $basePath
+     * @return void
+     */
+    public function __construct($basePath = null)
+    {
+
+        if ($basePath) {
+            $this->setBasePath($basePath);
+        }
+
+        $this->registerBaseBindings();
+        $this->registerBaseServiceProviders();
+        $this->registerCoreContainerAliases();
+
+        $this->registerErrorHandling();
+     }
+
+    /**
+     * Bootstrap the application container.
+     *
+     * @return void
+     */
+    protected function registerBaseBindings()
+    {
+        static::setInstance($this);
+
+        $this->instance('app', $this);
+        $this->instance(self::class, $this);
+        $this->instance(Container::class, $this);
+
+        $this->instance('files', new \Illuminate\Filesystem\Filesystem);
+
+        $this->singleton(PackageManifest::class, function () {
+            return new PackageManifest(
+                new Filesystem, $this->basePath(), $this->getCachedPackagesPath()
+            );
+        });
+
+    }
+
+
+
+
+
+    private function registerErrorHandling()
+    {
+        error_reporting(-1);
+
+        $whoops = new \Whoops\Run;
+        $whoops->pushHandler(new \Whoops\Handler\PrettyPageHandler);
+        $whoops->register();
+
+    }
+
+    protected function registerBaseServiceProviders()
+    {
+        $this->register(new EventServiceProvider($this));
+        $this->register(new LogServiceProvider($this));
+        $this->register(new RoutingServiceProvider($this));
+
+    }
+
+
+}

src/Exceptions/Container/BindingResolutionException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Run\Exceptions\Container;
+
+use Exception;
+use Psr\Container\ContainerExceptionInterface;
+
+class BindingResolutionException extends Exception implements ContainerExceptionInterface
+{
+
+}

src/Exceptions/Container/ContainerException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Run\Exceptions\Container;
+
+use Exception;
+use Psr\Container\ContainerExceptionInterface;
+
+class ContainerException extends Exception implements ContainerExceptionInterface
+{
+
+}

src/Exceptions/Container/NotFoundException.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Run\Exceptions\Container;
+
+use Exception;
+use Psr\Container\NotFoundExceptionInterface;
+
+class NotFoundException extends Exception implements NotFoundExceptionInterface
+{
+
+}

src/Exceptions/Handler.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Run\Exceptions;
+
+use Illuminate\Contracts\Debug\ExceptionHandler;
+use Throwable;
+
+class Handler implements ExceptionHandler
+{
+    /**
+     * Report or log an exception.
+     *
+     * @param \Throwable $e
+     * @return void
+     *
+     * @throws \Throwable
+     */
+    public function report(Throwable $e)
+    {
+        // TODO: Implement report() method.
+    }
+
+    /**
+     * Determine if the exception should be reported.
+     *
+     * @param \Throwable $e
+     * @return bool
+     */
+    public function shouldReport(Throwable $e)
+    {
+        // TODO: Implement shouldReport() method.
+    }
+
+    /**
+     * Render an exception into an HTTP response.
+     *
+     * @param \Illuminate\Http\Request $request
+     * @param \Throwable $e
+     * @return \Symfony\Component\HttpFoundation\Response
+     *
+     * @throws \Throwable
+     */
+    public function render($request, Throwable $e)
+    {
+        // TODO: Implement render() method.
+       throw   $e ;
+
+    }
+
+    /**
+     * Render an exception to the console.
+     *
+     * @param \Symfony\Component\Console\Output\OutputInterface $output
+     * @param \Throwable $e
+     * @return void
+     *
+     * @internal This method is not meant to be used or overwritten outside the framework.
+     */
+    public function renderForConsole($output, Throwable $e)
+    {
+        // TODO: Implement renderForConsole() method.
+    }
+}

src/Exceptions/RouteNotFoundException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Run\Exceptions;
+use Exception;
+
+class RouteNotFoundException extends Exception
+{
+
+    protected $message = '404 not found route';
+}

src/Steps/Container/Container.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace Run\Steps\Container;
+
+use Psr\Container\ContainerInterface;
+use Run\Exceptions\Container\ContainerException;
+
+class Container implements ContainerInterface
+{
+    /**
+     * The current globally available container (if any).
+     *
+     * @var static
+     */
+    protected static $instance;
+
+    private array $entries = [];
+
+    /**
+     * Get the globally available instance of the container.
+     *
+     * @return static
+     */
+    public static function getInstance()
+    {
+        if (is_null(static::$instance)) {
+            static::$instance = new static;
+        }
+
+        return static::$instance;
+    }
+
+    /**
+     * Set the shared instance of the container.
+     *
+     */
+    public static function setInstance(ContainerInterface $container = null)
+    {
+        return static::$instance = $container;
+    }
+
+
+
+    /**
+     * Resolve the given type from the container.
+     *
+     * @param  string|callable  $abstract
+     * @param  array  $parameters
+     * @return mixed
+     *
+     * @throws \Run\Exceptions\Container\BindingResolutionException
+     */
+    public function make($abstract, array $parameters = [])
+    {
+        return $this->resolve($abstract, $parameters);
+    }
+
+    public function get(string $id)
+    {
+        if ($this->has($id)) {
+            $entry = $this->entries[$id];
+
+            return $entry($this);
+        }
+
+        return $this->resolve($id);
+    }
+
+    public function has(string $id): bool
+    {
+        return isset($this->entries[$id]);
+    }
+
+    public function set(string $id, callable $concrete): void
+    {
+        $this->entries[$id] = $concrete;
+    }
+
+
+
+    protected function resolve(string $id ,$parameters = [])
+    {
+        //  1. Inspect the class that we are trying to get from the container
+        $reflectionClass = new \ReflectionClass($id);
+
+        if (! $reflectionClass->isInstantiable()) {
+            throw new ContainerException('Class "' . $id . '" is not instantiable');
+        }
+
+        // 2. Inspect the constructor of the class
+        $constructor = $reflectionClass->getConstructor();
+
+        if (! $constructor) {
+            return new $id;
+        }
+
+        // 3. Inspect the constructor parameters (dependencies)
+        $parameters = $constructor->getParameters();
+
+        if (! $parameters) {
+            return new $id;
+        }
+
+        // 4. If the constructor parameter is a class then try to resolve that class using the container
+        $dependencies = array_map(function (\ReflectionParameter $param) use ($id) {
+                $type = $param->getType();
+                $name = $param->getName();
+
+                if (! $type) throw new ContainerException(
+                        'Failed to resolve class "' . $id . '" because param "' . $name . '" is missing a type hint'
+                    );
+
+
+                if ($type instanceof \ReflectionUnionType)  throw new ContainerException(
+                        'Failed to resolve class "' . $id . '" because of union type for param "' . $name . '"'
+                    );
+
+
+                if ($type instanceof \ReflectionNamedType && ! $type->isBuiltin()) {
+                    return $this->get($type->getName());
+                }
+
+                throw new ContainerException(
+                    'Failed to resolve class "' . $id . '" because invalid param "' . $name . '"'
+                );
+            }, $parameters
+        );
+
+        return $reflectionClass->newInstanceArgs($dependencies);
+    }
+}