create-berna-stencil 1.0.8 → 1.0.10

package/src/api/vendor/vlucas/phpdotenv/src/Repository/Adapter/ReplacingWriter.php

@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Repository\Adapter;
+
+final class ReplacingWriter implements WriterInterface
+{
+    /**
+     * The inner writer to use.
+     *
+     * @var \Dotenv\Repository\Adapter\WriterInterface
+     */
+    private $writer;
+
+    /**
+     * The inner reader to use.
+     *
+     * @var \Dotenv\Repository\Adapter\ReaderInterface
+     */
+    private $reader;
+
+    /**
+     * The record of seen variables.
+     *
+     * @var array<string, string>
+     */
+    private $seen;
+
+    /**
+     * Create a new replacement writer instance.
+     *
+     * @param \Dotenv\Repository\Adapter\WriterInterface $writer
+     * @param \Dotenv\Repository\Adapter\ReaderInterface $reader
+     *
+     * @return void
+     */
+    public function __construct(WriterInterface $writer, ReaderInterface $reader)
+    {
+        $this->writer = $writer;
+        $this->reader = $reader;
+        $this->seen = [];
+    }
+
+    /**
+     * Write to an environment variable, if possible.
+     *
+     * @param non-empty-string $name
+     * @param string           $value
+     *
+     * @return bool
+     */
+    public function write(string $name, string $value)
+    {
+        if ($this->exists($name)) {
+            return $this->writer->write($name, $value);
+        }
+
+        // succeed if nothing to do
+        return true;
+    }
+
+    /**
+     * Delete an environment variable, if possible.
+     *
+     * @param non-empty-string $name
+     *
+     * @return bool
+     */
+    public function delete(string $name)
+    {
+        if ($this->exists($name)) {
+            return $this->writer->delete($name);
+        }
+
+        // succeed if nothing to do
+        return true;
+    }
+
+    /**
+     * Does the given environment variable exist.
+     *
+     * Returns true if it currently exists, or existed at any point in the past
+     * that we are aware of.
+     *
+     * @param non-empty-string $name
+     *
+     * @return bool
+     */
+    private function exists(string $name)
+    {
+        if (isset($this->seen[$name])) {
+            return true;
+        }
+
+        if ($this->reader->read($name)->isDefined()) {
+            $this->seen[$name] = '';
+
+            return true;
+        }
+
+        return false;
+    }
+}

package/src/api/vendor/vlucas/phpdotenv/src/Repository/Adapter/ServerConstAdapter.php

@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Repository\Adapter;
+
+use PhpOption\Option;
+use PhpOption\Some;
+
+final class ServerConstAdapter implements AdapterInterface
+{
+    /**
+     * Create a new server const adapter instance.
+     *
+     * @return void
+     */
+    private function __construct()
+    {
+        //
+    }
+
+    /**
+     * Create a new instance of the adapter, if it is available.
+     *
+     * @return \PhpOption\Option<\Dotenv\Repository\Adapter\AdapterInterface>
+     */
+    public static function create()
+    {
+        /** @var \PhpOption\Option<AdapterInterface> */
+        return Some::create(new self());
+    }
+
+    /**
+     * Read an environment variable, if it exists.
+     *
+     * @param non-empty-string $name
+     *
+     * @return \PhpOption\Option<string>
+     */
+    public function read(string $name)
+    {
+        /** @var \PhpOption\Option<string> */
+        return Option::fromArraysValue($_SERVER, $name)
+            ->filter(static function ($value) {
+                return \is_scalar($value);
+            })
+            ->map(static function ($value) {
+                if ($value === false) {
+                    return 'false';
+                }
+
+                if ($value === true) {
+                    return 'true';
+                }
+
+                return (string) $value;
+            });
+    }
+
+    /**
+     * Write to an environment variable, if possible.
+     *
+     * @param non-empty-string $name
+     * @param string           $value
+     *
+     * @return bool
+     */
+    public function write(string $name, string $value)
+    {
+        $_SERVER[$name] = $value;
+
+        return true;
+    }
+
+    /**
+     * Delete an environment variable, if possible.
+     *
+     * @param non-empty-string $name
+     *
+     * @return bool
+     */
+    public function delete(string $name)
+    {
+        unset($_SERVER[$name]);
+
+        return true;
+    }
+}

package/src/api/vendor/vlucas/phpdotenv/src/Repository/Adapter/WriterInterface.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Repository\Adapter;
+
+interface WriterInterface
+{
+    /**
+     * Write to an environment variable, if possible.
+     *
+     * @param non-empty-string $name
+     * @param string           $value
+     *
+     * @return bool
+     */
+    public function write(string $name, string $value);
+
+    /**
+     * Delete an environment variable, if possible.
+     *
+     * @param non-empty-string $name
+     *
+     * @return bool
+     */
+    public function delete(string $name);
+}

package/src/api/vendor/vlucas/phpdotenv/src/Repository/AdapterRepository.php

@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Repository;
+
+use Dotenv\Repository\Adapter\ReaderInterface;
+use Dotenv\Repository\Adapter\WriterInterface;
+use InvalidArgumentException;
+
+final class AdapterRepository implements RepositoryInterface
+{
+    /**
+     * The reader to use.
+     *
+     * @var \Dotenv\Repository\Adapter\ReaderInterface
+     */
+    private $reader;
+
+    /**
+     * The writer to use.
+     *
+     * @var \Dotenv\Repository\Adapter\WriterInterface
+     */
+    private $writer;
+
+    /**
+     * Create a new adapter repository instance.
+     *
+     * @param \Dotenv\Repository\Adapter\ReaderInterface $reader
+     * @param \Dotenv\Repository\Adapter\WriterInterface $writer
+     *
+     * @return void
+     */
+    public function __construct(ReaderInterface $reader, WriterInterface $writer)
+    {
+        $this->reader = $reader;
+        $this->writer = $writer;
+    }
+
+    /**
+     * Determine if the given environment variable is defined.
+     *
+     * @param string $name
+     *
+     * @return bool
+     */
+    public function has(string $name)
+    {
+        return '' !== $name && $this->reader->read($name)->isDefined();
+    }
+
+    /**
+     * Get an environment variable.
+     *
+     * @param string $name
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return string|null
+     */
+    public function get(string $name)
+    {
+        if ('' === $name) {
+            throw new InvalidArgumentException('Expected name to be a non-empty string.');
+        }
+
+        return $this->reader->read($name)->getOrElse(null);
+    }
+
+    /**
+     * Set an environment variable.
+     *
+     * @param string $name
+     * @param string $value
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return bool
+     */
+    public function set(string $name, string $value)
+    {
+        if ('' === $name) {
+            throw new InvalidArgumentException('Expected name to be a non-empty string.');
+        }
+
+        return $this->writer->write($name, $value);
+    }
+
+    /**
+     * Clear an environment variable.
+     *
+     * @param string $name
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return bool
+     */
+    public function clear(string $name)
+    {
+        if ('' === $name) {
+            throw new InvalidArgumentException('Expected name to be a non-empty string.');
+        }
+
+        return $this->writer->delete($name);
+    }
+}

package/src/api/vendor/vlucas/phpdotenv/src/Repository/RepositoryBuilder.php

@@ -0,0 +1,272 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Repository;
+
+use Dotenv\Repository\Adapter\AdapterInterface;
+use Dotenv\Repository\Adapter\EnvConstAdapter;
+use Dotenv\Repository\Adapter\GuardedWriter;
+use Dotenv\Repository\Adapter\ImmutableWriter;
+use Dotenv\Repository\Adapter\MultiReader;
+use Dotenv\Repository\Adapter\MultiWriter;
+use Dotenv\Repository\Adapter\ReaderInterface;
+use Dotenv\Repository\Adapter\ServerConstAdapter;
+use Dotenv\Repository\Adapter\WriterInterface;
+use InvalidArgumentException;
+use PhpOption\Some;
+use ReflectionClass;
+
+final class RepositoryBuilder
+{
+    /**
+     * The set of default adapters.
+     */
+    private const DEFAULT_ADAPTERS = [
+        ServerConstAdapter::class,
+        EnvConstAdapter::class,
+    ];
+
+    /**
+     * The set of readers to use.
+     *
+     * @var \Dotenv\Repository\Adapter\ReaderInterface[]
+     */
+    private $readers;
+
+    /**
+     * The set of writers to use.
+     *
+     * @var \Dotenv\Repository\Adapter\WriterInterface[]
+     */
+    private $writers;
+
+    /**
+     * Are we immutable?
+     *
+     * @var bool
+     */
+    private $immutable;
+
+    /**
+     * The variable name allow list.
+     *
+     * @var string[]|null
+     */
+    private $allowList;
+
+    /**
+     * Create a new repository builder instance.
+     *
+     * @param \Dotenv\Repository\Adapter\ReaderInterface[] $readers
+     * @param \Dotenv\Repository\Adapter\WriterInterface[] $writers
+     * @param bool                                         $immutable
+     * @param string[]|null                                $allowList
+     *
+     * @return void
+     */
+    private function __construct(array $readers = [], array $writers = [], bool $immutable = false, ?array $allowList = null)
+    {
+        $this->readers = $readers;
+        $this->writers = $writers;
+        $this->immutable = $immutable;
+        $this->allowList = $allowList;
+    }
+
+    /**
+     * Create a new repository builder instance with no adapters added.
+     *
+     * @return \Dotenv\Repository\RepositoryBuilder
+     */
+    public static function createWithNoAdapters()
+    {
+        return new self();
+    }
+
+    /**
+     * Create a new repository builder instance with the default adapters added.
+     *
+     * @return \Dotenv\Repository\RepositoryBuilder
+     */
+    public static function createWithDefaultAdapters()
+    {
+        $adapters = \iterator_to_array(self::defaultAdapters());
+
+        return new self($adapters, $adapters);
+    }
+
+    /**
+     * Return the array of default adapters.
+     *
+     * @return \Generator<\Dotenv\Repository\Adapter\AdapterInterface>
+     */
+    private static function defaultAdapters()
+    {
+        foreach (self::DEFAULT_ADAPTERS as $adapter) {
+            $instance = $adapter::create();
+            if ($instance->isDefined()) {
+                yield $instance->get();
+            }
+        }
+    }
+
+    /**
+     * Determine if the given name if of an adapterclass.
+     *
+     * @param string $name
+     *
+     * @return bool
+     */
+    private static function isAnAdapterClass(string $name)
+    {
+        if (!\class_exists($name)) {
+            return false;
+        }
+
+        return (new ReflectionClass($name))->implementsInterface(AdapterInterface::class);
+    }
+
+    /**
+     * Creates a repository builder with the given reader added.
+     *
+     * Accepts either a reader instance, or a class-string for an adapter. If
+     * the adapter is not supported, then we silently skip adding it.
+     *
+     * @param \Dotenv\Repository\Adapter\ReaderInterface|string $reader
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return \Dotenv\Repository\RepositoryBuilder
+     */
+    public function addReader($reader)
+    {
+        if (!(\is_string($reader) && self::isAnAdapterClass($reader)) && !($reader instanceof ReaderInterface)) {
+            throw new InvalidArgumentException(
+                \sprintf(
+                    'Expected either an instance of %s or a class-string implementing %s',
+                    ReaderInterface::class,
+                    AdapterInterface::class
+                )
+            );
+        }
+
+        $optional = Some::create($reader)->flatMap(static function ($reader) {
+            return \is_string($reader) ? $reader::create() : Some::create($reader);
+        });
+
+        $readers = \array_merge($this->readers, \iterator_to_array($optional));
+
+        return new self($readers, $this->writers, $this->immutable, $this->allowList);
+    }
+
+    /**
+     * Creates a repository builder with the given writer added.
+     *
+     * Accepts either a writer instance, or a class-string for an adapter. If
+     * the adapter is not supported, then we silently skip adding it.
+     *
+     * @param \Dotenv\Repository\Adapter\WriterInterface|string $writer
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return \Dotenv\Repository\RepositoryBuilder
+     */
+    public function addWriter($writer)
+    {
+        if (!(\is_string($writer) && self::isAnAdapterClass($writer)) && !($writer instanceof WriterInterface)) {
+            throw new InvalidArgumentException(
+                \sprintf(
+                    'Expected either an instance of %s or a class-string implementing %s',
+                    WriterInterface::class,
+                    AdapterInterface::class
+                )
+            );
+        }
+
+        $optional = Some::create($writer)->flatMap(static function ($writer) {
+            return \is_string($writer) ? $writer::create() : Some::create($writer);
+        });
+
+        $writers = \array_merge($this->writers, \iterator_to_array($optional));
+
+        return new self($this->readers, $writers, $this->immutable, $this->allowList);
+    }
+
+    /**
+     * Creates a repository builder with the given adapter added.
+     *
+     * Accepts either an adapter instance, or a class-string for an adapter. If
+     * the adapter is not supported, then we silently skip adding it. We will
+     * add the adapter as both a reader and a writer.
+     *
+     * @param \Dotenv\Repository\Adapter\WriterInterface|string $adapter
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return \Dotenv\Repository\RepositoryBuilder
+     */
+    public function addAdapter($adapter)
+    {
+        if (!(\is_string($adapter) && self::isAnAdapterClass($adapter)) && !($adapter instanceof AdapterInterface)) {
+            throw new InvalidArgumentException(
+                \sprintf(
+                    'Expected either an instance of %s or a class-string implementing %s',
+                    WriterInterface::class,
+                    AdapterInterface::class
+                )
+            );
+        }
+
+        $optional = Some::create($adapter)->flatMap(static function ($adapter) {
+            return \is_string($adapter) ? $adapter::create() : Some::create($adapter);
+        });
+
+        $readers = \array_merge($this->readers, \iterator_to_array($optional));
+        $writers = \array_merge($this->writers, \iterator_to_array($optional));
+
+        return new self($readers, $writers, $this->immutable, $this->allowList);
+    }
+
+    /**
+     * Creates a repository builder with mutability enabled.
+     *
+     * @return \Dotenv\Repository\RepositoryBuilder
+     */
+    public function immutable()
+    {
+        return new self($this->readers, $this->writers, true, $this->allowList);
+    }
+
+    /**
+     * Creates a repository builder with the given allow list.
+     *
+     * @param string[]|null $allowList
+     *
+     * @return \Dotenv\Repository\RepositoryBuilder
+     */
+    public function allowList(?array $allowList = null)
+    {
+        return new self($this->readers, $this->writers, $this->immutable, $allowList);
+    }
+
+    /**
+     * Creates a new repository instance.
+     *
+     * @return \Dotenv\Repository\RepositoryInterface
+     */
+    public function make()
+    {
+        $reader = new MultiReader($this->readers);
+        $writer = new MultiWriter($this->writers);
+
+        if ($this->immutable) {
+            $writer = new ImmutableWriter($writer, $reader);
+        }
+
+        if ($this->allowList !== null) {
+            $writer = new GuardedWriter($writer, $this->allowList);
+        }
+
+        return new AdapterRepository($reader, $writer);
+    }
+}

package/src/api/vendor/vlucas/phpdotenv/src/Repository/RepositoryInterface.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Repository;
+
+interface RepositoryInterface
+{
+    /**
+     * Determine if the given environment variable is defined.
+     *
+     * @param string $name
+     *
+     * @return bool
+     */
+    public function has(string $name);
+
+    /**
+     * Get an environment variable.
+     *
+     * @param string $name
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return string|null
+     */
+    public function get(string $name);
+
+    /**
+     * Set an environment variable.
+     *
+     * @param string $name
+     * @param string $value
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return bool
+     */
+    public function set(string $name, string $value);
+
+    /**
+     * Clear an environment variable.
+     *
+     * @param string $name
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return bool
+     */
+    public function clear(string $name);
+}

package/src/api/vendor/vlucas/phpdotenv/src/Store/File/Paths.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dotenv\Store\File;
+
+/**
+ * @internal
+ */
+final class Paths
+{
+    /**
+     * This class is a singleton.
+     *
+     * @codeCoverageIgnore
+     *
+     * @return void
+     */
+    private function __construct()
+    {
+        //
+    }
+
+    /**
+     * Returns the full paths to the files.
+     *
+     * @param string[] $paths
+     * @param string[] $names
+     *
+     * @return string[]
+     */
+    public static function filePaths(array $paths, array $names)
+    {
+        $files = [];
+
+        foreach ($paths as $path) {
+            foreach ($names as $name) {
+                $files[] = \rtrim($path, \DIRECTORY_SEPARATOR).\DIRECTORY_SEPARATOR.$name;
+            }
+        }
+
+        return $files;
+    }
+}