Zenstruck\Foundry\Story

Complexity

Total Complexity

23

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	2

11 Methods

Rating	Name	Duplication	Size	Complexity
A	load()	0	3	1
A	__callStatic()	0	3	1
A	__call()	0	3	1
A	getRandomRange()	0	20	4
A	addState()	0	11	2
A	get()	0	7	2
A	getRandomSet()	0	7	2
A	getRandom()	0	3	1
A	addToPool()	0	15	4
A	add()	0	5	1
A	normalizeObject()	0	18	4

<?php

namespace Zenstruck\Foundry;

/**
 * @author Kevin Bond <kevinbond@gmail.com>
 */
abstract class Story
{
    /** @var array<string, Proxy> */
    private $objects = [];

    /** @var array<string, Proxy[]> */
    private $pools = [];

    final public function __call(string $method, array $arguments)
    {
        return $this->get($method);
    }

    final public static function __callStatic($name, $arguments)
    {
        return static::load()->get($name);
    }

    /**
     * @return static
     */
    final public static function load(): self
    {
        return Factory::configuration()->stories()->load(static::class);
    }

    /**
     * Get a random item from a pool.
     */
    final public static function getRandom(string $pool): Proxy
    {
        return static::getRandomSet($pool, 1)[0];
    }

    /**
     * Get a random set of items from a pool.
     *
     * @return Proxy[]
     */
    final public static function getRandomSet(string $pool, int $number): array
    {
        if ($number < 0) {
            throw new \InvalidArgumentException(\sprintf('$number must be positive (%d given).', $number));
        }

        return static::getRandomRange($pool, $number, $number);
    }

    /**
     * Get a random range of items from a pool.
     *
     * @return Proxy[]
     */
    final public static function getRandomRange(string $pool, int $min, int $max): array
    {
        if ($min < 0) {
            throw new \InvalidArgumentException(\sprintf('$min must be positive (%d given).', $min));
        }

        if ($max < $min) {
            throw new \InvalidArgumentException(\sprintf('$max (%d) cannot be less than $min (%d).', $max, $min));
        }

        $story = static::load();
        $values = $story->pools[$pool] ?? [];

        \shuffle($values);

        if (\count($values) < $max) {
            throw new \RuntimeException(\sprintf('At least %d items must be on pool "%s" (%d items found).', $max, $pool, \count($values)));
        }

        return \array_slice($values, 0, \random_int($min, $max));
    }

    /**
     * @param object|Proxy|Factory $object
     *
     * @return static
     */
    final public function add(string $name, object $object): self
    {
        trigger_deprecation('zenstruck\foundry', '1.17.0', 'Using Story::add() is deprecated, use Story::addState().');

        return $this->addState($name, $object);
    }

    final public function get(string $name): Proxy
    {
        if (!\array_key_exists($name, $this->objects)) {
            throw new \InvalidArgumentException(\sprintf('"%s" was not registered. Did you forget to call "%s::add()"?', $name, static::class));
        }

        return $this->objects[$name];
    }

    abstract public function build(): void;

    /**
     * @param object|Proxy|Factory|object[]|Proxy[]|Factory[]|FactoryCollection $objects
     *
     * @return static
     */
    final protected function addToPool(string $pool, $objects): self
    {
        if ($objects instanceof FactoryCollection) {
            $objects = $objects->create();
        }

        if (!\is_array($objects)) {
            $objects = [$objects];
        }

        foreach ($objects as $object) {
            $this->pools[$pool][] = self::normalizeObject($object);
        }

        return $this;
    }

    /**
     * @param object|Proxy|Factory $object
     *
     * @return static
     */
    final protected function addState(string $name, object $object, ?string $pool = null): self
    {
        $proxy = self::normalizeObject($object);

        $this->objects[$name] = $proxy;

        if ($pool) {
            $this->addToPool($pool, $proxy);
        }

        return $this;
    }

    private static function normalizeObject(object $object): Proxy
    {
        // ensure factories are persisted
        if ($object instanceof Factory) {
            $object = $object->create();
        }

        // ensure objects are proxied
        if (!$object instanceof Proxy) {
            $object = new Proxy($object);
        }

        // ensure proxies are persisted
        if (!$object->isPersisted()) {
            $object->save();
        }

        return $object;
    }
}