kodedphp / stdlib

Config.php

<?php declare(strict_types=1);

/*
 * This file is part of the Koded package.
 *
 * (c) Mihail Binev <mihail@kodeart.com>
 *
 * Please view the LICENSE distributed with this source code
 * for the full copyright and license information.
 */

namespace Koded\Stdlib;

use Exception;

/**
 * Class Config works as a parameter bag that provides ways to fill it
 * from files or other Config instances. There are 2 common patterns
 * to populate the config,
 *
 * either you can fill the Config instance from config files:
 *
 *     $app->config()->fromPhpFile('myconfig.php');
 *     $app->config()->fromJsonFile('myconfig.json');
 *     $app->config()->fromEnvFile('.env');
 *     $app->config()->fromIniFile('myconfig.ini');
 *
 * or alternatively you can define the configuration options in the instance
 * that calls `fromObject`,
 *
 *     $app->config()->fromObject(MyConfig::class);
 *     $app->config()->fromObject($myconfig); // $myconfig is instance of Config
 *
 * Other interesting way to load configuration is from an environment variable
 * that points to a file
 *
 *     $app->config()->fromEnvVariable('MY_APP_SETTINGS');
 *
 * In this case, before launching the application you have to set the env variable
 * to the file you want to use. On Linux and OSX use the export statement
 *
 *     export MY_APP_SETTINGS='/path/to/config/file.php'
 *
 * or somewhere in your app bootstrap phase before constructing the Api instance
 *
 *     putenv('MY_APP_SETTINGS=/path/to/config/file.php');
 *
 */
class Config extends Arguments implements Configuration
{
    public string $rootPath = '';
    private bool $silent = false;

    /**
     * Config constructor.
     *
     * @param string    $rootPath       Path to which files are read relative from.
     *                                  When the config object is created by an application/library
     *                                  this is the application's root path
     * @param Data|null $defaults       [optional] An Optional config object with default values
     */
    public function __construct(string $rootPath = '', Data $defaults = null)
    {
        parent::__construct($defaults ? $defaults->toArray() : []);
        if (!$this->rootPath = $rootPath) {
            $this->rootPath = \getcwd();
        }
    }

    /**
     * Bad method calls can be suppressed and allow the app
     * to continue execution by setting the silent(true).
     *
     * The calling app should handle their configuration appropriately.
     *
     * @param string     $name      Method name
     * @param array|null $arguments [optional]
     *
     * @return Configuration
     * @throws Exception
     */
    public function __call(string $name, array|null $arguments): Configuration

The type Koded\Stdlib\null was not found. Maybe you did not declare it correctly or list all dependencies?

    {
        if (false === $this->silent) {
            throw new Exception('Unable to load the configuration file ' . \current($arguments));
        }
        return $this;
    }

    public function build(string $context): Configuration
    {
        throw new Exception('Configuration factory should implement the method ' . __METHOD__);
    }

    public function withParameters(array $parameters): Configuration
    {
        return $this->import($parameters);
    }

    public function fromObject(object|string $object): Configuration
    {
        if (\is_string($object) && \class_exists($object)) {
            $object = new $object;
        }
        $this->rootPath = $object->rootPath ?: $this->rootPath;
        return $this->import(\iterator_to_array($object));

It seems like $object can also be of type string; however, parameter $iterator of iterator_to_array() does only seem to accept Traversable, maybe add an additional type check?

    }

    public function fromJsonFile(string $filename): Configuration
    {
        return $this->loadDataFrom($filename, function($filename) {
            return \json_decode(\file_get_contents($filename), true);
        });
    }

    public function fromIniFile(string $filename): Configuration
    {
        return $this->loadDataFrom($filename, function($filename) {
            return \parse_ini_file($filename, true, INI_SCANNER_TYPED) ?: [];
        });
    }

    public function fromEnvFile(string $filename, string $namespace = ''): Configuration
    {
        try {
            $data = \parse_ini_file($this->filename($filename), true, INI_SCANNER_TYPED) ?: [];
            env('', null, $this->filter($data, $namespace, false));
        } catch (Exception $e) {
            \error_log('[Configuration error]: ' . $e->getMessage());
            env('', null, []);
        } finally {
            return $this;
        }
    }

    public function fromEnvVariable(string $variable): Configuration
    {
        if (false === empty($filename = \getenv($variable))) {
            $extension = \ucfirst(\pathinfo($filename, PATHINFO_EXTENSION));

It seems like pathinfo($filename, Koded\Stdlib\PATHINFO_EXTENSION) can also be of type array; however, parameter $string of ucfirst() does only seem to accept string, maybe add an additional type check?

            return \call_user_func([$this, "from{$extension}File"], $filename);
        }
        if (false === $this->silent) {
            throw new Exception(\strtr('The environment variable ":variable" is not set
            and as such configuration could not be loaded. Set this variable and
            make it point to a configuration file', [':variable' => $variable]));
        }
        \error_log('[Configuration error]: ' . (\error_get_last()['message'] ?? "env var: ${variable}"));
        return $this;
    }

    public function fromPhpFile(string $filename): Configuration
    {
        return $this->loadDataFrom($filename, function($filename) {
            /** @noinspection PhpIncludeInspection */
            return include $filename;
        });
    }

    public function fromEnvironment(
        array $variableNames,
        string $namespace = '',
        bool $lowercase = true,
        bool $trim = true
    ): Configuration {
        $data = [];
        foreach ($variableNames as $variable) {
            $value = \getenv($variable);
            $data[] = $variable . '=' . (false === $value ? 'null' : $value);
        }
        $data = \parse_ini_string(\join(PHP_EOL, $data), true, INI_SCANNER_TYPED) ?: [];
        $this->import($this->filter($data, $namespace, $lowercase, $trim));
        return $this;
    }

    public function silent(bool $silent): Configuration
    {
        $this->silent = $silent;
        return $this;
    }

    public function namespace(
        string $prefix,
        bool $lowercase = true,
        bool $trim = true): static
    {
        return (new static($this->rootPath))
            ->import($this->filter($this->toArray(), $prefix, $lowercase, $trim));
    }

    protected function loadDataFrom(string $filename, callable $loader): Configuration
    {
        return $this->import($loader($this->filename($filename)));
    }

    private function filename(string $filename):  string
    {
        return ('/' === $filename[0])
            ? $filename
            : $this->rootPath . '/' . \ltrim($filename, '/');
    }
}