FondBot::intents() - Code Metrics - Inspection of "wip" - fondbot/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ebdf7a...2dba39 )

by Vladimir

created 2018-09-07 22:41 UTC

FondBot::intents() A

↳ Parent: FondBot

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace FondBot;

use Closure;
use SplFileInfo;
use ReflectionClass;
use Illuminate\Support\Str;
use FondBot\Contracts\Activator;
use FondBot\Conversation\Intent;
use FondBot\Events\MessageReceived;
use Symfony\Component\Finder\Finder;
use FondBot\Conversation\FallbackIntent;

class FondBot
{
    /**
     * The registered drivers.
     *
     * @var array
     */
    private $drivers = [];

    /**
     * The registered channels.
     *
     * @var array
     */
    private $channels = [];

    /**
     * The registered intents.
     *
     * @var array
     */
    private $intents = [];

    /**
     * Fallback intent.
     *
     * @var string
     */
    private $fallbackIntent = FallbackIntent::class;

    /**
     * Context time to live in seconds.
     *
     * @var int
     */
    private $contextTtl;

    /**
     * Current channel.
     *
     * @var Channel
     */
    public static $currentChannel;

    public function __construct(array $config)
    {
        $this->contextTtl = $config['context_ttl'];
        $this->registerChannels($config['channels']);
        $this->intentsIn($config['intents_path']);
        $this->fallbackIntent = $config['fallback_intent'];
    }

    /**
     * Get the current FondBot version.
     *
     * @return string
     */
    public static function version(): string
    {
        return '4.0.0';
    }

    /**
     * Register a driver.
     *
     * @param string $name
     * @param Closure $callback
     */
    public function addDriver(string $name, Closure $callback): void
    {
        $this->drivers[$name] = $callback;
    }

    /**
     * Get all registered drivers.
     *
     * @return array
     */
    public function drivers(): array
    {
        return $this->drivers;
    }

    /**
     * Get all registered channels.
     *
     * @return array
     */
    public function channels(): array
    {
        return $this->channels;
    }

    /**
     * Get channel by name.
     *
     * @param string $name
     * @return Channel
     */
    public function channel(string $name): Channel
    {
        return $this->channels[$name];
    }

    /**
     * Get all registered intents.
     *
     * @return array
     */
    public function intents(): array
    {
        return $this->intents;
    }

    /**
     * Match intent by received message.
     *
     * @param MessageReceived $messageReceived
     *
     * @return Intent|null
     */
    public function matchIntent(MessageReceived $messageReceived): Intent
    {
        foreach ($this->intents as $intent) {
            /** @var Intent $intent */
            $intent = resolve($intent);
            $intent = resolve(/** @scrutinizer ignore-type */ $intent);

            foreach ($intent->activators() as $activator) {
                if (!$intent->passesAuthorization($messageReceived)) {
                    continue;
                }

                if ($activator instanceof Closure && value($activator($messageReceived)) === true) {
                    return $intent;
                }

                if ($activator instanceof Activator && $activator->matches($messageReceived)) {
                    return $intent;
                }
            }
        }

        // Otherwise, return fallback intent
        return resolve($this->fallbackIntent);

    }

    /**
     * Register the given channels.
     * @param array $channels
     */
    private function registerChannels(array $channels): void
    {
        $this->channels = collect($channels)
            ->mapWithKeys(function (array $parameters, string $name) {
                $driverCallback = $this->drivers[$parameters['driver']];

                /** @var Driver $driver */
                $driver = $driverCallback();
                $driver->initialize(collect($parameters)->except('driver'));

                return [
                    $name => new Channel($name, $driver, $parameters['webhook-secret'] ?? null),
                ];
            })
            ->toArray();
    }

    /**
     * Register all of the intent classes in the given directories.
     *
     * @param array $directories
     */
    private function intentsIn(array $directories): void
    {
        $namespace = app()->getNamespace();
        $namespace = app()->/** @scrutinizer ignore-call */ getNamespace();

        $intents = [];

        /** @var SplFileInfo[] $files */
        $files = (new Finder())->in($directories)->files();

        foreach ($files as $file) {
            $file = $namespace.str_replace(
                    ['/', '.php'],
                    ['\\', ''],
                    Str::after($file->getPathname(), app_path().DIRECTORY_SEPARATOR)
                );

            if (is_subclass_of($file, Intent::class) && !(new ReflectionClass($file))->isAbstract()) {
                $intents[] = $file;
            }
        }

        $this->intents = $intents;
    }
}


fondbot / framework

Push — master ( ebdf7a...2dba39 )

FondBot::intents() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like