Add CreateMenuItemFromNodeEvent and dispatch in createFromNode.

Author: Ben Glassman

ContentAwareFactory.php

@@ -9,22 +9,21 @@
  * file that was distributed with this source code.
  */
 
-
 namespace Symfony\Cmf\Bundle\MenuBundle;
 
 use Knp\Menu\Silex\RouterAwareFactory;
 use Knp\Menu\ItemInterface;
 use Knp\Menu\NodeInterface;
 use Knp\Menu\MenuItem;
 
+use Psr\Log\LoggerInterface;
+
 use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
 use Symfony\Component\Routing\Exception\RouteNotFoundException;
-use Symfony\Component\Security\Core\SecurityContextInterface;
-use Symfony\Cmf\Bundle\CoreBundle\PublishWorkflow\PublishWorkflowChecker;
-
-use Psr\Log\LoggerInterface;
 
 use Symfony\Cmf\Bundle\MenuBundle\Voter\VoterInterface;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Cmf\Bundle\MenuBundle\Event\CreateMenuItemFromNodeEvent;
 
 /**
  * This factory builds menu items from the menu nodes and builds urls based on
@@ -60,18 +59,6 @@ class ContentAwareFactory extends RouterAwareFactory
      */
     private $logger;
 
-    /**
-     * @var SecurityContextInterface
-     */
-    private $securityContext;
-
-    /**
-     * The permission to check for when doing the publish workflow check.
-     *
-     * @var string
-     */
-    private $publishWorkflowPermission = PublishWorkflowChecker::VIEW_ATTRIBUTE;
-
     /**
      * Whether to return null or a MenuItem without any URL if no URL can be
      * found for a MenuNode.
@@ -84,22 +71,20 @@ class ContentAwareFactory extends RouterAwareFactory
      * @param UrlGeneratorInterface $generator     for the parent class
      * @param UrlGeneratorInterface $contentRouter to generate routes when
      *      content is set
-     * @param SecurityContextInterface $securityContext the publish workflow
-     *      checker to check if menu items are published.
      * @param LoggerInterface $logger
      */
     public function __construct(
         UrlGeneratorInterface $generator,
         UrlGeneratorInterface $contentRouter,
-        SecurityContextInterface $securityContext,
-        LoggerInterface $logger
+        LoggerInterface $logger,
+        EventDispatcherInterface $dispatcher
     )
     {
         parent::__construct($generator);
         $this->contentRouter = $contentRouter;
-        $this->securityContext = $securityContext;
         $this->logger = $logger;
         $this->linkTypes = array('route', 'uri', 'content');
+        $this->dispatcher = $dispatcher;
     }
 
     /**
@@ -124,17 +109,6 @@ public function setAllowEmptyItems($allowEmptyItems)
         $this->allowEmptyItems = $allowEmptyItems;
     }
 
-    /**
-     * What attribute to use in the publish workflow check. This typically
-     * is VIEW or VIEW_ANONYMOUS.
-     *
-     * @param string $attribute
-     */
-    public function setPublishWorkflowPermission($attribute)
-    {
-        $this->publishWorkflowPermission = $attribute;
-    }
-
     /**
      * Add a voter to decide on current item.
      *
@@ -169,17 +143,36 @@ private function getVoters()
      */
     public function createFromNode(NodeInterface $node)
     {
-        $item = $this->createItem($node->getName(), $node->getOptions());
+        $event = new CreateMenuItemFromNodeEvent($node, $this);
+        $this->dispatcher->dispatch('cmf_menu.create_menu_item_from_node', $event);
+
+        if ($event->getSkipNode()) {
+            return null;
+        }
+
+        $item = $event->getItem() ?: $this->createItem($node->getName(), $node->getOptions());
 
         if (empty($item)) {
             return null;
         }
 
-        foreach ($node->getChildren() as $childNode) {
-            if (!$this->securityContext->isGranted($this->publishWorkflowPermission, $childNode)) {
-                continue;
-            }
+        if ($event->getSkipChildren()) {
+            return $item;
+        }
 
+        return $this->addChildrenFromNode($node, $item);
+    }
+
+    /**
+     * Add children to a menu item from a node
+     *
+     * @param NodeInterface $node
+     * @param ItemInterface $item
+     * @return ItemInterface
+     */
+    public function addChildrenFromNode(NodeInterface $node, ItemInterface $item)
+    {
+        foreach ($node->getChildren() as $childNode) {
             if ($childNode instanceof NodeInterface) {
                 $child = $this->createFromNode($childNode);
                 if (!empty($child)) {

Event/CreateMenuItemFromNodeEvent.php

@@ -0,0 +1,100 @@
+<?php
+
+/*
+ * This file is part of the Symfony CMF package.
+ *
+ * (c) 2011-2013 Symfony CMF
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Cmf\Bundle\MenuBundle\Event;
+
+use Knp\Menu\MenuItem;
+use Knp\Menu\NodeInterface;
+
+use Symfony\Component\EventDispatcher\Event;
+
+use Symfony\Cmf\Bundle\MenuBundle\ContentAwareFactory;
+
+class CreateMenuItemFromNodeEvent extends Event
+{
+    /**
+     * @var NodeInterface
+     */
+    protected $node;
+
+    /**
+     * @var ContentAwareFactory
+     */
+    protected $factory;
+
+    /**
+     * @var MenuItem
+     */
+    protected $item;
+
+    /**
+     * Whether or not to skip processing of this node
+     * 
+     * @var boolean
+     */
+    protected $skipNode = false;
+
+    /**
+     * Whether or not to skip processing of child nodes
+     * 
+     * @var boolean
+     */
+    protected $skipChildren = false;
+
+    public function __construct(
+        NodeInterface $node,
+        ContentAwareFactory $factory
+    ) {
+        $this->node = $node;
+        $this->factory = $factory;
+    }
+
+    public function getItem()
+    {
+        return $this->item;
+    }
+
+    public function setItem(MenuItem $item = null)
+    {
+        $this->item = $item;
+    }
+
+    public function getFactory()
+    {
+        return $this->factory;
+    }
+
+    public function getNode()
+    {
+        return $this->node;
+    }
+
+    public function setSkipNode($skipNode)
+    {
+        $this->skipNode = (bool) $skipNode;
+    }
+
+    public function getSkipNode()
+    {
+        return $this->skipNode;
+    }
+
+    public function setSkipChildren($skipChildren)
+    {
+        $this->skipChildren = (bool) $skipChildren;
+    }
+
+    public function getSkipChildren()
+    {
+        return $this->skipChildren;
+    }
+
+}

PublishWorkflow/CreateMenuItemFromNodeListener.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Symfony\Cmf\Bundle\MenuBundle\PublishWorkflow;
+
+use Symfony\Cmf\Bundle\MenuBundle\Event\CreateMenuItemFromNodeEvent;
+use Symfony\Cmf\Bundle\CoreBundle\PublishWorkflow\PublishWorkflowChecker;
+use Symfony\Component\Security\Core\SecurityContextInterface;
+use Symfony\Cmf\Bundle\MenuBundle\Voter\VoterInterface;
+use Symfony\Cmf\Bundle\MenuBundle\Model\Menu;
+
+class CreateMenuItemFromNodeListener
+{
+    /**
+     * @var SecurityContextInterface
+     */
+    private $securityContext;
+
+    /**
+     * The permission to check for when doing the publish workflow check.
+     *
+     * @var string
+     */
+    private $publishWorkflowPermission = PublishWorkflowChecker::VIEW_ATTRIBUTE;
+
+    public function __construct(SecurityContextInterface $securityContext)
+    {
+        $this->securityContext = $securityContext;
+    }
+
+    public function onCreateMenuItemFromNode(CreateMenuItemFromNodeEvent $event)
+    {
+        $node = $event->getNode();
+        $item = $event->getItem();
+        $factory = $event->getFactory();
+
+        if ($node instanceof Menu) {
+            return;
+        }
+
+        if (!$this->securityContext->isGranted($this->publishWorkflowPermission, $node)) {
+            $event->setSkipNode(true);
+        }
+
+    }
+}
+

Resources/config/menu.xml

@@ -13,8 +13,8 @@
         <service id="cmf_menu.factory" class="%cmf_menu.factory.class%">
             <argument type="service" id="router"/>
             <argument/> <!-- content url generator -->
-            <argument type="service" id="cmf_core.publish_workflow.checker"/>
             <argument type="service" id="logger"/>
+            <argument type="service" id="event_dispatcher"/>
             <call method="setAllowEmptyItems">
                 <argument>%cmf_menu.allow_empty_items%</argument>
             </call>

Resources/config/publish-workflow.xml

@@ -18,6 +18,13 @@
             <tag name="cmf_published_voter" priority="30"/>
         </service>
 
+        <service id="cmf_menu.publish_workflow.create_menu_item_from_node_listener"
+            class="Symfony\Cmf\Bundle\MenuBundle\PublishWorkflow\CreateMenuItemFromNodeListener">
+            <argument type="service" id="cmf_core.publish_workflow.checker"/>
+            <tag name="kernel.event_listener" event="cmf_menu.create_menu_item_from_node" method="onCreateMenuItemFromNode" />
+        </service>
+
+
     </services>
 
 </container>

Tests/Unit/ContentAwareFactoryTest.php

@@ -17,8 +17,8 @@ class ContentAwareFactoryTest extends \PHPUnit_Framework_Testcase
 {
     private $urlGenerator;
     private $contentUrlGenerator;
-    private $securityContext;
     private $logger;
+    private $dispatcher;
 
     private $node1;
     private $node2;
@@ -33,18 +33,18 @@ public function setUp()
         $this->contentUrlGenerator = $this->getMock(
             'Symfony\Component\Routing\Generator\UrlGeneratorInterface'
         );
-        $this->securityContext = $this->getMock(
-            'Symfony\Component\Security\Core\SecurityContextInterface'
-        );
         $this->logger = $this->getMock(
             'Psr\Log\LoggerInterface'
         );
+        $this->dispatcher = $this->getMock(
+            'Symfony\Component\EventDispatcher\EventDispatcherInterface'
+        );
 
         $this->factory = new ContentAwareFactory(
             $this->urlGenerator,
             $this->contentUrlGenerator,
-            $this->securityContext,
             $this->logger,
+            $this->dispatcher,
             false // refactore this empty items option
         );
 
@@ -79,9 +79,9 @@ public function testCreateFromNode($options)
             ->method('generate')
             ->will($this->returnValue('foobar'));
 
-        $this->node1->expects($this->once())
+        $this->node1->expects($this->any())
             ->method('getOptions')->will($this->returnValue(array()));
-        $this->node3->expects($this->once())
+        $this->node3->expects($this->any())
             ->method('getOptions')->will($this->returnValue(array()));
 
         $this->node1->expects($this->once())
@@ -95,28 +95,23 @@ public function testCreateFromNode($options)
             ->method('getChildren')
             ->will($this->returnValue(array()));
 
-        $mock = $this->securityContext->expects($this->at(0))
-            ->method('isGranted')
-            ->with('VIEW', $this->node2)
-        ;
-
         if ($options['node2_is_published']) {
-            $mock->will($this->returnValue(true));
-            $this->node2->expects($this->once())
+            $this->node2->expects($this->any())
                 ->method('getOptions')->will($this->returnValue(array()));
             $this->node2->expects($this->once())
                 ->method('getChildren')
                 ->will($this->returnValue(array()));
         } else {
-            $mock->will($this->returnValue(false));
+            $node2 = $this->node2;
+            $this->dispatcher->expects($this->any())
+                ->method('dispatch')
+                ->will($this->returnCallback(function ($name, $event) use ($options, $node2) {
+                    if ($event->getNode() === $node2) {
+                        $event->setSkipNode(true);
+                    }
+                }));
         }
 
-        $this->securityContext->expects($this->at(1))
-            ->method('isGranted')
-            ->with('VIEW', $this->node3)
-            ->will($this->returnValue(true))
-        ;
-
         $res = $this->factory->createFromNode($this->node1);
         $this->assertInstanceOf('Knp\Menu\MenuItem', $res);
     }