Retrait du repertoire vendor dans le suivis de git

vendor/knplabs/knp-menu

@@ -1 +0,0 @@
-Subproject commit f8e867268f63f561c1adadd6cbb5d8524f921873

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle

@@ -1 +0,0 @@
-Subproject commit f77e97924164b5500a15a209243e4c71fe466306

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/.gitignore

@@ -0,0 +1,4 @@
+/phpunit.xml
+/Tests/autoload.php
+/vendor/knp-menu
+/vendor/symfony

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/.travis.yml

@@ -0,0 +1,9 @@
+language: php
+php:
+    - 5.3
+    - 5.4
+env:
+  - SYMFONY_VERSION=v2.0.10
+  - SYMFONY_VERSION=origin/2.0
+  - SYMFONY_VERSION=origin/master
+before_script: php vendor/vendors.php

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/DependencyInjection/Compiler/AddProvidersPass.php

@@ -0,0 +1,36 @@
+<?php
+namespace Knp\Bundle\MenuBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * This compiler pass registers the providers in the ChainProvider.
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class AddProvidersPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('knp_menu.menu_provider.chain')) {
+            return;
+        }
+
+        $providers = array();
+        foreach ($container->findTaggedServiceIds('knp_menu.provider') as $id => $tags) {
+            $providers[] = new Reference($id);
+        }
+
+        if (1 === count($providers)) {
+            // Use an alias instead of wrapping it in the ChainProvider for performances
+            // when using only one (the default case as the bundle defines one provider)
+            $container->setAlias('knp_menu.menu_provider', (string) reset($providers));
+        } else {
+            $definition = $container->getDefinition('knp_menu.menu_provider.chain');
+            $definition->replaceArgument(0, $providers);
+            $container->setAlias('knp_menu.menu_provider', 'knp_menu.menu_provider.chain');
+        }
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/DependencyInjection/Compiler/AddRenderersPass.php

@@ -0,0 +1,32 @@
+<?php
+namespace Knp\Bundle\MenuBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+
+/**
+ * This compiler pass registers the renderers in the RendererProvider.
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class AddRenderersPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('knp_menu.renderer_provider')) {
+            return;
+        }
+        $definition = $container->getDefinition('knp_menu.renderer_provider');
+
+        $renderers = array();
+        foreach ($container->findTaggedServiceIds('knp_menu.renderer') as $id => $tags) {
+            foreach ($tags as $attributes) {
+                if (empty($attributes['alias'])) {
+                    throw new \InvalidArgumentException(sprintf('The alias is not defined in the "knp_menu.renderer" tag for the service "%s"', $id));
+                }
+                $renderers[$attributes['alias']] = $id;
+            }
+        }
+        $definition->replaceArgument(2, $renderers);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/DependencyInjection/Compiler/AddTemplatePathPass.php

@@ -0,0 +1,33 @@
+<?php
+namespace Knp\Bundle\MenuBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+
+/**
+ * This compiler pass adds the path for the KnpMenu template in the twig loader.
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class AddTemplatePathPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container)
+    {
+        $loaderDefinition = null;
+
+        if ($container->hasDefinition('twig.loader.filesystem')) {
+            $loaderDefinition = $container->getDefinition('twig.loader.filesystem');
+        } elseif ($container->hasDefinition('twig.loader')) {
+            // Symfony 2.0 and 2.1 were not using an alias for the filesystem loader
+            $loaderDefinition = $container->getDefinition('twig.loader');
+        }
+
+        if (null === $loaderDefinition) {
+            return;
+        }
+
+        $refl = new \ReflectionClass('Knp\Menu\ItemInterface');
+        $path = dirname($refl->getFileName()).'/Resources/views';
+        $loaderDefinition->addMethodCall('addPath', array($path));
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/DependencyInjection/Compiler/MenuPass.php

@@ -0,0 +1,27 @@
+<?php
+namespace Knp\Bundle\MenuBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+
+class MenuPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('knp_menu.menu_provider.container_aware')) {
+            return;
+        }
+        $definition = $container->getDefinition('knp_menu.menu_provider.container_aware');
+
+        $menus = array();
+        foreach ($container->findTaggedServiceIds('knp_menu.menu') as $id => $tags) {
+            foreach ($tags as $attributes) {
+                if (empty($attributes['alias'])) {
+                    throw new \InvalidArgumentException(sprintf('The alias is not defined in the "knp_menu.menu" tag for the service "%s"', $id));
+                }
+                $menus[$attributes['alias']] = $id;
+            }
+        }
+        $definition->replaceArgument(1, $menus);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/DependencyInjection/Configuration.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\DependencyInjection;
+
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+use Symfony\Component\Config\Definition\ConfigurationInterface;
+
+/**
+ * This class contains the configuration information for the bundle
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class Configuration implements ConfigurationInterface
+{
+    /**
+     * Generates the configuration tree.
+     *
+     * @return TreeBuilder
+     */
+    public function getConfigTreeBuilder()
+    {
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('knp_menu');
+
+        $rootNode
+            ->children()
+                ->arrayNode('providers')
+                    ->addDefaultsIfNotSet()
+                    ->children()
+                        ->booleanNode('builder_alias')->defaultTrue()->end()
+                        ->booleanNode('container_aware')->defaultTrue()->end()
+                    ->end()
+                ->end()
+                ->arrayNode('twig')
+                    ->addDefaultsIfNotSet()
+                    ->canBeUnset()
+                    ->children()
+                        ->scalarNode('template')->defaultValue('knp_menu.html.twig')->end()
+                    ->end()
+                ->end()
+                ->booleanNode('templating')->defaultFalse()->end()
+                ->scalarNode('default_renderer')->cannotBeEmpty()->defaultValue('twig')->end()
+            ->end();
+
+        return $treeBuilder;
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/DependencyInjection/KnpMenuExtension.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\DependencyInjection;
+
+use Symfony\Component\HttpKernel\DependencyInjection\Extension;
+use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Config\FileLocator;
+
+class KnpMenuExtension extends Extension
+{
+    /**
+     * Handles the knp_menu configuration.
+     *
+     * @param array $configs The configurations being loaded
+     * @param ContainerBuilder $container
+     */
+    public function load(array $configs, ContainerBuilder $container)
+    {
+        $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
+        $loader->load('menu.xml');
+
+        $configuration = new Configuration();
+        $config = $this->processConfiguration($configuration, $configs);
+
+        foreach ($config['providers'] as $builder => $enabled) {
+            if ($enabled) {
+                $container->getDefinition(sprintf('knp_menu.menu_provider.%s', $builder))->addTag('knp_menu.provider');
+            }
+        }
+
+        if (isset($config['twig'])) {
+            $loader->load('twig.xml');
+            $container->setParameter('knp_menu.renderer.twig.template', $config['twig']['template']);
+        }
+        if ($config['templating']) {
+            $loader->load('templating.xml');
+        }
+
+        $container->setParameter('knp_menu.default_renderer', $config['default_renderer']);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/KnpMenuBundle.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle;
+
+use Symfony\Component\HttpKernel\Bundle\Bundle;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Knp\Bundle\MenuBundle\DependencyInjection\Compiler\MenuPass;
+use Knp\Bundle\MenuBundle\DependencyInjection\Compiler\AddProvidersPass;
+use Knp\Bundle\MenuBundle\DependencyInjection\Compiler\AddRenderersPass;
+use Knp\Bundle\MenuBundle\DependencyInjection\Compiler\AddTemplatePathPass;
+
+class KnpMenuBundle extends Bundle
+{
+    public function build(ContainerBuilder $container)
+    {
+        parent::build($container);
+
+        $container->addCompilerPass(new MenuPass());
+        $container->addCompilerPass(new AddProvidersPass());
+        $container->addCompilerPass(new AddRenderersPass());
+        $container->addCompilerPass(new AddTemplatePathPass());
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Provider/BuilderAliasProvider.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Provider;
+
+use Knp\Menu\FactoryInterface;
+use Knp\Menu\ItemInterface;
+use Knp\Menu\Provider\MenuProviderInterface;
+use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\HttpKernel\Bundle\BundleInterface;
+use Symfony\Component\HttpKernel\KernelInterface;
+
+/**
+ * A menu provider that allows for an AcmeBundle:Builder:mainMenu shortcut syntax
+ *
+ * @author Ryan Weaver <ryan@knplabs.com>
+ */
+class BuilderAliasProvider implements MenuProviderInterface
+{
+    private $kernel;
+
+    private $container;
+
+    private $menuFactory;
+
+    private $builders = array();
+
+    public function __construct(KernelInterface $kernel, ContainerInterface $container, FactoryInterface $menuFactory)
+    {
+        $this->kernel = $kernel;
+        $this->container = $container;
+        $this->menuFactory = $menuFactory;
+    }
+
+    /**
+     * Looks for a menu with the bundle:class:method format
+     *
+     * For example, AcmeBundle:Builder:mainMenu would create and instantiate
+     * an Acme\DemoBundle\Menu\Builder class and call the mainMenu() method
+     * on it. The method is passed the menu factory.
+     *
+     * @param string $name The alias name of the menu
+     * @param array $options
+     * @return \Knp\Menu\ItemInterface
+     * @throws \InvalidArgumentException
+     */
+    public function get($name, array $options = array())
+    {
+        if (!$this->has($name)) {
+            throw new \InvalidArgumentException(sprintf('Invalid pattern passed to AliasProvider - expected "bundle:class:method", got "%s".', $name));
+        }
+
+        list($bundleName, $className, $methodName) = explode(':', $name);
+
+        $builder = $this->getBuilder($bundleName, $className);
+        if (!method_exists($builder, $methodName)) {
+            throw new \InvalidArgumentException(sprintf('Method "%s" was not found on class "%s" when rendering the "%s" menu.', $methodName, $className, $name));
+        }
+
+        $menu = $builder->$methodName($this->menuFactory, $options);
+        if (!$menu instanceof ItemInterface) {
+            throw new \InvalidArgumentException(sprintf('Method "%s" did not return an ItemInterface menu object for menu "%s"', $methodName, $name));
+        }
+
+        return $menu;
+    }
+
+    /**
+     * Verifies if the given name follows the bundle:class:method alias syntax.
+     *
+     * @param string $name The alias name of the menu
+     * @param array $options
+     * @return Boolean
+     */
+    public function has($name, array $options = array())
+    {
+        return 2 == substr_count($name, ':');
+    }
+
+    /**
+     * Creates and returns the builder that lives in the given bundle
+     *
+     * The convention is to look in the Menu namespace of the bundle for
+     * this class, to instantiate it with no arguments, and to inject the
+     * container if the class is ContainerAware.
+     *
+     * @param string $bundleName
+     * @param string $className The class name of the builder
+     * @throws \InvalidArgumentException If the class does not exist
+     */
+    protected function getBuilder($bundleName, $className)
+    {
+        $name = sprintf('%s:%s', $bundleName, $className);
+
+        if (!isset($this->builders[$name])) {
+            $class = null;
+            $logs = array();
+            $bundles = array();
+
+            foreach ($this->kernel->getBundle($bundleName, false) as  $bundle) {
+                $try = $bundle->getNamespace().'\\Menu\\'.$className;
+                if (class_exists($try)) {
+                    $class = $try;
+                    break;
+                }
+
+                $logs[] = sprintf('Class "%s" does not exist for menu builder "%s".', $try, $name);
+                $bundles[] = $bundle->getName();
+            }
+
+            if (null === $class) {
+                if (1 === count($logs)) {
+                    throw new \InvalidArgumentException($logs[0]);
+                }
+
+                throw new \InvalidArgumentException(sprintf('Unable to find menu builder "%s" in bundles %s.', $name, implode(', ', $bundles)));
+            }
+
+            $builder = new $class();
+            if ($builder instanceof ContainerAwareInterface) {
+                $builder->setContainer($this->container);
+            }
+
+            $this->builders[$name] = $builder;
+        }
+
+        return $this->builders[$name];
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Provider/ContainerAwareProvider.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Provider;
+
+use Knp\Menu\Provider\MenuProviderInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+class ContainerAwareProvider implements MenuProviderInterface
+{
+    private $container;
+    private $menuIds;
+
+    public function __construct(ContainerInterface $container, array $menuIds = array())
+    {
+        $this->container = $container;
+        $this->menuIds = $menuIds;
+    }
+
+    public function get($name, array $options = array())
+    {
+        if (!isset($this->menuIds[$name])) {
+            throw new \InvalidArgumentException(sprintf('The menu "%s" is not defined.', $name));
+        }
+
+        return $this->container->get($this->menuIds[$name]);
+    }
+
+    public function has($name, array $options = array())
+    {
+        return isset($this->menuIds[$name]);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/README.md

@@ -0,0 +1,25 @@
+KnpMenuBundle
+=============
+
+The `KnpMenuBundle` integrates the [KnpMenu](https://github.com/KnpLabs/KnpMenu)
+PHP library with Symfony2. This means easy-to-implement and feature-rich menus
+in your Symfony2 application!
+
+[![Build Status](https://secure.travis-ci.org/KnpLabs/KnpMenuBundle.png)](http://travis-ci.org/KnpLabs/KnpMenuBundle)
+
+### What now?
+
+Documentation! The documentation for this bundle is available in the `Resources/doc`
+directory of the bundle:
+
+* Read the [KnpMenuBundle documentation](https://github.com/KnpLabs/KnpMenuBundle/blob/master/Resources/doc/index.md)
+
+This bundle's job is to integrate a standalone PHP menu library called [KnpMenu](https://github.com/KnpLabs/KnpMenu).
+You can learn a lot more about how this library works by reading that library's
+documentation.
+
+## Credits
+
+This bundle was originally ported from [ioMenuPlugin](http://github.com/weaverryan/ioMenuPlugin),
+a menu plugin for symfony1. It has since been developed by [knpLabs](http://www.knplabs.com) and
+the Symfony community.

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Renderer/ContainerAwareProvider.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Renderer;
+
+use Knp\Menu\Renderer\RendererProviderInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+class ContainerAwareProvider implements RendererProviderInterface
+{
+    private $container;
+    private $rendererIds;
+    private $defaultRenderer;
+
+    public function __construct(ContainerInterface $container, $defaultRenderer, array $rendererIds)
+    {
+        $this->container = $container;
+        $this->rendererIds = $rendererIds;
+        $this->defaultRenderer = $defaultRenderer;
+    }
+
+    public function get($name = null)
+    {
+        if (null === $name) {
+            $name = $this->defaultRenderer;
+        }
+
+        if (!isset($this->rendererIds[$name])) {
+            throw new \InvalidArgumentException(sprintf('The renderer "%s" is not defined.', $name));
+        }
+
+        return $this->container->get($this->rendererIds[$name]);
+    }
+
+    public function has($name)
+    {
+        return isset($this->rendererIds[$name]);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Resources/config/menu.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" ?>
+
+<container xmlns="http://symfony.com/schema/dic/services"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
+
+    <parameters>
+        <parameter key="knp_menu.factory.class">Knp\Menu\Silex\RouterAwareFactory</parameter>
+        <parameter key="knp_menu.helper.class">Knp\Menu\Twig\Helper</parameter>
+        <parameter key="knp_menu.menu_provider.chain.class">Knp\Menu\Provider\ChainProvider</parameter>
+        <parameter key="knp_menu.menu_provider.container_aware.class">Knp\Bundle\MenuBundle\Provider\ContainerAwareProvider</parameter>
+        <parameter key="knp_menu.menu_provider.builder_alias.class">Knp\Bundle\MenuBundle\Provider\BuilderAliasProvider</parameter>
+        <parameter key="knp_menu.renderer_provider.class">Knp\Bundle\MenuBundle\Renderer\ContainerAwareProvider</parameter>
+        <parameter key="knp_menu.renderer.list.class">Knp\Menu\Renderer\ListRenderer</parameter>
+        <parameter key="knp_menu.renderer.list.options" type="collection"></parameter>
+    </parameters>
+
+    <services>
+        <service id="knp_menu.factory" class="%knp_menu.factory.class%">
+            <argument type="service" id="router" />
+        </service>
+
+        <service id="knp_menu.helper" class="%knp_menu.helper.class%" public="false">
+            <argument type="service" id="knp_menu.renderer_provider" />
+            <argument type="service" id="knp_menu.menu_provider" />
+        </service>
+
+        <service id="knp_menu.menu_provider.chain" class="%knp_menu.menu_provider.chain.class%" public="false">
+            <argument type="collection" />
+        </service>
+
+        <service id="knp_menu.menu_provider.container_aware" class="%knp_menu.menu_provider.container_aware.class%" public="false">
+            <argument type="service" id="service_container" />
+            <argument type="collection" />
+        </service>
+
+        <service id="knp_menu.menu_provider.builder_alias" class="%knp_menu.menu_provider.builder_alias.class%" public="false">
+            <argument type="service" id="kernel" />
+            <argument type="service" id="service_container" />
+            <argument type="service" id="knp_menu.factory" />
+        </service>
+
+        <service id="knp_menu.renderer_provider" class="%knp_menu.renderer_provider.class%">
+            <argument type="service" id="service_container" />
+            <argument>%knp_menu.default_renderer%</argument>
+            <argument type="collection" />
+        </service>
+
+        <service id="knp_menu.renderer.list" class="%knp_menu.renderer.list.class%">
+            <tag name="knp_menu.renderer" alias="list" />
+            <argument>%knp_menu.renderer.list.options%</argument>
+            <argument>%kernel.charset%</argument>
+        </service>
+    </services>
+
+</container>

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Resources/config/templating.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" ?>
+
+<container xmlns="http://symfony.com/schema/dic/services"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
+
+    <parameters>
+        <parameter key="knp_menu.templating.helper.class">Knp\Bundle\MenuBundle\Templating\Helper\MenuHelper</parameter>
+    </parameters>
+
+    <services>
+        <service id="knp_menu.templating.helper" class="%knp_menu.templating.helper.class%">
+            <tag name="templating.helper" alias="knp_menu" />
+            <argument type="service" id="knp_menu.helper" />
+        </service>
+    </services>
+
+</container>

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Resources/config/twig.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<container xmlns="http://symfony.com/schema/dic/services"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
+
+    <parameters>
+        <parameter key="knp_menu.twig.extension.class">Knp\Menu\Twig\MenuExtension</parameter>
+        <parameter key="knp_menu.renderer.twig.class">Knp\Menu\Renderer\TwigRenderer</parameter>
+        <parameter key="knp_menu.renderer.twig.options" type="collection"></parameter>
+    </parameters>
+
+    <services>
+        <service id="knp_menu.twig.extension" class="%knp_menu.twig.extension.class%" public="false">
+            <tag name="twig.extension" />
+            <argument type="service" id="knp_menu.helper" />
+        </service>
+
+        <service id="knp_menu.renderer.twig" class="%knp_menu.renderer.twig.class%">
+            <tag name="knp_menu.renderer" alias="twig" />
+            <argument type="service" id="twig" />
+            <argument>%knp_menu.renderer.twig.template%</argument>
+            <argument>%knp_menu.renderer.twig.options%</argument>
+        </service>
+    </services>
+
+</container>

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Resources/doc/custom_renderer.md

@@ -0,0 +1,32 @@
+Registering your own renderer
+=============================
+
+Registering your own renderer in the renderer provider is simply a matter
+of creating a service tagged with `knp_menu.renderer`:
+
+```yaml
+# src/Acme/MainBundle/Resources/config/services.yml
+services:
+    acme_hello.menu_renderer:
+        # The class implements Knp\Menu\Renderer\RendererInterface
+        class: Acme\MainBundle\Menu\CustomRenderer
+        arguments: [%kernel.charset%] # set your own dependencies here
+        tags:
+            # The alias is what is used to retrieve the menu
+            - { name: knp_menu.renderer, alias: custom }
+```
+
+>**Note**
+>The renderer service must be public as it will be retrieved at runtime to
+>keep it lazy-loaded.
+
+You can now use your renderer to render your menu:
+
+```jinja
+{{ knp_menu_render('main', {}, 'custom') }}
+```
+
+>**NOTE**
+>As the renderer is responsible to render some HTML code, the `knp_menu_render`
+>function is marked as safe. Take care to handle escaping data in your renderer
+>to avoid XSS if you use some user input in the menu.

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Resources/doc/events.md

@@ -0,0 +1,138 @@
+Using events to allow a menu to be extended
+===========================================
+
+If you want to let different parts of your system hook into the building
+of your menu, a good way is to use an approach based on the Symfony2 EventDispatcher
+component.
+
+## Create the menu builder
+
+Your menu builder will create the base menu item and then dispatch an event
+to allow other parts of your application to add more stuff to it.
+
+```php
+<?php
+// src/Acme/DemoBundle/Menu/MainBuilder.php
+
+namespace Acme\DemoBundle\Menu;
+
+use Acme\DemoBundle\MenuEvents;
+use Acme\DemoBundle\Event\ConfigureMenuEvent;
+use Knp\Menu\FactoryInterface;
+use Symfony\Component\DependencyInjection\ContainerAware;
+
+class MainBuilder extends ContainerAware
+{
+    public function build(FactoryInterface $factory)
+    {
+        $menu = $factory->createItem('root');
+
+        $menu->setCurrentUri($this->container->get('request')->getRequestUri());
+        $menu->addChild('Dashboard', array('route' => '_acp_dashboard'));
+
+        $this->container->get('event_dispatcher')->dispatch(MenuEvents::CONFIGURE, new ConfigureMenuEvent($factory, $menu));
+
+        return $menu;
+    }
+}
+```
+
+**Note:** This implementation assumes you use the BuilderAliasProvider (getting
+your menu as ``AcmeDemoBundle:MainBuilder:build``) but you could also define
+it as a service and inject the ``event_dispatcher`` service as a dependency.
+
+## Create the Event object
+
+The event object allows to pass some data to the listener. In this case,
+it will hold the menu being created and the factory.
+
+```php
+<?php
+// src/Acme/DemoBundle/Event/ConfigureMenuEvent.php
+
+namespace Acme\DemoBundle\Event;
+
+use Knp\Menu\FactoryInterface;
+use Knp\Menu\ItemInterface;
+use Symfony\Component\EventDispatcher\Event;
+
+class ConfigureMenuEvent extends Event
+{
+    const CONFIGURE = 'acme_demo.menu_configure';
+
+    private $factory;
+    private $menu;
+
+    /**
+     * @param \Knp\Menu\FactoryInterface $factory
+     * @param \Knp\Menu\ItemInterface $menu
+     */
+    public function __construct(FactoryInterface $factory, ItemInterface $menu)
+    {
+        $this->factory = $factory;
+        $this->menu = $menu;
+    }
+
+    /**
+     * @return \Knp\Menu\FactoryInterface
+     */
+    public function getFactory()
+    {
+        return $this->factory;
+    }
+
+    /**
+     * @return \Knp\Menu\ItemInterface
+     */
+    public function getMenu()
+    {
+        return $this->menu;
+    }
+}
+```
+
+**Note:** Following the Symfony2 best practices, the first segment of the
+event name will be the alias of the bundle, which allows avoiding conflicts.
+
+That's it. Your builder now provides a hook. Let's see how you can use it!
+
+## Create a listener
+
+You can register as many listeners as you want for the event. Let's add one.
+
+```php
+<?php
+// src/Acme/OtherBundle/EventListener/ConfigureMenuListener.php
+
+namespace Acme\OtherBundle\EventListener;
+
+use Acme\DemoBundle\Event\ConfigureMenuEvent;
+
+class ConfigureMenuListener
+{
+    /**
+     * @param \Acme\DemoBundle\Event\ConfigureMenuEvent $event
+     */
+    public function onMenuConfigure(ConfigureMenuEvent $event)
+    {
+        $menu = $event->getMenu();
+
+        $menu->addChild('Matches', array('route' => 'versus_rankedmatch_acp_matches_index'));
+        $menu->addChild('Participants', array('route' => 'versus_rankedmatch_acp_participants_index'));
+    }
+}
+```
+
+You can now register the listener.
+
+```yaml
+services:
+    acme_other.configure_menu_listener:
+        class: Acme\OtherBundle\EventListener\ConfigureMenuListener
+        tags:
+          - { name: kernel.event_listener, event: acme_demo.menu_configure, method: onMenuConfigure }
+```
+
+**Note:** When using Symfony 2.1, you could also create your listener as
+a subscriber and use the ``kernel.event_subscriber`` tag (which does not
+have any additional attributes).

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Resources/doc/i18n.md

@@ -0,0 +1,65 @@
+I18n for your menu labels
+=========================
+
+Let's assume you already have a working translation system.
+
+## Create the template
+
+At first, you need to create a template which extends `knp_menu.html.twig`
+and adds the Twig `trans` filter. In this example, the template is located
+at `src/Acme/MainBundle/Resources/views/Default/knp_menu.html.twig`. It allows
+changing the domain and the parameters for the translator through the extras
+of the item.
+
+```jinja
+{% extends 'knp_menu.html.twig' %}
+{% block label %}{{ item.label|trans(item.getExtra('translation_params', {}), item.getExtra('translation_domain', 'messages')) }}{% endblock %}
+```
+
+## Include the template
+
+### Alternative A: I18n for all menus
+
+If you want to translate all of your menus, change the default template:
+
+```yaml
+# app/config/config.yml
+knp_menu:
+    twig:
+        template: AcmeMainBundle:Default:knp_menu.html.twig
+```
+
+### Alternative B: I18n only for certain menus
+
+If you want to translate a certain menu, add the `template` parameter to
+its `knp_menu_render` call.
+
+```jinja
+{{ knp_menu_render('name_of_your_menu', {'template': 'AcmeMainBundle:Default:knp_menu.html.twig'}) }}
+```
+
+That's it.
+
+## Add translation domain information in the controller
+
+In your menu Builder class you need to add extras. For example, imagine you have two menu items Home and Login.
+
+```php
+<?php
+$menu = $factory->createItem('root');
+        
+$menu->addChild('Home', array('route' => 'homepage'));        
+$menu->addChild('Login', array('route' => 'login'));
+```
+
+To translate them you need to add translation_domain parameter using addExtras:
+
+```php
+<?php
+$menu = $factory->createItem('root');
+
+// will look for "Home" in Acme/DemoBundle/Resources/translations/AcmeDemoBundle.locale.yml
+$menu->addChild('Home', array('route' => 'homepage'))->addExtra('translation_domain', 'AcmeDemoBundle'); 
+// will look for "Login" in Acme/AdminBundle/Resources/translations/AcmeAdminBundle.locale.yml      
+$menu->addChild('Login', array('route' => 'login'))->addExtra('translation_domain', 'AcmeLoginBundle');
+```

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Resources/doc/index.md

@@ -0,0 +1,233 @@
+Using KnpMenuBundle
+===================
+
+Welcome to KnpMenuBundle - creating menus is fun again!
+
+**Basic Docs**
+
+* [Installation](#installation)
+* [Your first menu](#first-menu)
+* [Rendering Menus](#rendering-menus)
+* [Using PHP Templates](#php-templates)
+
+**More Advanced Stuff**
+
+* [Menus as Services](menu_service.md)
+* [Custom Menu Renderer](custom_renderer.md)
+* [I18n for your menu labels](i18n.md)
+* [Using events to allow extending the menu](events.md)
+
+<a name="installation"></a>
+
+## Installation
+
+### Step 1) Get the bundle and the library
+
+First, grab the KnpMenu library and KnpMenuBundle. There are two different ways
+to do this:
+
+#### Method a) Using the `deps` file
+
+Add the following lines to your  `deps` file and then run `php bin/vendors
+install`:
+
+```
+[KnpMenu]
+    git=https://github.com/KnpLabs/KnpMenu.git
+
+[KnpMenuBundle]
+    git=https://github.com/KnpLabs/KnpMenuBundle.git
+    target=bundles/Knp/Bundle/MenuBundle
+```
+
+#### Method b) Using submodules
+
+Run the following commands to bring in the needed libraries as submodules.
+
+```bash
+git submodule add https://github.com/KnpLabs/KnpMenuBundle.git vendor/bundles/Knp/Bundle/MenuBundle
+git submodule add https://github.com/KnpLabs/KnpMenu.git vendor/KnpMenu
+```
+
+### Step 2) Register the namespaces
+
+Add the following two namespace entries to the `registerNamespaces` call
+in your autoloader:
+
+``` php
+<?php
+// app/autoload.php
+$loader->registerNamespaces(array(
+    // ...
+    'Knp\Bundle' => __DIR__.'/../vendor/bundles',
+    'Knp\Menu'   => __DIR__.'/../vendor/KnpMenu/src',
+    // ...
+));
+```
+
+### Step 3) Register the bundle
+
+To start using the bundle, register it in your Kernel:
+
+``` php
+<?php
+// app/AppKernel.php
+
+public function registerBundles()
+{
+    $bundles = array(
+        // ...
+        new Knp\Bundle\MenuBundle\KnpMenuBundle(),
+    );
+    // ...
+}
+```
+
+### Step 4) (optional) Configure the bundle
+
+The bundle comes with a sensible default configuration, which is listed below.
+If you skip this step, these defaults will be used.
+
+```yaml
+# app/config/config.yml
+knp_menu:
+    twig:  # use "twig: false" to disable the Twig extension and the TwigRenderer
+        template: knp_menu.html.twig
+    templating: false # if true, enables the helper for PHP templates
+    default_renderer: twig # The renderer to use, list is also available by default
+```
+
+**Note:** Take care to change the default renderer if you disable the Twig support.
+
+<a name="first-menu"></a>
+
+## Create your first menu!
+
+There are two ways to create a menu: the "easy" way, and the more flexible
+method of creating a menu as a service.
+
+### Method a) The Easy Way (yay)!
+
+To create a menu, first create a new class in the `Menu` directory of one
+of your bundles. This class - called `Builder` in our example - will have
+one method for each menu that you need to build.
+
+An example builder class would look like this:
+
+```php
+<?php
+// src/Acme/DemoBundle/Menu/Builder.php
+namespace Acme\DemoBundle\Menu;
+
+use Knp\Menu\FactoryInterface;
+use Symfony\Component\DependencyInjection\ContainerAware;
+
+class Builder extends ContainerAware
+{
+    public function mainMenu(FactoryInterface $factory, array $options)
+    {
+        $menu = $factory->createItem('root');
+        $menu->setCurrentUri($this->container->get('request')->getRequestUri());
+
+        $menu->addChild('Home', array('route' => 'homepage'));
+        $menu->addChild('About Me', array(
+            'route' => 'page_show',
+            'routeParameters' => array('id' => 42)
+        ));
+        // ... add more children
+
+        return $menu;
+    }
+}
+```
+
+**Note** You only need to extend `ContainerAware` if you need the service
+container to be available via `$this->container`. You can also implement
+`ContainerAwareInterface` instead of extending this class.
+
+**Note** The menu builder can be overwritten using the bundle inheritance.
+
+To actually render the menu, just do the following from anywhere in any Twig
+template:
+
+```jinja
+{{ knp_menu_render('AcmeDemoBundle:Builder:mainMenu') }}
+```
+
+With this method, you refer to the menu using a three-part string:
+**bundle**:**class**:**method**.
+
+If you needed to create a second menu, you'd simply add another method to
+the `Builder` class (e.g. `sidebarMenu`), build and return the new menu,
+then render it via `AcmeDemoBundle:Builder:sidebarMenu`.
+
+That's it! The menu is *very* configurable. For more details, see the
+[KnpMenu](https://github.com/KnpLabs/KnpMenu/blob/master/doc/01-Basic-Menus.markdown)
+documentation.
+
+### Method b) A menu as a service
+
+For information on how to register a service and tag it as a menu, read
+[Creating Menus as Services](https://github.com/KnpLabs/KnpMenuBundle/blob/master/Resources/doc/menu_service.md).
+
+<a name="rendering-menus"></a>
+
+## Rendering Menus
+
+Once you've setup your menu, rendering it easy. If you've used the "easy"
+way, then do the following:
+
+```jinja
+{{ knp_menu_render('AcmeDemoBundle:Builder:mainMenu') }}
+```
+
+Additionally, you can pass some options to the renderer:
+
+```jinja
+{{ knp_menu_render('AcmeDemoBundle:Builder:mainMenu', {'depth': 2, 'currentAsLink': false}) }}
+```
+
+For a full list of options, see the "Other rendering options" header on the
+[KnpMenu](https://github.com/KnpLabs/KnpMenu/blob/master/doc/01-Basic-Menus.markdown) documentation.
+
+You can also "get" a menu, which you can use to render later:
+
+```jinja
+{% set menuItem = knp_menu_get('AcmeDemoBundle:Builder:mainMenu') %}
+
+{{ knp_menu_render(menuItem) }}
+```
+
+If you want to only retrieve a certain branch of the menu, you can do the
+following, where 'Contact' is one of the root menu items and has children
+beneath it.
+
+```jinja
+{% set menuItem = knp_menu_get('AcmeDemoBundle:Builder:mainMenu', ['Contact']) %}
+
+{{ knp_menu_render(['AcmeDemoBundle:Builder:mainMenu', 'Contact']) }}
+```
+
+If you want to pass some options to the builder, you can use the third parameter
+of the `knp_menu_get` function:
+
+```jinja
+{% set menuItem = knp_menu_get('AcmeDemoBundle:Builder:mainMenu', [], {'some_option': 'my_value'}) %}
+
+{{ knp_menu_render(menuItem) }}
+```
+
+<a name="php-templates"></a>
+
+## Using PHP templates
+
+If you prefer using PHP templates, you can use the templating helper to render
+and retrieve your menu from a template, just like available in Twig.
+
+```php
+// Retrieves an item by its path in the main menu
+$item = $view['knp_menu']->get('AcmeDemoBundle:Builder:main', array('child'));
+
+// Render an item
+echo $view['knp_menu']->render($item, array(), 'list');
+```

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Resources/doc/menu_service.md

@@ -0,0 +1,147 @@
+Creating Menus as Services
+==========================
+
+This bundle gives you a really convenient way to create menus by following
+a convention and - if needed - injecting the entire container.
+
+However, if you want to, you can instead choose to create a service for your
+menu object. The advantage of this method is that you can inject the exact
+dependencies that your menu needs, instead of injecting the entire service
+container. This can lead to code that is more testable and also potentially
+more reusable. The disadvantage is that it needs just a little more setup.
+
+Start by creating a builder for your menu. You can stick as many menus into
+a builder as you want, so you may only have one (or just a few) of these
+builder classes in your application:
+
+```php
+<?php
+// src/Acme/MainBundle/Menu/MenuBuilder.php
+
+namespace Acme\MainBundle\Menu;
+
+use Knp\Menu\FactoryInterface;
+use Symfony\Component\HttpFoundation\Request;
+
+class MenuBuilder
+{
+    private $factory;
+
+    /**
+     * @param FactoryInterface $factory
+     */
+    public function __construct(FactoryInterface $factory)
+    {
+        $this->factory = $factory;
+    }
+
+    public function createMainMenu(Request $request)
+    {
+        $menu = $this->factory->createItem('root');
+        $menu->setCurrentUri($request->getRequestUri());
+
+        $menu->addChild('Home', array('route' => 'homepage'));
+        // ... add more children
+
+        return $menu;
+    }
+}
+```
+
+Next, register two services: one for your menu builder, and one for the menu
+object created by the `createMainMenu` method:
+
+```yaml
+# src/Acme/MainBundle/Resources/config/services.yml
+services:
+    acme_main.menu_builder:
+        class: Acme\MainBundle\Menu\MenuBuilder
+        arguments: ["@knp_menu.factory"]
+
+    acme_main.menu.main:
+        class: Knp\Menu\MenuItem # the service definition requires setting the class
+        factory_service: acme_hello.menu_builder
+        factory_method: createMainMenu
+        arguments: ["@request"]
+        scope: request # needed as we have the request as a dependency here
+        tags:
+            - { name: knp_menu.menu, alias: main } # The alias is what is used to retrieve the menu
+```
+
+>**NOTE**
+>The menu service must be public as it will be retrieved at runtime to keep
+>it lazy-loaded.
+
+You can now render the menu directly in a template via the name given in the
+`alias` key above:
+
+```jinja
+{{ knp_menu_render('main') }}
+```
+
+Suppose now we need to create a second menu for the sidebar. The process
+is simple! Start by adding a new method to your builder:
+
+```php
+<?php
+// src/Acme/MainBundle/Menu/MenuBuilder.php
+
+// ...
+
+class MenuBuilder
+{
+    // ...
+
+    public function createSidebarMenu(Request $request)
+    {
+        $menu = $this->factory->createItem('sidebar');
+        $menu->setCurrentUri($request->getRequestUri());
+
+        $menu->addChild('Home', array('route' => 'homepage'));
+        // ... add more children
+
+        return $menu;
+    }
+}
+```
+
+Now, create a service for *just* your new menu, giving it a new name, like
+`sidebar`:
+
+```yaml
+# src/Acme/MainBundle/Resources/config/services.yml
+services:
+
+    acme_main.menu.sidebar:
+        class: Knp\Menu\MenuItem
+        factory_service: acme_hello.menu_builder
+        factory_method: createSidebarMenu
+        arguments: ["@request"]
+        scope: request
+        tags:
+            - { name: knp_menu.menu, alias: sidebar } # Named "sidebar" this time
+```
+
+It can now be rendered, just like the other menu:
+
+```jinja
+{{ knp_menu_render('sidebar') }}
+```
+
+## Disabling the core menu providers
+
+To be able to use different menu providers together (the container-based
+one and the builder-based one for instance), a chain provider is used.
+However, it is not used when only one provider is enabled to increase performance
+by getting rid of the wrapping. If you don't want to use the built-in providers,
+you can disable them through the configuration:
+
+```yaml
+#app/config/config.yml
+knp_menu:
+    providers:
+        builder_alias: false    # disable the builder-based provider
+        container_aware: true   # keep this one enabled. Can be omitted as it is the default
+```
+
+**Note:** Both providers are enabled by default.

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Templating/Helper/MenuHelper.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Templating\Helper;
+
+use Symfony\Component\Templating\Helper\Helper as TemplatingHelper;
+use Knp\Menu\Twig\Helper;
+
+class MenuHelper extends TemplatingHelper
+{
+    private $helper;
+
+    /**
+     * @param \Knp\Menu\Twig\Helper $helper
+     */
+    public function __construct(Helper $helper)
+    {
+        $this->helper = $helper;
+    }
+
+    /**
+     * Retrieves an item following a path in the tree.
+     *
+     * @param \Knp\Menu\ItemInterface|string $menu
+     * @param array $path
+     * @param array $options
+     * @return \Knp\Menu\ItemInterface
+     */
+    public function get($menu, array $path = array(), array $options = array())
+    {
+        return $this->helper->get($menu, $path, $options);
+    }
+
+    /**
+     * Renders a menu with the specified renderer.
+     *
+     * @param \Knp\Menu\ItemInterface|string|array $menu
+     * @param array $options
+     * @param string $renderer
+     * @return string
+     */
+    public function render($menu, array $options = array(), $renderer = null)
+    {
+        return $this->helper->render($menu, $options, $renderer);
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'knp_menu';
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/DependencyInjection/Compiler/AddProvidersPassTest.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\DependencyInjection\Compiler;
+
+use Knp\Bundle\MenuBundle\DependencyInjection\Compiler\AddProvidersPass;
+
+class AddProvidersPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testProcessWithoutProviderDefinition()
+    {
+        $providersPass = new AddProvidersPass();
+
+        $this->assertNull($providersPass->process($this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder')));
+    }
+
+    public function testProcessForOneProvider()
+    {
+        $containerBuilderMock = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $containerBuilderMock->expects($this->once())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+        $containerBuilderMock->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->with($this->equalTo('knp_menu.provider'))
+            ->will($this->returnValue(array('id' => array('provider_tag1'))));
+        $containerBuilderMock->expects($this->once())
+            ->method('setAlias')
+            ->with(
+                $this->equalTo('knp_menu.menu_provider'),
+                $this->equalTo('id')
+            );
+
+        $providersPass = new AddProvidersPass();
+        $providersPass->process($containerBuilderMock);
+    }
+
+    public function testProcessForManyProviders()
+    {
+        $definitionMock = $this->getMockBuilder('Symfony\Component\DependencyInjection\Definition')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $definitionMock->expects($this->once())
+            ->method('replaceArgument')
+            ->with($this->equalTo(0), $this->isType('array'));
+
+        $containerBuilderMock = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $containerBuilderMock->expects($this->once())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+        $containerBuilderMock->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->with($this->equalTo('knp_menu.provider'))
+            ->will($this->returnValue(array(
+                'id' => array('provider_tag1'),
+                'id2' => array('provider_tag2')
+            )));
+        $containerBuilderMock->expects($this->once())
+            ->method('setAlias')
+            ->with(
+                $this->equalTo('knp_menu.menu_provider'),
+                $this->equalTo('knp_menu.menu_provider.chain')
+            );
+        $containerBuilderMock->expects($this->once())
+            ->method('getDefinition')
+            ->with($this->equalTo('knp_menu.menu_provider.chain'))
+            ->will($this->returnValue($definitionMock));
+
+        $providersPass = new AddProvidersPass();
+        $providersPass->process($containerBuilderMock);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/DependencyInjection/Compiler/AddRenderersPassTest.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\DependencyInjection\Compiler;
+
+use Knp\Bundle\MenuBundle\DependencyInjection\Compiler\AddRenderersPass;
+
+class AddRenderersPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testProcessWithoutProviderDefinition()
+    {
+        $renderersPass = new AddRenderersPass();
+
+        $this->assertNull($renderersPass->process($this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder')));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testProcessWithEmptyAlias()
+    {
+        $containerBuilderMock = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $containerBuilderMock->expects($this->once())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+        $containerBuilderMock->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->with($this->equalTo('knp_menu.renderer'))
+            ->will($this->returnValue(array('id' => array('tag1' => array('alias' => '')))));
+
+        $renderersPass = new AddRenderersPass();
+        $renderersPass->process($containerBuilderMock);
+    }
+
+    public function testProcessWithAlias()
+    {
+        $definitionMock = $this->getMockBuilder('Symfony\Component\DependencyInjection\Definition')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $definitionMock->expects($this->once())
+            ->method('replaceArgument')
+            ->with($this->equalTo(2), $this->equalTo(array('test_alias' => 'id')));
+
+        $containerBuilderMock = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $containerBuilderMock->expects($this->once())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+        $containerBuilderMock->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->with($this->equalTo('knp_menu.renderer'))
+            ->will($this->returnValue(array('id' => array('tag1' => array('alias' => 'test_alias')))));
+        $containerBuilderMock->expects($this->once())
+            ->method('getDefinition')
+            ->with($this->equalTo('knp_menu.renderer_provider'))
+            ->will($this->returnValue($definitionMock));
+
+        $renderersPass = new AddRenderersPass();
+        $renderersPass->process($containerBuilderMock);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/DependencyInjection/Compiler/AddTemplatePathPassTest.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\DependencyInjection\Compiler;
+
+use Knp\Bundle\MenuBundle\DependencyInjection\Compiler\AddTemplatePathPass;
+
+class AddTemplatePathPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testProcessWithoutProviderDefinition()
+    {
+        $templatePathPass = new AddTemplatePathPass();
+
+        $this->assertNull($templatePathPass->process($this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder')));
+    }
+
+    public function testProcess()
+    {
+        $definitionMock = $this->getMockBuilder('Symfony\Component\DependencyInjection\Definition')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $definitionMock->expects($this->once())
+            ->method('addMethodCall')
+            ->with($this->equalTo('addPath'), $this->isType('array'));
+
+        $containerBuilderMock = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $containerBuilderMock->expects($this->once())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+        $containerBuilderMock->expects($this->once())
+            ->method('getDefinition')
+            ->with($this->equalTo('twig.loader.filesystem'))
+            ->will($this->returnValue($definitionMock));
+
+        $templatePathPass = new AddTemplatePathPass();
+        $templatePathPass->process($containerBuilderMock);
+    }
+
+    public function testProcessLegacy()
+    {
+        $definitionMock = $this->getMockBuilder('Symfony\Component\DependencyInjection\Definition')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $definitionMock->expects($this->once())
+            ->method('addMethodCall')
+            ->with($this->equalTo('addPath'), $this->isType('array'));
+
+        $containerBuilderMock = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $containerBuilderMock->expects($this->exactly(2))
+            ->method('hasDefinition')
+            ->will($this->onConsecutiveCalls(false, true));
+        $containerBuilderMock->expects($this->once())
+            ->method('getDefinition')
+            ->with($this->equalTo('twig.loader'))
+            ->will($this->returnValue($definitionMock));
+
+        $templatePathPass = new AddTemplatePathPass();
+        $templatePathPass->process($containerBuilderMock);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/DependencyInjection/Compiler/MenuPassTest.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\DependencyInjection\Compiler;
+
+use Knp\Bundle\MenuBundle\DependencyInjection\Compiler\MenuPass;
+
+class MenuPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testProcessWithoutProviderDefinition()
+    {
+        $menuPass = new MenuPass();
+
+        $this->assertNull($menuPass->process($this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder')));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testProcessWithEmptyAlias()
+    {
+        $containerBuilderMock = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $containerBuilderMock->expects($this->once())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+        $containerBuilderMock->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->with($this->equalTo('knp_menu.menu'))
+            ->will($this->returnValue(array('id' => array('tag1' => array('alias' => '')))));
+
+        $menuPass = new MenuPass();
+        $menuPass->process($containerBuilderMock);
+    }
+
+    public function testProcessWithAlias()
+    {
+        $definitionMock = $this->getMockBuilder('Symfony\Component\DependencyInjection\Definition')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $definitionMock->expects($this->once())
+            ->method('replaceArgument')
+            ->with($this->equalTo(1), $this->equalTo(array('test_alias' => 'id')));
+
+        $containerBuilderMock = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $containerBuilderMock->expects($this->once())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+        $containerBuilderMock->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->with($this->equalTo('knp_menu.menu'))
+            ->will($this->returnValue(array('id' => array('tag1' => array('alias' => 'test_alias')))));
+        $containerBuilderMock->expects($this->once())
+            ->method('getDefinition')
+            ->with($this->equalTo('knp_menu.menu_provider.container_aware'))
+            ->will($this->returnValue($definitionMock));
+
+        $menuPass = new MenuPass();
+        $menuPass->process($containerBuilderMock);
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/DependencyInjection/KnpMenuExtensionTest.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\DependencyInjection;
+
+use Knp\Bundle\MenuBundle\DependencyInjection\KnpMenuExtension;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Parameter;
+use Symfony\Component\DependencyInjection\Reference;
+
+class FOSAdvancedEncoderExtensionTest extends \PHPUnit_Framework_TestCase
+{
+    public function testDefault()
+    {
+        $container = new ContainerBuilder();
+        $loader = new KnpMenuExtension();
+        $loader->load(array(array()), $container);
+        $this->assertTrue($container->hasDefinition('knp_menu.renderer.list'), 'The list renderer is loaded');
+        $this->assertTrue($container->hasDefinition('knp_menu.renderer.twig'), 'The twig renderer is loaded');
+        $this->assertEquals('knp_menu.html.twig', $container->getParameter('knp_menu.renderer.twig.template'));
+        $this->assertFalse($container->hasDefinition('knp_menu.templating.helper'), 'The PHP helper is not loaded');
+        $this->assertTrue($container->getDefinition('knp_menu.menu_provider.builder_alias')->hasTag('knp_menu.provider'), 'The BuilderAliasProvider is enabled');
+        $this->assertTrue($container->getDefinition('knp_menu.menu_provider.container_aware')->hasTag('knp_menu.provider'), 'The ContainerAwareProvider is enabled');
+    }
+
+    public function testEnableTwig()
+    {
+        $container = new ContainerBuilder();
+        $loader = new KnpMenuExtension();
+        $loader->load(array(array('twig' => true)), $container);
+        $this->assertTrue($container->hasDefinition('knp_menu.renderer.twig'));
+        $this->assertEquals('knp_menu.html.twig', $container->getParameter('knp_menu.renderer.twig.template'));
+    }
+
+    public function testOverwriteTwigTemplate()
+    {
+        $container = new ContainerBuilder();
+        $loader = new KnpMenuExtension();
+        $loader->load(array(array('twig' => array('template' => 'foobar'))), $container);
+        $this->assertTrue($container->hasDefinition('knp_menu.renderer.twig'));
+        $this->assertEquals('foobar', $container->getParameter('knp_menu.renderer.twig.template'));
+    }
+
+    public function testDisableTwig()
+    {
+        $container = new ContainerBuilder();
+        $loader = new KnpMenuExtension();
+        $loader->load(array(array('twig' => false)), $container);
+        $this->assertTrue($container->hasDefinition('knp_menu.renderer.list'));
+        $this->assertFalse($container->hasDefinition('knp_menu.renderer.twig'));
+    }
+
+    public function testEnsablePhpTemplates()
+    {
+        $container = new ContainerBuilder();
+        $loader = new KnpMenuExtension();
+        $loader->load(array(array('templating' => true)), $container);
+        $this->assertTrue($container->hasDefinition('knp_menu.templating.helper'));
+    }
+
+    public function testDisableBuilderAliasProvider()
+    {
+        $container = new ContainerBuilder();
+        $loader = new KnpMenuExtension();
+        $loader->load(array(array('providers' => array('builder_alias' => false))), $container);
+        $this->assertFalse($container->getDefinition('knp_menu.menu_provider.builder_alias')->hasTag('knp_menu.provider'), 'The BuilderAliasProvider is disabled');
+        $this->assertTrue($container->getDefinition('knp_menu.menu_provider.container_aware')->hasTag('knp_menu.provider'), 'The ContainerAwareProvider is enabled');
+    }
+
+    public function testDisableContainerAwareProvider()
+    {
+        $container = new ContainerBuilder();
+        $loader = new KnpMenuExtension();
+        $loader->load(array(array('providers' => array('container_aware' => false))), $container);
+        $this->assertTrue($container->getDefinition('knp_menu.menu_provider.builder_alias')->hasTag('knp_menu.provider'), 'The BuilderAliasProvider is enabled');
+        $this->assertFalse($container->getDefinition('knp_menu.menu_provider.container_aware')->hasTag('knp_menu.provider'), 'The ContainerAwareProvider is disabled');
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Provider/BuilderAliasProviderTest.php

@@ -0,0 +1,245 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Provider;
+
+use Knp\Bundle\MenuBundle\Provider\BuilderAliasProvider;
+use Knp\Bundle\MenuBundle\Tests\Stubs\TestKernel;
+use Symfony\Component\HttpKernel\Kernel;
+
+class BuilderAliasProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testHas()
+    {
+        $provider = new BuilderAliasProvider(
+            $this->getMock('Symfony\Component\HttpKernel\KernelInterface'),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $this->getMock('Knp\Menu\FactoryInterface')
+        );
+        $this->assertFalse($provider->has('foo'));
+        $this->assertFalse($provider->has('foo:bar'));
+        $this->assertTrue($provider->has('foo:bar:baz'));
+    }
+
+    public function testGetExistentMenu()
+    {
+        $item = $this->getMock('Knp\Menu\ItemInterface');
+        // mock the factory to return a set value when the builder creates the menu
+        $factory = $this->getMock('Knp\Menu\FactoryInterface');
+        $factory->expects($this->once())
+            ->method('createItem')
+            ->with('Main menu')
+            ->will($this->returnValue($item));
+
+        $provider = new BuilderAliasProvider(
+            $this->createMockKernelForStub(),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $factory
+        );
+
+        $menu = $provider->get('FooBundle:Builder:mainMenu');
+        // returns the mocked value returned from mocked factory
+        $this->assertSame($item, $menu);
+    }
+
+    public function testGetContainerAwareMenu()
+    {
+        $item = $this->getMock('Knp\Menu\ItemInterface');
+        // mock the factory to return a set value when the builder creates the menu
+        $factory = $this->getMock('Knp\Menu\FactoryInterface');
+        $factory->expects($this->once())
+            ->method('createItem')
+            ->with('Main menu')
+            ->will($this->returnValue($item));
+
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface');
+        $container->expects($this->once())
+            ->method('get')
+            ->with('test');
+
+        $provider = new BuilderAliasProvider(
+            $this->createMockKernelForStub(),
+            $container,
+            $factory
+        );
+
+        $menu = $provider->get('FooBundle:ContainerAwareBuilder:mainMenu');
+        // returns the mocked value returned from mocked factory
+        $this->assertSame($item, $menu);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetInvalidReturnValue()
+    {
+        $provider = new BuilderAliasProvider(
+            $this->createMockKernelForStub(),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $this->getMock('Knp\Menu\FactoryInterface')
+        );
+
+        $menu = $provider->get('FooBundle:Builder:invalidMethod');
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetNonExistentMenu()
+    {
+        $provider = new BuilderAliasProvider(
+            $this->getMock('Symfony\Component\HttpKernel\KernelInterface'),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $this->getMock('Knp\Menu\FactoryInterface')
+        );
+        $provider->get('non-existent');
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Class "Knp\Bundle\MenuBundle\Tests\Stubs\Menu\Fake" does not exist for menu builder "FooBundle:Fake".
+     */
+    public function testGetNonExistentMenuClass()
+    {
+        $provider = new BuilderAliasProvider(
+            $this->createMockKernelForStub(),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $this->getMock('Knp\Menu\FactoryInterface')
+        );
+
+        $provider->get('FooBundle:Fake:mainMenu');
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetNonExistentMenuMethod()
+    {
+        $provider = new BuilderAliasProvider(
+            $this->createMockKernelForStub(),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $this->getMock('Knp\Menu\FactoryInterface')
+        );
+
+        // bundle will return a null namespace, class won't be found
+        $provider->get('FooBundle:Builder:fakeMenu');
+    }
+
+    public function testBundleInheritanceParent()
+    {
+        $item = $this->getMock('Knp\Menu\ItemInterface');
+        // mock the factory to return a set value when the builder creates the menu
+        $factory = $this->getMock('Knp\Menu\FactoryInterface');
+        $factory->expects($this->once())
+            ->method('createItem')
+            ->with('Main menu')
+            ->will($this->returnValue($item));
+
+        $provider = new BuilderAliasProvider(
+            $this->createTestKernel(),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $factory
+        );
+
+        $menu = $provider->get('FooBundle:Builder:mainMenu');
+        // returns the mocked value returned from mocked factory
+        $this->assertSame($item, $menu);
+    }
+
+    public function testBundleInheritanceChild()
+    {
+        $item = $this->getMock('Knp\Menu\ItemInterface');
+        // mock the factory to return a set value when the builder creates the menu
+        $factory = $this->getMock('Knp\Menu\FactoryInterface');
+        $factory->expects($this->once())
+            ->method('createItem')
+            ->with('Main menu for the child')
+            ->will($this->returnValue($item));
+
+        $provider = new BuilderAliasProvider(
+            $this->createTestKernel('Knp\Bundle\MenuBundle\Tests\Stubs\Child'),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $factory
+        );
+
+        $menu = $provider->get('FooBundle:Builder:mainMenu');
+        // returns the mocked value returned from mocked factory
+        $this->assertSame($item, $menu);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Unable to find menu builder "FooBundle:Fake" in bundles BarBundle, FooBundle.
+     */
+    public function testBundleInheritanceWrongClass()
+    {
+        $provider = new BuilderAliasProvider(
+            $this->createTestKernel(),
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            $this->getMock('Knp\Menu\FactoryInterface')
+        );
+
+        $provider->get('FooBundle:Fake:mainMenu');
+    }
+
+    /**
+     * Returns a mocked kernel with a mocked "FooBundle" whose namespace
+     * points to the Stubs directory.
+     */
+    private function createMockKernelForStub()
+    {
+        $bundle = $this->getMock('Symfony\Component\HttpKernel\Bundle\BundleInterface');
+        $bundle->expects($this->once())
+            ->method('getNamespace')
+            ->will($this->returnValue('Knp\Bundle\MenuBundle\Tests\Stubs'))
+        ;
+        $bundle->expects($this->any())
+            ->method('getName')
+            ->will($this->returnValue('FooBundle'))
+        ;
+
+        $kernel = $this->getMock('Symfony\Component\HttpKernel\KernelInterface');
+        $kernel->expects($this->once())
+            ->method('getBundle')
+            ->with('FooBundle', false)
+            ->will($this->returnValue(array($bundle)))
+        ;
+
+        return $kernel;
+    }
+
+    private function createTestKernel($childNamespace = 'Bar', $parentNamespace = 'Knp\Bundle\MenuBundle\Tests\Stubs')
+    {
+        $bundleInterface = version_compare(Kernel::VERSION, '2.1-dev', '<')
+            ? 'Knp\Bundle\MenuBundle\Tests\Stubs\ContainerAwareBundleInterface' // Symfony 2.0 misses the extend in the interface
+            : 'Symfony\Component\HttpKernel\Bundle\BundleInterface';
+
+        $bundle = $this->getMock($bundleInterface);
+        $bundle->expects($this->any())
+            ->method('getNamespace')
+            ->will($this->returnValue($parentNamespace))
+        ;
+        $bundle->expects($this->any())
+            ->method('getName')
+            ->will($this->returnValue('FooBundle'))
+        ;
+
+        $childBundle = $this->getMock($bundleInterface);
+        $childBundle->expects($this->any())
+            ->method('getNamespace')
+            ->will($this->returnValue($childNamespace))
+        ;
+        $childBundle->expects($this->any())
+            ->method('getName')
+            ->will($this->returnValue('BarBundle'))
+        ;
+        $childBundle->expects($this->any())
+            ->method('getParent')
+            ->will($this->returnValue('FooBundle'))
+        ;
+
+        $kernel = new TestKernel(array($bundle, $childBundle));
+        $kernel->boot();
+
+        return $kernel;
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Provider/ContainerAwareProviderTest.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Provider;
+
+use Knp\Bundle\MenuBundle\Provider\ContainerAwareProvider;
+
+class ContainerAwareProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testHas()
+    {
+        $provider = new ContainerAwareProvider($this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'), array('first' => 'first', 'second' => 'dummy'));
+        $this->assertTrue($provider->has('first'));
+        $this->assertTrue($provider->has('second'));
+        $this->assertFalse($provider->has('third'));
+    }
+
+    public function testGetExistentMenu()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface');
+        $container->expects($this->once())
+            ->method('get')
+            ->with('menu')
+            ->will($this->returnValue($menu))
+        ;
+        $provider = new ContainerAwareProvider($container, array('default' => 'menu'));
+        $this->assertSame($menu, $provider->get('default'));
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetNonExistentMenu()
+    {
+        $provider = new ContainerAwareProvider($this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'));
+        $provider->get('non-existent');
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Renderer/ContainerAwareProviderTest.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Renderer;
+
+use Knp\Bundle\MenuBundle\Renderer\ContainerAwareProvider;
+
+class ContainerAwareProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testHas()
+    {
+        $provider = new ContainerAwareProvider(
+            $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'),
+            'first',
+            array('first' => 'first', 'second' => 'dummy')
+        );
+        $this->assertTrue($provider->has('first'));
+        $this->assertTrue($provider->has('second'));
+        $this->assertFalse($provider->has('third'));
+    }
+
+    public function testGetExistentRenderer()
+    {
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface');
+        $container->expects($this->once())
+            ->method('get')
+            ->with('renderer')
+            ->will($this->returnValue($renderer))
+        ;
+        $provider = new ContainerAwareProvider($container, 'custom', array('default' => 'renderer', 'custom' => 'other'));
+        $this->assertSame($renderer, $provider->get('default'));
+    }
+
+    public function testGetDefaultRenderer()
+    {
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface');
+        $container->expects($this->once())
+            ->method('get')
+            ->with('renderer')
+            ->will($this->returnValue($renderer))
+        ;
+        $provider = new ContainerAwareProvider($container, 'default', array('default' => 'renderer'));
+        $this->assertSame($renderer, $provider->get());
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetNonExistentRenderer()
+    {
+        $provider = new ContainerAwareProvider($this->getMock('Symfony\Component\DependencyInjection\ContainerInterface'), 'default', array());
+        $provider->get('non-existent');
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Stubs/Child/Menu/Builder.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Stubs\Child\Menu;
+
+use Knp\Menu\FactoryInterface;
+
+class Builder
+{
+    public function mainMenu(FactoryInterface $factory)
+    {
+        return $factory->createItem('Main menu for the child');
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Stubs/ContainerAwareBundleInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Stubs;
+
+use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\HttpKernel\Bundle\BundleInterface;
+
+/**
+ * Stub interface as the kernel expects bundles to be container-aware but the interface
+ * does not do it. This allows creating a mock implementing both interfaces.
+ */
+interface ContainerAwareBundleInterface extends BundleInterface, ContainerAwareInterface
+{
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Stubs/Menu/Builder.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Stubs\Menu;
+
+use Knp\Menu\FactoryInterface;
+
+class Builder
+{
+    public function mainMenu(FactoryInterface $factory)
+    {
+        return $factory->createItem('Main menu');
+    }
+
+    public function invalidMethod(FactoryInterface $factory)
+    {
+        return new \stdClass();
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Stubs/Menu/ContainerAwareBuilder.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Stubs\Menu;
+
+use Knp\Menu\FactoryInterface;
+use Symfony\Component\DependencyInjection\ContainerAware;
+
+class ContainerAwareBuilder extends ContainerAware
+{
+    public function mainMenu(FactoryInterface $factory)
+    {
+        // Check that the container is really set.
+        $this->container->get('test');
+
+        return $factory->createItem('Main menu');
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Stubs/TestKernel.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Stubs;
+
+use Symfony\Component\Config\Loader\LoaderInterface;
+use Symfony\Component\HttpKernel\Kernel;
+
+class TestKernel extends Kernel
+{
+    private $mockBundles;
+
+    public function __construct(array $bundles)
+    {
+        $this->mockBundles = $bundles;
+
+        parent::__construct('test', false);
+    }
+
+    public function registerBundles()
+    {
+        return $this->mockBundles;
+    }
+
+    public function registerContainerConfiguration(LoaderInterface $loader)
+    {
+    }
+
+    protected function initializeContainer()
+    {
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/Templating/MenuHelperTest.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Knp\Bundle\MenuBundle\Tests\Templating;
+
+use Knp\Bundle\MenuBundle\Templating\Helper\MenuHelper;
+
+/**
+ * Test for MenuHelper class
+ *
+ * @author Leszek Prabucki <leszek.prabucki@gmail.com>
+ */
+class MenuHelperTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGet()
+    {
+        $helperMock = $this->getMockBuilder('Knp\Menu\Twig\Helper')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $helperMock->expects($this->once())
+            ->method('get')
+            ->with($this->equalTo('test'), $this->equalTo(array('pathArray')))
+            ->will($this->returnValue('returned value'));
+
+        $helper = new MenuHelper($helperMock);
+
+        $this->assertEquals('returned value', $helper->get('test', array('pathArray')));
+    }
+
+    public function testGetMenuWithOptions()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $helperMock = $this->getMockBuilder('Knp\Menu\Twig\Helper')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $helperMock->expects($this->once())
+            ->method('get')
+            ->with('default', array(), array('foo' => 'bar'))
+            ->will($this->returnValue($menu))
+        ;
+        $helper = new MenuHelper($helperMock);
+        $this->assertSame($menu, $helper->get('default', array(), array('foo' => 'bar')));
+    }
+
+    public function testRender()
+    {
+        $helperMock = $this->getMockBuilder('Knp\Menu\Twig\Helper')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $helperMock->expects($this->once())
+            ->method('render')
+            ->with($this->equalTo('test'), $this->equalTo(array('options')))
+            ->will($this->returnValue('returned value'));
+
+        $helper = new MenuHelper($helperMock);
+
+        $this->assertEquals('returned value', $helper->render('test', array('options')));
+    }
+
+    public function testGetName()
+    {
+        $helperMock = $this->getMockBuilder('Knp\Menu\Twig\Helper')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $helper = new MenuHelper($helperMock);
+
+        $this->assertEquals('knp_menu', $helper->getName());
+    }
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/autoload.php.dist

@@ -0,0 +1,23 @@
+<?php
+
+$vendorDir = __DIR__.'/../vendor';
+require_once $vendorDir.'/symfony/src/Symfony/Component/ClassLoader/UniversalClassLoader.php';
+
+use Symfony\Component\ClassLoader\UniversalClassLoader;
+
+$loader = new UniversalClassLoader();
+$loader->registerNamespaces(array(
+    'Symfony'   => $vendorDir.'/symfony/src',
+    'Knp\Menu' => $vendorDir.'/knp-menu/src',
+));
+$loader->register();
+
+spl_autoload_register(function($class) {
+    $class = ltrim($class, '\\');
+    if (0 === strpos($class, 'Knp\Bundle\MenuBundle\\')) {
+        $file = __DIR__.'/../'.str_replace('\\', '/', substr($class, strlen('Knp\Bundle\MenuBundle\\'))).'.php';
+        if (file_exists($file)) {
+            require $file;
+        }
+    }
+});

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/Tests/bootstrap.php

@@ -0,0 +1,7 @@
+<?php
+
+if (file_exists($file = __DIR__.'/autoload.php')) {
+    require_once $file;
+} elseif (file_exists($file = __DIR__.'/autoload.php.dist')) {
+    require_once $file;
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/UPGRADE.md

@@ -0,0 +1,229 @@
+Upgrade Instructions
+====================
+
+From pre 1.0 to now
+-------------------
+
+If you worked with this bundle before **Aug 30th, 2011**, then a number of
+changes have occurred to the bundle. To handle the changes, you have 2 options:
+
+**1) I'm cool, I don't really need to upgrade**
+
+No problem. The original version of the bundle was tagged and called `legacy`.
+You can lock KnpMenuBundle at the legacy version by adding a `version` option
+to the `[KnpMenuBundle]` entry of your `deps` file
+
+```
+[KnpMenuBundle]
+    git=https://github.com/KnpLabs/KnpMenuBundle.git
+    target=bundles/Knp/Bundle/MenuBundle
+    version=legacy
+```
+
+When you run `php bin/vendors install`, the original version of the bundle will
+be downloaded.
+
+**2) Let's upgrade!**
+
+The bundle has undergone a number of fundamental changes. We'll walk you
+through each one.
+
+### a) New setup
+
+To start, you'll need to add a new item to your `deps` file:
+
+```
+[knp-menu]
+    git=https://github.com/KnpLabs/KnpMenu.git
+```
+
+Next, make sure the `Knp` entries in your `app/autoload.php` file look like
+this:
+
+```php
+<?php
+// app/autoload.php
+
+$loader->registerNamespaces(array(
+    // ...
+    'Knp\Bundle' => __DIR__.'/../vendor/bundles',
+    'Knp\Menu'   => __DIR__.'/../vendor/knp-menu/src',
+    // ...
+));
+```
+
+### b) Working with menus
+
+Previously, a menu was just a class that you could instantiate. Now, you
+should use a menu factory to create menus. There have also been a few other
+changes in the syntax for creating menus. From inside a controller:
+
+**Before**:
+
+```php
+$menu = new MenuItem('My menu');
+$menu->addChild('Home', $this->generateUrl('homepage'));
+$menu->addChild('Comments', $this->generateUrl('comments'));
+```
+
+**After**:
+
+```php
+$menuFactory = $this->get('knp_menu.factory');
+
+$menu = $menuFactory->createItem('My menu');
+$menu->addChild('Home', array('uri' => $this->generateUrl('homepage')));
+$menu->addChild('Comments', array('uri' => $this->generateUrl('comments')));
+```
+
+### c) Menu classes
+
+Previously, you could create a menu class, make it a service, tag it with
+`knp_menu.menu`, and then render it in a Twig template. This is still possible,
+except that you would need to inject the `knp_menu.factory` service into
+your new menu. The new menu class might look something like this:
+
+```php
+<?php
+namespace Acme\MainBundle\Menu;
+
+use Knp\Menu\FactoryInterface;
+use Knp\Menu\MenuItem;
+
+class MainMenu extends MenuItem
+{
+    public function __construct(FactoryInterface $factory)
+    {
+        parent::__construct('Main Menu', $factory);
+
+        $this->addChild('Comments', array('route' => 'comments'));
+        // ...
+    }
+}
+```
+
+A better way, however, might be to have just one class - called a menu "builder" -
+which is responsible for creating as many different menus as you want. For
+example, a single `MenuBuilder` might have `createMainMenu` and `createSidebarMenu`
+methods, each which create a different menu.
+
+Let's look at how using a menu builder differs from the old approach of
+
+**Before**:
+
+```php
+<?php
+// src/Acme/MainBundle/Menu/MainMenu.php
+
+namespace Acme\MainBundle\Menu;
+
+use Knp\Bundle\MenuBundle\Menu;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\Routing\Router;
+
+class MainMenu extends Menu
+{
+    /**
+     * @param Request $request
+     * @param Router $router
+     */
+    public function __construct(Request $request, Router $router)
+    {
+        parent::__construct();
+
+        $this->setCurrentUri($request->getRequestUri());
+
+        $this->addChild('Home', $router->generate('homepage'));
+        // ... add more children
+    }
+}
+```
+
+**After**:
+
+```php
+<?php
+// src/Acme/MainBundle/Menu/MenuBuilder.php
+
+namespace Acme\MainBundle\Menu;
+
+use Knp\Menu\FactoryInterface;
+use Symfony\Component\HttpFoundation\Request;
+
+class MenuBuilder
+{
+    private $factory;
+
+    /**
+     * @param FactoryInterface $factory
+     */
+    public function __construct(FactoryInterface $factory)
+    {
+        $this->factory = $factory;
+    }
+
+    public function createMainMenu(Request $request)
+    {
+        $menu = $this->factory->createItem('root');
+        $menu->setCurrentUri($request->getRequestUri());
+
+        $menu->addChild('Home', array('route' => 'homepage'));
+        // ... add more children
+
+        return $menu;
+    }
+}
+```
+
+You'll still create a service for your "main" menu, but now, this will look
+a little bit different.
+
+**Before**:
+
+```yaml
+services:
+    acme_main.menu_main:
+        class:   Acme\MainBundle\Menu\MainMenu
+        tags:
+            -    { name: knp_menu.menu, alias: main }
+        arguments:
+            -    @request
+            -    @router
+```
+
+**After**:
+
+```yaml
+services:
+    # you'll just need this
+    acme_main.menu_builder:
+        class: Acme\MainBundle\Menu\MenuBuilder
+        arguments: ["@knp_menu.factory"]
+
+    acme_main.menu.main:
+        class: Knp\Menu\MenuItem # the service definition requires setting the class
+        factory_service: acme_hello.menu_builder
+        factory_method: createMainMenu
+        arguments: ["@request"]
+        scope: request # needed as we have the request as a dependency here
+        tags:
+            - { name: knp_menu.menu, alias: main } # The alias is what is used to retrieve the menu
+```
+
+The key difference is that the single builder itself needs to be registered
+as a service. Then, a tagged menu service is created for each method on the
+builder (e.g. `createMainMenu`) that creates a menu.
+
+Finally, rendering the menu in a template is a little bit different:
+
+**Before**:
+
+```jinja
+{{ knp_menu('main') }}
+```
+
+**After**:
+
+```jinja
+{{ knp_menu_render('main') }}
+```

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/composer.json

@@ -0,0 +1,29 @@
+{
+    "name":         "knplabs/knp-menu-bundle",
+    "description":  "This bundle provides an integration of the KnpMenu library",
+    "keywords":     ["menu"],
+    "type":         "symfony-bundle",
+    "license":      "MIT",
+    "authors":      [
+        {
+            "name":     "Knplabs",
+            "homepage": "http://knplabs.com"
+        },
+        {
+            "name":     "Christophe Coevoet",
+            "email":    "stof@notk.org"
+        },
+        {
+            "name":     "Symfony Community",
+            "homepage": "https://github.com/KnpLabs/KnpMenuBundle/contributors"
+        }
+    ],
+    "require":      {
+        "knplabs/knp-menu":         "1.1.*",
+        "symfony/framework-bundle": ">=2.0,<2.3-dev"
+    },
+    "autoload":     {
+        "psr-0": { "Knp\\Bundle\\MenuBundle": "" }
+    },
+    "target-dir": "Knp/Bundle/MenuBundle"
+}

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/phpunit.xml.dist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit colors="false" bootstrap="Tests/bootstrap.php">
+    <testsuites>
+        <testsuite name="KnpMenuBundle Test Suite">
+            <directory suffix="Test.php">./Tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./</directory>
+            <exclude>
+                <directory>./Resources</directory>
+                <directory>./Tests</directory>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>

vendor/knplabs/knp-menu-bundle/Knp/Bundle/MenuBundle/vendor/vendors.php

@@ -0,0 +1,23 @@
+#!/usr/bin/env php
+<?php
+
+set_time_limit(0);
+
+$vendorDir = __DIR__;
+$deps = array(
+    array('symfony', 'git://github.com/symfony/symfony.git', isset($_SERVER['SYMFONY_VERSION']) ? $_SERVER['SYMFONY_VERSION'] : 'origin/master'),
+    array('knp-menu', 'git://github.com/KnpLabs/KnpMenu.git', 'origin/master'),
+);
+
+foreach ($deps as $dep) {
+    list($name, $url, $rev) = $dep;
+
+    echo "> Installing/Updating $name\n";
+
+    $installDir = $vendorDir.'/'.$name;
+    if (!is_dir($installDir)) {
+        system(sprintf('git clone -q %s %s', escapeshellarg($url), escapeshellarg($installDir)));
+    }
+
+    system(sprintf('cd %s && git fetch -q origin && git reset --hard %s', escapeshellarg($installDir), escapeshellarg($rev)));
+}

vendor/knplabs/knp-menu/.gitignore

@@ -0,0 +1,4 @@
+/phpunit.xml
+/vendor/
+/composer.lock
+/composer.phar

vendor/knplabs/knp-menu/.travis.yml

@@ -0,0 +1,9 @@
+language: php
+
+php:
+    - 5.3
+    - 5.4
+
+before_script:
+    - wget -nc http://getcomposer.org/composer.phar
+    - php composer.phar install --dev

vendor/knplabs/knp-menu/CHANGELOG.md

@@ -0,0 +1,59 @@
+## 1.1.2 (2012-06-10)
+
+* Updated the Silex service provider for the change in the interface
+
+## 1.1.1 (2012-05-17)
+
+* Added the children attributes and the extras in the array export
+
+## 1.1.0 (2012-05-17)
+
+* Marked `Knp\Menu\ItemInterface::getCurrentItem` as deprecated
+* Added a recursive filter iterator keeping only displayed items
+* Added a filter iterator keeping only current items
+* Added a recursive iterator for the item
+* Fixed building an array of breadcrumbs when a label has only digits
+* Added a way to mark a label as safe
+* Refactored the ListRenderer to be consistent with the TwigRenderer and provide the same extension points
+* Added a way to attach extra data to an item
+* Removed unnecessary optimization in the TwigRenderer
+* Added some whitespace control in the Twig template to ensure an empty rendering is really empty
+* [BC break] Use the childrenAttributes for the root instead of the attributes
+* Made the default options configurable for the TwigRenderer
+* Added the support for menu registered as factory in PimpleProvider
+* Added a way to use the options in `knp_menu_get()` in Twig templates
+* Added an array of options for the MenuProviderInterface
+* Added a template to render an ordered list
+* Refactored the template a bit to make it easier to use an ordered list
+* Allow omitting the name of the child in `fromArray` (the key is used instead)
+
+## 1.0.0 (2011-12-03)
+
+* Add composer.json file
+* Added more flexible list element blocks
+* Add support for attributes on the children collection.
+* Added a default renderer
+* Added a ChainProvider for the menus.
+* Added the Silex extension
+* Added a RouterAwareFactory
+* Added an helper to be able to reuse the logic more easily for other templating engines
+* Added a way to retrieve an item using a path in a menu tree
+* Changed the toArray method to use a depth instead of simply using a boolean flag
+* Refactored the export to array and the creation from an array
+* Added better support for encoding problems when escaping a string in the ListRenderer
+* Added a Twig renderer
+* Added missing escaping in the ListRenderer
+* Renamed some methods in the ItemInterface
+* Removed the configuration of the current item as link from the item
+* Refactored the ListRenderer to use options
+* Changed the interface of callRecursively
+* Refactored the NodeInterface to be consistent
+* Moved the creation of the item to the factory
+* Added a Twig extension to render the menu easily
+* Changed the menu provider interface with a pimple-based implementation
+* Added a renderer provider to get a renderer by name and a Pimple-based implementation
+* Removed the renderer from the menu
+* Removed the num in the item by refactoring isLast and isFirst
+* Changed the RendererInterface to accept an array of options to be more flexible
+* Added an ItemInterface
+* Initial import of KnpMenuBundle decoupled classes with a new namespace

vendor/knplabs/knp-menu/README.markdown

@@ -0,0 +1,76 @@
+KnpMenu
+=======
+
+The KnpMenu library provides object oriented menus for PHP 5.3.
+It is used by the [KnpMenuBundle](https://github.com/KnpLabs/KnpMenuBundle) for Symfony2
+but can now be used stand-alone.
+
+[![Build Status](https://secure.travis-ci.org/KnpLabs/KnpMenu.png)](http://travis-ci.org/KnpLabs/KnpMenu)
+
+```php
+<?php
+
+use Knp\Menu\MenuFactory;
+use Knp\Menu\Renderer\ListRenderer;
+
+$factory = new MenuFactory();
+$menu = $factory->createItem('My menu');
+$menu->addChild('Home', array('uri' => '/'));
+$menu->addChild('Comments', array('uri' => '#comments'));
+$menu->addChild('Symfony2', array('uri' => 'http://symfony-reloaded.org/'));
+$menu->addChild('Coming soon');
+
+$renderer = new ListRenderer();
+echo $renderer->render($menu);
+```
+
+The above menu would render the following HTML:
+
+```html
+<ul>
+  <li class="first">
+    <a href="/">Home</a>
+  </li>
+  <li class="current">
+    <a href="#comments">Comments</a>
+  </li>
+  <li>
+    <a href="http://symfony-reloaded.org/">Symfony2</a>
+  </li>
+  <li class="last">
+    <span>Coming soon</span>
+  </li>
+</ul>
+```
+
+This way you can finally avoid writing an ugly template to show the selected item,
+the first and last items, submenus, ...
+
+> The bulk of the documentation can be found in the `doc` directory.
+
+## Installation
+
+KnpMenu does not provide an autoloader but follow the PSR-0 convention. You
+can use any compliant autoloader for the library, for instance the Symfony2
+[ClassLoader component](https://github.com/symfony/ClassLoader).
+Assuming you cloned the library in `vendor/KnpMenu`, it will be configured
+this way:
+
+```php
+<?php
+$loader->registerNamespaces(array(
+    'Knp\Menu' => __DIR__.'/vendor/KnpMenu/src'
+    // ...
+));
+```
+
+## What now?
+
+Follow the tutorial in `doc/01-Basics-Menus.markdown` and `doc/02-Twig-Integration.markdown`
+to discover how `KnpMenu` will rock your world!
+
+## Credits
+
+This bundle was originally ported from [ioMenuPlugin](http://github.com/weaverryan/ioMenuPlugin),
+a menu plugin for symfony1. It has since been developed by [knpLabs](http://www.knplabs.com) and
+the Symfony community.

vendor/knplabs/knp-menu/composer.json

@@ -0,0 +1,43 @@
+{
+    "name":         "knplabs/knp-menu",
+    "type":         "library",
+    "description":  "An object oriented menu library",
+    "keywords":     ["menu", "tree"],
+    "homepage":     "http://knplabs.com",
+    "license":      "MIT",
+    "authors":      [
+        {
+            "name":     "KnpLabs",
+            "homepage": "http://knplabs.com"
+        },
+        {
+            "name":     "Christophe Coevoet",
+            "email":    "stof@notk.org"
+        },
+        {
+            "name":     "Symfony Community",
+            "homepage": "https://github.com/KnpLabs/KnpMenu/contributors"
+        }
+    ],
+    "require":      {
+        "php":  ">=5.3.0"
+    },
+    "require-dev":  {
+        "pimple/pimple": "*",
+        "silex/silex":  "1.0.*",
+        "twig/twig":    ">=1.2,<2.0-dev"
+    },
+    "suggest":      {
+        "pimple/pimple": "for the built-in implementations of the menu provider and renderer provider",
+        "silex/silex":  "for the integration with your silex application",
+        "twig/twig":    "for the TwigRenderer and the integration with your templates"
+    },
+    "autoload":     {
+        "psr-0": { "Knp\\Menu\\": "src/" }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.1.x-dev"
+        }
+    }
+}

vendor/knplabs/knp-menu/doc/01-Basic-Menus.markdown

@@ -0,0 +1,297 @@
+Creating Menus: The Basics
+==========================
+
+Let's face it, creating menus sucks. Menus - a common aspect of any
+site - can range from being simple and mundane to giant monsters that
+become a headache to code and maintain.
+
+This bundle solves the issue by giving you a small, yet powerful and flexible
+framework for handling your menus. While most of the examples shown here
+are simple, the menus can grow arbitrarily large and deep.
+
+Creating a menu
+---------------
+
+The menu framework centers around one main interface: `Knp\Menu\ItemInterface`.
+Items are created by a factory implementing `Knp\Menu\FactoryInterface`.
+It's best to think of each `ItemInterface` object as an `<li>` tag that can
+hold children objects (`<li>` tags that are wrapped in a `<ul>` tag).
+For example:
+
+```php
+<?php
+
+use Knp\Menu\MenuFactory;
+use Knp\Menu\Renderer\ListRenderer;
+
+$factory = new MenuFactory();
+$menu = $factory->createItem('My menu');
+$menu->addChild('Home', array('uri' => '/'));
+$menu->addChild('Comments', array('uri' => '#comments'));
+$menu->addChild('Symfony2', array('uri' => 'http://symfony-reloaded.org/'));
+
+$renderer = new ListRenderer();
+echo $renderer->render($menu);
+```
+
+The above would render the following html code:
+
+```html
+<ul>
+  <li class="first">
+    <a href="/">Home</a>
+  </li>
+  <li class="current">
+    <a href="#comments">Comments</a>
+  </li>
+  <li class="last">
+    <a href="http://symfony-reloaded.org/">Symfony2</a>
+  </li>
+</ul>
+```
+
+>**NOTE**
+>The menu framework automatically adds `first` and `last` classes to each
+>`<li>` tag at each level for easy styling. Notice also that a `current`
+>class is added to the "current" menu item by uri and `current_ancestor`
+>to its ancestors (the classes are configurable) The above example assumes
+>the menu is being rendered on the `/comments` page, making the Comments
+>menu the "current" item.
+
+When the menu is rendered, it's actually spaced correctly so that it appears
+as shown in the source html. This is to allow for easier debugging and can
+be turned off by passing the `true` as the second argument to the renderer.
+
+```php
+<?php
+
+// ...
+
+$renderer = new ListRenderer(null, true);
+echo $renderer->render($menu);
+```
+
+You can also compress (or not compress) on a menu-by-menu basis by using the
+`compressed` option:
+
+```php
+<?php
+
+// ...
+
+$renderer = new ListRenderer();
+echo $renderer->render($menu, array('compressed' => true));
+```
+
+Working with your menu tree
+---------------------------
+
+Your menu tree works and acts like a multi-dimensional array. Specifically,
+it implements ArrayAccess, Countable and Iterator:
+
+```php
+<?php
+
+use Knp\Menu\MenuFactory;
+use Knp\Menu\Renderer\ListRenderer;
+
+$factory = new MenuFactory();
+$menu = $factory->createItem('My menu');
+$menu->addChild('Home', array('uri' => '/'));
+$menu->addChild('Comments');
+
+// ArrayAccess
+$menu['Comments']->setUri('#comments');
+$menu['Comments']->addChild('My comments', array('uri' => '/my_comments'));
+
+// Countable
+echo count($menu); // returns 2
+
+// Iterator
+foreach ($menu as $child) {
+  echo $child->getLabel();
+}
+```
+
+As you can see, the name you give your menu item (e.g. overview, comments)
+when creating it is the name you'll use when accessing it. By default,
+the name is also used when displaying the menu, but that can be overridden
+by setting the menu item's label (see below).
+
+Customizing each menu item
+--------------------------
+
+There are many ways to customize the output of each menu item. Each property
+can be customized in two ways: either by passing it as an option when creating
+the item, or by using the setter of an existing item.
+
+### The label
+
+By default, a menu item uses its name when rendering. You can easily
+change this without changing the name of your menu item by setting its label:
+
+```php
+<?php
+// Setting the label when creating the item
+$menu->addChild('Home', array('uri' => '/', 'label' => 'Back to homepage'));
+
+// Changing the label of an existing item
+$menu['Home']->setLabel('Back to homepage');
+```
+
+### The uri
+
+If an item isn't given a url, then text will be output instead of a link:
+
+```php
+<?php
+$menu->addChild('Not a link');
+$menu->addChild('Home', '/');
+$menu->addChild('Symfony', 'http://www.symfony-reloaded.org');
+```
+
+You can also specify the uri after creation via the `setUri()` method:
+
+```php
+<?php
+$menu['Home']->setUri('/');
+```
+
+>**NOTE**
+>If you want to remove the uri of an item, set it to `null`.
+
+### Menu attributes
+
+In fact, you can add any attribute to the `<li>` tag of a menu item. This
+can be done when creating a menu item or via the `setAttribute()` and `setAttributes()`
+methods:
+
+```php
+<?php
+$menu->addChild('Home', array('attributes' => array('id' => 'back_to_homepage')));
+$menu['Home']->setAttribute('id', 'back_to_homepage');
+```
+
+>**NOTE**
+>`setAttributes()` will overwrite all existing attributes.
+
+>**NOTE**
+>To remove an existing attribute, set it to `null`. It will not be rendered.
+
+You can also add link attributes (displayed on the `<a>` element), label
+attributes (displayed on the `<span>` element when it is not a link) or
+children attributes (rendered on the `<ul>` containing the list of children):
+
+```php
+<?php
+$menu->addChild('KnpLabs.com', array('uri' => 'http://knplabs.com'));
+$menu['KnpLabs.com']->setLinkAttribute('class', 'external-link');
+
+$menu->addChild('Not a link');
+$menu['Not a link']->setLabelAttribute('class', 'no-link-span');
+
+$menu->setChildrenAttribute('class', 'pull-left');
+```
+
+>**NOTE**
+>For the root element, only the children attributes are used as only the
+>`<ul>` element is displayed.
+
+>**NOTE**
+>In the 1.0 version of the library, the attributes were rendered on the root
+>element instead of rendering the children attributes, which was inconsistent
+>and has been changed for 1.1.
+
+### Rendering only part of a menu
+
+If you need to render only part of your menu, the menu framework gives
+you unlimited control to do so:
+
+```php
+<?php
+// render only 2 levels deep (root, parents, children)
+$renderer->render($menu, array('depth' => 2));
+
+// rendering everything except for the children of the Home branch
+$menu['Home']->setDisplayChildren(false);
+$renderer->render($menu);
+
+// render everything except for Home AND its children
+$menu['Home']->setDisplay(false);
+$renderer->render($menu);
+```
+
+Using the above controls, you can specify exactly which part of your menu
+you need to render at any given time.
+
+### Other rendering options
+
+Most renderers also support several other options, which can be passed as
+the second argument to the `render()` method:
+
+* `depth`
+* `currentAsLink` (default: `true`)
+* `currentClass` (default: `current`)
+* `ancestorClass` (default: `current_ancestor`)
+* `firstClass` (default: `first`)
+* `lastClass` (default:  `last`)
+* `compressed` (default: `false`)
+* `allow_safe_labels` (default: `false`)
+
+>**NOTE**
+>When setting the `allow_safe_labels` option to `true`, you can specify that
+>a label should not be escaped by the renderer by adding the `safe_label`
+>extra in the item. Use it with caution as it can create some XSS holes in
+>your application if the label is coming from the user.
+
+The Current Menu Item
+---------------------
+
+If the URI of a menu item matches the current URL, a `current` class will
+be added to the `li` around that item, as well as a `current_ancestor` around
+any of its parent `li` elements.
+
+But this is not done magically. In order for this to work, you must set the
+current URI on the root menu item:
+
+```php
+<?php
+
+use Knp\Menu\MenuFactory;
+use Knp\Menu\Renderer\ListRenderer;
+
+$factory = new MenuFactory();
+$menu = $factory->createItem('My menu');
+
+// set the current URL
+$menu->setCurrentUri('/my_comments');
+// $menu->setCurrentUri($_REQUEST['PATH_INFO]);
+
+// ...
+```
+
+Alternatively, you can manually set which menu item should be marked as current,
+independent of the current URL:
+
+```php
+<?php
+// ...
+
+$menu['Comments']->setCurrent(true);
+
+// ...
+```
+
+Creating a Menu from a Tree structure
+-------------------------------------
+
+You can create a menu easily from a Tree structure (a nested set for example) by
+making it implement ``Knp\Menu\NodeInterface``. You will then be able
+to create the menu easily (assuming ``$node`` is the root node of your structure):
+
+```php
+<?php
+
+$factory = new \Knp\Menu\MenuFactory();
+$menu = $factory->createFromNode($node);
+```

vendor/knplabs/knp-menu/doc/02-Twig-Integration.markdown

@@ -0,0 +1,272 @@
+Twig Integration
+================
+
+KnpMenu provides 2 different (and complementary) integrations with Twig:
+
+* [MenuExtension](#menu-extension): a Twig extension allowing you to easily render menus from within a Twig template
+
+* [TwigRenderer](#twig-renderer): a Twig renderer that (behind the scenes) uses a Twig template to render the menu
+
+<a name="menu-extension"></a>
+
+Using the MenuExtension
+-----------------------
+
+The easiest (but not best) way to render a menu inside a Twig template is
+to pass both the renderer and menu into a template:
+
+```php
+<?php
+
+// bootstrap Twig
+$twigLoader = new \Twig_Loader_Filesystem(array(
+    // path to your templates
+));
+$twig = new \Twig_Environment($twigLoader);
+
+// setup some renderer
+$renderer = new \Knp\Menu\Renderer\ListRenderer();
+//$menuRenderer = new \Knp\Menu\Renderer\TwigRenderer($twig, 'knp_menu.html.twig');
+
+// render a template
+$template = $twig->loadTemplate('menu.twig');
+echo $template->display(array(
+    'renderer' => $renderer,
+    'menu' => $menu
+));
+```
+
+To render the menu, your template would look like this:
+
+```jinja
+{{ renderer.render(menu) | raw }}
+```
+
+This is ok, but there is a better way. By configuring all of your renderers
+and menus in a central location, you can use a convenient and shorthand syntax
+to render your menus inside a Twig template.
+
+<a name="renderer-provider"></a>
+
+### Loading your renderers from a provider
+
+To make life simpler, a good option is to centralize the setup of all of
+your renderers. To do this, you'll need to create a "renderer provider", which
+is some object - implementing `Knp\Menu\Renderer\RendererProviderInterface` -
+which acts like a container for all of your renderers.
+
+The default implementation of the renderer provider is based on [Pimple](http://pimple-project.org/)
+so that your renderers can be lazy-loaded.
+
+```php
+<?php
+// setup pimple, and assign the renderer to "menu_renderer"
+$pimple = new \Pimple();
+$pimple['list_renderer'] = function() {
+    return new \Knp\Menu\Renderer\ListRenderer();
+};
+
+$rendererProvider = new \Knp\Menu\Renderer\PimpleProvider(
+    $pimple,
+    // common name of the renderer used by default
+    'main',
+    // common name for the renderer => name of the renderer in pimple
+    array('main' => 'list_renderer')
+);
+$helper = new \Knp\Menu\Twig\Helper($rendererProvider);
+$menuExtension = new \Knp\Menu\Twig\MenuExtension($helper);
+$twig->addExtension($menuExtension);
+```
+
+Now, the renderer is aliased to the name `main`. You can render the menu
+with the default renderer simply via:
+
+```jinja
+{{ knp_menu_render(menu) }}
+```
+
+In this example, `menu` variable is the  `MenuItem` object you've passed
+into your template.
+
+You can also pass options when rendering the template:
+
+```jinja
+{{ knp_menu_render(menu, {'currentAsLink': false, 'compressed': true}) }}
+```
+
+You can also use another renderer than the default one by passing its name:
+
+```jinja
+{{ knp_menu_render(menu, {}, 'main') }}
+```
+
+<a name="get-item-by-path"></a>
+
+### Retrieving an item by its path in the tree
+
+The Twig extension allow you to retrieve an item in your menu tree by its
+path (the name of the item is used in the path):
+
+```jinja
+{# The menu variable contains a Knp\Menu\ItemInterface object #}
+{% set item = knp_menu_get(menu, ['Comment', 'My comments']) %}
+
+{# The following could be used but would throw a Fatal Error for some invalid
+paths instead of an exception: #}
+{% set item = menu['Comment']['My comments'] %}
+
+{# actually render the part of the menu #}
+{{ knp_menu_render(item) }}
+```
+
+>**NOTE**
+>An InvalidArgumentException will be thrown if the path is invalid.
+
+Using the path is also supported when using the `knp_menu_render` function
+by using an array:
+
+```jinja
+{# The menu variable contains a Knp\Menu\ItemInterface object #}
+{{ knp_menu_render([menu, 'Comment', 'My comments']) }}
+```
+
+<a name="menu-provider"></a>
+
+### Loading the menu from a provider
+
+The MenuExtension also supports retrieving the menus from a provider implementing
+`Knp\Menu\Provider\MenuProviderInterface` which works the same way as the
+`RendererProviderInterface`. The default implementation is also based on
+Pimple.
+
+```php
+<?php
+$factory = new MenuFactory();
+
+$pimple = new \Pimple();
+// setup the renderer(s) in Pimple
+
+$pimple['menu_main'] = function() use ($factory) {
+    $menu = $factory->createItem('My menu');
+    // setup the menu
+
+    return $menu;
+};
+$pimple['menu_sidebar'] = ... //
+
+// $rendererProvider = ...
+$menuProvider = new \Knp\Menu\Provider\PimpleProvider(
+    $pimple,
+    array('main' => 'main_menu', 'sidebar' => 'menu_sidebar')
+);
+$helper = new \Knp\Menu\Twig\Helper($rendererProvider, $menuProvider);
+$menuExtension = new \Knp\Menu\Twig\MenuExtension($helper);
+```
+
+You can now retrieve the menu by its name in the template:
+
+```jinja
+{% set menu = knp_menu_get('sidebar') %}
+{# The menu variable now contains a Knp\Menu\ItemInterface object #}
+```
+
+When a menu provider is set, you can also use the menu name instead of the
+menu object in the other functions:
+
+```jinja
+{{ knp_menu_render('main', {'depth': 1}) }}
+
+{{ knp_menu_render(['main', 'Comments', 'My comments'], {'depth': 2}) }}
+
+{% set item = knp_menu_get('sidebar', ['First section']) %}
+```
+
+In some cases, you may want to build the menu differently according to the
+place it is used. As of KnpMenu 1.1, the ``knp_menu_get`` function supports
+passing an array of options for the menu provider.
+
+To be able to use these options in the Pimple provide, you should register
+the menu as a factory closure through ``$pimple->protect()``. It will then
+be called with the array of options as first argument and the pimple instance
+as second argument:
+
+```php
+<?php
+$factory = new MenuFactory();
+
+$pimple = new \Pimple();
+// setup the renderer(s) in Pimple
+
+$pimple['menu_main'] = $pimple->protect(function(array $options, $c) use ($factory) {
+    $menu = $factory->createItem('My menu');
+    // setup the menu
+    // you can use the options you passed to the provider
+    // and access the pimple container for this.
+
+    return $menu;
+});
+```
+
+<a name="twig-renderer"></a>
+
+Using the TwigRenderer
+----------------------
+
+### Registering the renderer
+
+To use the TwigRenderer, you need to add the path of the template in the loader
+when bootstrapping Twig.
+
+```php
+<?php
+
+$twigLoader = new \Twig_Loader_Filesystem(array(
+    __DIR__.'/vendor/KnpMenu/src/Knp/Menu/Resources/views',
+    // your own paths
+));
+$twig = new \Twig_Environment($twigLoader);
+$menuRenderer = new \Knp\Menu\Renderer\TwigRenderer($twig, 'knp_menu.html.twig');
+```
+
+This works just like any other renderer, and will output an un-ordered list
+of menu items (e.g. `ul` and `li` elements):
+
+```php
+<?php
+echo $menuRenderer->render($menu);
+```
+
+Behind the scenes, the renderer is using a Twig template to render the menu.
+This template can be customized by you.
+
+>**NOTE**
+>A second template named `knp_menu_ordered.html.twig` can be used if you
+>want to render the menu using an ordered list. This template extends the
+>previous one which must be available using the `knp_menu.html.twig` name
+>(which is the case when configuring the loader like previously).
+
+### Using a custom template
+
+If you need to customize how the template is rendered - beyond all of the
+options given to you by modifying the menu items themselves - you can customize
+the Twig template that renders the menu.
+
+You can change the template used to render the menu in two different ways:
+
+1) Globally: Change the second argument passed to the constructor of the renderer.
+
+2) Locally: Pass a `template` option when rendering the menu
+
+```php
+<?php
+echo $menuRenderer->render($menu, array('template' => 'my_menu.html.twig'));
+```
+
+The template needs to contain 2 blocks: `root` and `compressed_root` which
+are used to display the root of the menu. The easiest way to customize the
+rendering is to extend the built-in template and to replace the block you
+want.
+
+>**NOTE**
+>The built-in templates contains some additional blocks to make it easier
+>to customize it when using the inheritance.

vendor/knplabs/knp-menu/doc/03-Silex-Integration.markdown

@@ -0,0 +1,78 @@
+Silex Integration
+=================
+
+KnpMenu provides an extension for the [Silex](http://silex-project.org/)
+microframework.
+
+RouterAwareFactory
+------------------
+
+The `Knp\Menu\Silex\RouterAwareFactory` extends the default factory to add
+the support of the url generator of the Symfony2 Routing component. You can
+then pass 3 new options to the factory:
+
+* `route`: The route name (the generator will be used if the name is not `null`)
+* `routeParameters`: The parameters to generate the url (if omitted, an empty array is used)
+* `routeAbsolute`: Whether the generated url should be absolute (default `false`)
+
+>**NOTE**
+>When you give both a route and an uri to the factory, the route will be used.
+
+Using the KnpMenuExtension
+--------------------------
+
+### Registering the extension
+
+```php
+<?php
+
+// registering the autoloader for the library.
+$app['autoloader']->registerNamespace('Knp\Menu', __DIR__.'/vendor/KnpMenu/src');
+
+// registering the extension
+$app->register(new \Knp\Menu\Silex\KnpMenuServiceProvider());
+```
+
+>**WARNING**
+>The Twig integration is available only when the KnpMenuServiceProvider is registered
+>**after** the TwigServiceProvider in your application.
+
+#### Parameters
+
+* **knp_menu.menus** (optional): an array of ``alias => id`` pair for the
+  [menu provider](02-Twig-Integration.markdown#menu-provider).
+* **knp_menu.renderers** (optional): an array of ``alias => id`` pair for
+  the [renderer provider]((02-Twig-Integration.markdown#renderer-provider)).
+* **knp_menu.default_renderer** (optional): the alias of the default renderer (default to `'list'`)
+* **knp_menu.template** (optional): The template used by default by the TwigRenderer.
+
+#### Services
+
+* **knp_menu.factory**: The menu factory (it is a router-aware one if the
+  UrlGeneratorExtension is registered)
+* **knp_menu.renderer.list**: The ListRenderer
+* **knp_menu.renderer.twig**: The TwigRenderer (only when the Twig integration is available)
+
+### Adding your menu to the menu provider
+
+Making your menu available through the menu provider is really easy. Simply
+create the menu as a service in the application and register it in the parameter:
+
+```php
+<?php
+
+$app['my_main_menu'] = function($app) {
+    $menu = $app['knp_menu.factory']->createItem('root');
+    $menu->setCurrentUri($app['request']->getRequestUri());
+
+    $menu->addChild('Home', array('route' => 'homepage'));
+    // ... add more children
+
+    return $menu;
+};
+
+$app['knp_menu.menus'] = array('main' => 'my_main_menu');
+```
+
+Your menu is now available in the [menu provider](02-Twig-Integration.markdown#menu-provider)
+with the name `main`.

vendor/knplabs/knp-menu/doc/04-Iterators.md

@@ -0,0 +1,173 @@
+Iterating over Menus
+====================
+
+The simplest way to iterate over your item object is to iterate over its
+direct children, thanks to the `IteratorAggregate` implementation. But the
+PHP iterators allow much more powerful options to deal with our tree structure.
+
+All the examples in this chapter will use the following tree:
+
+```
+         A
+       /   \
+     /       \
+   B          C
+ / | \      /   \
+D  E  F    G     H
+|          |
+I          J
+```
+
+Iterating recursively
+---------------------
+
+The `Knp\Menu\Iterator\RecursiveItemIterator` allows you to iterate recursively
+over a tree of items. Using it is really easy: give it an item, and you will
+have a recursive iterator on this item.
+
+```php
+<?php
+
+$menu = /* get your root item from somewhere */;
+
+// create the iterator
+$itemIterator = new \Knp\Menu\Iterator\RecursiveItemIterator($menu);
+
+// iterate recursively on the iterator
+$iterator = new \RecursiveIteratorIterator($itemIterator, \RecursiveIteratorIterator::SELF_FIRST);
+
+foreach ($iterator as $item) {
+    echo $item->getName() . " ";
+}
+```
+
+The output will be:
+
+```
+B D I E F C G J H
+```
+
+Changing the second argument to `\RecursiveIteratorIterator::CHILD_FIRST`
+allows you to visit children before their parent and will produce the following
+order:
+
+```
+I D E F B J G H C
+```
+
+>**NOTE**
+>If you iterate over the `RecursiveItemIterator` without wrapping it in the
+>`\RecursiveIteratorIterator`, it will simply give you the direct children
+>like when using the iterator of the item.
+
+As you can see, the final iterator does not contain the root item (``A``).
+The reason is simple: the recursive iteration started only on its children.
+Fortunately, the `RecursiveItemIterator` accept any iterator over menu items,
+not only items themselves. This allows you to add the root item in the final
+iterator by changing the iterator wrapped in the `RecursiveItemIterator`:
+
+```php
+<?php
+
+$menu = /* get your root item from somewhere */;
+
+// create an iterator containing only the root item
+$rootIterator = new \ArrayIterator(array($menu));
+
+// create the item iterator
+$itemIterator = new \Knp\Menu\Iterator\RecursiveItemIterator($rootIterator);
+
+// iterate recursively on the iterator
+$iterator = new \RecursiveIteratorIterator($itemIterator, \RecursiveIteratorIterator::SELF_FIRST);
+
+foreach ($iterator as $item) {
+    echo $item->getName() . " ";
+}
+```
+
+The output will now contain the root item:
+
+```
+A B D I E F C G J H
+```
+
+Filtering only current items
+----------------------------
+
+Getting the current items is easy with the `Knp\Menu\Iterator\CurrentItemFilterIterator`.
+It is a filter iterator applied on another iterator.
+
+```php
+<?php
+
+$root = /* get your root item from somewhere */;
+$menu = $root['B'];
+
+// create the iterator
+$iterator = new \Knp\Menu\Iterator\CurrentItemFilterIterator($menu->getIterator());
+
+foreach ($iterator as $item) {
+    echo $item->getName() . " ";
+}
+```
+
+Assuming that D and F are current whereas E is not, this will output ``D F``.
+
+Getting the current item of the whole tree is simply done by applying the
+filter on the previous recursive iterator:
+
+```php
+<?php
+
+$menu = /* get your root item from somewhere */;
+
+$treeIterator = new \RecursiveIteratorIterator(
+    new \Knp\Menu\Iterator\RecursiveItemIterator(
+        new \ArrayIterator(array($menu))
+    ),
+    \RecursiveIteratorIterator::SELF_FIRST
+);
+
+$iterator = new \Knp\Menu\Iterator\CurrentItemFilterIterator($treeIterator);
+
+foreach ($iterator as $item) {
+    echo $item->getName() . " ";
+}
+```
+
+Filtering only displayed items
+------------------------------
+
+The `Knp\Menu\Iterator\DisplayedItemFilterIterator` allows you to filter
+items to keep only displayed ones. As hiding an item also hides its children,
+this filter is a recursive filter iterator and is applied on the recursive
+iterator, not on the flattened iterator.
+
+```php
+<?php
+
+$menu = /* get your root item from somewhere */;
+
+// create an iterator containing only the root item
+$rootIterator = new \ArrayIterator(array($menu));
+
+// create the item iterator
+$itemIterator = new \Knp\Menu\Iterator\RecursiveItemIterator($rootIterator);
+
+// wrap the iterator in the filter iterator
+$filteredIterator = new \Knp\Menu\Iterator\DisplayedItemFilterIterator($itemIterator);
+
+// iterate recursively on the iterator
+$iterator = new \RecursiveIteratorIterator($filteredIterator, \RecursiveIteratorIterator::SELF_FIRST);
+
+foreach ($iterator as $item) {
+    echo $item->getName() . " ";
+}
+```
+
+Assuming that E and F are hidden, and that C is displayed but hides its children,
+the output will be:
+
+```
+A B D I C
+```

vendor/knplabs/knp-menu/phpunit.xml.dist

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit colors="false" bootstrap="tests/bootstrap.php">
+    <testsuites>
+        <testsuite name="KnpMenu Test Suite">
+            <directory suffix="Test.php">./tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./src</directory>
+        </whitelist>
+    </filter>
+</phpunit>

vendor/knplabs/knp-menu/src/Knp/Menu/FactoryInterface.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Knp\Menu;
+
+/**
+ * Interface implemented by the factory to create items
+ */
+interface FactoryInterface
+{
+    /**
+     * Creates a menu item
+     *
+     * @param string $name
+     * @param array $options
+     * @return \Knp\Menu\ItemInterface
+     */
+    function createItem($name, array $options = array());
+
+    /**
+     * Create a menu item from a NodeInterface
+     *
+     * @param \Knp\Menu\NodeInterface $node
+     * @return \Knp\Menu\ItemInterface
+     */
+    function createFromNode(NodeInterface $node);
+
+    /**
+     * Creates a new menu item (and tree if $data['children'] is set).
+     *
+     * The source is an array of data that should match the output from MenuItem->toArray().
+     *
+     * @param  array $data The array of data to use as a source for the menu tree
+     * @return \Knp\Menu\ItemInterface
+     */
+    function createFromArray(array $data);
+}

vendor/knplabs/knp-menu/src/Knp/Menu/ItemInterface.php

@@ -0,0 +1,593 @@
+<?php
+
+namespace Knp\Menu;
+
+/**
+ * Interface implemented by a menu item.
+ *
+ * It roughly represents a single <li> tag and is what you should interact with
+ * most of the time by default.
+ * Originally taken from ioMenuPlugin (http://github.com/weaverryan/ioMenuPlugin)
+ */
+interface ItemInterface extends  \ArrayAccess, \Countable, \IteratorAggregate
+{
+    /**
+     * @return string
+     */
+    function getName();
+
+    /**
+     * Renames the item.
+     *
+     * This method must also update the key in the parent.
+     *
+     * Provides a fluent interface
+     *
+     * @param  string $name
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setName($name);
+
+    /**
+     * @param  \Knp\Menu\FactoryInterface $factory
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setFactory(FactoryInterface $factory);
+
+    /**
+     * Get the uri for a menu item
+     *
+     * @return string
+     */
+    function getUri();
+
+    /**
+     * Set the uri for a menu item
+     *
+     * Provides a fluent interface
+     *
+     * @param  string $uri The uri to set on this menu item
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setUri($uri);
+
+    /**
+     * Returns the label that will be used to render this menu item
+     *
+     * Defaults to the name of no label was specified
+     *
+     * @return string
+     */
+    function getLabel();
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param  string $label    The text to use when rendering this menu item
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setLabel($label);
+
+    /**
+     * @return array
+     */
+    function getAttributes();
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param  array $attributes
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setAttributes(array $attributes);
+
+    /**
+     * @param  string $name     The name of the attribute to return
+     * @param  mixed  $default  The value to return if the attribute doesn't exist
+     * @return mixed
+     */
+    function getAttribute($name, $default = null);
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param string $name
+     * @param mixed $value
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setAttribute($name, $value);
+
+    /**
+     * @return array
+     */
+    function getLinkAttributes();
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param  array $linkAttributes
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setLinkAttributes(array $linkAttributes);
+
+    /**
+     * @param  string $name     The name of the attribute to return
+     * @param  mixed  $default  The value to return if the attribute doesn't exist
+     * @return mixed
+     */
+    function getLinkAttribute($name, $default = null);
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param string $name
+     * @param string $value
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setLinkAttribute($name, $value);
+
+    /**
+     * @return array
+     */
+    function getChildrenAttributes();
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param  array $childrenAttributes
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setChildrenAttributes(array $childrenAttributes);
+
+    /**
+     * @param  string $name     The name of the attribute to return
+     * @param  mixed  $default  The value to return if the attribute doesn't exist
+     * @return mixed
+     */
+    function getChildrenAttribute($name, $default = null);
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param string $name
+     * @param string $value
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setChildrenAttribute($name, $value);
+
+    /**
+     * @return array
+     */
+    function getLabelAttributes();
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param  array $labelAttributes
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setLabelAttributes(array $labelAttributes);
+
+    /**
+     * @param  string $name     The name of the attribute to return
+     * @param  mixed  $default  The value to return if the attribute doesn't exist
+     * @return mixed
+     */
+    function getLabelAttribute($name, $default = null);
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param string $name
+     * @param mixed $value
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setLabelAttribute($name, $value);
+
+    /**
+     * @return array
+     */
+    function getExtras();
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param  array $extras
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setExtras(array $extras);
+
+    /**
+     * @param  string $name     The name of the extra to return
+     * @param  mixed  $default  The value to return if the extra doesn't exist
+     * @return mixed
+     */
+    function getExtra($name, $default = null);
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param string $name
+     * @param mixed $value
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setExtra($name, $value);
+
+    /**
+     * Whether or not this menu item should show its children.
+     *
+     * @return boolean
+     */
+    function getDisplayChildren();
+
+    /**
+     * Set whether or not this menu item should show its children
+     *
+     * Provides a fluent interface
+     *
+     * @param boolean $bool
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setDisplayChildren($bool);
+
+    /**
+     * Whether or not to display this menu item
+     *
+     * @return boolean
+     */
+    function isDisplayed();
+
+    /**
+     * Set whether or not this menu should be displayed
+     *
+     * Provides a fluent interface
+     *
+     * @param boolean $bool
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setDisplay($bool);
+
+    /**
+     * Add a child menu item to this menu
+     *
+     * Returns the child item
+     *
+     * @param mixed $child   An ItemInterface instance or the name of a new item to create
+     * @param array $options If creating a new item, the options passed to the factory for the item
+     * @return \Knp\Menu\ItemInterface
+     */
+    function addChild($child, array $options = array());
+
+    /**
+     * Returns the child menu identified by the given name
+     *
+     * @param  string $name  Then name of the child menu to return
+     * @return \Knp\Menu\ItemInterface|null
+     */
+    function getChild($name);
+
+    /**
+     * Moves child to specified position. Rearange other children accordingly.
+     *
+     * Provides a fluent interface
+     *
+     * @param integer $position Position to move child to.
+     * @return \Knp\Menu\ItemInterface
+     */
+    function moveToPosition($position);
+
+    /**
+     * Moves child to specified position. Rearange other children accordingly.
+     *
+     * Provides a fluent interface
+     *
+     * @param \Knp\Menu\ItemInterface $child Child to move.
+     * @param integer $position Position to move child to.
+     * @return \Knp\Menu\ItemInterface
+     */
+    function moveChildToPosition(ItemInterface $child, $position);
+
+    /**
+     * Moves child to first position. Rearange other children accordingly.
+     *
+     * Provides a fluent interface
+     *
+     * @return \Knp\Menu\ItemInterface
+     */
+    function moveToFirstPosition();
+
+    /**
+     * Moves child to last position. Rearange other children accordingly.
+     *
+     * Provides a fluent interface
+     *
+     * @return \Knp\Menu\ItemInterface
+     */
+    function moveToLastPosition();
+
+    /**
+     * Reorder children.
+     *
+     * Provides a fluent interface
+     *
+     * @param array $order New order of children.
+     * @return \Knp\Menu\ItemInterface
+     */
+    function reorderChildren($order);
+
+    /**
+     * Makes a deep copy of menu tree. Every item is copied as another object.
+     *
+     * @return \Knp\Menu\ItemInterface
+     */
+    function copy();
+
+    /**
+     * Get slice of menu as another menu.
+     *
+     * If offset and/or length are numeric, it works like in array_slice function:
+     *
+     *   If offset is non-negative, slice will start at the offset.
+     *   If offset is negative, slice will start that far from the end.
+     *
+     *   If length is null, slice will have all elements.
+     *   If length is positive, slice will have that many elements.
+     *   If length is negative, slice will stop that far from the end.
+     *
+     * It's possible to mix names/object/numeric, for example:
+     *   slice("child1", 2);
+     *   slice(3, $child5);
+     * Note: when using a child as limit, it will not be included in the returned menu.
+     * the slice is done before this menu.
+     *
+     * @param mixed $offset Name of child, child object, or numeric offset.
+     * @param mixed $length Name of child, child object, or numeric length.
+     * @return \Knp\Menu\ItemInterface
+     */
+    function slice($offset, $length = 0);
+
+    /**
+     * Split menu into two distinct menus.
+     *
+     * @param mixed $length Name of child, child object, or numeric length.
+     * @return array Array with two menus, with "primary" and "secondary" key
+     */
+    function split($length);
+
+    /**
+     * Returns the level of this menu item
+     *
+     * The root menu item is 0, followed by 1, 2, etc
+     *
+     * @return integer
+     */
+    function getLevel();
+
+    /**
+     * Returns the root ItemInterface of this menu tree
+     *
+     * @return \Knp\Menu\ItemInterface
+     */
+    function getRoot();
+
+    /**
+     * Returns whether or not this menu item is the root menu item
+     *
+     * @return boolean
+     */
+    function isRoot();
+
+    /**
+     * @return MenuItem|null
+     */
+    function getParent();
+
+    /**
+     * Used internally when adding and removing children
+     *
+     * Provides a fluent interface
+     *
+     * @param \Knp\Menu\ItemInterface|null $parent
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setParent(ItemInterface $parent = null);
+
+    /**
+     * Return the children as an array of ItemInterface objects
+     *
+     * @return array
+     */
+    function getChildren();
+
+    /**
+     * Provides a fluent interface
+     *
+     * @param  array $children An array of ItemInterface objects
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setChildren(array $children);
+
+    /**
+     * Removes a child from this menu item
+     *
+     * Provides a fluent interface
+     *
+     * @param mixed $name The name of ItemInterface instance or the ItemInterface to remove
+     * @return \Knp\Menu\ItemInterface
+     */
+    function removeChild($name);
+
+    /**
+     * @return \Knp\Menu\ItemInterface
+     */
+    function getFirstChild();
+
+    /**
+     * @return \Knp\Menu\ItemInterface
+     */
+    function getLastChild();
+
+    /**
+     * Returns whether or not this menu items has viewable children
+     *
+     * This menu MAY have children, but this will return false if the current
+     * user does not have access to view any of those items
+     *
+     * @return boolean
+     */
+    function hasChildren();
+
+    /**
+     * A string representation of this menu item
+     *
+     * e.g. Top Level > Second Level > This menu
+     *
+     * @param string $separator
+     * @return string
+     */
+    function getPathAsString($separator = ' > ');
+
+    /**
+     * Renders an array of label => uri pairs ready to be used for breadcrumbs.
+     *
+     * The subItem can be one of the following forms
+     *   * 'subItem'
+     *   * array('subItem' => '@homepage')
+     *   * array('subItem1', 'subItem2')
+     *
+     * @example
+     * // drill down to the Documentation menu item, then add "Chapter 1" to the breadcrumb
+     * $arr = $menu['Documentation']->getBreadcrumbsArray('Chapter 1');
+     * foreach ($arr as $name => $url)
+     * {
+     *
+     * }
+     *
+     * @param  mixed $subItem A string or array to append onto the end of the array
+     * @return array
+     */
+    function getBreadcrumbsArray($subItem = null);
+
+    /**
+     * Returns the current menu item if it is a child of this menu item
+     *
+     * @return \Knp\Menu\ItemInterface|null
+     * @deprecated this method is flawed and will be removed in 2.0
+     * @see \Knp\Menu\Iterator\CurrentItemFilterIterator
+     */
+    function getCurrentItem();
+
+    /**
+     * Set whether or not this menu item is "current"
+     *
+     * Provides a fluent interface
+     *
+     * @param boolean $bool Specify that this menu item is current
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setCurrent($bool);
+
+    /**
+     * Get whether or not this menu item is "current"
+     *
+     * @return boolean
+     */
+    function isCurrent();
+
+    /**
+     * Returns whether or not this menu is an ancestor of the current menu item
+     *
+     * @return boolean
+     */
+    function isCurrentAncestor();
+
+    /**
+     * Whether or not this menu item is last in its parent
+     *
+     * @return boolean
+     */
+    function isLast();
+
+    /**
+     * Whether or not this menu item is first in its parent
+     *
+     * @return boolean
+     */
+    function isFirst();
+
+    /**
+     * Whereas isFirst() returns if this is the first child of the parent
+     * menu item, this function takes into consideration whether children are rendered or not.
+     *
+     * This returns true if this is the first child that would be rendered
+     * for the current user
+     *
+     * @return boolean
+     */
+    function actsLikeFirst();
+
+    /**
+     * Whereas isLast() returns if this is the last child of the parent
+     * menu item, this function takes into consideration whether children are rendered or not.
+     *
+     * This returns true if this is the last child that would be rendered
+     * for the current user
+     *
+     * @return boolean
+     */
+    function actsLikeLast();
+
+    /**
+     * Returns the current uri, which is used for determining the current
+     * menu item.
+     *
+     * If the uri isn't set, this asks the parent menu for its current uri.
+     * This would recurse up the tree until the root is hit. Once the root
+     * is hit, if it still doesn't know the currentUri, it gets it from the
+     * request object.
+     *
+     * @return string
+     */
+    function getCurrentUri();
+
+    /**
+     * Sets the current uri, used when determining the current menu item
+     *
+     * This will set the current uri on the root menu item, which all other
+     * menu items will use
+     *
+     * Provides a fluent interface
+     *
+     * @param string $uri
+     * @return \Knp\Menu\ItemInterface
+     */
+    function setCurrentUri($uri);
+
+    /**
+     * Calls a method recursively on all of the children of this item
+     *
+     * @example
+     * $menu->callRecursively('setShowChildren', array(false));
+     *
+     * Provides a fluent interface
+     *
+     * @param string $method
+     * @param array $arguments
+     * @return \Knp\Menu\ItemInterface
+     */
+    function callRecursively($method, $arguments = array());
+
+    /**
+     * Exports this menu item to an array
+     *
+     * The children are exported until the specified depth:
+     *      null: no limit
+     *      0: no children
+     *      1: only direct children
+     *      ...
+     *
+     * @param integer $depth
+     * @return array
+     */
+    function toArray($depth = null);
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Iterator/CurrentItemFilterIterator.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Knp\Menu\Iterator;
+
+/**
+ * Filter iterator keeping only current items
+ */
+class CurrentItemFilterIterator extends \FilterIterator
+{
+    public function accept()
+    {
+        return $this->current()->isCurrent();
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Iterator/DisplayedItemFilterIterator.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Knp\Menu\Iterator;
+
+/**
+ * Filter iterator keeping only current items
+ */
+class DisplayedItemFilterIterator extends \RecursiveFilterIterator
+{
+    public function accept()
+    {
+        return $this->current()->isDisplayed();
+    }
+
+    public function hasChildren()
+    {
+        return $this->current()->getDisplayChildren() && parent::hasChildren();
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Iterator/RecursiveItemIterator.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Knp\Menu\Iterator;
+
+/**
+ * Recursive iterator iterating on an item
+ */
+class RecursiveItemIterator extends \IteratorIterator implements \RecursiveIterator
+{
+    public function hasChildren()
+    {
+        return 0 < count($this->current());
+    }
+
+    public function getChildren()
+    {
+        return new static($this->current());
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/MenuFactory.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace Knp\Menu;
+
+/**
+ * Factory to create a menu from a tree
+ */
+class MenuFactory implements FactoryInterface
+{
+    public function createItem($name, array $options = array())
+    {
+        $item = new MenuItem($name, $this);
+
+        $options = array_merge(
+            array(
+                'uri' => null,
+                'label' => null,
+                'attributes' => array(),
+                'linkAttributes' => array(),
+                'childrenAttributes' => array(),
+                'labelAttributes' => array(),
+                'extras' => array(),
+                'display' => true,
+                'displayChildren' => true,
+            ),
+            $options
+        );
+
+        $item
+            ->setUri($options['uri'])
+            ->setLabel($options['label'])
+            ->setAttributes($options['attributes'])
+            ->setLinkAttributes($options['linkAttributes'])
+            ->setChildrenAttributes($options['childrenAttributes'])
+            ->setLabelAttributes($options['labelAttributes'])
+            ->setExtras($options['extras'])
+            ->setDisplay($options['display'])
+            ->setDisplayChildren($options['displayChildren'])
+        ;
+
+        return $item;
+    }
+
+    /**
+     * Create a menu item from a NodeInterface
+     *
+     * @param NodeInterface $node
+     * @return MenuItem
+     */
+    public function createFromNode(NodeInterface $node)
+    {
+        $item = $this->createItem($node->getName(), $node->getOptions());
+
+        foreach ($node->getChildren() as $childNode) {
+            $item->addChild($this->createFromNode($childNode));
+        }
+
+        return $item;
+    }
+
+    /**
+     * Creates a new menu item (and tree if $data['children'] is set).
+     *
+     * The source is an array of data that should match the output from MenuItem->toArray().
+     *
+     * @param  array $data The array of data to use as a source for the menu tree
+     * @param  string $name The name of the source (if not set in data['name'])
+     * @return MenuItem
+     */
+    public function createFromArray(array $data, $name = null)
+    {
+        $name = isset($data['name']) ? $data['name'] : $name;
+        if (isset($data['children'])) {
+            $children = $data['children'];
+            unset($data['children']);
+        } else {
+            $children = array();
+        }
+
+        $item = $this->createItem($name, $data);
+        foreach ($children as $name => $child) {
+            $item->addChild($this->createFromArray($child, $name));
+        }
+
+        return $item;
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/NodeInterface.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Knp\Menu;
+
+/**
+ * Interface implemented by a node to construct a menu from a tree.
+ */
+interface NodeInterface
+{
+    /**
+     * Get the name of the node
+     *
+     * Each child of a node must have a unique name
+     *
+     * @return string
+     */
+    function getName();
+
+    /**
+     * Get the options for the factory to create the item for this node
+     *
+     * @return array
+     */
+    function getOptions();
+
+    /**
+     * Get the child nodes implementing NodeInterface
+     *
+     * @return \Traversable
+     */
+    function getChildren();
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Provider/ChainProvider.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Knp\Menu\Provider;
+
+class ChainProvider implements MenuProviderInterface
+{
+    /**
+     * @var MenuProviderInterface[]
+     */
+    private $providers;
+
+    public function __construct(array $providers)
+    {
+        $this->providers = $providers;
+    }
+
+    public function get($name, array $options = array())
+    {
+        foreach ($this->providers as $provider) {
+            if ($provider->has($name, $options)) {
+                return $provider->get($name, $options);
+            }
+        }
+
+        throw new \InvalidArgumentException(sprintf('The menu "%s" is not defined.', $name));
+    }
+
+    public function has($name, array $options = array())
+    {
+        foreach ($this->providers as $provider) {
+            if ($provider->has($name, $options)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Provider/MenuProviderInterface.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Knp\Menu\Provider;
+
+interface MenuProviderInterface
+{
+    /**
+     * Retrieves a menu by its name
+     *
+     * @param string $name
+     * @param array $options
+     * @return \Knp\Menu\ItemInterface
+     * @throws \InvalidArgumentException if the menu does not exists
+     */
+    function get($name, array $options = array());
+
+    /**
+     * Checks whether a menu exists in this provider
+     *
+     * @param string $name
+     * @param array $options
+     * @return bool
+     */
+    function has($name, array $options = array());
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Provider/PimpleProvider.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Knp\Menu\Provider;
+
+class PimpleProvider implements MenuProviderInterface
+{
+    private $pimple;
+    private $menuIds;
+
+    public function __construct(\Pimple $pimple, array $menuIds = array())
+    {
+        $this->pimple = $pimple;
+        $this->menuIds = $menuIds;
+    }
+
+    public function get($name, array $options = array())
+    {
+        if (!isset($this->menuIds[$name])) {
+            throw new \InvalidArgumentException(sprintf('The menu "%s" is not defined.', $name));
+        }
+
+        $menu = $this->pimple[$this->menuIds[$name]];
+
+        if ($menu instanceof \Closure) {
+            $menu = $menu($options, $this->pimple);
+        }
+
+        return $menu;
+    }
+
+    public function has($name, array $options = array())
+    {
+        return isset($this->menuIds[$name]);
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Renderer/ListRenderer.php

@@ -0,0 +1,227 @@
+<?php
+
+namespace Knp\Menu\Renderer;
+
+use \Knp\Menu\ItemInterface;
+
+/**
+ * Renders MenuItem tree as unordered list
+ */
+class ListRenderer extends Renderer implements RendererInterface
+{
+    private $defaultOptions;
+
+    /**
+     * @param array $defaultOptions
+     * @param string $charset
+     */
+    public function __construct(array $defaultOptions = array(), $charset = null)
+    {
+        $this->defaultOptions = array_merge(array(
+            'depth' => null,
+            'currentAsLink' => true,
+            'currentClass' => 'current',
+            'ancestorClass' => 'current_ancestor',
+            'firstClass' => 'first',
+            'lastClass' => 'last',
+            'compressed' => false,
+            'allow_safe_labels' => false,
+        ), $defaultOptions);
+
+        parent::__construct($charset);
+    }
+
+    /**
+     * Renders a menu with the specified renderer.
+     *
+     * @param \Knp\Menu\ItemInterface $item
+     * @param array $options
+     * @return string
+     */
+    public function render(ItemInterface $item, array $options = array())
+    {
+        $options = array_merge($this->defaultOptions, $options);
+
+        return $this->renderList($item, $item->getChildrenAttributes(), $options);
+    }
+
+    protected function renderList(ItemInterface $item, array $attributes, array $options)
+    {
+        /**
+         * Return an empty string if any of the following are true:
+         *   a) The menu has no children eligible to be displayed
+         *   b) The depth is 0
+         *   c) This menu item has been explicitly set to hide its children
+         */
+        if (!$item->hasChildren() || 0 === $options['depth'] || !$item->getDisplayChildren()) {
+            return '';
+        }
+
+        $html = $this->format('<ul'.$this->renderHtmlAttributes($attributes).'>', 'ul', $item->getLevel(), $options);
+        $html .= $this->renderChildren($item, $options);
+        $html .= $this->format('</ul>', 'ul', $item->getLevel(), $options);
+
+        return $html;
+    }
+
+    /**
+     * Renders all of the children of this menu.
+     *
+     * This calls ->renderItem() on each menu item, which instructs each
+     * menu item to render themselves as an <li> tag (with nested ul if it
+     * has children).
+     * This method updates the depth for the children.
+     *
+     * @param \Knp\Menu\ItemInterface $item
+     * @param array $options The options to render the item.
+     * @return string
+     */
+    protected function renderChildren(ItemInterface $item, array $options)
+    {
+        // render children with a depth - 1
+        if (null !== $options['depth']) {
+            $options['depth'] = $options['depth'] - 1;
+        }
+
+        $html = '';
+        foreach ($item->getChildren() as $child) {
+            $html .= $this->renderItem($child, $options);
+        }
+
+        return $html;
+    }
+
+    /**
+     * Called by the parent menu item to render this menu.
+     *
+     * This renders the li tag to fit into the parent ul as well as its
+     * own nested ul tag if this menu item has children
+     *
+     * @param \Knp\Menu\ItemInterface $item
+     * @param array $options The options to render the item
+     * @return string
+     */
+    protected function renderItem(ItemInterface $item, array $options)
+    {
+        // if we don't have access or this item is marked to not be shown
+        if (!$item->isDisplayed()) {
+            return '';
+        }
+
+        // create an array than can be imploded as a class list
+        $class = (array) $item->getAttribute('class');
+
+        if ($item->isCurrent()) {
+            $class[] = $options['currentClass'];
+        } elseif ($item->isCurrentAncestor()) {
+            $class[] = $options['ancestorClass'];
+        }
+
+        if ($item->actsLikeFirst()) {
+            $class[] = $options['firstClass'];
+        }
+        if ($item->actsLikeLast()) {
+            $class[] = $options['lastClass'];
+        }
+
+        // retrieve the attributes and put the final class string back on it
+        $attributes = $item->getAttributes();
+        if (!empty($class)) {
+            $attributes['class'] = implode(' ', $class);
+        }
+
+        // opening li tag
+        $html = $this->format('<li'.$this->renderHtmlAttributes($attributes).'>', 'li', $item->getLevel(), $options);
+
+        // render the text/link inside the li tag
+        //$html .= $this->format($item->getUri() ? $item->renderLink() : $item->renderLabel(), 'link', $item->getLevel());
+        $html .= $this->renderLink($item, $options);
+
+        // renders the embedded ul
+        $childrenClass = (array) $item->getChildrenAttribute('class');
+        $childrenClass[] = 'menu_level_'.$item->getLevel();
+
+        $childrenAttributes = $item->getChildrenAttributes();
+        $childrenAttributes['class'] = implode(' ', $childrenClass);
+
+        $html .= $this->renderList($item, $childrenAttributes, $options);
+
+        // closing li tag
+        $html .= $this->format('</li>', 'li', $item->getLevel(), $options);
+
+        return $html;
+    }
+
+    /**
+     * Renders the link in a a tag with link attributes or
+     * the label in a span tag with label attributes
+     *
+     * Tests if item has a an uri and if not tests if it's
+     * the current item and if the text has to be rendered
+     * as a link or not.
+     *
+     * @param \Knp\Menu\ItemInterface $item The item to render the link or label for
+     * @param array $options The options to render the item
+     * @return string
+     */
+    protected function renderLink(ItemInterface $item, array $options = array())
+    {
+        if ($item->getUri() && (!$item->isCurrent() || $options['currentAsLink'])) {
+            $text = $this->renderLinkElement($item, $options);
+        } else {
+            $text = $this->renderSpanElement($item, $options);
+        }
+
+        return $this->format($text, 'link', $item->getLevel(), $options);
+    }
+
+    protected function renderLinkElement(ItemInterface $item, array $options)
+    {
+        return sprintf('<a href="%s"%s>%s</a>', $this->escape($item->getUri()), $this->renderHtmlAttributes($item->getLinkAttributes()), $this->renderLabel($item, $options));
+    }
+
+    protected function renderSpanElement(ItemInterface $item, array $options)
+    {
+        return sprintf('<span%s>%s</span>', $this->renderHtmlAttributes($item->getLabelAttributes()), $this->renderLabel($item, $options));
+    }
+
+    protected function renderLabel(ItemInterface $item, array $options)
+    {
+        if ($options['allow_safe_labels'] && $item->getExtra('safe_label', false)) {
+            return $item->getLabel();
+        }
+
+        return $this->escape($item->getLabel());
+    }
+
+    /**
+     * If $this->renderCompressed is on, this will apply the necessary
+     * spacing and line-breaking so that the particular thing being rendered
+     * makes up its part in a fully-rendered and spaced menu.
+     *
+     * @param  string $html The html to render in an (un)formatted way
+     * @param  string $type The type [ul,link,li] of thing being rendered
+     * @param integer $level
+     * @param array $options
+     * @return string
+     */
+    protected function format($html, $type, $level, array $options)
+    {
+        if ($options['compressed']) {
+            return $html;
+        }
+
+        switch ($type) {
+            case 'ul':
+            case 'link':
+                $spacing = $level * 4;
+                break;
+
+            case 'li':
+                $spacing = $level * 4 - 2;
+                break;
+        }
+
+        return str_repeat(' ', $spacing).$html."\n";
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Renderer/PimpleProvider.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Knp\Menu\Renderer;
+
+class PimpleProvider implements RendererProviderInterface
+{
+    private $pimple;
+    private $rendererIds;
+    private $defaultRenderer;
+
+    public function __construct(\Pimple $pimple, $defaultRenderer, array $rendererIds)
+    {
+        $this->pimple = $pimple;
+        $this->rendererIds = $rendererIds;
+        $this->defaultRenderer = $defaultRenderer;
+    }
+
+    public function get($name = null)
+    {
+        if (null === $name) {
+            $name = $this->defaultRenderer;
+        }
+
+        if (!isset($this->rendererIds[$name])) {
+            throw new \InvalidArgumentException(sprintf('The renderer "%s" is not defined.', $name));
+        }
+
+        return $this->pimple[$this->rendererIds[$name]];
+    }
+
+    public function has($name)
+    {
+        return isset($this->rendererIds[$name]);
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Renderer/Renderer.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace Knp\Menu\Renderer;
+
+if (!defined('ENT_SUBSTITUTE')) {
+    define('ENT_SUBSTITUTE', 8);
+}
+
+abstract class Renderer
+{
+    protected $charset = 'UTF-8';
+
+    /**
+     * @param string $charset
+     */
+    public function __construct($charset = null)
+    {
+        if (null !== $charset) {
+            $this->charset = (string) $charset;
+        }
+    }
+
+    /**
+     * Renders a HTML attribute
+     *
+     * @param string $name
+     * @param string $value
+     * @return string
+     */
+    protected function renderHtmlAttribute($name, $value)
+    {
+        if (true === $value) {
+            return sprintf('%s="%s"', $name, $this->escape($name));
+        }
+
+        return sprintf('%s="%s"', $name, $this->escape($value));
+    }
+
+    /**
+     * Renders HTML attributes
+     *
+     * @param array $attributes
+     * @return string
+     */
+    protected function renderHtmlAttributes(array $attributes)
+    {
+        return implode('', array_map(array($this, 'htmlAttributesCallback'), array_keys($attributes), array_values($attributes)));
+    }
+
+    /**
+     * Prepares an attribute key and value for HTML representation.
+     *
+     * It removes empty attributes.
+     *
+     * @param  string $name   The attribute name
+     * @param  string $value  The attribute value
+     *
+     * @return string The HTML representation of the HTML key attribute pair.
+     */
+    private function htmlAttributesCallback($name, $value)
+    {
+        if (false === $value || null === $value) {
+            return '';
+        }
+
+        return ' '.$this->renderHtmlAttribute($name, $value);
+    }
+
+    /**
+     * Escapes an HTML value
+     *
+     * @param string $value
+     * @return string
+     */
+    protected function escape($value)
+    {
+        return $this->fixDoubleEscape(htmlspecialchars((string) $value, ENT_QUOTES | ENT_SUBSTITUTE, $this->charset));
+    }
+
+    /**
+     * Fixes double escaped strings.
+     *
+     * @param  string $escaped  string to fix
+     * @return string A single escaped string
+     */
+    protected function fixDoubleEscape($escaped)
+    {
+        return preg_replace('/&amp;([a-z]+|(#\d+)|(#x[\da-f]+));/i', '&$1;', $escaped);
+    }
+
+    /**
+     * Get the HTML charset
+     *
+     * @return string
+     */
+    public function getCharset()
+    {
+        return $this->charset;
+    }
+
+    /**
+     * Set the HTML charset
+     *
+     * @param string $charset
+     */
+    public function setCharset($charset)
+    {
+        $this->charset = (string) $charset;
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Renderer/RendererInterface.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Knp\Menu\Renderer;
+
+use Knp\Menu\ItemInterface;
+
+interface RendererInterface
+{
+    /**
+     * Renders menu tree.
+     *
+     * Common options:
+     *      - depth: The depth at which the item is rendered
+     *          null: no limit
+     *          0: no children
+     *          1: only direct children
+     *      - currentAsLink: whether the current item should be a link
+     *      - currentClass: class added to the current item
+     *      - ancestorClass: class added to the ancestors of the current item
+     *      - firstClass: class added to the first child
+     *      - lastClass: class added to the last child
+     *
+     * @param \Knp\Menu\ItemInterface $item Menu item
+     * @param array $options some rendering options
+     * @return string
+     */
+    public function render(ItemInterface $item, array $options = array());
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Renderer/RendererProviderInterface.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Knp\Menu\Renderer;
+
+interface RendererProviderInterface
+{
+    /**
+     * Retrieves a renderer by its name
+     *
+     * If null is given, a renderer marked as default is returned.
+     *
+     * @param string $name
+     * @return \Knp\Menu\Renderer\RendererInterface
+     * @throws \InvalidArgumentException if the renderer does not exists
+     */
+    function get($name = null);
+
+    /**
+     * Checks whether a renderer exists
+     *
+     * @param string $name
+     * @return bool
+     */
+    function has($name);
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Renderer/TwigRenderer.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Knp\Menu\Renderer;
+
+use Knp\Menu\ItemInterface;
+use Knp\Menu\Renderer\RendererProviderInterface;
+use Knp\Menu\Provider\MenuProviderInterface;
+
+class TwigRenderer implements RendererInterface
+{
+    /**
+     * @var \Twig_Environment
+     */
+    private $environment;
+    private $defaultOptions;
+
+    /**
+     * @param \Twig_Environment $environment
+     * @param string $template
+     * @param array $defaultOptions
+     */
+    public function __construct(\Twig_Environment $environment, $template, array $defaultOptions = array())
+    {
+        $this->environment = $environment;
+        $this->defaultOptions = array_merge(array(
+            'depth' => null,
+            'currentAsLink' => true,
+            'currentClass' => 'current',
+            'ancestorClass' => 'current_ancestor',
+            'firstClass' => 'first',
+            'lastClass' => 'last',
+            'template' => $template,
+            'compressed' => false,
+            'allow_safe_labels' => false,
+        ), $defaultOptions);
+    }
+
+    /**
+     * Renders a menu with the specified renderer.
+     *
+     * @param \Knp\Menu\ItemInterface $item
+     * @param array $options
+     * @return string
+     */
+    public function render(ItemInterface $item, array $options = array())
+    {
+        $options = array_merge($this->defaultOptions, $options);
+
+        $template = $options['template'];
+        if (!$template instanceof \Twig_Template) {
+            $template = $this->environment->loadTemplate($template);
+        }
+
+        $block = $options['compressed'] ? 'compressed_root' : 'root';
+
+        return $template->renderBlock($block, array('item' => $item, 'options' => $options));
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Resources/views/knp_menu.html.twig

@@ -0,0 +1,83 @@
+{% macro attributes(attributes) %}
+{% for name, value in attributes %}
+    {%- if value is not none and value is not sameas(false) -%}
+        {{- ' %s="%s"'|format(name, value is sameas(true) ? name|e : value|e)|raw -}}
+    {%- endif -%}
+{%- endfor -%}
+{% endmacro %}
+
+{% block compressed_root %}
+{% spaceless %}
+{{ block('root') }}
+{% endspaceless %}
+{% endblock %}
+
+{% block root %}
+{% set listAttributes = item.childrenAttributes %}
+{{ block('list') -}}
+{% endblock %}
+
+{% block list %}
+{% if item.hasChildren and options.depth is not sameas(0) and item.displayChildren %}
+    <ul{{ _self.attributes(listAttributes) }}>
+        {{ block('children') }}
+    </ul>
+{% endif %}
+{% endblock %}
+
+{% block children %}
+{# save current variables #}
+{% set currentOptions = options %}
+{% set currentItem = item %}
+{# update the depth for children #}
+{% if options.depth is not none %}
+{% set options = currentOptions|merge({'depth': currentOptions.depth - 1}) %}
+{% endif %}
+{% for item in currentItem.children %}
+    {{ block('item') }}
+{% endfor %}
+{# restore current variables #}
+{% set item = currentItem %}
+{% set options = currentOptions %}
+{% endblock %}
+
+{% block item %}
+{% if item.displayed %}
+{# building the class of the item #}
+    {%- set classes = item.attribute('class') is not empty ? [item.attribute('class')] : [] %}
+    {%- if item.current %}
+        {%- set classes = classes|merge([options.currentClass]) %}
+    {%- elseif item.currentAncestor %}
+        {%- set classes = classes|merge([options.ancestorClass]) %}
+    {%- endif %}
+    {%- if item.actsLikeFirst %}
+        {%- set classes = classes|merge([options.firstClass]) %}
+    {%- endif %}
+    {%- if item.actsLikeLast %}
+        {%- set classes = classes|merge([options.lastClass]) %}
+    {%- endif %}
+    {%- set attributes = item.attributes %}
+    {%- if classes is not empty %}
+        {%- set attributes = attributes|merge({'class': classes|join(' ')}) %}
+    {%- endif %}
+{# displaying the item #}
+    <li{{ _self.attributes(attributes) }}>
+        {%- if item.uri is not empty and (not item.current or options.currentAsLink) %}
+        {{ block('linkElement') }}
+        {%- else %}
+        {{ block('spanElement') }}
+        {%- endif %}
+{# render the list of children#}
+        {%- set childrenClasses = item.childrenAttribute('class') is not empty ? [item.childrenAttribute('class')] : [] %}
+        {%- set childrenClasses = childrenClasses|merge(['menu_level_' ~ item.level]) %}
+        {%- set listAttributes = item.childrenAttributes|merge({'class': childrenClasses|join(' ') }) %}
+        {{ block('list') }}
+    </li>
+{% endif %}
+{% endblock %}
+
+{% block linkElement %}<a href="{{ item.uri }}"{{ _self.attributes(item.linkAttributes) }}>{{ block('label') }}</a>{% endblock %}
+
+{% block spanElement %}<span{{ _self.attributes(item.labelAttributes) }}>{{ block('label') }}</span>{% endblock %}
+
+{% block label %}{% if options.allow_safe_labels and item.getExtra('safe_label', false) %}{{ item.label|raw }}{% else %}{{ item.label }}{% endif %}{% endblock %}

vendor/knplabs/knp-menu/src/Knp/Menu/Resources/views/knp_menu_ordered.html.twig

@@ -0,0 +1,11 @@
+{% extends 'knp_menu.html.twig' %}
+
+{% block list %}
+{% import 'knp_menu.html.twig' as macros %}
+
+{% if item.hasChildren and options.depth is not sameas(0) and item.displayChildren %}
+    <ol{{ macros.attributes(listAttributes) }}>
+        {{ block('children') }}
+    </ol>
+{% endif %}
+{% endblock %}

vendor/knplabs/knp-menu/src/Knp/Menu/Silex/KnpMenuServiceProvider.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Knp\Menu\Silex;
+
+use Silex\Application;
+use Silex\ServiceProviderInterface;
+use Knp\Menu\MenuFactory;
+use Knp\Menu\Renderer\ListRenderer;
+use Knp\Menu\Renderer\TwigRenderer;
+use Knp\Menu\Provider\PimpleProvider as PimpleMenuProvider;
+use Knp\Menu\Renderer\PimpleProvider as PimpleRendererProvider;
+use Knp\Menu\Twig\Helper;
+use Knp\Menu\Twig\MenuExtension;
+
+class KnpMenuServiceProvider implements ServiceProviderInterface
+{
+    public function register(Application $app)
+    {
+        $app['knp_menu.factory'] = $app->share(function () use ($app) {
+            if (isset($app['url_generator'])) {
+                return new RouterAwareFactory($app['url_generator']);
+            }
+
+            return new MenuFactory();
+        });
+
+        $app['knp_menu.renderer.list'] = $app->share(function () use ($app) {
+            return new ListRenderer(array(), $app['charset']);
+        });
+
+        $app['knp_menu.menu_provider'] = $app->share(function () use ($app) {
+            return new PimpleMenuProvider($app, $app['knp_menu.menus']);
+        });
+
+        if (!isset($app['knp_menu.menus'])) {
+            $app['knp_menu.menus'] = array();
+        }
+
+        $app['knp_menu.renderer_provider'] = $app->share(function () use ($app) {
+            $app['knp_menu.renderers'] = array_merge(
+                array('list' => 'knp_menu.renderer.list'),
+                isset($app['knp_menu.renderer.twig']) ? array('twig' => 'knp_menu.renderer.twig') : array(),
+                isset($app['knp_menu.renderers']) ? $app['knp_menu.renderers'] : array()
+            );
+
+            return new PimpleRendererProvider($app, $app['knp_menu.default_renderer'], $app['knp_menu.renderers']);
+        });
+
+        if (!isset($app['knp_menu.default_renderer'])) {
+            $app['knp_menu.default_renderer'] = 'list';
+        }
+
+        $app['knp_menu.helper'] = $app->share(function () use ($app){
+            return new Helper($app['knp_menu.renderer_provider'], $app['knp_menu.menu_provider']);
+        });
+
+        if (isset($app['twig'])) {
+            $app['knp_menu.twig_extension'] = $app->share(function () use ($app) {
+                return new MenuExtension($app['knp_menu.helper']);
+            });
+
+            $app['knp_menu.renderer.twig'] = $app->share(function () use ($app) {
+                return new TwigRenderer($app['twig'], $app['knp_menu.template']);
+            });
+
+            if (!isset($app['knp_menu.template'])) {
+                $app['knp_menu.template'] = 'knp_menu.html.twig';
+            }
+
+            $app['twig'] = $app->share($app->extend('twig', function (\Twig_Environment $twig) use ($app) {
+                $twig->addExtension($app['knp_menu.twig_extension']);
+
+                return $twig;
+            }));
+
+            $app['twig.loader.filesystem'] = $app->share($app->extend('twig.loader.filesystem', function (\Twig_Loader_Filesystem $loader) use ($app) {
+                $loader->addPath(__DIR__.'/../Resources/views');
+
+                return $loader;
+            }));
+        }
+    }
+    
+    /**
+     * Bootstraps the application.
+     *
+     * This method is called after all services are registers
+     * and should be used for "dynamic" configuration (whenever
+     * a service must be requested).
+     */
+    public function boot(Application $app){}
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Silex/RouterAwareFactory.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Knp\Menu\Silex;
+
+use Knp\Menu\MenuFactory;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+
+/**
+ * Factory able to use the Symfony2 Routing component to build the url
+ */
+class RouterAwareFactory extends MenuFactory
+{
+    protected $generator;
+
+    public function __construct(UrlGeneratorInterface $generator)
+    {
+        $this->generator = $generator;
+    }
+
+    public function createItem($name, array $options = array())
+    {
+        if (!empty($options['route'])) {
+            $params = isset($options['routeParameters']) ? $options['routeParameters'] : array();
+            $absolute = isset($options['routeAbsolute']) ? $options['routeAbsolute'] : false;
+            $options['uri'] = $this->generator->generate($options['route'], $params, $absolute);
+        }
+
+        return parent::createItem($name, $options);
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Twig/Helper.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Knp\Menu\Twig;
+
+use Knp\Menu\ItemInterface;
+use Knp\Menu\Renderer\RendererProviderInterface;
+use Knp\Menu\Provider\MenuProviderInterface;
+
+/**
+ * Helper class containing logic to retrieve and render menus from templating engines
+ *
+ */
+class Helper
+{
+    private $rendererProvider;
+    private $menuProvider;
+
+    /**
+     * @param \Knp\Menu\Renderer\RendererProviderInterface $rendererProvider
+     * @param \Knp\Menu\Provider\MenuProviderInterface|null $menuProvider
+     */
+    public function __construct(RendererProviderInterface $rendererProvider, MenuProviderInterface $menuProvider = null)
+    {
+        $this->rendererProvider = $rendererProvider;
+        $this->menuProvider = $menuProvider;
+    }
+
+    /**
+     * Retrieves item in the menu, eventually using the menu provider.
+     *
+     * @param \Knp\Menu\ItemInterface|string $menu
+     * @param array $path
+     * @param array $options
+     * @return \Knp\Menu\ItemInterface
+     * @throws \InvalidArgumentException when the path is invalid
+     * @throws \BadMethodCallException when there is no menu provider and the menu is given by name
+     */
+    public function get($menu, array $path = array(), array $options = array())
+    {
+        if (!$menu instanceof ItemInterface) {
+            if (null === $this->menuProvider) {
+                throw new \BadMethodCallException('A menu provider must be set to retrieve a menu');
+            }
+
+            $menuName = $menu;
+            $menu = $this->menuProvider->get($menuName, $options);
+
+            if (!$menu instanceof ItemInterface) {
+                throw new \LogicException(sprintf('The menu "%s" exists, but is not a valid menu item object. Check where you created the menu to be sure it returns an ItemInterface object.', $menuName));
+            }
+        }
+
+        foreach ($path as $child) {
+            $menu = $menu->getChild($child);
+            if (null === $menu) {
+                throw new \InvalidArgumentException(sprintf('The menu has no child named "%s"', $child));
+            }
+        }
+
+        return $menu;
+    }
+
+    /**
+     * Renders a menu with the specified renderer.
+     *
+     * If the argument is an array, it will follow the path in the tree to
+     * get the needed item. The first element of the array is the whole menu.
+     * If the menu is a string instead of an ItemInterface, the provider
+     * will be used.
+     *
+     * @throws \InvalidArgumentException
+     * @param \Knp\Menu\ItemInterface|string|array $menu
+     * @param array $options
+     * @param string $renderer
+     * @return string
+     */
+    public function render($menu, array $options = array(), $renderer =  null)
+    {
+        if (!$menu instanceof ItemInterface) {
+            $path = array();
+            if (is_array($menu)) {
+                if (empty($menu)) {
+                    throw new \InvalidArgumentException('The array cannot be empty');
+                }
+                $path = $menu;
+                $menu = array_shift($path);
+            }
+
+            $menu = $this->get($menu, $path);
+        }
+
+        return $this->rendererProvider->get($renderer)->render($menu, $options);
+    }
+}

vendor/knplabs/knp-menu/src/Knp/Menu/Twig/MenuExtension.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Knp\Menu\Twig;
+
+use Knp\Menu\ItemInterface;
+use Knp\Menu\Renderer\RendererProviderInterface;
+use Knp\Menu\Provider\MenuProviderInterface;
+
+class MenuExtension extends \Twig_Extension
+{
+    private $helper;
+
+    /**
+     * @param \Knp\Menu\Twig\Helper $helper
+     */
+    public function __construct(Helper $helper)
+    {
+        $this->helper = $helper;
+    }
+
+    public function getFunctions()
+    {
+        return array(
+            'knp_menu_get' => new \Twig_Function_Method($this, 'get'),
+            'knp_menu_render' => new \Twig_Function_Method($this, 'render', array('is_safe' => array('html'))),
+        );
+    }
+
+    /**
+     * Retrieves an item following a path in the tree.
+     *
+     * @param \Knp\Menu\ItemInterface|string $menu
+     * @param array $path
+     * @param array $options
+     * @return \Knp\Menu\ItemInterface
+     */
+    public function get($menu, array $path = array(), array $options = array())
+    {
+        return $this->helper->get($menu, $path, $options);
+    }
+
+    /**
+     * Renders a menu with the specified renderer.
+     *
+     * @param \Knp\Menu\ItemInterface|string|array $menu
+     * @param array $options
+     * @param string $renderer
+     * @return string
+     */
+    public function render($menu, array $options = array(), $renderer = null)
+    {
+        return $this->helper->render($menu, $options, $renderer);
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'knp_menu';
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Iterator/CurrentItemFilterIteratorTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Knp\Menu\Tests\Iterator;
+
+use Knp\Menu\Iterator\CurrentItemFilterIterator;
+use Knp\Menu\Iterator\RecursiveItemIterator;
+use Knp\Menu\Tests\TestCase;
+
+class CurrentItemFilterIteratorTest extends TestCase
+{
+    public function testSimpleFiltering()
+    {
+        $this->pt1->setCurrent(true);
+        $this->ch2->setCurrent(true);
+        $this->gc1->setCurrent(true);
+
+        $names = array();
+        // FilterIterator expects an Iterator implementation explicitly, not an IteratorAggregate.
+        $iterator = new CurrentItemFilterIterator($this->menu->getIterator());
+
+        foreach ($iterator as $value) {
+            $names[] = $value->getName();
+        }
+
+        $this->assertEquals(array('Parent 1'), $names);
+    }
+
+    public function testFiltering()
+    {
+        $this->pt1->setCurrent(true);
+        $this->ch2->setCurrent(true);
+        $this->gc1->setCurrent(true);
+
+        $names = array();
+        $iterator = new CurrentItemFilterIterator(
+            new \RecursiveIteratorIterator(new RecursiveItemIterator($this->menu), \RecursiveIteratorIterator::SELF_FIRST)
+        );
+
+        foreach ($iterator as $value) {
+            $names[] = $value->getName();
+        }
+
+        $this->assertEquals(array('Parent 1', 'Child 2', 'Grandchild 1'), $names);
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Iterator/DisplayedItemFilterIteratorTest.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Knp\Menu\Tests\Iterator;
+
+use Knp\Menu\Iterator\DisplayedItemFilterIterator;
+use Knp\Menu\Iterator\RecursiveItemIterator;
+use Knp\Menu\Tests\TestCase;
+
+class DisplayedItemFilterIteratorTest extends TestCase
+{
+    public function testFiltering()
+    {
+        $this->ch1->setDisplay(false);
+        $this->ch2->setDisplay(false);
+        $this->ch4->setDisplayChildren(false);
+
+        $names = array();
+        $iterator = new \RecursiveIteratorIterator(
+            new DisplayedItemFilterIterator(new RecursiveItemIterator($this->menu)),
+            \RecursiveIteratorIterator::SELF_FIRST
+        );
+        foreach ($iterator as $value) {
+            $names[] = $value->getName();
+        }
+
+        $this->assertEquals(array('Parent 1', 'Child 3', 'Parent 2', 'Child 4'), $names);
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Iterator/IteratorTest.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace Knp\Menu\Tests\Iterator;
+
+use Knp\Menu\Iterator\RecursiveItemIterator;
+use Knp\Menu\Tests\TestCase;
+
+class IteratorTest extends TestCase
+{
+    public function testIterator()
+    {
+        $count = 0;
+        foreach ($this->pt1 as $key => $value) {
+            $count++;
+            $this->assertEquals('Child '.$count, $key);
+            $this->assertEquals('Child '.$count, $value->getLabel());
+        }
+    }
+
+    public function testRecursiveIterator()
+    {
+        // Adding an item which does not provide a RecursiveIterator to be sure it works properly.
+        $child = $this->getMock('Knp\Menu\ItemInterface');
+        $child->expects($this->any())
+            ->method('getName')
+            ->will($this->returnValue('Foo'));
+        $child->expects($this->any())
+            ->method('getIterator')
+            ->will($this->returnValue(new \EmptyIterator()));
+        $this->menu->addChild($child);
+
+        $names = array();
+        foreach (new \RecursiveIteratorIterator(new RecursiveItemIterator($this->menu), \RecursiveIteratorIterator::SELF_FIRST) as $value) {
+            $names[] = $value->getName();
+        }
+
+        $this->assertEquals(array('Parent 1', 'Child 1', 'Child 2', 'Child 3', 'Parent 2', 'Child 4', 'Grandchild 1', 'Foo'), $names);
+    }
+
+    public function testRecursiveIteratorLeavesOnly()
+    {
+        $names = array();
+        foreach (new \RecursiveIteratorIterator(new RecursiveItemIterator($this->menu), \RecursiveIteratorIterator::LEAVES_ONLY) as $value) {
+            $names[] = $value->getName();
+        }
+
+        $this->assertEquals(array('Child 1', 'Child 2', 'Child 3', 'Grandchild 1'), $names);
+    }
+
+    public function testFullTreeIterator()
+    {
+        $fullTreeIterator = new \RecursiveIteratorIterator(
+            new RecursiveItemIterator(new \ArrayIterator(array($this->menu))), // recursive iterator containing the root item
+            \RecursiveIteratorIterator::SELF_FIRST
+        );
+
+        $names = array();
+        foreach ($fullTreeIterator as $value) {
+            $names[] = $value->getName();
+        }
+
+        $this->assertEquals(array('Root li', 'Parent 1', 'Child 1', 'Child 2', 'Child 3', 'Parent 2', 'Child 4', 'Grandchild 1'), $names);
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/MenuFactoryTest.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Knp\Menu\Tests;
+
+use Knp\Menu\MenuFactory;
+
+class MenuFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function testFromArrayWithoutChildren()
+    {
+        $factory = new MenuFactory();
+        $array = array(
+            'name' => 'joe',
+            'uri' => '/foobar',
+            'display' => false,
+        );
+        $item = $factory->createFromArray($array);
+        $this->assertEquals('joe', $item->getName());
+        $this->assertEquals('/foobar', $item->getUri());
+        $this->assertFalse($item->isDisplayed());
+        $this->assertEmpty($item->getAttributes());
+        $this->assertEmpty($item->getChildren());
+    }
+
+    public function testFromArrayWithChildren()
+    {
+        $factory = new MenuFactory();
+        $array = array(
+            'name' => 'joe',
+            'children' => array(
+                'jack' => array(
+                    'name' => 'jack',
+                    'label' => 'Jack',
+                ),
+                array(
+                    'name' => 'john'
+                )
+            ),
+        );
+        $item = $factory->createFromArray($array);
+        $this->assertEquals('joe', $item->getName());
+        $this->assertEmpty($item->getAttributes());
+        $this->assertCount(2, $item);
+        $this->assertTrue(isset($item['john']));
+    }
+
+    public function testFromArrayWithChildrenOmittingName()
+    {
+        $factory = new MenuFactory();
+        $array = array(
+            'name' => 'joe',
+            'children' => array(
+                'jack' => array(
+                    'label' => 'Jack',
+                ),
+                'john' => array(
+                    'label' => 'John'
+                )
+            ),
+        );
+        $item = $factory->createFromArray($array);
+        $this->assertEquals('joe', $item->getName());
+        $this->assertEmpty($item->getAttributes());
+        $this->assertCount(2, $item);
+        $this->assertTrue(isset($item['john']));
+        $this->assertTrue(isset($item['jack']));
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/MenuItemGetterSetterTest.php

@@ -0,0 +1,395 @@
+<?php
+
+namespace Knp\Menu\Tests;
+
+use Knp\Menu\MenuItem;
+use Knp\Menu\MenuFactory;
+
+class MenuItemGetterSetterTest extends \PHPUnit_Framework_TestCase
+{
+    public function testCreateMenuItemWithEmptyParameter()
+    {
+        $menu = $this->createMenu();
+        $this->assertTrue($menu instanceof MenuItem);
+    }
+
+    public function testCreateMenuWithNameAndUri()
+    {
+        $menu = $this->createMenu('test1', 'other_uri');
+        $this->assertEquals('test1', $menu->getName());
+        $this->assertEquals('other_uri', $menu->getUri());
+    }
+
+    public function testCreateMenuWithTitle()
+    {
+        $title = 'This is a test item title';
+        $menu = $this->createMenu(null, null, array('title' => $title));
+        $this->assertEquals($title, $menu->getAttribute('title'));
+    }
+
+    public function testName()
+    {
+        $menu = $this->createMenu();
+        $menu->setName('menu name');
+        $this->assertEquals('menu name', $menu->getName());
+    }
+
+    public function testLabel()
+    {
+        $menu = $this->createMenu();
+        $menu->setLabel('menu label');
+        $this->assertEquals('menu label', $menu->getLabel());
+    }
+
+    public function testNameIsUsedAsDefaultLabel()
+    {
+        $menu = $this->createMenu('My Label');
+        $this->assertEquals('My Label', $menu->getLabel());
+        $menu->setLabel('Other Label');
+        $this->assertEquals('Other Label', $menu->getLabel());
+    }
+
+    public function testUri()
+    {
+        $menu = $this->createMenu();
+        $menu->setUri('menu_uri');
+        $this->assertEquals('menu_uri', $menu->getUri());
+    }
+
+    public function testAttributes()
+    {
+        $attributes = array('class' => 'test_class', 'title' => 'Test title');
+        $menu = $this->createMenu();
+        $menu->setAttributes($attributes);
+        $this->assertEquals($attributes, $menu->getAttributes());
+    }
+
+    public function testDefaultAttribute()
+    {
+        $menu = $this->createMenu(null, null, array('id' => 'test_id'));
+        $this->assertEquals('test_id', $menu->getAttribute('id'));
+        $this->assertEquals('default_value', $menu->getAttribute('unknown_attribute', 'default_value'));
+    }
+
+    public function testLinkAttributes()
+    {
+        $attributes = array('class' => 'test_class', 'title' => 'Test title');
+        $menu = $this->createMenu();
+        $menu->setLinkAttributes($attributes);
+        $this->assertEquals($attributes, $menu->getLinkAttributes());
+    }
+
+    public function testDefaultLinkAttribute()
+    {
+        $menu = $this->createMenu();
+        $menu->setLinkAttribute('class', 'test_class');
+        $this->assertEquals('test_class', $menu->getLinkAttribute('class'));
+        $this->assertNull($menu->getLinkAttribute('title'));
+        $this->assertEquals('foobar', $menu->getLinkAttribute('title', 'foobar'));
+    }
+
+    public function testChildrenAttributes()
+    {
+        $attributes = array('class' => 'test_class', 'title' => 'Test title');
+        $menu = $this->createMenu();
+        $menu->setChildrenAttributes($attributes);
+        $this->assertEquals($attributes, $menu->getChildrenAttributes());
+    }
+
+    public function testDefaultChildrenAttribute()
+    {
+        $menu = $this->createMenu();
+        $menu->setChildrenAttribute('class', 'test_class');
+        $this->assertEquals('test_class', $menu->getChildrenAttribute('class'));
+        $this->assertNull($menu->getChildrenAttribute('title'));
+        $this->assertEquals('foobar', $menu->getChildrenAttribute('title', 'foobar'));
+    }
+
+    public function testLabelAttributes()
+    {
+        $attributes = array('class' => 'test_class', 'title' => 'Test title');
+        $menu = $this->createMenu();
+        $menu->setLabelAttributes($attributes);
+        $this->assertEquals($attributes, $menu->getLabelAttributes());
+    }
+
+    public function testDefaultLabelAttribute()
+    {
+        $menu = $this->createMenu();
+        $menu->setLabelAttribute('class', 'test_class');
+        $this->assertEquals('test_class', $menu->getLabelAttribute('class'));
+        $this->assertNull($menu->getLabelAttribute('title'));
+        $this->assertEquals('foobar', $menu->getLabelAttribute('title', 'foobar'));
+    }
+
+    public function testExtras()
+    {
+        $extras = array('class' => 'test_class', 'title' => 'Test title');
+        $menu = $this->createMenu();
+        $menu->setExtras($extras);
+        $this->assertEquals($extras, $menu->getExtras());
+    }
+
+    public function testDefaultExtras()
+    {
+        $menu = $this->createMenu();
+        $menu->setExtra('class', 'test_class');
+        $this->assertEquals('test_class', $menu->getExtra('class'));
+        $this->assertNull($menu->getExtra('title'));
+        $this->assertEquals('foobar', $menu->getExtra('title', 'foobar'));
+    }
+
+    public function testDisplay()
+    {
+        $menu = $this->createMenu();
+        $this->assertEquals(true, $menu->isDisplayed());
+        $menu->setDisplay(false);
+        $this->assertEquals(false, $menu->isDisplayed());
+    }
+
+    public function testShowChildren()
+    {
+        $menu = $this->createMenu();
+        $this->assertEquals(true, $menu->getDisplayChildren());
+        $menu->setDisplayChildren(false);
+        $this->assertEquals(false, $menu->getDisplayChildren());
+    }
+
+    public function testParent()
+    {
+        $menu = $this->createMenu();
+        $child = $this->createMenu('child_menu');
+        $this->assertNull($child->getParent());
+        $child->setParent($menu);
+        $this->assertEquals($menu, $child->getParent());
+    }
+
+    public function testChildren()
+    {
+        $menu = $this->createMenu();
+        $child = $this->createMenu('child_menu');
+        $menu->setChildren(array($child));
+        $this->assertEquals(array($child), $menu->getChildren());
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testSetExistingNameThrowsAnException()
+    {
+        $menu = $this->createMenu();
+        $menu->addChild('jack');
+        $menu->addChild('joe');
+        $menu->getChild('joe')->setName('jack');
+    }
+
+    public function testSetSameName()
+    {
+        $parent = $this->getMock('Knp\Menu\ItemInterface');
+        $parent->expects($this->never())
+            ->method('offsetExists');
+
+        $menu = $this->createMenu('my_name');
+        $menu->setParent($parent);
+        $menu->setName('my_name');
+        $this->assertEquals('my_name', $menu->getName());
+    }
+
+    public function testToArrayWithChildren()
+    {
+        $menu = $this->createMenu();
+        $menu->addChild('jack', array('uri' => 'http://php.net', 'linkAttributes' => array('title' => 'php'), 'display' => false))
+            ->addChild('john')
+        ;
+        $menu->addChild('joe', array('attributes' => array('class' => 'leaf'), 'label' => 'test', 'labelAttributes' => array('class' => 'center'), 'displayChildren' => false));
+
+        $this->assertEquals(
+            array(
+                'name' => 'test_menu',
+                'label' => null,
+                'uri' => 'homepage',
+                'attributes' => array(),
+                'labelAttributes' => array(),
+                'linkAttributes' => array(),
+                'childrenAttributes' => array(),
+                'extras' => array(),
+                'display' => true,
+                'displayChildren' => true,
+                'children' => array(
+                    'jack' => array(
+                        'name' => 'jack',
+                        'label' => null,
+                        'uri' => 'http://php.net',
+                        'attributes' => array(),
+                        'labelAttributes' => array(),
+                        'linkAttributes' => array('title' => 'php'),
+                        'childrenAttributes' => array(),
+                        'extras' => array(),
+                        'display' => false,
+                        'displayChildren' => true,
+                        'children' => array(
+                            'john' => array(
+                                'name' => 'john',
+                                'label' => null,
+                                'uri' => null,
+                                'attributes' => array(),
+                                'labelAttributes' => array(),
+                                'linkAttributes' => array(),
+                                'childrenAttributes' => array(),
+                                'extras' => array(),
+                                'display' => true,
+                                'displayChildren' => true,
+                                'children' => array(),
+                            ),
+                        ),
+                    ),
+                    'joe' => array(
+                        'name' => 'joe',
+                        'label' => 'test',
+                        'uri' => null,
+                        'attributes' => array('class' => 'leaf'),
+                        'labelAttributes' => array('class' => 'center'),
+                        'linkAttributes' => array(),
+                        'childrenAttributes' => array(),
+                        'extras' => array(),
+                        'display' => true,
+                        'displayChildren' => false,
+                        'children' => array(),
+                    ),
+                ),
+            ),
+            $menu->toArray()
+        );
+    }
+
+    public function testToArrayWithLimitedChildren()
+    {
+        $menu = $this->createMenu();
+        $menu->addChild('jack', array('uri' => 'http://php.net', 'linkAttributes' => array('title' => 'php'), 'display' => false))
+            ->addChild('john')
+        ;
+        $menu->addChild('joe', array('attributes' => array('class' => 'leaf'), 'label' => 'test', 'labelAttributes' => array('class' => 'center'), 'displayChildren' => false));
+
+        $this->assertEquals(
+            array(
+                'name' => 'test_menu',
+                'label' => null,
+                'uri' => 'homepage',
+                'attributes' => array(),
+                'labelAttributes' => array(),
+                'linkAttributes' => array(),
+                'childrenAttributes' => array(),
+                'extras' => array(),
+                'display' => true,
+                'displayChildren' => true,
+                'children' => array(
+                    'jack' => array(
+                        'name' => 'jack',
+                        'label' => null,
+                        'uri' => 'http://php.net',
+                        'attributes' => array(),
+                        'labelAttributes' => array(),
+                        'linkAttributes' => array('title' => 'php'),
+                        'childrenAttributes' => array(),
+                        'extras' => array(),
+                        'display' => false,
+                        'displayChildren' => true,
+                    ),
+                    'joe' => array(
+                        'name' => 'joe',
+                        'label' => 'test',
+                        'uri' => null,
+                        'attributes' => array('class' => 'leaf'),
+                        'labelAttributes' => array('class' => 'center'),
+                        'linkAttributes' => array(),
+                        'childrenAttributes' => array(),
+                        'extras' => array(),
+                        'display' => true,
+                        'displayChildren' => false,
+                    ),
+                ),
+            ),
+            $menu->toArray(1)
+        );
+    }
+
+    public function testToArrayWithoutChildren()
+    {
+        $menu = $this->createMenu();
+        $menu->addChild('jack', array('uri' => 'http://php.net', 'linkAttributes' => array('title' => 'php'), 'display' => false));
+        $menu->addChild('joe', array('attributes' => array('class' => 'leaf'), 'label' => 'test', 'labelAttributes' => array('class' => 'center'), 'displayChildren' => false));
+
+        $this->assertEquals(
+            array(
+                'name' => 'test_menu',
+                'label' => null,
+                'uri' => 'homepage',
+                'attributes' => array(),
+                'labelAttributes' => array(),
+                'linkAttributes' => array(),
+                'childrenAttributes' => array(),
+                'extras' => array(),
+                'display' => true,
+                'displayChildren' => true,
+            ),
+            $menu->toArray(0)
+        );
+    }
+
+    public function testCallRecursively()
+    {
+        $menu = $this->createMenu();
+        $child1 = $this->getMock('Knp\Menu\ItemInterface');
+        $child1->expects($this->any())
+            ->method('getName')
+            ->will($this->returnValue('Child 1'))
+        ;
+        $child1->expects($this->once())
+            ->method('callRecursively')
+            ->with('setDisplay', array(false))
+        ;
+        $menu->addChild($child1);
+        $child2 = $this->getMock('Knp\Menu\ItemInterface');
+        $child2->expects($this->any())
+            ->method('getName')
+            ->will($this->returnValue('Child 2'))
+        ;
+        $child2->expects($this->once())
+            ->method('callRecursively')
+            ->with('setDisplay', array(false))
+        ;
+        $menu->addChild($child2);
+
+        $menu->callRecursively('setDisplay', array(false));
+        $this->assertFalse($menu->isDisplayed());
+    }
+
+    public function testFactory()
+    {
+        $child1 = $this->getMock('Knp\Menu\ItemInterface');
+        $factory = $this->getMock('Knp\Menu\FactoryInterface');
+        $factory->expects($this->once())
+            ->method('createItem')
+            ->will($this->returnValue($child1));
+
+        $menu = $this->createMenu();
+        $menu->setFactory($factory);
+
+        $menu->addChild('child1');
+    }
+
+    /**
+     * Create a new MenuItem
+     *
+     * @param string $name
+     * @param string $uri
+     * @param array $attributes
+     * @return \Knp\Menu\MenuItem
+     */
+    protected function createMenu($name = 'test_menu', $uri = 'homepage', array $attributes = array())
+    {
+        $factory = new MenuFactory();
+
+        return $factory->createItem($name, array('attributes' => $attributes, 'uri' => $uri));
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/MenuItemReorderTest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Knp\Menu\Tests;
+
+use Knp\Menu\MenuItem;
+use Knp\Menu\MenuFactory;
+
+class MenuItemReorderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testReordering()
+    {
+        $factory = new MenuFactory();
+        $menu = new MenuItem('root', $factory);
+        $menu->addChild('c1');
+        $menu->addChild('c2');
+        $menu->addChild('c3');
+        $menu->addChild('c4');
+
+        $menu['c3']->moveToFirstPosition();
+        $arr = array_keys($menu->getChildren());
+        $this->assertEquals(array('c3', 'c1', 'c2', 'c4'), $arr);
+
+        $menu['c2']->moveToLastPosition();
+        $arr = array_keys($menu->getChildren());
+        $this->assertEquals(array('c3', 'c1', 'c4', 'c2'), $arr);
+
+        $menu['c1']->moveToPosition(2);
+        $arr = array_keys($menu->getChildren());
+        $this->assertEquals(array('c3', 'c4', 'c1', 'c2'), $arr);
+
+        $menu->reorderChildren(array('c4', 'c3', 'c2', 'c1'));
+        $arr = array_keys($menu->getChildren());
+        $this->assertEquals(array('c4', 'c3', 'c2', 'c1'), $arr);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testReorderingWithTooManyItemNames()
+    {
+        $factory = new MenuFactory();
+        $menu = new MenuItem('root', $factory);
+        $menu->addChild('c1');
+        $menu->reorderChildren(array('c1', 'c3'));
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testReorderingWithWrongItemNames()
+    {
+        $factory = new MenuFactory();
+        $menu = new MenuItem('root', $factory);
+        $menu->addChild('c1');
+        $menu->addChild('c2');
+        $menu->reorderChildren(array('c1', 'c3'));
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/MenuItemTreeTest.php

@@ -0,0 +1,378 @@
+<?php
+
+namespace Knp\Menu\Tests;
+
+use Knp\Menu\Iterator\CurrentItemFilterIterator;
+use Knp\Menu\MenuItem;
+use Knp\Menu\MenuFactory;
+
+class TestMenuItem extends MenuItem {}
+
+class MenuItemTreeTest extends TestCase
+{
+    public function testSampleTreeIntegrity()
+    {
+        $this->assertCount(2, $this->menu);
+        $this->assertCount(3, $this->menu['Parent 1']);
+        $this->assertCount(1, $this->menu['Parent 2']);
+        $this->assertCount(1, $this->menu['Parent 2']['Child 4']);
+        $this->assertEquals('Grandchild 1', $this->menu['Parent 2']['Child 4']['Grandchild 1']->getName());
+    }
+
+    public function testGetLevel()
+    {
+        $this->assertEquals(0, $this->menu->getLevel());
+        $this->assertEquals(1, $this->pt1->getLevel());
+        $this->assertEquals(1, $this->pt2->getLevel());
+        $this->assertEquals(2, $this->ch4->getLevel());
+        $this->assertEquals(3, $this->gc1->getLevel());
+    }
+
+    public function testGetRoot()
+    {
+        $this->assertSame($this->menu, $this->menu->getRoot());
+        $this->assertSame($this->menu, $this->pt1->getRoot());
+        $this->assertSame($this->menu, $this->gc1->getRoot());
+    }
+
+    public function testIsRoot()
+    {
+        $this->assertTrue($this->menu->isRoot());
+        $this->assertFalse($this->pt1->isRoot());
+        $this->assertFalse($this->ch3->isRoot());
+    }
+
+    public function testGetParent()
+    {
+        $this->assertNull($this->menu->getParent());
+        $this->assertSame($this->menu, $this->pt1->getParent());
+        $this->assertSame($this->ch4, $this->gc1->getParent());
+    }
+
+    public function testMoveSampleMenuToNewRoot()
+    {
+        $newRoot = new TestMenuItem("newRoot", $this->getMock('Knp\Menu\FactoryInterface'));
+        $newRoot->addChild($this->menu);
+
+        $this->assertEquals(1, $this->menu->getLevel());
+        $this->assertEquals(2, $this->pt1->getLevel());
+
+        $this->assertSame($newRoot, $this->menu->getRoot());
+        $this->assertSame($newRoot, $this->pt1->getRoot());
+        $this->assertFalse($this->menu->isRoot());
+        $this->assertTrue($newRoot->isRoot());
+        $this->assertSame($newRoot, $this->menu->getParent());
+    }
+
+    public function testIsFirst()
+    {
+        $this->assertFalse($this->menu->isFirst(), 'The root item is not considered as first');
+        $this->assertTrue($this->pt1->isFirst());
+        $this->assertFalse($this->pt2->isFirst());
+        $this->assertTrue($this->ch4->isFirst());
+    }
+
+    public function testActsLikeFirst()
+    {
+        $this->ch1->setDisplay(false);
+        $this->assertFalse($this->menu->actsLikeFirst(), 'The root item is not considered as first');
+        $this->assertFalse($this->ch1->actsLikeFirst(), 'A hidden item does not acts like first');
+        $this->assertTrue($this->ch2->actsLikeFirst());
+        $this->assertFalse($this->ch3->actsLikeFirst());
+        $this->assertTrue($this->ch4->actsLikeFirst());
+    }
+
+    public function testActsLikeFirstWithNoDisplayedItem()
+    {
+        $this->pt1->setDisplay(false);
+        $this->pt2->setDisplay(false);
+        $this->assertFalse($this->pt1->actsLikeFirst());
+        $this->assertFalse($this->pt2->actsLikeFirst());
+    }
+
+    public function testIsLast()
+    {
+        $this->assertFalse($this->menu->isLast(), 'The root item is not considered as last');
+        $this->assertFalse($this->pt1->isLast());
+        $this->assertTrue($this->pt2->isLast());
+        $this->assertTrue($this->ch4->isLast());
+    }
+
+    public function testActsLikeLast()
+    {
+        $this->ch3->setDisplay(false);
+        $this->assertFalse($this->menu->actsLikeLast(), 'The root item is not considered as last');
+        $this->assertFalse($this->ch1->actsLikeLast());
+        $this->assertTrue($this->ch2->actsLikeLast());
+        $this->assertFalse($this->ch3->actsLikeLast(), 'A hidden item does not acts like last');
+        $this->assertTrue($this->ch4->actsLikeLast());
+    }
+
+    public function testActsLikeLastWithNoDisplayedItem()
+    {
+        $this->pt1->setDisplay(false);
+        $this->pt2->setDisplay(false);
+        $this->assertFalse($this->pt1->actsLikeLast());
+        $this->assertFalse($this->pt2->actsLikeLast());
+    }
+
+    public function testArrayAccess()
+    {
+        $this->menu->addChild('Child Menu');
+        $this->assertEquals('Child Menu', $this->menu['Child Menu']->getName());
+        $this->assertNull($this->menu['Fake']);
+
+        $this->menu['New Child'] = 'New Label';
+        $this->assertEquals('Knp\Menu\MenuItem', get_class($this->menu['New Child']));
+        $this->assertEquals('New Child', $this->menu['New Child']->getName());
+        $this->assertEquals('New Label', $this->menu['New Child']->getLabel());
+
+        unset($this->menu['New Child']);
+        $this->assertNull($this->menu['New Child']);
+    }
+
+    public function testCountable()
+    {
+        $this->assertCount(2, $this->menu);
+
+        $this->menu->addChild('New Child');
+        $this->assertCount(3, $this->menu);
+
+        unset($this->menu['New Child']);
+        $this->assertCount(2, $this->menu);
+    }
+
+    public function testGetChildren()
+    {
+        $children = $this->ch4->getChildren();
+        $this->assertCount(1, $children);
+        $this->assertEquals($this->gc1->getName(), $children['Grandchild 1']->getName());
+    }
+
+    public function testGetFirstChild()
+    {
+        $this->assertSame($this->pt1, $this->menu->getFirstChild());
+        // test for bug in getFirstChild implementation (when internal array pointer is changed getFirstChild returns wrong child)
+        foreach ($this->menu->getChildren() as $c);
+        $this->assertSame($this->pt1, $this->menu->getFirstChild());
+    }
+
+    public function testGetLastChild()
+    {
+        $this->assertSame($this->pt2, $this->menu->getLastChild());
+        // test for bug in getFirstChild implementation (when internal array pointer is changed getLastChild returns wrong child)
+        foreach ($this->menu->getChildren() as $c);
+        $this->assertSame($this->pt2, $this->menu->getLastChild());
+    }
+
+    public function testAddChildDoesNotUSeTheFactoryIfItem()
+    {
+        $factory = $this->getMock('Knp\Menu\FactoryInterface');
+        $factory->expects($this->never())
+            ->method('createItem');
+        $menu = new MenuItem('Root li', $factory);
+        $menu->addChild(new MenuItem('Child 3', $factory));
+    }
+
+    /**
+     * @expectedException LogicException
+     */
+    public function testAddChildFailsIfInAnotherMenu()
+    {
+        $factory = $this->getMock('Knp\Menu\FactoryInterface');
+        $menu = new MenuItem('Root li', $factory);
+        $child = new MenuItem('Child 3', $factory);
+        $menu->addChild($child);
+
+        $menu2 = new MenuItem('Second menu', $factory);
+        $menu2->addChild($child);
+    }
+
+    public function testGetChild()
+    {
+        $this->assertSame($this->gc1, $this->ch4->getChild('Grandchild 1'));
+        $this->assertNull($this->ch4->getChild('nonexistentchild'));
+    }
+
+    public function testRemoveChild()
+    {
+        $gc2 = $this->ch4->addChild('gc2');
+        $gc3 = $this->ch4->addChild('gc3');
+        $gc4 = $this->ch4->addChild('gc4');
+        $this->assertCount(4, $this->ch4);
+        $this->ch4->removeChild('gc4');
+        $this->assertCount(3, $this->ch4);
+        $this->assertTrue($this->ch4->getChild('Grandchild 1')->isFirst());
+        $this->assertTrue($this->ch4->getChild('gc3')->isLast());
+    }
+
+    public function testRemoveFakeChild()
+    {
+        $this->menu->removeChild('fake');
+        $this->assertCount(2, $this->menu);
+    }
+
+    public function testReAddRemovedChild()
+    {
+        $gc2 = $this->ch4->addChild('gc2');
+        $this->ch4->removeChild('gc2');
+        $this->menu->addChild($gc2);
+        $this->assertCount(3, $this->menu);
+        $this->assertTrue($gc2->isLast());
+        $this->assertFalse($this->pt2->isLast());
+    }
+
+    public function testUpdateChildAfterRename()
+    {
+        $this->pt1->setName('Temp name');
+        $this->assertSame($this->pt1, $this->menu->getChild('Temp name'));
+        $this->assertEquals(array('Temp name', 'Parent 2'), array_keys($this->menu->getChildren()));
+        $this->assertNull($this->menu->getChild('Parent 1'));
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRenameToExistingSiblingNameThrowAnException()
+    {
+        $this->pt1->setName('Parent 2');
+    }
+
+    public function testGetSetCurrentUri()
+    {
+        $this->addChildWithExternalUrl();
+        $this->assertNull($this->menu->getCurrentUri());
+        $this->menu->setCurrentUri('http://symfony-reloaded.org/');
+        $this->assertEquals('http://symfony-reloaded.org/', $this->menu->getCurrentUri());
+        $this->assertEquals('http://symfony-reloaded.org/', $this->menu['child']->getCurrentUri());
+    }
+
+    public function testChildrenCurrentUri()
+    {
+        $this->addChildWithExternalUrl();
+        $this->menu->setCurrentUri('http://symfony-reloaded.org/');
+        $this->menu->addChild('test_child', array('uri' => 'http://php.net/'));
+        $this->assertEquals('http://symfony-reloaded.org/', $this->menu['test_child']->getCurrentUri());
+    }
+
+    public function testGetIsCurrentWhenCurrentUriIsNotSet()
+    {
+        $this->addChildWithExternalUrl();
+        $this->assertFalse($this->menu['child']->isCurrent());
+    }
+
+    public function testGetIsCurrentWhenCurrentUriIsSet()
+    {
+        $this->addChildWithExternalUrl();
+        $this->menu->setCurrentUri('http://www.symfony-reloaded.org');
+        $this->assertTrue($this->menu['child']->isCurrent());
+        $this->assertFalse($this->pt1->isCurrent());
+    }
+
+    public function testGetIsCurrentAncestor()
+    {
+        $this->addChildWithExternalUrl();
+        $this->menu->setCurrentUri('http://php.net');
+        $this->pt1->setUri('http://php.net');
+        $this->assertFalse($this->pt1->isCurrentAncestor());
+        $this->assertTrue($this->menu->isCurrentAncestor());
+    }
+
+    public function testDeepGetIsCurrentAncestor()
+    {
+        $this->addChildWithExternalUrl();
+        $this->menu->setCurrentUri('http://php.net');
+        $this->gc1->setUri('http://php.net');
+        $this->assertFalse($this->pt1->isCurrentAncestor());
+        $this->assertTrue($this->menu->isCurrentAncestor());
+        $this->assertTrue($this->pt2->isCurrentAncestor());
+        $this->assertTrue($this->ch4->isCurrentAncestor());
+    }
+
+    public function testGetCurrentItem()
+    {
+        $this->ch4->setCurrent(true);
+        $this->assertSame($this->ch4, $this->ch4->getCurrentItem());
+        $this->assertSame($this->ch4, $this->menu->getCurrentItem());
+        $this->assertNull($this->pt1->getCurrentItem());
+    }
+
+    public function testGetUri()
+    {
+        $this->addChildWithExternalUrl();
+        $this->assertNull($this->pt1->getUri());
+        $this->assertEquals('http://www.symfony-reloaded.org', $this->menu['child']->getUri());
+    }
+
+    /**
+     * @dataProvider getSliceData
+     */
+    public function testSlice($offset, $length, $count, $keys)
+    {
+        $sliced = $this->pt1->slice($offset, $length);
+        $this->assertCount($count, $sliced);
+        $this->assertEquals($keys, array_keys($sliced->getChildren()));
+    }
+
+    public function getSliceData()
+    {
+        $this->setUp();
+        return array(
+            'numeric offset and numeric length' => array(0, 2, 2, array($this->ch1->getName(), $this->ch2->getName())),
+            'numeric offset and no length' => array(0, null, 3, array($this->ch1->getName(), $this->ch2->getName(), $this->ch3->getName())),
+            'named offset and no length' => array('Child 2', null, 2, array($this->ch2->getName(), $this->ch3->getName())),
+            'child offset and no length' => array($this->ch3, null, 1, array($this->ch3->getName())),
+            'numeric offset and named length' => array(0, 'Child 3', 2, array($this->ch1->getName(), $this->ch2->getName())),
+            'numeric offset and child length' => array(0, $this->ch3, 2, array($this->ch1->getName(), $this->ch2->getName())),
+        );
+    }
+
+    /**
+     * @dataProvider getSplitData
+     */
+    public function testSplit($length, $count, $keys)
+    {
+        $splitted = $this->pt1->split($length);
+        $this->assertArrayHasKey('primary', $splitted);
+        $this->assertArrayHasKey('secondary', $splitted);
+        $this->assertCount($count, $splitted['primary']);
+        $this->assertCount(3 - $count, $splitted['secondary']);
+        $this->assertEquals($keys, array_keys($splitted['primary']->getChildren()));
+    }
+
+    public function getSplitData()
+    {
+        $this->setUp();
+        return array(
+            'numeric length' => array(1, 1, array($this->ch1->getName())),
+            'named length' => array('Child 3', 2, array($this->ch1->getName(), $this->ch2->getName())),
+            'child length' => array($this->ch3, 2, array($this->ch1->getName(), $this->ch2->getName())),
+        );
+    }
+
+    public function testPathAsString()
+    {
+        $this->assertEquals('Root li > Parent 2 > Child 4', $this->ch4->getPathAsString(), 'Path with default separator');
+        $this->assertEquals('Root li / Parent 1 / Child 2', $this->ch2->getPathAsString(' / '), 'Path with custom separator');
+    }
+
+    public function testBreadcrumbsArray()
+    {
+        $this->addChildWithExternalUrl();
+        $this->menu->addChild('123', array('uri' => 'http://www.symfony-reloaded.org'));
+
+        $this->assertEquals(array('Root li' => null, 'Parent 1' => null), $this->pt1->getBreadcrumbsArray());
+        $this->assertEquals(array('Root li' => null, 'child' => 'http://www.symfony-reloaded.org'), $this->menu['child']->getBreadcrumbsArray());
+        $this->assertEquals(array('Root li' => null, 'child' => 'http://www.symfony-reloaded.org', 'subitem1' => null), $this->menu['child']->getBreadcrumbsArray('subitem1'));
+        $this->assertEquals(
+            array('Root li' => null, 'child' => 'http://www.symfony-reloaded.org', 'subitem1' => null, 'subitem2' => null, 'subitem3' => 'http://php.net'),
+            $this->menu['child']->getBreadcrumbsArray(array('subitem1', 'subitem2' => null, 'subitem3' => 'http://php.net'))
+        );
+        $this->assertEquals(array('Root li' => null, '123' => 'http://www.symfony-reloaded.org'), $this->menu['123']->getBreadcrumbsArray());
+    }
+
+    protected function addChildWithExternalUrl()
+    {
+        $this->menu->addChild('child', array('uri' => 'http://www.symfony-reloaded.org'));
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Provider/ChainProviderTest.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace Knp\Menu\Tests\Provider;
+
+use Knp\Menu\Provider\ChainProvider;
+
+class ChainProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testHas()
+    {
+        $innerProvider =  $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $innerProvider->expects($this->at(0))
+            ->method('has')
+            ->with('first')
+            ->will($this->returnValue(true))
+        ;
+        $innerProvider->expects($this->at(1))
+            ->method('has')
+            ->with('second')
+            ->will($this->returnValue(false))
+        ;
+        $innerProvider->expects($this->at(2))
+            ->method('has')
+            ->with('third', array('foo' => 'bar'))
+            ->will($this->returnValue(false))
+        ;
+        $provider = new ChainProvider(array($innerProvider));
+        $this->assertTrue($provider->has('first'));
+        $this->assertFalse($provider->has('second'));
+        $this->assertFalse($provider->has('third', array('foo' => 'bar')));
+    }
+
+    public function testGetExistentMenu()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $innerProvider =  $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $innerProvider->expects($this->any())
+            ->method('has')
+            ->with('default')
+            ->will($this->returnValue(true))
+        ;
+        $innerProvider->expects($this->once())
+            ->method('get')
+            ->with('default')
+            ->will($this->returnValue($menu))
+        ;
+
+        $provider = new ChainProvider(array($innerProvider));
+        $this->assertSame($menu, $provider->get('default'));
+    }
+
+    public function testGetWithOptions()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $innerProvider =  $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $innerProvider->expects($this->any())
+            ->method('has')
+            ->with('default', array('foo' => 'bar'))
+            ->will($this->returnValue(true))
+        ;
+        $innerProvider->expects($this->once())
+            ->method('get')
+            ->with('default', array('foo' => 'bar'))
+            ->will($this->returnValue($menu))
+        ;
+
+        $provider = new ChainProvider(array($innerProvider));
+        $this->assertSame($menu, $provider->get('default', array('foo' => 'bar')));
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetNonExistentMenu()
+    {
+        $provider = new ChainProvider(array());
+        $provider->get('non-existent');
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Provider/PimpleProviderTest.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Knp\Menu\Tests\Provider;
+
+use Knp\Menu\Provider\PimpleProvider;
+
+class PimpleProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function setUp()
+    {
+        if (!class_exists('Pimple')) {
+            $this->markTestSkipped('Pimple is not available');
+        }
+    }
+
+    public function testHas()
+    {
+        $provider = new PimpleProvider(new \Pimple(), array('first' => 'first', 'second' => 'dummy'));
+        $this->assertTrue($provider->has('first'));
+        $this->assertTrue($provider->has('second'));
+        $this->assertFalse($provider->has('third'));
+    }
+
+    public function testGetExistentMenu()
+    {
+        $pimple = new \Pimple();
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $pimple['menu'] = function() use ($menu) {
+            return $menu;
+        };
+        $provider = new PimpleProvider($pimple, array('default' => 'menu'));
+        $this->assertSame($menu, $provider->get('default'));
+    }
+
+    public function testGetMenuAsClosure()
+    {
+        $pimple = new \Pimple();
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $pimple['menu'] = $pimple->protect(function($options, $c) use ($menu) {
+            $c['options'] = $options;
+            return $menu;
+        });
+        $provider = new PimpleProvider($pimple, array('default' => 'menu'));
+
+        $this->assertSame($menu, $provider->get('default', array('foo' => 'bar')));
+        $this->assertEquals(array('foo' => 'bar'), $pimple['options']);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetNonExistentMenu()
+    {
+        $provider = new PimpleProvider(new \Pimple());
+        $provider->get('non-existent');
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Renderer/AbstractRendererTest.php

@@ -0,0 +1,345 @@
+<?php
+
+namespace Knp\Menu\Tests\Renderer;
+
+use Knp\Menu\MenuItem;
+use Knp\Menu\MenuFactory;
+
+abstract class AbstractRendererTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \Knp\Menu\Renderer\RendererInterface
+     */
+    private $renderer;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    private $menu;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    private $pt1;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    private $ch1;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    private $ch2;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    private $ch3;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    private $pt2;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    private $ch4;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    private $gc1;
+
+    public function setUp()
+    {
+        $this->renderer = $this->createRenderer();
+
+        $this->menu = new MenuItem('Root li', new MenuFactory());
+        $this->menu->setChildrenAttributes(array('class' => 'root'));
+        $this->pt1 = $this->menu->addChild('Parent 1');
+        $this->ch1 = $this->pt1->addChild('Child 1');
+        $this->ch2 = $this->pt1->addChild('Child 2');
+
+        // add the 3rd child via addChild with an object
+        $this->ch3 = new MenuItem('Child 3', new MenuFactory());
+        $this->pt1->addChild($this->ch3);
+
+        $this->pt2 = $this->menu->addChild('Parent 2');
+        $this->ch4 = $this->pt2->addChild('Child 4');
+        $this->gc1 = $this->ch4->addChild('Grandchild 1');
+    }
+
+    abstract protected function createRenderer();
+
+    public function tearDown()
+    {
+        $this->renderer = null;
+        $this->menu = null;
+        $this->pt1 = null;
+        $this->ch1 = null;
+        $this->ch2 = null;
+        $this->ch3 = null;
+        $this->pt2 = null;
+        $this->ch4 = null;
+        $this->gc1 = null;
+    }
+
+    public function testRenderEmptyRoot()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $rendered = '';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderRootWithAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->setChildrenAttributes(array('class' => 'test_class'));
+        $menu->addChild('c1');
+        $rendered = '<ul class="test_class"><li class="first last"><span>c1</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderEncodedAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->setChildrenAttributes(array('title' => 'encode " me >'));
+        $menu->addChild('c1');
+        $rendered = '<ul title="encode &quot; me &gt;"><li class="first last"><span>c1</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderLink()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('uri' => '/about'));
+
+        $rendered = '<ul><li class="first last"><a href="/about">About</a></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderLinkWithAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('uri' => '/about', 'linkAttributes' => array('title' => 'About page')));
+
+        $rendered = '<ul><li class="first last"><a href="/about" title="About page">About</a></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderLinkWithEmptyAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array(
+            'uri' => '/about',
+            'linkAttributes' => array('title' => '', 'rel' => null, 'target' => false)
+        ));
+
+        $rendered = '<ul><li class="first last"><a href="/about" title="">About</a></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderLinkWithSpecialAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('uri' => '/about', 'linkAttributes' => array('title' => true)));
+
+        $rendered = '<ul><li class="first last"><a href="/about" title="title">About</a></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderChildrenWithAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $about = $menu->addChild('About');
+        $about->addChild('Us');
+        $about->setChildrenAttribute('title', 'About page');
+
+        $rendered = '<ul><li class="first last"><span>About</span><ul title="About page" class="menu_level_1"><li class="first last"><span>Us</span></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderChildrenWithEmptyAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $about = $menu->addChild('About');
+        $about->addChild('Us');
+        $about->setChildrenAttribute('title', '');
+        $about->setChildrenAttribute('rel', null);
+        $about->setChildrenAttribute('target', false);
+
+        $rendered = '<ul><li class="first last"><span>About</span><ul title="" class="menu_level_1"><li class="first last"><span>Us</span></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderChildrenWithSpecialAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $about = $menu->addChild('About');
+        $about->addChild('Us');
+        $about->setChildrenAttribute('title', true);
+
+        $rendered = '<ul><li class="first last"><span>About</span><ul title="title" class="menu_level_1"><li class="first last"><span>Us</span></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderLabelWithAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('labelAttributes' => array('title' => 'About page')));
+
+        $rendered = '<ul><li class="first last"><span title="About page">About</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderLabelWithEmptyAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('labelAttributes' => array('title' => '', 'rel' => null, 'target' => false)));
+
+        $rendered = '<ul><li class="first last"><span title="">About</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderLabelWithSpecialAttributes()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('labelAttributes' => array('title' => true)));
+
+        $rendered = '<ul><li class="first last"><span title="title">About</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderWeirdLink()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('uri' => 'http://en.wikipedia.org/wiki/%22Weird_Al%22_Yankovic?v1=1&v2=2'));
+
+        $rendered = '<ul><li class="first last"><a href="http://en.wikipedia.org/wiki/%22Weird_Al%22_Yankovic?v1=1&amp;v2=2">About</a></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderEscapedLabel()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('label' => 'Encode " me'));
+        $menu->addChild('Safe', array('label' => 'Encode " me again', 'extras' => array('safe_label' => true)));
+        $menu->addChild('Escaped', array('label' => 'Encode " me too', 'extras' => array('safe_label' => false)));
+
+        $rendered = '<ul><li class="first"><span>Encode &quot; me</span></li><li><span>Encode &quot; me again</span></li><li class="last"><span>Encode &quot; me too</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderSafeLabel()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About', array('label' => 'Encode " me'));
+        $menu->addChild('Safe', array('label' => 'Encode " me again', 'extras' => array('safe_label' => true)));
+        $menu->addChild('Escaped', array('label' => 'Encode " me too', 'extras' => array('safe_label' => false)));
+
+        $rendered = '<ul><li class="first"><span>Encode &quot; me</span></li><li><span>Encode " me again</span></li><li class="last"><span>Encode &quot; me too</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu, array('allow_safe_labels' => true)));
+    }
+
+    public function testRenderWholeMenu()
+    {
+        $rendered = '<ul class="root"><li class="first"><span>Parent 1</span><ul class="menu_level_1"><li class="first"><span>Child 1</span></li><li><span>Child 2</span></li><li class="last"><span>Child 3</span></li></ul></li><li class="last"><span>Parent 2</span><ul class="menu_level_1"><li class="first last"><span>Child 4</span><ul class="menu_level_2"><li class="first last"><span>Grandchild 1</span></li></ul></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu));
+    }
+
+    public function testRenderWithClassAndTitle()
+    {
+        $this->pt2->setAttribute('class', 'parent2_class');
+        $this->pt2->setAttribute('title', 'parent2 title');
+        $rendered = '<ul class="root"><li class="first"><span>Parent 1</span><ul class="menu_level_1"><li class="first"><span>Child 1</span></li><li><span>Child 2</span></li><li class="last"><span>Child 3</span></li></ul></li><li class="parent2_class last" title="parent2 title"><span>Parent 2</span><ul class="menu_level_1"><li class="first last"><span>Child 4</span><ul class="menu_level_2"><li class="first last"><span>Grandchild 1</span></li></ul></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu));
+    }
+
+    public function testRenderWithCurrentItem()
+    {
+        $this->ch2->setCurrent(true);
+        $rendered = '<ul class="root"><li class="current_ancestor first"><span>Parent 1</span><ul class="menu_level_1"><li class="first"><span>Child 1</span></li><li class="current"><span>Child 2</span></li><li class="last"><span>Child 3</span></li></ul></li><li class="last"><span>Parent 2</span><ul class="menu_level_1"><li class="first last"><span>Child 4</span><ul class="menu_level_2"><li class="first last"><span>Grandchild 1</span></li></ul></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu));
+    }
+
+    public function testRenderWithCurrentItemAsLink()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $about = $menu->addChild('About', array('uri' => '/about'));
+        $about->setCurrent(true);
+
+        $rendered = '<ul><li class="current first last"><a href="/about">About</a></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu));
+    }
+
+    public function testRenderWithCurrentItemNotAsLink()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $about = $menu->addChild('About', array('uri' => '/about'));
+        $about->setCurrent(true);
+
+        $rendered = '<ul><li class="current first last"><span>About</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($menu, array('currentAsLink' => false)));
+    }
+
+    public function testRenderSubMenuPortionWithClassAndTitle()
+    {
+        $this->pt2->setChildrenAttribute('class', 'parent2_class')->setChildrenAttribute('title', 'parent2 title');
+        $rendered = '<ul class="parent2_class" title="parent2 title"><li class="first last"><span>Child 4</span><ul class="menu_level_2"><li class="first last"><span>Grandchild 1</span></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu['Parent 2']));
+    }
+
+    public function testDoNotShowChildrenRendersNothing()
+    {
+        $this->menu->setDisplayChildren(false);
+        $rendered = '';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu));
+    }
+
+    public function testDoNotShowChildChildrenRendersPartialMenu()
+    {
+        $this->menu['Parent 1']->setDisplayChildren(false);
+        $rendered = '<ul class="root"><li class="first"><span>Parent 1</span></li><li class="last"><span>Parent 2</span><ul class="menu_level_1"><li class="first last"><span>Child 4</span><ul class="menu_level_2"><li class="first last"><span>Grandchild 1</span></li></ul></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu));
+    }
+
+    public function testDoNotShowChildRendersPartialMenu()
+    {
+        $this->menu['Parent 1']->setDisplay(false);
+        $rendered = '<ul class="root"><li class="first last"><span>Parent 2</span><ul class="menu_level_1"><li class="first last"><span>Child 4</span><ul class="menu_level_2"><li class="first last"><span>Grandchild 1</span></li></ul></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu));
+    }
+
+    public function testDepth0()
+    {
+        $rendered = '';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu, array('depth' => 0)));
+    }
+
+    public function testDepth1()
+    {
+        $rendered = '<ul class="root"><li class="first"><span>Parent 1</span></li><li class="last"><span>Parent 2</span></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu, array('depth' => 1)));
+    }
+
+    public function testDepth2()
+    {
+        $rendered = '<ul class="root"><li class="first"><span>Parent 1</span><ul class="menu_level_1"><li class="first"><span>Child 1</span></li><li><span>Child 2</span></li><li class="last"><span>Child 3</span></li></ul></li><li class="last"><span>Parent 2</span><ul class="menu_level_1"><li class="first last"><span>Child 4</span></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu, array('depth' => 2)));
+    }
+
+    public function testDepth2WithNotShowChildChildren()
+    {
+        $this->menu['Parent 1']->setDisplayChildren(false);
+        $rendered = '<ul class="root"><li class="first"><span>Parent 1</span></li><li class="last"><span>Parent 2</span><ul class="menu_level_1"><li class="first last"><span>Child 4</span></li></ul></li></ul>';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu, array('depth' => 2)));
+    }
+
+    public function testEmptyUncompressed()
+    {
+        $rendered = '';
+        $this->assertEquals($rendered, $this->renderer->render($this->menu, array('depth' => 0, 'compressed' => false)));
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Renderer/ListRendererTest.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Knp\Menu\Tests\Renderer;
+
+use Knp\Menu\Renderer\ListRenderer;
+use Knp\Menu\MenuItem;
+use Knp\Menu\MenuFactory;
+
+class ListRendererTest extends AbstractRendererTest
+{
+    protected function createRenderer()
+    {
+        $renderer = new ListRenderer(array('compressed' => true));
+
+        return $renderer;
+    }
+
+    public function testPrettyRendering()
+    {
+        $menu = new MenuItem('Root li', new MenuFactory());
+        $menu->setChildrenAttributes(array('class' => 'root'));
+        $menu->addChild('Parent 1');
+        $menu->addChild('Parent 2');
+
+        $renderer = new ListRenderer();
+        $rendered = <<<HTML
+<ul class="root">
+  <li class="first">
+    <span>Parent 1</span>
+  </li>
+  <li class="last">
+    <span>Parent 2</span>
+  </li>
+</ul>
+
+HTML;
+
+        $this->assertEquals($rendered, $renderer->render($menu));
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Renderer/PimpleProviderTest.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Knp\Menu\Tests\Renderer;
+
+use Knp\Menu\Renderer\PimpleProvider;
+
+class PimpleProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function setUp()
+    {
+        if (!class_exists('Pimple')) {
+            $this->markTestSkipped('Pimple is not available');
+        }
+    }
+
+    public function testHas()
+    {
+        $provider = new PimpleProvider(new \Pimple(), 'first', array('first' => 'first', 'second' => 'dummy'));
+        $this->assertTrue($provider->has('first'));
+        $this->assertTrue($provider->has('second'));
+        $this->assertFalse($provider->has('third'));
+    }
+
+    public function testGetExistentRenderer()
+    {
+        $pimple = new \Pimple();
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $pimple['renderer'] = function() use ($renderer) {
+            return $renderer;
+        };
+        $provider = new PimpleProvider($pimple, 'default',  array('default' => 'renderer'));
+        $this->assertSame($renderer, $provider->get('default'));
+    }
+
+    public function testGetDefaultRenderer()
+    {
+        $pimple = new \Pimple();
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $pimple['renderer'] = function() use ($renderer) {
+            return $renderer;
+        };
+        $provider = new PimpleProvider($pimple, 'default',  array('default' => 'renderer'));
+        $this->assertSame($renderer, $provider->get());
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetNonExistentRenderer()
+    {
+        $provider = new PimpleProvider(new \Pimple(), 'default', array());
+        $provider->get('non-existent');
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Renderer/TwigRendererTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Knp\Menu\Tests\Renderer;
+
+use Knp\Menu\Renderer\TwigRenderer;
+use Knp\Menu\MenuItem;
+use Knp\Menu\MenuFactory;
+
+class TwigRendererTest extends AbstractRendererTest
+{
+    public function createRenderer()
+    {
+        if (!class_exists('Twig_Environment')) {
+            $this->markTestSkipped('Twig is not available');
+        }
+        $loader = new \Twig_Loader_Filesystem(__DIR__.'/../../../../../src/Knp/Menu/Resources/views');
+        $environment = new \Twig_Environment($loader);
+        $renderer = new TwigRenderer($environment, 'knp_menu.html.twig', array('compressed' => true));
+
+        return $renderer;
+    }
+
+    public function testRenderOrderedList()
+    {
+        $menu = new MenuItem('test', new MenuFactory());
+        $menu->addChild('About')->addChild('foobar');
+
+        $rendered = '<ol><li class="first last"><span>About</span><ol class="menu_level_1"><li class="first last"><span>foobar</span></li></ol></li></ol>';
+        $this->assertEquals($rendered, $this->createRenderer()->render($menu, array('template' => 'knp_menu_ordered.html.twig')));
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Silex/KnpMenuServiceProviderTest.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Knp\Menu\Tests\Silex;
+
+use Knp\Menu\ItemInterface;
+use Knp\Menu\Silex\KnpMenuServiceProvider;
+use Silex\Application;
+use Silex\Provider\TwigServiceProvider;
+use Silex\Provider\UrlGeneratorServiceProvider;
+use Symfony\Component\HttpFoundation\Request;
+
+class KnpMenuServiceProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function setUp()
+    {
+        if (!class_exists('Silex\Application')) {
+            $this->markTestSkipped('Silex is not available');
+        }
+    }
+
+    public function testFactoryWithoutRouter()
+    {
+        $app = new Application();
+        $app->register(new KnpMenuServiceProvider());
+
+        $this->assertEquals('Knp\Menu\MenuFactory', get_class($app['knp_menu.factory']));
+    }
+
+    public function testFactoryWithRouter()
+    {
+        $app = new Application();
+        $app->register(new KnpMenuServiceProvider());
+        $app->register(new UrlGeneratorServiceProvider());
+
+        $this->assertInstanceOf('Knp\Menu\Silex\RouterAwareFactory', $app['knp_menu.factory']);
+    }
+
+    public function testTwigRendererNotRegistered()
+    {
+        $app = new Application();
+        $app->register(new KnpMenuServiceProvider());
+
+        $this->assertFalse(isset($app['knp_menu.renderer.twig']));
+    }
+
+    public function testTwigRendererRegistered()
+    {
+        $app = new Application();
+        $app->register(new TwigServiceProvider());
+        $app->register(new KnpMenuServiceProvider());
+
+        $this->assertTrue(isset($app['knp_menu.renderer.twig']));
+    }
+
+    public function testRenderNotCurrentWithList()
+    {
+        $app = $this->bootstrapApp();
+
+        $request = Request::create('/list');
+        $response = $app->handle($request);
+        $this->assertEquals('<ul class="nav"><li class="first"><a href="/twig">Home</a></li><li class="last"><a href="http://knplabs.com">KnpLabs</a></li></ul>', $response->getContent());
+    }
+
+    public function testRenderCurrentWithTwig()
+    {
+        $app = $this->bootstrapApp();
+
+        $app['test.menu.my'] = $app->extend('test.menu.my', function (\Knp\Menu\ItemInterface $menu) {
+            $menu->setCurrentUri('http://knplabs.com');
+
+            return $menu;
+        });
+
+        $request = Request::create('/twig');
+        $response = $app->handle($request);
+        $this->assertEquals('<ul class="nav"><li class="first"><a href="/twig">Home</a></li><li class="current last"><a href="http://knplabs.com">KnpLabs</a></li></ul>', $response->getContent());
+    }
+
+    private function bootstrapApp()
+    {
+        $app = new Application();
+        $app['debug'] = true;
+        $app->register(new TwigServiceProvider(), array(
+            'twig.templates' => array('main' => '{{ knp_menu_render("my_menu", {"compressed": true}, renderer) }}'),
+        ));
+        $app->register(new KnpMenuServiceProvider(), array(
+            'knp_menu.menus' => array('my_menu' => 'test.menu.my'),
+        ));
+        $app->register(new UrlGeneratorServiceProvider());
+
+        $app['test.menu.my'] = function (Application $app) {
+            /** @var $factory \Knp\Menu\FactoryInterface */
+            $factory = $app['knp_menu.factory'];
+
+            $root = $factory->createItem('root', array('childrenAttributes' => array('class' => 'nav')));
+            $root->addChild('home', array('route' => 'homepage', 'label' => 'Home'));
+            $root->addChild('KnpLabs', array('uri' => 'http://knplabs.com', 'extras' => array('routes' => 'homepage')));
+
+            return $root;
+        };
+
+        $app->get('/twig', function (Application $app) {
+            return $app['twig']->render('main', array('renderer' => 'twig'));
+        })->bind('homepage');
+
+        $app->get('/list', function (Application $app) {
+            return $app['twig']->render('main', array('renderer' => 'list'));
+        })->bind('list');
+
+        return $app;
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Silex/RouterAwareFactoryTest.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Knp\Menu\Tests\Silex;
+
+use Knp\Menu\Silex\RouterAwareFactory;
+
+class RouterAwareFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function setUp()
+    {
+        if (!interface_exists('Symfony\Component\Routing\Generator\UrlGeneratorInterface')) {
+            $this->markTestSkipped('The Symfony2 Routing component is not available');
+        }
+    }
+
+    public function testCreateItemWithRoute()
+    {
+        $generator = $this->getMock('Symfony\Component\Routing\Generator\UrlGeneratorInterface');
+        $generator->expects($this->once())
+            ->method('generate')
+            ->with('homepage', array(), false)
+            ->will($this->returnValue('/foobar'))
+        ;
+        $factory = new RouterAwareFactory($generator);
+        $item = $factory->createItem('test_item', array('uri' => '/hello', 'route' => 'homepage'));
+        $this->assertEquals('/foobar', $item->getUri());
+    }
+
+    public function testCreateItemWithRouteAndParameters()
+    {
+        $generator = $this->getMock('Symfony\Component\Routing\Generator\UrlGeneratorInterface');
+        $generator->expects($this->once())
+            ->method('generate')
+            ->with('homepage', array('id' => 12), false)
+            ->will($this->returnValue('/foobar'))
+        ;
+        $factory = new RouterAwareFactory($generator);
+        $item = $factory->createItem('test_item', array('route' => 'homepage', 'routeParameters' => array('id' => 12)));
+        $this->assertEquals('/foobar', $item->getUri());
+    }
+
+    public function testCreateItemWithAbsoluteRoute()
+    {
+        $generator = $this->getMock('Symfony\Component\Routing\Generator\UrlGeneratorInterface');
+        $generator->expects($this->once())
+            ->method('generate')
+            ->with('homepage', array(), true)
+            ->will($this->returnValue('http://php.net'))
+        ;
+        $factory = new RouterAwareFactory($generator);
+        $item = $factory->createItem('test_item', array('route' => 'homepage', 'routeAbsolute' => true));
+        $this->assertEquals('http://php.net', $item->getUri());
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/TestCase.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Knp\Menu\Tests;
+
+use Knp\Menu\Iterator\CurrentItemFilterIterator;
+use Knp\Menu\MenuItem;
+use Knp\Menu\MenuFactory;
+
+abstract class TestCase extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    protected $menu;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    protected $pt1;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    protected $ch1;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    protected $ch2;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    protected $ch3;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    protected $pt2;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    protected $ch4;
+
+    /**
+     * @var \Knp\Menu\MenuItem
+     */
+    protected $gc1;
+
+    protected function setUp()
+    {
+        $factory = new MenuFactory();
+        $this->menu = $factory->createItem('Root li', array('attributes' => array('class' => 'root')));
+        $this->pt1 = $this->menu->addChild('Parent 1');
+        $this->ch1 = $this->pt1->addChild('Child 1');
+        $this->ch2 = $this->pt1->addChild('Child 2');
+
+        // add the 3rd child via addChild with an object
+        $this->ch3 = new MenuItem('Child 3', $factory);
+        $this->pt1->addChild($this->ch3);
+
+        $this->pt2 = $this->menu->addChild('Parent 2');
+        $this->ch4 = $this->pt2->addChild('Child 4');
+        $this->gc1 = $this->ch4->addChild('Grandchild 1');
+    }
+
+    protected function tearDown()
+    {
+        $this->menu = null;
+        $this->pt1 = null;
+        $this->ch1 = null;
+        $this->ch2 = null;
+        $this->ch3 = null;
+        $this->pt2 = null;
+        $this->ch4 = null;
+        $this->gc1 = null;
+    }
+
+    // prints a visual representation of our basic testing tree
+    protected function printTestTree()
+    {
+        print('      Menu Structure   '."\n");
+        print('               rt      '."\n");
+        print('             /    \    '."\n");
+        print('          pt1      pt2 '."\n");
+        print('        /  | \      |  '."\n");
+        print('      ch1 ch2 ch3  ch4 '."\n");
+        print('                    |  '."\n");
+        print('                   gc1 '."\n");
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Twig/HelperTest.php

@@ -0,0 +1,252 @@
+<?php
+
+namespace Knp\Menu\Tests\Twig;
+
+use Knp\Menu\Twig\Helper;
+
+class HelperTest extends \PHPUnit_Framework_TestCase
+{
+    public function testRenderMenu()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $renderer->expects($this->once())
+            ->method('render')
+            ->with($menu, array())
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $rendererProvider->expects($this->once())
+            ->method('get')
+            ->with(null)
+            ->will($this->returnValue($renderer))
+        ;
+
+        $helper = new Helper($rendererProvider);
+
+        $this->assertEquals('<p>foobar</p>', $helper->render($menu));
+    }
+
+    public function testRenderMenuWithOptions()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $renderer->expects($this->once())
+            ->method('render')
+            ->with($menu, array('firstClass' => 'test'))
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $rendererProvider->expects($this->once())
+            ->method('get')
+            ->with(null)
+            ->will($this->returnValue($renderer))
+        ;
+
+        $helper = new Helper($rendererProvider);
+
+        $this->assertEquals('<p>foobar</p>', $helper->render($menu, array('firstClass' => 'test')));
+    }
+
+    public function testRenderMenuWithRenderer()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $renderer->expects($this->once())
+            ->method('render')
+            ->with($menu, array())
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $rendererProvider->expects($this->once())
+            ->method('get')
+            ->with('custom')
+            ->will($this->returnValue($renderer))
+        ;
+
+        $helper = new Helper($rendererProvider);
+
+        $this->assertEquals('<p>foobar</p>', $helper->render($menu, array(), 'custom'));
+    }
+
+    public function testRenderMenuByName()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $menuProvider = $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $menuProvider->expects($this->once())
+            ->method('get')
+            ->with('default')
+            ->will($this->returnValue($menu))
+        ;
+
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $renderer->expects($this->once())
+            ->method('render')
+            ->with($menu, array())
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $rendererProvider->expects($this->once())
+            ->method('get')
+            ->with(null)
+            ->will($this->returnValue($renderer))
+        ;
+
+        $helper = new Helper($rendererProvider, $menuProvider);
+
+        $this->assertEquals('<p>foobar</p>', $helper->render('default'));
+    }
+
+    public function testGetMenu()
+    {
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $menuProvider = $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $menuProvider->expects($this->once())
+            ->method('get')
+            ->with('default')
+            ->will($this->returnValue($menu))
+        ;
+
+        $helper = new Helper($rendererProvider, $menuProvider);
+
+        $this->assertSame($menu, $helper->get('default'));
+    }
+
+    /**
+     * @expectedException LogicException
+     */
+    public function testGetMenuWithBadReturnValue()
+    {
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $menuProvider = $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $menuProvider->expects($this->once())
+            ->method('get')
+            ->with('default')
+            ->will($this->returnValue(new \stdClass()))
+        ;
+
+        $helper = new Helper($rendererProvider, $menuProvider);
+        $helper->get('default');
+    }
+
+    /**
+     * @expectedException BadMethodCallException
+     */
+    public function testGetMenuWithoutProvider()
+    {
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $helper = new Helper($rendererProvider);
+        $helper->get('default');
+    }
+
+    public function testGetMenuWithOptions()
+    {
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $menuProvider = $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $menuProvider->expects($this->once())
+            ->method('get')
+            ->with('default', array('foo' => 'bar'))
+            ->will($this->returnValue($menu))
+        ;
+
+        $helper = new Helper($rendererProvider, $menuProvider);
+
+        $this->assertSame($menu, $helper->get('default', array(), array('foo' => 'bar')));
+    }
+
+    public function testGetMenuByPath()
+    {
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $menuProvider = $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $child = $this->getMock('Knp\Menu\ItemInterface');
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $menu->expects($this->any())
+            ->method('getChild')
+            ->with('child')
+            ->will($this->returnValue($child))
+        ;
+        $menuProvider->expects($this->once())
+            ->method('get')
+            ->with('default')
+            ->will($this->returnValue($menu))
+        ;
+
+        $helper = new Helper($rendererProvider, $menuProvider);
+
+        $this->assertSame($child, $helper->get('default', array('child')));
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testGetMenuByInvalidPath()
+    {
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $menuProvider = $this->getMock('Knp\Menu\Provider\MenuProviderInterface');
+        $child = $this->getMock('Knp\Menu\ItemInterface');
+        $child->expects($this->any())
+            ->method('getChild')
+            ->will($this->returnValue(null))
+        ;
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $menu->expects($this->any())
+            ->method('getChild')
+            ->with('child')
+            ->will($this->returnValue($child))
+        ;
+        $menuProvider->expects($this->once())
+            ->method('get')
+            ->with('default')
+            ->will($this->returnValue($menu))
+        ;
+
+        $helper = new Helper($rendererProvider, $menuProvider);
+
+        $this->assertSame($child, $helper->get('default', array('child', 'invalid')));
+    }
+
+    public function testRenderMenuByPath()
+    {
+        $child = $this->getMock('Knp\Menu\ItemInterface');
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $menu->expects($this->any())
+            ->method('getChild')
+            ->with('child')
+            ->will($this->returnValue($child))
+        ;
+
+        $renderer = $this->getMock('Knp\Menu\Renderer\RendererInterface');
+        $renderer->expects($this->once())
+            ->method('render')
+            ->with($child, array())
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $rendererProvider = $this->getMock('Knp\Menu\Renderer\RendererProviderInterface');
+        $rendererProvider->expects($this->once())
+            ->method('get')
+            ->with(null)
+            ->will($this->returnValue($renderer))
+        ;
+
+        $helper = new Helper($rendererProvider);
+
+        $this->assertEquals('<p>foobar</p>', $helper->render(array($menu, 'child')));
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage The array cannot be empty
+     */
+    public function testRenderByEmptyPath()
+    {
+        $helper = new Helper($this->getMock('Knp\Menu\Renderer\RendererProviderInterface'));
+        $helper->render(array());
+    }
+}

vendor/knplabs/knp-menu/tests/Knp/Menu/Tests/Twig/MenuExtensionTest.php

@@ -0,0 +1,146 @@
+<?php
+
+namespace Knp\Menu\Tests\Twig;
+
+use Knp\Menu\Twig\MenuExtension;
+
+class MenuExtensionTest extends \PHPUnit_Framework_TestCase
+{
+    public function setUp()
+    {
+        if (!class_exists('Twig_Environment')) {
+            $this->markTestSkipped('Twig is not available');
+        }
+    }
+
+    public function testRenderMenu()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $helper = $this->getHelperMock(array('render'));
+        $helper->expects($this->once())
+            ->method('render')
+            ->with($menu, array(), null)
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(menu) }}', $helper)->render(array('menu' => $menu)));
+    }
+
+    public function testRenderMenuWithOptions()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $helper = $this->getHelperMock(array('render'));
+        $helper->expects($this->once())
+            ->method('render')
+            ->with($menu, array('firstClass' => 'test'), null)
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(menu, {"firstClass": "test"}) }}', $helper)->render(array('menu' => $menu)));
+    }
+
+    public function testRenderMenuWithRenderer()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $helper = $this->getHelperMock(array('render'));
+        $helper->expects($this->once())
+            ->method('render')
+            ->with($menu, array(), 'custom')
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(menu, {}, "custom") }}', $helper)->render(array('menu' => $menu)));
+    }
+
+    public function testRenderMenuByName()
+    {
+        $helper = $this->getHelperMock(array('render'));
+        $helper->expects($this->once())
+            ->method('render')
+            ->with('default', array(), null)
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+
+        $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(menu) }}', $helper)->render(array('menu' => 'default')));
+    }
+
+    public function testGetMenu()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $helper = $this->getHelperMock(array('get'));
+        $helper->expects($this->once())
+            ->method('get')
+            ->with('default')
+            ->will($this->returnValue($menu))
+        ;
+        $extension = new MenuExtension($helper);
+        $this->assertSame($menu, $extension->get('default'));
+    }
+
+    public function testGetMenuWithOptions()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $helper = $this->getHelperMock(array('get'));
+        $helper->expects($this->once())
+            ->method('get')
+            ->with('default', array(), array('foo' => 'bar'))
+            ->will($this->returnValue($menu))
+        ;
+        $extension = new MenuExtension($helper);
+        $this->assertSame($menu, $extension->get('default', array(), array('foo' => 'bar')));
+    }
+
+    public function testGetMenuByPath()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $helper = $this->getHelperMock(array('get'));
+        $helper->expects($this->once())
+            ->method('get')
+            ->with('default', array('child'))
+            ->will($this->returnValue($menu))
+        ;
+        $extension = new MenuExtension($helper);
+        $this->assertSame($menu, $extension->get('default', array('child')));
+    }
+
+    public function testRetrieveMenuByName()
+    {
+        $menu = $this->getMock('Knp\Menu\ItemInterface');
+        $helper = $this->getHelperMock(array('get', 'render'));
+        $helper->expects($this->once())
+            ->method('render')
+            ->with($menu, array(), null)
+            ->will($this->returnValue('<p>foobar</p>'))
+        ;
+        $helper->expects($this->once())
+            ->method('get')
+            ->with('default')
+            ->will($this->returnValue($menu))
+        ;
+
+        $this->assertEquals('<p>foobar</p>', $this->getTemplate('{{ knp_menu_render(knp_menu_get("default")) }}', $helper)->render(array()));
+    }
+
+    private function getHelperMock(array $methods)
+    {
+        return $this->getMockBuilder('Knp\Menu\Twig\Helper')
+            ->disableOriginalConstructor()
+            ->setMethods($methods)
+            ->getMock()
+        ;
+    }
+
+    /**
+     * @param string $template
+     * @param \Knp\Menu\Twig\Helper $helper
+     * @return \Twig_TemplateInterface
+     */
+    private function getTemplate($template, $helper)
+    {
+        $loader = new \Twig_Loader_Array(array('index' => $template));
+        $twig = new \Twig_Environment($loader, array('debug' => true, 'cache' => false));
+        $twig->addExtension(new MenuExtension($helper));
+
+        return $twig->loadTemplate('index');
+    }
+}

vendor/knplabs/knp-menu/tests/bootstrap.php

@@ -0,0 +1,14 @@
+<?php
+
+function includeIfExists($file) {
+    if (file_exists($file)) {
+        return include $file;
+    }
+}
+
+if ((!$loader = includeIfExists(__DIR__.'/../vendor/autoload.php')) && (!$loader = includeIfExists(__DIR__.'/../../../autoload.php'))) {
+    die('You must set up the project dependencies, run the following commands:'.PHP_EOL.
+        'curl -s http://getcomposer.org/installer | php'.PHP_EOL.
+        'php composer.phar install'.PHP_EOL);
+}
+$loader->add('Knp\Menu\Tests\\', __DIR__);