UpdateHandler::loadFileOfEnv() - Code Metrics - Inspection of "Update" - telegram-bot-php/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( cc6cb5...f69508 )

by Shahrad
created 2022-08-17 19:08 UTC
UpdateHandler::loadFileOfEnv() A

↳ Parent: UpdateHandler
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	1
dl	0
loc	3
c	1
b	0
f	0
rs	10
cc	1
nc	1
nop	1
<?php

namespace TelegramBot;

use TelegramBot\Entities\Update;
use TelegramBot\Exception\InvalidBotTokenException;
use TelegramBot\Util\DotEnv;

/**
 * UpdateHandler class
 *
 * @link    https://github.com/telegram-bot-php/core
 * @author  Shahrad Elahi (https://github.com/shahradelahi)
 * @license https://github.com/telegram-bot-php/core/blob/master/LICENSE (MIT License)
 */
abstract class UpdateHandler extends Telegram
{

    /**
     * @var ?Update
     */
    protected ?Update $update;

    /**
     * @var array<Plugin>
     */
    private array $plugins = [];

    /**
     * @var bool
     */
    private bool $isActive = false;

    /**
     * The default configuration of the webhook.
     *
     * @var array
     */
    private array $config = [
        'autoload_env_file' => false,
        'env_file_path' => null,
    ];

    /**
     * Webhook constructor.
     *
     * @param string $api_key The API key of the bot. Leave it blank for autoload from .env file.
     */
    public function __construct(string $api_key = '')
    {
        parent::__construct($api_key);

        if (!Telegram::validateToken(self::getApiKey())) {
            throw new InvalidBotTokenException();
        }
    }

    /**
     * Initialize the receiver.
     *
     * @return void
     */
    public function init(): void
    {
        $this->config['env_file_path'] = $_SERVER['DOCUMENT_ROOT'] . '/.env';
    }

    /**
     * Add a plugin to the receiver
     *
     * @param array<Plugin> $plugins
     */
    public function addPlugin(array $plugins): void
    {
        foreach ($plugins as $plugin) {
            if (!is_subclass_of($plugin, Plugin::class)) {
                throw new \RuntimeException(
                    sprintf('The plugin %s must be an instance of %s', get_class($plugin), Plugin::class)
                );
            }
            $this->plugins[] = $plugin;
        }
    }

    /**
     * Match the message to the plugins
     *
     * @param ?Update $update The update to match
     * @return void
     */
    public function loadPlugins(Update $update = null): void
    {
        $update = $update ?? ($this->update ?? Telegram::getUpdate());
        $this->loadPluginsWith($this->plugins, $update);
        $this->loadPluginsWith($this->plugins, /** @scrutinizer ignore-type */ $update);
    }

    /**
     * Match the update with the given plugins
     *
     * @param array<Plugin> $plugins
     * @param ?Update $update The update to match
     * @return void
     */
    public function loadPluginsWith(array $plugins, Update $update = null): void
    {
        $update = $update ?? ($this->update ?? Telegram::getUpdate());

        foreach ($plugins as $plugin) {
            if (!is_subclass_of($plugin, Plugin::class)) {
                throw new \InvalidArgumentException(
                    sprintf('The plugin %s must be an instance of %s', get_class($plugin), Plugin::class)
                );
            }
        }

        if (!$update instanceof Update) {
            throw new \InvalidArgumentException(sprintf(
                'The update must be an instance of %s',
                Update::class
            ));
        }

        $this->spreadUpdateWith($update, $plugins);
    }

    /**
     * This function will get update and spread it to the plugins
     *
     * @param Update $update
     * @param array<Plugin> $plugins
     * @return void
     */
    private function spreadUpdateWith(Update $update, array $plugins): void
    {
        $this->isActive = true;

        foreach ($plugins as $plugin) {
            /** @var Plugin $plugin */
            (new $plugin())->__execute($this, $update);
            if ($this->isActive === false) break;
        }

        $this->isActive = false;
    }

    /**
     * Load the environment's
     *
     * @param string $path
     * @retrun void
     */
    public function loadFileOfEnv(string $path): void
    {
        DotEnv::load($path);
    }

    /**
     * Resolve the request.
     *
     * @param ?Update $update The custom to work with
     * @param array $config The configuration of the receiver
     *
     * @retrun void
     */
    public function resolve(Update $update = null, array $config = []): void
    {
        if (!method_exists($this, '__process')) {
            throw new \RuntimeException('The method __process does not exist');
        }

        if (is_array($config)) $this->updateConfiguration($config);


        if (!empty($update)) $this->update = $update;
        else $this->update = Telegram::getUpdate() !== false ? Telegram::getUpdate() : null;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        if (empty($this->update)) {
            TelegramLog::error(
                'The update is empty, the request is not processed'
            );
            return;
        }

        putenv('TG_CURRENT_UPDATE=' . $this->update->getRawData(false));

        $this->__process($this->update);
    }

    /**
     * Update the configuration
     *
     * @param array $configuration
     * @return void
     */
    public function updateConfiguration(array $configuration): void
    {
        $this->config = array_merge($this->config, $configuration);
    }

    /**
     * Use this method on the webhook class to get the updates
     *
     * @param Update $update
     * @return void
     */
    abstract public function __process(Update $update): void;

    /**
     * Stop the speeding process
     *
     * @return void
     */
    public function stop(): void
    {
        $this->isActive = false;
    }

}
telegram-bot-php / core

Push — master ( cc6cb5...f69508 )

UpdateHandler::loadFileOfEnv() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
