Configuration::configureOptions() - Code Metrics - Inspection of "Moar scrutinizer analysis cleanup" - unicorn-fail/emoji - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — latest ( 03f783...d7ba96 )

by Mark
created 2020-09-17 06:33 UTC
Configuration::configureOptions() A

↳ Parent: Configuration
Complexity

Conditions	1
Paths	1
Size

Total Lines	9
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	8
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	7
c	1
b	0
f	0
dl	0
loc	9
ccs	8
cts	8
cp	1
rs	10
cc	1
nc	1
nop	1
crap	1
<?php

declare(strict_types=1);

namespace UnicornFail\Emoji;

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\Util\Normalize;

class Configuration extends Data implements ConfigurationInterface
{
    /**
     * @param mixed[]|\Traversable $configuration
     */
    public function __construct(?iterable $configuration = null)
    {
        $resolver = new OptionsResolver();
        $this->configureOptions($resolver);

        $options = $configuration !== null ? (new \ArrayObject($configuration))->getArrayCopy() : [];
        $options = $configuration !== null ? (new \ArrayObject(/** @scrutinizer ignore-type */ $configuration))->getArrayCopy() : [];

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

        parent::__construct($data);
    }

    /**
     * @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->defineExcludeShortcodes($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 defineExcludeShortcodes(OptionsResolver $resolver): void
    {
        $resolver->define('excludeShortcodes')
            ->allowedTypes('string', 'string[]')
            ->default([])
            ->normalize(
            /**
             * @param mixed $value
             *
             * @return string[]
             */
                static function (Options $options, $value): array {
                    if (! $value) {
                        return $value;
                    }

                    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(
                /**
                 * @param mixed $value
                 */
                static function ($value): bool {
                    foreach ((array) $value as $v) {
                        if (! \in_array($v, ShortcodeInterface::SUPPORTED_PRESETS, true)) {
                            throw new InvalidOptionsException(\sprintf(
                                'The option "preset" with value "%s" is invalid. Accepted values are: %s.',
                                $v,
                                \implode(', ', \array_map(static function ($s) {
                                    return \sprintf('"%s"', $s);
                                }, ShortcodeInterface::SUPPORTED_PRESETS))
                            ));
                        }
                    }

                    return true;
                }
            )
            ->default(ShortcodeInterface::DEFAULT_PRESETS)
            ->normalize(
                /**
                 * @param mixed $value
                 *
                 * @return string[]
                 */
                static function (Options $options, $value): array {
                    // Presets.
                    $presets = [];
                    foreach ((array) $value as $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('int')
            ->allowedValues(Lexer::T_EMOTICON, Lexer::T_HTML_ENTITY, Lexer::T_SHORTCODE, Lexer::T_UNICODE)
            ->default(Lexer::T_UNICODE);
    }

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

unicorn-fail / emoji

Push — latest ( 03f783...d7ba96 )

Configuration::configureOptions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
