UnicornFail\Emoji\Dataset\RuntimeDataset

Complexity

Total Complexity

45

Size/Duplication

Total Lines	274
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

22 Methods

Rating	Name	Duplication	Size	Complexity
A	filter()	0	3	1
A	getPresets()	0	15	3
A	archive()	0	9	2
A	getDataset()	0	24	5
A	current()	0	3	1
A	offsetSet()	0	3	1
A	offsetExists()	0	3	1
A	unarchive()	0	25	6
A	normalizeLocale()	0	28	5
A	offsetGet()	0	3	1
A	normalizePreset()	0	23	4
A	offsetUnset()	0	3	1
A	rewind()	0	3	1
A	count()	0	3	1
A	isNative()	0	15	4
A	indexBy()	0	3	1
A	getLocale()	0	7	2
A	seek()	0	3	1
A	__construct()	0	4	1
A	next()	0	3	1
A	valid()	0	3	1
A	key()	0	3	1

<?php

declare(strict_types=1);

namespace UnicornFail\Emoji\Dataset;

use League\Configuration\ConfigurationInterface;
use League\Configuration\Exception\InvalidConfigurationException;
use UnicornFail\Emoji\Emojibase\EmojibaseDatasetInterface;
use UnicornFail\Emoji\Emojibase\EmojibaseShortcodeInterface;
use UnicornFail\Emoji\Exception\FileNotFoundException;
use UnicornFail\Emoji\Exception\LocalePresetException;
use UnicornFail\Emoji\Exception\MalformedArchiveException;
use UnicornFail\Emoji\Exception\UnarchiveException;
use UnicornFail\Emoji\Parser\EmojiParser;

final class RuntimeDataset implements \ArrayAccess, \Countable, \SeekableIterator
{
    public const DEFAULT = 'en';

    /** @var ConfigurationInterface */
    private $config;

    /** @var ?Dataset */
    private $dataset;

    /** @var ?string */
    private $locale;

    /** @var ?bool */
    private $native;

    /** @var ?string[] */
    private $presets;

    public function __construct(ConfigurationInterface $configuration, ?Dataset $dataset = null)
    {
        $this->config  = $configuration;
        $this->dataset = $dataset;
    }

    /**
     * @param string[] $indices
     *
     * @return false|string
     */
    public static function archive(Dataset $dataset, array $indices = EmojiParser::INDICES)
    {
        foreach ($indices as $index) {
            $dataset->indexBy($index);
        }

        $serialize = \serialize($dataset);

        return \gzencode($serialize, 9);
    }

    public static function unarchive(string $filename): Dataset
    {
        if (! \file_exists($filename)) {
            throw new FileNotFoundException($filename);
        }

        if (
            ! ($contents = \file_get_contents($filename)) ||
            ! ($decoded = \gzdecode($contents))
        ) {
            throw new UnarchiveException($filename);
        }

        try {
            /** @var ?Dataset $dataset */
            $dataset = \unserialize((string) $decoded);
        } catch (\Throwable $throwable) {
            throw new MalformedArchiveException($filename, $throwable);
        }

        if (! $dataset instanceof Dataset) {
            throw new MalformedArchiveException($filename);
        }

        return $dataset;
    }

    public static function normalizeLocale(string $locale): string
    {
        // Immediately return if locale is an exact match.
        if (\in_array($locale, EmojibaseDatasetInterface::SUPPORTED_LOCALES, true)) {
            return $locale;
        }

        // Immediately return if this local has already been normalized.
        /** @var string[] $normalized */
        static $normalized = [];
        if (isset($normalized[$locale])) {
            return $normalized[$locale];
        }

        $original              = $locale;
        $normalized[$original] = '';

        // Otherwise, see if it just needs some TLC.
        $locale = \strtolower($locale);
        $locale = \preg_replace('/[^a-z]/', '-', $locale) ?? $locale;
        foreach ([$locale, \current(\explode('-', $locale, 2))] as $locale) {
            if (\in_array($locale, EmojibaseDatasetInterface::SUPPORTED_LOCALES, true)) {
                $normalized[$original] = $locale;
                break;
            }
        }

        return $normalized[$original];
    }

    /**
     * @param string|string[] $value
     *
     * @return string[]
     */
    public static function normalizePreset($value): array
    {
        // Presets.
        $presets = [];
        foreach ((array) $value as $preset) {
            if (isset(EmojibaseShortcodeInterface::PRESET_ALIASES[$preset])) {
                $presets[] = EmojibaseShortcodeInterface::PRESET_ALIASES[$preset];
            } elseif (isset(EmojibaseShortcodeInterface::PRESETS[$preset])) {
                $presets[] = EmojibaseShortcodeInterface::PRESETS[$preset];
            } else {
                throw InvalidConfigurationException::forConfigOption('preset', $preset, \sprintf(
                    'Accepted values are: %s.',
                    \implode(', ', \array_map(
                        static function ($s) {
                            return \sprintf('"%s"', $s);
                        },
                        EmojibaseShortcodeInterface::SUPPORTED_PRESETS
                    ))
                ));
            }
        }

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

    public function count(): int
    {
        return $this->getDataset()->count();
    }

    public function current(): Emoji
    {
        return $this->getDataset()->current();
    }

    /**
     * @param callable(Emoji):bool $callback
     */
    public function filter(callable $callback): RuntimeDataset
    {
        return new self($this->config, $this->getDataset()->filter($callback));
    }

    public function getDataset(): Dataset
    {
        if ($this->dataset === null) {
            $locale     = $this->getLocale();
            $presets    = $this->getPresets();
            $throwables = [];
            $presets    = \array_filter($presets);
            $remaining  = $presets;
            while (\count($remaining) > 0) {
                $preset = \array_shift($remaining);
                try {
                    $this->dataset = self::unarchive(\sprintf('%s/%s/%s.gz', Dataset::DIRECTORY, $locale, $preset));
                    break;
                } catch (\Throwable $throwable) {
                    $throwables[$preset] = $throwable;
                }
            }

            if ($this->dataset === null) {
                throw new LocalePresetException($locale, $throwables);
            }
        }

        return $this->dataset;
    }

    public function getLocale(): string
    {
        if ($this->locale === null) {
            $this->locale = (string) ($this->config->get('local') ?? self::DEFAULT);
        }

        return $this->locale;
    }

    /**
     * @return string[]
     */
    public function getPresets(): array
    {
        if ($this->presets === null) {
            /** @var string[] $presets */
            $presets = (array) $this->config->get('preset');

            // Prepend the native preset if local is requires it and enabled.
            if ($this->isNative()) {
                \array_unshift($presets, EmojibaseShortcodeInterface::PRESET_CLDR_NATIVE);
            }

            $this->presets = $presets;
        }

        return $this->presets;
    }

    public function indexBy(string $index = 'hexcode'): RuntimeDataset
    {
        return new self($this->config, $this->getDataset()->indexBy($index));
    }

    public function isNative(): bool
    {
        if ($this->native === null) {
            $locale  = $this->getLocale();
            $default = \in_array($locale, EmojibaseDatasetInterface::NON_LATIN_LOCALES, true);

            /** @var ?bool $native */
            $native = $this->config->get('native');

            $this->native = $native === null
                ? $default
                : $native && $default;
        }

        return $this->native;
    }

    public function key(): string
    {
        return (string) $this->getDataset()->key();
    }

    public function next(): void
    {
        $this->getDataset()->next();
    }

    /** @param string $offset */
    public function offsetExists($offset): bool // phpcs:ignore
    {
        return $this->getDataset()->offsetExists($offset);
    }

    /** @param string $offset */
    public function offsetGet($offset): ?Emoji // phpcs:ignore
    {
        return $this->getDataset()->offsetGet($offset);
    }

    /**
     * @param string $offset
     * @param mixed  $value
     */
    public function offsetSet($offset, $value): void // phpcs:ignore
    {
        $this->getDataset()->offsetSet($offset, $value);
    }

    /** @param string $offset */
    public function offsetUnset($offset): void // phpcs:ignore
    {
        $this->getDataset()->offsetUnset($offset);
    }

    public function rewind(): void
    {
        $this->getDataset()->rewind();
    }

    /** @param int $position */
    public function seek($position): void // phpcs:ignore
    {
        $this->getDataset()->seek($position);
    }

    public function valid(): bool
    {
        return $this->getDataset()->valid();
    }
}