Configuration::definePresetNormalize() - Code Metrics - Inspection of "WIP: Basic implementation of commonmark’s AST & En..." - unicorn-fail/emoji - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — latest (#3)

by Mark
created 2020-09-21 01:28 UTC
Configuration::definePresetNormalize() A

↳ Parent: Configuration
Complexity

Conditions	5
Paths	8
Size

Total Lines	19
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	10
c	0
b	0
f	0
dl	0
loc	19
rs	9.6111
cc	5
nc	8
nop	2
<?php

declare(strict_types=1);

namespace UnicornFail\Emoji\Configuration;

use Dflydev\DotAccessData\Data;
use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;
use UnicornFail\Emoji\Emojibase\DatasetInterface;
use UnicornFail\Emoji\Emojibase\ShortcodeInterface;
use UnicornFail\Emoji\Exception\InvalidConfigurationException;
use UnicornFail\Emoji\Parser\Lexer;
use UnicornFail\Emoji\Util\Normalize;

class Configuration extends Data implements ConfigurationInterface
{
    /**
     * @param mixed[]|\Traversable $configuration
     */
    public function __construct(?iterable $configuration = null)
    {
        parent::__construct([]);

        /** @var string[] $data */
        $data = $configuration !== null ? (new \ArrayObject($configuration))->getArrayCopy() : [];
        $data = $configuration !== null ? (new \ArrayObject(/** @scrutinizer ignore-type */ $configuration))->getArrayCopy() : [];
        foreach ($data as $key => $value) {
            $this->set((string) $key, $value);
        }

        try {
            $resolver = new OptionsResolver();
            $this->configureOptions($resolver);
            $this->data = $resolver->resolve($this->data);
        } catch (\Throwable $throwable) {
            throw new InvalidConfigurationException($throwable->getMessage(), (int) $throwable->getCode(), $throwable->getPrevious());
        }
    }

    /**
     * @param mixed[]|\Traversable $configuration
     */
    public static function create(?iterable $configuration = null): ConfigurationInterface
    {
        if ($configuration instanceof ConfigurationInterface) {
            return $configuration;
        }

        return new self($configuration);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $this->defineConvertEmoticons($resolver);
        $this->defineExclude($resolver);
        $this->defineLocale($resolver);
        $this->defineNative($resolver);
        $this->definePresentation($resolver);
        $this->definePreset($resolver);
        $this->defineStringableType($resolver);
    }

    protected function defineConvertEmoticons(OptionsResolver $resolver): void
    {
        $resolver->define('convertEmoticons')
            ->allowedTypes('bool')
            ->default(true);
    }

    protected function defineExclude(OptionsResolver $resolver): void
    {
        $resolver->setDefault('exclude', static function (OptionsResolver $resolver): void {
            $resolver->define('shortcodes')
                ->allowedTypes('string', 'string[]')
                ->default([])
                ->normalize(
                /**
                 * @param string|string[] $value
                 *
                 * @return string[]
                 */
                    static function (Options $options, $value): array {
                        return Normalize::shortcodes($value);
                    }
                );
        });
    }

    protected function defineLocale(OptionsResolver $resolver): void
    {
        $resolver->define('locale')
            ->allowedTypes('string')
            ->allowedValues(static function (string $value): bool {
                return ! ! Normalize::locale($value);
            })
            ->default('en')
            ->normalize(static function (Options $options, string $value): string {
                return Normalize::locale($value);
            });
    }

    protected function defineNative(OptionsResolver $resolver): void
    {
        $resolver->define('native')
            ->allowedTypes('bool')
            ->default(static function (Options $options): bool {
                return \in_array($options['locale'], DatasetInterface::NON_LATIN_LOCALES, true);
            })
            ->normalize(static function (Options $options, bool $value) {
                return $value && \in_array($options['locale'], DatasetInterface::NON_LATIN_LOCALES, true);
            });
    }

    protected function definePresentation(OptionsResolver $resolver): void
    {
        $resolver->define('presentation')
            ->allowedTypes('int', 'null')
            ->allowedValues(...DatasetInterface::SUPPORTED_PRESENTATIONS)
            ->default(DatasetInterface::EMOJI);
    }

    protected function definePreset(OptionsResolver $resolver): void
    {
        $resolver->define('preset')
            ->allowedTypes('string', 'string[]')
            ->allowedValues(\Closure::fromCallable([$this, 'definePresetAllowedValues']))
            ->default(ShortcodeInterface::DEFAULT_PRESETS)
            ->normalize(\Closure::fromCallable([$this, 'definePresetNormalize']));
    }

    /**
     * @param mixed $values
     */
    protected function definePresetAllowedValues($values): bool
    {
        foreach ((array) $values as $value) {
            \assert(\is_string($value));
            if (! \in_array($value, ShortcodeInterface::SUPPORTED_PRESETS, true)) {
                throw new InvalidOptionsException(\sprintf(
                    'The option "preset" with value "%s" is invalid. Accepted values are: %s.',
                    $value,
                    \implode(', ', \array_map(static function ($s) {
                        return \sprintf('"%s"', $s);
                    }, ShortcodeInterface::SUPPORTED_PRESETS))
                ));
            }
        }

        return true;
    }

    /**
     * @param mixed $value
     *
     * @return string[]
     */
    protected function definePresetNormalize(Options $options, $value): array
    {
        // Presets.
        $presets = [];
        foreach ((array) $value as $preset) {
            \assert(\is_string($preset));
            if (isset(ShortcodeInterface::PRESET_ALIASES[$preset])) {
                $presets[] = ShortcodeInterface::PRESET_ALIASES[$preset];
            } elseif (isset(ShortcodeInterface::PRESETS[$preset])) {
                $presets[] = ShortcodeInterface::PRESETS[$preset];
            }
        }

        // Prepend the native preset if local is requires it and enabled.
        if ($options['native']) {
            \array_unshift($presets, ShortcodeInterface::PRESET_CLDR_NATIVE);
        }

        return \array_values(\array_unique($presets));
    }

    protected function defineStringableType(OptionsResolver $resolver): void
    {
        $resolver->define('stringableType')
            ->allowedTypes('string')
            ->allowedValues(Lexer::EMOTICON, Lexer::HTML_ENTITY, Lexer::SHORTCODE, Lexer::UNICODE)
            ->default(Lexer::UNICODE);
    }

    public function getIterator(): \ArrayObject
    {
        return new \ArrayObject($this->export());
    }

    /**
     * {@inheritDoc}
     */
    public function import(array $data, $clobber = true): void
    {
        $data = static::create(new \ArrayObject($data))->export();
        parent::import($data, $clobber);
    }
}

unicorn-fail / emoji

Pull Request — latest (#3)

Configuration::definePresetNormalize() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
