add foundation files

Author: Mulkave

composer.json

@@ -9,5 +9,10 @@
             "email": "[email protected]"
         }
     ],
-    "require": {}
+    "require": {},
+    "autoload": {
+        "psr-4": {
+            "Lucid\\Foundation": "src/"
+        }
+    }
 }

src/Feature.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Lucid\Foundation;
+
+use ReflectionClass;
+use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
+use App\Domains\Queue\DefaultQueue;
+use Illuminate\Contracts\Bus\SelfHandling;
+use Illuminate\Foundation\Bus\DispatchesJobs;
+
+abstract class Feature implements SelfHandling
+{
+    use MarshalTrait;
+    use DispatchesJobs;
+
+    /**
+     * beautifier function to be called instead of the
+     * laravel function dispatchFromArray.
+     * When the $arguments is an instance of Request
+     * it will call dispatchFrom instead.
+     *
+     * @param string                         $job
+     * @param array|\Illuminate\Http\Request $arguments
+     * @param array                          $extra
+     *
+     * @return mixed
+     */
+    public function run($job, $arguments = [], $extra = [])
+    {
+        if ($arguments instanceof Request) {
+            $result = $this->dispatch($this->marshal($job, $arguments, $extra));
+        } else {
+            if (!is_object($job)) {
+                $job = $this->marshal($job, new Collection(), $arguments);
+            }
+
+            $result = $this->dispatch($job, $arguments);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Run the given job in the given queue.
+     *
+     * @param string     $job
+     * @param array      $arguments
+     * @param Queue|null $queue
+     *
+     * @return mixed
+     */
+    public function runInQueue($job, $arguments, Queue $queue = null)
+    {
+        if (!$queue) {
+            $queue = DefaultQueue::class;
+        }
+
+        // instantiate and queue the job
+        $reflection = new ReflectionClass($job);
+        $jobInstance = $reflection->newInstanceArgs($arguments);
+        $jobInstance->onQueue((string) $queue);
+
+        return $this->dispatch($jobInstance);
+    }
+}

src/Http/Controller.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Lucid\Foundation\Http;
+
+use Lucid\Foundation\ServesFeaturesTrait;
+use Illuminate\Routing\Controller as BaseController;
+use Illuminate\Foundation\Validation\ValidatesRequests;
+
+/**
+ * Base controller.
+ */
+class Controller extends BaseController
+{
+    use ValidatesRequests;
+    use ServesFeaturesTrait;
+}

src/InvalidInputException.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Lucid\Foundation;
+
+use Exception;
+use Illuminate\Validation\Validator as IlluminateValidator;
+
+/**
+ * An exception class that supports validators by extracting their messages
+ * when given, or an array of messages as strings.
+ */
+class InvalidInputException extends Exception
+{
+    public function __construct($message = '', $code = 0, Exception $previous = null)
+    {
+        if ($message instanceof IlluminateValidator) {
+            $message = $message->messages()->all();
+        }
+
+        if (is_array($message)) {
+            $message = implode("\n", $message);
+        }
+
+        parent::__construct($message, $code, $previous);
+    }
+}

src/Job.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Lucid\Foundation;
+
+use Illuminate\Contracts\Bus\SelfHandling;
+
+/**
+ * An abstract Job to be extended by every job.
+ * Note that this job is self-handling which
+ * means it will NOT be queued, rather
+ * will have the "handle()" method
+ * called instead.
+ */
+abstract class Job implements SelfHandling
+{
+}

src/MarshalTrait.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Lucid\Foundation;
+
+use Exception;
+use ArrayAccess;
+use ReflectionClass;
+use ReflectionParameter;
+
+trait MarshalTrait
+{
+    /**
+     * Marshal a command from the given array accessible object.
+     *
+     * @param string       $command
+     * @param \ArrayAccess $source
+     * @param array        $extras
+     *
+     * @return mixed
+     */
+    protected function marshal($command, ArrayAccess $source, array $extras = [])
+    {
+        $injected = [];
+
+        $reflection = new ReflectionClass($command);
+
+        if ($constructor = $reflection->getConstructor()) {
+            $injected = array_map(function ($parameter) use ($command, $source, $extras) {
+                return $this->getParameterValueForCommand($command, $source, $parameter, $extras);
+            }, $constructor->getParameters());
+        }
+
+        return $reflection->newInstanceArgs($injected);
+    }
+
+    /**
+     * Get a parameter value for a marshaled command.
+     *
+     * @param string               $command
+     * @param \ArrayAccess         $source
+     * @param \ReflectionParameter $parameter
+     * @param array                $extras
+     *
+     * @return mixed
+     */
+    protected function getParameterValueForCommand($command, ArrayAccess $source,
+        ReflectionParameter $parameter, array $extras = [])
+    {
+        if (array_key_exists($parameter->name, $extras)) {
+            return $extras[$parameter->name];
+        }
+
+        if (isset($source[$parameter->name])) {
+            return $source[$parameter->name];
+        }
+
+        if ($parameter->isDefaultValueAvailable()) {
+            return $parameter->getDefaultValue();
+        }
+
+        throw new Exception("Unable to map parameter [{$parameter->name}] to command [{$command}]");
+    }
+}

src/Model.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Lucid\Foundation;
+
+use Eloquent;
+
+/**
+ * Base Model.
+ */
+class Model extends Eloquent
+{
+}

src/Providers/RouteServiceProvider.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Lucid\Foundation\Providers;
+
+use Illuminate\Routing\Router;
+use Illuminate\Foundation\Support\Providers\RouteServiceProvider as BaseServiceProvider;
+
+abstract class RouteServiceProvider extends BaseServiceProvider
+{
+    /**
+     * Read the routes from the "routes.php" file of this Service
+     *
+     * @param \Illuminate\Routing\Router $router
+     */
+    abstract public function map(Router $router);
+
+    public function loadRoutesFile($router, $namespace, $path)
+    {
+        $router->group(['namespace' => $namespace], function ($router) use ($path) {
+            if (file_exists($path)) {
+                require $path;
+            }
+        });
+    }
+}

src/QueueableJob.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Lucid\Foundation;
+
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Contracts\Queue\ShouldQueue;
+
+/**
+ * An abstract Job that can be managed with a queue
+ * when extended the job will be queued by default.
+ */
+class QueueableJob extends Job implements ShouldQueue
+{
+    use SerializesModels;
+    use InteractsWithQueue;
+}

src/ServesFeaturesTrait.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Lucid\Foundation;
+
+use Illuminate\Support\Collection;
+use Illuminate\Foundation\Bus\DispatchesJobs;
+
+trait ServesFeaturesTrait
+{
+    use MarshalTrait;
+    use DispatchesJobs;
+
+    /**
+     * Serve the given feature with the given arguments.
+     *
+     * @param \Lucid\Foundation\AbstractFeature $feature
+     * @param array                           $arguments
+     *
+     * @return mixed
+     */
+    public function serve($feature, $arguments = [])
+    {
+        return $this->dispatch($this->marshal($feature, new Collection(), $arguments));
+    }
+}