DNADesign\Elemental\Services\ElementTypeRegistry

Complexity

Total Complexity

13

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getTabProvider()	0	4	1
A	generate()	0	21	5
A	getDefinitions()	0	3	1
A	registerElement()	0	23	2
A	getDefinition()	0	21	4

<?php
namespace DNADesign\Elemental\Services;

use DNADesign\Elemental\Models\BaseElement;
use InvalidArgumentException;
use LogicException;
use Psr\SimpleCache\CacheInterface;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\GraphQL\Scaffolding\StaticSchema;

class ElementTypeRegistry
{
    use Injectable;

    const CACHE_KEY = 'element-types';

    /**
     * @var array
     */
    protected $elementTypes;

    /**
     * @var CacheInterface
     */
    protected static $cache;

    /**
     * Register an element type with this registry
     *
     * @param string $elementClass
     * @return $this
     */
    public function registerElement($elementClass)
    {
        $singleton = singleton($elementClass);

        if (!$singleton instanceof BaseElement) {
            throw new LogicException('Only elements that extend ' . BaseElement::class . ' can be registered');
        }

        // Get the GraphQL type name
        $typeName = StaticSchema::inst()->typeNameForDataObject($elementClass);

        $this->elementTypes[] = [
            'icon' => $singleton::config()->get('icon'),
            'name' => $typeName,
            'class' => $elementClass,
            'title' => $singleton->getType(),
            'inlineEditable' => $singleton->inlineEditable(),
            'editTabs' => $this->getTabProvider()->getTabsForElement($elementClass),
            // Cast to object as React prop-types expects it.
            'config' => (object) $singleton::getBlockConfig(),
        ];

        return $this;
    }

    /**
     * Get the schema of the element types that are registered
     *
     * @return array
     */
    public function getDefinitions()
    {
        return $this->elementTypes;
    }

    /**
     * Get the element type data for the given instance or class name of an element.
     *
     * @param $instanceOrClass
     * @return mixed
     */
    public function getDefinition($instanceOrClass)
    {
        if ($instanceOrClass instanceof BaseElement) {
            $instanceOrClass = get_class($instanceOrClass);
        }

        if (!is_string($instanceOrClass)) {
            throw new InvalidArgumentException(sprintf(
                'Given argument to %s is not an instance of a class extending %s and is not a string',
                __METHOD__,
                BaseElement::class
            ));
        }

        $definitions = $this->getDefinitions();

        if (!isset($definitions[$instanceOrClass])) {
            throw new InvalidArgumentException(sprintf('Unknown element "%s"', $instanceOrClass));
        }

        return $definitions[$instanceOrClass];
    }

    /**
     * @internal This API is only intended for use while SilverStripe does not have a caching layer for form schema.
     *           See: https://github.com/silverstripe/silverstripe-admin/issues/627
     * @return ElementTabProvider
     */
    protected function getTabProvider()
    {
        // This is a temporary solution until something client side is implemented to reveal tab names.
        return Injector::inst()->get(ElementTabProvider::class);
    }

    /**
     * Create a registry and attempt to fill it by resolving element types by introspecting class hierarchy
     *
     * @return static
     */
    public static function generate()
    {
        $registry = static::create();

        // Look in a cache (if provided) for type details
        if (static::$cache && ($types = static::$cache->get(self::CACHE_KEY))) {
            $registry->elementTypes = $types;
            return $registry;
        }

        // Find all element types
        $classNames = ClassInfo::getValidSubClasses(BaseElement::class);
        foreach ($classNames as $class) {
            // Skip the "abstract" element
            if ($class === BaseElement::class) {
                continue;
            }
            $registry->registerElement($class);
        }

        return $registry;
    }
}