DNADesign\Elemental\Services\ElementTabProvider

Complexity

Total Complexity

12

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getTabsForElement()	0	7	2
A	__construct()	0	6	2
A	getCache()	0	3	1
A	flush()	0	9	2
A	setCache()	0	4	1
A	generateAllTabs()	0	4	2
A	getCacheKey()	0	3	1
A	generateTabsForElement()	0	17	1

<?php
namespace DNADesign\Elemental\Services;

use DNADesign\Elemental\Models\BaseElement;
use Psr\SimpleCache\CacheInterface;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Flushable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Forms\TabSet;

/**
 * Provides top-level CMS field tab names for any element that extends BaseElement
 *
 * Note that this will be replaced by GraphQL form schema caching (see
 * http://github.com/silverstripe/silverstripe-admin/issues/627 ). This service may be removed without warning in a
 * minor release.
 *
 * @internal
 */
class ElementTabProvider implements Flushable
{
    use Configurable;

    /**
     * Set to true to refresh the tab cache on flush
     *
     * @config
     * @var bool
     */
    private static $regenerate_on_flush = false;

The private property $regenerate_on_flush is not used, and could be removed.

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

    /**
     * ElementTabProvider constructor.
     * @param CacheInterface $cache
     */
    public function __construct(CacheInterface $cache = null)
    {
        if (!$cache) {
            $cache = Injector::inst()->get(CacheInterface::class . '.ElementTabCache');
        }
        $this->cache = $cache;
    }

    /**
     * Get the top level tab names for the given element class
     *
     * @param string $elementClass
     * @return array Array of the tabs for the element
     */
    public function getTabsForElement($elementClass)
    {
        if (null !== ($tabs = $this->getCache()->get($this->getCacheKey($elementClass)))) {
            return $tabs;
        }

        return $this->generateTabsForElement($elementClass);
    }

    /**
     * This function is triggered early in the request if the "flush" query
     * parameter has been set. Each class that implements Flushable implements
     * this function which looks after it's own specific flushing functionality.
     *
     * @see FlushMiddleware
     */
    public static function flush()
    {
        /** @var static $self */
        $self = singleton(static::class);

        $self->cache->clear();

        if ($self->config()->get('regenerate_on_flush')) {
            $self->generateAllTabs();
        }
    }

    /**
     * @param CacheInterface $cache
     * @return $this
     */
    public function setCache($cache)
    {
        $this->cache = $cache;
        return $this;
    }

    /**
     * @return CacheInterface
     */
    protected function getCache()
    {
        return $this->cache;
    }

    /**
     * Identify and regenerate all tab names for all elemental blocks (and cache them)
     *
     * @return void
     */
    protected function generateAllTabs()
    {
        foreach (ClassInfo::subclassesFor(BaseElement::class) as $class) {
            $this->generateTabsForElement($class);
        }
    }

    /**
     * Generate top level tab names for the given element class (and cache them)
     *
     * @param string $elementClass
     * @return array
     */
    protected function generateTabsForElement($elementClass)
    {
        // Create the specified element
        /** @var BaseElement $element */
        $element = Injector::inst()->create($elementClass);

        // Generate CMS fields and grab the "Root" tabset.
        /** @var TabSet $tabset */
        $tabset = $element->getCMSFields()->fieldByName('Root');

        // Get and map (ID => name) the tab names
        $tabs = $tabset->Tabs()->map()->toArray();

        // Cache them for next time
        $this->getCache()->set($this->getCacheKey($elementClass), $tabs);

        return $tabs;
    }

    /**
     * Generate a valid cache key from the given element class.
     *
     * @param string $className
     * @return string
     */
    protected function getCacheKey($className)
    {
        return 'Tabs.' . str_replace(['\\'], '-', $className);
    }
}