Build modified streamline images

The official image from streamline does not currently work for the arm64
platform. As a temporary measure, the source code and docker build scripts
have been lifted from the official images and are used to build locally.

Some additional modifications are made to reduce overall image size, these
are documented in docker/README.md

docker/streamline-src/vendor/laravel/tinker/src/ClassAliasAutoloader.php

@@ -0,0 +1,163 @@
+<?php
+
+namespace Laravel\Tinker;
+
+use Illuminate\Support\Str;
+use Psy\Shell;
+
+class ClassAliasAutoloader
+{
+    /**
+     * The shell instance.
+     *
+     * @var \Psy\Shell
+     */
+    protected $shell;
+
+    /**
+     * All of the discovered classes.
+     *
+     * @var array
+     */
+    protected $classes = [];
+
+    /**
+     * Path to the vendor directory.
+     *
+     * @var string
+     */
+    protected $vendorPath;
+
+    /**
+     * Explicitly included namespaces/classes.
+     *
+     * @var \Illuminate\Support\Collection
+     */
+    protected $includedAliases;
+
+    /**
+     * Excluded namespaces/classes.
+     *
+     * @var \Illuminate\Support\Collection
+     */
+    protected $excludedAliases;
+
+    /**
+     * Register a new alias loader instance.
+     *
+     * @param  \Psy\Shell  $shell
+     * @param  string  $classMapPath
+     * @param  array  $includedAliases
+     * @param  array  $excludedAliases
+     * @return static
+     */
+    public static function register(Shell $shell, $classMapPath, array $includedAliases = [], array $excludedAliases = [])
+    {
+        return tap(new static($shell, $classMapPath, $includedAliases, $excludedAliases), function ($loader) {
+            spl_autoload_register([$loader, 'aliasClass']);
+        });
+    }
+
+    /**
+     * Create a new alias loader instance.
+     *
+     * @param  \Psy\Shell  $shell
+     * @param  string  $classMapPath
+     * @param  array  $includedAliases
+     * @param  array  $excludedAliases
+     * @return void
+     */
+    public function __construct(Shell $shell, $classMapPath, array $includedAliases = [], array $excludedAliases = [])
+    {
+        $this->shell = $shell;
+        $this->vendorPath = dirname(dirname($classMapPath));
+        $this->includedAliases = collect($includedAliases);
+        $this->excludedAliases = collect($excludedAliases);
+
+        $classes = require $classMapPath;
+
+        foreach ($classes as $class => $path) {
+            if (! $this->isAliasable($class, $path)) {
+                continue;
+            }
+
+            $name = class_basename($class);
+
+            if (! isset($this->classes[$name])) {
+                $this->classes[$name] = $class;
+            }
+        }
+    }
+
+    /**
+     * Find the closest class by name.
+     *
+     * @param  string  $class
+     * @return void
+     */
+    public function aliasClass($class)
+    {
+        if (Str::contains($class, '\\')) {
+            return;
+        }
+
+        $fullName = $this->classes[$class] ?? false;
+
+        if ($fullName) {
+            $this->shell->writeStdout("[!] Aliasing '{$class}' to '{$fullName}' for this Tinker session.\n");
+
+            class_alias($fullName, $class);
+        }
+    }
+
+    /**
+     * Unregister the alias loader instance.
+     *
+     * @return void
+     */
+    public function unregister()
+    {
+        spl_autoload_unregister([$this, 'aliasClass']);
+    }
+
+    /**
+     * Handle the destruction of the instance.
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        $this->unregister();
+    }
+
+    /**
+     * Whether a class may be aliased.
+     *
+     * @param  string  $class
+     * @param  string  $path
+     */
+    public function isAliasable($class, $path)
+    {
+        if (! Str::contains($class, '\\')) {
+            return false;
+        }
+
+        if (! $this->includedAliases->filter(function ($alias) use ($class) {
+            return Str::startsWith($class, $alias);
+        })->isEmpty()) {
+            return true;
+        }
+
+        if (Str::startsWith($path, $this->vendorPath)) {
+            return false;
+        }
+
+        if (! $this->excludedAliases->filter(function ($alias) use ($class) {
+            return Str::startsWith($class, $alias);
+        })->isEmpty()) {
+            return false;
+        }
+
+        return true;
+    }
+}

docker/streamline-src/vendor/laravel/tinker/src/Console/TinkerCommand.php

@@ -0,0 +1,170 @@
+<?php
+
+namespace Laravel\Tinker\Console;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Env;
+use Laravel\Tinker\ClassAliasAutoloader;
+use Psy\Configuration;
+use Psy\Shell;
+use Psy\VersionUpdater\Checker;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputOption;
+
+class TinkerCommand extends Command
+{
+    /**
+     * Artisan commands to include in the tinker shell.
+     *
+     * @var array
+     */
+    protected $commandWhitelist = [
+        'clear-compiled', 'down', 'env', 'inspire', 'migrate', 'migrate:install', 'optimize', 'up',
+    ];
+
+    /**
+     * The console command name.
+     *
+     * @var string
+     */
+    protected $name = 'tinker';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Interact with your application';
+
+    /**
+     * Execute the console command.
+     *
+     * @return int
+     */
+    public function handle()
+    {
+        $this->getApplication()->setCatchExceptions(false);
+
+        $config = Configuration::fromInput($this->input);
+        $config->setUpdateCheck(Checker::NEVER);
+
+        $config->getPresenter()->addCasters(
+            $this->getCasters()
+        );
+
+        if ($this->option('execute')) {
+            $config->setRawOutput(true);
+        }
+
+        $shell = new Shell($config);
+        $shell->addCommands($this->getCommands());
+        $shell->setIncludes($this->argument('include'));
+
+        $path = Env::get('COMPOSER_VENDOR_DIR', $this->getLaravel()->basePath().DIRECTORY_SEPARATOR.'vendor');
+
+        $path .= '/composer/autoload_classmap.php';
+
+        $config = $this->getLaravel()->make('config');
+
+        $loader = ClassAliasAutoloader::register(
+            $shell, $path, $config->get('tinker.alias', []), $config->get('tinker.dont_alias', [])
+        );
+
+        if ($code = $this->option('execute')) {
+            try {
+                $shell->setOutput($this->output);
+                $shell->execute($code);
+            } finally {
+                $loader->unregister();
+            }
+
+            return 0;
+        }
+
+        try {
+            return $shell->run();
+        } finally {
+            $loader->unregister();
+        }
+    }
+
+    /**
+     * Get artisan commands to pass through to PsySH.
+     *
+     * @return array
+     */
+    protected function getCommands()
+    {
+        $commands = [];
+
+        foreach ($this->getApplication()->all() as $name => $command) {
+            if (in_array($name, $this->commandWhitelist)) {
+                $commands[] = $command;
+            }
+        }
+
+        $config = $this->getLaravel()->make('config');
+
+        foreach ($config->get('tinker.commands', []) as $command) {
+            $commands[] = $this->getApplication()->add(
+                $this->getLaravel()->make($command)
+            );
+        }
+
+        return $commands;
+    }
+
+    /**
+     * Get an array of Laravel tailored casters.
+     *
+     * @return array
+     */
+    protected function getCasters()
+    {
+        $casters = [
+            'Illuminate\Support\Collection' => 'Laravel\Tinker\TinkerCaster::castCollection',
+            'Illuminate\Support\HtmlString' => 'Laravel\Tinker\TinkerCaster::castHtmlString',
+            'Illuminate\Support\Stringable' => 'Laravel\Tinker\TinkerCaster::castStringable',
+        ];
+
+        if (class_exists('Illuminate\Database\Eloquent\Model')) {
+            $casters['Illuminate\Database\Eloquent\Model'] = 'Laravel\Tinker\TinkerCaster::castModel';
+        }
+
+        if (class_exists('Illuminate\Process\ProcessResult')) {
+            $casters['Illuminate\Process\ProcessResult'] = 'Laravel\Tinker\TinkerCaster::castProcessResult';
+        }
+
+        if (class_exists('Illuminate\Foundation\Application')) {
+            $casters['Illuminate\Foundation\Application'] = 'Laravel\Tinker\TinkerCaster::castApplication';
+        }
+
+        $config = $this->getLaravel()->make('config');
+
+        return array_merge($casters, (array) $config->get('tinker.casters', []));
+    }
+
+    /**
+     * Get the console command arguments.
+     *
+     * @return array
+     */
+    protected function getArguments()
+    {
+        return [
+            ['include', InputArgument::IS_ARRAY, 'Include file(s) before starting tinker'],
+        ];
+    }
+
+    /**
+     * Get the console command options.
+     *
+     * @return array
+     */
+    protected function getOptions()
+    {
+        return [
+            ['execute', null, InputOption::VALUE_OPTIONAL, 'Execute the given code using Tinker'],
+        ];
+    }
+}

docker/streamline-src/vendor/laravel/tinker/src/TinkerCaster.php

@@ -0,0 +1,157 @@
+<?php
+
+namespace Laravel\Tinker;
+
+use Exception;
+use Symfony\Component\VarDumper\Caster\Caster;
+
+class TinkerCaster
+{
+    /**
+     * Application methods to include in the presenter.
+     *
+     * @var array
+     */
+    private static $appProperties = [
+        'configurationIsCached',
+        'environment',
+        'environmentFile',
+        'isLocal',
+        'routesAreCached',
+        'runningUnitTests',
+        'version',
+        'path',
+        'basePath',
+        'configPath',
+        'databasePath',
+        'langPath',
+        'publicPath',
+        'storagePath',
+        'bootstrapPath',
+    ];
+
+    /**
+     * Get an array representing the properties of an application.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return array
+     */
+    public static function castApplication($app)
+    {
+        $results = [];
+
+        foreach (self::$appProperties as $property) {
+            try {
+                $val = $app->$property();
+
+                if (! is_null($val)) {
+                    $results[Caster::PREFIX_VIRTUAL.$property] = $val;
+                }
+            } catch (Exception $e) {
+                //
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Get an array representing the properties of a collection.
+     *
+     * @param  \Illuminate\Support\Collection  $collection
+     * @return array
+     */
+    public static function castCollection($collection)
+    {
+        return [
+            Caster::PREFIX_VIRTUAL.'all' => $collection->all(),
+        ];
+    }
+
+    /**
+     * Get an array representing the properties of an html string.
+     *
+     * @param  \Illuminate\Support\HtmlString  $htmlString
+     * @return array
+     */
+    public static function castHtmlString($htmlString)
+    {
+        return [
+            Caster::PREFIX_VIRTUAL.'html' => $htmlString->toHtml(),
+        ];
+    }
+
+    /**
+     * Get an array representing the properties of a fluent string.
+     *
+     * @param  \Illuminate\Support\Stringable  $stringable
+     * @return array
+     */
+    public static function castStringable($stringable)
+    {
+        return [
+            Caster::PREFIX_VIRTUAL.'value' => (string) $stringable,
+        ];
+    }
+
+    /**
+     * Get an array representing the properties of a process result.
+     *
+     * @param  \Illuminate\Process\ProcessResult  $result
+     * @return array
+     */
+    public static function castProcessResult($result)
+    {
+        return [
+            Caster::PREFIX_VIRTUAL.'output' => $result->output(),
+            Caster::PREFIX_VIRTUAL.'errorOutput' => $result->errorOutput(),
+            Caster::PREFIX_VIRTUAL.'exitCode' => $result->exitCode(),
+            Caster::PREFIX_VIRTUAL.'successful' => $result->successful(),
+        ];
+    }
+
+    /**
+     * Get an array representing the properties of a model.
+     *
+     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @return array
+     */
+    public static function castModel($model)
+    {
+        $attributes = array_merge(
+            $model->getAttributes(), $model->getRelations()
+        );
+
+        $visible = array_flip(
+            $model->getVisible() ?: array_diff(array_keys($attributes), $model->getHidden())
+        );
+
+        $hidden = array_flip($model->getHidden());
+
+        $appends = (function () {
+            return array_combine($this->appends, $this->appends); // @phpstan-ignore-line
+        })->bindTo($model, $model)();
+
+        foreach ($appends as $appended) {
+            $attributes[$appended] = $model->{$appended};
+        }
+
+        $results = [];
+
+        foreach ($attributes as $key => $value) {
+            $prefix = '';
+
+            if (isset($visible[$key])) {
+                $prefix = Caster::PREFIX_VIRTUAL;
+            }
+
+            if (isset($hidden[$key])) {
+                $prefix = Caster::PREFIX_PROTECTED;
+            }
+
+            $results[$prefix.$key] = $value;
+        }
+
+        return $results;
+    }
+}

docker/streamline-src/vendor/laravel/tinker/src/TinkerServiceProvider.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Laravel\Tinker;
+
+use Illuminate\Contracts\Support\DeferrableProvider;
+use Illuminate\Foundation\Application as LaravelApplication;
+use Illuminate\Support\ServiceProvider;
+use Laravel\Lumen\Application as LumenApplication;
+use Laravel\Tinker\Console\TinkerCommand;
+
+class TinkerServiceProvider extends ServiceProvider implements DeferrableProvider
+{
+    /**
+     * Boot the service provider.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        $source = realpath($raw = __DIR__.'/../config/tinker.php') ?: $raw;
+
+        if ($this->app instanceof LaravelApplication && $this->app->runningInConsole()) {
+            $this->publishes([$source => $this->app->configPath('tinker.php')]);
+        } elseif ($this->app instanceof LumenApplication) {
+            $this->app->configure('tinker');
+        }
+
+        $this->mergeConfigFrom($source, 'tinker');
+    }
+
+    /**
+     * Register the service provider.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        $this->app->singleton('command.tinker', function () {
+            return new TinkerCommand;
+        });
+
+        $this->commands(['command.tinker']);
+    }
+
+    /**
+     * Get the services provided by the provider.
+     *
+     * @return array
+     */
+    public function provides()
+    {
+        return ['command.tinker'];
+    }
+}