WIP: FEATURE: Refactoring for Neos 9

.github/workflows/build.yml

@@ -0,0 +1,39 @@
+name: build
+
+on:
+  push:
+      branches:
+        - 'main'
+  pull_request: ~
+
+jobs:
+    test:
+        name: "Test (PHP ${{ matrix.php-versions }}, Neos ${{ matrix.neos-versions }})"
+
+        strategy:
+            fail-fast: false
+            matrix:
+                php-versions: ['8.2']
+                neos-versions: ['9.0']
+
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v2
+              with:
+                  path: ${{ env.FLOW_FOLDER }}
+
+            - name: Setup PHP
+              uses: shivammathur/setup-php@v2
+              with:
+                  php-version: ${{ matrix.php-versions }}
+                  extensions: mbstring, xml, json, zlib, iconv, intl, pdo_sqlite
+                  ini-values: date.timezone="Africa/Tunis", opcache.fast_shutdown=0, apc.enable_cli=on
+
+            # disabled as long as we have no official 9.0 version
+            #- name: Set Neos Version
+            #  run: composer require neos/neos ^${{ matrix.neos-versions }} --no-progress --no-interaction
+
+            - name: Run Tests
+              run: composer test

.gitignore

@@ -1 +1,4 @@
 Resources/Private/Scripts/TaxonomyEditor/node_modules
+composer.lock
+Packages
+vendor

Classes/Command/TaxonomyCommandController.php

@@ -1,285 +1,103 @@
 <?php
+
+/**
+ * This file is part of the Sitegeist.Taxonomies package
+ *
+ * (c) 2017
+ * Martin Ficzel <[email protected]>
+ *
+ * This package is Open Source Software. For the full copyright and license
+ * information, please view the LICENSE file which was distributed with this
+ * source code.
+ */
+
+declare(strict_types=1);
+
 namespace Sitegeist\Taxonomy\Command;
 
+use Neos\ContentRepository\Core\Projection\ContentGraph\Node;
+use Neos\ContentRepository\Core\Projection\ContentGraph\NodePath;
+use Neos\ContentRepository\Core\Projection\ContentGraph\Subtree;
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Cli\CommandController;
-use Neos\ContentRepository\Domain\Model\NodeInterface;
-use Neos\ContentRepository\Domain\Service\ImportExport\NodeExportService;
-use Neos\ContentRepository\Domain\Service\ImportExport\NodeImportService;
-use Neos\ContentRepository\Domain\Repository\NodeDataRepository;
-use Neos\Eel\FlowQuery\FlowQuery;
-use Neos\Flow\Persistence\PersistenceManagerInterface;
-use Sitegeist\Taxonomy\Service\DimensionService;
+use Neos\Flow\Cli\Exception\StopCommandException;
+use Neos\Flow\Mvc\Exception\StopActionException;
 use Sitegeist\Taxonomy\Service\TaxonomyService;
 
 /**
  * @Flow\Scope("singleton")
  */
 class TaxonomyCommandController extends CommandController
 {
-
-    /**
-     * @var array
-     * @Flow\InjectConfiguration
-     */
-    protected $configuration;
-
-    /**
-     * @Flow\Inject
-     * @var NodeImportService
-     */
-    protected $nodeImportService;
-
-    /**
-     * @var NodeExportService
-     * @Flow\Inject
-     */
-    protected $nodeExportService;
-
-    /**
-     * @var NodeDataRepository
-     * @Flow\Inject
-     */
-    protected $nodeDataRepository;
-
     /**
      * @var TaxonomyService
      * @Flow\Inject
      */
     protected $taxonomyService;
 
     /**
-     * @var DimensionService
-     * @Flow\Inject
-     */
-    protected $dimensionService;
-
-    /**
-     * @var PersistenceManagerInterface
-     * @Flow\Inject
+     * List all vocabularies
      */
-    protected $persistenceManager;
-
-    /**
-     * List taxonomy vocabularies
-     *
-     * @param string $vocabularyNode vocabularay nodename(path) to prune (globbing is supported)
-     * @return void
-     */
-    public function listCommand()
+    public function vocabulariesCommand(): void
     {
-        $taxonomyRoot = $this->taxonomyService->getRoot();
-
-        /**
-         * @var NodeInterface[] $vocabularyNodes
-         */
-        $vocabularyNodes = (new FlowQuery([$taxonomyRoot]))
-            ->children('[instanceof ' . $this->taxonomyService->getVocabularyNodeType() . ' ]')
-            ->get();
-
-        /**
-         * @var NodeInterface $vocabularyNode
-         */
-        foreach ($vocabularyNodes as $vocabularyNode) {
-            $this->outputLine($vocabularyNode->getName());
-        }
+        $subgraph = $this->taxonomyService->getDefaultSubgraph();
+        $vocabularies = $this->taxonomyService->findAllVocabularies($subgraph);
+        $this->output->outputTable(
+            array_map(
+                fn(Node $node) => [
+                    $node->nodeName?->value ?? $node->nodeAggregateId->value,
+                    $node->getProperty('title'),
+                    $node->getProperty('description')
+                ],
+                iterator_to_array($vocabularies->getIterator())
+            ),
+            ['name', 'title', 'description']
+        );
     }
 
     /**
-     * Import taxonomy content
+     * List taxonomies inside a vocabulary
      *
-     * @param string $filename relative path and filename to the XML file to read.
-     * @param string $vocabularyNode vocabularay nodename(path) to import (globbing is supported)
-     * @return void
+     * @param string $vocabulary name of the vocabulary to access
+     * @param string $path path to the taxonomy starting at the vocabulary
      */
-    public function importCommand($filename, $vocabulary = null)
+    public function taxonomiesCommand(string $vocabulary, string $path = ''): void
     {
-        $xmlReader = new \XMLReader();
-        $xmlReader->open($filename, null, LIBXML_PARSEHUGE);
+        $subgraph = $this->taxonomyService->getDefaultSubgraph();
 
-        $taxonomyRoot = $this->taxonomyService->getRoot();
-
-        while ($xmlReader->read()) {
-            if ($xmlReader->nodeType != \XMLReader::ELEMENT || $xmlReader->name !== 'vocabulary') {
-                continue;
-            }
-
-            $vocabularyName = (string) $xmlReader->getAttribute('name');
-            if (is_string($vocabulary) && fnmatch($vocabulary, $vocabularyName) == false) {
-                continue;
-            }
-
-            $this->nodeImportService->import($xmlReader, $taxonomyRoot->getPath());
-            $this->outputLine('Imported vocabulary %s from file %s', [$vocabularyName, $filename]);
+        if ($path) {
+            $startPoint = $this->taxonomyService->findTaxonomyByVocabularyNameAndPath($subgraph, $vocabulary, $path);
+        } else {
+            $startPoint = $this->taxonomyService->findVocabularyByName($subgraph, $vocabulary);
         }
-    }
-
-    /**
-     * Export taxonomy content
-     *
-     * @param string $filename filename for the xml that is written.
-     * @param string $vocabularyNode vocabularay nodename(path) to export (globbing is supported)
-     * @return void
-     */
-    public function exportCommand($filename, $vocabulary = null)
-    {
-        $xmlWriter = new \XMLWriter();
-        $xmlWriter->openUri($filename);
-        $xmlWriter->setIndent(true);
-
-        $xmlWriter->startDocument('1.0', 'UTF-8');
-        $xmlWriter->startElement('root');
-
-        $taxonomyRoot = $this->taxonomyService->getRoot();
 
-        /**
-         * @var NodeInterface[] $vocabularyNodes
-         */
-        $vocabularyNodes = (new FlowQuery([$taxonomyRoot]))
-            ->children('[instanceof ' . $this->taxonomyService->getVocabularyNodeType() . ' ]')
-            ->get();
-
-        /**
-         * @var NodeInterface $vocabularyNode
-         */
-        foreach ($vocabularyNodes as $vocabularyNode) {
-            $vocabularyName = $vocabularyNode->getName();
-            if (is_string($vocabulary) && fnmatch($vocabulary, $vocabularyName) == false) {
-                continue;
-            }
-            $xmlWriter->startElement('vocabulary');
-            $xmlWriter->writeAttribute('name', $vocabularyName);
-            $this->nodeExportService->export($vocabularyNode->getPath(), 'live', $xmlWriter,  false, false);
-            $this->outputLine('Exported vocabulary %s to file %s', [$vocabularyName, $filename]);
-            $xmlWriter->endElement();
-        }
-
-        $xmlWriter->endElement();
-        $xmlWriter->endDocument();
-
-        $xmlWriter->flush();
-    }
-
-    /**
-     * Prune taxonomy content
-     *
-     * @param string $vocabularyNode vocabularay nodename(path) to prune (globbing is supported)
-     * @return void
-     */
-    public function pruneCommand($vocabulary)
-    {
-        $taxonomyRoot = $this->taxonomyService->getRoot();
-
-        /**
-         * @var NodeInterface[] $vocabularyNodes
-         */
-        $vocabularyNodes = (new FlowQuery([$taxonomyRoot]))
-            ->children('[instanceof ' . $this->taxonomyService->getVocabularyNodeType() . ' ]')
-            ->get();
-
-        /**
-         * @var NodeInterface $vocabularyNode
-         */
-        foreach ($vocabularyNodes as $vocabularyNode) {
-            $vocabularyName = $vocabularyNode->getName();
-            if (is_string($vocabulary) && fnmatch($vocabulary, $vocabularyName) == false) {
-                continue;
-            }
-            $this->nodeDataRepository->removeAllInPath($vocabularyNode->getPath());
-            $dimensionNodes = $this->nodeDataRepository->findByPath($vocabularyNode->getPath());
-            foreach ($dimensionNodes as $node) {
-                $this->nodeDataRepository->remove($node);
-            }
-
-            $this->outputLine('Pruned vocabulary %s', [$vocabularyName]);
-        }
-    }
-
-    /**
-     * Reset a taxonimy dimension and create fresh variants from the base dimension
-     *
-     * @param string $dimensionName
-     * @param string $dimensionValue
-     * @return void
-     */
-    public function pruneDimensionCommand($dimensionName, $dimensionValue)
-    {
-        $taxonomyRoot = $this->taxonomyService->getRoot();
-        $targetSubgraph = $this->dimensionService->getDimensionSubgraphByTargetValues([$dimensionName => $dimensionValue]);
-
-        if (!$targetSubgraph) {
-            $this->outputLine('Target subgraph not found');
+        if (!$startPoint) {
+            $this->outputLine('nothing found');
             $this->quit(1);
         }
 
-        $targetContextValues = $this->dimensionService->getDimensionValuesForSubgraph($targetSubgraph);
-        $flowQuery = new FlowQuery([$taxonomyRoot]);
-        $taxonomyRootInTargetContest = $flowQuery->context($targetContextValues)->get(0);
+        $subtree = $this->taxonomyService->findSubtree($startPoint);
 
-        if (!$taxonomyRootInTargetContest) {
-            $this->outputLine('Not root in target context found');
-            $this->quit(1);
+        if ($subtree) {
+            $this->output->outputTable(
+                $this->subtreeToTableRowsRecursively($subtree),
+                ['name', 'title', 'description']
+            );
         }
-
-        if ($taxonomyRootInTargetContest == $taxonomyRoot) {
-            $this->outputLine('The root is the default context and cannot be pruned');
-            $this->quit(1);
-        }
-
-        $this->outputLine('Removing content all below ' . $taxonomyRootInTargetContest->getContextPath());
-        $flowQuery = new FlowQuery([$taxonomyRootInTargetContest]);
-        $allNodes = $flowQuery->find('[instanceof ' . $this->taxonomyService->getVocabularyNodeType() . '],[instanceof ' . $this->taxonomyService->getTaxonomyNodeType() . ']')->get();
-        foreach ($allNodes as $node) {
-            $this->outputLine(' - remove: ' . $node->getContextPath());
-            $node->remove();
-        }
-        $this->outputLine('Done');
     }
 
     /**
-     * Make sure all values from default are present in the target dimension aswell
-     *
-     * @param string $dimensionName
-     * @param string $dimensionValue
-     * @return void
+     * @return array<int, array<int, string>>
      */
-    public function populateDimensionCommand($dimensionName, $dimensionValue)
+    private function subtreeToTableRowsRecursively(Subtree $subtree): array
     {
-        $taxonomyRoot = $this->taxonomyService->getRoot();
-        $targetSubgraph = $this->dimensionService->getDimensionSubgraphByTargetValues([$dimensionName => $dimensionValue]);
-
-        if (!$targetSubgraph) {
-            $this->outputLine('Target subgraph not found');
-            $this->quit(1);
-        }
-
-        $targetContextValues = $this->dimensionService->getDimensionValuesForSubgraph($targetSubgraph);
-        $flowQuery = new FlowQuery([$taxonomyRoot]);
-        $taxonomyRootInTargetContest = $flowQuery->context($targetContextValues)->get(0);
-
-        if (!$taxonomyRootInTargetContest) {
-            $this->outputLine('Not root in target context found');
-            $this->quit(1);
-        }
-
-        if ($taxonomyRootInTargetContest == $taxonomyRoot) {
-            $this->outputLine('The root is the default context and cannot be recreated');
-            $this->quit(1);
-        }
-
-        if ($taxonomyRootInTargetContest == $taxonomyRoot) {
-            $this->outputLine('The root is the default context and cannot be recreated');
-            $this->quit(1);
-        }
-
-        $this->outputLine('Populating taxonomy content from default below' . $taxonomyRootInTargetContest->getContextPath());
-        $targetContext = $taxonomyRootInTargetContest->getContext();
-        $flowQuery = new FlowQuery([$taxonomyRoot]);
-        $allNodes = $flowQuery->find('[instanceof ' . $this->taxonomyService->getVocabularyNodeType() . '],[instanceof ' . $this->taxonomyService->getTaxonomyNodeType() . ']')->get();
-        foreach ($allNodes as $node) {
-            $this->outputLine(' - adopt: ' . $node->getContextPath());
-            $targetContext->adoptNode($node);
-        }
-        $this->outputLine('Done');
+        $rows = array_map(fn(Subtree $subtree)=>$this->subtreeToTableRowsRecursively($subtree), $subtree->children);
+        $row = [
+            str_repeat('  ', $subtree->level) . ($subtree->node->nodeName?->value ?? $subtree->node->nodeAggregateId->value),
+            (string) $subtree->node->getProperty('title'),
+            (string) $subtree->node->getProperty('description')
+        ];
+
+        return array_merge([$row], ...$rows);
     }
 }