CollectionManager::__construct() - Code Metrics - Inspection of "Always initialize empty namespace for collectables" - stakx-io/stakx - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 667cd2...043012 )

by Vladimir

created 2020-01-13 05:39 UTC

CollectionManager::__construct() A

↳ Parent: CollectionManager

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
nc	1
nop	5
dl	0
loc	13
rs	9.8333
c	0
b	0
f	0
ccs	7
cts	7
cp	1
crap	1

<?php

/**
 * @copyright 2018 Vladimir Jimenez
 * @license   https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\Manager;

use allejo\stakx\Configuration;
use allejo\stakx\Document\ContentItem;
use allejo\stakx\Document\JailedDocument;
use allejo\stakx\Event\CollectionDefinitionAdded;
use allejo\stakx\Event\CollectionItemAdded;
use allejo\stakx\Exception\TrackedItemNotFoundException;
use allejo\stakx\Filesystem\File;
use allejo\stakx\Filesystem\FileExplorer;
use allejo\stakx\Filesystem\FileExplorerDefinition;
use allejo\stakx\Filesystem\Folder;
use allejo\stakx\MarkupEngine\MarkupEngineManager;
use allejo\stakx\Templating\TemplateBridgeInterface;
use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

/**
 * The class that reads and saves information about all of the collections.
 */
class CollectionManager extends TrackingManager
{
    /** @var string[][] A copy of the collection definitions to be available for later usage. */
    private $collectionDefinitions;
    /** @var MarkupEngineManager */
    private $markupEngineManager;
    /** @var Configuration */
    private $configuration;
    /** @var EventDispatcherInterface */
    private $eventDispatcher;
    /** @var TemplateBridgeInterface */
    private $templateBridge;
    /** @var LoggerInterface */
    private $logger;

    /**
     * CollectionManager constructor.
     */
    public function __construct(
        MarkupEngineManager $markupEngineManager,
        Configuration $configuration,
        TemplateBridgeInterface $templateBridge,
        EventDispatcherInterface $eventDispatcher,
        LoggerInterface $logger
    ) {
        $this->markupEngineManager = $markupEngineManager;
        $this->configuration = $configuration;
        $this->eventDispatcher = $eventDispatcher;
        $this->templateBridge = $templateBridge;
        $this->logger = $logger;
    }

    /**
     * {@inheritdoc}
     */
    public function compileManager()
    {
        if (!$this->configuration->hasCollections())
        {
            $this->logger->notice('No Collections defined... Ignoring');

            return;
        }

        $this->parseCollections($this->configuration->getCollectionsFolders());
    }

    /**
     * Get all of the ContentItems grouped by Collection name.
     *
     * ```php
     * [
     *     'collection name' => [
     *         new ContentItem(),
     *         new ContentItem(),
     *     ]
     * ]
     * ```
     *
     * @return ContentItem[][]
     */
    public function &getCollections()
    {
        return $this->trackedItems;
    }

    /**
     * Get a ContentItem from a Collection passed on it's path.
     *
     * @param string $filePath
     *
     * @throws TrackedItemNotFoundException
     *
     * @return ContentItem
     */
    public function &getContentItem($filePath)
    {
        if (!isset($this->trackedItemsFlattened[$filePath]))
        {
            throw new TrackedItemNotFoundException("The ContentItem at '$filePath' was not found.");
        }

        return $this->trackedItemsFlattened[$filePath];
    }

    /**
     * A jailed representation of CollectionManager::getCollections().
     *
     * @return JailedDocument[][]

     */
    public function getJailedCollections()
    {
        return self::getJailedTrackedItems($this->trackedItemsFlattened, function ($contentItem) {
            return $contentItem['basename'];
        });
    }

    /**
     * Parse every collection and store them in the manager.
     *
     * @param string[][] $collections An array of definitions for collections
     */
    public function parseCollections($collections)
    {
        if ($collections == null || empty($collections))
        {
            $this->logger->debug('No collections found, nothing to parse.');

            return;
        }

        $this->collectionDefinitions = $collections;

        /**
         * The information which each collection has taken from the configuration file.
         *
         * $collection['name']   string The name of the collection
         *            ['folder'] string The folder where this collection has its ContentItems
         *
         * @var array
         */
        foreach ($collections as $collection)
        {
            $this->logger->notice('Loading "{name}" collection...', [
                'name' => $collection['name'],
            ]);

            $folder = new Folder($collection['folder']);

            $event = new CollectionDefinitionAdded($collection['name'], $folder);
            $this->eventDispatcher->dispatch(CollectionDefinitionAdded::NAME, $event);

            // Only fetch ContentItems with supported extensions
            $def = new FileExplorerDefinition($folder);
            $def->flags |= FileExplorer::INCLUDE_ONLY_FILES;
            $def->includes = [
                sprintf('/\.(%s)$/', implode('|', $this->markupEngineManager->getSupportedExtensions())),
            ];

            $this->declareTrackingNamespace($collection['name']);
            $this->scanTrackableItems($def, [
                'namespace' => $collection['name'],
            ]);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function createNewItem($filePath)
    {
        $collection = $this->getCollectionNameFromPath($filePath);

        return $this->handleTrackableItem($filePath, [
            'namespace' => $collection,
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function refreshItem($filePath)
    {
    }

    /**
     * {@inheritdoc}
     */
    protected function handleTrackableItem(File $filePath, array $options = [])
    {
        $collectionName = $options['namespace'];

        $contentItem = new ContentItem($filePath);
        $contentItem->setTemplateEngine($this->templateBridge);
        $contentItem->setMarkupEngine($this->markupEngineManager);
        $contentItem->setNamespace($collectionName);
        $contentItem->evaluateFrontMatter([], [
            'site' => $this->configuration->getConfiguration(),
        ]);

        $this->addObjectToTracker($contentItem, $collectionName);

        $this->logger->info('Loading ContentItem into "{name}" collection: {path}', [
            'name' => $collectionName,
            'path' => $filePath->getRelativeFilePath(),
        ]);

        $event = new CollectionItemAdded($contentItem);
        $this->eventDispatcher->dispatch(CollectionItemAdded::NAME, $event);

        return $contentItem;
    }

    /**
     * Get the name of the Collection this ContentItem belongs to based on its location.
     *
     * @param File $file
     *
     * @return string
     */
    private function getCollectionNameFromPath(File $file)
    {
        $folders = array_column($this->collectionDefinitions, 'folder');
        $index = array_search($file->getRelativeParentFolder(), $folders);

        if (isset($this->collectionDefinitions[$index]['name']))
        {
            return $this->collectionDefinitions[$index]['name'];
        }

        return '';
    }
}


1		<?php
2
3		/**
4		* @copyright 2018 Vladimir Jimenez
5		* @license https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
6		*/
7
8		namespace allejo\stakx\Manager;
9
10		use allejo\stakx\Configuration;
11		use allejo\stakx\Document\ContentItem;
12		use allejo\stakx\Document\JailedDocument;
13		use allejo\stakx\Event\CollectionDefinitionAdded;
14		use allejo\stakx\Event\CollectionItemAdded;
15		use allejo\stakx\Exception\TrackedItemNotFoundException;
16		use allejo\stakx\Filesystem\File;
17		use allejo\stakx\Filesystem\FileExplorer;
18		use allejo\stakx\Filesystem\FileExplorerDefinition;
19		use allejo\stakx\Filesystem\Folder;
20		use allejo\stakx\MarkupEngine\MarkupEngineManager;
21		use allejo\stakx\Templating\TemplateBridgeInterface;
22		use Psr\Log\LoggerInterface;
23		use Symfony\Component\EventDispatcher\EventDispatcherInterface;
24
25		/**
26		* The class that reads and saves information about all of the collections.
27		*/
28		class CollectionManager extends TrackingManager
29		{
30		/** @var string[][] A copy of the collection definitions to be available for later usage. */
31		private $collectionDefinitions;
32		/** @var MarkupEngineManager */
33		private $markupEngineManager;
34		/** @var Configuration */
35		private $configuration;
36		/** @var EventDispatcherInterface */
37		private $eventDispatcher;
38		/** @var TemplateBridgeInterface */
39		private $templateBridge;
40		/** @var LoggerInterface */
41		private $logger;
42
43		/**
44		* CollectionManager constructor.
45		*/
46	36	public function __construct(
47		MarkupEngineManager $markupEngineManager,
48		Configuration $configuration,
49		TemplateBridgeInterface $templateBridge,
50		EventDispatcherInterface $eventDispatcher,
51		LoggerInterface $logger
52		) {
53	36	$this->markupEngineManager = $markupEngineManager;
54	36	$this->configuration = $configuration;
55	36	$this->eventDispatcher = $eventDispatcher;
56	36	$this->templateBridge = $templateBridge;
57	36	$this->logger = $logger;
58	36	}
59
60		/**
61		* {@inheritdoc}
62		*/
63	6	public function compileManager()
64		{
65	6	if (!$this->configuration->hasCollections())
66		{
67		$this->logger->notice('No Collections defined... Ignoring');
68
69		return;
70		}
71
72	6	$this->parseCollections($this->configuration->getCollectionsFolders());
73	6	}
74
75		/**
76		* Get all of the ContentItems grouped by Collection name.
77		*
78		* ```php
79		* [
80		* 'collection name' => [
81		* new ContentItem(),
82		* new ContentItem(),
83		* ]
84		* ]
85		* ```
86		*
87		* @return ContentItem[][]
88		*/
89	15	public function &getCollections()
90		{
91	15	return $this->trackedItems;
92		}
93
94		/**
95		* Get a ContentItem from a Collection passed on it's path.
96		*
97		* @param string $filePath
98		*
99		* @throws TrackedItemNotFoundException
100		*
101		* @return ContentItem
102		*/
103	1	public function &getContentItem($filePath)
104		{
105	1	if (!isset($this->trackedItemsFlattened[$filePath]))
106		{
107		throw new TrackedItemNotFoundException("The ContentItem at '$filePath' was not found.");
108		}
109
110	1	return $this->trackedItemsFlattened[$filePath];
111		}
112
113		/**
114		* A jailed representation of CollectionManager::getCollections().
115		*
116		* @return JailedDocument[][]
		0 ignored issues – show Documentation introduced 2017-06-26 02:02 UTC by Report Bug Copy Issue Report Should the return type not be `array<JailedDocument\|JailedDocument[]>`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
117		*/
118		public function getJailedCollections()
119		{
120	19	return self::getJailedTrackedItems($this->trackedItemsFlattened, function ($contentItem) {
121	19	return $contentItem['basename'];
122	19	});
123		}
124
125		/**
126		* Parse every collection and store them in the manager.
127		*
128		* @param string[][] $collections An array of definitions for collections
129		*/
130	36	public function parseCollections($collections)
131		{
132	36	if ($collections == null \|\| empty($collections))
133		{
134	1	$this->logger->debug('No collections found, nothing to parse.');
135
136	1	return;
137		}
138
139	36	$this->collectionDefinitions = $collections;
140
141		/**
142		* The information which each collection has taken from the configuration file.
143		*
144		* $collection['name'] string The name of the collection
145		* ['folder'] string The folder where this collection has its ContentItems
146		*
147		* @var array
148		*/
149	36	foreach ($collections as $collection)
150		{
151	36	$this->logger->notice('Loading "{name}" collection...', [
152	36	'name' => $collection['name'],
153		]);
154
155	36	$folder = new Folder($collection['folder']);
156
157	36	$event = new CollectionDefinitionAdded($collection['name'], $folder);
158	36	$this->eventDispatcher->dispatch(CollectionDefinitionAdded::NAME, $event);
159
160		// Only fetch ContentItems with supported extensions
161	36	$def = new FileExplorerDefinition($folder);
162	36	$def->flags \|= FileExplorer::INCLUDE_ONLY_FILES;
163	36	$def->includes = [
164	36	sprintf('/\.(%s)$/', implode('\|', $this->markupEngineManager->getSupportedExtensions())),
165		];
166
167	36	$this->declareTrackingNamespace($collection['name']);
168	36	$this->scanTrackableItems($def, [
169	36	'namespace' => $collection['name'],
170		]);
171		}
172	36	}
173
174		/**
175		* {@inheritdoc}
176		*/
177	1	public function createNewItem($filePath)
178		{
179	1	$collection = $this->getCollectionNameFromPath($filePath);
180
181	1	return $this->handleTrackableItem($filePath, [
182	1	'namespace' => $collection,
183		]);
184		}
185
186		/**
187		* {@inheritdoc}
188		*/
189		public function refreshItem($filePath)
190		{
191		}
192
193		/**
194		* {@inheritdoc}
195		*/
196	36	protected function handleTrackableItem(File $filePath, array $options = [])
197		{
198	36	$collectionName = $options['namespace'];
199
200	36	$contentItem = new ContentItem($filePath);
201	36	$contentItem->setTemplateEngine($this->templateBridge);
202	36	$contentItem->setMarkupEngine($this->markupEngineManager);
203	36	$contentItem->setNamespace($collectionName);
204	36	$contentItem->evaluateFrontMatter([], [
205	36	'site' => $this->configuration->getConfiguration(),
206		]);
207
208	36	$this->addObjectToTracker($contentItem, $collectionName);
209
210	36	$this->logger->info('Loading ContentItem into "{name}" collection: {path}', [
211	36	'name' => $collectionName,
212	36	'path' => $filePath->getRelativeFilePath(),
213		]);
214
215	36	$event = new CollectionItemAdded($contentItem);
216	36	$this->eventDispatcher->dispatch(CollectionItemAdded::NAME, $event);
217
218	36	return $contentItem;
219		}
220
221		/**
222		* Get the name of the Collection this ContentItem belongs to based on its location.
223		*
224		* @param File $file
225		*
226		* @return string
227		*/
228	1	private function getCollectionNameFromPath(File $file)
229		{
230	1	$folders = array_column($this->collectionDefinitions, 'folder');
231	1	$index = array_search($file->getRelativeParentFolder(), $folders);
232
233	1	if (isset($this->collectionDefinitions[$index]['name']))
234		{
235	1	return $this->collectionDefinitions[$index]['name'];
236		}
237
238		return '';
239		}
240		}
241

stakx-io / stakx

Push — develop ( 667cd2...043012 )

CollectionManager::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like