From 3772fdac679d0ac5ea8510e688c11b99325f634f Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Tue, 10 Oct 2023 18:16:57 +0300 Subject: [PATCH 01/42] Adding mode classes --- .../EntityDocRenderer/Mode/CommonDirMode.php | 17 +++++++++++++++++ .../Mode/EntityRendererModeInterface.php | 12 ++++++++++++ .../EntityDocRenderer/Mode/SameDirMode.php | 17 +++++++++++++++++ 3 files changed, 46 insertions(+) create mode 100644 src/Core/Renderer/EntityDocRenderer/Mode/CommonDirMode.php create mode 100644 src/Core/Renderer/EntityDocRenderer/Mode/EntityRendererModeInterface.php create mode 100644 src/Core/Renderer/EntityDocRenderer/Mode/SameDirMode.php diff --git a/src/Core/Renderer/EntityDocRenderer/Mode/CommonDirMode.php b/src/Core/Renderer/EntityDocRenderer/Mode/CommonDirMode.php new file mode 100644 index 00000000..17e86799 --- /dev/null +++ b/src/Core/Renderer/EntityDocRenderer/Mode/CommonDirMode.php @@ -0,0 +1,17 @@ + Date: Tue, 10 Oct 2023 20:23:20 +0300 Subject: [PATCH 02/42] Adding new event --- .../OnCreateDocumentedEntityWrapper.php | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 src/Core/Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php diff --git a/src/Core/Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php b/src/Core/Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php new file mode 100644 index 00000000..5a7a6b4f --- /dev/null +++ b/src/Core/Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php @@ -0,0 +1,21 @@ +documentedEntityWrapper; + } +} From 7fae7471dbfe901e88c98b5200d04d6fea8b276a Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Tue, 10 Oct 2023 20:24:44 +0300 Subject: [PATCH 03/42] Made InitiatorFilePath customizable --- src/Core/Renderer/Context/DocumentedEntityWrapper.php | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/Core/Renderer/Context/DocumentedEntityWrapper.php b/src/Core/Renderer/Context/DocumentedEntityWrapper.php index 51e0cb9e..65674178 100644 --- a/src/Core/Renderer/Context/DocumentedEntityWrapper.php +++ b/src/Core/Renderer/Context/DocumentedEntityWrapper.php @@ -34,7 +34,7 @@ public function getDocRender(): EntityDocRendererInterface */ public function getKey(): string { - return md5("{$this->documentTransformableEntity->getName()}{$this->initiatorFilePath}"); + return md5("{$this->documentTransformableEntity->getName()}{$this->getInitiatorFilePath()}"); } public function getEntityName(): string @@ -52,7 +52,7 @@ private function getUniqueFileName(): string } $usedKeysCounter ??= []; $fileName = $this->documentTransformableEntity->getShortName(); - $initiatorFileDir = dirname($this->initiatorFilePath); + $initiatorFileDir = dirname($this->getInitiatorFilePath()); $counterKey = "{$initiatorFileDir}{$fileName}"; if (!isset($usedKeysCounter[$counterKey])) { @@ -87,7 +87,7 @@ public function getDocumentTransformableEntity(): DocumentTransformableEntityInt */ public function getDocUrl(): string { - $pathParts = explode('/', $this->initiatorFilePath); + $pathParts = explode('/', $this->getInitiatorFilePath()); array_pop($pathParts); $path = implode('/', $pathParts); return "{$path}/{$this->getDocRender()->getDocFileNamespace()}/{$this->getFileName()}"; @@ -97,4 +97,9 @@ public function getInitiatorFilePath(): string { return $this->initiatorFilePath; } + + public function setInitiatorFilePath(string $initiatorFilePath): void + { + $this->initiatorFilePath = $initiatorFilePath; + } } From 0ce487551bc1380e41497109092a90d2e736d12f Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Tue, 10 Oct 2023 20:25:56 +0300 Subject: [PATCH 04/42] Dispatch new events --- .../Context/DocumentedEntityWrappersCollection.php | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/Core/Renderer/Context/DocumentedEntityWrappersCollection.php b/src/Core/Renderer/Context/DocumentedEntityWrappersCollection.php index 75cd0630..2e681a0b 100644 --- a/src/Core/Renderer/Context/DocumentedEntityWrappersCollection.php +++ b/src/Core/Renderer/Context/DocumentedEntityWrappersCollection.php @@ -6,6 +6,8 @@ use BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache; use BumbleDocGen\Core\Parser\Entity\RootEntityInterface; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateDocumentedEntityWrapper; +use BumbleDocGen\Core\Plugin\PluginEventDispatcher; final class DocumentedEntityWrappersCollection implements \IteratorAggregate, \Countable { @@ -16,7 +18,8 @@ final class DocumentedEntityWrappersCollection implements \IteratorAggregate, \C public function __construct( private RendererContext $rendererContext, - private LocalObjectCache $localObjectCache + private LocalObjectCache $localObjectCache, + private PluginEventDispatcher $pluginEventDispatcher ) { } @@ -38,6 +41,8 @@ public function createAndAddDocumentedEntityWrapper(RootEntityInterface $rootEnt $this->rendererContext->getCurrentTemplateFilePatch() ); + $this->pluginEventDispatcher->dispatch(new OnCreateDocumentedEntityWrapper($documentedEntity)); + $parentEntityName = $this->rendererContext->getCurrentDocumentedEntityWrapper()?->getEntityName(); $this->documentedEntitiesRelations[$this->rendererContext->getCurrentTemplateFilePatch()][$parentEntityName][$documentedEntity->getEntityName()] = [ 'entity_name' => $documentedEntity->getEntityName(), From 9685fa6c4c36f3fa74a23b75d21f7fd53d904708 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Tue, 10 Oct 2023 20:27:59 +0300 Subject: [PATCH 05/42] Removing modes --- .../EntityDocRenderer/Mode/CommonDirMode.php | 17 ----------------- .../Mode/EntityRendererModeInterface.php | 12 ------------ .../EntityDocRenderer/Mode/SameDirMode.php | 17 ----------------- 3 files changed, 46 deletions(-) delete mode 100644 src/Core/Renderer/EntityDocRenderer/Mode/CommonDirMode.php delete mode 100644 src/Core/Renderer/EntityDocRenderer/Mode/EntityRendererModeInterface.php delete mode 100644 src/Core/Renderer/EntityDocRenderer/Mode/SameDirMode.php diff --git a/src/Core/Renderer/EntityDocRenderer/Mode/CommonDirMode.php b/src/Core/Renderer/EntityDocRenderer/Mode/CommonDirMode.php deleted file mode 100644 index 17e86799..00000000 --- a/src/Core/Renderer/EntityDocRenderer/Mode/CommonDirMode.php +++ /dev/null @@ -1,17 +0,0 @@ - Date: Tue, 10 Oct 2023 20:32:48 +0300 Subject: [PATCH 06/42] Renaming method to get parent doc path --- .../Context/DocumentedEntityWrapper.php | 18 +++++++++--------- src/Core/Renderer/Context/RendererContext.php | 2 +- src/Core/Renderer/RendererIteratorFactory.php | 6 +++--- .../PhpClassToMd/PhpClassToMdDocRenderer.php | 2 +- .../PhpClassToMd/templates/class.md.twig | 2 +- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/Core/Renderer/Context/DocumentedEntityWrapper.php b/src/Core/Renderer/Context/DocumentedEntityWrapper.php index 65674178..0f13d6a7 100644 --- a/src/Core/Renderer/Context/DocumentedEntityWrapper.php +++ b/src/Core/Renderer/Context/DocumentedEntityWrapper.php @@ -15,12 +15,12 @@ final class DocumentedEntityWrapper { /** * @param DocumentTransformableEntityInterface $documentTransformableEntity An entity that is allowed to be documented - * @param string $initiatorFilePath The file in which the documentation of the entity was requested + * @param string $parentDocFilePath The file in which the documentation of the entity was requested */ public function __construct( private DocumentTransformableEntityInterface $documentTransformableEntity, private LocalObjectCache $localObjectCache, - private string $initiatorFilePath + private string $parentDocFilePath ) { } @@ -34,7 +34,7 @@ public function getDocRender(): EntityDocRendererInterface */ public function getKey(): string { - return md5("{$this->documentTransformableEntity->getName()}{$this->getInitiatorFilePath()}"); + return md5("{$this->documentTransformableEntity->getName()}{$this->getParentDocFilePath()}"); } public function getEntityName(): string @@ -52,7 +52,7 @@ private function getUniqueFileName(): string } $usedKeysCounter ??= []; $fileName = $this->documentTransformableEntity->getShortName(); - $initiatorFileDir = dirname($this->getInitiatorFilePath()); + $initiatorFileDir = dirname($this->getParentDocFilePath()); $counterKey = "{$initiatorFileDir}{$fileName}"; if (!isset($usedKeysCounter[$counterKey])) { @@ -87,19 +87,19 @@ public function getDocumentTransformableEntity(): DocumentTransformableEntityInt */ public function getDocUrl(): string { - $pathParts = explode('/', $this->getInitiatorFilePath()); + $pathParts = explode('/', $this->getParentDocFilePath()); array_pop($pathParts); $path = implode('/', $pathParts); return "{$path}/{$this->getDocRender()->getDocFileNamespace()}/{$this->getFileName()}"; } - public function getInitiatorFilePath(): string + public function getParentDocFilePath(): string { - return $this->initiatorFilePath; + return $this->parentDocFilePath; } - public function setInitiatorFilePath(string $initiatorFilePath): void + public function setParentDocFilePath(string $parentDocFilePath): void { - $this->initiatorFilePath = $initiatorFilePath; + $this->parentDocFilePath = $parentDocFilePath; } } diff --git a/src/Core/Renderer/Context/RendererContext.php b/src/Core/Renderer/Context/RendererContext.php index 5856078a..18a836d9 100644 --- a/src/Core/Renderer/Context/RendererContext.php +++ b/src/Core/Renderer/Context/RendererContext.php @@ -37,7 +37,7 @@ public function getCurrentTemplateFilePatch(): string public function setCurrentDocumentedEntityWrapper(DocumentedEntityWrapper $currentDocumentedEntityWrapper): void { $this->currentDocumentedEntityWrapper = $currentDocumentedEntityWrapper; - $this->setCurrentTemplateFilePatch($currentDocumentedEntityWrapper->getInitiatorFilePath()); + $this->setCurrentTemplateFilePatch($currentDocumentedEntityWrapper->getParentDocFilePath()); } public function getCurrentDocumentedEntityWrapper(): ?DocumentedEntityWrapper diff --git a/src/Core/Renderer/RendererIteratorFactory.php b/src/Core/Renderer/RendererIteratorFactory.php index 65332edd..2cd435c1 100644 --- a/src/Core/Renderer/RendererIteratorFactory.php +++ b/src/Core/Renderer/RendererIteratorFactory.php @@ -138,7 +138,7 @@ public function getDocumentedEntityWrappersWithOutdatedCache(): \Generator $this->markFileNameAsRendered($entityWrapper->getDocUrl()); - $filesDependenciesKey = "{$entityWrapper->getEntityName()}_{$entityWrapper->getInitiatorFilePath()}"; + $filesDependenciesKey = "{$entityWrapper->getEntityName()}_{$entityWrapper->getParentDocFilePath()}"; if ( !$this->configuration->useSharedCache() || !$this->isGeneratedEntityDocumentExists($entityWrapper) || @@ -153,7 +153,7 @@ public function getDocumentedEntityWrappersWithOutdatedCache(): \Generator $this->rootEntityCollectionsGroup->clearOperationsLog(); yield $entityWrapper; } else { - $this->moveCachedDataToCurrentData($entityWrapper->getInitiatorFilePath(), $entityWrapper->getEntityName()); + $this->moveCachedDataToCurrentData($entityWrapper->getParentDocFilePath(), $entityWrapper->getEntityName()); $this->logger->info("Use cached version `{$this->configuration->getOutputDir()}{$entityWrapper->getDocUrl()}`"); ++$skippedCount; continue; @@ -257,7 +257,7 @@ private function isConfigurationVersionChanged(): bool private function isEntityRelationsCacheOutdated(DocumentedEntityWrapper $entityWrapper): bool { $cachedEntitiesRelations = $this->sharedCompressedDocumentFileCache->get('entities_relations', []); - if (!array_key_exists($entityWrapper->getInitiatorFilePath(), $cachedEntitiesRelations)) { + if (!array_key_exists($entityWrapper->getParentDocFilePath(), $cachedEntitiesRelations)) { return true; } diff --git a/src/LanguageHandler/Php/Renderer/EntityDocRenderer/PhpClassToMd/PhpClassToMdDocRenderer.php b/src/LanguageHandler/Php/Renderer/EntityDocRenderer/PhpClassToMd/PhpClassToMdDocRenderer.php index 88aaa972..5c1ffca3 100644 --- a/src/LanguageHandler/Php/Renderer/EntityDocRenderer/PhpClassToMd/PhpClassToMdDocRenderer.php +++ b/src/LanguageHandler/Php/Renderer/EntityDocRenderer/PhpClassToMd/PhpClassToMdDocRenderer.php @@ -50,7 +50,7 @@ public function getRenderedText(DocumentedEntityWrapper $entityWrapper): string { return $this->classRendererTwig->render('class.md.twig', [ 'classEntity' => $entityWrapper->getDocumentTransformableEntity(), - 'generationInitiatorFilePath' => $entityWrapper->getInitiatorFilePath() + 'parentDocFilePath' => $entityWrapper->getParentDocFilePath() ]); } } diff --git a/src/LanguageHandler/Php/Renderer/EntityDocRenderer/PhpClassToMd/templates/class.md.twig b/src/LanguageHandler/Php/Renderer/EntityDocRenderer/PhpClassToMd/templates/class.md.twig index 5239bbbc..540e0be3 100644 --- a/src/LanguageHandler/Php/Renderer/EntityDocRenderer/PhpClassToMd/templates/class.md.twig +++ b/src/LanguageHandler/Php/Renderer/EntityDocRenderer/PhpClassToMd/templates/class.md.twig @@ -1,4 +1,4 @@ -{{ generatePageBreadcrumbs(classEntity.getShortName(), generationInitiatorFilePath, false) }} +{{ generatePageBreadcrumbs(classEntity.getShortName(), parentDocFilePath, false) }} {% include '_classHeader.md.twig' with {'classEntity': classEntity} only %} From 7d730e6b55c551c9e60e2bfb81da80735f670ac5 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Tue, 10 Oct 2023 20:45:21 +0300 Subject: [PATCH 07/42] Adding new event --- .../Renderer/BeforeRenderingEntities.php | 28 +++++++++++++++++++ src/Core/Renderer/Renderer.php | 5 ++++ 2 files changed, 33 insertions(+) create mode 100644 src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php diff --git a/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php b/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php new file mode 100644 index 00000000..2ea578ac --- /dev/null +++ b/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php @@ -0,0 +1,28 @@ +configuration; + } + + public function getRootEntityCollectionsGroup(): RootEntityCollectionsGroup + { + return $this->rootEntityCollectionsGroup; + } +} diff --git a/src/Core/Renderer/Renderer.php b/src/Core/Renderer/Renderer.php index b4551e50..315dc006 100644 --- a/src/Core/Renderer/Renderer.php +++ b/src/Core/Renderer/Renderer.php @@ -9,6 +9,7 @@ use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; use BumbleDocGen\Core\Parser\Entity\RootEntityCollectionsGroup; use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeCreatingDocFile; +use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeRenderingEntities; use BumbleDocGen\Core\Plugin\PluginEventDispatcher; use BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper; use BumbleDocGen\Core\Renderer\Context\RendererContext; @@ -90,6 +91,10 @@ public function run(): void $this->logger->info("Saving `{$filePatch}`"); } + $this->pluginEventDispatcher->dispatch( + new BeforeRenderingEntities($this->configuration, $this->rootEntityCollectionsGroup) + ); + foreach ($this->renderIteratorFactory->getDocumentedEntityWrappersWithOutdatedCache() as $entityWrapper) { /** @var DocumentedEntityWrapper $entityWrapper */ From f08993ff93e8f31523467254addcb3a0ed573982 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Tue, 10 Oct 2023 21:10:42 +0300 Subject: [PATCH 08/42] Adding new event --- .../Event/Renderer/AfterRenderingEntities.php | 28 +++++++++++++++++++ src/Core/Renderer/Renderer.php | 5 ++++ 2 files changed, 33 insertions(+) create mode 100644 src/Core/Plugin/Event/Renderer/AfterRenderingEntities.php diff --git a/src/Core/Plugin/Event/Renderer/AfterRenderingEntities.php b/src/Core/Plugin/Event/Renderer/AfterRenderingEntities.php new file mode 100644 index 00000000..577976c7 --- /dev/null +++ b/src/Core/Plugin/Event/Renderer/AfterRenderingEntities.php @@ -0,0 +1,28 @@ +configuration; + } + + public function getRootEntityCollectionsGroup(): RootEntityCollectionsGroup + { + return $this->rootEntityCollectionsGroup; + } +} diff --git a/src/Core/Renderer/Renderer.php b/src/Core/Renderer/Renderer.php index 315dc006..8bf3dd0b 100644 --- a/src/Core/Renderer/Renderer.php +++ b/src/Core/Renderer/Renderer.php @@ -8,6 +8,7 @@ use BumbleDocGen\Core\Configuration\Configuration; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; use BumbleDocGen\Core\Parser\Entity\RootEntityCollectionsGroup; +use BumbleDocGen\Core\Plugin\Event\Renderer\AfterRenderingEntities; use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeCreatingDocFile; use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeRenderingEntities; use BumbleDocGen\Core\Plugin\PluginEventDispatcher; @@ -113,6 +114,10 @@ public function run(): void $this->logger->info("Saving `{$filePatch}`"); } + $this->pluginEventDispatcher->dispatch( + new AfterRenderingEntities($this->configuration, $this->rootEntityCollectionsGroup) + ); + foreach ($this->renderIteratorFactory->getFilesToRemove() as $file) { $this->fs->remove($file->getPathname()); $this->logger->info("Removing `{$file->getPathname()}` file"); From d4463c8bc96869370f867c39a61eaf6c9733c3b4 Mon Sep 17 00:00:00 2001 From: Mohan Raj Date: Wed, 11 Oct 2023 12:06:33 +0530 Subject: [PATCH 09/42] Add unit test case to ValueToClassTransformer --- .../ValueToClassTransformerTest.php | 85 +++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 tests/Unit/Core/Configuration/ValueTransformer/ValueToClassTransformerTest.php diff --git a/tests/Unit/Core/Configuration/ValueTransformer/ValueToClassTransformerTest.php b/tests/Unit/Core/Configuration/ValueTransformer/ValueToClassTransformerTest.php new file mode 100644 index 00000000..14b59497 --- /dev/null +++ b/tests/Unit/Core/Configuration/ValueTransformer/ValueToClassTransformerTest.php @@ -0,0 +1,85 @@ +valueToClassTransformer = new ValueToClassTransformer(new Container()); + } + + public function testCanTransform(): void + { + $this->assertFalse($this->valueToClassTransformer->canTransform('')); + + $this->assertFalse($this->valueToClassTransformer->canTransform([])); + + $this->assertFalse($this->valueToClassTransformer->canTransform([ + 'class' => 'ClassThatDoesntExists' + ])); + + $this->assertTrue($this->valueToClassTransformer->canTransform([ + 'class' => ValueToClassTransformer::class + ])); + } + + public function testTransform(): void + { + $value = [ + 'class' => Exception::class, + ]; + + $class = $this->valueToClassTransformer->transform($value); + $this->assertInstanceOf(Exception::class, $class); + + $value = [ + 'class' => DocGeneratorFactory::class, + ]; + + $class = $this->valueToClassTransformer->transform($value); + $this->assertInstanceOf(DocGeneratorFactory::class, $class); + + $value = [ + 'class' => Configuration::class, + 'arguments' => [ + [ + 'class' => ConfigurationParameterBag::class, + 'arguments' => [ + ['class' => ValueToClassTransformer::class], + [] + ] + ], + [ + 'class' => LocalObjectCache::class + ], + [ + 'class' => NullLogger::class + ] + ] + ]; + + $class = $this->valueToClassTransformer->transform($value); + $this->assertInstanceOf(Configuration::class, $class); + + + $this->assertNull($this->valueToClassTransformer->transform('')); + } +} From a84b340abf1a68caa291c23ffad983d346991445 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Wed, 11 Oct 2023 16:57:06 +0300 Subject: [PATCH 10/42] Removing unnecessary code --- .../Event/Renderer/AfterRenderingEntities.php | 17 ----------------- .../Event/Renderer/BeforeRenderingEntities.php | 17 ----------------- src/Core/Renderer/Renderer.php | 8 ++------ 3 files changed, 2 insertions(+), 40 deletions(-) diff --git a/src/Core/Plugin/Event/Renderer/AfterRenderingEntities.php b/src/Core/Plugin/Event/Renderer/AfterRenderingEntities.php index 577976c7..e34cfdc4 100644 --- a/src/Core/Plugin/Event/Renderer/AfterRenderingEntities.php +++ b/src/Core/Plugin/Event/Renderer/AfterRenderingEntities.php @@ -4,25 +4,8 @@ namespace BumbleDocGen\Core\Plugin\Event\Renderer; -use BumbleDocGen\Core\Configuration\Configuration; -use BumbleDocGen\Core\Parser\Entity\RootEntityCollectionsGroup; use Symfony\Contracts\EventDispatcher\Event; final class AfterRenderingEntities extends Event { - public function __construct( - private Configuration $configuration, - private RootEntityCollectionsGroup $rootEntityCollectionsGroup - ) { - } - - public function getConfiguration(): Configuration - { - return $this->configuration; - } - - public function getRootEntityCollectionsGroup(): RootEntityCollectionsGroup - { - return $this->rootEntityCollectionsGroup; - } } diff --git a/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php b/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php index 2ea578ac..c574c921 100644 --- a/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php +++ b/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php @@ -4,25 +4,8 @@ namespace BumbleDocGen\Core\Plugin\Event\Renderer; -use BumbleDocGen\Core\Configuration\Configuration; -use BumbleDocGen\Core\Parser\Entity\RootEntityCollectionsGroup; use Symfony\Contracts\EventDispatcher\Event; final class BeforeRenderingEntities extends Event { - public function __construct( - private Configuration $configuration, - private RootEntityCollectionsGroup $rootEntityCollectionsGroup - ) { - } - - public function getConfiguration(): Configuration - { - return $this->configuration; - } - - public function getRootEntityCollectionsGroup(): RootEntityCollectionsGroup - { - return $this->rootEntityCollectionsGroup; - } } diff --git a/src/Core/Renderer/Renderer.php b/src/Core/Renderer/Renderer.php index 8bf3dd0b..367ecc69 100644 --- a/src/Core/Renderer/Renderer.php +++ b/src/Core/Renderer/Renderer.php @@ -92,9 +92,7 @@ public function run(): void $this->logger->info("Saving `{$filePatch}`"); } - $this->pluginEventDispatcher->dispatch( - new BeforeRenderingEntities($this->configuration, $this->rootEntityCollectionsGroup) - ); + $this->pluginEventDispatcher->dispatch(new BeforeRenderingEntities()); foreach ($this->renderIteratorFactory->getDocumentedEntityWrappersWithOutdatedCache() as $entityWrapper) { /** @var DocumentedEntityWrapper $entityWrapper */ @@ -114,9 +112,7 @@ public function run(): void $this->logger->info("Saving `{$filePatch}`"); } - $this->pluginEventDispatcher->dispatch( - new AfterRenderingEntities($this->configuration, $this->rootEntityCollectionsGroup) - ); + $this->pluginEventDispatcher->dispatch(new AfterRenderingEntities()); foreach ($this->renderIteratorFactory->getFilesToRemove() as $file) { $this->fs->remove($file->getPathname()); From abd24954f0b4098fcce68f307e0731cae9c86f95 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 13:34:33 +0300 Subject: [PATCH 11/42] Mute LastPageCommitter plugin errors --- .../LastPageCommitter/LastPageCommitter.php | 35 +++++++++---------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/src/Core/Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php b/src/Core/Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php index a39b2ba6..dcf1b813 100644 --- a/src/Core/Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php +++ b/src/Core/Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php @@ -5,7 +5,6 @@ namespace BumbleDocGen\Core\Plugin\CorePlugin\LastPageCommitter; use BumbleDocGen\Core\Configuration\Configuration; -use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeCreatingDocFile; use BumbleDocGen\Core\Plugin\PluginInterface; use BumbleDocGen\Core\Renderer\Context\RendererContext; @@ -28,26 +27,26 @@ public static function getSubscribedEvents(): array ]; } - /** - * @throws InvalidConfigurationParameterException - */ final public function beforeCreatingDocFile(BeforeCreatingDocFile $event): void { - $gitClientPath = $this->configuration->getGitClientPath(); - $filePath = str_replace( - "{$this->configuration->getProjectRoot()}/", - '', - "{$this->configuration->getTemplatesDir()}{$this->context->getCurrentTemplateFilePatch()}" - ); - exec("{$gitClientPath} log --no-merges -1 {$filePath}", $output); + try { + $gitClientPath = $this->configuration->getGitClientPath(); + $filePath = str_replace( + "{$this->configuration->getProjectRoot()}/", + '', + "{$this->configuration->getTemplatesDir()}{$this->context->getCurrentTemplateFilePatch()}" + ); + exec("{$gitClientPath} log --no-merges -1 {$filePath}", $output); - $content = $event->getContent(); - if (isset($output[2]) && str_contains($output[2], 'Date: ')) { - $author = str_replace('Author:', 'Last page committer:', htmlspecialchars($output[1])); - $date = str_replace('Date:', 'Last modified date:', $output[2]); - $contentRegenerationDate = 'Page content update date: ' . date('D M d Y'); - $content .= "\n\n
\n
\n{$author}
{$date}
{$contentRegenerationDate}
Made with Bumble Documentation Generator
"; + $content = $event->getContent(); + if (isset($output[2]) && str_contains($output[2], 'Date: ')) { + $author = str_replace('Author:', 'Last page committer:', htmlspecialchars($output[1])); + $date = str_replace('Date:', 'Last modified date:', $output[2]); + $contentRegenerationDate = 'Page content update date: ' . date('D M d Y'); + $content .= "\n\n
\n
\n{$author}
{$date}
{$contentRegenerationDate}
Made with Bumble Documentation Generator
"; + } + $event->setContent($content); + } catch (\Exception) { } - $event->setContent($content); } } From 277ff965f4939645cbf4782bc6a1d69a648dd0e3 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 13:34:57 +0300 Subject: [PATCH 12/42] Adding new events --- .../Renderer/BeforeRenderingDocFiles.php | 11 ++++++++++ .../Renderer/OnCreateMainTwigEnvironment.php | 20 +++++++++++++++++++ 2 files changed, 31 insertions(+) create mode 100644 src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php create mode 100644 src/Core/Plugin/Event/Renderer/OnCreateMainTwigEnvironment.php diff --git a/src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php b/src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php new file mode 100644 index 00000000..594dd80c --- /dev/null +++ b/src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php @@ -0,0 +1,11 @@ +filesystemLoader; + } +} From 599be210d734ac16597b766f97cabfc88704441f Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 13:36:38 +0300 Subject: [PATCH 13/42] Changing MainTwigEnvironment create logic --- .../Renderer/Twig/MainTwigEnvironment.php | 30 ++++++++++++++----- 1 file changed, 22 insertions(+), 8 deletions(-) diff --git a/src/Core/Renderer/Twig/MainTwigEnvironment.php b/src/Core/Renderer/Twig/MainTwigEnvironment.php index 1b3ea973..b3b3d24e 100644 --- a/src/Core/Renderer/Twig/MainTwigEnvironment.php +++ b/src/Core/Renderer/Twig/MainTwigEnvironment.php @@ -6,6 +6,8 @@ use BumbleDocGen\Core\Configuration\Configuration; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateMainTwigEnvironment; +use BumbleDocGen\Core\Plugin\PluginEventDispatcher; use Twig\Environment; use Twig\Error\LoaderError; use Twig\Error\RuntimeError; @@ -15,27 +17,39 @@ final class MainTwigEnvironment { private Environment $twig; + private bool $isEnvLoaded = false; + + public function __construct( + private Configuration $configuration, + private MainExtension $mainExtension, + private PluginEventDispatcher $pluginEventDispatcher, + ) { + } /** * @throws InvalidConfigurationParameterException */ - public function __construct( - Configuration $configuration, - MainExtension $mainExtension - ) { - $templateFolder = $configuration->getTemplatesDir(); - $loader = new FilesystemLoader([$templateFolder]); - $this->twig = new Environment($loader); - $this->twig->addExtension($mainExtension); + private function loadMainTwigEnvironment(): void + { + if (!$this->isEnvLoaded) { + $templateFolder = $this->configuration->getTemplatesDir(); + $loader = new FilesystemLoader([$templateFolder]); + $this->pluginEventDispatcher->dispatch(new OnCreateMainTwigEnvironment($loader)); + $this->twig = new Environment($loader); + $this->twig->addExtension($this->mainExtension); + $this->isEnvLoaded = true; + } } /** * @throws SyntaxError * @throws RuntimeError * @throws LoaderError + * @throws InvalidConfigurationParameterException */ public function render($name, array $context = []): string { + $this->loadMainTwigEnvironment(); return $this->twig->render($name, $context); } } From 46055c6200e79e9b7ebcb10bddf079cb83a3faf2 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 13:37:05 +0300 Subject: [PATCH 14/42] Adding template file dto --- src/Core/Renderer/TemplateFile.php | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/Core/Renderer/TemplateFile.php diff --git a/src/Core/Renderer/TemplateFile.php b/src/Core/Renderer/TemplateFile.php new file mode 100644 index 00000000..316cda71 --- /dev/null +++ b/src/Core/Renderer/TemplateFile.php @@ -0,0 +1,22 @@ +rearPath; + } + + public function getRelativeDocPath(): string + { + return $this->relativeDocPath; + } +} From 9dfddc7930bb6ffb5ef1ecea9eb0ce7104d37744 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 14:06:15 +0300 Subject: [PATCH 15/42] Mute errors --- .../Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Core/Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php b/src/Core/Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php index dcf1b813..994a192a 100644 --- a/src/Core/Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php +++ b/src/Core/Plugin/CorePlugin/LastPageCommitter/LastPageCommitter.php @@ -36,7 +36,8 @@ final public function beforeCreatingDocFile(BeforeCreatingDocFile $event): void '', "{$this->configuration->getTemplatesDir()}{$this->context->getCurrentTemplateFilePatch()}" ); - exec("{$gitClientPath} log --no-merges -1 {$filePath}", $output); + + exec("{$gitClientPath} log --no-merges -1 {$filePath} 2>/dev/null", $output); $content = $event->getContent(); if (isset($output[2]) && str_contains($output[2], 'Date: ')) { From 0808f3cb57da2f7997bab1c8a90905db110d332e Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 14:07:40 +0300 Subject: [PATCH 16/42] Adding breadcrumbs template handler event --- .../OnLoadTemplateContentForBreadcrumbs.php | 31 +++++++++++++++++++ .../Breadcrumbs/BreadcrumbsHelper.php | 7 ++++- 2 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 src/Core/Plugin/Event/Renderer/OnLoadTemplateContentForBreadcrumbs.php diff --git a/src/Core/Plugin/Event/Renderer/OnLoadTemplateContentForBreadcrumbs.php b/src/Core/Plugin/Event/Renderer/OnLoadTemplateContentForBreadcrumbs.php new file mode 100644 index 00000000..20f47ccc --- /dev/null +++ b/src/Core/Plugin/Event/Renderer/OnLoadTemplateContentForBreadcrumbs.php @@ -0,0 +1,31 @@ +templateName; + } + + public function setCustomTemplateFilePath(?string $customTemplateFilePath): void + { + $this->customTemplateFilePath = $customTemplateFilePath; + } + + public function getCustomTemplateFilePath(): ?string + { + return $this->customTemplateFilePath; + } +} diff --git a/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php b/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php index aa43054b..4c6170c8 100644 --- a/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php +++ b/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php @@ -8,6 +8,8 @@ use BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache; use BumbleDocGen\Core\Configuration\Configuration; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnLoadTemplateContentForBreadcrumbs; +use BumbleDocGen\Core\Plugin\PluginEventDispatcher; use DI\DependencyException; use DI\NotFoundException; use Symfony\Component\Finder\Finder; @@ -34,6 +36,7 @@ public function __construct( private Configuration $configuration, private LocalObjectCache $localObjectCache, private BreadcrumbsTwigEnvironment $breadcrumbsTwig, + private PluginEventDispatcher $pluginEventDispatcher, private string $prevPageNameTemplate = self::DEFAULT_PREV_PAGE_NAME_TEMPLATE ) { } @@ -44,7 +47,9 @@ public function __construct( private function loadTemplateContent(string $templateName): string { $outputDir = $this->configuration->getTemplatesDir(); - $filePath = "{$outputDir}{$templateName}"; + $event = $this->pluginEventDispatcher->dispatch(new OnLoadTemplateContentForBreadcrumbs($templateName)); + $filePath = $event->getCustomTemplateFilePath(); + $filePath = $filePath ?: "{$outputDir}{$templateName}"; if (!str_ends_with($filePath, '.twig')) { $templateName .= '.twig'; return $this->loadTemplateContent($templateName); From 58e0bcea13010cf50c5f7b0b48a092ea3cc3d4f0 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 14:10:48 +0300 Subject: [PATCH 17/42] Changing rendering method --- src/Core/Renderer/Renderer.php | 6 +- src/Core/Renderer/RendererIteratorFactory.php | 100 +++++++++++------- 2 files changed, 68 insertions(+), 38 deletions(-) diff --git a/src/Core/Renderer/Renderer.php b/src/Core/Renderer/Renderer.php index 367ecc69..28d96cb1 100644 --- a/src/Core/Renderer/Renderer.php +++ b/src/Core/Renderer/Renderer.php @@ -10,6 +10,7 @@ use BumbleDocGen\Core\Parser\Entity\RootEntityCollectionsGroup; use BumbleDocGen\Core\Plugin\Event\Renderer\AfterRenderingEntities; use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeCreatingDocFile; +use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeRenderingDocFiles; use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeRenderingEntities; use BumbleDocGen\Core\Plugin\PluginEventDispatcher; use BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper; @@ -66,9 +67,10 @@ public function run(): void $templateParams[$collectionName] = $rootEntityCollection; } + $this->pluginEventDispatcher->dispatch(new BeforeRenderingDocFiles()); + foreach ($this->renderIteratorFactory->getTemplatesWithOutdatedCache() as $templateFile) { - /**@var \SplFileInfo $templateFile */ - $filePatch = str_replace($templateFolder, '', $templateFile->getRealPath()); + $filePatch = $templateFile->getRelativeDocPath(); if (str_ends_with($filePatch, '.twig')) { $this->rendererContext->setCurrentTemplateFilePatch($filePatch); diff --git a/src/Core/Renderer/RendererIteratorFactory.php b/src/Core/Renderer/RendererIteratorFactory.php index 2cd435c1..c2ab099d 100644 --- a/src/Core/Renderer/RendererIteratorFactory.php +++ b/src/Core/Renderer/RendererIteratorFactory.php @@ -25,6 +25,7 @@ final class RendererIteratorFactory private const INTERNAL_CACHING_SYSTEM_VERSION = 2; private array $renderedFileNames = []; + private array $extraTemplates = []; public function __construct( private RendererContext $rendererContext, @@ -42,6 +43,11 @@ public function __construct( ) { } + public function addExtraTemplate(TemplateFile $templateFile): void + { + $this->extraTemplates[] = $templateFile; + } + /** * @throws InvalidConfigurationParameterException */ @@ -59,44 +65,68 @@ public function getTemplatesWithOutdatedCache(): \Generator ->sortByName() ->files(); + $getAllDocuments = function () use ($finder, $templateFolder): array { + $allDocuments = $this->extraTemplates; + foreach ($finder as $templateFile) { + $docFileRelativeName = str_replace($templateFolder, '', $templateFile->getRealPath()); + $allDocuments[] = new TemplateFile($templateFile->getRealPath(), $docFileRelativeName); + } + return $allDocuments; + }; + $skippedCount = 0; - foreach ($pb->iterate($finder) as $templateFile) { - $templateFileName = str_replace($templateFolder, '', $templateFile->getRealPath()); - $pb->setStepDescription("Processing {$templateFileName} file"); + foreach ($pb->iterate($getAllDocuments()) as $templateFile) { + $pb->setStepDescription("Processing {$templateFile->getRelativeDocPath()} file"); + + $file = $this->prepareDocFileForRendering($templateFile); + if (!$file) { + var_dump(1); + ++$skippedCount; + continue; + } + yield $file; + } + + $processed = $finder->count() - $skippedCount; + $this->io->table([], [ + ['Processed documents:', "{$processed}"], + ['Skipped (without changes):', "{$skippedCount}"], + ]); + } + + /** + * @throws InvalidConfigurationParameterException + */ + private function prepareDocFileForRendering(TemplateFile $templateFile): ?TemplateFile + { + $templateFileName = $templateFile->getRelativeDocPath(); + + $this->rendererContext->clearDependencies(); + $this->rootEntityCollectionsGroup->clearOperationsLog(); + + $this->rendererContext->setCurrentTemplateFilePatch($templateFileName); + $fileDependency = $this->dependencyFactory->createFileDependency( + filePath: $templateFile->getRealPath() + ); + $this->rendererContext->addDependency($fileDependency); + + $this->markFileNameAsRendered($templateFileName); + + if ( + !$this->configuration->useSharedCache() || + !$this->isGeneratedDocumentExists($templateFileName) || + $this->isInternalCachingVersionChanged() || + $this->isConfigurationVersionChanged() || + $this->isFilesDependenciesCacheOutdated($templateFileName) || + $this->isEntitiesOperationsLogCacheOutdated($templateFileName) + ) { $this->rendererContext->clearDependencies(); $this->rootEntityCollectionsGroup->clearOperationsLog(); - $this->rendererContext->setCurrentTemplateFilePatch($templateFileName); $fileDependency = $this->dependencyFactory->createFileDependency( filePath: $templateFile->getRealPath() ); $this->rendererContext->addDependency($fileDependency); - - $this->markFileNameAsRendered($templateFileName); - - if ( - !$this->configuration->useSharedCache() || - !$this->isGeneratedDocumentExists($templateFileName) || - $this->isInternalCachingVersionChanged() || - $this->isConfigurationVersionChanged() || - $this->isFilesDependenciesCacheOutdated($templateFileName) || - $this->isEntitiesOperationsLogCacheOutdated($templateFileName) - ) { - $this->rendererContext->clearDependencies(); - $this->rootEntityCollectionsGroup->clearOperationsLog(); - $this->rendererContext->setCurrentTemplateFilePatch($templateFileName); - $fileDependency = $this->dependencyFactory->createFileDependency( - filePath: $templateFile->getRealPath() - ); - $this->rendererContext->addDependency($fileDependency); - yield $templateFile; - } else { - $this->moveCachedDataToCurrentData($templateFileName); - $this->logger->info("Use cached version `{$templateFile->getRealPath()}`"); - ++$skippedCount; - continue; - } - $this->sharedCompressedDocumentFileCache->set( $this->getOperationsLogCacheKey($templateFileName), $this->rootEntityCollectionsGroup->getOperationsLogWithoutDuplicates() @@ -106,13 +136,11 @@ public function getTemplatesWithOutdatedCache(): \Generator $this->getFilesDependenciesCacheKey($templateFileName), $this->rendererContext->getDependencies() ); + return $templateFile; } - - $processed = $finder->count() - $skippedCount; - $this->io->table([], [ - ['Processed documents:', "{$processed}"], - ['Skipped (without changes):', "{$skippedCount}"], - ]); + $this->moveCachedDataToCurrentData($templateFileName); + $this->logger->info("Use cached version `{$templateFile->getRealPath()}`"); + return null; } /** From 91b2f4cc0e90e59b64007eff189db0ee82fc0412 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 15:33:23 +0300 Subject: [PATCH 18/42] Adding method to check is abstract or not --- src/LanguageHandler/Php/Parser/Entity/ClassEntity.php | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/LanguageHandler/Php/Parser/Entity/ClassEntity.php b/src/LanguageHandler/Php/Parser/Entity/ClassEntity.php index f40d19ca..61cf3940 100644 --- a/src/LanguageHandler/Php/Parser/Entity/ClassEntity.php +++ b/src/LanguageHandler/Php/Parser/Entity/ClassEntity.php @@ -797,6 +797,15 @@ public function getFileContent(): string return $this->getReflection()->isInstantiable(); } + /** + * @throws ReflectionException + * @throws InvalidConfigurationParameterException + */ + #[CacheableMethod] public function isAbstract(): bool + { + return $this->getReflection()->isAbstract(); + } + /** * @throws ReflectionException * @throws InvalidConfigurationParameterException From 5ba978c67da6730cf1e5d1f03f424206c1fc9a51 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 15:33:43 +0300 Subject: [PATCH 19/42] Adding new filters --- .../Parser/Entity/ClassEntityCollection.php | 36 ++++++++++++++++--- 1 file changed, 32 insertions(+), 4 deletions(-) diff --git a/src/LanguageHandler/Php/Parser/Entity/ClassEntityCollection.php b/src/LanguageHandler/Php/Parser/Entity/ClassEntityCollection.php index 4cd1bd6f..717c6635 100644 --- a/src/LanguageHandler/Php/Parser/Entity/ClassEntityCollection.php +++ b/src/LanguageHandler/Php/Parser/Entity/ClassEntityCollection.php @@ -234,10 +234,6 @@ public function filterByPaths(array $paths): ClassEntityCollection return $classEntityCollection; } - /** - * @throws ReflectionException - * @throws InvalidConfigurationParameterException - */ public function filterByNameRegularExpression(string $regexPattern): ClassEntityCollection { $classEntityCollection = $this->cloneForFiltration(); @@ -282,6 +278,38 @@ public function getOnlyInterfaces(): ClassEntityCollection return $classEntityCollection; } + /** + * @throws ReflectionException + * @throws InvalidConfigurationParameterException + */ + public function getOnlyTraits(): ClassEntityCollection + { + $classEntityCollection = $this->cloneForFiltration(); + foreach ($classEntityCollection as $objectId => $classEntity) { + /**@var ClassEntity $classEntity */ + if (!$classEntity->isTrait()) { + $classEntityCollection->remove($objectId); + } + } + return $classEntityCollection; + } + + /** + * @throws ReflectionException + * @throws InvalidConfigurationParameterException + */ + public function getOnlyAbstractClasses(): ClassEntityCollection + { + $classEntityCollection = $this->cloneForFiltration(); + foreach ($classEntityCollection as $objectId => $classEntity) { + /**@var ClassEntity $classEntity */ + if (!$classEntity->isAbstract() || $classEntity->isInterface()) { + $classEntityCollection->remove($objectId); + } + } + return $classEntityCollection; + } + /** * @param string $search * Search query. For the search, only the main part is taken, up to the characters: `::`, `->`, `#`. From 393e4d33b7b1760b6eeea30000f4c7508a0199f1 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 15:34:06 +0300 Subject: [PATCH 20/42] Adding EntityDocUnifiedPlace plugin --- .../EntityDocUnifiedPlacePlugin.php | 82 +++++++++++++++++++ .../templates/__structure/classes.md.twig | 17 ++++ .../templates/__structure/files.md.twig | 7 ++ .../templates/__structure/interfaces.md.twig | 12 +++ .../templates/__structure/readme.md.twig | 10 +++ .../templates/__structure/traits.md.twig | 12 +++ 6 files changed, 140 insertions(+) create mode 100644 src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php create mode 100644 src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/classes.md.twig create mode 100644 src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/files.md.twig create mode 100644 src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/interfaces.md.twig create mode 100644 src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/readme.md.twig create mode 100644 src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/traits.md.twig diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php new file mode 100644 index 00000000..69ca2120 --- /dev/null +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php @@ -0,0 +1,82 @@ + 'onCreateDocumentedEntityWrapper', + OnCreateMainTwigEnvironment::class => 'onCreateMainTwigEnvironment', + BeforeRenderingDocFiles::class => 'beforeRenderingDocFiles', + OnLoadTemplateContentForBreadcrumbs::class => 'onLoadTemplateContentForBreadcrumbs', + ]; + } + + public function onCreateDocumentedEntityWrapper(OnCreateDocumentedEntityWrapper $event): void + { + $structureDirName = self::ENTITY_DOC_STRUCTURE_DIR_NAME; + $event->getDocumentedEntityWrapper()->setParentDocFilePath("/{$structureDirName}/readme.md"); + } + + public function onLoadTemplateContentForBreadcrumbs(OnLoadTemplateContentForBreadcrumbs $event): void + { + if (str_starts_with($event->getTemplateName(), '/' . self::ENTITY_DOC_STRUCTURE_DIR_NAME)) { + $event->setCustomTemplateFilePath(self::TEMPLATES_FOLDER . $event->getTemplateName()); + } + } + + /** + * @throws LoaderError + */ + public function onCreateMainTwigEnvironment(OnCreateMainTwigEnvironment $event): void + { + $event->getFilesystemLoader()->addPath(self::TEMPLATES_FOLDER); + } + + public function beforeRenderingDocFiles(BeforeRenderingDocFiles $event): void + { + $finder = Finder::create() + ->in(self::TEMPLATES_FOLDER) + ->ignoreDotFiles(true) + ->ignoreVCSIgnored(true) + ->reverseSorting() + ->sortByName() + ->files(); + + foreach ($finder as $templateFile) { + $docFileRelativeName = str_replace( + self::TEMPLATES_FOLDER, + '', + $templateFile->getRealPath() + ); + $this->rendererIteratorFactory->addExtraTemplate(new TemplateFile($templateFile->getRealPath(), $docFileRelativeName)); + } + } +} diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/classes.md.twig b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/classes.md.twig new file mode 100644 index 00000000..5830ddec --- /dev/null +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/classes.md.twig @@ -0,0 +1,17 @@ +{% set title = 'Project classes' %} +{% set prevPage = 'Project structure' %} +{{ generatePageBreadcrumbs(title, _self) }} + +{{ "Project classes" | textToHeading('H1') }} + + + + +{% for abstractClassEntity in phpClassEntityCollection.getOnlyAbstractClasses() %} + +{% endfor %} + +{% for classEntity in phpClassEntityCollection.getOnlyInstantiable() %} + +{% endfor %} +
NameNamespace
Abstract classes
{{ abstractClassEntity.getName() }}|short_form{{ abstractClassEntity.getNamespaceName() }}
Classes
{{ classEntity.getName() }}|short_form{{ classEntity.getNamespaceName() }}
\ No newline at end of file diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/files.md.twig b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/files.md.twig new file mode 100644 index 00000000..4fa2665a --- /dev/null +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/files.md.twig @@ -0,0 +1,7 @@ +{% set title = 'Project files map' %} +{% set prevPage = 'Project structure' %} +{{ generatePageBreadcrumbs(title, _self) }} + +{{ "Files map" | textToHeading('H1') }} + +{{ drawClassMap( phpClassEntityCollection ) }} \ No newline at end of file diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/interfaces.md.twig b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/interfaces.md.twig new file mode 100644 index 00000000..38043d92 --- /dev/null +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/interfaces.md.twig @@ -0,0 +1,12 @@ +{% set title = 'Project interfaces' %} +{% set prevPage = 'Project structure' %} +{{ generatePageBreadcrumbs(title, _self) }} + +{{ "Project interfaces" | textToHeading('H1') }} + + + +{% for interfaceEntity in phpClassEntityCollection.getOnlyInterfaces() %} + +{% endfor %} +
NameNamespace
{{ interfaceEntity.getName() }}|short_form{{ interfaceEntity.getNamespaceName() }}
\ No newline at end of file diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/readme.md.twig b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/readme.md.twig new file mode 100644 index 00000000..6768b644 --- /dev/null +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/readme.md.twig @@ -0,0 +1,10 @@ +{% set title = 'Project structure' %} +{% set prevPage = '/' %} +{{ generatePageBreadcrumbs(title, _self) }} + +{{ "Project structure" | textToHeading('H1') }} + +* Interfaces +* Classes +* Traits +* Files map \ No newline at end of file diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/traits.md.twig b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/traits.md.twig new file mode 100644 index 00000000..265b90af --- /dev/null +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/traits.md.twig @@ -0,0 +1,12 @@ +{% set title = 'Project traits' %} +{% set prevPage = 'Project structure' %} +{{ generatePageBreadcrumbs(title, _self) }} + +{{ "Project traits" | textToHeading('H1') }} + + + +{% for traitEntity in phpClassEntityCollection.getOnlyTraits() %} + +{% endfor %} +
NameNamespace
{{ traitEntity.getName() }}|short_form{{ traitEntity.getNamespaceName() }}
\ No newline at end of file From 6095b7162de0ffb717a99255768e85bd96ccb305 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 17:01:15 +0300 Subject: [PATCH 21/42] Adding a new event to manage the doc link loader --- .../Renderer/BeforeLoadAllPagesLinks.php | 24 +++++++++++++++++++ .../Breadcrumbs/BreadcrumbsHelper.php | 21 +++++++++------- 2 files changed, 36 insertions(+), 9 deletions(-) create mode 100644 src/Core/Plugin/Event/Renderer/BeforeLoadAllPagesLinks.php diff --git a/src/Core/Plugin/Event/Renderer/BeforeLoadAllPagesLinks.php b/src/Core/Plugin/Event/Renderer/BeforeLoadAllPagesLinks.php new file mode 100644 index 00000000..570249c4 --- /dev/null +++ b/src/Core/Plugin/Event/Renderer/BeforeLoadAllPagesLinks.php @@ -0,0 +1,24 @@ +templatesDirs; + } + + public function addTemplatesDir(string $dirName): void + { + $this->templatesDirs[] = $dirName; + } +} diff --git a/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php b/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php index 4c6170c8..d4713c32 100644 --- a/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php +++ b/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php @@ -8,6 +8,7 @@ use BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache; use BumbleDocGen\Core\Configuration\Configuration; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; +use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeLoadAllPagesLinks; use BumbleDocGen\Core\Plugin\Event\Renderer\OnLoadTemplateContentForBreadcrumbs; use BumbleDocGen\Core\Plugin\PluginEventDispatcher; use DI\DependencyException; @@ -230,15 +231,17 @@ public function getAllPageLinks(): array } }; - /**@var \SplFileInfo[] $allFiles */ - $allFiles = new \RecursiveIteratorIterator( - new \RecursiveDirectoryIterator( - $templatesDir, - \FilesystemIterator::SKIP_DOTS - ) - ); - foreach ($allFiles as $file) { - $filePatch = str_replace($templatesDir, '', $file->getRealPath()); + $event = $this->pluginEventDispatcher->dispatch(new BeforeLoadAllPagesLinks([$templatesDir])); + + $finder = Finder::create() + ->ignoreVCS(true) + ->ignoreDotFiles(true) + ->ignoreUnreadableDirs() + ->sortByName() + ->in($event->getTemplatesDirs()); + + foreach ($finder->files() as $file) { + $filePatch = str_replace($event->getTemplatesDirs(), '', $file->getRealPath()); if (!str_ends_with($filePatch, '.twig')) { continue; } From 3c9ac441cfcd472c008992b637f260e5333528af Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Thu, 12 Oct 2023 17:01:35 +0300 Subject: [PATCH 22/42] Updating EntityDocUnifiedPlace plugin --- .../EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php | 7 +++++++ .../templates/__structure/{files.md.twig => map.md.twig} | 4 ++-- .../templates/__structure/readme.md.twig | 2 +- 3 files changed, 10 insertions(+), 3 deletions(-) rename src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/{files.md.twig => map.md.twig} (61%) diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php index 69ca2120..beb439ce 100644 --- a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php @@ -4,6 +4,7 @@ namespace BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace; +use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeLoadAllPagesLinks; use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeRenderingDocFiles; use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateDocumentedEntityWrapper; use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateMainTwigEnvironment; @@ -36,6 +37,7 @@ public static function getSubscribedEvents(): array OnCreateMainTwigEnvironment::class => 'onCreateMainTwigEnvironment', BeforeRenderingDocFiles::class => 'beforeRenderingDocFiles', OnLoadTemplateContentForBreadcrumbs::class => 'onLoadTemplateContentForBreadcrumbs', + BeforeLoadAllPagesLinks::class => 'beforeLoadAllPagesLinks' ]; } @@ -79,4 +81,9 @@ public function beforeRenderingDocFiles(BeforeRenderingDocFiles $event): void $this->rendererIteratorFactory->addExtraTemplate(new TemplateFile($templateFile->getRealPath(), $docFileRelativeName)); } } + + public function beforeLoadAllPagesLinks(BeforeLoadAllPagesLinks $event): void + { + $event->addTemplatesDir(self::TEMPLATES_FOLDER); + } } diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/files.md.twig b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/map.md.twig similarity index 61% rename from src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/files.md.twig rename to src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/map.md.twig index 4fa2665a..7d2885f2 100644 --- a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/files.md.twig +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/map.md.twig @@ -1,7 +1,7 @@ -{% set title = 'Project files map' %} +{% set title = 'Project entities map' %} {% set prevPage = 'Project structure' %} {{ generatePageBreadcrumbs(title, _self) }} -{{ "Files map" | textToHeading('H1') }} +{{ "Entities map" | textToHeading('H1') }} {{ drawClassMap( phpClassEntityCollection ) }} \ No newline at end of file diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/readme.md.twig b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/readme.md.twig index 6768b644..2f31c6a7 100644 --- a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/readme.md.twig +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/templates/__structure/readme.md.twig @@ -7,4 +7,4 @@ * Interfaces * Classes * Traits -* Files map \ No newline at end of file +* All entities map \ No newline at end of file From 14bc65b6c376afd0d0892896757569a6128c8e30 Mon Sep 17 00:00:00 2001 From: Mohan Raj Date: Fri, 13 Oct 2023 13:16:12 +0530 Subject: [PATCH 23/42] Add Unit Tests for ValueResolver Namespace --- .../ValueResolver/ArgvValueResolverTest.php | 78 +++++++++++++++++++ .../InternalValueResolverTest.php | 77 ++++++++++++++++++ .../ValueResolver/RefValueResolverTest.php | 76 ++++++++++++++++++ 3 files changed, 231 insertions(+) create mode 100644 tests/Unit/Core/Configuration/ValueResolver/ArgvValueResolverTest.php create mode 100644 tests/Unit/Core/Configuration/ValueResolver/InternalValueResolverTest.php create mode 100644 tests/Unit/Core/Configuration/ValueResolver/RefValueResolverTest.php diff --git a/tests/Unit/Core/Configuration/ValueResolver/ArgvValueResolverTest.php b/tests/Unit/Core/Configuration/ValueResolver/ArgvValueResolverTest.php new file mode 100644 index 00000000..574d9e69 --- /dev/null +++ b/tests/Unit/Core/Configuration/ValueResolver/ArgvValueResolverTest.php @@ -0,0 +1,78 @@ + '/home/john/foo', + 9 => '/bin/phpunit' + ]; + $this->argvValueResolver = new ArgvValueResolver(); + $this->configurationParameterBag = $this->createMock(ConfigurationParameterBag::class); + } + + /** + * @dataProvider dataProviderCollection + */ + public function testArgvValueResolver($value, $expected): void + { + $resolvedValue = $this->argvValueResolver->resolveValue( + $this->configurationParameterBag, + $value + ); + + if (is_array($value) && is_array($expected)) { + foreach ($expected as $key => $val) { + $this->assertEquals($val, $resolvedValue[$key]); + } + + return; + } + + $this->assertEquals($expected, $resolvedValue); + } + + public function dataProviderCollection(): array + { + return [ + 'testSingleValue' => [ + '$value' => '%argv:8%/docs', + '$expected' => '/home/john/foo/docs', + ], + 'testArrayWithPlaceholder' => [ + '$value' => [ + 'project_root' => '%argv:8%/test', + 'output_dir' => '%argv:9%/docs', + ], + '$expected' => [ + 'project_root' => '/home/john/foo/test', + 'output_dir' => '/bin/phpunit/docs', + ], + ], + 'testSingleValueWithoutPlaceholder' => [ + '$value' => 'docs', + '$expected' => 'docs', + ], + 'testDefaultValue' => [ + '$value' => false, + '$expected' => false, + ], + ]; + } +} diff --git a/tests/Unit/Core/Configuration/ValueResolver/InternalValueResolverTest.php b/tests/Unit/Core/Configuration/ValueResolver/InternalValueResolverTest.php new file mode 100644 index 00000000..18db307b --- /dev/null +++ b/tests/Unit/Core/Configuration/ValueResolver/InternalValueResolverTest.php @@ -0,0 +1,77 @@ +internalValueResolver = new InternalValueResolver([ + 'WORKING_DIR' => '/home/john/foo', + 'bin' => '/bin/phpunit' + ]); + $this->configurationParameterBag = $this->createMock(ConfigurationParameterBag::class); + } + + /** + * @dataProvider dataProviderCollection + */ + public function testArgvValueResolver($value, $expected): void + { + $resolvedValue = $this->internalValueResolver->resolveValue( + $this->configurationParameterBag, + $value + ); + + if (is_array($value) && is_array($expected)) { + foreach ($expected as $key => $val) { + $this->assertEquals($val, $resolvedValue[$key]); + } + + return; + } + + $this->assertEquals($expected, $resolvedValue); + } + + public function dataProviderCollection(): array + { + return [ + 'testSingleValue' => [ + '$value' => '%WORKING_DIR%/docs', + '$expected' => '/home/john/foo/docs', + ], + 'testSingleValueWithoutPlaceholder' => [ + '$value' => 'docs', + '$expected' => 'docs', + ], + 'testArrayWithPlaceholder' => [ + '$value' => [ + 'project_root' => '%WORKING_DIR%/test', + 'output_dir' => '%bin%/docs', + ], + '$expected' => [ + 'project_root' => '/home/john/foo/test', + 'output_dir' => '/bin/phpunit/docs', + ], + ], + 'testDefaultValue' => [ + '$value' => false, + '$expected' => false, + ], + ]; + } +} diff --git a/tests/Unit/Core/Configuration/ValueResolver/RefValueResolverTest.php b/tests/Unit/Core/Configuration/ValueResolver/RefValueResolverTest.php new file mode 100644 index 00000000..01f01d13 --- /dev/null +++ b/tests/Unit/Core/Configuration/ValueResolver/RefValueResolverTest.php @@ -0,0 +1,76 @@ +refValueResolver = new RefValueResolver(); + $this->configurationParameterBag = $this->createMock(ConfigurationParameterBag::class); + $this->configurationParameterBag->expects($this->any())->method('get')->willReturn('test'); + } + + /** + * @dataProvider dataProviderCollection + */ + public function testRefValueResolver($value, $expected): void + { + $resolvedValue = $this->refValueResolver->resolveValue( + $this->configurationParameterBag, + $value + ); + + if (is_array($value) && is_array($expected)) { + foreach ($expected as $key => $val) { + $this->assertEquals($val, $resolvedValue[$key]); + } + + return; + } + + $this->assertEquals($expected, $resolvedValue); + } + + public function dataProviderCollection(): array + { + return [ + 'testSingleValue' => [ + '$value' => '%project_root%/docs', + '$expected' => 'test/docs', + ], + 'testArrayWithPlaceholder' => [ + '$value' => [ + 'project_root' => 'test', + 'output_dir' => '%project_root%/docs', + ], + '$expected' => [ + 'project_root' => 'test', + 'output_dir' => 'test/docs', + ], + ], + 'testSingleValueWithoutPlaceholder' => [ + '$value' => 'docs', + '$expected' => 'docs', + ], + 'testDefaultValue' => [ + '$value' => false, + '$expected' => false, + ], + ]; + } +} From 221376a6410658b6d8bc21f3f0c163aeee23cd39 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 13:06:50 +0300 Subject: [PATCH 24/42] Fixing template path getter --- ...=> OnGetTemplatePathByRelativeDocPath.php} | 2 +- .../Breadcrumbs/BreadcrumbsHelper.php | 32 +++++++++---------- src/Core/Renderer/TemplateFile.php | 22 +++++++++++++ .../EntityDocUnifiedPlacePlugin.php | 6 ++-- 4 files changed, 42 insertions(+), 20 deletions(-) rename src/Core/Plugin/Event/Renderer/{OnLoadTemplateContentForBreadcrumbs.php => OnGetTemplatePathByRelativeDocPath.php} (91%) diff --git a/src/Core/Plugin/Event/Renderer/OnLoadTemplateContentForBreadcrumbs.php b/src/Core/Plugin/Event/Renderer/OnGetTemplatePathByRelativeDocPath.php similarity index 91% rename from src/Core/Plugin/Event/Renderer/OnLoadTemplateContentForBreadcrumbs.php rename to src/Core/Plugin/Event/Renderer/OnGetTemplatePathByRelativeDocPath.php index 20f47ccc..946f5816 100644 --- a/src/Core/Plugin/Event/Renderer/OnLoadTemplateContentForBreadcrumbs.php +++ b/src/Core/Plugin/Event/Renderer/OnGetTemplatePathByRelativeDocPath.php @@ -6,7 +6,7 @@ use Symfony\Contracts\EventDispatcher\Event; -final class OnLoadTemplateContentForBreadcrumbs extends Event +final class OnGetTemplatePathByRelativeDocPath extends Event { private ?string $customTemplateFilePath = null; diff --git a/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php b/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php index d4713c32..826a473a 100644 --- a/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php +++ b/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php @@ -9,8 +9,8 @@ use BumbleDocGen\Core\Configuration\Configuration; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeLoadAllPagesLinks; -use BumbleDocGen\Core\Plugin\Event\Renderer\OnLoadTemplateContentForBreadcrumbs; use BumbleDocGen\Core\Plugin\PluginEventDispatcher; +use BumbleDocGen\Core\Renderer\TemplateFile; use DI\DependencyException; use DI\NotFoundException; use Symfony\Component\Finder\Finder; @@ -47,22 +47,19 @@ public function __construct( */ private function loadTemplateContent(string $templateName): string { - $outputDir = $this->configuration->getTemplatesDir(); - $event = $this->pluginEventDispatcher->dispatch(new OnLoadTemplateContentForBreadcrumbs($templateName)); - $filePath = $event->getCustomTemplateFilePath(); - $filePath = $filePath ?: "{$outputDir}{$templateName}"; - if (!str_ends_with($filePath, '.twig')) { - $templateName .= '.twig'; - return $this->loadTemplateContent($templateName); - } + $filePath = TemplateFile::getTemplatePathByRelativeDocPath( + $templateName, + $this->configuration, + $this->pluginEventDispatcher + ); try { - return $this->localObjectCache->getMethodCachedResult(__METHOD__, $templateName); + return $this->localObjectCache->getMethodCachedResult(__METHOD__, $filePath); } catch (ObjectNotFoundException) { } $templateContent = file_get_contents($filePath) ?: ''; - $this->localObjectCache->cacheMethodResult(__METHOD__, $templateName, $templateContent); + $this->localObjectCache->cacheMethodResult(__METHOD__, $filePath, $templateContent); return $templateContent; } @@ -186,19 +183,22 @@ public function getBreadcrumbs(string $filePatch, bool $fromCurrent = true): arr * @throws DependencyException * @throws InvalidConfigurationParameterException */ - public function getBreadcrumbsForTemplates(string $templateFilePatch, bool $fromCurrent = true): array + public function getBreadcrumbsForTemplates(string $filePatch, bool $fromCurrent = true): array { $breadcrumbs = []; - $filePatch = $templateFilePatch; do { - $filePatch = str_replace('.twig', '', $filePatch); if (!$fromCurrent) { $fromCurrent = true; continue; } - $templateFilePatch = "{$this->configuration->getTemplatesDir()}{$filePatch}"; + $filePatch = str_replace('.twig', '', $filePatch); + $templateFilePatch = TemplateFile::getTemplatePathByRelativeDocPath( + $filePatch, + $this->configuration, + $this->pluginEventDispatcher + ); $breadcrumbs[] = [ - 'template' => "$templateFilePatch.twig", + 'template' => $templateFilePatch, 'title' => $this->getTemplateTitle($filePatch), ]; } while ($filePatch = $this->getPrevPage($filePatch)); diff --git a/src/Core/Renderer/TemplateFile.php b/src/Core/Renderer/TemplateFile.php index 316cda71..694e0f7b 100644 --- a/src/Core/Renderer/TemplateFile.php +++ b/src/Core/Renderer/TemplateFile.php @@ -4,12 +4,34 @@ namespace BumbleDocGen\Core\Renderer; +use BumbleDocGen\Core\Configuration\Configuration; +use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetTemplatePathByRelativeDocPath; +use BumbleDocGen\Core\Plugin\PluginEventDispatcher; + final class TemplateFile { public function __construct(private string $rearPath, private string $relativeDocPath) { } + /** + * @throws InvalidConfigurationParameterException + */ + public static function getTemplatePathByRelativeDocPath( + string $relativeDocPath, + Configuration $configuration, + PluginEventDispatcher $pluginEventDispatcher, + ): string { + if (!str_ends_with($relativeDocPath, '.twig')) { + $relativeDocPath .= '.twig'; + } + $outputDir = $configuration->getTemplatesDir(); + $event = $pluginEventDispatcher->dispatch(new OnGetTemplatePathByRelativeDocPath($relativeDocPath)); + $filePath = $event->getCustomTemplateFilePath(); + return $filePath ?: "{$outputDir}{$relativeDocPath}"; + } + public function getRealPath(): string { return $this->rearPath; diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php index beb439ce..74e00ed8 100644 --- a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php @@ -8,7 +8,7 @@ use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeRenderingDocFiles; use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateDocumentedEntityWrapper; use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateMainTwigEnvironment; -use BumbleDocGen\Core\Plugin\Event\Renderer\OnLoadTemplateContentForBreadcrumbs; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetTemplatePathByRelativeDocPath; use BumbleDocGen\Core\Plugin\PluginInterface; use BumbleDocGen\Core\Renderer\RendererIteratorFactory; use BumbleDocGen\Core\Renderer\TemplateFile; @@ -36,7 +36,7 @@ public static function getSubscribedEvents(): array OnCreateDocumentedEntityWrapper::class => 'onCreateDocumentedEntityWrapper', OnCreateMainTwigEnvironment::class => 'onCreateMainTwigEnvironment', BeforeRenderingDocFiles::class => 'beforeRenderingDocFiles', - OnLoadTemplateContentForBreadcrumbs::class => 'onLoadTemplateContentForBreadcrumbs', + OnGetTemplatePathByRelativeDocPath::class => 'onGetFilePathByRelativeDocPath', BeforeLoadAllPagesLinks::class => 'beforeLoadAllPagesLinks' ]; } @@ -47,7 +47,7 @@ public function onCreateDocumentedEntityWrapper(OnCreateDocumentedEntityWrapper $event->getDocumentedEntityWrapper()->setParentDocFilePath("/{$structureDirName}/readme.md"); } - public function onLoadTemplateContentForBreadcrumbs(OnLoadTemplateContentForBreadcrumbs $event): void + public function onGetFilePathByRelativeDocPath(OnGetTemplatePathByRelativeDocPath $event): void { if (str_starts_with($event->getTemplateName(), '/' . self::ENTITY_DOC_STRUCTURE_DIR_NAME)) { $event->setCustomTemplateFilePath(self::TEMPLATES_FOLDER . $event->getTemplateName()); From e8491b2c6b491f295f3e61fc8c0ab2b68a8c1641 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 13:07:07 +0300 Subject: [PATCH 25/42] Removing debug output --- src/Core/Renderer/RendererIteratorFactory.php | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Core/Renderer/RendererIteratorFactory.php b/src/Core/Renderer/RendererIteratorFactory.php index c2ab099d..2c87477e 100644 --- a/src/Core/Renderer/RendererIteratorFactory.php +++ b/src/Core/Renderer/RendererIteratorFactory.php @@ -80,7 +80,6 @@ public function getTemplatesWithOutdatedCache(): \Generator $file = $this->prepareDocFileForRendering($templateFile); if (!$file) { - var_dump(1); ++$skippedCount; continue; } From 48aad0ec8e828a0ea37258de594c17cc222e6048 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 13:07:21 +0300 Subject: [PATCH 26/42] Adding throws info --- src/Core/Renderer/Twig/Function/GeneratePageBreadcrumbs.php | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/Core/Renderer/Twig/Function/GeneratePageBreadcrumbs.php b/src/Core/Renderer/Twig/Function/GeneratePageBreadcrumbs.php index e5c47469..da2aa43f 100644 --- a/src/Core/Renderer/Twig/Function/GeneratePageBreadcrumbs.php +++ b/src/Core/Renderer/Twig/Function/GeneratePageBreadcrumbs.php @@ -8,6 +8,8 @@ use BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsHelper; use BumbleDocGen\Core\Renderer\Context\Dependency\RendererDependencyFactory; use BumbleDocGen\Core\Renderer\Context\RendererContext; +use DI\DependencyException; +use DI\NotFoundException; use Twig\Error\LoaderError; use Twig\Error\RuntimeError; use Twig\Error\SyntaxError; @@ -45,9 +47,11 @@ public static function getOptions(): array * current template, and the reference to it in breadcrumbs should not be clickable. * * @return string - * @throws SyntaxError * @throws RuntimeError + * @throws DependencyException * @throws LoaderError + * @throws SyntaxError + * @throws NotFoundException * @throws InvalidConfigurationParameterException */ public function __invoke( From f611ec5d744d1e9e74fe98b6ef53d4a5e03234ba Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 17:41:08 +0300 Subject: [PATCH 27/42] Optimization of unified folder functionality --- .../Renderer/OnCreateMainTwigEnvironment.php | 20 ------- ...inks.php => OnGetProjectTemplatesDirs.php} | 5 +- .../Breadcrumbs/BreadcrumbsHelper.php | 8 +-- src/Core/Renderer/Renderer.php | 12 ++-- src/Core/Renderer/RendererIteratorFactory.php | 51 ++++++++--------- src/Core/Renderer/TemplateFile.php | 55 ++++++++++++++++++- .../Renderer/Twig/MainTwigEnvironment.php | 9 +-- .../EntityDocUnifiedPlacePlugin.php | 51 ++--------------- 8 files changed, 97 insertions(+), 114 deletions(-) delete mode 100644 src/Core/Plugin/Event/Renderer/OnCreateMainTwigEnvironment.php rename src/Core/Plugin/Event/Renderer/{BeforeLoadAllPagesLinks.php => OnGetProjectTemplatesDirs.php} (86%) diff --git a/src/Core/Plugin/Event/Renderer/OnCreateMainTwigEnvironment.php b/src/Core/Plugin/Event/Renderer/OnCreateMainTwigEnvironment.php deleted file mode 100644 index 291d79da..00000000 --- a/src/Core/Plugin/Event/Renderer/OnCreateMainTwigEnvironment.php +++ /dev/null @@ -1,20 +0,0 @@ -filesystemLoader; - } -} diff --git a/src/Core/Plugin/Event/Renderer/BeforeLoadAllPagesLinks.php b/src/Core/Plugin/Event/Renderer/OnGetProjectTemplatesDirs.php similarity index 86% rename from src/Core/Plugin/Event/Renderer/BeforeLoadAllPagesLinks.php rename to src/Core/Plugin/Event/Renderer/OnGetProjectTemplatesDirs.php index 570249c4..7b02201c 100644 --- a/src/Core/Plugin/Event/Renderer/BeforeLoadAllPagesLinks.php +++ b/src/Core/Plugin/Event/Renderer/OnGetProjectTemplatesDirs.php @@ -6,7 +6,10 @@ use Symfony\Contracts\EventDispatcher\Event; -final class BeforeLoadAllPagesLinks extends Event +/** + * + */ +final class OnGetProjectTemplatesDirs extends Event { public function __construct(private array $templatesDirs) { diff --git a/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php b/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php index 826a473a..1d762c22 100644 --- a/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php +++ b/src/Core/Renderer/Breadcrumbs/BreadcrumbsHelper.php @@ -8,7 +8,7 @@ use BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache; use BumbleDocGen\Core\Configuration\Configuration; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; -use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeLoadAllPagesLinks; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs; use BumbleDocGen\Core\Plugin\PluginEventDispatcher; use BumbleDocGen\Core\Renderer\TemplateFile; use DI\DependencyException; @@ -218,6 +218,8 @@ public function getAllPageLinks(): array } $pageLinks = []; $templatesDir = $this->configuration->getTemplatesDir(); + $event = $this->pluginEventDispatcher->dispatch(new OnGetProjectTemplatesDirs([$templatesDir])); + $templatesDirs = $event->getTemplatesDirs(); $addLinkKey = function (string $key, $value) use (&$pageLinks) { $pageLinks[$key] = $value; @@ -231,8 +233,6 @@ public function getAllPageLinks(): array } }; - $event = $this->pluginEventDispatcher->dispatch(new BeforeLoadAllPagesLinks([$templatesDir])); - $finder = Finder::create() ->ignoreVCS(true) ->ignoreDotFiles(true) @@ -241,7 +241,7 @@ public function getAllPageLinks(): array ->in($event->getTemplatesDirs()); foreach ($finder->files() as $file) { - $filePatch = str_replace($event->getTemplatesDirs(), '', $file->getRealPath()); + $filePatch = str_replace($templatesDirs, '', $file->getRealPath()); if (!str_ends_with($filePatch, '.twig')) { continue; } diff --git a/src/Core/Renderer/Renderer.php b/src/Core/Renderer/Renderer.php index 28d96cb1..c5741f78 100644 --- a/src/Core/Renderer/Renderer.php +++ b/src/Core/Renderer/Renderer.php @@ -70,22 +70,18 @@ public function run(): void $this->pluginEventDispatcher->dispatch(new BeforeRenderingDocFiles()); foreach ($this->renderIteratorFactory->getTemplatesWithOutdatedCache() as $templateFile) { - $filePatch = $templateFile->getRelativeDocPath(); - - if (str_ends_with($filePatch, '.twig')) { - $this->rendererContext->setCurrentTemplateFilePatch($filePatch); - $content = $this->twig->render($filePatch, $templateParams); + if ($templateFile->isTemplate()) { + $this->rendererContext->setCurrentTemplateFilePatch($templateFile->getRelativeTemplatePath()); + $content = $this->twig->render($templateFile->getRelativeTemplatePath(), $templateParams); $content = $this->pluginEventDispatcher->dispatch( new BeforeCreatingDocFile($content, $this->rendererContext) )->getContent(); - - $filePatch = str_replace('.twig', '', $filePatch); } else { $content = file_get_contents($templateFile->getRealPath()); } - $filePatch = "{$outputDir}{$filePatch}"; + $filePatch = "{$outputDir}{$templateFile->getRelativeDocPath()}"; $newDirName = dirname($filePatch); if (!is_dir($newDirName)) { $this->fs->mkdir($newDirName, 0755); diff --git a/src/Core/Renderer/RendererIteratorFactory.php b/src/Core/Renderer/RendererIteratorFactory.php index 2c87477e..ca39c4d1 100644 --- a/src/Core/Renderer/RendererIteratorFactory.php +++ b/src/Core/Renderer/RendererIteratorFactory.php @@ -12,6 +12,8 @@ use BumbleDocGen\Core\Configuration\ConfigurationParameterBag; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; use BumbleDocGen\Core\Parser\Entity\RootEntityCollectionsGroup; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs; +use BumbleDocGen\Core\Plugin\PluginEventDispatcher; use BumbleDocGen\Core\Renderer\Context\Dependency\RendererDependencyFactory; use BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper; use BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrappersCollection; @@ -25,7 +27,6 @@ final class RendererIteratorFactory private const INTERNAL_CACHING_SYSTEM_VERSION = 2; private array $renderedFileNames = []; - private array $extraTemplates = []; public function __construct( private RendererContext $rendererContext, @@ -38,16 +39,12 @@ public function __construct( private RendererDependencyFactory $dependencyFactory, private LocalObjectCache $localObjectCache, private ProgressBarFactory $progressBarFactory, + private PluginEventDispatcher $pluginEventDispatcher, private OutputStyle $io, private Logger $logger, ) { } - public function addExtraTemplate(TemplateFile $templateFile): void - { - $this->extraTemplates[] = $templateFile; - } - /** * @throws InvalidConfigurationParameterException */ @@ -56,26 +53,24 @@ public function getTemplatesWithOutdatedCache(): \Generator $pb = $this->progressBarFactory->createStylizedProgressBar(); $pb->setName('Generating main documentation pages'); - $templateFolder = $this->configuration->getTemplatesDir(); + $templatesDir = $this->configuration->getTemplatesDir(); + $event = $this->pluginEventDispatcher->dispatch(new OnGetProjectTemplatesDirs([$templatesDir])); + $templatesDirs = $event->getTemplatesDirs(); $finder = Finder::create() - ->in($templateFolder) + ->in($templatesDirs) ->ignoreDotFiles(true) ->ignoreVCSIgnored(true) ->reverseSorting() ->sortByName() ->files(); - $getAllDocuments = function () use ($finder, $templateFolder): array { - $allDocuments = $this->extraTemplates; - foreach ($finder as $templateFile) { - $docFileRelativeName = str_replace($templateFolder, '', $templateFile->getRealPath()); - $allDocuments[] = new TemplateFile($templateFile->getRealPath(), $docFileRelativeName); - } - return $allDocuments; - }; - $skippedCount = 0; - foreach ($pb->iterate($getAllDocuments()) as $templateFile) { + foreach ($pb->iterate($finder) as $templateFile) { + $templateFile = TemplateFile::create( + $templateFile, + $this->configuration, + $this->pluginEventDispatcher + ); $pb->setStepDescription("Processing {$templateFile->getRelativeDocPath()} file"); $file = $this->prepareDocFileForRendering($templateFile); @@ -98,46 +93,46 @@ public function getTemplatesWithOutdatedCache(): \Generator */ private function prepareDocFileForRendering(TemplateFile $templateFile): ?TemplateFile { - $templateFileName = $templateFile->getRelativeDocPath(); + $relativeTemplateName = $templateFile->getRelativeTemplatePath() ?: $templateFile->getRelativeDocPath(); $this->rendererContext->clearDependencies(); $this->rootEntityCollectionsGroup->clearOperationsLog(); - $this->rendererContext->setCurrentTemplateFilePatch($templateFileName); + $this->rendererContext->setCurrentTemplateFilePatch($relativeTemplateName); $fileDependency = $this->dependencyFactory->createFileDependency( filePath: $templateFile->getRealPath() ); $this->rendererContext->addDependency($fileDependency); - $this->markFileNameAsRendered($templateFileName); + $this->markFileNameAsRendered($relativeTemplateName); if ( !$this->configuration->useSharedCache() || - !$this->isGeneratedDocumentExists($templateFileName) || + !$this->isGeneratedDocumentExists($relativeTemplateName) || $this->isInternalCachingVersionChanged() || $this->isConfigurationVersionChanged() || - $this->isFilesDependenciesCacheOutdated($templateFileName) || - $this->isEntitiesOperationsLogCacheOutdated($templateFileName) + $this->isFilesDependenciesCacheOutdated($relativeTemplateName) || + $this->isEntitiesOperationsLogCacheOutdated($relativeTemplateName) ) { $this->rendererContext->clearDependencies(); $this->rootEntityCollectionsGroup->clearOperationsLog(); - $this->rendererContext->setCurrentTemplateFilePatch($templateFileName); + $this->rendererContext->setCurrentTemplateFilePatch($relativeTemplateName); $fileDependency = $this->dependencyFactory->createFileDependency( filePath: $templateFile->getRealPath() ); $this->rendererContext->addDependency($fileDependency); $this->sharedCompressedDocumentFileCache->set( - $this->getOperationsLogCacheKey($templateFileName), + $this->getOperationsLogCacheKey($relativeTemplateName), $this->rootEntityCollectionsGroup->getOperationsLogWithoutDuplicates() ); $this->sharedCompressedDocumentFileCache->set( - $this->getFilesDependenciesCacheKey($templateFileName), + $this->getFilesDependenciesCacheKey($relativeTemplateName), $this->rendererContext->getDependencies() ); return $templateFile; } - $this->moveCachedDataToCurrentData($templateFileName); + $this->moveCachedDataToCurrentData($relativeTemplateName); $this->logger->info("Use cached version `{$templateFile->getRealPath()}`"); return null; } diff --git a/src/Core/Renderer/TemplateFile.php b/src/Core/Renderer/TemplateFile.php index 694e0f7b..65089895 100644 --- a/src/Core/Renderer/TemplateFile.php +++ b/src/Core/Renderer/TemplateFile.php @@ -6,13 +6,42 @@ use BumbleDocGen\Core\Configuration\Configuration; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs; use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetTemplatePathByRelativeDocPath; use BumbleDocGen\Core\Plugin\PluginEventDispatcher; +use Symfony\Component\Finder\SplFileInfo; final class TemplateFile { - public function __construct(private string $rearPath, private string $relativeDocPath) + private bool $isTemplate = false; + + public function __construct(private string $realPath, private string $relativeDocPath) + { + $this->isTemplate = str_ends_with($realPath, '.twig'); + } + + public function isTemplate(): bool { + return $this->isTemplate; + } + + /** + * @throws InvalidConfigurationParameterException + */ + public static function create( + SplFileInfo $fileInfo, + Configuration $configuration, + PluginEventDispatcher $pluginEventDispatcher + ): self { + $realPath = $fileInfo->getRealPath(); + return new self( + $realPath, + self::getRelativeDocPathByTemplatePath( + $realPath, + $configuration, + $pluginEventDispatcher + ) + ); } /** @@ -32,13 +61,33 @@ public static function getTemplatePathByRelativeDocPath( return $filePath ?: "{$outputDir}{$relativeDocPath}"; } + /** + * @throws InvalidConfigurationParameterException + */ + public static function getRelativeDocPathByTemplatePath( + string $templatePath, + Configuration $configuration, + PluginEventDispatcher $pluginEventDispatcher, + ): string { + $templatePath = str_replace('.twig', '', $templatePath); + $templatesDir = $configuration->getTemplatesDir(); + $event = $pluginEventDispatcher->dispatch(new OnGetProjectTemplatesDirs([$templatesDir])); + $templatesDirs = $event->getTemplatesDirs(); + return str_replace($templatesDirs, '', $templatePath); + } + public function getRealPath(): string { - return $this->rearPath; + return $this->realPath; } public function getRelativeDocPath(): string { - return $this->relativeDocPath; + return str_replace('.twig', '', $this->relativeDocPath); + } + + public function getRelativeTemplatePath(): ?string + { + return $this->isTemplate ? "{$this->getRelativeDocPath()}.twig" : null; } } diff --git a/src/Core/Renderer/Twig/MainTwigEnvironment.php b/src/Core/Renderer/Twig/MainTwigEnvironment.php index b3b3d24e..b57f5e0d 100644 --- a/src/Core/Renderer/Twig/MainTwigEnvironment.php +++ b/src/Core/Renderer/Twig/MainTwigEnvironment.php @@ -6,7 +6,7 @@ use BumbleDocGen\Core\Configuration\Configuration; use BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException; -use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateMainTwigEnvironment; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs; use BumbleDocGen\Core\Plugin\PluginEventDispatcher; use Twig\Environment; use Twig\Error\LoaderError; @@ -32,9 +32,10 @@ public function __construct( private function loadMainTwigEnvironment(): void { if (!$this->isEnvLoaded) { - $templateFolder = $this->configuration->getTemplatesDir(); - $loader = new FilesystemLoader([$templateFolder]); - $this->pluginEventDispatcher->dispatch(new OnCreateMainTwigEnvironment($loader)); + $templatesDir = $this->configuration->getTemplatesDir(); + $event = $this->pluginEventDispatcher->dispatch(new OnGetProjectTemplatesDirs([$templatesDir])); + $templatesDirs = $event->getTemplatesDirs(); + $loader = new FilesystemLoader($templatesDirs); $this->twig = new Environment($loader); $this->twig->addExtension($this->mainExtension); $this->isEnvLoaded = true; diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php index 74e00ed8..a90eaf7e 100644 --- a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php @@ -4,16 +4,10 @@ namespace BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace; -use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeLoadAllPagesLinks; -use BumbleDocGen\Core\Plugin\Event\Renderer\BeforeRenderingDocFiles; +use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs; use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateDocumentedEntityWrapper; -use BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateMainTwigEnvironment; use BumbleDocGen\Core\Plugin\Event\Renderer\OnGetTemplatePathByRelativeDocPath; use BumbleDocGen\Core\Plugin\PluginInterface; -use BumbleDocGen\Core\Renderer\RendererIteratorFactory; -use BumbleDocGen\Core\Renderer\TemplateFile; -use Symfony\Component\Finder\Finder; -use Twig\Error\LoaderError; /** * This plugin changes the algorithm for saving entity documents. The standard system stores each file @@ -25,19 +19,12 @@ final class EntityDocUnifiedPlacePlugin implements PluginInterface private const TEMPLATES_FOLDER = __DIR__ . DIRECTORY_SEPARATOR . 'templates'; public const ENTITY_DOC_STRUCTURE_DIR_NAME = '__structure'; - public function __construct( - private RendererIteratorFactory $rendererIteratorFactory, - ) { - } - public static function getSubscribedEvents(): array { return [ OnCreateDocumentedEntityWrapper::class => 'onCreateDocumentedEntityWrapper', - OnCreateMainTwigEnvironment::class => 'onCreateMainTwigEnvironment', - BeforeRenderingDocFiles::class => 'beforeRenderingDocFiles', - OnGetTemplatePathByRelativeDocPath::class => 'onGetFilePathByRelativeDocPath', - BeforeLoadAllPagesLinks::class => 'beforeLoadAllPagesLinks' + OnGetTemplatePathByRelativeDocPath::class => 'onGetTemplatePathByRelativeDocPath', + OnGetProjectTemplatesDirs::class => 'onGetProjectTemplatesDirs' ]; } @@ -47,42 +34,14 @@ public function onCreateDocumentedEntityWrapper(OnCreateDocumentedEntityWrapper $event->getDocumentedEntityWrapper()->setParentDocFilePath("/{$structureDirName}/readme.md"); } - public function onGetFilePathByRelativeDocPath(OnGetTemplatePathByRelativeDocPath $event): void + public function onGetTemplatePathByRelativeDocPath(OnGetTemplatePathByRelativeDocPath $event): void { if (str_starts_with($event->getTemplateName(), '/' . self::ENTITY_DOC_STRUCTURE_DIR_NAME)) { $event->setCustomTemplateFilePath(self::TEMPLATES_FOLDER . $event->getTemplateName()); } } - /** - * @throws LoaderError - */ - public function onCreateMainTwigEnvironment(OnCreateMainTwigEnvironment $event): void - { - $event->getFilesystemLoader()->addPath(self::TEMPLATES_FOLDER); - } - - public function beforeRenderingDocFiles(BeforeRenderingDocFiles $event): void - { - $finder = Finder::create() - ->in(self::TEMPLATES_FOLDER) - ->ignoreDotFiles(true) - ->ignoreVCSIgnored(true) - ->reverseSorting() - ->sortByName() - ->files(); - - foreach ($finder as $templateFile) { - $docFileRelativeName = str_replace( - self::TEMPLATES_FOLDER, - '', - $templateFile->getRealPath() - ); - $this->rendererIteratorFactory->addExtraTemplate(new TemplateFile($templateFile->getRealPath(), $docFileRelativeName)); - } - } - - public function beforeLoadAllPagesLinks(BeforeLoadAllPagesLinks $event): void + public function onGetProjectTemplatesDirs(OnGetProjectTemplatesDirs $event): void { $event->addTemplatesDir(self::TEMPLATES_FOLDER); } From ef58cf223be05567b5bc5d84384dba40b24690c5 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 17:49:04 +0300 Subject: [PATCH 28/42] Adding events comments --- src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php | 3 +++ src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php | 3 +++ .../Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php | 3 +++ src/Core/Plugin/Event/Renderer/OnGetProjectTemplatesDirs.php | 2 +- .../Event/Renderer/OnGetTemplatePathByRelativeDocPath.php | 3 +++ src/Core/Plugin/Event/Renderer/OnGettingResourceLink.php | 3 +++ 6 files changed, 16 insertions(+), 1 deletion(-) diff --git a/src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php b/src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php index 594dd80c..97b4e5ae 100644 --- a/src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php +++ b/src/Core/Plugin/Event/Renderer/BeforeRenderingDocFiles.php @@ -6,6 +6,9 @@ use Symfony\Contracts\EventDispatcher\Event; +/** + * The event occurs before the main documents begin rendering + */ final class BeforeRenderingDocFiles extends Event { } diff --git a/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php b/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php index c574c921..4a39b7ef 100644 --- a/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php +++ b/src/Core/Plugin/Event/Renderer/BeforeRenderingEntities.php @@ -6,6 +6,9 @@ use Symfony\Contracts\EventDispatcher\Event; +/** + * The event occurs before the rendering of entity documents begins, after the main documents have been created + */ final class BeforeRenderingEntities extends Event { } diff --git a/src/Core/Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php b/src/Core/Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php index 5a7a6b4f..1ec4d004 100644 --- a/src/Core/Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php +++ b/src/Core/Plugin/Event/Renderer/OnCreateDocumentedEntityWrapper.php @@ -7,6 +7,9 @@ use BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper; use Symfony\Contracts\EventDispatcher\Event; +/** + * The event occurs when an entity is added to the list for documentation + */ final class OnCreateDocumentedEntityWrapper extends Event { public function __construct( diff --git a/src/Core/Plugin/Event/Renderer/OnGetProjectTemplatesDirs.php b/src/Core/Plugin/Event/Renderer/OnGetProjectTemplatesDirs.php index 7b02201c..dcd059b1 100644 --- a/src/Core/Plugin/Event/Renderer/OnGetProjectTemplatesDirs.php +++ b/src/Core/Plugin/Event/Renderer/OnGetProjectTemplatesDirs.php @@ -7,7 +7,7 @@ use Symfony\Contracts\EventDispatcher\Event; /** - * + * This event occurs when all directories containing document templates are retrieved */ final class OnGetProjectTemplatesDirs extends Event { diff --git a/src/Core/Plugin/Event/Renderer/OnGetTemplatePathByRelativeDocPath.php b/src/Core/Plugin/Event/Renderer/OnGetTemplatePathByRelativeDocPath.php index 946f5816..322a3358 100644 --- a/src/Core/Plugin/Event/Renderer/OnGetTemplatePathByRelativeDocPath.php +++ b/src/Core/Plugin/Event/Renderer/OnGetTemplatePathByRelativeDocPath.php @@ -6,6 +6,9 @@ use Symfony\Contracts\EventDispatcher\Event; +/** + * The event occurs when the path to the template file is obtained relative to the path to the document + */ final class OnGetTemplatePathByRelativeDocPath extends Event { private ?string $customTemplateFilePath = null; diff --git a/src/Core/Plugin/Event/Renderer/OnGettingResourceLink.php b/src/Core/Plugin/Event/Renderer/OnGettingResourceLink.php index d303603c..4c6c6cf7 100644 --- a/src/Core/Plugin/Event/Renderer/OnGettingResourceLink.php +++ b/src/Core/Plugin/Event/Renderer/OnGettingResourceLink.php @@ -6,6 +6,9 @@ use Symfony\Contracts\EventDispatcher\Event; +/** + * Event occurs when a reference to an entity (resource) is received + */ final class OnGettingResourceLink extends Event { private ?string $resourceUrl = null; From 157e379e0ad20dd9e77168aa662aec923abda829 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 17:49:19 +0300 Subject: [PATCH 29/42] Removing old code --- src/Core/Renderer/Renderer.php | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Core/Renderer/Renderer.php b/src/Core/Renderer/Renderer.php index c5741f78..bbd8f210 100644 --- a/src/Core/Renderer/Renderer.php +++ b/src/Core/Renderer/Renderer.php @@ -59,7 +59,6 @@ public function __construct( */ public function run(): void { - $templateFolder = $this->configuration->getTemplatesDir(); $outputDir = $this->configuration->getOutputDir(); $templateParams = []; From 47a70d5b032e7309e9c73cddf626cd1e2f26b932 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 18:12:53 +0300 Subject: [PATCH 30/42] Adding comments --- .../EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php index a90eaf7e..ed17c712 100644 --- a/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php +++ b/src/LanguageHandler/Php/Plugin/CorePlugin/EntityDocUnifiedPlace/EntityDocUnifiedPlacePlugin.php @@ -30,12 +30,15 @@ public static function getSubscribedEvents(): array public function onCreateDocumentedEntityWrapper(OnCreateDocumentedEntityWrapper $event): void { + // Here we replace the parent document for all entities so that they are all in the same directory. $structureDirName = self::ENTITY_DOC_STRUCTURE_DIR_NAME; $event->getDocumentedEntityWrapper()->setParentDocFilePath("/{$structureDirName}/readme.md"); } public function onGetTemplatePathByRelativeDocPath(OnGetTemplatePathByRelativeDocPath $event): void { + // When getting the path to the template file, + // we need to take into account that it is located in the plugin directory, and not the standard one. if (str_starts_with($event->getTemplateName(), '/' . self::ENTITY_DOC_STRUCTURE_DIR_NAME)) { $event->setCustomTemplateFilePath(self::TEMPLATES_FOLDER . $event->getTemplateName()); } From c98d2341d3f07cb1a1c553e200c6778428d90119 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 18:24:01 +0300 Subject: [PATCH 31/42] Adding unified doc structure demo --- demo/demo6-unified-document-structure/.gitignore | 2 ++ .../demo-config.yaml | 6 ++++++ .../demo6-unified-document-structure/demoScript.php | 13 +++++++++++++ 3 files changed, 21 insertions(+) create mode 100644 demo/demo6-unified-document-structure/.gitignore create mode 100644 demo/demo6-unified-document-structure/demo-config.yaml create mode 100644 demo/demo6-unified-document-structure/demoScript.php diff --git a/demo/demo6-unified-document-structure/.gitignore b/demo/demo6-unified-document-structure/.gitignore new file mode 100644 index 00000000..79d6c21b --- /dev/null +++ b/demo/demo6-unified-document-structure/.gitignore @@ -0,0 +1,2 @@ +/.bumbleDocGenCache/ +/docs/ diff --git a/demo/demo6-unified-document-structure/demo-config.yaml b/demo/demo6-unified-document-structure/demo-config.yaml new file mode 100644 index 00000000..282d3021 --- /dev/null +++ b/demo/demo6-unified-document-structure/demo-config.yaml @@ -0,0 +1,6 @@ +parent_configuration: '%WORKING_DIR%/bumble_doc_gen.yaml' +demo_dir: '%WORKING_DIR%/demo/demo6-unified-document-structure' # Here I define a template configuration variable +output_dir: "%demo_dir%/docs" +cache_dir: '%demo_dir%/.bumbleDocGenCache' +plugins: # Connecting this built-in plugin will change the structure of the configured document + - class: \BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace\EntityDocUnifiedPlacePlugin \ No newline at end of file diff --git a/demo/demo6-unified-document-structure/demoScript.php b/demo/demo6-unified-document-structure/demoScript.php new file mode 100644 index 00000000..0681075a --- /dev/null +++ b/demo/demo6-unified-document-structure/demoScript.php @@ -0,0 +1,13 @@ +#!/usr/bin/env php +create(__DIR__ . '/demo-config.yaml'); + $docGen->generate(); +} catch (\Exception | \Psr\Cache\InvalidArgumentException $e) { + die($e->getMessage()); +} From 0d6434c7162ed96f8d74ac66ef380d44de392ad0 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 18:40:45 +0300 Subject: [PATCH 32/42] Adding information about new feature --- ...templates.md.twig => 01_templates.md.twig} | 0 ...dcrumbs.md.twig => 02_breadcrumbs.md.twig} | 0 .../3.renderer/03_documentStructure.md.twig | 19 +++++++++++++++++++ ...s.md.twig => 04_twigCustomFilters.md.twig} | 0 ...md.twig => 05_twigCustomFunctions.md.twig} | 0 5 files changed, 19 insertions(+) rename selfdoc/templates/tech/3.renderer/{templates.md.twig => 01_templates.md.twig} (100%) rename selfdoc/templates/tech/3.renderer/{breadcrumbs.md.twig => 02_breadcrumbs.md.twig} (100%) create mode 100644 selfdoc/templates/tech/3.renderer/03_documentStructure.md.twig rename selfdoc/templates/tech/3.renderer/{twigCustomFilters.md.twig => 04_twigCustomFilters.md.twig} (100%) rename selfdoc/templates/tech/3.renderer/{twigCustomFunctions.md.twig => 05_twigCustomFunctions.md.twig} (100%) diff --git a/selfdoc/templates/tech/3.renderer/templates.md.twig b/selfdoc/templates/tech/3.renderer/01_templates.md.twig similarity index 100% rename from selfdoc/templates/tech/3.renderer/templates.md.twig rename to selfdoc/templates/tech/3.renderer/01_templates.md.twig diff --git a/selfdoc/templates/tech/3.renderer/breadcrumbs.md.twig b/selfdoc/templates/tech/3.renderer/02_breadcrumbs.md.twig similarity index 100% rename from selfdoc/templates/tech/3.renderer/breadcrumbs.md.twig rename to selfdoc/templates/tech/3.renderer/02_breadcrumbs.md.twig diff --git a/selfdoc/templates/tech/3.renderer/03_documentStructure.md.twig b/selfdoc/templates/tech/3.renderer/03_documentStructure.md.twig new file mode 100644 index 00000000..e5047268 --- /dev/null +++ b/selfdoc/templates/tech/3.renderer/03_documentStructure.md.twig @@ -0,0 +1,19 @@ +{% set title = 'Document structure of generated entities' %} +{% set prevPage = 'Renderer' %} +{{ generatePageBreadcrumbs(title, _self) }} + +{{ "Document structure of generated entities" | textToHeading('H1') }} + +*By default, the documentation generator offers two options for organizing the structure of generated entity documents:* + +1) The standard structure is an entity document next to a parent document. If the document template contained +a link to the entity documentation, during the documentation generation process we created a classes directory +in the same directory where the parent document was located, and inside this classes directory we created an entity document. + +2) All entity documents are located in a separate directory with the structure of the entire documented project. **At the moment this is only available for PHP projects** + +To enable the second option, you need to connect the built-in plugin: +```yaml +plugins: + - class: \BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace\EntityDocUnifiedPlacePlugin +``` diff --git a/selfdoc/templates/tech/3.renderer/twigCustomFilters.md.twig b/selfdoc/templates/tech/3.renderer/04_twigCustomFilters.md.twig similarity index 100% rename from selfdoc/templates/tech/3.renderer/twigCustomFilters.md.twig rename to selfdoc/templates/tech/3.renderer/04_twigCustomFilters.md.twig diff --git a/selfdoc/templates/tech/3.renderer/twigCustomFunctions.md.twig b/selfdoc/templates/tech/3.renderer/05_twigCustomFunctions.md.twig similarity index 100% rename from selfdoc/templates/tech/3.renderer/twigCustomFunctions.md.twig rename to selfdoc/templates/tech/3.renderer/05_twigCustomFunctions.md.twig From 5f540aa05e14ae7ce5c30f66a0b5d680879c9233 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 18:43:04 +0300 Subject: [PATCH 33/42] Fixing file dependency checker --- src/Core/Renderer/Context/Dependency/FileDependency.php | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/Core/Renderer/Context/Dependency/FileDependency.php b/src/Core/Renderer/Context/Dependency/FileDependency.php index 0af60376..f1a1e3c8 100644 --- a/src/Core/Renderer/Context/Dependency/FileDependency.php +++ b/src/Core/Renderer/Context/Dependency/FileDependency.php @@ -70,10 +70,15 @@ public function isChanged(RendererHelper $rendererHelper): bool $fileName = $rendererHelper->fileInternalLinkToFilePath($this->fileInternalLink); $newHash = ''; if ($this->contentFilterRegex && $this->matchIndex) { + $fileContent = @file_get_contents($fileName); + if (!$fileContent) { + return true; + } + if ( preg_match( $this->contentFilterRegex, - file_get_contents($fileName), + $fileContent, $matches ) && isset($matches[$this->matchIndex]) From e20b7d02d1adee05d806cb98700672871a485ea8 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Fri, 13 Oct 2023 18:43:27 +0300 Subject: [PATCH 34/42] Updating doc --- docs/README.md | 2 +- docs/shared_c.cache | 2 +- .../classes/DocumentedEntityWrapper.md | 71 +++- .../DocumentedEntityWrappersCollection.md | 19 +- .../classes/GeneratePageBreadcrumbs.md | 20 +- .../classes/LastPageCommitter.md | 15 +- docs/tech/1.configuration/readme.md | 2 +- docs/tech/2.parser/classes/ClassEntity.md | 58 ++- .../2.parser/classes/ClassEntityCollection.md | 88 ++++- docs/tech/2.parser/entity.md | 2 +- docs/tech/2.parser/entityFilterCondition.md | 2 +- docs/tech/2.parser/readme.md | 2 +- docs/tech/2.parser/sourceLocator.md | 2 +- .../{templates.md => 01_templates.md} | 2 +- .../{breadcrumbs.md => 02_breadcrumbs.md} | 2 +- docs/tech/3.renderer/03_documentStructure.md | 22 ++ ...stomFilters.md => 04_twigCustomFilters.md} | 2 +- ...Functions.md => 05_twigCustomFunctions.md} | 8 +- .../3.renderer/classes/AddIndentFromLeft.md | 2 +- .../3.renderer/classes/BreadcrumbsHelper.md | 37 +- .../classes/ClassEntityCollection.md | 92 ++++- .../classes/ClassEntityCollection_2.md | 92 ++++- .../classes/CustomFunctionInterface.md | 2 +- .../classes/DocumentedEntityWrapper.md | 73 +++- .../classes/DocumentedEntityWrapper_2.md | 73 +++- .../classes/DocumentedEntityWrapper_3.md | 73 +++- .../DocumentedEntityWrappersCollection.md | 21 +- .../DocumentedEntityWrappersCollection_2.md | 21 +- .../DocumentedEntityWrappersCollection_3.md | 21 +- docs/tech/3.renderer/classes/DrawClassMap.md | 10 +- .../classes/DrawDocumentationMenu.md | 6 +- .../classes/DrawDocumentedEntityLink.md | 6 +- .../3.renderer/classes/FileGetContents.md | 2 +- docs/tech/3.renderer/classes/FixStrSize.md | 2 +- .../classes/GeneratePageBreadcrumbs.md | 24 +- .../classes/GeneratePageBreadcrumbs_2.md | 22 +- .../classes/GetClassMethodsBodyCode.md | 6 +- .../classes/GetDocumentationPageUrl.md | 4 +- .../classes/GetDocumentationPageUrl_2.md | 4 +- .../classes/GetDocumentedEntityUrl.md | 6 +- .../classes/GetDocumentedEntityUrl_2.md | 6 +- .../classes/GetDocumentedEntityUrl_3.md | 6 +- .../InvalidConfigurationParameterException.md | 2 +- ...nvalidConfigurationParameterException_2.md | 2 +- ...nvalidConfigurationParameterException_3.md | 2 +- ...nvalidConfigurationParameterException_4.md | 2 +- ...nvalidConfigurationParameterException_5.md | 2 +- .../classes/LanguageHandlerInterface.md | 2 +- .../3.renderer/classes/LoadPluginsContent.md | 2 +- .../classes/PageHtmlLinkerPlugin.md | 6 +- docs/tech/3.renderer/classes/PregMatch.md | 2 +- .../3.renderer/classes/PrepareSourceLink.md | 2 +- .../classes/PrintEntityCollectionAsList.md | 4 +- docs/tech/3.renderer/classes/Quotemeta.md | 2 +- .../3.renderer/classes/ReflectionException.md | 2 +- .../classes/ReflectionException_2.md | 2 +- .../classes/ReflectionException_3.md | 2 +- .../classes/ReflectionException_4.md | 2 +- .../3.renderer/classes/RemoveLineBrakes.md | 2 +- .../3.renderer/classes/RendererContext.md | 2 +- .../3.renderer/classes/RendererContext_2.md | 2 +- .../3.renderer/classes/RendererContext_3.md | 2 +- .../classes/RootEntityCollection.md | 2 +- .../3.renderer/classes/RootEntityInterface.md | 2 +- .../classes/RootEntityInterface_2.md | 2 +- docs/tech/3.renderer/classes/StrTypeToUrl.md | 6 +- .../3.renderer/classes/TextToCodeBlock.md | 2 +- docs/tech/3.renderer/classes/TextToHeading.md | 2 +- docs/tech/3.renderer/readme.md | 4 +- .../tech/3.renderer/templatesDynamicBlocks.md | 6 +- docs/tech/3.renderer/templatesLinking.md | 6 +- docs/tech/3.renderer/templatesVariables.md | 6 +- .../classes/AfterRenderingEntities.md | 92 +++++ .../classes/BeforeRenderingDocFiles.md | 92 +++++ .../classes/BeforeRenderingEntities.md | 92 +++++ .../classes/EntityDocUnifiedPlacePlugin.md | 196 ++++++++++ .../classes/LastPageCommitter.md | 15 +- .../OnCreateDocumentedEntityWrapper.md | 160 ++++++++ .../classes/OnGetProjectTemplatesDirs.md | 201 ++++++++++ .../OnGetTemplatePathByRelativeDocPath.md | 225 +++++++++++ .../classes/OnGettingResourceLink.md | 12 +- docs/tech/4.pluginSystem/readme.md | 18 +- docs/tech/classes/AfterRenderingEntities.md | 92 +++++ docs/tech/classes/BeforeRenderingDocFiles.md | 92 +++++ docs/tech/classes/BeforeRenderingEntities.md | 92 +++++ docs/tech/classes/BreadcrumbsHelper.md | 35 +- docs/tech/classes/ClassEntity.md | 58 ++- docs/tech/classes/ClassEntityCollection.md | 88 ++++- docs/tech/classes/DocumentedEntityWrapper.md | 71 +++- .../DocumentedEntityWrappersCollection.md | 19 +- .../classes/EntityDocUnifiedPlacePlugin.md | 196 ++++++++++ docs/tech/classes/GeneratePageBreadcrumbs.md | 20 +- docs/tech/classes/LastPageCommitter.md | 15 +- docs/tech/classes/MainTwigEnvironment.md | 21 +- .../OnCreateDocumentedEntityWrapper.md | 160 ++++++++ .../tech/classes/OnGetProjectTemplatesDirs.md | 201 ++++++++++ .../OnGetTemplatePathByRelativeDocPath.md | 225 +++++++++++ docs/tech/classes/OnGettingResourceLink.md | 12 +- docs/tech/classes/Renderer.md | 6 +- docs/tech/classes/RendererIteratorFactory.md | 17 +- docs/tech/classes/TemplateFile.md | 359 ++++++++++++++++++ docs/tech/map.md | 17 +- docs/tech/readme.md | 2 +- 103 files changed, 3493 insertions(+), 424 deletions(-) rename docs/tech/3.renderer/{templates.md => 01_templates.md} (93%) rename docs/tech/3.renderer/{breadcrumbs.md => 02_breadcrumbs.md} (89%) create mode 100644 docs/tech/3.renderer/03_documentStructure.md rename docs/tech/3.renderer/{twigCustomFilters.md => 04_twigCustomFilters.md} (97%) rename docs/tech/3.renderer/{twigCustomFunctions.md => 05_twigCustomFunctions.md} (97%) create mode 100644 docs/tech/4.pluginSystem/classes/AfterRenderingEntities.md create mode 100644 docs/tech/4.pluginSystem/classes/BeforeRenderingDocFiles.md create mode 100644 docs/tech/4.pluginSystem/classes/BeforeRenderingEntities.md create mode 100644 docs/tech/4.pluginSystem/classes/EntityDocUnifiedPlacePlugin.md create mode 100644 docs/tech/4.pluginSystem/classes/OnCreateDocumentedEntityWrapper.md create mode 100644 docs/tech/4.pluginSystem/classes/OnGetProjectTemplatesDirs.md create mode 100644 docs/tech/4.pluginSystem/classes/OnGetTemplatePathByRelativeDocPath.md create mode 100644 docs/tech/classes/AfterRenderingEntities.md create mode 100644 docs/tech/classes/BeforeRenderingDocFiles.md create mode 100644 docs/tech/classes/BeforeRenderingEntities.md create mode 100644 docs/tech/classes/EntityDocUnifiedPlacePlugin.md create mode 100644 docs/tech/classes/OnCreateDocumentedEntityWrapper.md create mode 100644 docs/tech/classes/OnGetProjectTemplatesDirs.md create mode 100644 docs/tech/classes/OnGetTemplatePathByRelativeDocPath.md create mode 100644 docs/tech/classes/TemplateFile.md diff --git a/docs/README.md b/docs/README.md index 4cd120ae..37e38472 100644 --- a/docs/README.md +++ b/docs/README.md @@ -95,4 +95,4 @@ To update this documentation, run the following command:
-Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
Last modified date: Thu Oct 5 17:42:06 2023 +0300
Page content update date: Fri Oct 06 2023
Made with Bumble Documentation Generator
\ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
Last modified date: Thu Oct 5 17:42:06 2023 +0300
Page content update date: Fri Oct 13 2023
Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/shared_c.cache b/docs/shared_c.cache index d1bbf22c..dc6359c4 100644 --- a/docs/shared_c.cache +++ b/docs/shared_c.cache @@ -1 +1 @@ -eJzsvXlvG0uWL/g+ysMFGq9qBuiKfXFhMLi272LMXdy2u/uP8UMjlhMyuyRRICnXdffUd59IkpK1UMFMMplOZZzb1RYXKZI8+Ys453dW90Iy+eK/ly+4fPHd/AoWbjWbXy7/43x+9h9/WUH49JcFuHgB/3wR/3n199nZd391L2jz+0y8+O7q09Wrc7dc/nC5mq2+vJqfn0No/vy7v/7+Quf1Xl5f+HN4PQ8/weXHV/MFfHzrFktYfNz8wcevf/HL/Oz3m4t/vH20vLPk5qqU3P2UzYchL/77H//4R/789sV3aXYOy/+IcAWXES7DLD956jvwF/89e0Hy51Rk1+d816ywyJ/01fxyBX+sPr6+WfTLxx/zVb4+/e6FWH8wtbn8m/zri0t3/svs8m/f/TV/LP3iu//+pxVcXJ27VfPhZot/+sfuD5UXMS++C80FL1f5Inmhd3AGf3z319/+uvnmF24VPr3J192+lm/BJ7f8tL4Oe/EdI9QkA0FA0jxxEzjl2lgwSnibXPjur/+YvaADfGe26zu/++H717/+0ObrLjMmX3z3lz/99z/9+U//8//+85+WsMoP/vynjJlz+POf/t//+X/97/8z//hf3/3vP//pn/+PP//pf/1/3+X3/+kff/7LdzsENXthHosqyuSITiLJLKMgLajomRPCKK4lEXotKtaIaieMS6J6PVtkyM4XX+7KizXyMvnC/+Poxf5HFudDidNdKGve0LSXS94VnTY0glRaORBMcWKVoiIyoqnWXFKeRfePzW/uPE4u3NVoz5L8DdYfJ0sznM8v4faPlaQJjHM0EE+aT6TswZ/o1b2Vt1vJ7L5PByz4P66X7gxeza8vVw32ab5rhve2eLq+XP/Ob+4C1sDj6yMgo/Hll7du9Wm5Bp3s7XpucbbcwqQ5rm8frDf0X5aLsEGb7U98812AGRKDzcsiI3C2al6G9dJZk2U1HZJRUnJQyvogZJSe8xiDZCIlWH/Gw1H55v7V7uBzfXQdI+Cnlt6FVHuCy8D2lbV088bdHjgPLnO5nJ/Dx++vrprP0gBMPr7hm995Nb+4cJfx4/cx/jpbLmeXZ/kXXp7Pw9+W27duvo5U+5eYNZ/RnW9fuYu5RgFlKDzW1ffXeOmWcOe6vLmu2fM3Wd2ev7l8tzZAfo0ftnrjziqiufJTQrpZJb+2Fvmdv5P573acjbv/7u1i/p/5y95cfvl+tbgOq+vF3QVV83XoEwvmBc4WsFy+dIu7j390a/3V/LneGhN7//z96sv57L8g3nnt1nTgu3bVKxc+wRaS68cZfxdv5/Pz5s9sI4bHN+H2z36Zh3zLNyv8EeBqc0z4Rhq/zVc/5i0Rb19fg4nsFsOuBdcPN2utX1j//RqN+um/f//JLSCj7+Kq+fIQ829cX2zsMvi6SoNHudN23K4yv14EaD5Alv8jodAGmmLnMZrvSJqdXd+cyHefrf9SPP3xn/7LfGpkLdWoJne2XqUBp9n98e+t8vWWvLn87M5ncfey9+9QA1S1Gyn3Fv83d34N7yAD8HM+0r5fnH2+98p6rQa1qsXXvb/WjVH4eL0GxerxLtiz3jtIj5cqILuw1L1n68+Z6cgaU6xBtm772T4s3OUyzRcXN2t+mK+Nxjuvrxdt4K4fH19tF/36wv3PynafJo80VHMkP7Zj8wLNDtA7QfJAxa230/rf/we+3D7YHpzzBx9LbA39jqu+huSuz1ePFl+v2eyVVubE/TVviMWWV+xeWz0JxyfXdvkXN6/e/+p6t7Zrt1S+z7O16cHMkxuuxTL/vnBX2di4o3XYepe0MRgL691+Or4+/LuhplntV1h9mm9sAtpJ4neU2vv8lbKR9jOcX222Fme7NfyB7KdZkbeFWkfLtVlbtN1weyz3e6jjckty+uQDzbrNxjBtbtPudd9nU/QGRO/BLcKn+8JoNotogfIdG42vd8hO3Xn/b/MHOmvA924+X+06ArlteYY+tYAgLbf8rgWWPy3m12sLX9AnLaqnlrknENHsA10S5sallQ/CjYm/tn7nlw9f/dGdN+b79ul65WY/mNIXbLlyNt0+NGdwPordrMHa3Ys0G8OUvn67i6xtPYhvLu+vvt4gj8lP19U/LK4fyEbtJmalhbePvt55/aSl1mqND1+u8h67vliv1WwLWTq7nlzrPpqaXcFL93zLlTbP1kyL7CaYX//knjW+tknuvbJehO6Txf1FbnyD+Zx9vNZaM+w0unau1eBzc3bPF48X40+ahTsXewfherGcfYbiJxT71OD9RTfnafM5Hy+1Jrql/fNgqbvP7t16+TRx2L/SAwUi9dOW4Pn12WzzePvwF7fMcDpbk+3ZKn+ix6+s1zRPf9NHazZ/3fikYYO3r0/XK9mnrazSSs3Dn1cX55unm/fXroFmB6jdO2Dfeu+Wq0fL0SepzXaNHz5nRnxzV37PutfF0t1QbJ/kNgveOuNfQiYd8GoBWWWvnUoN9NYr8Y4r/X75E6yaRRrOtf6E60BBXkm0+5J3Vmq+5kYB5t/e/NKrTdBmvWCzEcTuE3Cz4O+X51+2lskfeZc20llfY/3XDfhF6RZufqz/4PVsedXEdTZoUnq3c+zhn97bbGrtz9l9Atz9o4d30j551n69eU04LyzyLyzvPv5qOWvyJCnYt8iHv8/Ofrj8PFvMLy+2ktN0/2otg1PNauxJ865DVLBZiD95ApUWunnv60t3fXhPG/Hd1rwHBS07fNKtN+zWMfAEHdXqSdv0yTUh3mN962X0kxyr7TIPAKzNk567Rys+oPDrP7f7ZXV7RDz9yj1ZGbL/rrZY88EXNfRJnXC7xo0qyCZVgOVyfl9X3b66Xu5ptltY7qfZ6tO1b15fPl6xxQZ5vOKjV+6LstkgvHwW3DxY//76zC5/hpsHX88vo/Zj6PZOb+26O7vY6P1naHPObS3mJjTSBPAvVz8u5he/QFoD0TxNQ3cu8up6uZpfbJ7cF5l90hTcu9ADyFnypAbcudSPsz/erxbvZ/+1/iC2AawoHxl3//rtAs5+bbTg+o9ZN5nmP75yixtrdmsSWN7tE/zL9XwFF7By6z8WTxKynX/8Di7mn5tLw8uF+1sTk8tryCep+M41svQaDvZh/q+LTbBlDcydxGPn3zek+MP81TzCOmi3XuKJOFF5iZ+zgs6GzXoB8yT5ebDANoB+g6jt03vgtHb/IVZa7AFAKSFtwX6z3uuF+/uNZln7j36Fy+vNWi3sjqfXutFSN9ijpDWCb5ZrbI5s3G5N0OVmFd5V+rchyHyw3jG0NquJ7qut7kmrWXULTkrkk/xu/2o38rpdTD3pb3hiscZ6v7Vpb612SvSTPOCJhd4uZpeP/GnfZwW33K5onozu3V/xV5ft+T/yJ1ne4tO2PACaP91hC9N1eJQ9vPbmx9e4A11HQfnDfXD31+7oK7qJdj68cb+4y7PrhpC6y3i+5sz3nt/bx3Qd8Xx0Ou5Z4uHu3R38fLjI209XTwahNsus7d2Hd3z/Mg+CCvkXNm/cE9VOu7fF2l8Tvjbr7ERlp3UeCm+n96LFivkUXbkbwG+W2mkEd13qwedjO30Y+xd9/eXSXczCJsRz50NuIp/d1/sa8n4HafsB78e3N8HPh0fP/pUff0S+y6buttBDKe70anRb8v7OZTv9e/tXzAZ6NpdXX+5+X3UYbu4v9fAb610R7v2Lfr27Nw/nizvMk64joVmftl/4kYO72Ys3mH/45ptlViOf1ylDd7z6dB0vzZryhFfNNmtYNRkud6+7jqxmG+R0173257Pw4KJ0fdEO967TRf9ttpz52fkaMvcuy3q5bIvL/TqPszTbAmod3bUdDqSHF9js0ZZAWsd7bYeDoP3VdgOoOSbsEbh98nq7gKPWd7CDJdDuao2DtiHZr64Xi2xR3aDr7pWb08b2fuEnoWqOvIs3R2db1GyOn4duhZ4uuBM46yj2MRItXHEHdMTmzOmgdNtebz941pFye4JLPwWfdQD9EZkvXHDz46uni66j44+ij4UV7ofovl9+uQyPQoZ0HRV/lN7RetUNx386kEjFzvSR1uvfpA9ubP244/M3p4DpgNkn1n//ZbmCi6eEtDPjdudFPl1tn27+cCeJLP/h+02QbEP71wF100pTPYourh3In67er669h8WDp19DjHQdb28nwn3XaHJ151nKOy6y3nCtcLDvIvnhjStivutKvDeR5Yf/ejlb7bjGOlOl1fGx9xrLxfp8ajLNH12mvSbfd5n3Xy7S/PLL+gZdZsntuNh6p7YC+b6LNe6QHRfQrY+Cu1HfLUn4/fLVJwh/e7O8y6vd5UtonEmb9U3HG38vdP59yidBs1bee09T93W6wKMUpbbX+P3y+xjvLN44fO8tv84eaHUPuoSj7igR1d7OL1zh7bYs7sP813j75ObdXb6wddZBK4O761WbJ3d+aXM13pZ5F7zD69V/dVebFde6t81+f9p9ullwbXMuX87jl8bXv1lc7nLt3hSg3LoBP7765FY/Xa0+Pqzvue9PVDu9sU+vtqm3uXm/qcG5kaLe5QV6eqHHFTMPPpj56z/+sa6KbsygM1g1mw3i74t1bgn8Bn/ngSbGIAVNgmFCJUe49cA0d5JTJ5tqshNlom4KHq04vNKrsPqOmrJTXWldVvblphCyXFG22ZGn+BQPCzIZ2X3Dm/eapNJTfIYHRZr7hFHCpRKESy4NdT5aiFp7AVwTr4yURASFuOyIy6OqGCuD7VGyKp62loBMzGlPg1XBeqFTfmIFGKIp4Yjqrqg+qrC2NlgfJawSrrX3hBqbiBMejPIhH9Q+aEYiBJlsnAiu5WC47lbsXRmOuwmnhFuWD2JnhNXBSMalljyCEFzGCMkogedx5/P4yIYDlSH5WHGVsO2iSFEo45jjSlrjQAsCjHkWLE8sIba7nsmd22BUhubuAirh1zprqLDGR8Wl1ISSlATnJlAwlkaP+O2I3x7bsVQG7B4lV0I8WB6Yilz5bJUQI6X0gTGl83MWsm2CiO9qjRzaL6gyfB8sp6Jt7bViTLCkZCRgHJWZD1IIRMr8CkyFEw6I5oPbV9UG54MFVbRHVNSeeWsdE0lYamW2RaKwzrmQoQ6I5672dNd2apXBuLN8ymwQlALqHPFRq8SNs1S4SAzLUBbIBrtb07119asM1v0JroR36XQTxGZUQwzMG8dTSJElw4ng1qH10YMtveu2PW46WRm8D5ZTMRqepDCJUSmZItSppAMQ4ZQnlLrkEc2d0XxcC9TaMH2ctErIJpQEyow2ShDpoqXZlvYxcCVAOqMZIrsrsg9sy1sbpA8UU5EhUuK0bQLhNnHKvSeeGABvwEttlUEsd2WI3XtEVwbjAyRUQnBIBIQTErSV2ikSqZBWKKeDiilozLrryc5o26u8MjQfKa0SsqNzQWYeSCyjVCbgOsaY7Q2VLY7IIuY5d0X2afrnVwb40wixGJXhLiQhtG9mxRBJpNFcxSb9CUwiyCS7+wH7GPVQGex7kVkR5RaiI5rSZJjjOnnJXCKMNmPKOIsOUd4V5X0NIakN6X3Jrcg7SbZkdGRBRMutlkyrIBTT1IoQJEervTPaexiRUxvQexBZ0U+oiWjm3QmRD3FColQpusRNJNrSOJkKg28evzxgdlNtSO9NcMUz3VjCXYpRmqSdVi5wKqxUjEhnqaGI945473e0WGWY71d4xRzYYGzyEC3xkgvOGBfSg4PAnfM+oQ+9M+57nn5XG/J7Ft+enBWmrElEBKkV95FacJaZFGgQTE8F++JbZsw+usjuEY2VofxwQRW9MFLHbMSACFbaBsyaG8hnO3gjk8Zq9+5neb8TQysDec/SK5/kyimS2SlVlBoNilsvqBfWKhGIQOu9M/L7nGpbG+77lF0J9d4o6cBqHZkEyAc/IUIaRTKBpRowx7w76k8xd7k29J9ChsVKC828B8F94DRR4ygFyokSxhnilURPZT/e+Cfv4M6RbJWBvg+RFb00IIPxYI2O1AlBmirlZJrC5UxgI0OMd2aqR46urwzfx4qrmANpYG2le588Y0QSIIJEJXS2aQglWOfZT+5Ai5u1nUdSa1V+b3IrxpksJzwSEhzn1AZwnFkdZZSKEhYm43McEO2lofQt7lqdB3pPUisiXTKbJJFW+Iz0pJxTUquUeaq2LCVkp51tlm7+tOaebVpxV4fuIyRVQrQgyQjCUwyCJsKVYEYIqTwFbxwIzPs6HdPcPFk/fp+VbNOQftvwvzJo9yGyok+RUaq0NDx6LZVNGhwYyrQIOnAd0BrvjPE2/rDdF3l1Pr+Er/KpDur9Sa6IeK4Sz/wTuM9gl0JTC9lKifk/DTpgRfRJvOi7L7IZX7+5ygyW9WL/JDIs7YIkQURNjCeSaM14EEyCSl57IZkMWK93ktyB3Re5fVSvQ71n6RX9j44rrzwQlW34/G8+/UnkmlsTPBi0eLojv41vYc+9uzeLvTbs9y2/IqdVjHtmCDjOAyiRn4NXigme94HGeVSd0X8iYdW2CU4lxj3dOEgSkDWG1kqFmJKTWhPKPfWWKsyf7LoXRIuIyuZHvZbOQTIq5kJyFiXTPlpJPTeJqiiSjyG6EISzyGc7e3B2No24f5G89FnjRn43n6+2jrd6DZjjBVbMhdHa0eAYyce0sEYzIkjGNxFRaSr8VOx1NqqqDcT1UYIq9hptGsIwD4G56LzVQJJT2kVrGY9e4XndGc8tkpV23ablT4v5dX0zY48VVzEHgIuoXRDRcJ5N6KQp1SlFzbgzIYJFbHfFdovagq83q16r+mA5FaduUhWMDBAF0d5FH6kQREAAYkQGOuZudfYUlrjPj7Pz1bomIK5npH5sRjrNLx+++qM7b2ZPbp9Wh/MTSLC0AwylIZvbRgqfAe+psMQR2kzyVIZGh32+OnsLS8q35f2bncOHpmxmfrlys8bzW+tmOK0wi170SAMFzT2XglqTnzgZtWU6Ri95RDun874o6e92t3LdTxzim8uKN8RppFjaCVwnGXnkXMnEtJSNK1KJGINLzjoucCd0tZEeD5Hveg8/LK5rNpF6F2DRO0kyzSVUK5YE9wA6OkGskCxxrX3ESr3OjLcUDX98+7aPKnXlHCOrYo01CEtjtvSplIYmq7kDMFZw6rx22Gmge0yplN9UvlMfvlzlS1xfVIfuXmRW7gHJiKCBeRBeg5TgnElMRcOpSIqgJ77z2V3KYn3yjlXstTxWXsWJHFJTyySD6EWCQLwEZVkI1ANJiiK6u6Kbl9wN28n0m2fVAbmLaIpdqDkYzjO2lQyMA9ecKpt8UFbxjGX0q3Q+kUtk6N4ctnX/wXuvVIfi44RVnpchGECgoDT31jIg0JT/WyNiZMAw07BXe/r+rXo9W0DTqGEGy7rh3YvMir5Aylk+sSXIJLNRLTl3ghjCuDDce4m55Z1RvrM58s471gQyNpVg80XlMO9FaEUrRUVrOAskQ93SQIIkIVNH76kzOhj0jnT2eZeEdf+WvYNwvVjOPgMe68XZAYcKr4R7Sq3nAhiTVKZmXLoJ3tvgA4/AosXzvfP53v7WbRZtDqy60d6HyIo2TLDAg5DcSSecYpQ0zhKSrKE0SYdne2eMl2LSD27Y3Wf1egV7kFi5fy5PNhGraYqgwOumvyjPfJRo4yPWC52Si957VnPNcy8yK8+jttHQoFMKzEjBbaSsKXFuMhqD1B5R3tVG330qnV+fzTaPtw9/ccvV2/VHvLiYrfKJ9PiV6tDeq+yKqE/KkMSiE0Zplk0XQm3QTTlzSBn2U6mV++bWy6M719yjX2aXf4ONa/jr0+qw3oPEijX7WscoGCMA2W7hIv9jkiMhg91SIjBC1BnhuysKSverefjz6uJ883Tzfn0470tuxV51oImT0SXqmPKGaMt4Yqzxu0gqMA+rO9p3h/j23bV3y1XdYO9JbMUYKSgZhSGGE2IYiyKj3qZIg/GUJoMne2es707K2NypHz7nX7654u+Xzd1AclqcQH2I4Ip9W6SnzUiAaKRvZu8Gr2PGumpK7ZTUOMOuV1t9c9tuJk99fAkpv7m+F3n9/PuNm7g+oB8vsWKcVFgRaAa41pxrT3z0jIRkBZdeOoXxolMi/PfLn2DV3Kp3sNycT1kTI8K7S6zobzEJuGpKpDmTXkURucqAj0w7DYJjffQJbJY796u5H5tV829vfmk9U/CywgEvvQmuWPcshEnG+eStJ0QkbkFkO4Y50vQUVQHx3hHvYncFwOa2/X55/mW71B8Qrps/X9/J6sB9oJTKtokHpUW0KgJp3IchoxmSsEqFbK3gbJfOSC65CDY/1rfl9Wx55VbhU4Wu8UNEVMzHksFZz0JI2lBh85tUGhJpSkIbBcggO2N4dyPLuzeo3rSUbsIpdkBUgXppmHOGOCIlkSRmA9pT40Fj95QDcLtbWHdvTc3+vK7iKfaEE84r2bRZBp5B7Eh0RBiTKV/j7YgasdsRu7uLrr66nbLgY1jkX1jefVzpNLjjhFW0h71JyfJAqcuWQ9DaJRoE1U4wwRjFM7mzJ2Nnb459t+rD32dnP1x+ni3mlxc1Mr2epFa2mpMUEcBlqAcPRKRm7k8SmfZZoiTmv/aM9LVj6Y/Vx9dw1bx0Gb7clhd++foaIv0wqRVzpTxnDgixzgVNwMtsogQfNYuGS2nQW9cZ6TspUOmeNUGymkF+tMDKk08cy/8LPLh8dmsrlVVEGs5s8oZiPVpnfO/OUy7drpv3vr70o1ufUdVBvVfZFU91CdwCc9RSJiHobLCzmI9zRYyggaPXrzPqd9aidLtz9boFe5Ze0W8YQ5SNqyXbNYZT4mm0KQhtCRALEu2ZU53383Dd8KoPC3e5TPPFRTPIabN+xbjvU3bFSc3c2uiMUho8xACcheiDsKCM5Rp7YnX3OO5MlXjyzsE2U+LfF+6qSp/jkeIq509pRzTXVHHHBTMpAfVEQoypCWti/lRnhrozU6Ltzao5SNSj5Ir9JazQSiYP3MnoTTMXKyXKUvCCZh6LNkzn07ydi+Hmhe3z6uB9qJiK1WmGEENDE8dPxhAqE4hkCTOGJ2AGT++e7fHNEvmtp19Be7wX2RW7hlNBAvfK8iiTIUJwTxgVXCTJnZXof+nZ/9LiztVst/QsvaK1HoW3MiVhJDAigmTaUpn/L5CQJPrbu1vr5XSOm2rat4t5gOVyfr9Twu2r1UG+L7HtqUZOxIcomFNUKZFY/pcB81zabPBg/6Cemenjm/bTbPXp2jevLyuHe3+SK8765EqQbL9bBVIpZ6hqvO15C+QXqQg4ya1na/7xfXv0Clrzvciu6F2PygjhuQq8SQIzXnJjVf4BmhPlMRusK+p5Oa/p5kF1iG4tl/JMH0GyGcKMpk4LmbTiklhJCGFO6oRo7YpWUT5nbh5Umm7eUTpFvzcRxBGjszWhlJFK6mxvkOil5wmMIojcjsjd49C9dWptxxvUmpZ1qJiKNoMHa7nSHjSNKdLoZEzeJW+UpzZg7XBnLJcJfZPevx2H9/H7GN80SUOrHxfzi18gVRjJOUpYxcoI4/MRbYkPjkWjQlIECGPCymwcc6wB6u7zKB8+d2/Vq+vlan6xeVIv7TteYMXaTdI0WaPCWvCSBZICsEzxvKM08OQwXtkZ3zuFtfd21Ryu6UNkxZoIYpx0XCsAR6y1zUBj72QwQoTo0c7uzhDL3te7N+zH2R/vV4v3s/+q7+A+UEpFxsiSScFTylziTDLLg5c8cWDSQbZUEMldkVxO5Lx7j94u4OzXpgVNfUA+SEjlqHlqUqIIGBsYlUkFxZwx1DlplAoYNT8hW8y36MotbuZ/1dgA8zhhFb0gYKjinBtGHaEgiaeGR+6dVi6IFBHXpzuf/+V6voILWLnq8HyYkIqZHlSKZKSiIakoSRBKEO6AKwUyW9OYz9f5fC5Huu7eondwMf/cnDXwcuH+Bsvq4HyUrIq1ksHyREzjqZYmaeKy3WyUDTRbz9mmxjqDzqgux8Lu3qlMbz58uYIP839dnNeH6EPlVPRqgFEsWsdTlJQpJZTxKlDhlKdRCPRqdEbzziHpO+/SB/hj9WH+ah7h5fk8VGhBHyGqYsc1oCGKyLL9bMDnk1oYbYNVOmpjJUP7uTOm27tWNzfqZ3Axr14fog8WVDF/VEqhgYSgOLMhH9NApLVGMEWpBob+us7RlTYHzxZfN8GC7dOKI4i9CK14bkeuNFhjRT6sTWKaReoDN6CF54RhB9jOOG/jotp9y6qOJPYktqLv2lpiwVJjg9GGSeu1FUmk5JvRCQmxfpKI+c1Ne71wf3+97TewXuxXuLyuD+c9iKxstwC1yQtHFXCmfEwpBcUgCJ2IEYjxzhhv49PadcNuempUGajpSWrlzoFUKWUYI1oCaJ+ywd7MEAHCDBDACq+TRCJv7lnT2fQnWG3nbFXo6j5KWMU+JJqpkJKTBqJ0yfJEA4T1gIZ8phuOuD4l88zvN6usC6zv9GSvDt/9CK1oqQRGSZBN8z8qnMyPuWNUaZaf0eAQ5yfG+eqeZdncuhoDPP0Irdhhh4MA50jIZ3iGtQwyeC6c1vlB/omxy844L/eIefKW3ZiWVcK8D5kVI/TOOq+1MCAUYynb35RIJYn0jAilE6K8qzXeJgf55o41t+N29FedI4OPllcxq4o3J7iOXAgmeGr6iPAQhFFacyEpZlV1PsPbJL7d3K23i9nlarPq1wt/v/xltqwP5v0JrpihYkkGuRGKCh0YEwyYJlJIo1Ui3OJp3hXvooU/7Fc3u/zhj3wYLWcVBoAOkFCx+tcSB0QGa0J0QiZhgiYxEqttkoFgVXtne6RFJlxzf2qf+XewnIpoToY6KjVLEmiQkVKVmhoyyxhNFH0lndHMHp42mx/NL1fYk2+PNMrzJ51JkngiHVPZPtZKGKczKCEKEzEK0xmZ/KGw7t6LWvvetBNKMc+J2GbQNbGUORcCYY4FoMozS7l3DruBdLYHHnqUfnGXZ9f5s/zsLuN5vtCD5/Um8R0hqXJ/G0M09TY0GHYZygKMCcoyEpUWAhHdGdEPteCe+1Rzut5RsipXenmiOZAULJFUC00VC5Q4wrOBARo7VXdGtd5zp95+unpwzabB+OZhfbg+TlrFDiDSKsGaEi/tYlQyH93ZbNZK6aSVxx7snZGtH7pC99+rVy58gs2/zeTC/AubN2q1q08hwqIVns0UHiVZZ3uANTRZIyjnkUUmvcCqms6n+wE38Nwtl7Ue70eKq5jnkVK0LpHgUlDJEa9j5pXZdpGCE8YMYrsjth+FujrdrIqN8/4EV7RnsoUeQ8iHOeNCCBO41ZJookEo47D/ZHe8P4wctLht88vlyt3EeOsD+vESK/aEcowzzZSLKmUamjhN1NMUnFRSaYuZe50t9mPvV8WHeq+yK/YVNpFGpRTQxAnR1lNFdcxmTTMlkhKcytH5XH9YKrL/zr3+cukuZuFXWH2ax1oP957EVqwh48E5nRJ1MShDpQkx492qSIWxHLHe/YTvftN++CPA1foy7yBtr377WnWo71+ARRveW5M5q+Zcm+ZxcCJqH6gQiab8u4j/rv6Yh1nI+29f1Yf80fIq99wOngADMEFwQpnXylipDUv5sGcWa+E7WzLH3a2KrfceJVesHTZcOKVBM0spOBs1pJCNeWZ4YEFjd+4BfJB371u9SS/9Ca4cU02Q7RcVXRKJ8Xywu8Rdxr8QzIaEWd4D+CDfLuZ5sdWXSi2YHiRWQngmpoZoSYOlxGovVT7fXbJSei+4D5j5PYAP8v79qtiK6VV2RdQrnoxWAoKVKVqhGVfRG8IcAWU4dpPtjPqHbQ7237mvzoSbh/PFvy/c1VWFo4P7Fl/ZhvcsBhYZeEFk0t7xlKjQMRAauUbsd8U+JfsSsO/cvU2n4FfzyzhbX2YdGL8JpDx8883y7WL2Od+225eq2xnDCre4b7KBxISKMgZBnHAybxoZPEvOZyqA0+QP2Df7kryPubXzVf5wEGveOcOKt1jvz5yyoJNVTQdFqSJQmSx3Xpnkg8G9033vPJRWjzf32p/PQs0bZ0DZljPgwEWnmckmm5NcMytpVkJNtqcUENFS675rOtjZne7sv82WMz87X1PQevfNoNIt2moicSBCN4OQHHMU8n5hlkUJjlPFMe48/M5pcU9/ncdZmlVI/weWblHnKEeMoTwYRw0nhplEFLUKAotGWqz67bpzbIeEm4d3cROxQq/Aow0zjFBL+0SQaIQliVumhNY885vgtBQhSe1SQg3TeZ90COi2v6XVewGGEmtxrwSSmONaxWiUYyKwEJhROltiPhGJlWud98oRnp0nb2rlrH8QmRY7UzAjVYokCkcZzWwlRRcS5yLzfmsoWl7dOUuHZgvtbunvl+dfflzML15dLxb5YjektdItM7yAi/MevM1cnxmT7bJgmLM0OS9E0ElC4ID7p7OW6f3uopdsMKkWu40ryOyFumyKMeU41RE0p8lrownRuFMG5S43CUzI8nvlLl3EWqzgU87ZBJpaS4yLUYIFkTLLF5xrKbHGo7tVRk5zV6un+gNKttinhqVmbKJg4IOIxgA4DYZJrxTTwWGsf0g7rHBba+f7w0i1GKW0JOoQM7/3IkRFgtcQkhI26xdOEk7B6K5bOpTBtb2pyPnvK5nhRVzsoQNEJamCTdrYwE3eQoxQRYPVxgSHFVqdtc0J7i/y/gHlWuzpTSMViTjmoo0KHDdJBk1lkxMjtMH63a67RXZIFdz8+BnOrypMcTlcUMW8Yg/KEaeaulwWgiVMJ+/zS1pypgRWL3bFs+5wm97PrxcBfpmHZkjGx++XXy7DvZeqw3i/wivGCsFaGoKgLEFknHLPo1A+EJKsMR5x3xX3j4TV+ta9ul6u5hf3Xqu3K8OpxFiMZoggmPfRGQGJWsmlEjKmbP1bpyJHFj3cXljfsUt3vmnfHuvWBqcSY5EN2xiACZthLxW3MjpiNaGCKEoCYzhHuPNe6OAlfOImvv+yXMEFmkenlWUxhme5d5khEJCRcGWUSoTI5LjljgVNcFd03BWiVU32p6vt0+qQ3lk+xTNdhsSiV1SCzfaMUyxC0kEKriGagH3wO/tsWnWZub0772G1ymsvq0PxwXIqnsVUMeKZcUQHF4JSxiQempnD2jmIeBZ3tlBalcKcX5/NNtffPmymiuV33q+uvc+/dP/p5neqA/wpRVmcWmUEYZSBll5IETjIxCn1jIVoHBC02k9jte+7ka/mF1fz/LEq3xSnlGW53w5ELiCqtO4WEnkgmd5ypkC7rCtwV3SO7LZySOy7k/lh/vPri7z2vPKtcXqBFrWGNz4QS322nwi3nlhmiAYiiUk0/z/uj29iSeWH/3o5W9W9M04pyiJXNlqz4JWMniRjVfKUS5d4Nqe0ExLZRec90SprZe+NXC7WOV2wrHxbnFaaxalbVKhMuYWRzDEubLLcK58skQkoiTgdurM11apeeN+9fP/lIs0vv6zN48t8gbr3xyAyLdpUjlnJQHBmkjY0G1eZkSeINIZMygVOZOysP1p5wvfd0Q9/n53VvTNOJseiNSVcDJFpF62RnkcwGixYRb3jPkbcDafJrNjcuh8+57+9ufLvl68+Qfjbm+XdOcru8iU096y+zXAiMRYnBnDjTTLUCBAKWMg0I3Nsb41LSRCHPWxOybY3N3H7Ab5PK1g09ydfCuexd2XbXUVZ5BSeMeqD4okrH7PNlLeH9k139CSDAGTbnfdEq4jrjhv5++X3Md65gx/mNW+H00ixnIPKEoTMEYC5IELWFElwIg1POjYJeLgTTsEb3sFlhMXtVfNvPv1KpWU3J5NjcTfwQJW1PEhpfCQxW0qhKcoMwKmUBPvLdN0N7foDF25jfnt9rn2Y/xpvn9y827DCHy4/zxbzyyYIVd0eGVi6pZ0TtZSxaVuWOLGEEc40aJX3EuHWOoHdZjp7aduYxl1vbfPkzi9Vt2GGEWqx7tMZlbdINNoSo400grHEktZNlgjFjrKd90mrcbq3N7A50z7+uIXmx9cL9/f1LfzVXVW3F/oTXDEXyiUqDAhB839Gca255cYDTS6BwjnEnfGu20Rin7htP8GmQ8mmG+Py5Tx+eTWP9RV7nkSGxe4VVkuTmpHzhEetTfJSKc6JBgEyUayE6HzqPzR8P8DF1XkWdn7c/EVTl/vJrX66Wn38dbZc5nXz7708n4e/LW9/ozrY9yO0Yge96JtBeZqCJdqraJh0ILj2TYPwhDO5O+NcPjypnr5l78DFC7h5/8fZeY31a0fLq+wdsgy0oAFMNmu8yBBPMkM8CekUGJyc0vkUf0jHnr5bN+8s368W12F1vYCKz/GexFbCOuiQHFDBITClbBSKKMGV0lJRpQD7bXXD+m+1YVTQF99t09k+3uazfWzGJM7PoXnlIpvaNz/3DOFp0tqMFtmGJo1r3gFRSnkWhLYsKEwARSgWoch1CYrfX12dz8LmdpdzBoBG4ERks9YJKbVW4En+L5u2jsXJZFhyhOGJfM8vvvvhjwBX+5HGlOTWZo1LopSgNQkyEG6CE4xrStFHjEjbh7QPnxbzv7t8pT1IS9QzHTVzkctEnE48UiOZBaqojxi1Q6TtCUBn1bpa5D/ZjzUlqDRGMeOcB6cYYTTzCM6090oqNZXpCmww9sztXbvmcrVwYbXc5IW9ni2v3Cp8aq7WPK+OIneSTdHq457ZQJLgjPmse52MXEtqOYsmWIn5cXhClnmw3UU+dgLx6/MGkv9oUMmzqNLsHJb/EeGqiUddhll+8pcVhE9/uXBX/3wR/3n199lZc0m+ueTvL9TDYTrrr3Ybzmq2A/yx+vj6ZsUvTdd2+Pp0Czy6vfZNC7tfZpd/Wx87GSb//U+rG8fSf8TZ4p/+seMT5RWykENztcvVpv/7OziDPzYgaDTHRfNt3+SLbl/LC39yy0/ri+QtpbxhjnJiQDRtgpXUSUZnJYkCtBSNummAe/ovzHZ94Xc/fP/61x/afN3N4fKXP/33P/35T//z//7zn5awyg/+/KeMn3P485/+3//5f/3v/zP/+F/f/e8//+mf/48//+l//X/f5ff/6R9//st3OwQ1e2EeiyrK5IhOIklOeZAWVPTMCdEE3CVpsq/+0Wim04tKP4mNxdrdPhJ5ZdNWB0o9AcFtoonxpqyYxhgpENZ4N9c6IS81v9nay/84n59td57456t1EvamqeOjr7be/vn8yRe92uYIbU6Lu0nZv7/QD2tG2x9Bt4+Wd5bcXJXe+9DrD6PWnybfmnCej5/bv1WSJsjWGLcCRPOB1MPgSfsP9OreyluUNOnshx6y9xfcoa2a/OCeFn+oOChfozsj8uWXt271ad1Ar7lbPV3vgZJwL9gd5vaX5SL8pVn65os2amz94oMkhQ1GbX8ynu8C1ZA43QfTSCnC9A5MzVeY3nYcPzlWv1o2O1XJtjpl8+NBH/SKsOropsgYsbrFql3b4s24rDeXy5XLa208BicBK3nx3xOEm8hwm62alzfkIzMBCZpYIiCpYIGxILknmnPGXQqR+XW9yqNkt/af8c39q90BI1tT0yME/NTSu2BpT3AZ2L6yli5pvo1+WHx39zy705ngF7dcvV1/xouL2Sqv//iV5pOvA/UPOxA+sWTzx40J3WQeNgp+dXG+eXrT62AjiEdx/3bLvVuuHq7WOKlO2TN0E0Y6aQPG2Qvx1yEa2c1eyN6Etbst2OyF+uvJOyzNXui/DtSmZsO4Ttb3Y/bCbtwj/9g6SZ4sSXI2Ghp0SoEZKRr7MfM8SIbSEKTGvIGuDudeT8jK/IC9yq7YplzrGAVjBEAIwkX+xyRHAiPEUiKwhLUr6ntT4pUhvje5FcuLsgHsZHSJOqa8IdoynhgzwXtJBcNWsp3R3pONWRvYexIbDqAYaSOnrgyoMvzjAIqp7AkcQNHfpsABFBPZFTiAou8UVRxAMaX9gQMoRmZJ4QCKb78ncABFn9sCB1BMZmfgAIoTGFQ4gGJiuwQHUPSkOU45gKKUAmYAU8BmmFU7htSxAkw9s5hVe/fMEndhushn8tpibN4eLre2c/laTYA12iFgMbX2xKm1JETDXWrSar0h1PHINM+kD5RNkW9GhGBq7b7UWt18mUedZu8Gxx/MsWhsxffz60WAX+ahaVN1DxbbYHspl2qz3m1F20tI+c215bnpZ9jUs90m1HZY6PfLn2DVrPEOlpvPt6552+TStviGdxZqvuNGtvm3N7/0alMHd5s5e6I5UZuk2VNO3dmmy55mkEmTKdsq9ZPK4KxnITRUVNj8JpWGRJqS0EYBBsC6ktFuxT6VMczulVBPdoeXnnJqs+qR3jnvg9cxGK+E50JJPRXcDtVjqhdVURmYe5BY0U0orAg0A1xrzrUnPnpGQrKCSy+dmkpfST1KhD9hwyDCu0oMZ8+ua5Zw9uwzgv3pZs9uTHFRaFWzt2HGUM1r5M5eLm0+49HtbEKSyQcAQimz+YywxHgtmfdSW2abVFVsZ/NXbGdzwnY29ol2NvyfF1uJ/aX5Mq+ul6v5xc3Ak+V4+9rIsqdYUEYieorHEIFrQHobgvvLzf78SxNU/csN0G4E0Phid0Xm/pL105N/WlcMRFAvEyJ7NK1wHg3Wua+G7g+Qun+8VtsiJ2M4SsQwxvFOHcfLpqNQQLQyWiodHXCaX9DSyWA5MxjHa98iR+10WxRmRN5UZ6wX/BUur29DeDtR0WIl2EbObqJvzbeXO4tvn1isIQDNDL+Npb68jeB1OcJ/2szQgaaE92XDBMIi/+nyxrXdca3VPSk1a/7r4vwmVqceZq+1XOtGTtulmqDco9lYpaUabr9xBizvxCbVk7HOJ5Z5u5hdrh6ShO+Xv8yWt27S/uaQbrjRSYY7tm86Yy2xYKmxwWjDpPXaisxkk9ci2oQd9Tv7t3s4cyrz9PUhshLGjQRqkxeOKuBM+ZhSCopBEDoRg7Peu2O8H21YG8z7kVpxnikXUbsgouHcW5o0pTqlqBl3JkSYSjMlMRjS5e7Y272LvJvPtyZDvSklB8up2EBGUqWUYYxoCdAMLxW6yZQCwgyQTQ/wCaB5wOm8RxGP2iB9lLCK7S40UyElJw1E6ZLliQYINBN9ny0Ug1OnO9sjvZDhyvDdj9CKdndglATpg7BUOJkfc8eo0iw/o8Ehzk+M8yccNYjzA4RWtrpBgHMk5DM8w1oGGTwXTuv8IP+cSgbVgDjvw4lYG8z7kFl5wrpuTm1GAmhhjWZEkOQjEVFpKjxMBOUDcssWwvrKme5GqSqD9uGCKs73dNZ5rYUBoRhLmU9SIpUk0mdkK41NtTrj+dh4TW2wPlZexUnJvLFIdORCMMGT8SHyEIRRWnMh6VQqcwa0SXoLI1YG8/4EV6xEc0YlTqLRlhhtpBH5TGdJ66aZKJU4g/5ovB8c5q4d7wcLrsg5U4rWJRJcCio54nV0zoZswghOGJsK3tm48P7gmrszyhHvBwqu6DN3iTamuqD5v6auQnPLjQeaXAKV1ETwPuBwpFOkHVUG/ZPIsJzJIoUGEoLizAZJGRBpbbZ1FKUamMNd0PXU7yUTvjLY91U+sE5MVLxQh9m+0ksMVJDZFGM/UWLX9sMeXZlJFc2bXgEVMub/F9oxFbwDJmTynBqszMTKzNNVZjY54yeXlzBtttmoREe0Z8SB1YQIk5r5hSxqqRLTLoSMt61m152KWtffYcQlrfuKprS02FR2NoqSVlIoaV1/otuCVtm+oHX7h5WVAmqwWAo4G085a1kXbezR9cf7ePdYrbeUVUPiiF8sZT1xKatIVDhBg/ASLBPWCypVNJFbKjwNFEtZ25Sy2ubLtEpG3hxx38fYmKnZAF7ML36BtLqpYRVt4s2bNX6c/fF+tXg/+6/b1rOiTRRv88dvF3D2a2Mt3zjwO3z4/LdXbgHv73Ws5d2u/y/X80wcYOVu0nlkm8Kbzd++g4v55+bC8HLh/gbL21rUnfUNO5fIgvvw5Qo+zLelrE0NqmzjMdn8+YdMm5oushFens/D326qTnfnwBRW+BnWbW83ZKVVKWjyYC1X2oOmMUUanYzJu+SN8tQGdLF3Tog5atNW5lQ8TljF1ABinHRcKwBHrLUmMeWdDEaIEL3CSXFdcX2gIqkM0AdKqYRkzpJJwVPKXOJMMsuDlzxxYNKB8Rj+6Yzkg6ya2oB8kJCKTSdiIswYAsYGRmVSQTFnDHVOGqXCVJoqj9LS2GFhV4bn44RVtKDBUMU5N4w6QkESTw2P3DutXBApIq5Pdz7fYX2V4fkwIRWTx6kUyUhFQ1JRkiCUINwBVwpktqYxebzz+XyMB6IyOB8lq2LBT7A8EdN4OaRJmrhsNxtlA83Wc7apsUyzM6oPdYrVhuhD5YTlmAMmgGM5Zls4n6QcU4JRLFrHU5SUKSWU8SpQ4ZSnUQj00nXG8xExh9oQfYSoisOjgIYoIst80IDPlocw2gardNTGSoZ8sJ8zuk0UrDZEHyyom7Rs2jkt+3Gu4lBJ2U0ldaek7Icf9eiUbC1MypTZQkMpoqWJc2Mis1QQSVXgmJKNKdmYkj3SlGzTIiX75mv/m1usc8PGm5O9Tn560iIhVkluiKXMZRkQ5lgAqnw+qbh3bioNYge0SB62XXpYAvjgeb1VY0dICgvhx9b4AQvhT1sIv7HBWUsbvKic5FCVkaSVEV74rEdb4VmxOZ8kQIIQPDOW8KzwqeIpGeUSjqxEKxyt8DFa4U2e9um9BO1Kt2/eH4n0ZLbYtQUatZEi2UaQYLj3jhPrVSRb60h14DCNQLJiGy2D4SUGE7SOUTBGAIQgXOR/TD7KGlhZSgQymM72nt4prM1g7ebx9mHTCrlBTmPINEbN6uJ883Tzfn3mXl9yw9bS2Fp63Eg/dWtpHBTwLdsa4aCAfgcFbLg76cjddxhlQzF32YpTPP1Jj+ftyhspIe937qN1MqTIIlcuGJLZvBbI25G3I29H3j493t64eFvz9tdfLt3FLKwTj8Ybf2zaW6y/muqoAZ/8eoN5sEUnoD3xeY/WhlkXRidFZIJIrh0zwiUCnitrwYXtkYXaELUhakPUhpPShk3JfGttOHoFKNt2tt31jQbjfv3DqaWaM5ZZbRhhTS0WTyxY8FYlCOAclUahmkM1h2puvGquXKa5Q3SvZ4t8cs4XX+7Kb52t2Ph2d7j4Oi72P7J4H94BuguxzRt6d3e4rpe8lwNuaASptHIgmMqKTSmarXiiqdZc0m22qWgRqX2IiLEquJY+zsdfZ6jCgL43YEvVJpUw0nBhdHSR0OCFBmpsPr6TZsGgPxNV2+lVG57PB53PjUG873z2Xyegj/aQLpYBaOF8UweQKHDqpSPRZXVvYpaGsCJqDLh2LQMo9xR6+RUwdx//DOdXTfv0ygKtxwmrOCVMMxVSctJAlC4fjIkGCGuQUwUGEwlOnEhw2awCTSz8zo2rDt/9CO2mW69sZ2Q/oZMGK8HlbSztnR/yaHM7MQATfBBBS219hGwQZdXGbf4vGEvQ3EZzGz1JI/Qklcxt9s9X64P5L8tN88V5cNm2H625zcsjN1RGi8CRG+MZGbOzJdf2Gu/vIu7+s2pnxmTrWeAkr9k3nOR1i91GR3yd5LVZu0I4GhxhNMMRRiceYWQiUdFJ7Z0JyVBHIiEyeq+EF1FxwBFGT10Gtq9sSehTVSQ7Ve6NJzf/+b03biYZ7SbYO5dqrOzNZ5wvHq3VfHldcgfdX+sdhOvFcvYZSp+P/XWT1dnWulg7FppP+Wglfn9sT+kwtFHhYYjG5biP1xKAk/II4DEYl5wWhr/WamsmHGKMtubJbU2ZuKBUWO6p5kpL4YhnLHIfIShPPNqabWzNtXQfGXWFVkz3FfL3yy+XYYfR2WqCIg8WeBCSO+mEU4wSkhQlyRpKk3QJw497r/Qg/Hi8JVVb7LEP23N/4HG/d34Egcd9H/L4wKMXPkYwhOnAGM1HdYrJNyOfmDIqYqUWBh6ffeBR7d9eoxKcdYY7T6IiCaIOXEfLTAiek0i9cltuLcS+sOPIc7BpKb0vSk0tkwyiFwkC8RKUZSFQD41BwtAO6WiH8J0j1rYXebuY/2de/YYcV2ZwdBHN1rIQpo1l8Q2rBno989pOEIgsadrkJ3uVQDCdImEJnNCRUicBbQm0JbBmYKQ1A0/VLd8eFxt1srnx+WPEWfObozUuWNkhql1MBh2io4k3ydJteIC5j7ePqo02aS8ERfiiP3+g09KLiMHN2RiCm/ZO4tw0T70dYSVmCOWcGG+y0QdJmmCUFxIoJ8IEpjGs1CasJNdhpd0tn59StBcX88uHr/7ozpdw+/QmocmUSHTLhTNBaUb5NUaumzWIuXONtYhKkYF211h70CG+uby3eJPxpHeW9HVa/MPi+r5g+F+fGga+z7T5aTG/vmqWEH/dmzyV6TZg8tQojufm8NqTe/KXB/e8mlOcWPBMequiTtIRZ4QCTiIBHlS09vknB7BBkgM2/hyybxTZnfSAR4dMQ87z07Wd/PDNN8u3i9nn/DEenfCUPARQn9ecr7JEID468ynpkAjR9arX/nwWHmkCSh4m5/Z1yX+bLWd+dr72ijxQE/ah+ulwzV9h9Wke291J0Vyrw5iv9tfadQdlc7UjYPPk1R7fObW+cw/Nm6Ov1VDKHxfzi1fXi0Xehze39+t1dfMVe7/sE0gxR969fJfyqfLIjfcEVuxapA890D1dbueGJ0cKs3DBx4ihm/Plocrp4XJ7QUObc8ae4MpP4Ibydulf1jAiaGAehNcgJThnElPRcCqSIhh27Rp2PdqxWVkstgdH8KZ1d6lzafuYxlDxWvV0D9O2H/bo8G02y7kWLGhiHdfAvPRBGhZ8dEoRHGGB4VtMBXuuqWCbs2O00VoqywEIQ5x16OG6o6vFXQ/XrY3ZvD1g0LaFIfhuPl89RtYUPV4F9FLiJKIXo7UndrA6R7lWNlDmrKVcspg4DZ5C4jFZGZ+9g3W46ivVwcdyc83dSvRu5VWBd6cUrUskuBRUti29js7lO0mk4IQxMxHezQbj3f3dwMoIeH+CKwctDc1ME5XiMzTpXroloElnBEP0okl3YpMuJWFDSpRYybz1miuieJRNPbZMylM06do3b+rVpNuk6nddbxsW3rVkI4hHh8n+JTfRw10LssM+401gadeSvIUlS6jyDULXI9DBGpqhKijnkUUmvXATsWQHjCAdhdvq7NdjxbWnOQaJIWRwMy6EMIFbLYkmGoTKRgFiuzNLO/YMrQ7ePUishPDkGGeaKRdVooolThP1NAUnlVR600MKEd4B4b1aCZVhvVfZreNkTcOT2eXWXGLWJ6GzUc04B59AMwKWC6qCBKI5Yn0An9td8/WbJL1QchcSwx7l2dr/2I+89rnaPMHO/bPRFLv2t0+m6HTb4QXRzHltI4REDShiXPIkOdU0mKBOUYJekDZekPWXUR3SzLfXfP3l0l3Mwl0I3vhAHmXrdUPy5qvvcShoE2lUSgFNnJCsr6miOpLguFeWYkpqdzXdEwQqs0b7ElvRwcCCJ7CeBSY4ocxrZazUhqWgDLNTGWo5YBi4P49qbXDvT3JFxHtrrEuac22ax8GJqH2gQiSa8u9OBPHfsOCgq0quDOdHy6uIbpkgo1tFl0RiPB/jLnGnQQvBbEgK0d31PD82oFUdvnuQWAnhLgZDtKQhm+JWe6mEUy5ZKb0X3AccVzyAw/jpkG1lWO9VdiXUg9aOBsdIyEe5NZoRQZKPRESlqfBotXS2Wg4uJagM4sfVXDyF55AISQJchrNWKsRm/rzWhHJPvaUKT/GueBalNkvbizzy5lYG5YNk1Kn/8uaejLX/8sNPd3QBb5DeWQVUC1BUac9ACOOCyhpJSEFxlgMW8GIB7ygLeJ8cIU//OX/uNDu73rz16LuNrI6XFWc6ZIrotCXUWJvytvOeeGIAvAEvtVVTKXIa0MrYeVtf3UXM/Wf12RjdJVSyk2MU3sqUhJGQOV+QTFsq8/8FEpK0EhHc1Z+3s+nmrbp4mz9Vc/Rnlh5guZwv1sVHj16tDtZ9ia2IdWuJBZtP62C0YdJ6bUW2mJLXIto0lVjkgFjfKazbm/YhK/SPP27R9vH1wv09/9r1RV5jvdivcHldH857EFkJ4/kYpzZ54agCzpSPKaWgGAShEzECMd4Z4+XxK0/fMNjG024M/bpg3o/USkj3mqnQuPUMROkyd0s0QKDAqc/YN+jh64z0hz1iS/csv79O0GtU8MuGw4VF/tNlfUDvRWjFRhocBDhHQsZ2cFwGmbm2cFrnB/knJvV3xvnDRtPlW7Z6eDT96+K8Ppj3IbMSypWzzmstDAjFWCIgKJFKEukzK1Uap3QfnTVVumPN7Xh7fn22GVHReBWrQ/jR8iqhm/HmBNeRC8EET8aHyEMQRmnNhaQU0d31DN85m+WJu/V2MXtcP/f98pfZsj6Y9ye4IgsNjJIgfRCWCrdunOAYVZrlZzQbMYj309rmt/p3vVZjblZptPQitGKWiaRKKcMY0RJA+ySFpjI4IMxAtmEQ512tlrIb+P4ta+Ks+bZtNXB93PM4YRWbJniwlivtQdOYIo1OxuRd8kZ5agNmeZ8E1+tA/sfvY2zC75erZtzGL5Dqs1GOE1YJ15IYJx3XCsARa20zCcQ7GYwQIXpFENcdcS3asKbNrfpx9sf71eL97L8qzAs8TErluH3KNoYhYGy2tWVSQTFnDHVOGqUCxu1PeEK/XcCVW8D7+fUiQJXhneOEVbQ8wFDFOTeMOkJBEk8Nj9w7rVwQKSKuu57QbQj/5lb9y/V8BRewctXh+TAhFT1+VIpkpKIhqShJEEoQ7oArBTJbIejx63w+t4kob27RO7iYf27OGni5cH+DConhMbIqRmmC5YmYhh1KkzRxHJhZz2eQzlOKscjOqN45/3vnncpm4YcvV/BhXqMr72A5FdkgGMWidTxFSZlSQhmvAhVOeRqFQDbYGc1tHK6bu/QB/lh9mL+aR3h5Pg8VWtBHiKrYrBpoiCKybD8b8PmkFkbbYJWO2ljJ0H7ujOk2CZt3b9TP4GJevT5EHyyocv+oZFLItgVziTPJLA9e8pTtDunAeGxQfUI+mKn72a9NOVh1WD5MSMVIodYxCsYIQLYsml7rxCRHAiPEUiIs4rgjjtXuWut1Us768fbhTY0IbIpIfl5dnG+ebt6vDtq9ya3onXY2Ghp0SoEZKbiNlHELyWSOGKT2iPaOaH/UB+aJu/aLW67erj/ixcVs1ZxPj16pDvG9yu6mtassdGvYX+LMB2raIPmTxeX7PuTRvRuEddlGowDOCyc0kTEQyYLJ1MRbqyj2bsDeDafr3dB0VNnRgsAt88dZ/iXOw38sV4vrsLpeAPvnq8vxNR5oBsKtv8UTJ82+bzJMU5id50vhox19qqhAuQZrfSCEMceiFtr5QIN33nLGtreetLv1477zov2dH/zG7zxUn/5kR993prnnmgeraQqBJcIZ9UJLRpOzwZnNfeemeN/hD5c/8MjvOtt71x9/jWHuOdlzz+99ruPtB68DA6WDAE8M5SrRbD1YxoLzCug2/sp37PSHun1kd5qVOsrQzJEclZolCTTISKlKjdcrf2+a6GQy59lgzIk9vKubH80vV9hmY480SpyeSmeSJJ5Ix1TkQithXD6NKURh4mRy3YdDJn8orLv34kcX8r/1NXduJ5QtC+dPWEg7FcAgOvJYstlSN2pFqc0MqInrNbXgnEmbKSNRwQSt7Y1utI9044Ovfrmcn8PH76+uRqckRUlJ8pA5H4MUNAmGCZXZM7ceso3oMoN2U0l+FcMpycfR6DvQqOwIKgujpCIFA8GNFs0MXcuDdECUUp4FoS0Laipub27lQMj8rTbsNR64918u0vyyWe/ian6ZxXEXgOezsLnh5fhLSopwrYLiEHlShgvSjF/KPAogksl0UxgKhxvy+/XGXK4W2RRZfnwPi8+z0NgPmQRX3Pe6k3CK6f/KMON11Nq7/NNSLwQILWUIMSY1lfZlw5GMZnj841vzw+f8W69ny6vGzGyudv95vUg+VlxbYtKMqNlBTJ6yKrZxwwt39S2ChFMJkA0RS5xOgGyYgKJ4Ul73wP5tweU9A+qDktlAsgwYTyyJSJlUTgUbNhpLP3Y079zOTa6Au4xNZfKvs+UyHz75F9aJu8vtW6Pj2rzEtbX3TX/zRJzwYJQPxOd/NCMRgkx2KgnFw3Ft8XjL3UdO09n4FiqV6d9uwikPtArJARUcAlPKRqGIElwpLRVtivAmgluuLXLxE2GRlrj4DSBbgTFrFAUqJZeYSCRAdB5ozGomRC+cnAoYh8qHrA6K+TqzbBO5fKFbjmF3JwocaJQgBUEKghRk5BTkcULjvt0+a37VnW9fuUsvnhMH4ZaATMxpT4PN8vBCp/zECjBEUzKVpBhOhnMLPm7g0gE7lWnf44RV7O0OWjghVXQcEgMX8iNmwTGvlbdpMvPDhvJ3V2cY0mwNvFltsmO+PztbwFn+EHs601hDk2MSBPGE2eAkcEcksSRTZSumEhscyqFTH+SyFfJh4T7DYnmfj/CD+MhTBycSEiQkSEjGTUiaKsguhOSe8/Y5ERAMgmAQBIMgo8UtBkEwCDIaMGIQZMAgiNbdSced0xNJBpIMJBnjJhmadyMZ+Vucv7l8t0bFr/HDVgRIO8arMZF2jEK/Iu1A2jEaLCLtQNoxDijuzL3a3ZTpcLsEiQgSESQi4yYismU7hZsNv21bgdRjxFoTqccodCxSD6Qeo8EiUg+kHuOA4i7qYTqUlj9hiSDZQLKBZGPcZMOIw8jG28X8P/Oxc+NeWL6/6cOLLGS8ChRZyCjULbIQZCGjwSKyEGQh44DiLhZCiTqchuyzUZCfID9BfjJufqJUO36S9/rZApbLl25x9/FtJ++RsZHibAawPDSt75X31BEjpfSBMaXzcxa0nEoZOhuqWnfnWO92sKlMBR8sp2IhsNeKMcGSkpGAWU8dIRQCkTK/AlMh1wOi+bGwHt+l96sv57P/gnjntfrgfLCgbpzgpr31Wd4iaGuirYm25shtTd3d1tx5ejwnY7MS7WwMqucpqWd0Q6IbcsBkCHuYHbgDvGgIoiGIhuC4DUH5eLzvY8G9cuETbA+e9eM3+bu/nc/PR2f/yZL9Z1XUnnlrXVaXwlIruQlRWOdcyKYhTERdigFHOPFd0irApTIF21k+JWtPJ2KFjtYEr3SQoLwMjifhKAdD1FS6DNqhWrZWZ+41WuHtcrHF3z3ktZwlZilx2jb5YzZlk8V74okB8Aa81FZNpbnqcP5tsVMvZvskzc6ut6vde1bfEdpdQsUxjlnXS+ZNtogolQm4ztaji1ZZGiKLSJm7ItjsNLXv358f/ghwtX705vKzO5/Fe2/nD5TXyufP7a9VB/LTCBFdR+g6GtR1RNq4jkoGMHqM0GOEHqNxe4zM3uZhtzv8l3lw59vNfqu9fvdNpupv89WP+ZCOd9TVyFxJ5SqarCyBE+FVdEJKrRV4kv8zWVQsijAV9UmQjJ9IgdoX37U01ZiS3FqhCIlSgtYkyEC4CU4wrimdCulGU+10SPvwaTH/+42tVkBaop7pqJmLXCbidOKRGsksUEWzKkWkIdKKc0zyh3i/WuQ/eVDZ0qq310FmAzIGZAzIGMbNGPYXtuza+uuHm12/fmF0BKGYayidBqY5oxpiYN44nkKKLJlMGrh1U8k1ZAPOV3xcsNEONpUp4YPlVLIM81OlgDpH8vmoEjfOUuEiMUzkB2wqsefhwibKtLpLLdwmlcG7P8F1Knxps4XQFkVbFG3RcduimrW2Rd9/cguITaeQJp8ZYv6N64vNF4NxWqRFl7VKUpjEqJRMEepU0gGIcMoTSl3yU7FI1YDFqfppVdQCPJUp7iOlhWlpmJY2IjRjWtq4EYxpaSNOS9sM/BCdeNdeFYHsC9kXsq9xsy+1d7r51/0+v14EaFwsq/niGRedZXEEyow2ShCZNToNXvsYuBIgndFsIpp9wKIzuVsr7UVNZcr7UDFhCRqWoGEJ2reGIHL98YAWuf64Y6nI9UfM9bEEDW2JAUvQdDen0pN2MHqT0JuE3qSRe5NIG29SyUwbmSOJFgP4lTAfqhRyn9Eo2Z65T0j5/HNCgrZSO0UiFdIK5XRQMQWtJoLhb56D8vT9ubXSX7qz6tB8pLRKyK4l4X84ZGO+fztMnyLfn1sCMjGnPQ02W1xe6JSfWAGGaEomM5dlODSrPYMQv49x1vxdvl+bV+6aoLVB+ihhFU9pC06GIIJ0PkhPWcp2dKSGSiaSDXYiuNaD4ZplYb1+c4eN1utBLYmiWHUvmNfSOC01Ux6kjVTaYEI2H0ASjpjsjEmyvhFYK/W0IDA+9YIOl7GCAapnGaCipjF2vQ2eWeqo8tn6NUFZRqLSQkzlYB7QCH7oTPrFXZ5d58/yczbhzvOFHjxf1mwDHyOrEqoNV4JkY9cqkEo5Q1WI0vgQ84tUBIGo7ohqvZOA3wZs3uZP1QRf3i7mAZbL+Y5X7qQ+VYbyXmVXQr1SgXppmHOGOCIlkSQSzjw1HjSPeJZ3Dp3sFtb59dnscvuj5uO7q3iKzTc0TzYRq2lmhAp8tj0I40AJ0cZHO5UU8uGwq3aO5dhe5F5OyP1nNQO6F5kVc8uJD15TYS14yQJJAZjyzDtKA0/OIcq7onynsG5164e/z84+bhI7Pr66Xq7mF5snVYO8B5GVME4iVxqssSJYZRLTLFIfuAEtPCdsKg02B8T440jB4xu2RdrNLds+rRrnPYntJuuStc26fDrSjgmXmHCJCZfjTrhs1zypbTbNyJIvi1W8leStUSMwc22UGvuEmWvZHCXcpRilSdpp5QLPLEwqRqSz1NCJYHtAh/BOYd2/V//mzq/hw8JdLtN8cZEvvnlhvj4G77xeHdD7FR7GuV8Ml02PYe5nGeauJP9ouPMf84+Oyj+qJEdzQDxijma7HM2OfenaGd/o2ELHFjq2xu3Ysq360h1pg43M30VxvuULawZSwtU153g43nIzCI62bs9x1F5DlYsqF1XuuFWuNp1V7trL9w6W8/PPWZbfL84+33tldBq22M2DcReSENpnUpuIJNJormIwkoFJZDLjOIaLJ+1OUOuIoMq0dC8yKyY8aSJAKSsEZesB1ipFl7iJRFsa7VRQPpQZ+eT4s8Idu/es3kqD/gSH/W2wv81IQX50lsB2Xjc5iKbt0RTIypCVISsbNysz3TP87u/6G9k8Z2ZmIeZ9SGkyzHGdvGQuEZYNWE44i1MpRKF8OKO1hVpqBaPK1HlvckOKhhTtGcAdKRpStKmDvC+KdliWSgttgTQNaRrStHHTNK2PpGnvID1jhmZJdFFHFkS03GrJtApCMU2tCEHyqajwAWNnbYsuCgCqTI/3ITKkZUjLngHSkZYhLZs6yPuhZdb2wMoe6gkkZEjIkJCNm5AZfiQhe0pljoyWseKo+zpMVjrcZFu0WdFm/faAR5t1nCDvK5QgezBad28fNF3RdEXTdeSm64GxhFb9d0ZmvhZ7vNXSB2u4sAI2wnoWjbAgGJs8REu85IIzxoX04CBw57xPUxksbYfDvTj41n19oV7y1rf4il3nE0kgQCdmwKpIwHJgnhurGQmOTKXRwXAUjm467DQGlptdVnhuPxYANrt6MZzLDJtd4UDS0WESGwLubwi4dUYdEUFtYQijQwodUuiQGrlDyvblkNrJBkbmkiq2YauEmbPh6AlS85FR821jONqn2t9xKVT8qPhR8Y9b8as2kaj7Z9pLt4TH2ntkKl6UVLx0mWRbk4gIUivuI7XgLDMp0CCYnoqKF8Ml+ssW0tqNm8qU+eGCKo4TAt3kRKnoOCQGLuRHLGOaea28nYzNSocKo1bXOrhpEvxm1bw9X3x/draAs/wh9ngsraHJMQmCeMJscBK4I5JYwiFYkSaCOYmQOxHkMv3IrOEzLJYuX2xv1idJIh9soLVSIabkpNaEck+9pYpPBGzDcXKxM4/x/kU2P+ol3gfJ6GY8b1uf+n7VjzQaaTTS6HHTaNOms/qDE8qFT7D59/+BL7cP8m9vzLDxus+LBUlM6ki4AxFsE8TOzIQb8BDBG5k0mYqmHrAgSe9sGH4wmCpT4j1Lr2SkOs28z2eqD5wmahylQDlRwjhDvJJTqcUbzkjd3e/jyXvX0IjabdY+RHYbIGrbkvrA3YSGLRq2aNiO3LBVxxq2ryG56/PVo2NgdGZtsf2ZdFkqhJtIFaVGg+LWC+qFtUoEIqZSqDRgnRLtbJc9jaTKlHyvsiv6+Osgc8PFSZHLIZcbE/KRy40Y7n1yOWL64HJPaRFkcsjkkMmNm8k1x/xxTO5GqluhPnNG542SDqzWkUmAbOQSIqRRJGlHNbCp5K8MyOhsZ+tsP6IqU/knkSEyPGR4zwX/yPCQ4dUD916jdaoPhrdPmyDTQ6aHTG/cTK/VpKJuh8zIiF2xgLsSxa41avYqNHvrARddVkc9jnoc9fjI9XibARctNv2HhZutnpcOB5DBeLBGR5o3HWFM6WS4ynJTNrKp6HBBBtPhcud0hvboqUx/HyuuG93dts9/25VRb6PeRr09br3dKKY+9Pa/L9xVXuZHF1bzxZfRKfBiGVhoWjuLQLxPnjEiCRBBohJaAmTZwUQU+IBd1FSLauRWMKpMk/cmt2JLaaeBac6ohhiYN46nkCLLJivJx6qbir06HNrlzhTnzX36ZR7c+Z2Hv/v/zNdav1Adug+W021ioOjPQr2/Y9BURVMVTdWRm6qkV1N1nJ6moqFai6dpQNWNnqZhPU2FvoCWEx4JCY5zagM4zqyOMkpFCQuTaXQ55HTgNmfW/hOyMoz3JLVbm5X1brOicxUtVrRYn4HFqo7qtNXs+19h9WkeR2elFuOhVjKbJJFW+KzIk3JOSa0ScKctS2kyxSpDdVvNku6WaX4XOJUp7yMkdRMFPbqR0NdFUUejjkYdPW4dfXAC8lb/No/fr+aLrBp+hvOrEQ41L7qUBElGEJ5iEDQRrgQzQkjlKXjjQKiJKGs13HDn9tm0TyOoMq3dh8iKriUVtWfeWsdEEpZayU2IwjrngtdqMgH+wTAudppZj27Rm6wh3s7n59UBurN8+kiff2pvoBWKVihaoeO2Qs0BDU92n1OvzueX8FX/jM0YLc4684xSpaXh0WupbNLgwFCmRdCB6zAVPS0GDAG16dHRDkiVqfAeJVcyTZMEETUxnkiiNeNBMAkqee2FZDLIiUCeDse/WrXl2HOS1VsL2rP0inOyHFdeeSDKgcj/Wkgkcs2tCR7MdE774ZDfsw6vDvt9y6+EftDa0eAYCaCFNZoRQZKPRESlqfCI/s5BshbCejefrx5bv5XB/HBB3ea0HNi+p425hN4K9Fagt2Lc3opD2rPu3vubOb6bkysfIeP1W5Tbs3KVuAgEuNfgpNA027LAM8SiBh3YRHS5HK4DQKveol0hVZmeP4kM0ZeBvoxnswGG82VUwuYGLMxBNjcUmzu0GWs31YG8Dnkd8rpx87pDJoO3158jY3TFGoZKTNkBW8KgKTsqU/a4qcltr4RKH5U+Kv1xK317QFuNLkHQkal9WewEV0dKghzQg4U5Cccp/iFzEixo4YRU0XFIDFzIj5gFx7xW3qbJtOAYqnL3t9rQSrMZsXEAzRffn50t4Cx/iD1D3ayhyWV2JYgnzAYngbvMuizhEKyYSrW4QsidCHL0xXcfFu4zLJZN4TVGqAZ10yOrHxWrxwAVBqjGBvIeAlQHttBqbxajnwr9VOinGrmf6oBGHd2V1djcVcV6SaEY98wQcJwHUCI/B68Uy5iDpN1UzFkzXKetE0mrNp1/KjEit3vBOJK7Z7EHBiR3lmfkuyCi4dxbmjSlOqWYN4EzIYKdCPQHrCXbOaniKc5SL8YPlhO6KtBVMUI4H++qOLCBU+cPjx4L9Figx2LcHgvVfbbiI0U5MndEeY5iIiQJyJ9ba6VCTMlJrQnlnmarVPGJKO4Be4mKFvMAa7dBD5IR2p9of44Pykfbn+awAYkPtgfalmhbom05btuyMfg62pb5XDprUqR2nyAjMzR1ydCUnEXJtI9WUs9NoiqKrKFDdCEIZ6fSb0MM2LR+58brgp/KVPXxAkMT9IXE7nCjA/YxNihWFpiBAF1fmjdWFjyBuaGMhPog16WyQDrNlDWJiCC14j7SfLpZZlKgQbDJTC8ecuhhC2m9dEtAjX2woDCn5IXGnJKxwfkUOSWVFHYPWPiFdd1HofwEdd3/uMmSPyACUHJVYDgAwwEYDhh3OEB1L455FmGAYvlLJV5SMaCNil7Sb+klrcSJwIdqhoFOhG/tRKjD7Y8u2PF4/dFvhX6r5+a32uTuHVY6gowdGTsy9ufH2Jvy4B4Y+/Knxfz66nnxdqW5isxDYC46bzWQ5JR20VrGo1dTSd/Tw6XvSXMYHb1BT22q+khxIeXJJzRyntFwnkoynYbiPPVBrkumUy1e91H5KNHpfqTTfRMcl71R7I0pgEQbiTYS7XETbaWOINrj7cRQHEiNnRiwE8MEOjFUEstRw81Vx2DOyYM51TMnbCwyPjgf3VjEHMmcsLkIUiakTN9cWC1b7XdoXLf5Bll4cbY+l17NLy7mlw9f/dGdL+H26fMiU9ZkRU0D8yC8BinBOZOYykYpFUmRyYQrh1PbtiCsx3jaPqrYGD1WXiWjVFMVjAwQBdHeRR+pEERAAGJEpl9TiVcOWBlXYsGHnZaV4f0EEizWhtbhLBtuB6Cv7GS+sm2X8Y5tHg/ZM8jTkKchTxs3T6OkQxJpy0MgS+xDFm8jZTdryNOz5GyG0kAEMVL4bMR6KixxhDIutTI0OjcRnU7pYErdlHImj8ZWZdr/tMIshtTQmYHOjMk6M5DKIZV7XlSOdUxJPFI5IKtDVoesbtysznZIWGx3HPwyD1ko8c3leNmcLM65jjRQ0NxzKag1+YmTUVumY/SSx6nkgQ3WPTorx1J+0+Ggqkzzn0iKRf5GidOWUGNtyhrKe+KJAfAGvNRWYbius4W784DLdyPNzq63q917Vh3KD5DQHo4GTYUsaCu1UyRSIa1QTgcVU9AKEdzVA7GTfxTuT75+/tN8DL10Z9Wh+UhpofcBvQ+jwnPvRRfRuSCZN5mgUCoT8GxlRxetsjREFuVEUDxg5GQn871/4vzwR4Cr9aM3l5/d+SzuPoJuf606mJ9GiLcJFR3T2w+17dH9hu43dL+N3P1G+3a/fVhcY+77qI0BDBePVe+fNFzMdZKRR86VTExL2QyVVSLG4JKzjouJoHvA3Hd1tEP0wWFZGdz7FyA6LNBhMSqIH5f5zk9B1O5tGeRoyNGQo42bo2lyDEfbPhpn5+QiHQNiaSJUqywT7gF0dIJYIVniWvsYJ6KwB0xrl6Xbug86lWnuo2SFSemDjYlBL8OovAzIspBlPSuW1bR/OY5k3T36kU8hn0I+NXI+ZfriUx++XOUj6vpidLyKlniVA2FpJJRRKQ1NVnMHYKzg1Hnt2FQGKAyXX674wVThK4IqU9m9yOzGUUpInzr8Zn3U5ajLUZePXJeLHnT5ePveM0xXQUfSaHU4OpLQkTQtRB/lSFI9GaHYPRwNUDRAv7mw2hmgskNTureL+X/mE2rzbHS2pirZmlFqaplkEL1IEIiXoCwLgXogSdGp2JoDNiXgpa5oD5BSmRbuIhpsH4DtA0YE3Z7bB1QyPH7A8bM4O74Twz/h7PhsrjsZggjS+SA9ZSmf0JEaKplINkymz9Fg2GZZWK/f3DHK6y2gLokC2wFgO4DnheZTtQN4eh8wwbyWxmmpmfIgbaTSBhNCiiAJx7O589lM1gfSb/PVj/nisV4sPy2IrRtVd+wRe48PoscUPaboMR23x1R3aDnxfn69CLBuLTNffHzplnDvldH5UIvxesLBcJ5clk9gPNuWnCqbsris4pbJyShVORybLxWQ78VOZZr3OGEVO0sECzwIyZ10wilGSRMTIMkaSpN0U0koHS4RRZVa7d6/Vfee1Ru470FiN2H8jkX3e3YOWqRokaJFOnKLtENByP3t/nq2yCfXfJFPiHEbpsVC+0oM0wETSdEuRbt0MFwP188P7dJvYpcW/PRWMIBAQWnubVZwBChhwRoRY6PtJoLw4TJcimVpbXV/bRjvQ2aHlvK1Wx9ZGLIwZGEjZ2H2UBbWSOzNqvnL+QJp2NiVOdKwUWpxpGFIwyYL7hPTsGwzsXxaS5BJMg+ScyeIIYwLw72XU0kbHJCGidb3q6D8awN5L0K7JWL0GCL25AWQiSETQyY2biZm9KFM7B2E68Vy9hkwMPaM9DoyslHqc2RkyMgmC+4TMzKiojWcBZJJmaWBBEmCc8Z76owOZioIH46R6ZKwOhsBlYG9X+HdMjR7DEPbeyFkasjUkKmNm6npg5na5vxq5Ib8bOxaHvnZKLU68jPkZ5MF94n5GaXWcwGMSSqTSYya4L0NPvAILFqMmHVGeHuK8aTqrw3iPYjspmjsKCr2xOpIwJCAIQEbOQFTBxOwJ7TmyPhXcZJQJXYqFn6PWIn3V/htjtLhOxdHFY4qHFX4yFX4wdXf957dVaZjU+KiOA5Q82QTsZqmCAq8FoIwDlmXa+OjnUyP4eGa/XUoiHsaQrXp8T5kVmwGD1o4IVV0HBIDF/IjZsExr5W3aSrN4CkfCOa/1YZQmk2Em5Tm78/OFnCWP8S+8mxDk2MSBPGE2eAkcEcksYRDsGIq/Gio9u31QS6Tmw8L9xkWS5cvhkGjQWcFIBn/dmT8yD4AT5kIyMeRjyMfHzcfN61c6ufXZ7PN4+3DX9xy9XatKC4uZqv8vR6/MjpeXh655mw0NOiUAjMywysLiltIWZ2HILWfiD5nZDCFrnerp8OgVJlq71V2xREsCihTLGWarkk+WI3gSWTIw5q9azIR2A8VU6qOMzUjq95/uUjzy2a9i6v5ZRbHxx8+539fz5ZXjY5qLtg8f3/tl2Ex89C6zt8KrWTymcXL6A13JqREWQpeZGvJhYlgc7isJdnOKrp5Yfu8usP3UDHhcEwcjjkiGPc8HFNKTzm1IRrpnfM+eB2D8Up4LpTUFBHcj8NrY9itNebXM+clpPzm+l7k9fPvN3S1OkT3IDEcR4jjCJ8X6E81jnDr+G2dhnUI90QHMDqA0QE8bgdwu5zqR7u/2eeNNGBTbvf16ejcvrSYVB2TMiSx6PKe04yQRLKNqz31NqQQJExE6bNvHsjtgqDKVHwPEitW/8ngrGchJG2osPlNKg2JNCWhjQJkbp19DzuVy81NWv+oNyuhm3AwNpH1EwYnnl9wQgvnleQmUeDUS0eiI8KYGBkRVkQ9EXAOGJzY2d/hqz+n4SFhkX9heffxz3B+VaHFcJywSrhWmqvIPATmovNWA0lOaRetZTx6NZX6hAFxbfYL6918vnpIkZY/LebXV/Uh+0hxFYNwHAQ4R0KgEByXQQbPhdM6P8g/MaDcmertLCO5PYY+/H129vHHLco+/gSr/FvXF3kJiJvV/3VxXh3Ae5EZBuowUDdmjJ82UMcE81oap6VmyoO0kUobTAgpgiR8Ko3ohgvUNaB5/ebjb/PVj/nisd5g29OCKJ64FpwMQQTpfMinL0vc+0gNlUwkGxCPnfHI1rfhazimYkQWRFHCZODBOZ0SzeRPZSSaEK2nVkUqjOVkKjxuOEzqh5T7F3d5dp0/y8/uMp7nC739dPXgml/D8u8gba9eL5L7FyAm82Ayz/PaAydN5mnfUql9ZBEzeDCDBzN4xp3B06ix4zJ4moc/ry7ON083748vj4dgHs+Q9ZuYxzOyPJ5K8iGwVhPTIcaKTUyHGCeyMR3i2eAa0yEwHWKi2MZ0iANsZkyHeG4ox3QITIeYdKgD0yEwHWJUeMR0CEyHGBkmMR0C0yFqxj+mQ4w9HYIS0Uc+xK7YKGZFYFYEZkWMPCuC9pEV8W65wqSIsWt9TIoYsY7HpAhMihgxPDEp4hmFHjApApMiJolrTIrApIiJYhuTIg6wmTEp4rmhHJMiMCli0gEPTIrApIhR4RGTIjApYmSYxKQITIqoGf+YFDH+pAjeV1LEg9Ao5kRgTgTmRIw8J4K3z4nYUPDt8fb7ZXMmvp9fLwL8Mg9uNV/czU4YW1aEKCVFMFAyCkMMJ8QwFoVL1KZIg/GUJjMZJmaGc37t9scfgKPKVH1/giu6wli2c4PJZymX3CedGZ/mCbyLTgkepjLaHlMkToRSkbXG2+XiUVLE+9X86srly6/faJkToQSVxihmnPPgFCOMKpCcae+VVJOJHVM+2OnL7d0MlsvVwoXVcncGS3UHbCfZlGDr8olpE7GapggKvBaCMA6UEG18tFOB7YBT4naGOLcXuafnPqK5UAwLd5TZrSNAdnMEdDBH0BWArgB0BYzbFdBl7Gu7aPxz8gFUkv/CFSbAjFebnzgBBlk/sn5k/cj6kfUfzPq5FVrJ5IE7Gb3hzoSUKEvBi2y3TyYZfDjWL9vZ5zcvbJ9XB+BDxXTgIIg2xgZyeuT0yOkny+l/v/wJVs12fwfLjVdvLZ6RcXpe4vRNTW2gmdJrzbn2xOf9R0KygksvnZpKNt9IOf0TAKpMcfcgMeT0yOmR048HjMjpRwHdjpy+Dx6084BGHoQ8CHnQuHlQ9zTnO3u+OeY2Z1L+7c0vvdp82dHRIVmiQ8pZ57UWBoRiLGV4USKz3GRmRULpNBX1PJzv0nZoytDcjg14lrfoqUxjHy2vYumeScBVIIJwJr2KInKVuX9k2ul8kLqJoFsOmJC3Pxe95SlZGc77ExxSf6T+SP3HA0ak/qOAbm/hfMtF1C6IaDj3liZNaT5Go2ZNYD/CVCr/Bgzn73Z3P9GI787hUhmCD5bTccn6rcwOdGihQwsdWuN2aCnR3qH1++X5l+3h9AeE6+YvtqpxZN4rWvJeiby/knE+eesJEYlbEFLmfUc8M0RNJfOODue+EjvdMXtBU5mmPlBKWz1tVDc1/dSCqJNRJ6NOHrlO7jBfaPPjAWMdnUIuhpM098wGkgRnzFNqnIx5q1HLWTTByqlUzAmGDsjTadaWg1bu7pFi/1IhlPBGUqqdE4SKGJzPzwQRlgJMxUjUQ423qg6THYb/fH3e0keelGHG66x4vcs/LfVCgNBShhBjUlMZ/jNgm7H7d6voB955t6oGd3dxFaORIWivedQxpeCD5UZTHYlWPBBrJzPZCqORpzIGxO5o5GFoJMKD0iJaFYGQwEgQiUMSVqmgOVcTQeNwcR2xc3RYmczUhuADRHTjJerYgnnnaugiQhcRuojG7SKSsquL6I7CG5lzqBitqWQI72DRmursweOn8K41q9aHaNbbdVCnok5FnTpynaq76tRnO6ggs1fqpWHOGeKIlESSSDjz1HjQPE4mXXHAHIjd0noSLZVp4a7iKebagl4bfzHbhImBC/kRs+CY18rbZCYC3sFSxKszCWk+6N+smrfni+/PzhZwlj/EHq+0NTQ5JkEQT5gNTgLPByexhEOwYiolj0P5AeuDHH3x3YeF+wyLZVMRUwYblcFZz0JI2lBh85tUGhJpSkKbzIcnArbhug2JnTbwU+6RyqDZTTg3dNgeQoexkT8SYiTEIxBWy6Z/bfIQv/b2bOAQFvkXlncf/wznVyPMSNTFjEThvJLcJAo882RHoiPCmBhZ0wlwMjkIlAzY4mJnULMteCpTyccJq8idKXHaEmqsTVmveJ/pjAHwBrzUVk2FOw+VapsP1p3n1f2RyveeVQfmAyRUQrB0GpjmjGqIgXnjeAopsmQ4yYrfRURw15N5ZwXxKxc+wcdmANf5nYe/+//M11q/UB2OD5ZTMb/Mm5TN1Gy4ukzsg9Yu0SCodoIJxuhUHPHDoVntPG32qc6mY9QPl59ni/nlBVRYm9iT1IoeVMG8lsZpqZnyIG2k0gYT8uENkvCpIF0PhvQGOK/ffPxtvvoxXzz+8EeAqyoNjKcFUbQjLDgZggjS+SA9ZSlbw5EaKplINiAeO+ORrW/DV0dJxYgsiKLYetC5ILNNSyyjVCbgOsboolWWhsjiVOYMDFX7kO/4Tl/ffe5xe28+vrn87M5n8d7b+QPltVawqBfNpxHiTSPtthnr7bwfGFbAsAKGFcYdVjCkh7DCI+4xsvhCMam9FtY/VHU50v5vTPu3rQRZT7r8wRVQqaNSR6U+JaW+Q3CvZ4t8nM0XX+5Ib2xKvZhTnwm7FBHAZa0ePBCR8r8miaC5JUpOpXM1Hy5nYI96agsiVOqHSK3YHUkCt8ActfkUgKCzGcuilEYRI2jgU0lQHQ7pmne9ZzfvfX2p3gzWnqVX9NBKQZRizGTMayGTVlwSKwkhzEmdpnLID9gPZGdU/fbe3TyoNBGso3QwtjBgpgHGFsYeWzjAIdHOOkKHBDok0CExboeEbtMhp4PgnpUvInjOHBBis9LXBHzeczZkkLFoeOZpU2lfK4ebonX0xqtNsx8vMPRAvBgO3+iBQA/EmJCPHohxIBs9EOiBmDTAT5vd2LZrYHu7CH0P6HtA38O4fQ/NsLajfA+PrcMf3doHOTo3RHGyk+SO5f8FHpzmVluprCLScGaTN9RORuMPV9Cgy+ZYNyhVpul7lR1StCGbLCBFG4aiVZLDNppydExh2+07Pn0KGzoj0BkxPuCfyhlRfaRwwBMfA4XDBwq36T6mB2/bkzY/Ot7Q8YaOt5E73kzvjrfxzs1ixQygOhIkBpubhRkSRzrfMEPi2Zq06H7r1f22MVab8/wExipOnENzFc3Vby6sk8aJ5+G6aYvxYeEul2m+uGgmymwOq/Eaq7w4ji6GKJv2+p4zwynxNNoUhLYEiAU5FSeUHq4ZY9tYZysoVabQe5VdyVD1hhBDQzOFMRlDmjCESJYwY3gCZtxEYD+cobrnzm2WyG89/QqivhfZlVAPWjsaHCMBtLBGMyJI8pGIqDQVHhD1HVEvWwjr3Xy+eqz+K4P44YLqIcLQQlsgZUPKhpRt3JSt8WMeTtkgbrb8vy/c1dUIp6IVi4oTtzY6o5QGDzEAZyH6IPIuNDbvv6l0LTXDdS2VphPTeISe2vT3keIqWaWVuCCGK6tED8Qz8EDgMLW+T3QcptbuKD/FMDX0p6E/bTQI79mftiknlse6Hx7YROhxQI8DehzG7XEwokePw10nwNicD8WR7NHovBG5poo7LphJKUuOSIgxsRDSVHT7kN3V7TFs+h6QKlPtPUqumMfIOQOIxHvLAifZiOXSSUhWMi2cFROB/FDF87/VBtOM0rWQG69AGWkWMqCEVNFxSAxcyI+YBce8Vt4mg0hDpJWQRrN1+mbVvD1ffH92toCz/CHKkONWaCWTB+5k9IY7E1KiLAUvsqHtpuJvHdDz1M6gvnlh+7w63X2omNCLil7U8YH5FF5Uy0XULohoOPeWJk2pTilq1pzREaYS5v3WaH4q7ahej+nBciqhuZKkhQHRjDkLw+YsbDMPVc+u/ztuCIwCYBQAowDjjgKog8aZPKIxI3P5F6vCKnERqOGqwtBH8M18BJX04xgwNwXbcTyPdhyVMLDhMmuRgX0LBmYOHuXwQE8g20K2hWxr3GyrW2OOHx5mbhZzOZ8TBasko1qMpiymG5Qq0+SDtSioxGTFoMFIgX7KQkcM72J497mFdw9tvtFFIyAtQ1qGtGzktKxTe+8Wu3/M5TDFyXqWChK4V5bnbWmIENwTRgVvdqezcjLhBDOWeEJXMFWm3HuWHhYrvKBDWbBYrbC/WoFZQ5NjEgTJ56wNTgJ3RBJLOAQr0kQwxxFyJ4Jc5j4fFu5zPub2V2PV4nRFn+szQO5gPlf0S6Ff6nn6pbpP8uhmDqNnCj1T6JkauWeKdvFMvc0aoRHC28U8wHI5X3x86Zbw6NXRuaSKuQIxCm9lSsJIYEQEybSlMv9fICFJO5WJygNOnFOquP1ao6gyhd6X2ErWquFKkMzKrAKplDNUNe1jfYj5RSrCVHqzjGZgzeOb9uiVei3YXmVX5GiUOG0JNdambGp5TzwxAN6Al9qqqbheh+NoYqfivj/v/d6z6rB9gIRu8wV4V17WUjUgIUNChoRs5ISsU9fMxxv/p9nq07VvXl8+Y07GQCWSrVLBnKJKicTyv1lknkvLnPMTUdhUDsfJyr0fuwCpMk3eo+SQmQ3WyxCZGTKz8aAemdl4sH0MM+vczKi9dkByhuQMydnIyVmn8tpuWnJk9IyW6FkltuqAITM0VkdjrB5atNXlOqjsUdmjsh+3speki7K/eTA+RV7U5JXw7+FytpF/n4R/F3peRGWE8FwFDiYJ4yU3GbheguZEeTYRBLPhXEh85w3acdJVBtzWcinO69ZcReYhMBedtxpIckq7aC3j0avJwHUwtO7uOfJUGvzXyy1/Wsyvr6oD8bHiKmGbCA9Ki2hVBEICI0EkDklYpYLmXCG2uxoTOzNC355fn80utz9++Jz/5PVsedUYvRUeyoeICOd74XyvseH4FL27qSUOiAzWhOiEzMZx0CRGYrVNMhA8jztjuexp/PD32dnHX93ssnnww+Xn2WJ+2fQ5qw/Mh8qpeDITQRwxOhKhlJFKasMViV56nsAogmju92S+rYPetpz40YX875f6wHygmIosMElhEqNSMkWoU0kHIMIpTyh1yePkxc5Y1k9PFHz/yS0gvppfXC1guYT4ett+snFsVzp/8ThpFWeKWnAyBBGk80H6bDlz7yM1VDKRbJhKO4ThIsMsC+v1mzsBmR/+CHC18YtWBtuSKIpdkATzWhqnpWbKg7SRShtMCCmCJBwx2RmTZH0jfpuvfswXjxUj8klBlPAYnQuSeUMso02XJK5jjC5aZWmILE6m4nwwPJqdJtr9kNLtvfn45vKzO5/Fe2/nD5TXyiZcvVg+jRC3+TSadU2nuXmAqTKYKoOpMiNPlemUF3vz4Gc4vxphwowoNouRgijFmNHUaSGTVlwSKwkhzEmdphK+FWS4GFfZV/gQLJUp5Y7SwegsRmdHBd+eo7OVpCtiueCIINxvumIl3H84BCP3Hz3371xKc9+sQQ8AegDQAzBuD4CSh3gAHsXMR+YKoMUmRZUkpPDhZhlhRso3y0jBvFfMex0hlg/Ke8UaG6yxmWqNTTQ62/pcU8UdF8yklI0zIiHGxEJIUxmyNBy297T32zOzuubZiT1KDn2+6PMdEbJ79vmGRKAZ/QnaSu0yRaRCWqGcDiqmoDHy1tke2Z2//PT9ufVOvnRn1aH5SGlhHcO3RzbWMXRBdh91DJUk+gxodWCezzB5PpI7lv8XeHCa22xyKKuINJzZ5A2dzDyz4ZC7p7/gjijQzXtfX6rVVd2r7IqodxqY5oxqiIF543gKKbJkOBHcOrREOlsiO+/cRrf+Mg/u/M7D3/1/5mtVaoMcKqcSmsHywFTkynvqiJFS+sCY0vk5C1pyRPPxaL5czs/zdRbzs8ZAfOkWdx/Xel4fLKcSmrUBpqzUNinBuIpr1x2JmlhBBSfos+6KZpqv8uv8cn4+P8sHy9lZhQbzLhFg3uULjnmXzwnFJ827NPrQvMsHmSOYgIkJmJiAOe4EzIZoz28Omr0JmOsOXJsv8vH7GJvL5y+2mF/8Amk1ujRMVsrCTB6s5Up70DSmSKOTMXmXvFGe2jCV4BodTrPL8hz6PdipTIMfJ6xi90bjM/W3xAfHolEhKZIPRyasDBw4nUzXmuF68+/RJnfv1avr5Wp+sXlS72Sd4wW2NUVt55HmxY2DBikapGiQjtwg7VQR1OIoGZlRWhyrU4nuHnAoCerub6a7O7uR9q6N+hv1N+rvketv3Yf+vpflPzINXmz0pbPu9poKa8FLFkgKwJRn3lEaeHJTiVnKATX4Tml1Q1BtOrwHkRVLa0A3dQkqOg6JgQv5EbPgmNfK2zSV0prBXEy/1QZQmpXETbDw+7OzBZzlD7GnGbc1NDkmQRBPmA1OAndEEks4BCvSRDAnEXInghx98d2HhfucjzmXL4Y+9Aw2hTR8rHDtj4bbvmj4HfMAiTgScSTi4ybiShxKxH+c/fF+tXg/+6/xec+LKR2SGCcd1wrAEWutSZl6OxmMECH6yTTWGjClQ5RbNTwFmsp09YFSQgMUkzhGjOreLFCjjrFAv+4YNDrR6ESjc+RGJz/U6Hy7gLNfmw/xvGxOzpJJwVPKXOJMMsuDlzxxYNJBVuJTUdQD2pw7u+Dtw0xlyvkwIaHFiRbniEHdn8Upj7E4bzcMGpxocKLBOW6D8/D6tbzNr9wC3s+vFwE2knlOhmeMiTBjCBgbGJVJBcWcMdQ5aZQKUylMH2f92g7sVKarjxMWGqJoiI4Y3COpX3u0cdAgRYMUDdJxG6SHe0D/5XqeJQAr97wM0QSGKs65YdQRCpJ4anjk3mnlgkhT6aA4Tg/oHcxUpqMPExIanmh4jhjUI/GA3m4YNDjR4ESDc9wGpyaHGpzv4GL+uSGW8HLh/gbL52V3MipFMlLRrKijJEEoQbgDrhRISQydiroe0AG687a2hE5lmvooWaEVilboiLHdn/uTHWOFPtw3aIyiMYrG6LiNUaUONUbfrxYfvlzBh/m/Ls5HZ4jmVwqWqOUgwDkSAoXguAwyeC5cBlfW2WIyM9CHM0QbH/pe2Gw158efYPX6wajYNYRqU9p9yKw4szFYnohp2iZLkzRxHJhRNuQTwHlKp4LyAXvT7R4B1OJ0rAzaB8sJeRbyrBHjug+ehZNIhwvL4iTSUjy2v0mkOPerZ+Ti3K/Oc79Aa0ezaUACaGGNZkSQ5CMRUWkqPCAGuxq7LYT1bj5fPab5lSH1cEEV2+cJ5rU0TkvNlAdpI5U2mBBSBEn4ZMzdwfDcYOX1m4+/zVc/5ovHemfRPS2IEh6bMeNOp0RdDMpQaUK0nloVqTCWk6lYp8PhUT8syPjFXZ5d58/ys7uM5002+aerB9f8OiHwHaTt1evFcf8CLM4dt+BkCCJI54P0lCXufaR5JzCRbMDzuPN5zNbH0NegS71ILokCZ90OiEmcddsDmk8769Yck6Fw19uM2QmYnYDZCSPPTrCHZid8yBL8MH81j/DyfB6eWasACUaxaB1PUVKmlFDGq0CFU55GIbAvandnlmgduXmEnMrU9zGiwvgtxm9HDO3+8mTpMVbog22DhigaomiIjtwQPXhI3maz/5zxkU+q52WGEqAhisgMowa88SCMtsEqHbWxkmGjgJ5iqm1wU5mmPlxQaIKiCTpiYPfXMOCoMVH3Ng0aoGiAogE6bgNUH+AJvSke2R4k26d3jpKRGaO0ZIwaKYUGEoLizAZJGRBprRFMUaqBTSXHlJrhdHcbR99eDNWmv3sR2laHU3KgH2nPBVCho0JHhT5uhW4O6IO+e9vfmwI/MpUuiv6lyJUGa6wIVpnENItZbNyAFp4Tpiei0tWAddhtmny3QFFtSr0nsZV8Tzaj2gmpouOQGLiQHzELjnmtvE1mImCnciCw/1YbSGm2Fd6smrfni+/PzhZwlj/EnhoSa2hyTIIgnmTW5CRwRySxhEOwIk0EcwohdyLIZRvlw8J9hsXS5YuVwVYJQR8KbMjPx8DPDxwHsddWQIaODB0Z+rgZuj4g5+Nm479euL+/3jZsWv/9r3B5PTp2jl3SBq0uwi5pB+jzU3dJi9YSC5YaG4w2TFqvMzMSKXktok1TcUIN2CVNtcnd2XNQ1obyHkSG3GzQxCckZ9+OnBVsFkqctiSf5jZl4uA98cQArBtSaaum4mUd7jAXO03R+8W8955VB+oDJFTspSacV5KbRIFTLx2JjghjYmREWBEnY48MhuA9g29fNjQ+LPIvLO8+rrQp4HHCKuGaW6GVTB64k9Eb7kxIibIUvKA8TIZNDojrdo6cmxe2z+tD9IFiKvYC4o7l/zUtsTS32kplFZEm29bJG2qn0ndlOCzrci/SHU7Jm/e+vvSjC6v54kt1AO9VdtiREDsSPpeOhNiRDTuynQyR2JFtHJjEjmxj78hmDyxELLqzMT8C8yMwP2Lc+RHmgDnGuzb9Tah2I6KRpUiYck0i0Ez5haMKeOZEMaUUFIMgdCJGTMZXO2DsuM2U3v0gqky/9yQ1jCBjBHnsSD99BLmOrLcBj3TMeusO81NnvVkuonZBRMO5tzTpfIqnFDVr4nIRpuI7GzAat9MLf/8iX4cA1XuAHywnjExgZOK5RCZwVlLf8WGclXQcjnFW0rPGP0bmMDI3NkxiZG7skTlKWH+hubuuQozOYXQOo3Pjjs7pI/qLNTL7CVavNt9vObqgHC8F5YKkSinDGNESQPskhaYyuAwkAxlgE1H0Awbl9hQF7MFOZRr9OGFhCA5DcCMH+OlDcCHlY9oJCdpK7RSJVEgrlNNBxRS0mgjQBzzAdccSxVtS8dJVOHvkOGndpEUe2TrqgWpAyoWUCynXyCnXETMa8vvNH8LbrCHuVNaOjnqpEvXymqmQkpMGonQZTokGCOtCdqrA8Kko7gGTZ7oYW09iqDIF3o/QkIohFZsS0A+iYtiNBLuRjNaXht1IRoRr7EbSCtHYjWT8WMZuJM+gGwnm82A+z/jgf+J8niPHBT7BddG3jL5l9C1P2bd8WyC2PWLOYF0h9px8yyYwSoL0QVgqnMyPs81LlWb5GQ1uMr7lkc4XehJDlSn4foSGvmX0LU8J6OhbHoPfAn3Lo/AtY/UbVr+dCrVY/TYSTKK3bMTeMuwUMdzZjJ0i9neK6Mt7u5NNovcWvbfovR2599b04r29195rZM5bWizKTNza6IxSGjzEAJyF2LhyQRmbdyHq3c5c37Tbew+Q8+8Ld1Ul2z9SXEVuZXTWL1xTxR0XzKSUDwQiIcbEsmE5FYctH85fa4+5WXcPq9pg3qPkMHtyyNMcsydbneInyJ6spd/vgHFlbPjb/eA+dcNfjCpjVHkMOD95VDlKQZRizGjqtJBJKy6JlYQQ5qROU+m9OlxUWZQzum8eVBpG7igdnF2Ps+vHhN6eZ9cbYMpmsCYlGFdxDV0SNbGCCk6mYmQMh2Car/Lr/HJ+Pj/7mJc4q/CA3SWCEgZB6yYfmJEAWlijGREk+UhEVJoKD4jBrr6JFsL6OrGhYufb4YLCbDLMJsNssooxidlkmE2G+wCzyXDu0LjwiHOHjsTxKeYObbMpSW/ZlHeCKJhMicmUmEw58mRKcXgyZXMavj2/Pps1OY3r7zi6REpRyqNUzjqvtTAgFGNNn3RKZBaX9IwIpdNENPyQwy3KKVP74VOZRj9aXpilgFkKI8f46bMUiPCgtIiZmwEhgZEgEockrFJBc44jLjrHeneWc2/Onu2PHz7nP3k9W141ZkiFkbRDRIQz5HGG/OiAfMQM+c1oFnWc6+CxVYNuA3QboNtg3G4Dww93G7xdzC4fxe2/X/4yW47PfyBL/gPGm1oHHbkQTPBkfIg8hLwNteZCUjoVnT2c0lblysIOOKpMi/cnOPQooEdh7GA/uUehljq24XCOZWzdYX7qMjbM7sXs3ill92ImJWZSjg/rJ55iIY9zvxW4APrh0A+Hfrhx++EU6eyH+9XNLn/4I3+l5fogGZnDTZccbtKSZLwRigodGBNZKppIIY1WiWQwTUTBSzNcpHfnbS0CpjL1fYCEijZqZM54T2QyxGkTrQ8GjNPaUgY6TsaFNlSHnN9qw2OjG9aguwXcx+/9crVwYdUSglQJEzVnhirwQUiZVPA+KUW1DM5NhSYJghA8EQT5IwjePmrpYK2k6d2AridsetfK8XSKpnfYagZbzYzBKD241UwljtPhwrroOB2x47RgGRtDNPU2eGapo8oLMCYoy0hUWghMwu1slTw8px5WrD54XnO76aNktQ0HNOA8IBpwz3+Bbn90+6Pbf+Ruf3WQ27958MPl59liftkkiozO+V+s1qWWOCAyWBOiEzIJEzSJkVhtkwxkKlVedDjn/+7SjxawqU0zHyon9Bqg12BEOO7Za1BJNPZbIxiDsacLxtbh98KEwWcF8pMmDDbf4kAPwQPzBv0E6CdAP8G4/QRiT3rg5kfz/nwxOm9AeQgqTYY6KjVLEmiQkVKVJLPcMkYTdXwiulsN5w5gD+/rfXRUpoX3SAOp/TcnRkjtT0btsaNW3wjGjlpDd9SKUlPLJIPoRYJAvARlWQjUA0mKTqV/93AY5jt7TGwv8nYx/8+8+uZZddjtIppiAgqNVCTimIs2KnDcJBk0lVRxENpMxSH1DSuyCy3TNz8qHb14uKBKeE5RGSE8V4GDScJ4yU02gPNRrDlRHs/gzmdw2QF+86A6+LaWSwmtSnMVmYeQj1/nrc52glM6H8WW8ejVVNA6XBqsLKnF7UV2tXlY/rSYX19VB+JjxYXTRHGa6JB47TpNtJIJX8Odrzjh66gJX5VMAx0QjzgN9NhpoJVMneODYRKnzh2J5FNMnas+JQtLEZ/VHvgG03Cj0U2dg01SpWgDZdFzo6QVgmuvpsLXhtMDnL747kNeId+Z0OShXH4/+/jqfJZ/qV5Yt5LJNnFQtSgtvJsigemBmB6I6YEjTw/U7dMDf3Qh//tldFmCxQkdVDqTJPFEOqYiF1oJ4zRNFKIwEcREtKgczpzkD6W1EyO16dFWQikG/uvIZh3QFYXJrP0ks1biJB2OiKCT9GgnaSWBpAExiYGkYwJJmPCPCf/PIeF/48ix3Rw5W/sV/Tnoz0F/zrj9Oc0UyJI/Z09HuTu9m5+Tk4cQqyQ3xFLmXAiEORaAqqaHI/fOTcUaFANmzT+cPNceOJWp4SMkhe3Rh8xExvboreB8gvbomvjgNRXWZjbEAkkBMmln3lEaeHJTiWQPdzqrncJ6MN9tbZ/cDL9dP6m5t24fIivWS0euNFhjRch0PzHNYjbWuAEtPCdMI8a7YnxnMXCrEc9V47wnseHUYJwaPD50HzM1eO36smS/66utAY/+MPSHoT9s3P4wvaf9WZcJCyPziJVbpdcxx0QM19gUB5l0UNPHDTIphFmzwemEVNFxSAxcyI+YBce8Vt6mqYRZ6VBx/+oGV9JsCrxZbcKa35+dLeAsf4g9qSbW0OSYBEE8YTY4CdwRSSzhEKyYSpPzoTyx9UGuKbFYuM/5mHP5YnvcSHVEsoaaDY2BrIECWRty3aJAqL0lgPQa6TXS65HTa9aNXj8uFH/pltsDanQEm7ISw1bBE82BpGCJpFpoqligxBEuHQPtJ6KpmRowRK879xm4C5/a9PVx0ipZoU4z7/Mp6QOniRpHKVBOmso5Q7yScSrYHs57tDv8/OAiLnyCzb8NUdi8Wq892ofIin12EiFJQP49rZUKMSUntSaZZ1FvqZpKwd2AlaHi4Ym04yK1o/ogGRWD8SCD8WCNjjQb/4QxpZPhKttvykY2mbOaDGeGtGjCufPg+bBwswozBo8UF/aCeqEHwzb2gnqWvaCwJ2DP+wB7Ah65B4btCUio8jxKIikJHJqAnDWCcp51AJNeYAb50TbO/tt3xx9XHdqPFVex0sdbY13SnGvTPA5ORO0DFSLRlH8Xsd0V27bzzfoVVp/msVZwHyuvIrqz1Z7RraJLIjHOUnCJOw1aCGZDwjlynT2JtPPdertoAhurL5XiuweJFREeLIkhZOOEcSGECdxqSTTRIJRxWN02BMIzuVqu3OUKEX6oxIozvGRILHpFJWTKyZ1iEZIOUnANMdsriPCuFkqr+/Xpavv0PaxWee1ldbg+WE7FHOKUYrZISDZEgkqOeB2ds4GSjGfC2FRyiAc8r48iRxWnyfcnuJsEPNE9Aa+UJYApeJiChyl4407Bs/zYFLwHwbn8C5s3xtrvmxZ7QXFplWDK06hdjEpSb4knWimdtPJuKnl5ZsBYyQFqah+kKtP0pxBhMV5oMlMTgXifPGNEEiCCRCW0BMiHCfqUO9u4LdJ2diY5/PvCXeU1awV+b3IrpqsqnoxWAoKVmdsJvRlvS5gjoAyfTArUcCe+6HxcfQ3p3jycL7b3sDrQ9y0+bDyNjadHBO+DGk8Xxks4DUxzRjXEwLxxPIUUWTKcZJLo8PQ+2ru8uT9rLfvLPLjzOw9/9/+Zr7V+oTocHyynYq/LRBII0Ik1JngkYDkwz43VjARHptK3dTg0082EkMbj42aXFVoTjwWA0Y21uwyjG6PGbZ/RjeozQ+mAHTMwNXQsqaGVTF4b7jDHyWs4eW10mMTJa8dMXqukRHA4woUlgs+yRBDTkDEN+VszvtOmIWsTaVRKAU2cEG09VVRHEhz3+bCfTBHsgAjvXsP5+sulu5iFquul+hIbFgViUeBoQY5Fgc8J3VgU+E2KAtdJ95l19pF1vyffD1PxMRUfU/HHnYqvj0/FvxsZGFnaPePYDvcFtQP2ocN2uF0M1tO1w60kxpzPNgwyjxTcJwwyV9Lsebgei9jruTsbO3GvZ8tF1C6IaDj3liZNqU4pasadCRGmErQeMktoZ/Lsg6KG20ms9SL7YDlh6/LMvAaDM7Yub1H3ga3LDzuVh8slwtblx5nVHcWFhXlYmDciOPdcmFdJ27cB51th27fDbOY+2r5V0iRgODRjk4CjQD5ok4A6igKHwz4WBR7q6BukKJDSSEUijrloowLHTbZlNJVUcRDaYE1AZ8vlobAKt23z42c4r/FUP1xQ2CIDW2SMD86naJFRyTArMZzbD6dZHWuMDzrNqpKybjpcqhTWdWNd9/hAiYXdWNi9F5ADzufGym6s7B7vRhh1tRRWdp90wJRjnGWzw0WVqMrmME3U0xScVFJpi00TOxPCY+9XxS7qXmVXQn02bYihgTlnkjGksXEy/SPMGJ6AGTzXj0b9/Uq1zRL5radfqTe5r1fZYWcD7GwwWqSftrMBC54AAzBBcEKZ18pYqQ1LQRlmNaK7q61+3N2q2I7pUXLYy2Pc7BR7eZxywLeLwRAtabCUWO2lEk65ZKX0fl01iQg/PTu9f78qPtV7ld3N2Nh+Gth8zdPCZjXYrAab1Yy7WY3ps1nN3UNlbG1rSKltjeQsSqZ9tJJ6bhJVUSQfQ3QhCGenkovEh5sWu3sH3r9IXvqsKab7WvhcsUY/XmCY+v+CDolwTP4/EOmDJP+D1o4Gx0gALazRjAiSj3QiotJU+Kk4mPlwDW0eJbUXe1hUDPDDBbUn+58paxIRQWrFfaQWsmliUqBBMD2VI5wPWIjbQlpfm8MhoA8QVNEmyQezE1JFxyExcCE/YhnTTbTE2zQVQNuB8Pxbbaik+sV3b1bN2/PF92dnCzjLHwK7cWA3jlGhFLtxjBvB2I2jpQ1wim4cWKF9apMWK7RbmrS9VGgT4UFpEfPRDIQERoJI2bgVVqmgOZ9KFsRwFE08rMjcXOT8+mx2uf3xw+f8J69ny6smIFIhkg8RUTmTxyrBlKdRuxiVpN5mK1krpVPmZW4qLfwHzHM4wN9ZngJTHcZPIcI9VbAJQgAJzAURvElJcCINTzpaTSjugY57oAkz772BXdLMKzVbTiZH7DuDfWdGh/aT9J0BywNTsekvTR0xUkofmpbTTb/poCXmcfaA5svl/ByajMOzBSyXL93i7uNajZiD5YRDiV58w97pOJKoCOoTjiSqpPXHcNjGzh/PsvNHJZ3ysFHes9kDwzbKq2Rs14CZfDi16wj+2UJOxdPcZeqpPBDlQOR/LSQSuebWBA8mTCUxdUD/es8lJLWhvHf5YdPTAdGPPU+x5+noMIktT/e3PF3XXFPSd9H114+N5ddYfo3l1+Muv26I9PzWiDqo/PpBg82R1V1TXqq7VsETzYGkYImkWmiqWKDEES4dAz2VXCNqhyoCyaJ+OJ53P4S+lu5Up6CPlFaxX5Bm3sO6NRBN1DhKgXKihHGGeCWnkjUxnNdKtRHWrjG99Tqw+hAZ9iTPSowOh3LsSn76vm9dupKHREgSkPeC1kqFmJKTWhPKPfWWqsnkCw3XOUM8VLo7LlL7yX2QjIppbyCD8WCNjjRzXNKkvCXTZMExZSObijlCv2GmUFvl+mHhZqvqEH2suLCuG+u6RwTnnuu6K8njVJjHOU44nzKPE6u8+8Y2Vnm3RDXO4X4WeMZ6qHZwPkU9VCVZ9nQ4RzWm2WOa/Yg3wnCOPsyzf1Z59thb7NR2DfYWa2fX9NFbrJKW58OhGRueHxqg7LHh+WZSj+klafReEBSzRTFbFLNFx50tanrOFr17tIwtb5SW8kYrmRQvyHBUDUfFH87ShhoVX8sIiAGjhDgC4sBISmtB4QgIHAFxKlQeMAKikkSLAZ1cmGgxlkQLdOCiA3c6DlxsRN43x8NG5EdTvYEbkVdSYDUc4cPyqpGVV2HzlZ4Rjs1XWjRfwQZVw+ERG1Qd26Cqksy0AS1hTEw70g4eNDGtkhTl4fCPGcojzlDeNoY7QY7P12+N2T6Y7YPZPiPP9qHHZvu8/nLpLmbhV1h9mscbMj62RB9SSvTRJtKolAKaOCE6W72K6kiC4z4r/8lYvtmkH84D1t1024mjyrR9X2LDVkMv+HBpbdhq6Bu0GvKGC6c0aGYpBWejhhTyKc4MD82IvYnA2Aw3BvuACoK7p0692O5PcNh+CNsPjQjYPbcfwhYtp04sxhYtu4F8mhYtlWR5YjutsaIax6Iei22J0ZDnhPjh+7Vwb411SXOuTfM4OBG1D1SIRFP+3YnsgwFtFnsUWaoO8kfLC3M+XmAzomcD92FzPkBrR4NjJIAW1mhGBEk+EhGVpsLj6X40I91xka/DbLHU9QBB3eZu8D5yN3aEjzBtA9M2MG1j3Gkb9ui0jT1ac2wJHMX8DaAROBFeRSek1FqBJ/k/k0XGophKoxY7VPpGdRX+mWLtSI6kvSjY4j5DVYuqFlXtuFWtFseq2nGnRiqcnfuC2uGyxXB2bieefLrZubW49s1w7k907o/IuY+zoftOkMTZ0J1TI088G7qSLGA24GhozAI+EOqDZAFXUr2Bg6JHhW0cFH0gr8RB0SNFNA6KfkZZBVipMXClBma2Y2b7qE5nHBQ93tMZq5DaohoHRT8LPOOg6HZwxkHRh2ekDwdnLDx6loVHlZRmsOE8JFib8axqMyrp2U2HC+1g025s2j0uQGLX7mO7duM0plOzP5zG1I799TGNyaYUrUskuBRUcsTrzAdtoCTjmTCGkZMBsjmeyEiuDN79CW5bTmJVH9UkWKeJxSNYPDIGYbVsr91r8cjdY2VsZSSsVEbCWcioYgAmZEVOm8nLxkptWFbzhlk9Eb2uBlTsx2WO16zZ+5PcnrAcU9YkIoLUivtILTjLTAo0CKanYsryAXMoDp4OXxnCDxdUkZuBFk5IFR2HxMCF/IhlTDeHubdpKoC2A+G5uiJ7mq3gN6vm7fni+7OzBZzlD4FpaMM6tzANbSxpaOi4RcftdBy3XFolmPI0ahejktRb4olWSqdsHbip9AkYDs2nmAFfGdBPIUKsRR138AJLUYcrRa2kf8ZwA5iwe8aIumfUkn+J6ZfPBe7Dpl9Wku02HP4x2e3oZLdKUoIHxCRmBB+TEVxJsRLWKj0rLJ+qVmk7dqD3PLav3xkz2jCjDTPaRp7RxvvMaLvjahpZQpso5bNV0oVtwK7I2IXtG3RhqyRiQe1wYz4xZjHqmAVmFGFG0VQzinCY4TdIOMZhhkcJ6tarIPv2KtwqBHQqoFMBnQrjdio0oc3jnApvF83fr77cKMqReROoxClLmYcNqLtxylIXBX66KUs4haZvDwNOoensWzjxFBouE1iXVHTZimKcpeASdzrTMMFsSGoiGM+aaTiUt6pSKJoAtYH8eInh4BkcPDMuUOPgmQOPahw8M1JE4+CZZ+QBxsEzew9oHDxzAIJx8MxI4YyDZ57R6YyDZ9qiGgfPPAs84+CZdnDGwTOHo3m47u5YzDHiYo7qC5/pcBEbrHx+VpXPlVSZDpcTjVWmOHdmVHjESnwcOzN27ofdC9txPxw7M0I049iZQ5M4eh87Y/pIrL+fKIIZ9ZhRjxn1486oNz1n1N89WsaWW09LufUuBkO0pMFmaWkvlXDKJSul9+uk5InodjFcqb4+NtGwYv3eq+xw/AyOnxkhxnH8zBGAxvEzJ0Iljp/59m4BTEYbTTIaOnDRgTsdBy6On+mb4+H4maOp3sDjZyopQh2O8GEJ6shKUCtJhBjulMdEiKMTIWpJG8as4eeE5uGzhitJmhzwbMakyWOSJivJYh+QEWIS+5F88ARJ7NvmmSfI8fn6jTHbB7N9MNtn5Nk+9thsn68HzM3D+eLfF+7qqqkCHlvCDykm/CiejFYCgpUpWqEZzxvSEOYIKMOnUpashquX0KKz5irCqTbF37P4imZvPiuiF0RRmcEfY3KOKeqtSSwYG9NEwD9UEXN1WRIiY+Pd3H2Gjy9htVZ0j4H49RF2o8JuVOOCb7/dqDBJApMkppMkQYQHpUXMUAZCAiNBJA5JWKWC5nwqAeIBz+OHHp3NRc6vz2aX2x8/fM5/8nq2vGp4XoW27yEiKqdkkkCZ0UYJIl20NHjtY+CZ7klnNLp1O5/IuyNF60SU9/PrRYCmjVK29dYvvVnBxdv5/Lw6HB8qpmLCTmIKVEouMZFIgOg80JhYCpnBOTmV0PFQDbWr42r5OrMmoT1fCPNmBs0Mw7wZzJsZGyYxbwbzZnAfYN5Mq7yZTd4ApX3kDRRiFZg6gKkDmDow7tQB2nzCA3MHNt8oCzPONq71JjMgP12u3M3X/frmm+XbxexzFtftS6NLLOClvAJvPIuBRQZeEJm0dzwlKnQMhMZsvk5EU9PhGkRTwttHxo/GWmXqf1jhFuPAhhFBA/MgvAYpwTmTmIqGU5HUZFJxh+snLW1BWI9u5c2jeofIHS0vnIs4ZFQNxyLuD6sdNhZxQ/sEOYr2HakrkBMiJ0ROOHJOyMhwnHCeRbSC+FxZYSNGoaKMQRAnnMyUUAbPkvM2pDQV43ZQVvjwvp4WbZWZDkOLF5khMsPRbgZkhsgMp4Xo45ghG5YZPtQWyA2RGyI3HDk3bBrpDsQNr/35LDxTYiiZUxZ0sorK4KSKQGXGnvPKJB/MVGzbQYlhhzHWx0KtMrNhUNkiJURKONqdgJQQKeG0EH0UJeR2UEp4X1UgH0Q+iHxw7Hzw8N5TnU6Hf5stZ352vmZ7z5IR8pC3gtPMeOOd5JpZSbNgmwmzUkDEBNIDGGGH1krHg60yu2Fg6SIrRFY42r2ArBBZ4bQQfVyg8LjKwWOVBfJC5IXICyvjhS3OhV/ncZZmY+xYXEwhbdqw5U0JRjHHHIXMBpllMVu5PGt/mIj6p8P1ADieuXQCW2WWw8DSPaXN0eGDoM2BNgfaHGO3OWhvNsevsPo0j1NrYsCVI8bk/WkcNZwYZhJR1CoILBppp9JuaEAftO0w1udwjFVmYgwjVPQ4o8d5tFsAPc7ocZ4Woo/LQ+K9sr+2SgJZH7I+ZH1jZ318ANb3vNsUCBKNsCRxy5TQmjtlg9NShCS1S2kyPuYBeZ85BUWpvj3BUGJF7ofcb7SbALkfcr9pIfo47icH4n7YjwDZH7K/58b++utV9+TJ8JwbEYhAEnNcqxiNckwEFgIzSmdV7xORUxnDOyT1O6KDWmuIVWYgDCJTJH1I+ka7A5D0IembFqKPI3399qJrqSOQ8SHjQ8Y3csbXzBw9KeP7/fL8y4+L+cWr68Uii+GmPO05sj80a9Gsna5Zq5iRKkUShaOMMstSdCFxLjSz1tCppDMPZ9ZS8tBmO/VhWtl2GF7ASAuRFo5qCxzXeUAMQAuLOwopIlJEpIgjp4j01BTx2XejM94yx5gxRthgmLM0OS9E0ElC4DAV03nIsGDvlh12oRtMqhgaRB/KaPcAhgaRA04L0ceFBofggNh2DpkfMr9nyPz6KwZ8u2gWWn2ZWhMYpoBEQ51jginHqY6gOU1eG02IRup3APU7omqtC8oqsxKGEiuSPyR/o90ESP6Q/E0L0WMqBmyvJpD9IftD9jd29icHYX/PuxlMUM7ZBJpaS4yLUYIFkUKSguedKvVElP6gg6gebtGTAa0yW2FAySILRBY42n2ALBBZ4LQQfRwL1IOxQGwKgzwQeeBz44H95X8Wzobn3BbGsqSUYYKBDyIaA+A0GCa9UkwHNxWL9pnkf3YAWWVmwkBSRfKH5G+0ewDJH5K/aSF6TPmfrbUEMj9kfsj8Rs78GvJ1YuaH7WGem/JH03ashsBJTVtvSdQhama9CFGRkDEekhI2hcRJShNB93CmbT54+2fj2CDmfsB7eBEjPUR6OKpNcFyLGDUIPcQmMUgVkSo+Z6pIT08Vn32bmAREJZmFlrSxgZtsQTNCFQ1WGxOcmoj6HzJMeAL7DhvFDChXDBWiP2W0uwBDhcgFp4Xo40KFw3BBbBaDDBAZ4LNjgEofTAA3P36G8/zno2N0psToKI3ZFiWOuWijAsdNkkFTmfU3CG3kRJQ45Xw4I/WhuFoDpzJdfrigiqSLEqctocbalHWJ98QTA+ANeKmtmsqEywHN0p3nVFYcaXZ2vV3t3rPqgHyAhEoIdoono5WAYGWKVmjGszVkCHMElOEREdwRwVq0P2i213wHaXvNm4fzxb8v3FWN53Tf4ithXzoNTHNGNcTAvHE8hRRZMpxkQ9ch9jtbI3Tn2eTCJ/j4yzy48zsPf/f/ma+1fqE6kB8spxKatQGmbDY7khKbQzwbISRqYgUVnDhEc0c0N0G6X+eX80zO8q04O6vwNN4lghIGCVWeR0kkJYGDNTRZIzIfiiwy6cVUMGiGO1E79KG8ueZXH0B1eD1WXMUQBA/O6ZSoi0EZKk2I1lOrIhXG8skE2MRwlrLqfLN++CPA1V1LLz+8fa06tPcvwBL+o3NBZiuZWEapTMB1jNFFqywN+XyfivdODoZ/s9Nbfp/Jf71fby4/u/NZvPd2/kB5rRUs6t0DpxHiNohn7FExvLt+RAzKYVAOg3LjDsqZw4Ny7+fXiwANYV/NFx+/X365DPdeGl2grph6KT0oR5xKwSUWgiVMJ+/zS1pypsRksm3IcLZuh/DTfixVpuP7FV5xqjvYbM0GQVmCyJqIHo9C+UBIssb4qQB/uCTKR8JqfeteXS9X84t7r9WbiXYqMWJ0BKMjowP7EdGRTeolOY627VMhSOWQyiGVGzeVs31RubL+HBmpoyVSV4ltO2A9HRq3IzduN+YA7dMcKF0SDQM0DNAwqMQwuJHRhpjEcXt7ZXEorwiCeR+dEZColVwqIWMyJlinIp9Mr6rhMhsO12hlVKFh0IsYS14v05wYwFQIyhPPadZKihgIIXrrBZlKlsNgVvJvtYFW5iP93dx9ho8vYbVWgLfZ6fcx+uHLFXzsgEysNcJao+dda5TtskCZ0Ublg9RFS4PXPgauBEhn9FQyKAeMKOxOflq7x++dLOuX3mQD/u18fl4djA8VE2ZDvhjQmYbZkCPPhuzXkVYy0dGRho40dKSN25FGyeGD7p44Cd5/WWbRPIPkSVHsW2ljACZs5EkqbmV0xGpCBVHZ/GWMTsQyYGo406DDILbO0KrNQjilLEsGM4CWIZHkk9amMZG1ymeMzqayp1wlO5VtMVROcXWONcW7ONa+98vVwoUVun4fIXSo7lTVIfRkrl9MxcVU3OeZisuOG5jY0QJBvwH6DdBvMG6/QdOio7Pb4NPV9unoXAGUlXwBwXLvgksEZCRcGaUSIXkPcssdC5pMRHGLAYO2vA1/vYOXyjR2Z/kUA7bEKskNsZQ5FwJhGbRAlWeWZly7qXD2AVPG5b7b8+B5vVnhR0iqmEWTUrT5QM6HclDZGPI6ZiAHSqTghDHMoumKaHVUy627SrsygPcnuBLekwyJRa+oBKsid4pFSDpktGuIJkylI983dB2UFex7WK3y2svq4H2wnEpo5lZoJZMH7mT0hjsTUqIsBS8yn3VhImgeLlN9d2rUI95688L2eX1gPlBMxX69xAevqbAWvGSBpAAsm9beURp4cngyd7ZEdgrr9iZ9+PvsbDtWaVvFt3myrNkG6UFkxcCFBSdDEEE6H6TPJzX3PlJDJRPJhqkQyOHmvbAsrNdv7vgR6811LIkCM3cHxCRm7o44c7dU9sm8lsZpqbPdAdJGKm0wIaQIknA8mzufzWR9IP02X/2YLx7rxfLTgig6myNXGqyxIlhlEtMsUh+4AS08J0xPBI8D2sMP24PvMu62+Lkx77ZPq7aJexJbMRlSa0eDYyRkdFujGREk+UhEVJkRekCsd/VjtBDWu/l8Vb3X+XBB4WyMAavhcDbGkTg/xWyMzUwAcmBG262rG7PUMEsNs9TGnaXWGIGHZ6l9DWaNLVuNFCvX6ogVUzJc33+MFn/DaHFI+UR0QoK2UjtFsjUqrVBOBxVT0GoieB6QZT0sHtzXD+bWJ/nSndWH6eOkhQVBWBA0PkyfYnJxJRE5ixG55wT14SNy1jAiaD7PQXgNUoJzJjEVDaciqcl40QacnmwLwtoQz3zD4uxGFW8eVZxzf6y8MBdowNlamAt0dC5QJTkQA2IScyCOyYHAnGDMCf7WyD11TjDm+WCezyhwPkCej6WCBO6V5VEmQ4TgnjAqeBPadFZOphfgcHkRD6uC79+0zRL5radfqRnyPUvvJiPCHJsRcRPOwcwIzIzAzIhxZ0ZQQg9IjTi/PptthLp9+NItIb/zfnXtff6l+083vzO67AleSp6ICihTLDkOmmTEGcGTyLRtHYFWk2n1M1QQo77mkflC779cpPlls97F1fwyi+PjD5/zv69ny6tm8zYXbJ6/v/bLsJj51k1PAlWMeGay7gguBKWMSTzQIKN2DuJUsDnk6NdW6aWHnXqVAf+Uoiz6IYQVeQ9EozXn2hOfTSkSkhVceunUVKLOA/ohduYGbG/X+uD6alD9fvnTxuZ/B8tNB8+tpVQV9HuQ2G2jVX4gCTtkYyFPQ56GPG3sPO2Q+Sz7ToO1ZZpPwXETteJ8FiRqSNTGStQyGAmjDLT0QorAQSaej0XGspnqgEwmXjBcAUa7eTcHHnuVIf+ksiw2sRQuhsi0i9ZIzyMYDRasot5xH+NU2v4NR9XaTVa/y0O2V/798tUnCH97s7yr493lS2juWX0b4kRiRLcFui1GDPs+3RaHzoc5SMug3wL9Fui3GLvfQp/Ab5Ef5j+/vshfe47Oi9Frf3RePEPnhacQuYCoUgQqU+SBJBs5U6Cddg6dF51NU9uBXxx29lUG/9MLFN0Y6MZ4brsC3RgT2AvoxviWbgx7IjfG06oGfRnoy0Bfxth9GafIlc8P//VytkIvxtiVP3oxnqEXg3jjA7HUJx4Itz7vbkM0EElMovn/J4LNIVMweknw3n3qVQb8U4oSPRfouXh2+wE9F89/L6DnYop1I7uUDPos0GeBPoux+yzEKXwWy8Va08IS3RZj1/zotniGbouUzVEWvJLRk2SsSp5y6RLnlOqMzqlgc0i3xcNmuP0efJVh/8TSROcFOi+e3ZZA58Xz3wvovPiWzgt1KufFbj2D/gv0X6D/YuT+i/ukvif/xZa23bI29GKM3QRAL8Yz9GJoKhTRQRjJHOOiOQy98skSmYCS6CeCzSFLSB4eOac4/irbAYPIFD0a6NF4bhsDPRoT2Avo0fiGHo2G55zEo1HUNujXQL8G+jXG7dew5gRujWbIEboyxq770ZXxDF0ZxDErWT7/mEnaUEu9FzJBpDGATGIyHG3AhIyH06v6OvIqQ/3J5IguC3RZPLvNgC6L578X0GXxLZMwyIlcFo80DLop0E2BboqRuykO797ZRb0+Jy9FJaavQNv3mRkB38L2Zcy5EEw+dbnkPmmdkuYJvItOCR6mkuGBLrsTYVbwF9+9XS4eOener+ZXVy5ffv1GSx+dElQao5hxzoNTjDCqQHKmvVdSKTYRMFI+2MnM7V2P6uVq4cJqudujWt1x20k2Rf8BVdmMkERSEjhYQ5M1gnIeWWTSCzcR2IrBUNvEAfYrwvvX/Kr5qgPyseK68RzQ47pmtjdJ0HGAjgN0HIzbcXBMr8zNSbA9cb5P+ds1uz4faU84Bp6T98Bx400y1AgQCljQLBCTvDUuJUGcmYiyp2Y470GHJnpdkVWZJXBKUaIXAb0I6EUYDxjRizAK6PbmRbApResSCS4Flc1/r6NzNlAiBSeMTcWwGM6LoI6ixRVbEf0Jrqeult1MFfQuoHcBvQvj9i4052kfzoXfL7+P8c4p8GE+Yr+CKvkVtGesERtPXPnImTHUaB8EcUkGAVOpnWBDcaisLx/m1PUDqsqMgRNJsWQJi6yKknE+eesJEYlbEFJmFUU8M0RNJUFHD7YTxMNmj3ezS3+/PP+yXeoPCNfNn9fJ5A6UEvrF0C+GfrHxgBH9YqOALmbXjNUvhtk1A2fXoM8Xfb5jR3n/Pt/GB9WXz7fEJdHdi+5edPeO3N17QLOcWzlutnz+zadf+RnO8+rPy+HLBEsQAkhgLojgTUpZ6UvDk45WEzoV3U+Hc/i2aaRxCKwqswVOJseid0JzFZmHwFx03mogyammRtMyHv1kvBPDFWU+4i07LvJuPl89PCCXPy3m11fVgf5YcRVpHgcBzpEQKATHZZDBc+GymSFD/jmVgMaADUYenlD3La+mU8XHH7co+/gTrPJvXV/kJSBuVv/XxXl1AO9FZiWUg9aOBsdIAC2s0YwIknwkIipNhQdEedcTvIWwdh1J1UH7cEGV8Bx4cE6nRF0MylBpQrSeWhWpMJYTtEi64lm3qk64d80f/ghwtb7MO0jbq9++Vh3O+xdgCf/RuSCZN5nWUyoTcB1jzAa5sjREFrEtWmd+utNf9Gp+mWZn19vVvt6vN5ef3fks3ns7f6C81goW9e6B0wjx2OZp3dkwuq3RbY1u63G7rdcdEXr0W7/d+qQ/zH+Nt09u3m0I2A+Xn2eL+WVDu0bnzGZFZzYPVFmb96k0mfLFQExghKoAnEpJ7FRsheG6a1MijvPCdgNbZVbEwNItmdnSkmS8EYoKHRgT+TDSRApptEokn+FT2TqD7Ryx80C87+j61c0yDcqaZ1mjDX2AhG4MZEF7N5C7bCW0mtFqRqt57FbzAZ2Dup4PzZM7vzQ6a1kW5yRpKWNyXiROLGGEMw1aZfs563vrmk06CZUvhsv7tG08o0djrDIzYRihlmxjbwgxNDDnTDKGNF5okfKOMYYnYGYquf9suFJAvXPQRBf35Z1qo8r2Q6+yK5YNVuJNQWfKJPbFiJwpKRtQ0RmlNHiIeb+wEH0QmQYZmwkQ7px+sggf054HyUL/vnBXNabOHiuuchahiNoFEQ3n3tKkKdUpRc24MyECYrsztncP3Xoibaheu+dgOd1OUT+w/deR3AKdhegsRGfhuJ2FTa3Jwb7C+znLrxfu7+tj4Fd3NTp/oC35A2W2WBMn0WhLjDbSCMaysLSOPBAqJ1MGPlz0vFU5cyscVabr+xNcyZQ1UgoNJATFmQ2SMiDS2gx7lW1aYFPx69EBGx88pOCl6o5X18vV/OLmab2GbT9Cw8ovrPwaN8xPXfmFtbtYuzs+r1tPtbvYoglbNI0C5X22aCq2JfFaGqelZsqDtJFKG0wIKYIkHL3MXfHeYOf1m4+/zVc/5ovHeiu3nhYEVuFiFe7zwfGwVbjSgpMhiCCdD9JTlrj3keadwESyAc/jzucxWx9DX53t9SK5JAqsDMfK8OeF5tNWhhN5ZAz7aV85xqkxTo1x6nHHqRs90FOc+idYbXY+rD7N4/LlPGZyHmF0IWtdCll7lzIBAyFo/q/Zh5pbbjzQ5BKopKZiAgzIyx6On+kDUpWZACeRIQayMZA9ctyfPpCNIT4M8U01xFeJi3m4RuzoYkYXc834Rxfz0S7mSsLQA2ISw9DHhKErCXkMOKwFQx5jD3ncuHV7Cnk84WDB6AdGPzD6Me7oh97TB/fD9kvmx80vzbPwPrnVT1erj7/Olst8ouXfe3k+D39b3v7G6MIdxQo9arMxmjSkQHiGl0leKsU50SBAJjoVP++Aw9oeuSwPwlBl+r4foZXsXBEYD5n7By8UkOA0dzxRwazRQSfFJwL0YdPNPuQVsuUVmgPp8vvZx1fnM6iwT1BJFCVMUhqpSMSxzLeiAsdNkkFTSRUHoc1UuNeAsYeHwiq4Fzc/Kp2EebigsJHPgCVF2MinJZwPb+RTffQMCzSeDcwxevas8Y/RM4yejQ6TGD3D6NmI8IjRsxFHzwrncjQ6RCdskipFGyiLnhslrRBcezUVN/JwXmROn3Ip1QvrVjK5LWtrMc/pACczBnUxqItB3ZEHdfeUtD297d+tkXHzfv525yOcwGRK8VwbvVVUagqWZMUbDZMOGh1ssmJOYTJhrgF9sA9Lr7rCpzItfbS8MIqLUdznFMUFrR0NjpEAWmQgMiJI8pGIqDQVHhCTXU/cFsLaVRJVHWIPFxRyeeTyz4HLVx+dwtquZxSdqiQagLU0zwrN3yAaUEeUFmscn0mUtpJMLuyD8GxwfIpMrnXcy7YobezmkMOIF0a8MOI17oiXoYdGvG7eWb5fLa7D6nrx9XdGF/hSpcBXRhEDLWgA413ygmifpGEyCekUmMl4YQdsWPdQRx2IospUe19iwzAYhsEwDFYxJjEMhmGwKTkNMAx2gjAYurbQtTUuSA9bpIghNwy5jW8PnHhiDz/Gx1sgnejqRVcvunrH7eqlrEWEZ3OsnV+fzTaPtw9/ccvV/9/e+TU3ijN7+BvNYMDG3nM1yUxmU2fyTjbJ7rmZqi0BcsK7NrgAZzdbNd/9SGAcbAOWkMCJ+d3M+E/cLTXSI6kldd9mw8pyGaSscoefbBBgf1hlP7l/SZjVDhoVoAAovHsojCublkjzP6n5rNHUYWu98Xzm2TZrbmQ2o7bBLWi6M9eZF5gwW2OCA4Ebic/V+bw9XS7yt/n3QAQQAUScAyIErkiLIeIuSUEIEAKEODNC2AKEqHTvHQDjgiSUfXOfrl2X/dHuW1AD1AA1zocaAkuPVtS4jJarKKExsAFsABtnhw2nI2ywl+zn6yWregR2gB1gx/mxo6uFCnv5exikoAaoAWqcHTXsrqiRxNltGX7IAuAAOACO8wLH2OgIHPcvy3kUvmSOjpDVH/gAPoCPc8OHNe0IHzwvMZABZAAZ54YMU+DMd/msxpdnVpfiZPv3kB+Hv4/WsUe/RR4/6l26bw9GgBFgxBkwoqi1HCO2xr2gc/ZldmEmT33BTQs4AA6AA+DwPfxKU86FO5rk8whmNcABcAAczgAO7VYXJTjw9UV+N5b9df5Hl3mNwQgwAow4A0ZYasezcmRs7th/Dy+fqPfXdVKOKUjCC8o5AmKAGCDGGRBD8VDWjgvz05zVkNOBLUEqA5GCGqAGqHEG1LAEHBWi1PgefvL9Ei4eIgADwAAwzgkYs7Gc7yL/LzPRnHjY4AAGgIEzwIB4XKytPflpqR9X6zx+4I/PMfm7uCaWheC7oeF6QwfrQ7z50UdukMt1kkbL4pdJGRM2MAFMvG9M2NNae5X6wZsyneG4pkHozDEMezr3TMMwfWc8mZsO8bwpz4fATGd1b7rJSMR0jQg5qR0dMjZGtmW6BrHGNqH2bO6PDNexiOt5tkkL1M70oZZu9o1K+8mgLWgL2oK2oG1+ckd4gVuT8WJ/rQu+gq/gK/gKvuazWYHLnE2zWW7TrzTdnHdKAFlAFpAFZAHZHcgKXHltguwmRwnl0YYveEPyYvZTwBawBWwBW8BWM2zTnZ0wDt3f4wVgC9gCtoAtYLsDW4F7EYKwLfbCwFqwFqwFa8Ha/a0w4UvsR5O/A7AALAALwAKwO5NZ0UAANZNZfkMvP2Cf7N7/B2fBWXAWnAVn80uOphpnb+MgPJjSfkq+BQmAC+ACuAAugCsN3Kpb5Q03GLJ75TdkBeACuAAugAvg6gDurue2KdQPgAvgArgALoCbR1sTcN1KzHD5jYZsgkvTp8hPLiKfEdjHFTKwF+wFe8FerQdudyuP+7qALWAL2AK21YfAWsI2q82PT77Py8BqF0fLb3TevF+W/QaIBWKBWCCWV3Qmidh9gJzUimPfGk3IyJ1Z1CYMru7IGE9tx6UGNXz2qgCsQNz2esBeBf/cp/F98G/z9BVkBVlB1tObDmTtk6wtQ83kZL2N6eMNLwnACrACrAArwGpr8QkwsK5ITO/3E5sCsAAsAAvAArCKM9ff1hGzD00JwAqwAqwAK8C6BWvL8DE5WO/oMnrmU1Z6EZO/aHM8RPAVfAVfT2868LVPvraMaJDz9T6NH15W9CE6FpILbAVbwdbTmw5s7ZOtLVMu5mx9YPblCZl9erGIPPhcgVfgFXgFXl/xaqvj9VfWeoLwEXAFXAFXwBVwlZm77l+X3XvfdE+rMN4fJA4Ik7iD1zHwCrwCr0PFq9g1reL7N2K9sTGbODM68p3p2J7PuCHp1HJdYhkzd+IbmfXsHi65GVLWq+DvSc04MryRZZu+6Vke68vEGc+tKfEcb2Kwwco0iug5Alcw9EXPwWCFwQqD1ZsyHQYrDFYnN6PgYCUc/SKPDJ+93rzkmeW4sfjwxYeydLnI3+bfN4xV/M+C8BEjFUYqjFQYqTBSKVpPqOHV0/ekRrTIzCMua4ZTZzY1zLE/safOfE6njjX1xva0GKda7qesZTP1YYzCGIUx6g2ZDmMUxqh3MkaN+0rdjUEKgxQGqTdkOgxSGKTexyA1MmUHqQve07yY/UFSfv0rXaxofDg4ua9/gmNpGJcwLmFcYhW1RExXiY4TQ9VzKZ04E29iOhahjmHPxubYGDvjqTWxtjHEW0ZYeJ35hzRmhuEz/hJiAVfAFXAFXIcN19FMdIs6P0C1CQUWeSSN4h+fg5h67AX7yc4XG7aaH1bZrz4m5S/BVrD1nNg6qbXXtv2/KcPNyNQiruFPjDn1Hc9y/Jk59TzXMvyROyH0DZD1GDhO21FH/ow1vLk7s+bO3Jt6I38+d8zZ3DCJM3bmstPWSrJyS16nfN4axUAr0Aq0Aq1Aq/S5yiq03lFvHSfBM8XsFYgFYoFYIPYQscJxwysRex+EjwvK7QmwAqwAK8AKsErMXRsusO5y9lPyEnpALBALxAKxQKxs5PDquWv53X4kG3AVXAVXwdUhcnUqidXbOPov9dL83T4/99sP+cUCOAFOgPOtgZNPqGzRvNebnp9Xg1nTD7ITmJfRchmF+59ekUVCt2/3AUGza8R7v8FEC7wAL940L3qZaE3qb2KJAuSkdhwxszk2HY1n1syYeTaZEWc0MV1jNrEnoxHZcHcsep1IjrtM4gOzPn8IJAgTIBgIBoKBYCC4AsG2aNgBKQRny3/qX4dgL9gL9oK9YG8VeyVP0Iux9yFew+sA7AK7wC6wW4Vd2Suhh9jdvPoaR+sVCAvCgrAgLAj7StiJwE56wxnQA+DybCbsbZKSosqvX14nt3HwzKyJOS+IDCKDyCByFZEF5rw6iRwxC6bUB5PBZDAZTAaTq5jcIhGtApPX7iLwAGQAGUAGkAHkKiCrXV2VAvIfQRK4wSJL0AokA8lAMpAMJB8iWeCIhASSb2j6FPlwIQPFb4coQDFQ/C5QLHBZQwuK4TsGjAFjwBgwbrg5p3c/rxbGcBqDxCAxSAwS15HYEYgdoUzi7+Hi5SqOlpfrOGamKDzLoDKoDCqDyqDygbOiDypjDw8sBovBYrC4T8fxbRytaHxgE+ziAcaAMWAMGDfD2O4NxtjHA46BY+AYOO7NT9GAY+zkgcVgMVgMFtfu5Fm9sBh7eeDym7AXuAwuvwcuT/rhMnbzQGPQGDQGjRtpbArQWCh6Zm3qSVAWlAVlQdkhU1YkxW/DnPdLZoE8AkX++jJaLKhXP6kFX8FX8BV8FTHcPjFOari54Zmm6Uw8Z+4a5sjxbMNyXWvszcdkNHGKFJ+GbqACo8AoMAqMDgujI7V4PAVGN0HRQFKQFCQFSYdIUrMDkmKRD6aCqWDqUJk6EkhmfJypn19Csgy8/M4vpqjAKXAKnA4Sp2rx0Dc4LXMUE1QQFUQFUYdKVEM7UcFRcBQcBUeHxVE921DFTQCQFCQFSUHSIZJUzzbULkmxygdTwVQwdahMNQSCupSvSG0gehdF2McHQAFQAHTYAJ0JJEav4Gf+35FrpUAn0Al0Ap1nik7xuScz4Dx4XMekuJX/+m5DztEHr/zpQTsiv1gAKAD6vgE6tmrtdaz9n9R+zphOrenUcujEmzmjmW1avue4pjX15zYhk8K9ZwriYGvQW/JIuXFu48ijSRLFPy5IQg8+BSPACDDiLBghcsxv16APrG4/rtZh5qL68Tkmf7M/Wy9ZFTMr3NBwDT6AD+DDWfDBFF1SCPCBbo6tcdMBEUAEEHEeiBA4RdCECPY9ZdXPlhkX3ABezH6agBAgBAhxFoQYzVQJke7PIX6PFwAEAAFAnAcgBO5uNwHiW0T828X6MQiTy7yigAPgADicBRxMgayVTXC4jYPDGDmfkm9BAkqAEqDEmVBC2QuR7uxjcG8EFhkgBAhxLoQYSR+H2CUEtyWjxGaBAf8kyAAyDJsMWW1+fPJ9XgZWuzhafqNzrCpABpDhPMhgtHRM5mS4Cv65T+P74F8KJAAJQMJZIEFtsnAb0xWJ6X20jj2Kg1AgA8hwNmQwWm5U5GT4bR0xy9CUgAggAohwFkQYtTw9nRPhji6jZz5JoBcx+YvC4wgwAAznAQaRjJT1YLhP44eXFX2IsEEJKAAK5wIFkcC29VB4YJZ9iC4jn14sIg9+BXABXDgPLogkDjjGhV9ZvYPwEVQAFUCF86CCkrfxNqaPN7wkIAKIACKcBRFMSzR0ZnZVKnu9eVmEeNrEgPo1XS7yt/n3gAQgAUicByREPY+HkPhGkpTT4TJaLoOUzyIOPgEoAAqA4hxAMRFwRub/8eAtPCbkfqciv4zQySU6OTe6AJzLRr8iHvv3BbbXYPuRJXrW93InevKXfzy6yl5dh89kEfg7X9+SmCwpq+72zzZDpP1hlY2q9y8JMx5GSIyQZzhCVjYtkeZ/UvNZo6nje5PxfObZNmtuZDajtsEtaLoz15kXvBA43HM8e9orPu7ofBOcAKwAK8CKc2LFSDGGSW2AI6ABaAAa3jMabFE0aFl2WB/izWP5yE10uU7SaFlgJkGCLIDjjMBhT2vtVeoHb8p0huOaBqEzxzDs6dwzDcP0nfFkbjrE81h76ytF1mQkYrpGhJzWyUnGxsi2TNcg1tgm1J7N/ZHhOhZxPc82i4xZtoCXU88aDuAFeAFegBfgbZmbbGvYvUjg/xeT1Wq78wzMArPALDALzOZ7FKJHAkUxm7yGUAZxQVwQF8QFccvEld/pKQxbfLB5D7wCr8Ar8Aq87vgNFDMFNaYSqzZUZgiQFqQFaUFaXtGZJGn3AXJSK459azQhI3dmUZswxrojYzy1HZca1PDZq8JxIBBzoMuNMUAX0AV0T286QLdH6Nqim2IdHgUDeAFegPf0pgN4+wSv6DaZdvAWdv2DxAFhynbIOwZ5QV6Qd6jkFfPoFt+/EeuNjdnEmdGR70zH9nzGDUmnlusSy5i5E9/IrGf34A83pKxXwd+TmnFkeCPLNn3TszzWl4kznltT4jnexGDjmGkUbprZKdw0GLQwaGHQelOmw6CFQevkZhQctISPyOyOUndRlOYvM7PNiUcxNmFswtiEsQljE8YmTQsqgQhs3S2ouK2D8BFDFoYsDFkYsjBkKVpPqOHV0/ekRrTIzCMua4ZTZzY1zLE/safOfE6njjX1xva02LoSTTHZ2dYVBi0MWhi03oDpMGhh0Hofg9ZIYNtKNfoDhicMTxie3pDpMDxheHofw5MlEBVOY9QMjFQYqTBSvSHTYaTCSPU+RqqRqPevRbQRDEsYljAsvSHTYVjCsPQ+hiVrcqJNKZd3WC9menCFFeMVxiuMV//TmKj1GDpODFvPpXTiTLyJ6ViEOoY9G5tjY+yMp9bE2obEEt1M0QJb88MqO+p20NSQagqUff+UndTaq7bhn9RwMzK1iGv4E2NOfcezHH9mTj3PtQx/5E7INs9Jr0mmtqaimRM8twn7qR/wP8LEDMgAMt40Mk4dsVQUIKe9UcDM5th0NJ5ZM2Pm2WRGnNHEdI3ZxJ6MRuS007PccmAtWAvWgrUihtsnxkkNNzc80zTZ0teZu4Y5cjzbsFzXGnvzMRlNHJlw0HquawGsACvA+mYMB7B2C1ZD9AicaIwG8BP8BD/fjOHAz2752e8O+OiDV/477M2AsefH2IZt3GPt/6T2c8Z0ak2nlkMn3swZzWzT8j3HNa2pP7cJmRTEMPtayoIWoAVo8b5p0T7NZPMNWrABbAAb3jcb5HMkSl9fBCaACWDifWPCEHVRCN4dAxPABDDhfTNB5D6pshNivyOSX0YAgwQYsgclOsdT9S/jYak/LFN3PBFkcMS4O6xxF9ffkMGxMV9560AYrUI2gbagLWj7lkwH2vZI25HAXnXbsENAK9AKtL4l0wGtPaKVFTA778h5GtNF5pdJMreLldmGdbe8ykuy2gnJNuZfs4JkfzuZ8XemffA8wiRa0B+fViv+Z2YmcbTR+PJnSJaUF7f5d+wnY27F7fS4/LPV0+pyQZIkn0u/zqFZ7RJexmq5l9FySUL/xyffvwmSJAgf2R9cLCLvr2TzVVNxlcQq1GZyXG12X5UsNp+UBTRUR0lu+/rYh713V+8FSajA45CTo2D/6RE9rIcvrsO7DKU3/sOGGyINSlGywjOo63mFZvYZjcVqIS+rfbkZb8R03cbRf9nvCpMl92m89tJ1LFIhjUoUWt2ophBM6WNMk+SCxOXXV8RLo/ilsbm1FalQC1NA5X36sgj+pX7ps8ZqtJap0F+sqhnHJfGe6GYzKnt9zSYNt1G0aOwusqIUesshX7aqvkUe43qudbtZ893l7fk/UXoVrUN/+3ljZ9GmQ2tfqSpD9jJXn30g2VfERCrUwqlXef9EYsrG3+WKN2bqF85EPq89Xhc1wQo1qpynbxRH69ij3H6MMcKdp61EhZ5/OOk72O3cedfY9+WFaW9P9cq227IX5LFFexIV3L5G0+qnr7Tz3FTRbvQp8Lx66Ngpzx9ksaZ3lA2Iz2wp/Cl+fN75pBHlOsQr1E6gWe2qLxbu4jXUpUKhloezlyNFuKNz8QpqkK59vtGgfefd9ip3i/lGCx3t6+mIWvkhJmEyj+JlUYyHKJNa+ryprnr1KNT3cIUnWo7XD4Serm5NWlcuB1EIuIPh8MdSKxdBmQrPrhLquzrz+VP27//Sl+2LzTI3Enx0ehUp1Lhy6t5YkM90TtaL9KA8jfXVqUahtofOimPF2Nsbk6t1F+p0j6a1xSHsD7/shg2RH03lpGv1O4ppZygMUkm/o5Rk3XM8Ac2b0zICXi5tKhRqWbnMEy/C0QeoSYFC25SDPS/ADU2fomZ3eHuhfRCk5Jy7Zy2En0yni1Wb+bicdK3e8kPt2598ix6/r2ixfl9EId2+lfSWt1XS8ShYXYjrNPPlf9lshgrVuRN1Hc/xqouzfaVvjieuSKHGIgA8UpCkLLOhzrpVKfi/RGhSXZT7IHwsBoF7SmLvSaihd6VRwR8rMLxLTPFaiVMgcqVHcVcds+IjH9teY9yJNVR12d2ulmXr015mt3PuKp3J1zhaN551UZWse3fsaDxF+d0xAZEKxG/qqFe7gduzjfoo3P/0iiz4gZDN20bm61emQP2mliNYmGBBH/jamy3BScCHIwEjdKtXwR5NjU+sXNkmIfWvQzFDdKNQoS8cntySLdBDvBbsCtp1aT3X11SWzavjaFYRq3s3T0jtw8uKzazWS/ndPEnxCs+qaYlUq15s9FEV3b5WVhMTN8fB8ndNFZCRovXc6KuWncMS2abDzieS50Yl5HbUX3b1fg5iyr14bIEtXC0t4hVqV7nzVamej6q5GyGKxaunRb7uPdNK/XfUW8dJ8EzbPEa9ejryK+6WI18pc6uLP00N0hXq1jQh2tNefie26aIuvBfG7LwT9CVpEa99Z3Sxfgzy15uX30jCxp/H7BhzkDKzHn7SYme0nRrtrfSgGFwhv/pD8/Hq9W2LViojXPsuWpNy/vLXdLnI3+bft9hFk1ehUMvqecaxItwlqXAlNWnQfWJqo/bLMytvQYfv4beI+K2go01HR30xL8P2+t4FnbMvL2NK0vwmFR+7WvdFMeH91Ox7+JWmXC8/jZYZObtxqKdmNcI7bZsl5bzl5GLYX+d/dJlfgFRsm4I6FHYUqpeTeRm+h4uXzU7GP2y6yH+UFatxT6GdQIUaNHEs/y/T8TlIVvz6aPPQ1kaaQtmrdy3K2sQ2cqTkKJS3euZd1iPIZVlJuj0Br0x8zUhffn38dIOaXN3na47pffg7ePwSPgdxFC6PYUmPgs5qWHHDvVjDvpSuubevoagC3TuhEnf4pXdCZWTrXmM16S6+e/1I4JSbVjW6T57IFUPh5ElrRd0/3809uu2xdMmjp1rV6N4PF41tJr8fLi5Z96m4FvHa5E/FtVKi8PTEOLh3QFv+/uVxiZ31t+1yoP4THf1NTk1nPBUohuipNr2KdHt5tmoL18ttHHk0SaJdN9r2U3kvj7yGzohzWIKvQfq0dvnniXg19SnprLceFuLgEx29VU6Nwm5w8yS6eNG4FSwqQmHF2mys4sXx5Z6koM7GrS1xN3uUIqFPWkrsbM3N14qbswo8zhIP6BWmV3G0/EbnzSOwktzO1mtlveWoaGJbfsqyde/THtUtOg3UIF23Z7NS+1Xwz30a3wf/NjvZ2glUqEHzKqGs8DamjzfcH9lYgVbyeqEA07cicbFJf2RjQE1uL8/jt3WU0iVNiabnUZKn+wRhpb47uoyeucHoRUz+oon8CUJBsbpPdleqZX2Rn+p7iH6PmwPstBWpUIvKk0mVKvlZ4ofoMvJpFl2xsSIKUnXfg2jQ+islfhA2h9tpLVP3abQ9nevQy49Y5iPX5q3YiK9Ffmerzib9oiO/Jg0dz2yKEnyOyd+FMyq7o3VDw7XyzOaI9M72R+q1F462ozvvehR0PHMoCsC3L77SdLMZ3jxUKcntiShfiwCbbNle2mDTRpRa+b3VL93pDrwcRwZmPfJ1n4w8rr/oD8eqp0O87tsKNer5MZTt/vzRIy7KonWf4KlRfRsH4cHtw0/JtyBpcYKnjQ6FVYkArG9IEH75h1k0OXYsQ15YtzN4rkzi7EJrke1rYe6bLP/veDShIz9U8Mzuz07KggX8hWK/V3ju+7jbT3a5917sXlR7oRpX1EeUCk6flcQq1Gb/2PPxJKSvAdukYqbKCVbYkdnn83HFezF22B/kX4gcS+lAm8bTCwKleRUmdXpBUrLGMV1Kc8sT4611aDxXLVAGtnROSTHBkDpXLS9c4x6prHLBHX6dajR6Wo4X4/MLkx54eWwvgYepSYPCE5UvQWPqaqn7+Mq6NK6ajpdF9KEqi9Z4WkNOdcvzYe2V9DqWlAvRLl5zax29jiW3cbSicfrSyViyL7zXsWRXeWdjSb0ahdru+8COF+OVeMXLKBY4napbU/s6j4xjq7pSUQ6CX3Cxxai+/+V1chsHz1leJoE4MP2WQ8Vex1aOKuWMUqaK50sRsli/JVGx2b67Q2NJ1+4i8AQN1mMxVKwlAQepYv4RJIEbLDKVQvbqtSCntJhAAW8iP5gHzVjvuSDtLTaTmOXvFymfPqnRvh/9CvaRmFWKl0+G7n2VQMFGCsNPbQnFad6LehUmSXhkxcrHr3bzo7aX6zhmxigIKwLyvsui0Kq0F1Vy1OupAKdhU7FqUqR3TyVQ6X37R741FVFugt5bIU7T3xrKKMHxfgqg0pYkfGmiJVRgef+lUWhdHRRWlud9FUHjqd6GIub/CcTOaC1TwX8moXM3Gt2n5CX02sdgVNLTvr4H2QuEy5EfyJUPXtiVxlPYoEh9me/N+8JPvyuNCjaQGMJqSnT/kqR0KdcNOlWrcFpOyJH7tNq8bTwrJytK40m5ZlX3eSy05qPQbUUqtEQhv8pBAMLsRvrT6j5duy6N994ej3PYpdaue+WxUvHU5RHrQeLG6FKtwkxMiJrHisVeFiejI3GTdK/71D2Gvfw9DNKee0y1VgVbCE2Vj5YqiTMVNBE3R7eKu/ZxHivY/ctyHoUvWZ8OWdXFO04f6hXai9DwfKx4/KC4eEvpSmXXM+ByyNHNjv738PKJen9dJ2XZJLyg/JaG+gxYXmM/FN0JCfxpzmaiXDub+UifI+1Sq4IthKZ9leGRP/l+SS6/Myxkhm4UdsyF7Y2RXMTnplhQx90dnansele6oUy3G+kP0Y2/fVN8K3Fjp+eCdLwrLVtO/qb0R8q70sr6Oz5P2XCHOJN8QxqTVenToeBHFJkO1t/dzIuQbcUlF5H/wiMvNLoTu1Cn8JT3e+sDXa4WJKXbC2I/Lp9I+nWV/rgJkiQPM59FlkiELsXpka/xVHe9/jtK/CUtvr8KFkf8RcqiNd5DqFddfMOWKfHaS9cxFXtumjS0rWOVay+7+3mQYPw6pcvbKMouZI94baaVAbguo3AePK43+XxfbxFch89kEfg7X7MZCyslm7UJXWLoRp+C4aovzeaG4y7XRenld5fnZ8s+2Bqw+hb0we9f65QL+U+UXkXr0Bcymj4dKoaqzAuTa75/IjHf9V6uYspW+X7hDeJRJHbNhfZWXaDcjGVHP/prNegqL+nvFmjnHUx3pAfXm26r/4I8woyFGXVkcs8seQ7puWsjnx3Pb35udugsOzW63U/pBLyw2U/9aR9h1J9as0sO9fY4mpDmNJ5oSENtSHozpaIdDbUdacz4mc/pzzCsooZ8iphB/dSZ4xDmrHdINJnzMKEiLFm/XmqyZPFdZQpHGPVni1xJrTy8cjFdG4VhGtHeOd/cfw4PDaGH1O8JHZitIusV7Fe/h7s3I6zOhmJle7hnHeEci7qBdguNaUDOu4egpWhNqgLgDLUZacr0gllNC2vW5pWBNX/qy2IzzpybihnsJaLLS0pWOCWrL21960zVMkoUTjm3zGTfOsdwrUQMNVjTyGJMY2InDAz1B0p3LXqQQgqmE/W71OSwggF/CqfPGibs0Dw05aQathmH2n06SwAGcv/Ul2BsmG0T7UdrMjcLPXK4PelMLs/oS/qHjjDEjtBRdsVhGnPonUh/8sph23Oo/Uhjokw0oIE2IP05SYdpyqF3Ia3JUIdtyqF2oY6yzqIxDbUxaU/qC990ZUAW2aQ1w2yRaDkdpoxBz6yM0iiYgGXYhhsqkNRy36DH/ewh4PkwWyYalv6I32hJA21JXcZUR6MaaKPSGqoerWigrUhXQoBhG3KoHUh/7oVh2nHo/acIIvQxpd7TR/vDKovnlifI/Rhn3Pmw9D+kbGa0vaLJKpAtgqdZs9EbBre2xehUo3CTU3Nw0ap7nLpUKNRSb+RLkawuLTUodHvkDH61BXIGl6yBnMHIGYycwdK9BjmDkTNYNpNjedTfy9HKgwvv7HSKhsHQpkOhnk2T1b2Izxd0zr68ZFPtNHcU8fixjRVUF95Pzb6HX/Mtszua5EYuB7JSrFmN8E7bpnCUboW2KahDgUTI24283WVbCO2Cn3Pebrs659hmAZr9J3S1T06OzoOiai4XHGZA2hi4U7u73abmPEM7Gmo7QtoYse0L2y62L6wP8UblR75hcblO0mhZ6E3K+xijUXkjw87CMOuL6Fw19dcgXWFxozUGcVX19CgYdqiGoymQds3I1/L8jFLeh5LGqijJVWh3moIW1zY7LfJ7q19tGGFN9auRr1C/sw5Nr5JcubantZapUI8zHNj1RmOVc8i10aGxnqqHnUXq2VpHx/UUjMqlVE8hHQrn0To8cly1ZutCXU8j4u4EXWhSpke+yrIMiV+wgBdrKUj8Aj9QB7cNWq6h4OZH4hckfmkjWWE2hMQvu4UoPrhE4pe31p2HOsVQdATlWytn4H1GApwuBkjcZMcyoL+WJOg+Q1D7wY52ZzNWIbIDIKv/KqxtNp8lyRLd75wksUoHSWbZXFBkrz2T8+OT71+zj8P0Ko6W3+i8eT2kJFfheKzIFmCu9yr45z6N74N/m8/JthOoUAORaW2u8Damjzck9Z4aK9BKXsenQrb6ViSm90L3LdTk9vI8fltHKWUdnGh6HiV5Cs9DxLGf67ujy+iZG4xexOQv2nxIR0Ws7vlApVrWFx9eVvQhOrLz1FqkQi1E/Lq5ygf6T8rvDvg0i8nTWBEFqbrPpTRo/ZVmd0Pkz6WIyFTxq7RvWtb5b5BiljnIWSZ2TbBrsiU9dk3eeXceKsaLiNuHi+Ui1NgfJA54ntud1bJZWi1nr8fHohTsvRfzR7UXivON8ESDIPBES3Fw1MRB7i1hC6kyBe0SBfOFzjDCyp31cu687wLhhjzWv1j/Yv2L9S+6M2avOEreQRTqScUs2n29w1C36W4KbLqXrkKUX+/lG5LfIj0iFxfn67eGFB8YOg3uBnWIIPPDKhtFPibl8KA7EWRKCJrUb1ZWJnT8HMSUZ1cNaHKQzFFudSspXjeQKtXz+CHXaZ5dQrx6WuQrzGKargDs6r+j3jpOgmfa5jHq1aPwPMXLcR+EjwuedYaKP00N0jU+S+FMq5+Sl9Br/yyV9Cg8yyan5561y+/ELtyrC1dBsjk7QPJhVpLyrlLGZas6dtomLXMc/ZfpyN81VV1GisIgLldYDNV7Qd+27SIvc36eiOn2A/7ntZuPRuaCrHZp5qbfk/SDB02Nwv1Pr8giodu3jbjQr0zBa9HU6AQLw5jNz4pxHwrJY/4cN0K3ehXs0YQ5sXJl4KP+dShmiG4UavTjyBfoIV4LdgXtunSf5q0ty+bV1zhaN4ZcUhLbvjYjQyjtQ00xuFj2NklJmO5/eZ3cxsEza3BCT7jfcqjYSyhxSMtyRmyEYj1U0GL9lkTFZhITX9mSrt1F4AkarMdiqFhrf2mrq5h/BEngBotMpZC9ei1Ie4vNJLz8+0XJr/Spsasf/Qr2kTiAJV4+GVb1VQIFGynAtLaE4mzqRb0Kk4RS78mU73u4eOHXDS/XccyMUfBCBEt9l0WhVWkvqiTDeyrAadjECLCi8cESXpbePZVApfftu1M0FVFuutlbIU7T3xrKKMHxfgqg0paEEkLKlVCB5f2XRqF1dVBYWZ73VQQF/0jlQbFjjgyx09qqohW87p05/OCgr9u4yctcn4YlezOMazQVx0ulyiB1cFVSssaNSAHNG5fC8WppEK7gHFdVLtYwtapReI7yxyw/vzDpgZevMQQepiYNGg9ZHy9BWXXLQ9btlWgcwOUKITWAy4rulTXFhKkT1uwL75U1u8o7Y029GoXWeSZJeOym3f2Nzvw/sWSybcSpnCTFpV5ci8Cl3m1/0DQ9H2orGHbv17oUGrYph9qFOlpzDtOYQ+9E+pf0w7bnUPtRJ26TYZpy6F1Io19q2IYcagfS6gJEExpoE+rC14rGNNDGhDRiB/foRx+8ckOruLu5cwTAzN7YlVdndhv0zrtGR7q8MI0bp7vxGIrIaAwhHk2SKP5xQRJ68KnUxmlLDQp11JcAW/jmuJx0hbqJpGAQTtlcVT09ChRqeNaBZc49xmT1gbka9d8i4uchF/lxyZSVQv4snoRohWemMe2k8JGv1jp663vvLEKoYD6hQj+/xc3zsOXNpzkxjpLcjuuDTF7SAnt5IsiEJSxP4XkgExYyYSET1tlnIBxGfPoDZ2BNEb6RJOW6+a2QIOVGPvhE6uClihoFd1UrNwtut/zU6wM57wUrWopWj9IwXetoRgj0iwQU0pI13o2S0owEFG0kAo7Yb5bFmEa/OQYGpPTQfsCvvT8N6b/PFFvoFsijh4bU0eFFNX8lBq3s8Br/5ce7L58+33xpzFxt7nt28v/yvCRNVT7yw/Ydwtr3SpYFXxGeQqQx6oHY7xUarJjJwLNhdr2feSnzA6N/PpHkqWiUrmWO3Znrjsee63iGPzZn47k5sYk3MmzPc7K/Yz8N+PHVkCz+9Ij3FISPfyYvSUqXfz7TOMm0BL+Y//Pz/wEWRXNU \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/tech/1.configuration/classes/DocumentedEntityWrapper.md b/docs/tech/1.configuration/classes/DocumentedEntityWrapper.md index 859e4c92..674254c8 100644 --- a/docs/tech/1.configuration/classes/DocumentedEntityWrapper.md +++ b/docs/tech/1.configuration/classes/DocumentedEntityWrapper.md @@ -48,12 +48,15 @@ final class DocumentedEntityWrapper
  • getFileName - The name of the file to be generated
    • -
  • - getInitiatorFilePath -
  • getKey - Get document key
    • +
  • + getParentDocFilePath +
    • +
  • + setParentDocFilePath +
    • @@ -73,7 +76,7 @@ final class DocumentedEntityWrapper ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $initiatorFilePath); +public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $parentDocFilePath); ``` @@ -100,7 +103,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransfor - - $initiatorFilePath + $parentDocFilePath string The file in which the documentation of the entity was requested @@ -219,16 +222,16 @@ public function getFileName(): string;
    ```php -public function getInitiatorFilePath(): string; +public function getKey(): string; ``` - +
    Get document key
    Parameters: not specified @@ -240,22 +243,60 @@ public function getInitiatorFilePath(): string;
    ```php -public function getKey(): string; +public function getParentDocFilePath(): string; ``` -
    Get document key
    + Parameters: not specified Return value: string +
    +
    +
    + + + +```php +public function setParentDocFilePath(string $parentDocFilePath): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $parentDocFilePathstring-
    + +Return value: void + +
    diff --git a/docs/tech/1.configuration/classes/DocumentedEntityWrappersCollection.md b/docs/tech/1.configuration/classes/DocumentedEntityWrappersCollection.md index 0edbc843..fd7a969f 100644 --- a/docs/tech/1.configuration/classes/DocumentedEntityWrappersCollection.md +++ b/docs/tech/1.configuration/classes/DocumentedEntityWrappersCollection.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Configuration files / DocumentedEntityWrappersCollection

    - DocumentedEntityWrappersCollection class: + DocumentedEntityWrappersCollection class:

    @@ -60,11 +60,11 @@ final class DocumentedEntityWrappersCollection implements \IteratorAggregate, \T ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache); +public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher); ``` @@ -89,6 +89,11 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $localObjectCache \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - @@ -102,7 +107,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext ```php @@ -129,7 +134,7 @@ public function count(): int; ```php @@ -167,7 +172,7 @@ public function createAndAddDocumentedEntityWrapper(\BumbleDocGen\Core\Parser\En ```php @@ -188,7 +193,7 @@ public function getDocumentedEntitiesRelations(): array; ```php diff --git a/docs/tech/1.configuration/classes/GeneratePageBreadcrumbs.md b/docs/tech/1.configuration/classes/GeneratePageBreadcrumbs.md index d293832d..2fab1179 100644 --- a/docs/tech/1.configuration/classes/GeneratePageBreadcrumbs.md +++ b/docs/tech/1.configuration/classes/GeneratePageBreadcrumbs.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Configuration files / GeneratePageBreadcrumbs

    - GeneratePageBreadcrumbs class: + GeneratePageBreadcrumbs class:

    @@ -67,7 +67,7 @@ final class GeneratePageBreadcrumbs implements \BumbleDocGen\Core\Renderer\Twig\ ```php @@ -114,7 +114,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsH ```php @@ -160,14 +160,20 @@ public function __invoke(string $currentPageTitle, string $templatePath, bool $s Throws:
    @@ -141,7 +134,7 @@ public function beforeCreatingDocFile(\BumbleDocGen\Core\Plugin\Event\Renderer\B ```php diff --git a/docs/tech/1.configuration/readme.md b/docs/tech/1.configuration/readme.md index 69fd79e4..4ee9497d 100644 --- a/docs/tech/1.configuration/readme.md +++ b/docs/tech/1.configuration/readme.md @@ -222,4 +222,4 @@ The inheritance algorithm is as follows: scalar types can be overwritten by each
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/2.parser/classes/ClassEntity.md b/docs/tech/2.parser/classes/ClassEntity.md index ab6c5060..a1df0337 100644 --- a/docs/tech/2.parser/classes/ClassEntity.md +++ b/docs/tech/2.parser/classes/ClassEntity.md @@ -228,6 +228,9 @@ class ClassEntity extends \BumbleDocGen\LanguageHandler\Php\Parser\Entity\BaseEn
  • implementsInterface
    • +
  • + isAbstract +
  • isClassLoad
    • @@ -368,7 +371,7 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf ```php @@ -636,7 +639,7 @@ public function getCasesNames(): array; ```php @@ -780,7 +783,7 @@ public function getConstantEntityCollection(): \BumbleDocGen\LanguageHandler\Php ```php @@ -1042,7 +1045,7 @@ public function getDocNote(): string; ```php @@ -2207,7 +2210,7 @@ public function hasAnnotationKey(string $annotationKey): bool; ```php @@ -2308,7 +2311,7 @@ public function hasExamples(): bool; ```php @@ -2356,7 +2359,7 @@ public function hasMethod(string $method): bool; ```php @@ -2404,7 +2407,7 @@ public function hasParentClass(string $parentClassName): bool; ```php @@ -2506,7 +2509,7 @@ public function hasTraits(): bool; ```php @@ -2537,6 +2540,37 @@ public function implementsInterface(string $interfaceName): bool; Return value: bool +Throws: + + + +
    +
    + + + +```php +public function isAbstract(): bool; +``` + + + +Parameters: not specified + +Return value: bool + + Throws:
    @@ -626,7 +622,7 @@ public function getEntityCollectionName(): string; ```php @@ -759,10 +755,41 @@ public function getLoadedOrCreateNew(string $objectName, bool $withAddClassEntit
    + + +```php +public function getOnlyAbstractClasses(): \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection; +``` + + + +Parameters: not specified + +Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection + + +Throws: + + +
    +
    +
    + ```php @@ -793,7 +820,7 @@ public function getOnlyInstantiable(): \BumbleDocGen\LanguageHandler\Php\Parser\ ```php @@ -802,6 +829,37 @@ public function getOnlyInterfaces(): \BumbleDocGen\LanguageHandler\Php\Parser\En +Parameters: not specified + +Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection + + +Throws: + + +
    +
    +
    + + + +```php +public function getOnlyTraits(): \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection; +``` + + + Parameters: not specified Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection @@ -908,7 +966,7 @@ public function has(string $objectName): bool; ```php diff --git a/docs/tech/2.parser/entity.md b/docs/tech/2.parser/entity.md index 75efade4..dc7ed102 100644 --- a/docs/tech/2.parser/entity.md +++ b/docs/tech/2.parser/entity.md @@ -123,4 +123,4 @@ These classes are a convenient wrapper for accessing data in templates:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/2.parser/entityFilterCondition.md b/docs/tech/2.parser/entityFilterCondition.md index 2273be88..16a7474e 100644 --- a/docs/tech/2.parser/entityFilterCondition.md +++ b/docs/tech/2.parser/entityFilterCondition.md @@ -78,4 +78,4 @@ Filter condition for working with entities PHP language handler:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/2.parser/readme.md b/docs/tech/2.parser/readme.md index a8eb5dd3..65ecc350 100644 --- a/docs/tech/2.parser/readme.md +++ b/docs/tech/2.parser/readme.md @@ -41,4 +41,4 @@ In this section, we show how the parser works and what components it consists of
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/2.parser/sourceLocator.md b/docs/tech/2.parser/sourceLocator.md index 5c874b72..3b20d28e 100644 --- a/docs/tech/2.parser/sourceLocator.md +++ b/docs/tech/2.parser/sourceLocator.md @@ -30,4 +30,4 @@ You can create your own source locators or use any existing ones. All source loc
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:09:56 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:09:56 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/templates.md b/docs/tech/3.renderer/01_templates.md similarity index 93% rename from docs/tech/3.renderer/templates.md rename to docs/tech/3.renderer/01_templates.md index 18adcb46..1890904a 100644 --- a/docs/tech/3.renderer/templates.md +++ b/docs/tech/3.renderer/01_templates.md @@ -101,4 +101,4 @@ Result after starting the documentation generation process:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/breadcrumbs.md b/docs/tech/3.renderer/02_breadcrumbs.md similarity index 89% rename from docs/tech/3.renderer/breadcrumbs.md rename to docs/tech/3.renderer/02_breadcrumbs.md index d7aacecf..57afbe9e 100644 --- a/docs/tech/3.renderer/breadcrumbs.md +++ b/docs/tech/3.renderer/02_breadcrumbs.md @@ -51,4 +51,4 @@ Here is an example of the result of the `generatePageBreadcrumbs` function:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/03_documentStructure.md b/docs/tech/3.renderer/03_documentStructure.md new file mode 100644 index 00000000..c5748408 --- /dev/null +++ b/docs/tech/3.renderer/03_documentStructure.md @@ -0,0 +1,22 @@ + BumbleDocGen / Technical description of the project / Renderer / Document structure of generated entities
    + +

    Document structure of generated entities

    + +*By default, the documentation generator offers two options for organizing the structure of generated entity documents:* + +1) The standard structure is an entity document next to a parent document. If the document template contained +a link to the entity documentation, during the documentation generation process we created a classes directory +in the same directory where the parent document was located, and inside this classes directory we created an entity document. + +2) All entity documents are located in a separate directory with the structure of the entire documented project. **At the moment this is only available for PHP projects** + +To enable the second option, you need to connect the built-in plugin: +```yaml +plugins: + - class: \BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace\EntityDocUnifiedPlacePlugin +``` + + +
    +
    +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/3.renderer/twigCustomFilters.md b/docs/tech/3.renderer/04_twigCustomFilters.md similarity index 97% rename from docs/tech/3.renderer/twigCustomFilters.md rename to docs/tech/3.renderer/04_twigCustomFilters.md index 7543e0ea..ab3a8e56 100644 --- a/docs/tech/3.renderer/twigCustomFilters.md +++ b/docs/tech/3.renderer/04_twigCustomFilters.md @@ -263,4 +263,4 @@ Here is a list of filters available by default:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/twigCustomFunctions.md b/docs/tech/3.renderer/05_twigCustomFunctions.md similarity index 97% rename from docs/tech/3.renderer/twigCustomFunctions.md rename to docs/tech/3.renderer/05_twigCustomFunctions.md index e2e992f1..a8d4102a 100644 --- a/docs/tech/3.renderer/twigCustomFunctions.md +++ b/docs/tech/3.renderer/05_twigCustomFunctions.md @@ -177,7 +177,7 @@ Here is a list of functions available by default: - getDocumentationPageUrl
    + getDocumentationPageUrl
    Creates an entity link by object @@ -193,7 +193,7 @@ Here is a list of functions available by default: - getDocumentedEntityUrl
    + getDocumentedEntityUrl
    Get the URL of a documented entity by its name. If the entity is found, next to the file where this method was called, the `EntityDocRendererInterface::getDocFileExtension()` directory will be created, in which the documented entity file will be created
    :warning: This function initiates the creation of documents for the displayed entities
    @@ -344,7 +344,7 @@ Here is a list of functions available by default: $classEntityCollections - ClassEntityCollection + ClassEntityCollection The collection of entities for which the class map will be generated @@ -385,4 +385,4 @@ Here is a list of functions available by default:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/classes/AddIndentFromLeft.md b/docs/tech/3.renderer/classes/AddIndentFromLeft.md index 3779d94b..423b69fa 100644 --- a/docs/tech/3.renderer/classes/AddIndentFromLeft.md +++ b/docs/tech/3.renderer/classes/AddIndentFromLeft.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / AddIndentFromLeft
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / AddIndentFromLeft

    AddIndentFromLeft class: diff --git a/docs/tech/3.renderer/classes/BreadcrumbsHelper.md b/docs/tech/3.renderer/classes/BreadcrumbsHelper.md index ee9de81d..82c460dc 100644 --- a/docs/tech/3.renderer/classes/BreadcrumbsHelper.md +++ b/docs/tech/3.renderer/classes/BreadcrumbsHelper.md @@ -1,8 +1,8 @@ - BumbleDocGen / Technical description of the project / Renderer / Documentation structure and breadcrumbs / BreadcrumbsHelper
    + BumbleDocGen / Technical description of the project / Renderer / Documentation structure and breadcrumbs / BreadcrumbsHelper

    - BreadcrumbsHelper class: + BreadcrumbsHelper class:

    @@ -67,7 +67,7 @@ final class BreadcrumbsHelper @@ -82,11 +82,11 @@ final class BreadcrumbsHelper ```php -public function __construct(\BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsTwigEnvironment $breadcrumbsTwig, string $prevPageNameTemplate = \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsHelper::DEFAULT_PREV_PAGE_NAME_TEMPLATE); +public function __construct(\BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsTwigEnvironment $breadcrumbsTwig, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher, string $prevPageNameTemplate = \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsHelper::DEFAULT_PREV_PAGE_NAME_TEMPLATE); ``` @@ -116,6 +116,11 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf $breadcrumbsTwig \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsTwigEnvironment - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - $prevPageNameTemplate @@ -134,7 +139,7 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf ```php @@ -168,7 +173,7 @@ public function getAllPageLinks(): array; ```php @@ -224,11 +229,11 @@ public function getBreadcrumbs(string $filePatch, bool $fromCurrent = true): arr ```php -public function getBreadcrumbsForTemplates(string $templateFilePatch, bool $fromCurrent = true): array; +public function getBreadcrumbsForTemplates(string $filePatch, bool $fromCurrent = true): array; ``` @@ -245,7 +250,7 @@ public function getBreadcrumbsForTemplates(string $templateFilePatch, bool $from - $templateFilePatch + $filePatch string - @@ -280,7 +285,7 @@ public function getBreadcrumbsForTemplates(string $templateFilePatch, bool $from ```php @@ -331,7 +336,7 @@ public function getPageDataByKey(string $key): array|null; ```php @@ -382,7 +387,7 @@ public function getPageDocFileByKey(string $key): string|null; ```php @@ -433,7 +438,7 @@ public function getPageLinkByKey(string $key): string|null; ```php @@ -478,7 +483,7 @@ public function getTemplateLinkKey(string $templateName): string|null; ```php @@ -534,7 +539,7 @@ $breadcrumbsHelper->getTemplateTitle() == 'Some template title'; // is true ```php diff --git a/docs/tech/3.renderer/classes/ClassEntityCollection.md b/docs/tech/3.renderer/classes/ClassEntityCollection.md index 250fd73f..be77ac0b 100644 --- a/docs/tech/3.renderer/classes/ClassEntityCollection.md +++ b/docs/tech/3.renderer/classes/ClassEntityCollection.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / ClassEntityCollection
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / ClassEntityCollection

    ClassEntityCollection class: @@ -72,12 +72,18 @@ final class ClassEntityCollection extends \BumbleDocGen\Core\Parser\Entity\Logga
  • getLoadedOrCreateNew
    • +
  • + getOnlyAbstractClasses +
  • getOnlyInstantiable
  • getOnlyInterfaces
    • +
  • + getOnlyTraits +
  • getOperationsLogCollection
    • @@ -333,7 +339,7 @@ public function filterByInterfaces(array $interfaces): \BumbleDocGen\LanguageHan ```php @@ -364,16 +370,6 @@ public function filterByNameRegularExpression(string $regexPattern): \BumbleDocG Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection -Throws: - -
    @@ -626,7 +622,7 @@ public function getEntityCollectionName(): string; ```php @@ -753,8 +749,39 @@ public function getLoadedOrCreateNew(string $objectName, bool $withAddClassEntit See: +
    +
    +
    + + + +```php +public function getOnlyAbstractClasses(): \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection; +``` + + + +Parameters: not specified + +Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection + + +Throws: + +
    @@ -762,7 +789,7 @@ public function getLoadedOrCreateNew(string $objectName, bool $withAddClassEntit ```php @@ -793,7 +820,7 @@ public function getOnlyInstantiable(): \BumbleDocGen\LanguageHandler\Php\Parser\ ```php @@ -802,6 +829,37 @@ public function getOnlyInterfaces(): \BumbleDocGen\LanguageHandler\Php\Parser\En +Parameters: not specified + +Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection + + +Throws: + + +
    +
    +
    + + + +```php +public function getOnlyTraits(): \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection; +``` + + + Parameters: not specified Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection @@ -908,7 +966,7 @@ public function has(string $objectName): bool; ```php diff --git a/docs/tech/3.renderer/classes/ClassEntityCollection_2.md b/docs/tech/3.renderer/classes/ClassEntityCollection_2.md index 83388311..c6d11d3c 100644 --- a/docs/tech/3.renderer/classes/ClassEntityCollection_2.md +++ b/docs/tech/3.renderer/classes/ClassEntityCollection_2.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / ClassEntityCollection
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / ClassEntityCollection

    ClassEntityCollection class: @@ -72,12 +72,18 @@ final class ClassEntityCollection extends \BumbleDocGen\Core\Parser\Entity\Logga
  • getLoadedOrCreateNew
    • +
  • + getOnlyAbstractClasses +
  • getOnlyInstantiable
  • getOnlyInterfaces
    • +
  • + getOnlyTraits +
  • getOperationsLogCollection
    • @@ -333,7 +339,7 @@ public function filterByInterfaces(array $interfaces): \BumbleDocGen\LanguageHan ```php @@ -364,16 +370,6 @@ public function filterByNameRegularExpression(string $regexPattern): \BumbleDocG Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection -Throws: - -

    @@ -626,7 +622,7 @@ public function getEntityCollectionName(): string; ```php @@ -753,8 +749,39 @@ public function getLoadedOrCreateNew(string $objectName, bool $withAddClassEntit See: +
    +
    +
    + + + +```php +public function getOnlyAbstractClasses(): \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection; +``` + + + +Parameters: not specified + +Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection + + +Throws: + +
    @@ -762,7 +789,7 @@ public function getLoadedOrCreateNew(string $objectName, bool $withAddClassEntit ```php @@ -793,7 +820,7 @@ public function getOnlyInstantiable(): \BumbleDocGen\LanguageHandler\Php\Parser\ ```php @@ -802,6 +829,37 @@ public function getOnlyInterfaces(): \BumbleDocGen\LanguageHandler\Php\Parser\En +Parameters: not specified + +Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection + + +Throws: + + +
    +
    +
    + + + +```php +public function getOnlyTraits(): \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection; +``` + + + Parameters: not specified Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection @@ -908,7 +966,7 @@ public function has(string $objectName): bool; ```php diff --git a/docs/tech/3.renderer/classes/CustomFunctionInterface.md b/docs/tech/3.renderer/classes/CustomFunctionInterface.md index 6d49d821..f2f47483 100644 --- a/docs/tech/3.renderer/classes/CustomFunctionInterface.md +++ b/docs/tech/3.renderer/classes/CustomFunctionInterface.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / CustomFunctionInterface
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / CustomFunctionInterface

    CustomFunctionInterface class: diff --git a/docs/tech/3.renderer/classes/DocumentedEntityWrapper.md b/docs/tech/3.renderer/classes/DocumentedEntityWrapper.md index a3e2f5e3..14cf61fa 100644 --- a/docs/tech/3.renderer/classes/DocumentedEntityWrapper.md +++ b/docs/tech/3.renderer/classes/DocumentedEntityWrapper.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / DocumentedEntityWrapper
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / DocumentedEntityWrapper

    DocumentedEntityWrapper class: @@ -48,12 +48,15 @@ final class DocumentedEntityWrapper
  • getFileName - The name of the file to be generated
    • -
  • - getInitiatorFilePath -
  • getKey - Get document key
    • +
  • + getParentDocFilePath +
    • +
  • + setParentDocFilePath +
    • @@ -73,7 +76,7 @@ final class DocumentedEntityWrapper ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $initiatorFilePath); +public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $parentDocFilePath); ``` @@ -100,7 +103,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransfor - - $initiatorFilePath + $parentDocFilePath string The file in which the documentation of the entity was requested @@ -219,16 +222,16 @@ public function getFileName(): string;
    ```php -public function getInitiatorFilePath(): string; +public function getKey(): string; ``` - +
    Get document key
    Parameters: not specified @@ -240,22 +243,60 @@ public function getInitiatorFilePath(): string;
    ```php -public function getKey(): string; +public function getParentDocFilePath(): string; ``` -
    Get document key
    + Parameters: not specified Return value: string +
    +
    +
    + + + +```php +public function setParentDocFilePath(string $parentDocFilePath): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $parentDocFilePathstring-
    + +Return value: void + +
    diff --git a/docs/tech/3.renderer/classes/DocumentedEntityWrapper_2.md b/docs/tech/3.renderer/classes/DocumentedEntityWrapper_2.md index 7c9c1fcb..c6dfad98 100644 --- a/docs/tech/3.renderer/classes/DocumentedEntityWrapper_2.md +++ b/docs/tech/3.renderer/classes/DocumentedEntityWrapper_2.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / DocumentedEntityWrapper
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / DocumentedEntityWrapper

    DocumentedEntityWrapper class: @@ -48,12 +48,15 @@ final class DocumentedEntityWrapper
  • getFileName - The name of the file to be generated
    • -
  • - getInitiatorFilePath -
  • getKey - Get document key
    • +
  • + getParentDocFilePath +
    • +
  • + setParentDocFilePath +
    • @@ -73,7 +76,7 @@ final class DocumentedEntityWrapper ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $initiatorFilePath); +public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $parentDocFilePath); ``` @@ -100,7 +103,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransfor - - $initiatorFilePath + $parentDocFilePath string The file in which the documentation of the entity was requested @@ -219,16 +222,16 @@ public function getFileName(): string;
    ```php -public function getInitiatorFilePath(): string; +public function getKey(): string; ``` - +
    Get document key
    Parameters: not specified @@ -240,22 +243,60 @@ public function getInitiatorFilePath(): string;
    ```php -public function getKey(): string; +public function getParentDocFilePath(): string; ``` -
    Get document key
    + Parameters: not specified Return value: string +
    +
    +
    + + + +```php +public function setParentDocFilePath(string $parentDocFilePath): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $parentDocFilePathstring-
    + +Return value: void + +
    diff --git a/docs/tech/3.renderer/classes/DocumentedEntityWrapper_3.md b/docs/tech/3.renderer/classes/DocumentedEntityWrapper_3.md index 2ecafd8c..f7d977a4 100644 --- a/docs/tech/3.renderer/classes/DocumentedEntityWrapper_3.md +++ b/docs/tech/3.renderer/classes/DocumentedEntityWrapper_3.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / DocumentedEntityWrapper
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / DocumentedEntityWrapper

    DocumentedEntityWrapper class: @@ -48,12 +48,15 @@ final class DocumentedEntityWrapper
  • getFileName - The name of the file to be generated
    • -
  • - getInitiatorFilePath -
  • getKey - Get document key
    • +
  • + getParentDocFilePath +
    • +
  • + setParentDocFilePath +
    • @@ -73,7 +76,7 @@ final class DocumentedEntityWrapper ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $initiatorFilePath); +public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $parentDocFilePath); ``` @@ -100,7 +103,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransfor - - $initiatorFilePath + $parentDocFilePath string The file in which the documentation of the entity was requested @@ -219,16 +222,16 @@ public function getFileName(): string;
    ```php -public function getInitiatorFilePath(): string; +public function getKey(): string; ``` - +
    Get document key
    Parameters: not specified @@ -240,22 +243,60 @@ public function getInitiatorFilePath(): string;
    ```php -public function getKey(): string; +public function getParentDocFilePath(): string; ``` -
    Get document key
    + Parameters: not specified Return value: string +
    +
    +
    + + + +```php +public function setParentDocFilePath(string $parentDocFilePath): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $parentDocFilePathstring-
    + +Return value: void + +
    diff --git a/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection.md b/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection.md index 591ffc8a..a0475d57 100644 --- a/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection.md +++ b/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection.md @@ -1,8 +1,8 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / DocumentedEntityWrappersCollection
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / DocumentedEntityWrappersCollection

    - DocumentedEntityWrappersCollection class: + DocumentedEntityWrappersCollection class:

    @@ -60,11 +60,11 @@ final class DocumentedEntityWrappersCollection implements \IteratorAggregate, \T ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache); +public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher); ``` @@ -89,6 +89,11 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $localObjectCache \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - @@ -102,7 +107,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext ```php @@ -129,7 +134,7 @@ public function count(): int; ```php @@ -167,7 +172,7 @@ public function createAndAddDocumentedEntityWrapper(\BumbleDocGen\Core\Parser\En ```php @@ -188,7 +193,7 @@ public function getDocumentedEntitiesRelations(): array; ```php diff --git a/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection_2.md b/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection_2.md index e872394e..ff2e994b 100644 --- a/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection_2.md +++ b/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection_2.md @@ -1,8 +1,8 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / DocumentedEntityWrappersCollection
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / DocumentedEntityWrappersCollection

    - DocumentedEntityWrappersCollection class: + DocumentedEntityWrappersCollection class:

    @@ -60,11 +60,11 @@ final class DocumentedEntityWrappersCollection implements \IteratorAggregate, \T ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache); +public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher); ``` @@ -89,6 +89,11 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $localObjectCache \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - @@ -102,7 +107,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext ```php @@ -129,7 +134,7 @@ public function count(): int; ```php @@ -167,7 +172,7 @@ public function createAndAddDocumentedEntityWrapper(\BumbleDocGen\Core\Parser\En ```php @@ -188,7 +193,7 @@ public function getDocumentedEntitiesRelations(): array; ```php diff --git a/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection_3.md b/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection_3.md index 75560dd1..54a1ffda 100644 --- a/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection_3.md +++ b/docs/tech/3.renderer/classes/DocumentedEntityWrappersCollection_3.md @@ -1,8 +1,8 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / DocumentedEntityWrappersCollection
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / DocumentedEntityWrappersCollection

    - DocumentedEntityWrappersCollection class: + DocumentedEntityWrappersCollection class:

    @@ -60,11 +60,11 @@ final class DocumentedEntityWrappersCollection implements \IteratorAggregate, \T ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache); +public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher); ``` @@ -89,6 +89,11 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $localObjectCache \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - @@ -102,7 +107,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext ```php @@ -129,7 +134,7 @@ public function count(): int; ```php @@ -167,7 +172,7 @@ public function createAndAddDocumentedEntityWrapper(\BumbleDocGen\Core\Parser\En ```php @@ -188,7 +193,7 @@ public function getDocumentedEntitiesRelations(): array; ```php diff --git a/docs/tech/3.renderer/classes/DrawClassMap.md b/docs/tech/3.renderer/classes/DrawClassMap.md index 488f196a..e586f3df 100644 --- a/docs/tech/3.renderer/classes/DrawClassMap.md +++ b/docs/tech/3.renderer/classes/DrawClassMap.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / DrawClassMap
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / DrawClassMap

    DrawClassMap class: @@ -165,13 +165,13 @@ public function __invoke(\BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEn \DI\NotFoundException
  • - \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
    • + \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
  • \DI\DependencyException
  • - \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException @@ -267,13 +267,13 @@ public function getDirectoryStructure(\BumbleDocGen\LanguageHandler\Php\Parser\E \DI\NotFoundException
  • - \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
    • + \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
  • \DI\DependencyException
  • - \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException diff --git a/docs/tech/3.renderer/classes/DrawDocumentationMenu.md b/docs/tech/3.renderer/classes/DrawDocumentationMenu.md index 05797d8b..4ca60643 100644 --- a/docs/tech/3.renderer/classes/DrawDocumentationMenu.md +++ b/docs/tech/3.renderer/classes/DrawDocumentationMenu.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / DrawDocumentationMenu
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / DrawDocumentationMenu

    DrawDocumentationMenu class: @@ -21,7 +21,7 @@ and all links with this page are recursively collected for it, after which the h See: @@ -196,7 +196,7 @@ public function __invoke(string|null $startPageKey = NULL, int|null $maxDeep = N \DI\DependencyException
  • - \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException diff --git a/docs/tech/3.renderer/classes/DrawDocumentedEntityLink.md b/docs/tech/3.renderer/classes/DrawDocumentedEntityLink.md index 6b475e45..2a87a2aa 100644 --- a/docs/tech/3.renderer/classes/DrawDocumentedEntityLink.md +++ b/docs/tech/3.renderer/classes/DrawDocumentedEntityLink.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / DrawDocumentedEntityLink
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / DrawDocumentedEntityLink

    DrawDocumentedEntityLink class: @@ -169,13 +169,13 @@ public function __invoke(\BumbleDocGen\Core\Parser\Entity\RootEntityInterface $e \DI\NotFoundException
  • - \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
    • + \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
  • \DI\DependencyException
  • - \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException diff --git a/docs/tech/3.renderer/classes/FileGetContents.md b/docs/tech/3.renderer/classes/FileGetContents.md index d00bf38f..751fa10e 100644 --- a/docs/tech/3.renderer/classes/FileGetContents.md +++ b/docs/tech/3.renderer/classes/FileGetContents.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / FileGetContents
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / FileGetContents

    FileGetContents class: diff --git a/docs/tech/3.renderer/classes/FixStrSize.md b/docs/tech/3.renderer/classes/FixStrSize.md index e1b3bd18..10df8270 100644 --- a/docs/tech/3.renderer/classes/FixStrSize.md +++ b/docs/tech/3.renderer/classes/FixStrSize.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / FixStrSize
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / FixStrSize

    FixStrSize class: diff --git a/docs/tech/3.renderer/classes/GeneratePageBreadcrumbs.md b/docs/tech/3.renderer/classes/GeneratePageBreadcrumbs.md index a6ac987e..a52c69b5 100644 --- a/docs/tech/3.renderer/classes/GeneratePageBreadcrumbs.md +++ b/docs/tech/3.renderer/classes/GeneratePageBreadcrumbs.md @@ -1,8 +1,8 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / GeneratePageBreadcrumbs
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / GeneratePageBreadcrumbs

    - GeneratePageBreadcrumbs class: + GeneratePageBreadcrumbs class:

    @@ -67,7 +67,7 @@ final class GeneratePageBreadcrumbs implements \BumbleDocGen\Core\Renderer\Twig\ ```php @@ -114,7 +114,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsH ```php @@ -160,16 +160,22 @@ public function __invoke(string $currentPageTitle, string $templatePath, bool $s Throws: @@ -180,7 +186,7 @@ public function __invoke(string $currentPageTitle, string $templatePath, bool $s ```php @@ -201,7 +207,7 @@ public static function getName(): string; ```php diff --git a/docs/tech/3.renderer/classes/GeneratePageBreadcrumbs_2.md b/docs/tech/3.renderer/classes/GeneratePageBreadcrumbs_2.md index 3ce49e61..b8130200 100644 --- a/docs/tech/3.renderer/classes/GeneratePageBreadcrumbs_2.md +++ b/docs/tech/3.renderer/classes/GeneratePageBreadcrumbs_2.md @@ -1,8 +1,8 @@ - BumbleDocGen / Technical description of the project / Renderer / Documentation structure and breadcrumbs / GeneratePageBreadcrumbs
    + BumbleDocGen / Technical description of the project / Renderer / Documentation structure and breadcrumbs / GeneratePageBreadcrumbs

    - GeneratePageBreadcrumbs class: + GeneratePageBreadcrumbs class:

    @@ -67,7 +67,7 @@ final class GeneratePageBreadcrumbs implements \BumbleDocGen\Core\Renderer\Twig\ ```php @@ -114,7 +114,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsH ```php @@ -160,14 +160,20 @@ public function __invoke(string $currentPageTitle, string $templatePath, bool $s Throws: diff --git a/docs/tech/3.renderer/classes/GetDocumentedEntityUrl_2.md b/docs/tech/3.renderer/classes/GetDocumentedEntityUrl_2.md index 0755e794..06db0cda 100644 --- a/docs/tech/3.renderer/classes/GetDocumentedEntityUrl_2.md +++ b/docs/tech/3.renderer/classes/GetDocumentedEntityUrl_2.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / GetDocumentedEntityUrl
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / GetDocumentedEntityUrl

    GetDocumentedEntityUrl class: @@ -211,13 +211,13 @@ public function __invoke(\BumbleDocGen\Core\Parser\Entity\RootEntityCollection $ \DI\DependencyException
  • - \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
  • \DI\NotFoundException
  • - \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
    • + \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException diff --git a/docs/tech/3.renderer/classes/GetDocumentedEntityUrl_3.md b/docs/tech/3.renderer/classes/GetDocumentedEntityUrl_3.md index b4ed9a18..a593c077 100644 --- a/docs/tech/3.renderer/classes/GetDocumentedEntityUrl_3.md +++ b/docs/tech/3.renderer/classes/GetDocumentedEntityUrl_3.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / GetDocumentedEntityUrl
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / GetDocumentedEntityUrl

    GetDocumentedEntityUrl class: @@ -211,13 +211,13 @@ public function __invoke(\BumbleDocGen\Core\Parser\Entity\RootEntityCollection $ \DI\DependencyException
  • - \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
  • \DI\NotFoundException
  • - \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
    • + \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException diff --git a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException.md b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException.md index a4d50e27..f9aa45e6 100644 --- a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException.md +++ b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / InvalidConfigurationParameterException
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / InvalidConfigurationParameterException

    InvalidConfigurationParameterException class: diff --git a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_2.md b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_2.md index 11f45ac4..3a56a587 100644 --- a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_2.md +++ b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_2.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / InvalidConfigurationParameterException
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / InvalidConfigurationParameterException

    InvalidConfigurationParameterException class: diff --git a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_3.md b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_3.md index 82de65b3..44637b0f 100644 --- a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_3.md +++ b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_3.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / InvalidConfigurationParameterException
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / InvalidConfigurationParameterException

    InvalidConfigurationParameterException class: diff --git a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_4.md b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_4.md index e9c07866..4e84c94a 100644 --- a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_4.md +++ b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_4.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / InvalidConfigurationParameterException
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / InvalidConfigurationParameterException

    InvalidConfigurationParameterException class: diff --git a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_5.md b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_5.md index da299758..1bea4efd 100644 --- a/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_5.md +++ b/docs/tech/3.renderer/classes/InvalidConfigurationParameterException_5.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Documentation structure and breadcrumbs / InvalidConfigurationParameterException
    + BumbleDocGen / Technical description of the project / Renderer / Documentation structure and breadcrumbs / InvalidConfigurationParameterException

    InvalidConfigurationParameterException class: diff --git a/docs/tech/3.renderer/classes/LanguageHandlerInterface.md b/docs/tech/3.renderer/classes/LanguageHandlerInterface.md index 4dbea3fa..f2ebf676 100644 --- a/docs/tech/3.renderer/classes/LanguageHandlerInterface.md +++ b/docs/tech/3.renderer/classes/LanguageHandlerInterface.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / LanguageHandlerInterface
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / LanguageHandlerInterface

    LanguageHandlerInterface class: diff --git a/docs/tech/3.renderer/classes/LoadPluginsContent.md b/docs/tech/3.renderer/classes/LoadPluginsContent.md index de00f64c..ceaccca5 100644 --- a/docs/tech/3.renderer/classes/LoadPluginsContent.md +++ b/docs/tech/3.renderer/classes/LoadPluginsContent.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / LoadPluginsContent
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / LoadPluginsContent

    LoadPluginsContent class: diff --git a/docs/tech/3.renderer/classes/PageHtmlLinkerPlugin.md b/docs/tech/3.renderer/classes/PageHtmlLinkerPlugin.md index 40a6be83..8a27c1d5 100644 --- a/docs/tech/3.renderer/classes/PageHtmlLinkerPlugin.md +++ b/docs/tech/3.renderer/classes/PageHtmlLinkerPlugin.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / PageHtmlLinkerPlugin
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / PageHtmlLinkerPlugin

    PageHtmlLinkerPlugin class: @@ -170,10 +170,10 @@ public function beforeCreatingDocFile(\BumbleDocGen\Core\Plugin\Event\Renderer\B \DI\DependencyException
  • - \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
    • + \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
  • - \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException diff --git a/docs/tech/3.renderer/classes/PregMatch.md b/docs/tech/3.renderer/classes/PregMatch.md index 87230b31..8594dfd6 100644 --- a/docs/tech/3.renderer/classes/PregMatch.md +++ b/docs/tech/3.renderer/classes/PregMatch.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / PregMatch
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / PregMatch

    PregMatch class: diff --git a/docs/tech/3.renderer/classes/PrepareSourceLink.md b/docs/tech/3.renderer/classes/PrepareSourceLink.md index f9c3640c..479ebd63 100644 --- a/docs/tech/3.renderer/classes/PrepareSourceLink.md +++ b/docs/tech/3.renderer/classes/PrepareSourceLink.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / PrepareSourceLink
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / PrepareSourceLink

    PrepareSourceLink class: diff --git a/docs/tech/3.renderer/classes/PrintEntityCollectionAsList.md b/docs/tech/3.renderer/classes/PrintEntityCollectionAsList.md index 7b122b2b..c03d19cf 100644 --- a/docs/tech/3.renderer/classes/PrintEntityCollectionAsList.md +++ b/docs/tech/3.renderer/classes/PrintEntityCollectionAsList.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / PrintEntityCollectionAsList
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / PrintEntityCollectionAsList

    PrintEntityCollectionAsList class: @@ -168,7 +168,7 @@ public function __invoke(\BumbleDocGen\Core\Parser\Entity\RootEntityCollection $ Throws: diff --git a/docs/tech/3.renderer/classes/Quotemeta.md b/docs/tech/3.renderer/classes/Quotemeta.md index c4ca5fbc..7e722aff 100644 --- a/docs/tech/3.renderer/classes/Quotemeta.md +++ b/docs/tech/3.renderer/classes/Quotemeta.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / Quotemeta
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / Quotemeta

    Quotemeta class: diff --git a/docs/tech/3.renderer/classes/ReflectionException.md b/docs/tech/3.renderer/classes/ReflectionException.md index 4396c3b1..6abd0a00 100644 --- a/docs/tech/3.renderer/classes/ReflectionException.md +++ b/docs/tech/3.renderer/classes/ReflectionException.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / ReflectionException
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / ReflectionException

    ReflectionException class: diff --git a/docs/tech/3.renderer/classes/ReflectionException_2.md b/docs/tech/3.renderer/classes/ReflectionException_2.md index fb44a626..6fdbe101 100644 --- a/docs/tech/3.renderer/classes/ReflectionException_2.md +++ b/docs/tech/3.renderer/classes/ReflectionException_2.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / ReflectionException
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / ReflectionException

    ReflectionException class: diff --git a/docs/tech/3.renderer/classes/ReflectionException_3.md b/docs/tech/3.renderer/classes/ReflectionException_3.md index 9f952930..29026f64 100644 --- a/docs/tech/3.renderer/classes/ReflectionException_3.md +++ b/docs/tech/3.renderer/classes/ReflectionException_3.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / ReflectionException
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / ReflectionException

    ReflectionException class: diff --git a/docs/tech/3.renderer/classes/ReflectionException_4.md b/docs/tech/3.renderer/classes/ReflectionException_4.md index e7361253..cc6d9b26 100644 --- a/docs/tech/3.renderer/classes/ReflectionException_4.md +++ b/docs/tech/3.renderer/classes/ReflectionException_4.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / ReflectionException
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / ReflectionException

    ReflectionException class: diff --git a/docs/tech/3.renderer/classes/RemoveLineBrakes.md b/docs/tech/3.renderer/classes/RemoveLineBrakes.md index e1a7b13a..237cbdee 100644 --- a/docs/tech/3.renderer/classes/RemoveLineBrakes.md +++ b/docs/tech/3.renderer/classes/RemoveLineBrakes.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / RemoveLineBrakes
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / RemoveLineBrakes

    RemoveLineBrakes class: diff --git a/docs/tech/3.renderer/classes/RendererContext.md b/docs/tech/3.renderer/classes/RendererContext.md index 4d035ed1..2938cd52 100644 --- a/docs/tech/3.renderer/classes/RendererContext.md +++ b/docs/tech/3.renderer/classes/RendererContext.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / RendererContext
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / RendererContext

    RendererContext class: diff --git a/docs/tech/3.renderer/classes/RendererContext_2.md b/docs/tech/3.renderer/classes/RendererContext_2.md index 4522cdb9..b75cf640 100644 --- a/docs/tech/3.renderer/classes/RendererContext_2.md +++ b/docs/tech/3.renderer/classes/RendererContext_2.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates / RendererContext
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / RendererContext

    RendererContext class: diff --git a/docs/tech/3.renderer/classes/RendererContext_3.md b/docs/tech/3.renderer/classes/RendererContext_3.md index e1f353e9..ab188eda 100644 --- a/docs/tech/3.renderer/classes/RendererContext_3.md +++ b/docs/tech/3.renderer/classes/RendererContext_3.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / RendererContext
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / RendererContext

    RendererContext class: diff --git a/docs/tech/3.renderer/classes/RootEntityCollection.md b/docs/tech/3.renderer/classes/RootEntityCollection.md index 68eabdcb..a14453ba 100644 --- a/docs/tech/3.renderer/classes/RootEntityCollection.md +++ b/docs/tech/3.renderer/classes/RootEntityCollection.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / RootEntityCollection
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / RootEntityCollection

    RootEntityCollection class: diff --git a/docs/tech/3.renderer/classes/RootEntityInterface.md b/docs/tech/3.renderer/classes/RootEntityInterface.md index 2d3df749..7d97a5c6 100644 --- a/docs/tech/3.renderer/classes/RootEntityInterface.md +++ b/docs/tech/3.renderer/classes/RootEntityInterface.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template functions / RootEntityInterface
    + BumbleDocGen / Technical description of the project / Renderer / Template functions / RootEntityInterface

    RootEntityInterface class: diff --git a/docs/tech/3.renderer/classes/RootEntityInterface_2.md b/docs/tech/3.renderer/classes/RootEntityInterface_2.md index 0f674832..7badee12 100644 --- a/docs/tech/3.renderer/classes/RootEntityInterface_2.md +++ b/docs/tech/3.renderer/classes/RootEntityInterface_2.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / RootEntityInterface
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables / RootEntityInterface

    RootEntityInterface class: diff --git a/docs/tech/3.renderer/classes/StrTypeToUrl.md b/docs/tech/3.renderer/classes/StrTypeToUrl.md index 8f4b2be9..a59cf956 100644 --- a/docs/tech/3.renderer/classes/StrTypeToUrl.md +++ b/docs/tech/3.renderer/classes/StrTypeToUrl.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / StrTypeToUrl
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / StrTypeToUrl

    StrTypeToUrl class: @@ -176,13 +176,13 @@ public function __invoke(string $text, \BumbleDocGen\Core\Parser\Entity\RootEnti \DI\NotFoundException
  • - \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
    • + \BumbleDocGen\LanguageHandler\Php\Parser\Entity\Exception\ReflectionException
  • \DI\DependencyException
  • - \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException diff --git a/docs/tech/3.renderer/classes/TextToCodeBlock.md b/docs/tech/3.renderer/classes/TextToCodeBlock.md index 69229bd3..e24d5d55 100644 --- a/docs/tech/3.renderer/classes/TextToCodeBlock.md +++ b/docs/tech/3.renderer/classes/TextToCodeBlock.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / TextToCodeBlock
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / TextToCodeBlock

    TextToCodeBlock class: diff --git a/docs/tech/3.renderer/classes/TextToHeading.md b/docs/tech/3.renderer/classes/TextToHeading.md index fe1ea5ce..503e117a 100644 --- a/docs/tech/3.renderer/classes/TextToHeading.md +++ b/docs/tech/3.renderer/classes/TextToHeading.md @@ -1,5 +1,5 @@ - BumbleDocGen / Technical description of the project / Renderer / Template filters / TextToHeading
    + BumbleDocGen / Technical description of the project / Renderer / Template filters / TextToHeading

    TextToHeading class: diff --git a/docs/tech/3.renderer/readme.md b/docs/tech/3.renderer/readme.md index 275c4b7b..cc4c5c24 100644 --- a/docs/tech/3.renderer/readme.md +++ b/docs/tech/3.renderer/readme.md @@ -10,7 +10,7 @@ We use twig to process templates.

    More detailed description of renderer components

    - +

    Starting the rendering process

    @@ -60,4 +60,4 @@ This process is presented in the form of a diagram below.
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/3.renderer/templatesDynamicBlocks.md b/docs/tech/3.renderer/templatesDynamicBlocks.md index b3f8bf98..ee997fe9 100644 --- a/docs/tech/3.renderer/templatesDynamicBlocks.md +++ b/docs/tech/3.renderer/templatesDynamicBlocks.md @@ -1,10 +1,10 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates dynamic blocks
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates dynamic blocks

    Templates dynamic blocks

    There are several ways to create dynamic blocks in templates. -* First of all, these are custom twig functions and filters. +* First of all, these are custom twig functions and filters. You can use the built-in functions and filters or add your own, so you can implement any logic for generating dynamically changing content. ```twig @@ -26,4 +26,4 @@ You can use the built-in functions and filters or add your own, so you can imple
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/3.renderer/templatesLinking.md b/docs/tech/3.renderer/templatesLinking.md index a7b16b7b..50213b4e 100644 --- a/docs/tech/3.renderer/templatesLinking.md +++ b/docs/tech/3.renderer/templatesLinking.md @@ -1,4 +1,4 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Linking templates

    Linking templates

    @@ -22,9 +22,9 @@ will be replaced with this link: The second way to relink templates is to generate links through functions. -There are a number of functions that allow you to get a link to an entity, for example GetDocumentedEntityUrl, and there are also functions for getting a link to other documents, for example GetDocumentationPageUrl. +There are a number of functions that allow you to get a link to an entity, for example GetDocumentedEntityUrl, and there are also functions for getting a link to other documents, for example GetDocumentationPageUrl. You can also implement your own functions for relinking if necessary.
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/3.renderer/templatesVariables.md b/docs/tech/3.renderer/templatesVariables.md index 8aa1ecb1..c84cf918 100644 --- a/docs/tech/3.renderer/templatesVariables.md +++ b/docs/tech/3.renderer/templatesVariables.md @@ -1,4 +1,4 @@ - BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables
    + BumbleDocGen / Technical description of the project / Renderer / How to create documentation templates? / Templates variables

    Templates variables

    @@ -6,9 +6,9 @@ There are several variables available in each processed template. 1) Firstly, these are built-in twig variables, for example `_self`, which returns the path to the processed template. -2) Secondly, variables with collections of processed programming languages are available in the template (see LanguageHandlerInterface). For example, when processing a PHP project collection, a collection ClassEntityCollection will be available in the template under the name phpClassEntityCollection +2) Secondly, variables with collections of processed programming languages are available in the template (see LanguageHandlerInterface). For example, when processing a PHP project collection, a collection ClassEntityCollection will be available in the template under the name phpClassEntityCollection
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/classes/AfterRenderingEntities.md b/docs/tech/4.pluginSystem/classes/AfterRenderingEntities.md new file mode 100644 index 00000000..ee57fae3 --- /dev/null +++ b/docs/tech/4.pluginSystem/classes/AfterRenderingEntities.md @@ -0,0 +1,92 @@ + + BumbleDocGen / Technical description of the project / Plugin system / AfterRenderingEntities
    + +

    + AfterRenderingEntities class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class AfterRenderingEntities extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    Event is the base class for classes containing event data.
    + + + + + + + +

    Methods:

    + +
      +
    1. + isPropagationStopped + - Is propagation stopped?
      2. +
    2. + stopPropagation + - Stops the propagation of the event to further event listeners.
      3. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/classes/BeforeRenderingDocFiles.md b/docs/tech/4.pluginSystem/classes/BeforeRenderingDocFiles.md new file mode 100644 index 00000000..10df4a78 --- /dev/null +++ b/docs/tech/4.pluginSystem/classes/BeforeRenderingDocFiles.md @@ -0,0 +1,92 @@ + + BumbleDocGen / Technical description of the project / Plugin system / BeforeRenderingDocFiles
    + +

    + BeforeRenderingDocFiles class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class BeforeRenderingDocFiles extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    The event occurs before the main documents begin rendering
    + + + + + + + +

    Methods:

    + +
      +
    1. + isPropagationStopped + - Is propagation stopped?
      2. +
    2. + stopPropagation + - Stops the propagation of the event to further event listeners.
      3. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/classes/BeforeRenderingEntities.md b/docs/tech/4.pluginSystem/classes/BeforeRenderingEntities.md new file mode 100644 index 00000000..a57268a7 --- /dev/null +++ b/docs/tech/4.pluginSystem/classes/BeforeRenderingEntities.md @@ -0,0 +1,92 @@ + + BumbleDocGen / Technical description of the project / Plugin system / BeforeRenderingEntities
    + +

    + BeforeRenderingEntities class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class BeforeRenderingEntities extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    The event occurs before the rendering of entity documents begins, after the main documents have been created
    + + + + + + + +

    Methods:

    + +
      +
    1. + isPropagationStopped + - Is propagation stopped?
      2. +
    2. + stopPropagation + - Stops the propagation of the event to further event listeners.
      3. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/classes/EntityDocUnifiedPlacePlugin.md b/docs/tech/4.pluginSystem/classes/EntityDocUnifiedPlacePlugin.md new file mode 100644 index 00000000..f1b12b32 --- /dev/null +++ b/docs/tech/4.pluginSystem/classes/EntityDocUnifiedPlacePlugin.md @@ -0,0 +1,196 @@ + + BumbleDocGen / Technical description of the project / Plugin system / EntityDocUnifiedPlacePlugin
    + +

    + EntityDocUnifiedPlacePlugin class: +

    + + + + + +```php +namespace BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace; + +final class EntityDocUnifiedPlacePlugin implements \BumbleDocGen\Core\Plugin\PluginInterface, \Symfony\Component\EventDispatcher\EventSubscriberInterface +``` + +
    This plugin changes the algorithm for saving entity documents. The standard system stores each file +in a directory next to the file where it was requested. This behavior changes and all documents are saved +in a separate directory structure, so they are not duplicated.
    + + + + + + + +

    Methods:

    + +
      +
    1. + getSubscribedEvents + - Returns an array of event names this subscriber wants to listen to.
      2. +
    2. + onCreateDocumentedEntityWrapper +
      3. +
    3. + onGetProjectTemplatesDirs +
      4. +
    4. + onGetTemplatePathByRelativeDocPath +
      5. +
    + + +

    Constants:

    + + + + + + +

    Method details:

    + +
    + + + +```php +public static function getSubscribedEvents(): array; +``` + +
    Returns an array of event names this subscriber wants to listen to.
    + +Parameters: not specified + +Return value: array + + +
    +
    +
    + + + +```php +public function onCreateDocumentedEntityWrapper(\BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateDocumentedEntityWrapper $event): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $event\BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateDocumentedEntityWrapper-
    + +Return value: void + + +
    +
    +
    + + + +```php +public function onGetProjectTemplatesDirs(\BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs $event): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $event\BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs-
    + +Return value: void + + +
    +
    +
    + + + +```php +public function onGetTemplatePathByRelativeDocPath(\BumbleDocGen\Core\Plugin\Event\Renderer\OnGetTemplatePathByRelativeDocPath $event): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $event\BumbleDocGen\Core\Plugin\Event\Renderer\OnGetTemplatePathByRelativeDocPath-
    + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/classes/LastPageCommitter.md b/docs/tech/4.pluginSystem/classes/LastPageCommitter.md index fc4d781c..8bdd4747 100644 --- a/docs/tech/4.pluginSystem/classes/LastPageCommitter.md +++ b/docs/tech/4.pluginSystem/classes/LastPageCommitter.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Plugin system / LastPageCommitter

    - LastPageCommitter class: + LastPageCommitter class:

    @@ -54,7 +54,7 @@ final class LastPageCommitter implements \BumbleDocGen\Core\Plugin\PluginInterfa ```php @@ -96,7 +96,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext ```php @@ -127,13 +127,6 @@ public function beforeCreatingDocFile(\BumbleDocGen\Core\Plugin\Event\Renderer\B Return value: void -Throws: - -
    @@ -141,7 +134,7 @@ public function beforeCreatingDocFile(\BumbleDocGen\Core\Plugin\Event\Renderer\B ```php diff --git a/docs/tech/4.pluginSystem/classes/OnCreateDocumentedEntityWrapper.md b/docs/tech/4.pluginSystem/classes/OnCreateDocumentedEntityWrapper.md new file mode 100644 index 00000000..300a593b --- /dev/null +++ b/docs/tech/4.pluginSystem/classes/OnCreateDocumentedEntityWrapper.md @@ -0,0 +1,160 @@ + + BumbleDocGen / Technical description of the project / Plugin system / OnCreateDocumentedEntityWrapper
    + +

    + OnCreateDocumentedEntityWrapper class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class OnCreateDocumentedEntityWrapper extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    The event occurs when an entity is added to the list for documentation
    + + + + + + +

    Initialization methods:

    + +
      +
    1. + __construct +
      2. +
    + +

    Methods:

    + +
      +
    1. + getDocumentedEntityWrapper +
      2. +
    2. + isPropagationStopped + - Is propagation stopped?
      3. +
    3. + stopPropagation + - Stops the propagation of the event to further event listeners.
      4. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper $documentedEntityWrapper); +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $documentedEntityWrapper\BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper-
    + + + +
    +
    +
    + + + +```php +public function getDocumentedEntityWrapper(): \BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper; +``` + + + +Parameters: not specified + +Return value: \BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/classes/OnGetProjectTemplatesDirs.md b/docs/tech/4.pluginSystem/classes/OnGetProjectTemplatesDirs.md new file mode 100644 index 00000000..889c3574 --- /dev/null +++ b/docs/tech/4.pluginSystem/classes/OnGetProjectTemplatesDirs.md @@ -0,0 +1,201 @@ + + BumbleDocGen / Technical description of the project / Plugin system / OnGetProjectTemplatesDirs
    + +

    + OnGetProjectTemplatesDirs class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class OnGetProjectTemplatesDirs extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    This event occurs when all directories containing document templates are retrieved
    + + + + + + +

    Initialization methods:

    + +
      +
    1. + __construct +
      2. +
    + +

    Methods:

    + +
      +
    1. + addTemplatesDir +
      2. +
    2. + getTemplatesDirs +
      3. +
    3. + isPropagationStopped + - Is propagation stopped?
      4. +
    4. + stopPropagation + - Stops the propagation of the event to further event listeners.
      5. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +public function __construct(array $templatesDirs); +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $templatesDirsarray-
    + + + +
    +
    +
    + + + +```php +public function addTemplatesDir(string $dirName): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $dirNamestring-
    + +Return value: void + + +
    +
    +
    + + + +```php +public function getTemplatesDirs(): array; +``` + + + +Parameters: not specified + +Return value: array + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/classes/OnGetTemplatePathByRelativeDocPath.md b/docs/tech/4.pluginSystem/classes/OnGetTemplatePathByRelativeDocPath.md new file mode 100644 index 00000000..ec4c765d --- /dev/null +++ b/docs/tech/4.pluginSystem/classes/OnGetTemplatePathByRelativeDocPath.md @@ -0,0 +1,225 @@ + + BumbleDocGen / Technical description of the project / Plugin system / OnGetTemplatePathByRelativeDocPath
    + +

    + OnGetTemplatePathByRelativeDocPath class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class OnGetTemplatePathByRelativeDocPath extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    The event occurs when the path to the template file is obtained relative to the path to the document
    + + + + + + +

    Initialization methods:

    + +
      +
    1. + __construct +
      2. +
    + +

    Methods:

    + +
      +
    1. + getCustomTemplateFilePath +
      2. +
    2. + getTemplateName +
      3. +
    3. + isPropagationStopped + - Is propagation stopped?
      4. +
    4. + setCustomTemplateFilePath +
      5. +
    5. + stopPropagation + - Stops the propagation of the event to further event listeners.
      6. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +public function __construct(string $templateName); +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $templateNamestring-
    + + + +
    +
    +
    + + + +```php +public function getCustomTemplateFilePath(): string|null; +``` + + + +Parameters: not specified + +Return value: string | null + + +
    +
    +
    + + + +```php +public function getTemplateName(): string; +``` + + + +Parameters: not specified + +Return value: string + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +public function setCustomTemplateFilePath(string|null $customTemplateFilePath): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $customTemplateFilePathstring | null-
    + +Return value: void + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/classes/OnGettingResourceLink.md b/docs/tech/4.pluginSystem/classes/OnGettingResourceLink.md index ed006392..c8ede590 100644 --- a/docs/tech/4.pluginSystem/classes/OnGettingResourceLink.md +++ b/docs/tech/4.pluginSystem/classes/OnGettingResourceLink.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Plugin system / OnGettingResourceLink

    - OnGettingResourceLink class: + OnGettingResourceLink class:

    @@ -15,7 +15,7 @@ namespace BumbleDocGen\Core\Plugin\Event\Renderer; final class OnGettingResourceLink extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface ``` -
    Event is the base class for classes containing event data.
    +
    Event occurs when a reference to an entity (resource) is received
    @@ -63,7 +63,7 @@ final class OnGettingResourceLink extends \Symfony\Contracts\EventDispatcher\Eve ```php @@ -100,7 +100,7 @@ public function __construct(string $resourceName); ```php @@ -121,7 +121,7 @@ public function getResourceName(): string; ```php @@ -165,7 +165,7 @@ public function isPropagationStopped(): bool; ```php diff --git a/docs/tech/4.pluginSystem/readme.md b/docs/tech/4.pluginSystem/readme.md index 594b5440..c8a633e4 100644 --- a/docs/tech/4.pluginSystem/readme.md +++ b/docs/tech/4.pluginSystem/readme.md @@ -149,11 +149,25 @@ Plugins for any programming languages work regardless of which language handler Adding links to the documentation of PHP classes in the \Twig namespace + + EntityDocUnifiedPlacePlugin + PHP + + + + This plugin changes the algorithm for saving entity documents. The standard system stores each file +in a directory next to the file where it was requested. This behavior changes and all documents are saved +in a separate directory structure, so they are not duplicated. +

    Default events

    - +

    Adding a new plugin

    @@ -192,4 +206,4 @@ plugins:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/classes/AfterRenderingEntities.md b/docs/tech/classes/AfterRenderingEntities.md new file mode 100644 index 00000000..e8faf6a2 --- /dev/null +++ b/docs/tech/classes/AfterRenderingEntities.md @@ -0,0 +1,92 @@ + + BumbleDocGen / Technical description of the project / Class map / AfterRenderingEntities
    + +

    + AfterRenderingEntities class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class AfterRenderingEntities extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    Event is the base class for classes containing event data.
    + + + + + + + +

    Methods:

    + +
      +
    1. + isPropagationStopped + - Is propagation stopped?
      2. +
    2. + stopPropagation + - Stops the propagation of the event to further event listeners.
      3. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/classes/BeforeRenderingDocFiles.md b/docs/tech/classes/BeforeRenderingDocFiles.md new file mode 100644 index 00000000..72b44ec5 --- /dev/null +++ b/docs/tech/classes/BeforeRenderingDocFiles.md @@ -0,0 +1,92 @@ + + BumbleDocGen / Technical description of the project / Class map / BeforeRenderingDocFiles
    + +

    + BeforeRenderingDocFiles class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class BeforeRenderingDocFiles extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    The event occurs before the main documents begin rendering
    + + + + + + + +

    Methods:

    + +
      +
    1. + isPropagationStopped + - Is propagation stopped?
      2. +
    2. + stopPropagation + - Stops the propagation of the event to further event listeners.
      3. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/classes/BeforeRenderingEntities.md b/docs/tech/classes/BeforeRenderingEntities.md new file mode 100644 index 00000000..689d8eb5 --- /dev/null +++ b/docs/tech/classes/BeforeRenderingEntities.md @@ -0,0 +1,92 @@ + + BumbleDocGen / Technical description of the project / Class map / BeforeRenderingEntities
    + +

    + BeforeRenderingEntities class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class BeforeRenderingEntities extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    The event occurs before the rendering of entity documents begins, after the main documents have been created
    + + + + + + + +

    Methods:

    + +
      +
    1. + isPropagationStopped + - Is propagation stopped?
      2. +
    2. + stopPropagation + - Stops the propagation of the event to further event listeners.
      3. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/classes/BreadcrumbsHelper.md b/docs/tech/classes/BreadcrumbsHelper.md index 5daddcdf..0ed6be72 100644 --- a/docs/tech/classes/BreadcrumbsHelper.md +++ b/docs/tech/classes/BreadcrumbsHelper.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Class map / BreadcrumbsHelper

    - BreadcrumbsHelper class: + BreadcrumbsHelper class:

    @@ -67,7 +67,7 @@ final class BreadcrumbsHelper @@ -82,11 +82,11 @@ final class BreadcrumbsHelper ```php -public function __construct(\BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsTwigEnvironment $breadcrumbsTwig, string $prevPageNameTemplate = \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsHelper::DEFAULT_PREV_PAGE_NAME_TEMPLATE); +public function __construct(\BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsTwigEnvironment $breadcrumbsTwig, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher, string $prevPageNameTemplate = \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsHelper::DEFAULT_PREV_PAGE_NAME_TEMPLATE); ``` @@ -116,6 +116,11 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf $breadcrumbsTwig \BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsTwigEnvironment - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - $prevPageNameTemplate @@ -134,7 +139,7 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf ```php @@ -168,7 +173,7 @@ public function getAllPageLinks(): array; ```php @@ -224,11 +229,11 @@ public function getBreadcrumbs(string $filePatch, bool $fromCurrent = true): arr ```php -public function getBreadcrumbsForTemplates(string $templateFilePatch, bool $fromCurrent = true): array; +public function getBreadcrumbsForTemplates(string $filePatch, bool $fromCurrent = true): array; ``` @@ -245,7 +250,7 @@ public function getBreadcrumbsForTemplates(string $templateFilePatch, bool $from - $templateFilePatch + $filePatch string - @@ -280,7 +285,7 @@ public function getBreadcrumbsForTemplates(string $templateFilePatch, bool $from ```php @@ -331,7 +336,7 @@ public function getPageDataByKey(string $key): array|null; ```php @@ -382,7 +387,7 @@ public function getPageDocFileByKey(string $key): string|null; ```php @@ -433,7 +438,7 @@ public function getPageLinkByKey(string $key): string|null; ```php @@ -478,7 +483,7 @@ public function getTemplateLinkKey(string $templateName): string|null; ```php @@ -534,7 +539,7 @@ $breadcrumbsHelper->getTemplateTitle() == 'Some template title'; // is true ```php diff --git a/docs/tech/classes/ClassEntity.md b/docs/tech/classes/ClassEntity.md index d13e3ecf..7ba93dad 100644 --- a/docs/tech/classes/ClassEntity.md +++ b/docs/tech/classes/ClassEntity.md @@ -228,6 +228,9 @@ class ClassEntity extends \BumbleDocGen\LanguageHandler\Php\Parser\Entity\BaseEn
  • implementsInterface
    • +
  • + isAbstract +
  • isClassLoad
    • @@ -368,7 +371,7 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf ```php @@ -636,7 +639,7 @@ public function getCasesNames(): array; ```php @@ -780,7 +783,7 @@ public function getConstantEntityCollection(): \BumbleDocGen\LanguageHandler\Php ```php @@ -1042,7 +1045,7 @@ public function getDocNote(): string; ```php @@ -2207,7 +2210,7 @@ public function hasAnnotationKey(string $annotationKey): bool; ```php @@ -2308,7 +2311,7 @@ public function hasExamples(): bool; ```php @@ -2356,7 +2359,7 @@ public function hasMethod(string $method): bool; ```php @@ -2404,7 +2407,7 @@ public function hasParentClass(string $parentClassName): bool; ```php @@ -2506,7 +2509,7 @@ public function hasTraits(): bool; ```php @@ -2537,6 +2540,37 @@ public function implementsInterface(string $interfaceName): bool; Return value: bool +Throws: + + + +
    +
    + + + +```php +public function isAbstract(): bool; +``` + + + +Parameters: not specified + +Return value: bool + + Throws:
    @@ -626,7 +622,7 @@ public function getEntityCollectionName(): string; ```php @@ -759,10 +755,41 @@ public function getLoadedOrCreateNew(string $objectName, bool $withAddClassEntit
    + + +```php +public function getOnlyAbstractClasses(): \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection; +``` + + + +Parameters: not specified + +Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection + + +Throws: + + +
    +
    +
    + ```php @@ -793,7 +820,7 @@ public function getOnlyInstantiable(): \BumbleDocGen\LanguageHandler\Php\Parser\ ```php @@ -802,6 +829,37 @@ public function getOnlyInterfaces(): \BumbleDocGen\LanguageHandler\Php\Parser\En +Parameters: not specified + +Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection + + +Throws: + + +
    +
    +
    + + + +```php +public function getOnlyTraits(): \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection; +``` + + + Parameters: not specified Return value: \BumbleDocGen\LanguageHandler\Php\Parser\Entity\ClassEntityCollection @@ -908,7 +966,7 @@ public function has(string $objectName): bool; ```php diff --git a/docs/tech/classes/DocumentedEntityWrapper.md b/docs/tech/classes/DocumentedEntityWrapper.md index 5dbfc8b3..0ef5de59 100644 --- a/docs/tech/classes/DocumentedEntityWrapper.md +++ b/docs/tech/classes/DocumentedEntityWrapper.md @@ -48,12 +48,15 @@ final class DocumentedEntityWrapper
  • getFileName - The name of the file to be generated
    • -
  • - getInitiatorFilePath -
  • getKey - Get document key
    • +
  • + getParentDocFilePath +
    • +
  • + setParentDocFilePath +
    • @@ -73,7 +76,7 @@ final class DocumentedEntityWrapper ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $initiatorFilePath); +public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransformableEntityInterface $documentTransformableEntity, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, string $parentDocFilePath); ``` @@ -100,7 +103,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentTransfor - - $initiatorFilePath + $parentDocFilePath string The file in which the documentation of the entity was requested @@ -219,16 +222,16 @@ public function getFileName(): string;
    ```php -public function getInitiatorFilePath(): string; +public function getKey(): string; ``` - +
    Get document key
    Parameters: not specified @@ -240,22 +243,60 @@ public function getInitiatorFilePath(): string;
    ```php -public function getKey(): string; +public function getParentDocFilePath(): string; ``` -
    Get document key
    + Parameters: not specified Return value: string +
    +
    +
    + + + +```php +public function setParentDocFilePath(string $parentDocFilePath): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $parentDocFilePathstring-
    + +Return value: void + +
    diff --git a/docs/tech/classes/DocumentedEntityWrappersCollection.md b/docs/tech/classes/DocumentedEntityWrappersCollection.md index d535f6de..1d16d4c1 100644 --- a/docs/tech/classes/DocumentedEntityWrappersCollection.md +++ b/docs/tech/classes/DocumentedEntityWrappersCollection.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Class map / DocumentedEntityWrappersCollection

    - DocumentedEntityWrappersCollection class: + DocumentedEntityWrappersCollection class:

    @@ -60,11 +60,11 @@ final class DocumentedEntityWrappersCollection implements \IteratorAggregate, \T ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache); +public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher); ``` @@ -89,6 +89,11 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $localObjectCache \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - @@ -102,7 +107,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext ```php @@ -129,7 +134,7 @@ public function count(): int; ```php @@ -167,7 +172,7 @@ public function createAndAddDocumentedEntityWrapper(\BumbleDocGen\Core\Parser\En ```php @@ -188,7 +193,7 @@ public function getDocumentedEntitiesRelations(): array; ```php diff --git a/docs/tech/classes/EntityDocUnifiedPlacePlugin.md b/docs/tech/classes/EntityDocUnifiedPlacePlugin.md new file mode 100644 index 00000000..d4b0f3d0 --- /dev/null +++ b/docs/tech/classes/EntityDocUnifiedPlacePlugin.md @@ -0,0 +1,196 @@ + + BumbleDocGen / Technical description of the project / Class map / EntityDocUnifiedPlacePlugin
    + +

    + EntityDocUnifiedPlacePlugin class: +

    + + + + + +```php +namespace BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace; + +final class EntityDocUnifiedPlacePlugin implements \BumbleDocGen\Core\Plugin\PluginInterface, \Symfony\Component\EventDispatcher\EventSubscriberInterface +``` + +
    This plugin changes the algorithm for saving entity documents. The standard system stores each file +in a directory next to the file where it was requested. This behavior changes and all documents are saved +in a separate directory structure, so they are not duplicated.
    + + + + + + + +

    Methods:

    + +
      +
    1. + getSubscribedEvents + - Returns an array of event names this subscriber wants to listen to.
      2. +
    2. + onCreateDocumentedEntityWrapper +
      3. +
    3. + onGetProjectTemplatesDirs +
      4. +
    4. + onGetTemplatePathByRelativeDocPath +
      5. +
    + + +

    Constants:

    + + + + + + +

    Method details:

    + +
    + + + +```php +public static function getSubscribedEvents(): array; +``` + +
    Returns an array of event names this subscriber wants to listen to.
    + +Parameters: not specified + +Return value: array + + +
    +
    +
    + + + +```php +public function onCreateDocumentedEntityWrapper(\BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateDocumentedEntityWrapper $event): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $event\BumbleDocGen\Core\Plugin\Event\Renderer\OnCreateDocumentedEntityWrapper-
    + +Return value: void + + +
    +
    +
    + + + +```php +public function onGetProjectTemplatesDirs(\BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs $event): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $event\BumbleDocGen\Core\Plugin\Event\Renderer\OnGetProjectTemplatesDirs-
    + +Return value: void + + +
    +
    +
    + + + +```php +public function onGetTemplatePathByRelativeDocPath(\BumbleDocGen\Core\Plugin\Event\Renderer\OnGetTemplatePathByRelativeDocPath $event): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $event\BumbleDocGen\Core\Plugin\Event\Renderer\OnGetTemplatePathByRelativeDocPath-
    + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/classes/GeneratePageBreadcrumbs.md b/docs/tech/classes/GeneratePageBreadcrumbs.md index 40242f1e..8aa0fd06 100644 --- a/docs/tech/classes/GeneratePageBreadcrumbs.md +++ b/docs/tech/classes/GeneratePageBreadcrumbs.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Class map / GeneratePageBreadcrumbs

    - GeneratePageBreadcrumbs class: + GeneratePageBreadcrumbs class:

    @@ -67,7 +67,7 @@ final class GeneratePageBreadcrumbs implements \BumbleDocGen\Core\Renderer\Twig\ ```php @@ -114,7 +114,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Breadcrumbs\BreadcrumbsH ```php @@ -160,14 +160,20 @@ public function __invoke(string $currentPageTitle, string $templatePath, bool $s Throws:
    @@ -141,7 +134,7 @@ public function beforeCreatingDocFile(\BumbleDocGen\Core\Plugin\Event\Renderer\B ```php diff --git a/docs/tech/classes/MainTwigEnvironment.md b/docs/tech/classes/MainTwigEnvironment.md index 1d23e8cb..e358eaee 100644 --- a/docs/tech/classes/MainTwigEnvironment.md +++ b/docs/tech/classes/MainTwigEnvironment.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Class map / MainTwigEnvironment

    - MainTwigEnvironment class: + MainTwigEnvironment class:

    @@ -55,7 +55,7 @@ final class MainTwigEnvironment ```php -public function __construct(\BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Renderer\Twig\MainExtension $mainExtension); +public function __construct(\BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Renderer\Twig\MainExtension $mainExtension, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher); ``` @@ -80,19 +80,17 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf $mainExtension \BumbleDocGen\Core\Renderer\Twig\MainExtension - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - -Throws: - -
    @@ -100,7 +98,7 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf ```php @@ -147,6 +145,9 @@ public function render(mixed $name, array $context = [ ]): string;
  • \Twig\Error\LoaderError
    • +
  • + \BumbleDocGen\Core\Configuration\Exception\InvalidConfigurationParameterException
    • +
    diff --git a/docs/tech/classes/OnCreateDocumentedEntityWrapper.md b/docs/tech/classes/OnCreateDocumentedEntityWrapper.md new file mode 100644 index 00000000..7490327c --- /dev/null +++ b/docs/tech/classes/OnCreateDocumentedEntityWrapper.md @@ -0,0 +1,160 @@ + + BumbleDocGen / Technical description of the project / Class map / OnCreateDocumentedEntityWrapper
    + +

    + OnCreateDocumentedEntityWrapper class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class OnCreateDocumentedEntityWrapper extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    The event occurs when an entity is added to the list for documentation
    + + + + + + +

    Initialization methods:

    + +
      +
    1. + __construct +
      2. +
    + +

    Methods:

    + +
      +
    1. + getDocumentedEntityWrapper +
      2. +
    2. + isPropagationStopped + - Is propagation stopped?
      3. +
    3. + stopPropagation + - Stops the propagation of the event to further event listeners.
      4. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +public function __construct(\BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper $documentedEntityWrapper); +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $documentedEntityWrapper\BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper-
    + + + +
    +
    +
    + + + +```php +public function getDocumentedEntityWrapper(): \BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper; +``` + + + +Parameters: not specified + +Return value: \BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrapper + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/classes/OnGetProjectTemplatesDirs.md b/docs/tech/classes/OnGetProjectTemplatesDirs.md new file mode 100644 index 00000000..dc32725c --- /dev/null +++ b/docs/tech/classes/OnGetProjectTemplatesDirs.md @@ -0,0 +1,201 @@ + + BumbleDocGen / Technical description of the project / Class map / OnGetProjectTemplatesDirs
    + +

    + OnGetProjectTemplatesDirs class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class OnGetProjectTemplatesDirs extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    This event occurs when all directories containing document templates are retrieved
    + + + + + + +

    Initialization methods:

    + +
      +
    1. + __construct +
      2. +
    + +

    Methods:

    + +
      +
    1. + addTemplatesDir +
      2. +
    2. + getTemplatesDirs +
      3. +
    3. + isPropagationStopped + - Is propagation stopped?
      4. +
    4. + stopPropagation + - Stops the propagation of the event to further event listeners.
      5. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +public function __construct(array $templatesDirs); +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $templatesDirsarray-
    + + + +
    +
    +
    + + + +```php +public function addTemplatesDir(string $dirName): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $dirNamestring-
    + +Return value: void + + +
    +
    +
    + + + +```php +public function getTemplatesDirs(): array; +``` + + + +Parameters: not specified + +Return value: array + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/classes/OnGetTemplatePathByRelativeDocPath.md b/docs/tech/classes/OnGetTemplatePathByRelativeDocPath.md new file mode 100644 index 00000000..482c6d64 --- /dev/null +++ b/docs/tech/classes/OnGetTemplatePathByRelativeDocPath.md @@ -0,0 +1,225 @@ + + BumbleDocGen / Technical description of the project / Class map / OnGetTemplatePathByRelativeDocPath
    + +

    + OnGetTemplatePathByRelativeDocPath class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Plugin\Event\Renderer; + +final class OnGetTemplatePathByRelativeDocPath extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface +``` + +
    The event occurs when the path to the template file is obtained relative to the path to the document
    + + + + + + +

    Initialization methods:

    + +
      +
    1. + __construct +
      2. +
    + +

    Methods:

    + +
      +
    1. + getCustomTemplateFilePath +
      2. +
    2. + getTemplateName +
      3. +
    3. + isPropagationStopped + - Is propagation stopped?
      4. +
    4. + setCustomTemplateFilePath +
      5. +
    5. + stopPropagation + - Stops the propagation of the event to further event listeners.
      6. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +public function __construct(string $templateName); +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $templateNamestring-
    + + + +
    +
    +
    + + + +```php +public function getCustomTemplateFilePath(): string|null; +``` + + + +Parameters: not specified + +Return value: string | null + + +
    +
    +
    + + + +```php +public function getTemplateName(): string; +``` + + + +Parameters: not specified + +Return value: string + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function isPropagationStopped(): bool; +``` + +
    Is propagation stopped?
    + +Parameters: not specified + +Return value: bool + + +
    +
    +
    + + + +```php +public function setCustomTemplateFilePath(string|null $customTemplateFilePath): void; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $customTemplateFilePathstring | null-
    + +Return value: void + + +
    +
    +
    + + + +```php +// Implemented in Symfony\Contracts\EventDispatcher\Event + +public function stopPropagation(): void; +``` + +
    Stops the propagation of the event to further event listeners.
    + +Parameters: not specified + +Return value: void + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/classes/OnGettingResourceLink.md b/docs/tech/classes/OnGettingResourceLink.md index e8c8d7e3..2b6178f0 100644 --- a/docs/tech/classes/OnGettingResourceLink.md +++ b/docs/tech/classes/OnGettingResourceLink.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Class map / OnGettingResourceLink

    - OnGettingResourceLink class: + OnGettingResourceLink class:

    @@ -15,7 +15,7 @@ namespace BumbleDocGen\Core\Plugin\Event\Renderer; final class OnGettingResourceLink extends \Symfony\Contracts\EventDispatcher\Event implements \Psr\EventDispatcher\StoppableEventInterface ``` -
    Event is the base class for classes containing event data.
    +
    Event occurs when a reference to an entity (resource) is received
    @@ -63,7 +63,7 @@ final class OnGettingResourceLink extends \Symfony\Contracts\EventDispatcher\Eve ```php @@ -100,7 +100,7 @@ public function __construct(string $resourceName); ```php @@ -121,7 +121,7 @@ public function getResourceName(): string; ```php @@ -165,7 +165,7 @@ public function isPropagationStopped(): bool; ```php diff --git a/docs/tech/classes/Renderer.md b/docs/tech/classes/Renderer.md index 2c62f449..093db9ac 100644 --- a/docs/tech/classes/Renderer.md +++ b/docs/tech/classes/Renderer.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Class map / Renderer

    - Renderer class: + Renderer class:

    @@ -59,7 +59,7 @@ See: ```php @@ -136,7 +136,7 @@ public function __construct(\BumbleDocGen\Core\Configuration\Configuration $conf ```php diff --git a/docs/tech/classes/RendererIteratorFactory.md b/docs/tech/classes/RendererIteratorFactory.md index 5ca58c0c..31821e94 100644 --- a/docs/tech/classes/RendererIteratorFactory.md +++ b/docs/tech/classes/RendererIteratorFactory.md @@ -2,7 +2,7 @@ BumbleDocGen / Technical description of the project / Class map / RendererIteratorFactory

    - RendererIteratorFactory class: + RendererIteratorFactory class:

    @@ -57,11 +57,11 @@ final class RendererIteratorFactory ```php -public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Parser\Entity\RootEntityCollectionsGroup $rootEntityCollectionsGroup, \BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrappersCollection $documentedEntityWrappersCollection, \BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Configuration\ConfigurationParameterBag $configurationParameterBag, \BumbleDocGen\Core\Cache\SharedCompressedDocumentFileCache $sharedCompressedDocumentFileCache, \BumbleDocGen\Core\Renderer\RendererHelper $rendererHelper, \BumbleDocGen\Core\Renderer\Context\Dependency\RendererDependencyFactory $dependencyFactory, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Console\ProgressBar\ProgressBarFactory $progressBarFactory, \Symfony\Component\Console\Style\OutputStyle $io, \Monolog\Logger $logger); +public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $rendererContext, \BumbleDocGen\Core\Parser\Entity\RootEntityCollectionsGroup $rootEntityCollectionsGroup, \BumbleDocGen\Core\Renderer\Context\DocumentedEntityWrappersCollection $documentedEntityWrappersCollection, \BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Configuration\ConfigurationParameterBag $configurationParameterBag, \BumbleDocGen\Core\Cache\SharedCompressedDocumentFileCache $sharedCompressedDocumentFileCache, \BumbleDocGen\Core\Renderer\RendererHelper $rendererHelper, \BumbleDocGen\Core\Renderer\Context\Dependency\RendererDependencyFactory $dependencyFactory, \BumbleDocGen\Core\Cache\LocalCache\LocalObjectCache $localObjectCache, \BumbleDocGen\Console\ProgressBar\ProgressBarFactory $progressBarFactory, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher, \Symfony\Component\Console\Style\OutputStyle $io, \Monolog\Logger $logger); ``` @@ -126,6 +126,11 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext $progressBarFactory \BumbleDocGen\Console\ProgressBar\ProgressBarFactory - + + + $pluginEventDispatcher + \BumbleDocGen\Core\Plugin\PluginEventDispatcher + - $io @@ -149,7 +154,7 @@ public function __construct(\BumbleDocGen\Core\Renderer\Context\RendererContext ```php @@ -177,7 +182,7 @@ public function getDocumentedEntityWrappersWithOutdatedCache(): \Generator; ```php @@ -205,7 +210,7 @@ public function getFilesToRemove(): \Generator; ```php diff --git a/docs/tech/classes/TemplateFile.md b/docs/tech/classes/TemplateFile.md new file mode 100644 index 00000000..37062ca4 --- /dev/null +++ b/docs/tech/classes/TemplateFile.md @@ -0,0 +1,359 @@ + + BumbleDocGen / Technical description of the project / Class map / TemplateFile
    + +

    + TemplateFile class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Renderer; + +final class TemplateFile +``` + + + + + + + + +

    Initialization methods:

    + +
      +
    1. + __construct +
      2. +
    2. + create +
      3. +
    + +

    Methods:

    + +
      +
    1. + getRealPath +
      2. +
    2. + getRelativeDocPath +
      3. +
    3. + getRelativeDocPathByTemplatePath +
      4. +
    4. + getRelativeTemplatePath +
      5. +
    5. + getTemplatePathByRelativeDocPath +
      6. +
    6. + isTemplate +
      7. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +public function __construct(string $realPath, string $relativeDocPath); +``` + + + +Parameters: + + + + + + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $realPathstring-
    $relativeDocPathstring-
    + + + +
    +
    +
    + + + +```php +public static function create(\Symfony\Component\Finder\SplFileInfo $fileInfo, \BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher): self; +``` + + + +Parameters: + + + + + + + + + + + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $fileInfoSymfony\Component\Finder\SplFileInfo-
    $configuration\BumbleDocGen\Core\Configuration\Configuration-
    $pluginEventDispatcher\BumbleDocGen\Core\Plugin\PluginEventDispatcher-
    + +Return value: self + + +Throws: + + +
    +
    +
    + + + +```php +public function getRealPath(): string; +``` + + + +Parameters: not specified + +Return value: string + + +
    +
    +
    + + + +```php +public function getRelativeDocPath(): string; +``` + + + +Parameters: not specified + +Return value: string + + +
    +
    +
    + + + +```php +public static function getRelativeDocPathByTemplatePath(string $templatePath, \BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher): string; +``` + + + +Parameters: + + + + + + + + + + + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $templatePathstring-
    $configuration\BumbleDocGen\Core\Configuration\Configuration-
    $pluginEventDispatcher\BumbleDocGen\Core\Plugin\PluginEventDispatcher-
    + +Return value: string + + +Throws: + + +
    +
    +
    + + + +```php +public function getRelativeTemplatePath(): string|null; +``` + + + +Parameters: not specified + +Return value: string | null + + +
    +
    +
    + + + +```php +public static function getTemplatePathByRelativeDocPath(string $relativeDocPath, \BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Plugin\PluginEventDispatcher $pluginEventDispatcher): string; +``` + + + +Parameters: + + + + + + + + + + + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $relativeDocPathstring-
    $configuration\BumbleDocGen\Core\Configuration\Configuration-
    $pluginEventDispatcher\BumbleDocGen\Core\Plugin\PluginEventDispatcher-
    + +Return value: string + + +Throws: + + +
    +
    +
    + + + +```php +public function isTemplate(): bool; +``` + + + +Parameters: not specified + +Return value: bool + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/map.md b/docs/tech/map.md index b1fef760..26b53b19 100644 --- a/docs/tech/map.md +++ b/docs/tech/map.md @@ -92,8 +92,14 @@ Directory layout ( only documented files shown ): │ │ │ │ ├──Parser/ │ │ │ │ │ └── OnLoadSourceLocatorsCollection.php — Called when source locators are loaded │ │ │ │ └──Renderer/ +│ │ │ │ │ ├── AfterRenderingEntities.php — Event is the base class for classes containing event data. │ │ │ │ │ ├── BeforeCreatingDocFile.php — Called before the content of the documentation document is saved to a file -│ │ │ │ │ ├── OnGettingResourceLink.php — Event is the base class for classes containing event data. +│ │ │ │ │ ├── BeforeRenderingDocFiles.php — The event occurs before the main documents begin rendering +│ │ │ │ │ ├── BeforeRenderingEntities.php — The event occurs before the rendering of entity documents begins, after the main documents have b... +│ │ │ │ │ ├── OnCreateDocumentedEntityWrapper.php — The event occurs when an entity is added to the list for documentation +│ │ │ │ │ ├── OnGetProjectTemplatesDirs.php — This event occurs when all directories containing document templates are retrieved +│ │ │ │ │ ├── OnGetTemplatePathByRelativeDocPath.php — The event occurs when the path to the template file is obtained relative to the path to the document +│ │ │ │ │ ├── OnGettingResourceLink.php — Event occurs when a reference to an entity (resource) is received │ │ │ │ │ └── OnLoadEntityDocPluginContent.php — Called when entity documentation is generated (plugin content loading) │ │ │ ├── OnlySingleExecutionEvent.php │ │ │ ├── PluginEventDispatcher.php — The EventDispatcherInterface is the central point of Symfony's event listener system. @@ -148,7 +154,8 @@ Directory layout ( only documented files shown ): │ │ │ │ └── MainTwigEnvironment.php │ │ │ ├── Renderer.php — Generates and processes files from directory TemplatesDir saving them to directory OutputDir │ │ │ ├── RendererHelper.php -│ │ │ └── RendererIteratorFactory.php +│ │ │ ├── RendererIteratorFactory.php +│ │ │ └── TemplateFile.php │ ├──LanguageHandler/ │ │ ├──Php/ │ │ │ ├──Parser/ @@ -199,7 +206,7 @@ Directory layout ( only documented files shown ): │ │ │ │ └── ParserHelper.php │ │ │ ├──Plugin/ │ │ │ │ ├──CorePlugin/ -│ │ │ │ │ └──BasePhpStubber/ +│ │ │ │ │ ├──BasePhpStubber/ │ │ │ │ │ │ ├── BasePhpStubberPlugin.php — Adding links to type documentation and documentation of built-in PHP classes │ │ │ │ │ │ ├── ComposerStubberPlugin.php — Adding links to the documentation of PHP classes in the \Composer namespace │ │ │ │ │ │ ├── PhpDocumentorStubberPlugin.php — Adding links to the documentation of PHP classes in the \phpDocumentor namespace @@ -207,6 +214,8 @@ Directory layout ( only documented files shown ): │ │ │ │ │ │ ├── PsrClassesStubberPlugin.php — Adding links to the documentation of PHP classes in the \Psr namespace │ │ │ │ │ │ ├── SymfonyComponentStubberPlugin.php — Adding links to the documentation of PHP classes in the \Symfony\Component namespace │ │ │ │ │ │ └── TwigStubberPlugin.php — Adding links to the documentation of PHP classes in the \Twig namespace +│ │ │ │ │ └──EntityDocUnifiedPlace/ +│ │ │ │ │ │ └── EntityDocUnifiedPlacePlugin.php — This plugin changes the algorithm for saving entity documents. The standard system stores each fi... │ │ │ │ └──Event/ │ │ │ │ │ ├──Entity/ │ │ │ │ │ │ └── OnCheckIsClassEntityCanBeLoad.php — Event is the base class for classes containing event data. @@ -238,4 +247,4 @@ Directory layout ( only documented files shown ):
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file diff --git a/docs/tech/readme.md b/docs/tech/readme.md index 28e36af4..e4611b64 100644 --- a/docs/tech/readme.md +++ b/docs/tech/readme.md @@ -44,4 +44,4 @@ After that, the process of parsing the project code according to the configurati
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Fri Oct 06 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file From b964e65b8318eb0997257768e5cb266dc6295a3d Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Sun, 15 Oct 2023 20:19:45 +0300 Subject: [PATCH 35/42] Removing empty doc dirs --- src/Core/Renderer/Renderer.php | 6 +++++- src/Core/Renderer/RendererIteratorFactory.php | 15 +++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/src/Core/Renderer/Renderer.php b/src/Core/Renderer/Renderer.php index bbd8f210..5fa7c683 100644 --- a/src/Core/Renderer/Renderer.php +++ b/src/Core/Renderer/Renderer.php @@ -112,8 +112,12 @@ public function run(): void $this->pluginEventDispatcher->dispatch(new AfterRenderingEntities()); foreach ($this->renderIteratorFactory->getFilesToRemove() as $file) { + if (!$file->isWritable()) { + continue; + } + $type = $file->getType(); $this->fs->remove($file->getPathname()); - $this->logger->info("Removing `{$file->getPathname()}` file"); + $this->logger->info("Removing `{$file->getPathname()}` {$type}"); } $this->rootEntityCollectionsGroup->updateAllEntitiesCache(); diff --git a/src/Core/Renderer/RendererIteratorFactory.php b/src/Core/Renderer/RendererIteratorFactory.php index ca39c4d1..cd012551 100644 --- a/src/Core/Renderer/RendererIteratorFactory.php +++ b/src/Core/Renderer/RendererIteratorFactory.php @@ -237,6 +237,21 @@ public function getFilesToRemove(): \Generator } yield $docFile; } + + // check empty directories + $finder = Finder::create() + ->in($outputFolder) + ->ignoreDotFiles(true) + ->ignoreUnreadableDirs() + ->directories(); + + $dirs = []; + foreach ($finder as $dir) { + if (!Finder::create()->in($dir->getRealPath())->files()->count()) { + $dirs[] = $dir; + } + } + yield from $dirs; } private function isInternalCachingVersionChanged(): bool From 5358c29e8ed802ad1f98880d59d40c9deb682fb5 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Sun, 15 Oct 2023 20:20:01 +0300 Subject: [PATCH 36/42] Updating doc --- docs/README.md | 2 +- docs/shared_c.cache | 2 +- docs/tech/1.configuration/readme.md | 3 ++- docs/tech/2.parser/entity.md | 2 +- docs/tech/2.parser/entityFilterCondition.md | 2 +- docs/tech/2.parser/readme.md | 2 +- docs/tech/2.parser/sourceLocator.md | 2 +- docs/tech/3.renderer/01_templates.md | 2 +- docs/tech/3.renderer/02_breadcrumbs.md | 2 +- docs/tech/3.renderer/03_documentStructure.md | 2 +- docs/tech/3.renderer/04_twigCustomFilters.md | 2 +- docs/tech/3.renderer/05_twigCustomFunctions.md | 2 +- docs/tech/3.renderer/readme.md | 2 +- docs/tech/3.renderer/templatesDynamicBlocks.md | 2 +- docs/tech/3.renderer/templatesLinking.md | 2 +- docs/tech/3.renderer/templatesVariables.md | 2 +- docs/tech/4.pluginSystem/readme.md | 2 +- docs/tech/map.md | 2 +- docs/tech/readme.md | 2 +- 19 files changed, 20 insertions(+), 19 deletions(-) diff --git a/docs/README.md b/docs/README.md index 37e38472..5fa99ea3 100644 --- a/docs/README.md +++ b/docs/README.md @@ -95,4 +95,4 @@ To update this documentation, run the following command:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/shared_c.cache b/docs/shared_c.cache index dc6359c4..d6bfe39a 100644 --- a/docs/shared_c.cache +++ b/docs/shared_c.cache @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/tech/1.configuration/readme.md b/docs/tech/1.configuration/readme.md index 4ee9497d..78b94ead 100644 --- a/docs/tech/1.configuration/readme.md +++ b/docs/tech/1.configuration/readme.md @@ -41,6 +41,7 @@ Let's look at an example of a real configuration in more detail: - class: \SelfDocConfig\Plugin\RoaveStubber\BetterReflectionStubberPlugin - class: \SelfDocConfig\Plugin\TwigFilterClassParser\TwigFilterClassParserPlugin - class: \SelfDocConfig\Plugin\TwigFunctionClassParser\TwigFunctionClassParserPlugin + # - class: \BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace\EntityDocUnifiedPlacePlugin ``` @@ -222,4 +223,4 @@ The inheritance algorithm is as follows: scalar types can be overwritten by each
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/2.parser/entity.md b/docs/tech/2.parser/entity.md index dc7ed102..255e91f3 100644 --- a/docs/tech/2.parser/entity.md +++ b/docs/tech/2.parser/entity.md @@ -123,4 +123,4 @@ These classes are a convenient wrapper for accessing data in templates:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/2.parser/entityFilterCondition.md b/docs/tech/2.parser/entityFilterCondition.md index 16a7474e..11849c8f 100644 --- a/docs/tech/2.parser/entityFilterCondition.md +++ b/docs/tech/2.parser/entityFilterCondition.md @@ -78,4 +78,4 @@ Filter condition for working with entities PHP language handler:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/2.parser/readme.md b/docs/tech/2.parser/readme.md index 65ecc350..fc6de6a4 100644 --- a/docs/tech/2.parser/readme.md +++ b/docs/tech/2.parser/readme.md @@ -41,4 +41,4 @@ In this section, we show how the parser works and what components it consists of
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/2.parser/sourceLocator.md b/docs/tech/2.parser/sourceLocator.md index 3b20d28e..f180ba8f 100644 --- a/docs/tech/2.parser/sourceLocator.md +++ b/docs/tech/2.parser/sourceLocator.md @@ -30,4 +30,4 @@ You can create your own source locators or use any existing ones. All source loc
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:09:56 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:09:56 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/01_templates.md b/docs/tech/3.renderer/01_templates.md index 1890904a..ac0359e9 100644 --- a/docs/tech/3.renderer/01_templates.md +++ b/docs/tech/3.renderer/01_templates.md @@ -101,4 +101,4 @@ Result after starting the documentation generation process:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/02_breadcrumbs.md b/docs/tech/3.renderer/02_breadcrumbs.md index 57afbe9e..d8b652eb 100644 --- a/docs/tech/3.renderer/02_breadcrumbs.md +++ b/docs/tech/3.renderer/02_breadcrumbs.md @@ -51,4 +51,4 @@ Here is an example of the result of the `generatePageBreadcrumbs` function:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/03_documentStructure.md b/docs/tech/3.renderer/03_documentStructure.md index c5748408..b05480f0 100644 --- a/docs/tech/3.renderer/03_documentStructure.md +++ b/docs/tech/3.renderer/03_documentStructure.md @@ -19,4 +19,4 @@ plugins:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/04_twigCustomFilters.md b/docs/tech/3.renderer/04_twigCustomFilters.md index ab3a8e56..7f501e21 100644 --- a/docs/tech/3.renderer/04_twigCustomFilters.md +++ b/docs/tech/3.renderer/04_twigCustomFilters.md @@ -263,4 +263,4 @@ Here is a list of filters available by default:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/05_twigCustomFunctions.md b/docs/tech/3.renderer/05_twigCustomFunctions.md index a8d4102a..ff557bbf 100644 --- a/docs/tech/3.renderer/05_twigCustomFunctions.md +++ b/docs/tech/3.renderer/05_twigCustomFunctions.md @@ -385,4 +385,4 @@ Here is a list of functions available by default:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Fri Oct 13 18:40:45 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/readme.md b/docs/tech/3.renderer/readme.md index cc4c5c24..d5e768e2 100644 --- a/docs/tech/3.renderer/readme.md +++ b/docs/tech/3.renderer/readme.md @@ -60,4 +60,4 @@ This process is presented in the form of a diagram below.
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/templatesDynamicBlocks.md b/docs/tech/3.renderer/templatesDynamicBlocks.md index ee997fe9..e1781ec5 100644 --- a/docs/tech/3.renderer/templatesDynamicBlocks.md +++ b/docs/tech/3.renderer/templatesDynamicBlocks.md @@ -26,4 +26,4 @@ You can use the built-in functions and filters or add your own, so you can imple
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/templatesLinking.md b/docs/tech/3.renderer/templatesLinking.md index 50213b4e..3c365277 100644 --- a/docs/tech/3.renderer/templatesLinking.md +++ b/docs/tech/3.renderer/templatesLinking.md @@ -27,4 +27,4 @@ You can also implement your own functions for relinking if necessary.
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/3.renderer/templatesVariables.md b/docs/tech/3.renderer/templatesVariables.md index c84cf918..9847a53c 100644 --- a/docs/tech/3.renderer/templatesVariables.md +++ b/docs/tech/3.renderer/templatesVariables.md @@ -11,4 +11,4 @@ There are several variables available in each processed template.
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/4.pluginSystem/readme.md b/docs/tech/4.pluginSystem/readme.md index c8a633e4..5bc1a94e 100644 --- a/docs/tech/4.pluginSystem/readme.md +++ b/docs/tech/4.pluginSystem/readme.md @@ -206,4 +206,4 @@ plugins:
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/map.md b/docs/tech/map.md index 26b53b19..49ec75c3 100644 --- a/docs/tech/map.md +++ b/docs/tech/map.md @@ -247,4 +247,4 @@ Directory layout ( only documented files shown ):
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Sat Sep 2 21:01:47 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/readme.md b/docs/tech/readme.md index e4611b64..f081314e 100644 --- a/docs/tech/readme.md +++ b/docs/tech/readme.md @@ -44,4 +44,4 @@ After that, the process of parsing the project code according to the configurati
    -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Fri Oct 13 2023
    Made with Bumble Documentation Generator
    \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
    Last modified date: Thu Oct 5 17:42:06 2023 +0300
    Page content update date: Sun Oct 15 2023
    Made with Bumble Documentation Generator \ No newline at end of file From 8c9a9fb5faf730a759af103e209bb63b4bfa0e6e Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Sun, 15 Oct 2023 20:23:22 +0300 Subject: [PATCH 37/42] Updating doc --- docs/shared_c.cache | 2 +- docs/tech/1.configuration/readme.md | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/shared_c.cache b/docs/shared_c.cache index d6bfe39a..1f16b676 100644 --- a/docs/shared_c.cache +++ b/docs/shared_c.cache @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/tech/1.configuration/readme.md b/docs/tech/1.configuration/readme.md index 78b94ead..05051a2c 100644 --- a/docs/tech/1.configuration/readme.md +++ b/docs/tech/1.configuration/readme.md @@ -41,7 +41,6 @@ Let's look at an example of a real configuration in more detail: - class: \SelfDocConfig\Plugin\RoaveStubber\BetterReflectionStubberPlugin - class: \SelfDocConfig\Plugin\TwigFilterClassParser\TwigFilterClassParserPlugin - class: \SelfDocConfig\Plugin\TwigFunctionClassParser\TwigFunctionClassParserPlugin - # - class: \BumbleDocGen\LanguageHandler\Php\Plugin\CorePlugin\EntityDocUnifiedPlace\EntityDocUnifiedPlacePlugin ``` From f8630f1eca79b2c62541213a85b345de451c329c Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Mon, 16 Oct 2023 15:28:54 +0300 Subject: [PATCH 38/42] Fixing file path problem --- .../CommonFilterCondition/LocatedInCondition.php | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/Core/Parser/FilterCondition/CommonFilterCondition/LocatedInCondition.php b/src/Core/Parser/FilterCondition/CommonFilterCondition/LocatedInCondition.php index 568a8d6c..2e019196 100644 --- a/src/Core/Parser/FilterCondition/CommonFilterCondition/LocatedInCondition.php +++ b/src/Core/Parser/FilterCondition/CommonFilterCondition/LocatedInCondition.php @@ -28,6 +28,9 @@ public function __construct( public function canAddToCollection(EntityInterface $entity): bool { $fileName = $entity->getAbsoluteFileName(); + if (!$fileName) { + return false; + } foreach ($this->directories as $directory) { $directory = $this->parameterBag->resolveValue($directory); if (!str_starts_with($directory, DIRECTORY_SEPARATOR)) { From 841a2dde8761c117e305333816a9624c2a654e10 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Mon, 16 Oct 2023 15:29:23 +0300 Subject: [PATCH 39/42] Adding new filter condition --- .../LocatedNotInCondition.php | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 src/Core/Parser/FilterCondition/CommonFilterCondition/LocatedNotInCondition.php diff --git a/src/Core/Parser/FilterCondition/CommonFilterCondition/LocatedNotInCondition.php b/src/Core/Parser/FilterCondition/CommonFilterCondition/LocatedNotInCondition.php new file mode 100644 index 00000000..e35f72e0 --- /dev/null +++ b/src/Core/Parser/FilterCondition/CommonFilterCondition/LocatedNotInCondition.php @@ -0,0 +1,46 @@ +getAbsoluteFileName(); + if (!$fileName) { + return false; + } + foreach ($this->directories as $directory) { + $directory = $this->parameterBag->resolveValue($directory); + if (!str_starts_with($directory, DIRECTORY_SEPARATOR)) { + $directory = rtrim($this->configuration->getProjectRoot(), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $directory; + } + $directory = realpath($directory); + if (!$directory || str_starts_with($fileName, $directory)) { + return false; + } + } + return true; + } +} From ae5fbad2264bd72e1708f09af230f19826fba36a Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Mon, 16 Oct 2023 15:29:31 +0300 Subject: [PATCH 40/42] Updating doc --- docs/shared_c.cache | 2 +- .../2.parser/classes/LocatedInCondition.md | 2 +- .../2.parser/classes/LocatedNotInCondition.md | 142 ++++++++++++++++++ docs/tech/2.parser/entityFilterCondition.md | 4 +- docs/tech/classes/LocatedNotInCondition.md | 142 ++++++++++++++++++ docs/tech/map.md | 3 +- 6 files changed, 290 insertions(+), 5 deletions(-) create mode 100644 docs/tech/2.parser/classes/LocatedNotInCondition.md create mode 100644 docs/tech/classes/LocatedNotInCondition.md diff --git a/docs/shared_c.cache b/docs/shared_c.cache index dc6359c4..a408b55b 100644 --- a/docs/shared_c.cache +++ b/docs/shared_c.cache @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/tech/2.parser/classes/LocatedInCondition.md b/docs/tech/2.parser/classes/LocatedInCondition.md index 282b2a89..4a32811d 100644 --- a/docs/tech/2.parser/classes/LocatedInCondition.md +++ b/docs/tech/2.parser/classes/LocatedInCondition.md @@ -132,7 +132,7 @@ public function canAddToCollection(\BumbleDocGen\Core\Parser\Entity\EntityInterf Throws: diff --git a/docs/tech/2.parser/classes/LocatedNotInCondition.md b/docs/tech/2.parser/classes/LocatedNotInCondition.md new file mode 100644 index 00000000..0ebcf0d0 --- /dev/null +++ b/docs/tech/2.parser/classes/LocatedNotInCondition.md @@ -0,0 +1,142 @@ + + BumbleDocGen / Technical description of the project / Parser / Entity filter conditions / LocatedNotInCondition
    + +

    + LocatedNotInCondition class: +

    + + + + + +```php +namespace BumbleDocGen\Core\Parser\FilterCondition\CommonFilterCondition; + +final class LocatedNotInCondition implements \BumbleDocGen\Core\Parser\FilterCondition\ConditionInterface +``` + +
    Checking the existence of an entity not in the specified directories
    + + + + + + +

    Initialization methods:

    + +
      +
    1. + __construct +
      2. +
    + +

    Methods:

    + +
      +
    1. + canAddToCollection +
      2. +
    + + + + + + + +

    Method details:

    + +
    + + + +```php +public function __construct(\BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Configuration\ConfigurationParameterBag $parameterBag, array $directories = [ ]); +``` + + + +Parameters: + + + + + + + + + + + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $configuration\BumbleDocGen\Core\Configuration\Configuration-
    $parameterBag\BumbleDocGen\Core\Configuration\ConfigurationParameterBag-
    $directoriesarray-
    + + + +
    +
    +
    + + + +```php +public function canAddToCollection(\BumbleDocGen\Core\Parser\Entity\EntityInterface $entity): bool; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
    NameTypeDescription
    $entity\BumbleDocGen\Core\Parser\Entity\EntityInterface-
    + +Return value: bool + + +Throws: + + +
    +
    + + \ No newline at end of file diff --git a/docs/tech/2.parser/entityFilterCondition.md b/docs/tech/2.parser/entityFilterCondition.md index 16a7474e..4620de81 100644 --- a/docs/tech/2.parser/entityFilterCondition.md +++ b/docs/tech/2.parser/entityFilterCondition.md @@ -68,7 +68,7 @@ language_handlers: Common filtering conditions that are available for any entity: -
    • FalseCondition - False conditions, any object is not available
    • FileTextContainsCondition - Checking if a file contains a substring
    • LocatedInCondition - Checking the existence of an entity in the specified directories
    • TrueCondition - True conditions, any object is available
    • ConditionGroup - Filter condition to group other filter conditions. A group can have an OR/AND condition test; +
      • FalseCondition - False conditions, any object is not available
      • FileTextContainsCondition - Checking if a file contains a substring
      • LocatedInCondition - Checking the existence of an entity in the specified directories
      • LocatedNotInCondition - Checking the existence of an entity not in the specified directories
      • TrueCondition - True conditions, any object is available
      • ConditionGroup - Filter condition to group other filter conditions. A group can have an OR/AND condition test; In the case of OR, it is enough to successfully check at least one condition, in the case of AND, all checks must be successfully completed.
      Filter condition for working with entities PHP language handler: @@ -78,4 +78,4 @@ Filter condition for working with entities PHP language handler:
      -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
      Last modified date: Sat Sep 2 21:01:47 2023 +0300
      Page content update date: Fri Oct 13 2023
      Made with Bumble Documentation Generator
      \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
      Last modified date: Sat Sep 2 21:01:47 2023 +0300
      Page content update date: Mon Oct 16 2023
      Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/classes/LocatedNotInCondition.md b/docs/tech/classes/LocatedNotInCondition.md new file mode 100644 index 00000000..f8530f07 --- /dev/null +++ b/docs/tech/classes/LocatedNotInCondition.md @@ -0,0 +1,142 @@ + + BumbleDocGen / Technical description of the project / Class map / LocatedNotInCondition
      + +

      + LocatedNotInCondition class: +

      + + + + + +```php +namespace BumbleDocGen\Core\Parser\FilterCondition\CommonFilterCondition; + +final class LocatedNotInCondition implements \BumbleDocGen\Core\Parser\FilterCondition\ConditionInterface +``` + +
      Checking the existence of an entity not in the specified directories
      + + + + + + +

      Initialization methods:

      + +
        +
      1. + __construct +
        2. +
      + +

      Methods:

      + +
        +
      1. + canAddToCollection +
        2. +
      + + + + + + + +

      Method details:

      + +
      + + + +```php +public function __construct(\BumbleDocGen\Core\Configuration\Configuration $configuration, \BumbleDocGen\Core\Configuration\ConfigurationParameterBag $parameterBag, array $directories = [ ]); +``` + + + +Parameters: + + + + + + + + + + + + + + + + + + + + + + + + + + +
      NameTypeDescription
      $configuration\BumbleDocGen\Core\Configuration\Configuration-
      $parameterBag\BumbleDocGen\Core\Configuration\ConfigurationParameterBag-
      $directoriesarray-
      + + + +
      +
      +
      + + + +```php +public function canAddToCollection(\BumbleDocGen\Core\Parser\Entity\EntityInterface $entity): bool; +``` + + + +Parameters: + + + + + + + + + + + + + + + + +
      NameTypeDescription
      $entity\BumbleDocGen\Core\Parser\Entity\EntityInterface-
      + +Return value: bool + + +Throws: + + +
      +
      + + \ No newline at end of file diff --git a/docs/tech/map.md b/docs/tech/map.md index 26b53b19..a064a2e9 100644 --- a/docs/tech/map.md +++ b/docs/tech/map.md @@ -67,6 +67,7 @@ Directory layout ( only documented files shown ): │ │ │ │ │ ├── FalseCondition.php — False conditions, any object is not available │ │ │ │ │ ├── FileTextContainsCondition.php — Checking if a file contains a substring │ │ │ │ │ ├── LocatedInCondition.php — Checking the existence of an entity in the specified directories +│ │ │ │ │ ├── LocatedNotInCondition.php — Checking the existence of an entity not in the specified directories │ │ │ │ │ └── TrueCondition.php — True conditions, any object is available │ │ │ │ ├── ConditionGroup.php — Filter condition to group other filter conditions. A group can have an OR/AND condition test; In ... │ │ │ │ ├── ConditionGroupTypeEnum.php @@ -247,4 +248,4 @@ Directory layout ( only documented files shown ):
      -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
      Last modified date: Sat Sep 2 21:01:47 2023 +0300
      Page content update date: Fri Oct 13 2023
      Made with Bumble Documentation Generator
      \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
      Last modified date: Sat Sep 2 21:01:47 2023 +0300
      Page content update date: Mon Oct 16 2023
      Made with Bumble Documentation Generator \ No newline at end of file From 7e553bdb734ce5e58d62b4365f3732a095cbadc6 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Mon, 16 Oct 2023 15:33:20 +0300 Subject: [PATCH 41/42] Updating doc --- docs/shared_c.cache | 2 +- docs/tech/2.parser/entityFilterCondition.md | 4 ++-- docs/tech/map.md | 3 ++- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/docs/shared_c.cache b/docs/shared_c.cache index 1f16b676..f734ecf7 100644 --- a/docs/shared_c.cache +++ b/docs/shared_c.cache @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/tech/2.parser/entityFilterCondition.md b/docs/tech/2.parser/entityFilterCondition.md index 11849c8f..4620de81 100644 --- a/docs/tech/2.parser/entityFilterCondition.md +++ b/docs/tech/2.parser/entityFilterCondition.md @@ -68,7 +68,7 @@ language_handlers: Common filtering conditions that are available for any entity: -
      • FalseCondition - False conditions, any object is not available
      • FileTextContainsCondition - Checking if a file contains a substring
      • LocatedInCondition - Checking the existence of an entity in the specified directories
      • TrueCondition - True conditions, any object is available
      • ConditionGroup - Filter condition to group other filter conditions. A group can have an OR/AND condition test; +
        • FalseCondition - False conditions, any object is not available
        • FileTextContainsCondition - Checking if a file contains a substring
        • LocatedInCondition - Checking the existence of an entity in the specified directories
        • LocatedNotInCondition - Checking the existence of an entity not in the specified directories
        • TrueCondition - True conditions, any object is available
        • ConditionGroup - Filter condition to group other filter conditions. A group can have an OR/AND condition test; In the case of OR, it is enough to successfully check at least one condition, in the case of AND, all checks must be successfully completed.
        Filter condition for working with entities PHP language handler: @@ -78,4 +78,4 @@ Filter condition for working with entities PHP language handler:
        -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
        Last modified date: Sat Sep 2 21:01:47 2023 +0300
        Page content update date: Sun Oct 15 2023
        Made with Bumble Documentation Generator
        \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
        Last modified date: Sat Sep 2 21:01:47 2023 +0300
        Page content update date: Mon Oct 16 2023
        Made with Bumble Documentation Generator \ No newline at end of file diff --git a/docs/tech/map.md b/docs/tech/map.md index 49ec75c3..a064a2e9 100644 --- a/docs/tech/map.md +++ b/docs/tech/map.md @@ -67,6 +67,7 @@ Directory layout ( only documented files shown ): │ │ │ │ │ ├── FalseCondition.php — False conditions, any object is not available │ │ │ │ │ ├── FileTextContainsCondition.php — Checking if a file contains a substring │ │ │ │ │ ├── LocatedInCondition.php — Checking the existence of an entity in the specified directories +│ │ │ │ │ ├── LocatedNotInCondition.php — Checking the existence of an entity not in the specified directories │ │ │ │ │ └── TrueCondition.php — True conditions, any object is available │ │ │ │ ├── ConditionGroup.php — Filter condition to group other filter conditions. A group can have an OR/AND condition test; In ... │ │ │ │ ├── ConditionGroupTypeEnum.php @@ -247,4 +248,4 @@ Directory layout ( only documented files shown ):
        -Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
        Last modified date: Sat Sep 2 21:01:47 2023 +0300
        Page content update date: Sun Oct 15 2023
        Made with Bumble Documentation Generator
        \ No newline at end of file +Last page committer: fshcherbanich <filipp.shcherbanich@team.bumble.com>
        Last modified date: Sat Sep 2 21:01:47 2023 +0300
        Page content update date: Mon Oct 16 2023
        Made with Bumble Documentation Generator \ No newline at end of file From b926d2aa81ab56558dabd4f0e9db8768dcc30e04 Mon Sep 17 00:00:00 2001 From: fshcherbanich Date: Mon, 16 Oct 2023 17:00:10 +0300 Subject: [PATCH 42/42] Updating project version --- SECURITY.md | 7 ++++--- src/DocGenerator.php | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/SECURITY.md b/SECURITY.md index 31d30021..a8008456 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -8,9 +8,10 @@ Security updates will be applied to certain versions of our software. Please ref | Version | Supported | Notes | |---------|--------------------|----------------------------------------| -| 1.2.x | :white_check_mark: | Current version, fully supported. | -| 1.1.x | :x: | Not supported, please upgrade to 1.2.x | -| 1.0.x | :x: | Not supported, please upgrade to 1.2.x | +| 1.3.x | :white_check_mark: | Current version, fully supported. | +| 1.2.x | :x: | Not supported, please upgrade to 1.3.x | +| 1.1.x | :x: | Not supported, please upgrade to 1.3.x | +| 1.0.x | :x: | Not supported, please upgrade to 1.3.x | ## Reporting a Vulnerability diff --git a/src/DocGenerator.php b/src/DocGenerator.php index 92b3b732..9049c145 100644 --- a/src/DocGenerator.php +++ b/src/DocGenerator.php @@ -33,7 +33,7 @@ */ final class DocGenerator { - public const VERSION = '1.2.1'; + public const VERSION = '1.3.0'; public const LOG_FILE_NAME = 'last_run.log'; public function __construct(