BlockRegistrationManager::trackAssetManagersForBlocks() - Code Metrics - Inspection of "Daily Inspection: Create folder for Custom errors..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — Gutenberg/master (3b2a95)

unknown

created 2018-08-10 21:54 UTC

trackAssetManagersForBlocks() A

↳ Parent: BlockRegistrationManager

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
nc	3
nop	1
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0

<?php

namespace EventEspresso\core\services\editor;

use EventEspresso\core\domain\entities\editor\BlockCollection;
use EventEspresso\core\domain\entities\editor\BlockInterface;
use EventEspresso\core\exceptions\ExceptionStackTraceDisplay;
use EventEspresso\core\exceptions\InvalidClassException;
use EventEspresso\core\exceptions\InvalidEntityException;
use EventEspresso\core\services\assets\BlockAssetManagerCollection;
use EventEspresso\core\services\collections\CollectionDetails;
use EventEspresso\core\services\collections\CollectionDetailsException;
use EventEspresso\core\services\collections\CollectionInterface;
use EventEspresso\core\services\collections\CollectionLoader;
use EventEspresso\core\services\collections\CollectionLoaderException;
use EventEspresso\core\services\request\RequestInterface;
use EventEspresso\core\services\route_match\RouteMatchSpecificationManager;
use Exception;
use WP_Block_Type;

/**
 * Class BlockRegistrationManager
 * Loads BlockInterface classes into the injected BlockCollection,
 * which can be used in other classes by retrieving it from EE's Loader.
 * After loading, the BlockManager gets each Block to register
 * its block type and ensures assets are enqueued at the appropriate time
 *
 * @package EventEspresso\core\domain\services\editor
 * @author  Brent Christensen
 * @since   $VID:$
 */
class BlockRegistrationManager extends BlockManager
{

    /**
     * @var BlockAssetManagerCollection $block_asset_manager_collection
     */
    protected $block_asset_manager_collection;

    /**
     * @var RouteMatchSpecificationManager $route_manager
     */
    protected $route_manager;

    /**
     * array for tracking asset managers required by blocks for the current route
     *
     * @var array $block_asset_managers
     */
    protected $block_asset_managers = array();


    /**
     * BlockRegistrationManager constructor.
     *
     * @param BlockAssetManagerCollection    $block_asset_manager_collection
     * @param BlockCollection                $blocks
     * @param RouteMatchSpecificationManager $route_manager
     * @param RequestInterface               $request
     */
    public function __construct(
        BlockAssetManagerCollection $block_asset_manager_collection,
        BlockCollection $blocks,
        RouteMatchSpecificationManager $route_manager,
        RequestInterface $request
    ) {
        $this->block_asset_manager_collection = $block_asset_manager_collection;
        $this->route_manager = $route_manager;
        parent::__construct($blocks, $request);
    }


    /**
     *  Returns the name of a hookpoint to be used to call initialize()
     *
     * @return string
     */
    public function initHook()
    {
        return 'AHEE__EE_System__initialize';
    }


    /**
     * Perform any early setup required for block editors to functions
     *
     * @return void
     * @throws Exception
     */
    public function initialize()
    {
        $this->initializeBlocks();
        add_action('AHEE__EE_System__initialize_last', array($this, 'registerBlocks'));
        add_action('wp_loaded', array($this, 'unloadAssets'));
    }


    /**
     * @return CollectionInterface|BlockInterface[]
     * @throws CollectionLoaderException
     * @throws CollectionDetailsException
     */
    protected function populateBlockCollection()
    {
        $loader = new CollectionLoader(
            new CollectionDetails(
                // collection name
                'editor_blocks',
                // collection interface
                'EventEspresso\core\domain\entities\editor\BlockInterface',
                // FQCNs for classes to add (all classes within each namespace will be loaded)
                apply_filters(
                    'FHEE__EventEspresso_core_services_editor_BlockManager__populateBlockCollection__collection_FQCNs',
                    array(
                        // 'EventEspresso\core\domain\entities\editor\blocks\common',
                        // 'EventEspresso\core\domain\entities\editor\blocks\editor',
                        // 'EventEspresso\core\domain\entities\editor\blocks\widgets',
                    )
                ),
                // filepaths to classes to add
                array(),
                // file mask to use if parsing folder for files to add
                '',
                // what to use as identifier for collection entities
                // using CLASS NAME prevents duplicates (works like a singleton)
                CollectionDetails::ID_CLASS_NAME
            ),
            $this->blocks
        );
        return $loader->getCollection();
    }


    /**
     * populates the BlockCollection and calls initialize() on all installed blocks
     *
     * @return void
     * @throws Exception
     */
    public function initializeBlocks()
    {
        try {
            $this->populateBlockCollection();
            // cycle thru block loaders and initialize each loader
            foreach ($this->blocks as $block) {
                $block->initialize();
                $this->trackAssetManagersForBlocks($block);
                if (! $this->block_asset_manager_collection->has($block->assetManager())) {
                    $this->block_asset_manager_collection->add($block->assetManager());
                    $block->assetManager()->setAssetHandles();
                }
            }
        } catch (Exception $exception) {
            new ExceptionStackTraceDisplay($exception);
        }
    }


    /**
     * track blocks with routes that match the current request
     *
     * @param BlockInterface $block
     * @throws InvalidClassException
     */
    private function trackAssetManagersForBlocks(BlockInterface $block)
    {
        $supported_routes = $block->supportedRoutes();
        foreach ($supported_routes as $supported_route) {
            if ($this->route_manager->routeMatchesCurrentRequest($supported_route)) {
                $this->block_asset_managers[ $block->blockType() ] = $block->assetManager()->assetNamespace();
            }
        }
    }


    /**
     * returns true if the block should be registered for the current request
     * else removes block from block_routes array and returns false
     *
     * @param BlockInterface $block
     * @return boolean
     * @throws InvalidClassException
     */
    public function matchesRoute(BlockInterface $block)
    {
        if (isset($this->block_asset_managers[ $block->blockType() ])) {
            return true;
        }
        unset($this->block_asset_managers[ $block->blockType() ]);
        return false;
    }


    /**
     * calls registerBlock() and load assets for all installed blocks
     *
     * @return void
     * @throws Exception
     */
    public function registerBlocks()
    {
        try {
            // cycle thru block loader folders
            foreach ($this->blocks as $block) {
                if (! $this->matchesRoute($block)) {
                    continue;
                }
                // perform any setup required for the block
                $block_type = $block->registerBlock();
                if (! $block_type instanceof WP_Block_Type) {

                    throw new InvalidEntityException($block_type, 'WP_Block_Type');
                }
                do_action(
                    'FHEE__EventEspresso_core_services_editor_BlockManager__registerBlocks__block_type_registered',
                    $block,
                    $block_type
                );
            }
        } catch (Exception $exception) {
            new ExceptionStackTraceDisplay($exception);
        }
    }

    public function unloadAssets()
    {
        $assets = array_flip($this->block_asset_managers);
        foreach ($this->block_asset_manager_collection as $asset_manager) {
            // if there are no longer any blocks that require these assets,
            if (! isset($assets[ $asset_manager->assetNamespace() ])) {
                // then unset asset enqueueing and bail
                remove_action('wp_enqueue_scripts', array($asset_manager, 'addManifestFile'), 0);
                remove_action('admin_enqueue_scripts', array($asset_manager, 'addManifestFile'), 0);
                remove_action('wp_enqueue_scripts', array($asset_manager, 'addAssets'), 2);
                remove_action('admin_enqueue_scripts', array($asset_manager, 'addAssets'), 2);
            }
        }
    }
}


1			<?php
2
3			namespace EventEspresso\core\services\editor;
4
5			use EventEspresso\core\domain\entities\editor\BlockCollection;
6			use EventEspresso\core\domain\entities\editor\BlockInterface;
7			use EventEspresso\core\exceptions\ExceptionStackTraceDisplay;
8			use EventEspresso\core\exceptions\InvalidClassException;
9			use EventEspresso\core\exceptions\InvalidEntityException;
10			use EventEspresso\core\services\assets\BlockAssetManagerCollection;
11			use EventEspresso\core\services\collections\CollectionDetails;
12			use EventEspresso\core\services\collections\CollectionDetailsException;
13			use EventEspresso\core\services\collections\CollectionInterface;
14			use EventEspresso\core\services\collections\CollectionLoader;
15			use EventEspresso\core\services\collections\CollectionLoaderException;
16			use EventEspresso\core\services\request\RequestInterface;
17			use EventEspresso\core\services\route_match\RouteMatchSpecificationManager;
18			use Exception;
19			use WP_Block_Type;
20
21			/**
22			* Class BlockRegistrationManager
23			* Loads BlockInterface classes into the injected BlockCollection,
24			* which can be used in other classes by retrieving it from EE's Loader.
25			* After loading, the BlockManager gets each Block to register
26			* its block type and ensures assets are enqueued at the appropriate time
27			*
28			* @package EventEspresso\core\domain\services\editor
29			* @author Brent Christensen
30			* @since $VID:$
31			*/
32			class BlockRegistrationManager extends BlockManager
33			{
34
35			/**
36			* @var BlockAssetManagerCollection $block_asset_manager_collection
37			*/
38			protected $block_asset_manager_collection;
39
40			/**
41			* @var RouteMatchSpecificationManager $route_manager
42			*/
43			protected $route_manager;
44
45			/**
46			* array for tracking asset managers required by blocks for the current route
47			*
48			* @var array $block_asset_managers
49			*/
50			protected $block_asset_managers = array();
51
52
53			/**
54			* BlockRegistrationManager constructor.
55			*
56			* @param BlockAssetManagerCollection $block_asset_manager_collection
57			* @param BlockCollection $blocks
58			* @param RouteMatchSpecificationManager $route_manager
59			* @param RequestInterface $request
60			*/
61			public function __construct(
62			BlockAssetManagerCollection $block_asset_manager_collection,
63			BlockCollection $blocks,
64			RouteMatchSpecificationManager $route_manager,
65			RequestInterface $request
66			) {
67			$this->block_asset_manager_collection = $block_asset_manager_collection;
68			$this->route_manager = $route_manager;
69			parent::__construct($blocks, $request);
70			}
71
72
73			/**
74			* Returns the name of a hookpoint to be used to call initialize()
75			*
76			* @return string
77			*/
78			public function initHook()
79			{
80			return 'AHEE__EE_System__initialize';
81			}
82
83
84			/**
85			* Perform any early setup required for block editors to functions
86			*
87			* @return void
88			* @throws Exception
89			*/
90			public function initialize()
91			{
92			$this->initializeBlocks();
93			add_action('AHEE__EE_System__initialize_last', array($this, 'registerBlocks'));
94			add_action('wp_loaded', array($this, 'unloadAssets'));
95			}
96
97
98			/**
99			* @return CollectionInterface\|BlockInterface[]
100			* @throws CollectionLoaderException
101			* @throws CollectionDetailsException
102			*/
103			protected function populateBlockCollection()
104			{
105			$loader = new CollectionLoader(
106			new CollectionDetails(
107			// collection name
108			'editor_blocks',
109			// collection interface
110			'EventEspresso\core\domain\entities\editor\BlockInterface',
111			// FQCNs for classes to add (all classes within each namespace will be loaded)
112			apply_filters(
113			'FHEE__EventEspresso_core_services_editor_BlockManager__populateBlockCollection__collection_FQCNs',
114			array(
115			// 'EventEspresso\core\domain\entities\editor\blocks\common',
116			// 'EventEspresso\core\domain\entities\editor\blocks\editor',
117			// 'EventEspresso\core\domain\entities\editor\blocks\widgets',
118			)
119			),
120			// filepaths to classes to add
121			array(),
122			// file mask to use if parsing folder for files to add
123			'',
124			// what to use as identifier for collection entities
125			// using CLASS NAME prevents duplicates (works like a singleton)
126			CollectionDetails::ID_CLASS_NAME
127			),
128			$this->blocks
129			);
130			return $loader->getCollection();
131			}
132
133
134			/**
135			* populates the BlockCollection and calls initialize() on all installed blocks
136			*
137			* @return void
138			* @throws Exception
139			*/
140			public function initializeBlocks()
141			{
142			try {
143			$this->populateBlockCollection();
144			// cycle thru block loaders and initialize each loader
145			foreach ($this->blocks as $block) {
146			$block->initialize();
147			$this->trackAssetManagersForBlocks($block);
148			if (! $this->block_asset_manager_collection->has($block->assetManager())) {
149			$this->block_asset_manager_collection->add($block->assetManager());
150			$block->assetManager()->setAssetHandles();
151			}
152			}
153			} catch (Exception $exception) {
154			new ExceptionStackTraceDisplay($exception);
155			}
156			}
157
158
159			/**
160			* track blocks with routes that match the current request
161			*
162			* @param BlockInterface $block
163			* @throws InvalidClassException
164			*/
165			private function trackAssetManagersForBlocks(BlockInterface $block)
166			{
167			$supported_routes = $block->supportedRoutes();
168			foreach ($supported_routes as $supported_route) {
169			if ($this->route_manager->routeMatchesCurrentRequest($supported_route)) {
170			$this->block_asset_managers[ $block->blockType() ] = $block->assetManager()->assetNamespace();
171			}
172			}
173			}
174
175
176			/**
177			* returns true if the block should be registered for the current request
178			* else removes block from block_routes array and returns false
179			*
180			* @param BlockInterface $block
181			* @return boolean
182			* @throws InvalidClassException
183			*/
184			public function matchesRoute(BlockInterface $block)
185			{
186			if (isset($this->block_asset_managers[ $block->blockType() ])) {
187			return true;
188			}
189			unset($this->block_asset_managers[ $block->blockType() ]);
190			return false;
191			}
192
193
194			/**
195			* calls registerBlock() and load assets for all installed blocks
196			*
197			* @return void
198			* @throws Exception
199			*/
200			public function registerBlocks()
201			{
202			try {
203			// cycle thru block loader folders
204			foreach ($this->blocks as $block) {
205			if (! $this->matchesRoute($block)) {
206			continue;
207			}
208			// perform any setup required for the block
209			$block_type = $block->registerBlock();
210			if (! $block_type instanceof WP_Block_Type) {
			0 ignored issues – show Bug introduced 2018-03-07 22:00 UTC by Report Bug Copy Issue Report The class `WP_Block_Type` does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json? Loading history...
211			throw new InvalidEntityException($block_type, 'WP_Block_Type');
212			}
213			do_action(
214			'FHEE__EventEspresso_core_services_editor_BlockManager__registerBlocks__block_type_registered',
215			$block,
216			$block_type
217			);
218			}
219			} catch (Exception $exception) {
220			new ExceptionStackTraceDisplay($exception);
221			}
222			}
223
224			public function unloadAssets()
225			{
226			$assets = array_flip($this->block_asset_managers);
227			foreach ($this->block_asset_manager_collection as $asset_manager) {
228			// if there are no longer any blocks that require these assets,
229			if (! isset($assets[ $asset_manager->assetNamespace() ])) {
230			// then unset asset enqueueing and bail
231			remove_action('wp_enqueue_scripts', array($asset_manager, 'addManifestFile'), 0);
232			remove_action('admin_enqueue_scripts', array($asset_manager, 'addManifestFile'), 0);
233			remove_action('wp_enqueue_scripts', array($asset_manager, 'addAssets'), 2);
234			remove_action('admin_enqueue_scripts', array($asset_manager, 'addAssets'), 2);
235			}
236			}
237			}
238			}
239

eventespresso / event-espresso-core

Branch — Gutenberg/master (3b2a95)

trackAssetManagersForBlocks() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like