Mise à jour du composer.json et modification des routes pour l'admin generator.

app/bootstrap.php.cache

             unset($this->scopedServices[$name]);
 
             foreach ($this->scopeChildren[$name] as $child) {
-                $services[$child] = $this->scopedServices[$child];
-                unset($this->scopedServices[$child]);
+                if (isset($this->scopedServices[$child])) {
+                    $services[$child] = $this->scopedServices[$child];
+                    unset($this->scopedServices[$child]);
+                }
             }
 
                         $this->services = call_user_func_array('array_diff_key', $services);
     protected $classes;
     protected $errorReportingLevel;
 
-    const VERSION         = '2.1.7';
-    const VERSION_ID      = '20107';
+    const VERSION         = '2.1.9';
+    const VERSION_ID      = '20109';
     const MAJOR_VERSION   = '2';
     const MINOR_VERSION   = '1';
-    const RELEASE_VERSION = '7';
+    const RELEASE_VERSION = '9';
     const EXTRA_VERSION   = '';
 
     
         $request = $this->container->get('request');
 
                 if (0 === strpos($controller, 'http://') || 0 === strpos($controller, 'https://')) {
-            $subRequest = Request::create($controller, 'get', array(), $request->cookies->all(), array(), $request->server->all());
+            $subRequest = $request::create($controller, 'get', array(), $request->cookies->all(), array(), $request->server->all());
             if ($session = $request->getSession()) {
                 $subRequest->setSession($session);
             }
         } elseif (0 === strpos($controller, '/')) {
-            $subRequest = Request::create($request->getUriForPath($controller), 'get', array(), $request->cookies->all(), array(), $request->server->all());
+            $subRequest = $request::create($request->getUriForPath($controller), 'get', array(), $request->cookies->all(), array(), $request->server->all());
             if ($session = $request->getSession()) {
                 $subRequest->setSession($session);
             }

app/config/routing.yml

   resource: "@MuzichCommentBundle/Resources/config/routing.yml"
   prefix:   /{_locale}/
   
-AdmingeneratorGeneratorBundle_Dashboard:
-    resource: "@AdmingeneratorGeneratorBundle/Resources/config/routing.yml"
-    prefix:   /
-
 shtumi_useful:
     resource: '@ShtumiUsefulBundle/Resources/config/routing.xml'
     prefix:   /system/search/
 
 ########## ADMIN
+MuzichAdminBundle:
+    resource: "@MuzichAdminBundle/Resources/config/routing.yml"
+    prefix: /admin/
+    
+AdmingeneratorDashboard_welcome:
+    pattern: /admin/dashboard
+    defaults: { _controller: MuzichAdminBundle:Dashboard:welcome }
+
 MuzichAdminBundle_admin_muzich_admin_bundle_admin_element:
     resource: "@MuzichAdminBundle/Controller/Admin_element/"
     type:     admingenerator

composer.json

         "doctrine/doctrine-fixtures-bundle": "dev-master",
         "stof/doctrine-extensions-bundle": "dev-master",
         "gregwar/image-bundle": "dev-master",
-        "cedriclombardot/admingenerator-generator-bundle": "dev-master",
+        "cedriclombardot/admingenerator-generator-bundle": "1.0.*@dev",
+        "cedriclombardot/twig-generator": "dev-master",
+        "white-october/pagerfanta-bundle": "1.0.*@dev",
+        "pagerfanta/pagerfanta": "1.0.*@dev",
         "shtumi/useful-bundle": "dev-master",
-        "sonata-project/doctrine-orm-admin-bundle": "dev-master",
-        "sonata-project/admin-bundle": "dev-master",
-        "sonata-project/jquery-bundle": "dev-master",
-        "sonata-project/block-bundle": "dev-master"
+        "sonata-project/doctrine-orm-admin-bundle": "2.1.*@dev",
+        "sonata-project/admin-bundle": "2.1.*@dev",
+        "sonata-project/jquery-bundle": "1.8.*@dev",
+        "sonata-project/block-bundle": "2.1.*@dev"
     },
     "scripts": {
         "post-install-cmd": [

src/Muzich/AdminBundle/Controller/DashboardController.php

+<?php
+
+namespace Muzich\AdminBundle\Controller;
+
+use Muzich\CoreBundle\lib\Controller;
+use Symfony\Component\HttpFoundation\Request;
+
+class DashboardController extends Controller
+{
+  public function welcomeAction()
+  {
+    return $this->render('MuzichAdminBundle:Dashboard:welcome.html.twig', array(
+      'base_admin_template' => $this->container->getParameter('admingenerator.base_admin_template'),
+    ));
+  }
+  
+}

src/Muzich/AdminBundle/Resources/views/Dashboard/dashboard.html.twig

+{% extends base_admin_template %}
+
+{% block body %}    
+    <div class="row-fluid">
+      <div class="span3">
+        <div class="well well-small sidebar-nav">
+          {{ knp_menu_render('dashboard') }}
+        </div><!--/.well -->
+      </div><!--/span-->
+      <div class="span9">
+          {% block content %}
+          {% endblock %}
+      </div><!--/span-->
+    </div><!--/row-->
+{% endblock %}
+    
+{% block javascripts %}
+    {{ parent() }}
+{% endblock %}

src/Muzich/AdminBundle/Resources/views/Dashboard/welcome.html.twig

+{% extends 'MuzichAdminBundle:Dashboard:dashboard.html.twig' %}
+
+{% block title %}Admingenerator{% endblock %}
+
+{% block content %}
+    <div class="hero-unit">          
+      {% block page_title %}
+          <header>
+              <h1>Muzi.ch Admin</h1>
+          </header>
+      {% endblock %}
+      <p>Administration interface of muzi.ch.</p>
+    </div>
+    <div class="row-fluid">
+      Ici prendron place les données statistiques
+    </div><!--/row-->
+{% endblock %}

src/Muzich/AdminBundle/Resources/views/base_admin_assetic_less.html.twig

+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>{% block title %}Admin{% endblock %}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+    {% block scripts_head %}
+        <!-- jquery.min.js -->
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-1.8.3.min.js') }}"></script>
+        
+        <!-- HTML5 shim, for IE6-8 support of HTML5 elements -->
+        <!--[if lt IE 9]>
+            <script src="{{ asset('bundles/admingeneratorgenerator/js/html5shiv/html5.js') }}"></script>
+        <![endif]-->
+    {% endblock %}
+
+    {% block stylesheets %}
+        <!-- bootstrap.min.css -->
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/bootstrap/bootstrap.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/bootstrap/bootstrap-extended.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/bootstrap/bootstrap-datepicker.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/google/prettify.css') }}" type="text/css" media="all" />
+                    
+        <!-- bootstrap-responsive.min.css -->
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/bootstrap/bootstrap-responsive.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/bootstrap/bootstrap-responsive-extended.css') }}" type="text/css" media="all" />
+        
+        <!-- admingenerator.min.css -->
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/admingenerator/general.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/admingenerator/nested-list.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/admingenerator/collection.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/admingenerator/upload.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/admingenerator/filetypeicons.css') }}" type="text/css" media="all" />
+        <link rel="stylesheet" href="{{ asset('bundles/admingeneratorgenerator/css/admingenerator/form/single-upload.css') }}" type="text/css" media="all" />
+    {% endblock %}
+
+    {% block icons %}
+        <!-- Favicon and touch icons -->
+        <link rel="shortcut icon" href="{{ asset('bundles/admingeneratorgenerator/ico/favicon.ico') }}">
+        <link rel="apple-touch-icon-precomposed" sizes="144x144" href="{{ asset('bundles/admingeneratorgenerator/ico/apple-touch-icon-144-precomposed.png') }}">
+        <link rel="apple-touch-icon-precomposed" sizes="114x114" href="{{ asset('bundles/admingeneratorgenerator/ico/apple-touch-icon-114-precomposed.png') }}">
+        <link rel="apple-touch-icon-precomposed" sizes="72x72" href="{{ asset('bundles/admingeneratorgenerator/ico/apple-touch-icon-72-precomposed.png') }}">
+        <link rel="apple-touch-icon-precomposed" href="{{ asset('bundles/admingeneratorgenerator/ico/apple-touch-icon-57-precomposed.png') }}">
+    {% endblock %}
+    
+    
+    <link rel="stylesheet" href="{{ asset('css/jquery-ui-1.10.1.autocomplete.min.css') }}" type="text/css" media="all" />
+    <script type="text/javascript" src="{{ asset('js/jquery-ui-1.10.1.autocomplete.min.js') }}"></script>
+    
+  </head>
+
+  <body>
+
+    <div class="navbar navbar-inverse navbar-fixed-top">
+      <div class="navbar-inner">
+        <div class="container">
+          <a class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+          </a>
+          {% block logo %}
+            <a class="brand" href="{{ path('AdmingeneratorDashboard_welcome') }}">Admin</a>
+          {% endblock %}
+          <div class="nav-collapse collapse">
+            {% block profile %}
+              <ul class="nav pull-right">
+                <li><p class="navbar-text" style="padding-right: 10px;">{{ 'profile.welcome'|trans({'%username%': app.user ? app.user : 'anonymous'}, 'Admingenerator')|raw }}</li>
+                {% if app.user %}
+                  <li><button onclick="document.location='{{ path('fos_user_security_logout') }}'" class="btn " title="{{ 'profile.logout'|trans({}, 'Admingenerator') }}"><i class="icon-off"></i> {{ 'profile.logout'|trans({}, 'Admingenerator') }}</button></li>
+                {% else %}
+                  <li><button onclick="document.location='{{ path('fos_user_security_login') }}'" class="btn " title="{{ 'profile.login'|trans({}, 'Admingenerator') }}">{{ 'profile.login'|trans({}, 'Admingenerator') }}</button></li>
+                {% endif %}
+              </ul>
+            {% endblock %}
+            {% block menu %}
+              {{ knp_menu_render('admin') }}
+              {{ knp_menu_render('moderation') }}
+            {% endblock %}
+          </div><!--/.nav-collapse -->
+        </div>
+      </div>
+    </div>
+
+    <div class="container-fluid">
+        {% block flashes %}
+            <div id="flashes" class="row-fluid">
+                {% if app.session.hasFlash('success') %}
+                  <div class="alert alert-success">
+                    <button type="button" class="close" data-dismiss="alert">×</button>
+                    {{ app.session.flash('success')|raw }}
+                  </div>
+                {% endif %}
+                {% if app.session.hasFlash('error') %}
+                  <div class="alert alert-error">
+                    <button type="button" class="close" data-dismiss="alert">×</button>
+                    {{ app.session.flash('error')|raw }}
+                  </div>
+                {% endif %}
+            </div><!--/row-->
+        {% endblock %}
+
+        {% block body %}
+            <div class="row-fluid">
+            </div><!--/row-->
+        {% endblock %}
+
+      <hr>
+
+      <footer>
+        <p>
+          {% block footer %}
+              &copy; Symfony2Admingenerator {{ ("now"|date('Y') > 2012) ? '2012 - ' ~ "now"|date('Y') : '2012' }}
+          {% endblock %}
+        </p>
+      </footer>
+
+    </div> <!-- /container -->
+
+    {% block javascripts %}
+        <!-- bootstrap.min.js -->
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-transition.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-alert.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-modal.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-dropdown.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-scrollspy.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-tab.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-tooltip.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-popover.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-button.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-collapse.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-carousel.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-typeahead-extended.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-affix.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/bootstrap-datepicker.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/bootstrap/locales/bootstrap-datepicker.' ~ app.request.locale ~ '.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/google/prettify.js') }}"></script>
+        
+        <!-- jquery-ui.min.js  -->
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-ui/jquery.ui.core.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-ui/jquery.ui.widget.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-ui/jquery.ui.mouse.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-ui/jquery.ui.draggable.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-ui/jquery.ui.droppable.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-ui/jquery.ui.sortable.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-ui/jquery.ui.effect.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/jquery-ui/jquery.ui.effect-slide.js') }}"></script>
+       
+        <!-- blueimp.jquery-file-upload.min.js  -->
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/blueimp/blueimp.javascript-templates.min.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/blueimp/blueimp.javascript-load-image.min.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/blueimp/blueimp.canvas-to-blob.min.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/blueimp/jquery.iframe-transport.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/blueimp/jquery.fileupload.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/blueimp/jquery.fileupload-fp.js') }}"></script>
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/blueimp/jquery.fileupload-ui.js') }}"></script>
+        
+        <!-- jquery.spin.min.js  -->
+        <script type="text/javascript" src="{{ asset('bundles/admingeneratorgenerator/js/spin/jquery.spin.js') }}"></script>
+    {% endblock %}
+
+  </body>
+</html>

vendor/autoload.php

 
 require_once __DIR__ . '/composer' . '/autoload_real.php';
 
-return ComposerAutoloaderInit6c3b313faf78baf847838c5239806fa1::getLoader();
+return ComposerAutoloaderInitc9b19a18ee3786b65d05efbb2e260c14::getLoader();

vendor/bin/doctrine

-#!/usr/bin/env php
-<?php
-
-include('doctrine.php');

vendor/bin/doctrine

+../doctrine/orm/bin/doctrine

vendor/bin/doctrine.php

-<?php
-/*
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
- * <http://www.doctrine-project.org>.
- */
-
-(@include_once __DIR__ . '/../vendor/autoload.php') || @include_once __DIR__ . '/../../../autoload.php';
-$configFile = getcwd() . DIRECTORY_SEPARATOR . 'cli-config.php';
-
-$helperSet = null;
-if (file_exists($configFile)) {
-    if ( ! is_readable($configFile)) {
-        trigger_error(
-            'Configuration file [' . $configFile . '] does not have read permission.', E_ERROR
-        );
-    }
-
-    require $configFile;
-
-    foreach ($GLOBALS as $helperSetCandidate) {
-        if ($helperSetCandidate instanceof \Symfony\Component\Console\Helper\HelperSet) {
-            $helperSet = $helperSetCandidate;
-            break;
-        }
-    }
-}
-
-$helperSet = ($helperSet) ?: new \Symfony\Component\Console\Helper\HelperSet();
-
-\Doctrine\ORM\Tools\Console\ConsoleRunner::run($helperSet);

vendor/bin/doctrine.php

+../doctrine/orm/bin/doctrine.php

vendor/cedriclombardot/admingenerator-generator-bundle/Admingenerator/GeneratorBundle

-Subproject commit bc8c823b758c834c953cdfc50f023e82cebe2321
+Subproject commit dbcbd469aec90551e48730075f310d9bf6d92cb6

vendor/cedriclombardot/twig-generator

-Subproject commit 3dd145ec52aad082774562788c709390289c3458
+Subproject commit b4a846956d330ed464070f6276801d16c92ae5c5

vendor/composer/autoload_real.php

 
 // autoload_real.php generated by Composer
 
-class ComposerAutoloaderInit6c3b313faf78baf847838c5239806fa1
+class ComposerAutoloaderInitc9b19a18ee3786b65d05efbb2e260c14
 {
     private static $loader;
 
             return self::$loader;
         }
 
-        spl_autoload_register(array('ComposerAutoloaderInit6c3b313faf78baf847838c5239806fa1', 'loadClassLoader'));
+        spl_autoload_register(array('ComposerAutoloaderInitc9b19a18ee3786b65d05efbb2e260c14', 'loadClassLoader'));
         self::$loader = $loader = new \Composer\Autoload\ClassLoader();
-        spl_autoload_unregister(array('ComposerAutoloaderInit6c3b313faf78baf847838c5239806fa1', 'loadClassLoader'));
+        spl_autoload_unregister(array('ComposerAutoloaderInitc9b19a18ee3786b65d05efbb2e260c14', 'loadClassLoader'));
 
         $vendorDir = dirname(__DIR__);
         $baseDir = dirname($vendorDir);

vendor/doctrine/common/lib/Doctrine/Common/Version.php

     /**
      * Current Doctrine Version
      */
-    const VERSION = '2.3.1-DEV';
+    const VERSION = '2.3.0';
 
     /**
      * Compares a Doctrine version with the current one.

vendor/doctrine/data-fixtures

-Subproject commit 261c41729843b6b1c7cf4e579d10f8daec119d43
+Subproject commit eef10f6b92706bdae2841a8fdeb45ad8999b15b3

vendor/doctrine/dbal/.travis.yml

   - DB=mysqli
 
 before_script:
+  - composer update --dev --prefer-source
   - sh -c "if [ '$DB' = 'pgsql' ]; then psql -c 'DROP DATABASE IF EXISTS doctrine_tests;' -U postgres; fi"
   - sh -c "if [ '$DB' = 'pgsql' ]; then psql -c 'DROP DATABASE IF EXISTS doctrine_tests_tmp;' -U postgres; fi"
   - sh -c "if [ '$DB' = 'pgsql' ]; then psql -c 'create database doctrine_tests;' -U postgres; fi"
   - sh -c "if [ '$DB' = 'pgsql' ]; then psql -c 'create database doctrine_tests_tmp;' -U postgres; fi"
   - sh -c "if [ '$DB' = 'mysql' ]; then mysql -e 'create database IF NOT EXISTS doctrine_tests_tmp;create database IF NOT EXISTS doctrine_tests;'; fi"
   - sh -c "if [ '$DB' = 'mysqli' ]; then mysql -e 'create database IF NOT EXISTS doctrine_tests_tmp;create database IF NOT EXISTS doctrine_tests;'; fi"
-  - git submodule update --init
 
 script: phpunit --configuration tests/travis/$DB.travis.xml
 

vendor/doctrine/dbal/composer.json

 {
     "name": "doctrine/dbal",
-    "type": "library",
+    "type": "library","version":"2.3.3",
     "description": "Database Abstraction Layer",
     "keywords": ["dbal", "database", "persistence", "queryobject"],
     "homepage": "http://www.doctrine-project.org",
     ],
     "require": {
         "php": ">=5.3.2",
-        "doctrine/common": "2.3.*"
+        "doctrine/common": ">=2.3.0,<2.5-dev"
     },
     "autoload": {
         "psr-0": { "Doctrine\\DBAL": "lib/" }

vendor/doctrine/dbal/lib/Doctrine/DBAL/Platforms/Keywords/MySQLKeywords.php

             'PROCEDURE',
             'PURGE',
             'RAID0',
+            'RANGE',
             'READ',
             'READS',
             'REAL',

vendor/doctrine/dbal/lib/Doctrine/DBAL/Platforms/Keywords/OracleKeywords.php

             'MODE',
             'ROWS',
             'WITH',
+            'RANGE',
         );
     }
 }

vendor/doctrine/dbal/lib/Doctrine/DBAL/Schema/AbstractSchemaManager.php

      *
      * @param \Doctrine\DBAL\Connection $conn
      */
-    public function __construct(\Doctrine\DBAL\Connection $conn)
+    public function __construct(\Doctrine\DBAL\Connection $conn, AbstractPlatform $platform = null)
     {
-        $this->_conn = $conn;
-        $this->_platform = $this->_conn->getDatabasePlatform();
+        $this->_conn     = $conn;
+        $this->_platform = $platform ?: $this->_conn->getDatabasePlatform();
     }
 
     /**

vendor/doctrine/dbal/lib/Doctrine/DBAL/Schema/SQLServerSchemaManager.php

     protected function _getPortableTableColumnDefinition($tableColumn)
     {
         $dbType = strtolower($tableColumn['TYPE_NAME']);
+        $dbType = strtok($dbType, '(), ');
 
         $autoincrement = false;
         if (stripos($dbType, 'identity')) {

vendor/doctrine/dbal/lib/Doctrine/DBAL/Version.php

     /**
      * Current Doctrine Version
      */
-    const VERSION = '2.3.3-DEV';
+    const VERSION = '2.3.3';
 
     /**
      * Compares a Doctrine version with the current one.

vendor/doctrine/dbal/tests/Doctrine/Tests/TestInit.php

 
 error_reporting(E_ALL | E_STRICT);
 
-require_once __DIR__ . '/../../../lib/vendor/doctrine-common/lib/Doctrine/Common/ClassLoader.php';
-
-$classLoader = new \Doctrine\Common\ClassLoader('Doctrine\Common', __DIR__ . '/../../../lib/vendor/doctrine-common/lib');
-$classLoader->register();
-
-$classLoader = new \Doctrine\Common\ClassLoader('Doctrine\DBAL', __DIR__ . '/../../../lib');
-$classLoader->register();
-
-$classLoader = new \Doctrine\Common\ClassLoader('Doctrine\Tests', __DIR__ . '/../../');
-$classLoader->register();
-
-$classLoader = new \Doctrine\Common\ClassLoader('Symfony', __DIR__ . "/../../../lib/vendor");
-$classLoader->register();
+if (file_exists(__DIR__ . '/../../../vendor/autoload.php')) {
+    $loader = require_once __DIR__ . '/../../../vendor/autoload.php';
+} elseif (file_exists(__DIR__ . '/../../../../../autoload.php')) {
+    $loader = require __DIR__ . '/../../../vendor/autoload.php';
+} else {
+    throw new \RuntimeException('Could not locate composer autoloader');
+}
 
+$loader->add('Doctrine\Tests', __DIR__ . '/../../');

vendor/doctrine/doctrine-bundle/Doctrine/Bundle/DoctrineBundle/.travis.yml

 php:
   - 5.3
   - 5.4
-  - 5.5
 
-matrix:
-  allow_failures:
-    - php: 5.5
+before_script: composer install --dev
 
-before_script: composer install --dev --prefer-source

vendor/doctrine/doctrine-fixtures-bundle/Doctrine/Bundle/FixturesBundle

-Subproject commit fcce1a0f1820983b89f50cd97d78aabf668442b7
+Subproject commit 275540d96599baec19fa3292c4d06c5cd4eefd06

vendor/doctrine/orm/composer.json

 {
     "name": "doctrine/orm",
-    "type": "library",
+    "type": "library","version":"2.3.3",
     "description": "Object-Relational-Mapper for PHP",
     "keywords": ["orm", "database"],
     "homepage": "http://www.doctrine-project.org",

vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/SimpleObjectHydrator.php

                 // One solution is to load the association, but it might require extra efforts.
                 return array('name' => $column);
 
-            default:
+            case (isset($this->_rsm->metaMappings[$column])):
                 return array(
                     'name' => $this->_rsm->metaMappings[$column]
                 );
+
+            default:
+                return null;
         }
     }
 }

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/ClassMetadataInfo.php

         $mapping['orphanRemoval']   = isset($mapping['orphanRemoval']) ? (bool) $mapping['orphanRemoval'] : false;
         $mapping['isCascadeRemove'] = $mapping['orphanRemoval'] ? true : $mapping['isCascadeRemove'];
 
+        if ($mapping['orphanRemoval']) {
+            unset($mapping['unique']);
+        }
+
         if (isset($mapping['id']) && $mapping['id'] === true && !$mapping['isOwningSide']) {
             throw MappingException::illegalInverseIdentifierAssocation($this->name, $mapping['fieldName']);
         }

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/XmlDriver.php

 
                 if (isset($mapping['version'])) {
                     $metadata->setVersionMapping($mapping);
+                    unset($mapping['version']);
                 }
 
                 $metadata->mapField($mapping);
         }
 
         if (isset($fieldMapping['version']) && $fieldMapping['version']) {
-            $mapping['version'] = $fieldMapping['version'];
+            $mapping['version'] = $this->evaluateBoolean($fieldMapping['version']);
         }
 
         if (isset($fieldMapping['column-definition'])) {

vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/YamlDriver.php

 
                 if (isset($mapping['version'])) {
                     $metadata->setVersionMapping($mapping);
+                    unset($mapping['version']);
                 }
 
                 $metadata->mapField($mapping);

vendor/doctrine/orm/lib/Doctrine/ORM/PersistentCollection.php

      */
     public function matching(Criteria $criteria)
     {
+        if ($this->isDirty) {
+            $this->initialize();
+        }
+
         if ($this->initialized) {
             return $this->coll->matching($criteria);
         }
             throw new \RuntimeException("Matching Criteria on PersistentCollection only works on OneToMany assocations at the moment.");
         }
 
-        // If there are NEW objects we have to check if any of them matches the criteria
-        $newObjects = array();
-
-        if ($this->isDirty) {
-            $newObjects = $this->coll->matching($criteria)->toArray();
-        }
-
-        $targetClass = $this->em->getClassMetadata(get_class($this->owner));
-
-        $id              = $targetClass->getSingleIdReflectionProperty()->getValue($this->owner);
+        $id              = $this->em
+            ->getClassMetadata(get_class($this->owner))
+            ->getSingleIdReflectionProperty()
+            ->getValue($this->owner);
         $builder         = Criteria::expr();
         $ownerExpression = $builder->eq($this->backRefFieldName, $id);
         $expression      = $criteria->getWhereExpression();
 
         $persister = $this->em->getUnitOfWork()->getEntityPersister($this->association['targetEntity']);
 
-        return new ArrayCollection(array_merge($persister->loadCriteria($criteria), $newObjects));
+        return new ArrayCollection($persister->loadCriteria($criteria));
     }
 }
 

vendor/doctrine/orm/lib/Doctrine/ORM/Query/Exec/MultiTableUpdateExecutor.php

 
                     $updateSql .= $sqlWalker->walkUpdateItem($updateItem);
 
-                    //FIXME: parameters can be more deeply nested. traverse the tree.
-                    //FIXME (URGENT): With query cache the parameter is out of date. Move to execute() stage.
                     if ($newValue instanceof AST\InputParameter) {
-                        $parameterName = $newValue->name;
-                        $parameter     = $sqlWalker->getQuery()->getParameter($parameterName);
-
-                        $value = $sqlWalker->getQuery()->processParameterValue($parameter->getValue());
-                        $type  = ($parameter->getValue() === $value)
-                            ? $parameter->getType()
-                            : ParameterTypeInferer::inferType($value);
-
-                        $this->_sqlParameters[$i]['parameters'][] = $value;
-                        $this->_sqlParameters[$i]['types'][] = $type;
+                        $this->_sqlParameters[$i][] = $newValue->name;
 
                         ++$this->_numParametersInUpdateClause;
                     }
             );
 
             // Execute UPDATE statements
-            for ($i=0, $count=count($this->_sqlStatements); $i<$count; ++$i) {
-                $parameters = array();
-                $types      = array();
-
-                if (isset($this->_sqlParameters[$i])) {
-                    $parameters = isset($this->_sqlParameters[$i]['parameters']) ? $this->_sqlParameters[$i]['parameters'] : array();
-                    $types = isset($this->_sqlParameters[$i]['types']) ? $this->_sqlParameters[$i]['types'] : array();
+            foreach ($this->_sqlStatements as $key => $statement) {
+                $paramValues = array();
+                $paramTypes  = array();
+
+                if (isset($this->_sqlParameters[$key])) {
+                    foreach ($this->_sqlParameters[$key] as $parameterKey => $parameterName) {
+                        $paramValues[] = $params[$parameterKey];
+                        $paramTypes[]  = isset($types[$parameterKey]) ? $types[$parameterKey] : ParameterTypeInferer::inferType($params[$parameterKey]);
+                    }
                 }
 
-                $conn->executeUpdate($this->_sqlStatements[$i], $parameters, $types);
+                $conn->executeUpdate($statement, $paramValues, $paramTypes);
             }
         } catch (\Exception $exception) {
             // FAILURE! Drop temporary table to avoid possible collisions

vendor/doctrine/orm/lib/Doctrine/ORM/Query/Expr/Base.php

      */
     public function add($arg)
     {
-        if ( $arg !== null || ($arg instanceof self && $arg->count() > 0) ) {
+        if ( $arg !== null && (!$arg instanceof self || $arg->count() > 0) ) {
             // If we decide to keep Expr\Base instances, we can use this check
             if ( ! is_string($arg)) {
                 $class = get_class($arg);

vendor/doctrine/orm/lib/Doctrine/ORM/Query/SqlWalker.php

         $sqlParts = array();
 
         foreach ($identificationVarDecls as $identificationVariableDecl) {
-            $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
+            $sql = $this->platform->appendLockHint(
+                $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration),
+                $this->query->getHint(Query::HINT_LOCK_MODE)
+            );
 
             foreach ($identificationVariableDecl->joins as $join) {
                 $sql .= $this->walkJoin($join);
                 }
             }
 
-            $sqlParts[] = $this->platform->appendLockHint($sql, $this->query->getHint(Query::HINT_LOCK_MODE));
+            $sqlParts[] = $sql;
         }
 
         return ' FROM ' . implode(', ', $sqlParts);
         $sqlParts = array ();
 
         foreach ($identificationVarDecls as $subselectIdVarDecl) {
-            $sql = $this->walkRangeVariableDeclaration($subselectIdVarDecl->rangeVariableDeclaration);
+            $sql = $this->platform->appendLockHint(
+                $this->walkRangeVariableDeclaration($subselectIdVarDecl->rangeVariableDeclaration),
+                $this->query->getHint(Query::HINT_LOCK_MODE)
+            );
 
             foreach ($subselectIdVarDecl->joins as $join) {
                 $sql .= $this->walkJoin($join);
             }
 
-            $sqlParts[] = $this->platform->appendLockHint($sql, $this->query->getHint(Query::HINT_LOCK_MODE));
+            $sqlParts[] = $sql;
         }
 
         return ' FROM ' . implode(', ', $sqlParts);

vendor/doctrine/orm/lib/Doctrine/ORM/Tools/Pagination/CountOutputWalker.php

      */
     public function walkSelectStatement(SelectStatement $AST)
     {
+        if ($this->platform->getName() === "mssql") {
+            $AST->orderByClause = null;
+        }
+
         $sql = parent::walkSelectStatement($AST);
 
         // Find out the SQL alias of the identifier column of the root entity

vendor/doctrine/orm/lib/Doctrine/ORM/Version.php

     /**
      * Current Doctrine Version
      */
-    const VERSION = '2.3.3-DEV';
+    const VERSION = '2.3.3';
 
     /**
      * Compares a Doctrine version with the current one.

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Functional/OneToManyBidirectionalAssociationTest.php

         $this->assertInstanceOf('Doctrine\Common\Collections\Collection', $results);
         $this->assertEquals(2, count($results));
     }
-	
+
+    /**
+     * @group DDC-2340
+     */
+    public function testMatchingOnDirtyCollection()
+    {
+        $this->_createFixture();
+
+        $product  = $this->_em->find('Doctrine\Tests\Models\ECommerce\ECommerceProduct', $this->product->getId());
+
+        $thirdFeature = new ECommerceFeature();
+        $thirdFeature->setDescription('Model writing tutorial');
+
+        $features = $product->getFeatures();
+        $features->add($thirdFeature);
+
+        $results = $features->matching(new Criteria(
+            Criteria::expr()->eq('description', 'Model writing tutorial')
+        ));
+
+        $this->assertEquals(2, count($results));
+    }
+
     public function testMatchingBis()
     {
         $this->_createFixture();
 
         $product  = $this->_em->find('Doctrine\Tests\Models\ECommerce\ECommerceProduct', $this->product->getId());
         $features = $product->getFeatures();
-        
+
         $thirdFeature = new ECommerceFeature();
         $thirdFeature->setDescription('Third feature');
         $product->addFeature($thirdFeature);

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1666Test.php

+<?php
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\Tests\Models\CMS\CmsUser;
+use Doctrine\Tests\Models\CMS\CmsEmail;
+
+/**
+ * @group DDC-1666
+ */
+class DDC1666Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    public function setUp()
+    {
+        $this->useModelSet('cms');
+        parent::setUp();
+    }
+
+    public function testGivenOrphanRemovalOneToOne_WhenReplacing_ThenNoUniqueConstraintError()
+    {
+        $user = new CmsUser();
+        $user->name = "Benjamin";
+        $user->username = "beberlei";
+        $user->status = "something";
+        $user->setEmail($email = new CmsEmail());
+        $email->setEmail("kontakt@beberlei.de");
+
+        $this->_em->persist($user);
+        $this->_em->flush();
+
+        $this->assertTrue($this->_em->contains($email));
+
+        $user->setEmail($newEmail = new CmsEmail());
+        $newEmail->setEmail("benjamin.eberlei@googlemail.com");
+
+        $this->_em->flush();
+
+        $this->assertFalse($this->_em->contains($email));
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC2090Test.php

+<?php
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\Tests\Models\Company\CompanyEmployee;
+
+/**
+ * @group DDC-2090
+ */
+class DDC2090Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    public function setUp()
+    {
+        $this->useModelSet('company');
+        parent::setUp();
+    }
+
+    public function testIssue()
+    {
+        $className = 'Doctrine\Tests\Models\Company\CompanyEmployee';
+        $date1     = new \DateTime('2011-11-11 11:11:11');
+        $date2     = new \DateTime('2012-12-12 12:12:12');
+        $employee1 = new CompanyEmployee;
+        $employee2 = new CompanyEmployee;
+
+        $employee1->setName("Fabio B. Silva");
+        $employee1->setStartDate(new \DateTime('yesterday'));
+        $employee1->setDepartment("R&D");
+        $employee1->setSalary(100);
+
+        $employee2->setName("Doctrine Bot");
+        $employee1->setStartDate(new \DateTime('yesterday'));
+        $employee2->setDepartment("QA");
+        $employee2->setSalary(100);
+
+        $this->_em->persist($employee1);
+        $this->_em->persist($employee2);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $this->_em->createQueryBuilder()
+            ->update($className, 'e')
+            ->set('e.startDate', ':date')
+            ->set('e.salary', ':salary')
+            ->where('e = :e')
+            ->setParameters(array(
+                'e'      => $employee1,
+                'date'   => $date1,
+                'salary' => 101,
+            ))
+            ->getQuery()
+            ->useQueryCache(true)
+            ->execute();
+
+        $this->_em->createQueryBuilder()
+            ->update($className, 'e')
+            ->set('e.startDate', ':date')
+            ->set('e.salary', ':salary')
+            ->where('e = :e')
+            ->setParameters(array(
+                'e'      => $employee2,
+                'date'   => $date2,
+                'salary' => 102,
+            ))
+            ->getQuery()
+            ->useQueryCache(true)
+            ->execute();
+
+        $this->_em->clear();
+
+        $e1 = $this->_em->find($className, $employee1->getId());
+        $e2 = $this->_em->find($className, $employee2->getId());
+
+        $this->assertEquals(101, $e1->getSalary());
+        $this->assertEquals(102, $e2->getSalary());
+        $this->assertEquals($date1, $e1->getStartDate());
+        $this->assertEquals($date2, $e2->getStartDate());
+
+        $this->_em->createQueryBuilder()
+            ->update($className, 'e')
+            ->set('e.startDate', '?1')
+            ->set('e.salary', '?2')
+            ->where('e = ?0')
+            ->setParameters(array($employee1, $date1, 101))
+            ->getQuery()
+            ->useQueryCache(true)
+            ->execute();
+
+        $this->_em->createQueryBuilder()
+            ->update($className, 'e')
+            ->set('e.startDate', '?1')
+            ->set('e.salary', '?2')
+            ->where('e = ?0')
+            ->setParameters(array($employee2, $date2, 102))
+            ->getQuery()
+            ->useQueryCache(true)
+            ->execute();
+
+
+        $this->_em->clear();
+
+        $e1 = $this->_em->find($className, $employee1->getId());
+        $e2 = $this->_em->find($className, $employee2->getId());
+
+        $this->assertEquals(101, $e1->getSalary());
+        $this->assertEquals(102, $e2->getSalary());
+        $this->assertEquals($date1, $e1->getStartDate());
+        $this->assertEquals($date2, $e2->getStartDate());
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Hydration/SimpleObjectHydratorTest.php

         $hydrator   = new \Doctrine\ORM\Internal\Hydration\SimpleObjectHydrator($this->_em);
         $hydrator->hydrateAll($stmt, $rsm);
     }
+
+    public function testExtraFieldInResultSetShouldBeIgnore()
+    {
+        $rsm = new ResultSetMapping;
+        $rsm->addEntityResult('Doctrine\Tests\Models\CMS\CmsAddress', 'a');
+        $rsm->addFieldResult('a', 'a__id', 'id');
+        $rsm->addFieldResult('a', 'a__city', 'city');
+        $resultSet = array(
+            array(
+                'a__id'   => '1',
+                'a__city' => 'Cracow',
+                'doctrine_rownum' => '1'
+            ),
+        );
+
+        $expectedEntity = new \Doctrine\Tests\Models\CMS\CmsAddress();
+        $expectedEntity->id = 1;
+        $expectedEntity->city = 'Cracow';
+
+        $stmt       = new HydratorMockStatement($resultSet);
+        $hydrator   = new \Doctrine\ORM\Internal\Hydration\SimpleObjectHydrator($this->_em);
+        $result = $hydrator->hydrateAll($stmt, $rsm);
+        $this->assertEquals($result[0], $expectedEntity);
+    }
 }

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Mapping/AbstractMappingDriverTest.php

     {
         $this->assertTrue($class->isVersioned);
         $this->assertEquals("version", $class->versionField);
+
+        $this->assertFalse(isset($class->fieldMappings['version']['version']));
     }
 
     /**

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Mapping/yaml/Doctrine.Tests.Models.DDC1476.DDC1476EntityWithDefaultFieldType.dcm.yml

       generator:
         strategy: NONE
   fields:
-    name:
+    name: ~

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Mapping/yaml/Doctrine.Tests.ORM.Mapping.DDC2069Entity.dcm.yml

 Doctrine\Tests\ORM\Mapping\DDC2069Entity:
   type: entity
   id:
-    id:
+    id: ~
   fields:
     name:
       type: string ( 255 )
       columns: name, value
   indexes:
     0:
-      columns: value, name
+      columns: value, name

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Query/ExprTest.php

         $select = new Expr\Select(array('foo', 'bar'));
         $this->assertEquals(array('foo', 'bar'), $select->getParts());
     }
+
+    public function testAddEmpty() {
+        $andExpr = $this->_expr->andx();
+        $andExpr->add($this->_expr->andx());
+        
+        $this->assertEquals(0, $andExpr->count());
+    }
+
+    public function testAddNull() {
+        $andExpr = $this->_expr->andx();
+        $andExpr->add(null);
+        
+        $this->assertEquals(0, $andExpr->count());
+    }
 }

vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Tools/Pagination/CountOutputWalkerTest.php

             "SELECT COUNT(*) AS dctrn_count FROM (SELECT DISTINCT id1 FROM (SELECT count(u0_.id) AS sclr0, g1_.id AS id1, u0_.id AS id2 FROM groups g1_ LEFT JOIN user_group u2_ ON g1_.id = u2_.group_id LEFT JOIN User u0_ ON u0_.id = u2_.user_id GROUP BY g1_.id HAVING sclr0 > 0) dctrn_result) dctrn_table", $query->getSql()
         );
     }
+
+    public function testCountQueryOrderBySqlServer()
+    {
+        if ($this->entityManager->getConnection()->getDatabasePlatform()->getName() !== "mssql") {
+            $this->markTestSkipped('SQLServer only test.');
+        }
+
+        $query = $this->entityManager->createQuery(
+            'SELECT p FROM Doctrine\Tests\ORM\Tools\Pagination\BlogPost p ORDER BY p.id');
+        $query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, 'Doctrine\ORM\Tools\Pagination\CountOutputWalker');
+        $query->setFirstResult(null)->setMaxResults(null);
+
+        $this->assertEquals(
+            "SELECT COUNT(*) AS dctrn_count FROM (SELECT DISTINCT id0 FROM (SELECT b0_.id AS id0, b0_.author_id AS author_id1, b0_.category_id AS category_id2 FROM BlogPost b0_) dctrn_result) dctrn_table",
+            $query->getSql()
+        );
+    }
 }
 

vendor/gedmo/doctrine-extensions/README.md

 left on mine. I do not want users to lose availability of stable extensions which they were and are
 used to, at the moment.
 
-**Version 2.3.4**
+**Version 2.3.5**
 
 [![Build Status](https://secure.travis-ci.org/l3pp4rd/DoctrineExtensions.png?branch=master)](http://travis-ci.org/l3pp4rd/DoctrineExtensions)
 
 
 ### Latest updates
 
+**2013-03-05**
+
+- A new extension - **References**, which links Entities in Documents and visa versa, [read more about it](https://github.com/l3pp4rd/DoctrineExtensions/blob/master/doc/references.md). It was contributed by @jwage, @avalanche123, @jmikola and @bobthecow, thanks
+
 **2013-02-05**
 
 - **Sluggable** added back slug handler mapping driver support for yaml and xml.
 - **Sluggable** now allows to regenerate slug if its set to empty or null. Also it allows to
 manually set the slug, in that case it would only transliterate it and ensure uniqueness.
 
-**2012-04-09**
-
-- **Translatable** now does not force lowercase letters on locale or language. If your database is case
-sensitive, take this into account and upgrade your current translations in the database. This change
-will not be backported into 2.2 or older versions of extensions and will be available in comming
-releases.
-- **Sortable** now handles and synchronizes all object sort positions which are allready in memory
-of unitOfWork. Which does not require to do **$em->clear()** after each operation anymore.
-
-**2012-03-04**
-
-- We should be very grateful for contributions of [comfortablynumb](http://github.com/comfortablynumb)
-He has contributed most to these extensions and recently - long waited [softdeleteable
-behavior](https://github.com/l3pp4rd/DoctrineExtensions/blob/master/doc/softdeleteable.md) for **ORM** users. Also most important, there
-was a tree extension missing for **ODM** now everyone can enjoy [materialized path tree strategy](https://github.com/l3pp4rd/DoctrineExtensions/blob/master/doc/tree.md#materialized-path) for **ORM** including.
-
-**2012-02-26**
-
-- Removed slug handlers, this functionality brought complications which could not be maintained.
-
-**2012-02-15**
-
-- Add option to force **Translatable** store translation in default locale like any other.
-See [documentation](http://github.com/l3pp4rd/DoctrineExtensions/blob/master/doc/translatable.md#advanced-examples)
-
-**2012-01-29**
-
-- Translatable finally has **Personal Translations** which can relate through a real **foreign key**
-constraint and be used as a standard doctrine collection. This allows to configure domain
-objects anyway you prefere and still enjoy all features **Translatable** provides.
-- There were **BC** breaks introduced in **master** branch of extensions which is
-based on **doctrine2.3.x** version. If you are not interested in upgrading you can
-safely checkout at **2.2.x** or **2.1.x** [tag](http://github.com/l3pp4rd/DoctrineExtensions/tags).
-To upgrade your source code follow the [upgrade guide](https://github.com/l3pp4rd/DoctrineExtensions/blob/master/upgrade/2-3-0.md)
-- Library now can map only **MappedSuperclass**es which would avoid generation of **ext_**
-tables which might not be used. Also it provides [convinient methods](https://github.com/l3pp4rd/DoctrineExtensions/blob/master/lib/Gedmo/DoctrineExtensions.php#L66)
-to hook extension metadata drivers into metadata driver chain.
-- [Example demo application](https://github.com/l3pp4rd/DoctrineExtensions/blob/master/example/em.php) has a detailed configuration provided, which
-explains and shows how extensions can or should be used with **Doctrine2** ORM. To install
-it follow the [steps](#example-demo).
-
 ### Summary and features
 
 This package contains extensions for Doctrine2 that hook into the facilities of Doctrine and
 - **Translator** - explicit way to handle translations
 - **Softdeleteable** - allows to implicitly remove records
 - **Uploadable** - provides file upload handling in entity fields
+- **References** - supports linking Entities in Documents and visa versa
 
 Currently these extensions support **Yaml**, **Annotation**  and **Xml** mapping. Additional mapping drivers
 can be easily implemented using Mapping extension to handle the additional metadata mapping.
 - Loggable
 - Translator
 - Tree (Materialized Path strategy for now)
+- References
 
 All these extensions can be nested together and mapped in traditional ways - annotations,
 xml or yaml

vendor/gedmo/doctrine-extensions/doc/references.md

+# Cross Object Mapper References behavior extension for Doctrine 2
+
+Create documents and entities that contain references to each other.
+
+## Options
+
+The following options are possible on reference one and many associations:
+
+**Owning Side**
+
+- **type** - The type of association.
+- **class** - The associated class name.
+- **inversedBy** - The property name for the inverse side of this association.
+- **identifier** - The property name to store the associated object id in.
+
+**Inverse Side**
+
+- **type** - The type of association.
+- **class** - The associated class name.
+- **mappedBy** - The property name for the owning side of this association.
+
+## Annotations
+
+**@Gedmo\ReferenceOne**
+
+``` php
+<?php
+
+/**
+ * @Gedmo\ReferenceMany(type="entity", class="Entity\StockItem", mappedBy="product")
+ */
+private $stockItems;
+```
+
+**@Gedmo\ReferenceMany**
+
+``` php
+<?php
+
+/**
+ * @Gedmo\ReferenceOne(type="document", class="Document\Product", inversedBy="stockItems", identifier="productId")
+ */
+private $product;
+```
+
+## Example
+
+Here is an example where you have a Product which is mapped using the Doctrine MongoDB ODM project and it contains a property `$stockItems` that is populated from the Doctrine2 ORM.
+
+``` php
+<?php
+
+namespace Document;
+
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM;
+use Gedmo\Mapping\Annotation as Gedmo;
+
+/**
+ * @ODM\Document
+ */
+class Product
+{
+    /**
+     * @ODM\Id
+     */
+    private $id;
+
+    /**
+     * @ODM\String
+     */
+    private $name;
+
+    /**
+     * @Gedmo\ReferenceMany(type="entity", class="Entity\StockItem", mappedBy="product")
+     */
+    private $stockItems;
+
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    public function setId($id)
+    {
+        $this->id = $id;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    public function getStockItems()
+    {
+        return $this->stockItems;
+    }
+
+    public function setStockItems(Collection $stockItems)
+    {
+        $this->stockItems = $stockItems;
+    }
+}
+```
+
+The `StockItem` has a reference to the `Product` as well.
+
+``` php
+<?php
+
+namespace Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+use Gedmo\Mapping\Annotation as Gedmo;
+use References\Fixture\ODM\MongoDB\Product;
+
+/**
+ * @ORM\Entity
+ */
+class StockItem
+{
+    /**
+     * @ORM\Id
+     * @ORM\Column(type="integer")
+     * @ORM\GeneratedValue(strategy="IDENTITY")
+     */
+    private $id;
+
+    /**
+     * @ORM\Column
+     */
+    private $name;
+
+    /**
+     * @ORM\Column
+     */
+    private $sku;
+
+    /**
+     * @ORM\Column(type="integer")
+     */
+    private $quantity;
+
+    /**
+     * @Gedmo\ReferenceOne(type="document", class="Document\Product", inversedBy="stockItems", identifier="productId")
+     */
+    private $product;
+
+    /**
+     * @ORM\Column(type="string")
+     */
+    private $productId;
+
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    public function setId($id)
+    {
+        $this->id = $id;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    public function getSku()
+    {
+        return $this->sku;
+    }
+
+    public function setSku($sku)
+    {
+        $this->sku = $sku;
+    }
+
+    public function getQuantity()
+    {
+        return $this->quantity;
+    }
+
+    public function setQuantity($quantity)
+    {
+        $this->quantity = $quantity;
+    }
+
+    public function setProduct(Product $product)
+    {
+        $this->product = $product;
+    }
+
+    public function getProduct()
+    {
+        return $this->product;
+    }
+
+    public function setProductId($productId)
+    {
+        $this->productId = $productId;
+    }
+
+    public function getProductId()
+    {
+        return $this->productId;
+    }
+}
+```

vendor/gedmo/doctrine-extensions/doc/tree.md

 
 ### Using routes in decorator, show only selected items, return unlimited levels items as 2 levels
 
-```
+``` php
+<?php
 $controller = $this;
         $tree = $root->childrenHierarchy(null,false,array('decorate' => true,
             'rootOpen' => function($tree) {
 modifications on the tree could occur. Look at the MongoDB example of schema definition to see how it must be configured.
 - If your **TreePathSource** field is of type "string", then the primary key will be concatenated in the form: "value-id".
  This is to allow you to use non-unique values as the path source. For example, this could be very useful if you need to
- use the date as the path source (maybe to create a tree of comments and order them by date).
+ use the date as the path source (maybe to create a tree of comments and order them by date). If you want to change this 
+ default behaviour you can set the attribute "appendId" of **TreePath** to true or false. By default the path does not start
+ with the given separator but ends with it. You can customize this behaviour with "startsWithSeparator" and "endsWithSeparator".
+ `@Gedmo\TreePath(appendId=false, startsWithSeparator=true, endsWithSeparator=false)`
 - **TreePath** field can only be of types: string, text
 - **TreePathSource** field can only be of types: id, integer, smallint, bigint, string, int, float (I include here all the
 variations of the field types, including the ORM and ODM for MongoDB ones).
 - **TreeLockTime** must be of type "date" (used only in MongoDB for now).
+- **TreePathHash** allows you to define a field that is automatically filled with the md5 hash of the path. This field could be neccessary if you want to set a unique constraint on the database table.
 
 ### ORM Entity example (Annotations)
 
 
 ```
 
+### MongoDB example (Yaml)
+
+YourNamespace\Document\Category:
+    type:               mappedSuperclass
+    repositoryClass:    Gedmo\Tree\Document\MongoDB\Repository\MaterializedPathRepository
+    collection:         categories
+    gedmo:
+        tree:
+            type: materializedPath
+            activateLocking: true
+    fields:
+        id:
+            id:     true
+        title:
+            type:   string
+            gedmo:
+                -   sluggable
+        slug:
+            type:   string
+            gedmo:
+                0:  treePathSource
+                slug:
+                    unique:     false
+                    fields:
+                        - title
+        path:
+            type:   string
+            gedmo:
+                treePath:
+                    separator:           '/'
+                    appendId:            false
+                    startsWithSeparator: false  # default
+                    endsWithSeparator:   true   # default
+        level:
+            type:   int
+            name:   lvl
+            nullable:   true
+            gedmo:
+                -   treeLevel
+        lockTime:
+            type:   date
+            gedmo:
+                -   treeLockTime
+        hash:
+            type:   string
+            gedmo:
+                -   treePathHash
+        parent:
+            reference:  true
+            type:       one
+            inversedBy: children
+            targetDocument: YourNamespace\Document\Category
+            simple:     true
+            gedmo:
+                -   treeParent
+
+
 ### Path generation
 
 When an entity is inserted, a path is generated using the value of the field configured as the TreePathSource.

vendor/gedmo/doctrine-extensions/lib/Gedmo/Blameable/BlameableListener.php

             if (method_exists($this->user, 'getUsername')) {
                 return (string)$this->user->getUsername();
             }
-            if (method_exists($this->user, '__toString()')) {
+            if (method_exists($this->user, '__toString')) {
                 return $this->user->__toString();
             }
             throw new InvalidArgumentException("Field expects string, user must be a string, or object should have method getUsername or __toString");

vendor/gedmo/doctrine-extensions/lib/Gedmo/Mapping/Annotation/Reference.php

+<?php
+
+namespace Gedmo\Mapping\Annotation;
+
+use Doctrine\Common\Annotations\Annotation;
+
+/**
+ * Reference annotation for ORM -> ODM references extension
+ * to be user like @ReferenceMany(type="entity", class="MyEntity", identifier="entity_id")
+ *
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @package Gedmo.Mapping.Annotation
+ * @subpackage Language
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ * @Annotation
+ */
+abstract class Reference extends Annotation
+{
+    public $type;
+    public $class;
+    public $identifier;
+    public $mappedBy;
+    public $inversedBy;
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/Mapping/Annotation/ReferenceMany.php

+<?php
+
+namespace Gedmo\Mapping\Annotation;
+
+use Doctrine\Common\Annotations\Annotation;
+
+/**
+ * Reference annotation for ORM -> ODM references extension
+ * to be user like @ReferenceOne(type="entity", class="MyEntity", identifier="entity_id")
+ *
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @package Gedmo.Mapping.Annotation
+ * @subpackage Language
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ * @Annotation
+ */
+class ReferenceMany extends Reference
+{
+}
+

vendor/gedmo/doctrine-extensions/lib/Gedmo/Mapping/Annotation/ReferenceOne.php

+<?php
+
+namespace Gedmo\Mapping\Annotation;
+
+use Doctrine\Common\Annotations\Annotation;
+
+/**
+ * Reference annotation for ORM -> ODM references extension
+ * to be user like @ReferenceOne(type="entity", class="MyEntity", identifier="entity_id")
+ *
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @package Gedmo.Mapping.Annotation
+ * @subpackage Language
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ * @Annotation
+ */
+class ReferenceOne extends Reference
+{
+}
+

vendor/gedmo/doctrine-extensions/lib/Gedmo/Mapping/Annotation/TreePath.php

  *
  * @author Gustavo Falco <comfortablynumb84@gmail.com>
  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author <rocco@roccosportal.com>
  * @package Gedmo.Mapping.Annotation
  * @subpackage TreePath
  * @link http://www.gediminasm.org
 final class TreePath extends Annotation
 {
     public $separator = ',';
+
+    public $appendId = null;
+
+    public $startsWithSeparator = false;
+
+    public $endsWithSeparator = true;
 }
 

vendor/gedmo/doctrine-extensions/lib/Gedmo/Mapping/Annotation/TreePathHash.php

+<?php
+
+namespace Gedmo\Mapping\Annotation;
+
+use Doctrine\Common\Annotations\Annotation;
+
+/**
+ * TreePath annotation for Tree behavioral extension
+ *
+ * @Annotation
+ * @Target("PROPERTY")
+ *
+ * @author <rocco@roccosportal.com>
+ * @package Gedmo.Mapping.Annotation
+ * @subpackage TreePathHash
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+final class TreePathHash extends Annotation
+{
+
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/LazyCollection.php

+<?php
+
+namespace Gedmo\References;
+
+use Doctrine\Common\Collections\ArrayCollection;
+
+use Doctrine\Common\Collections\Collection;
+
+/**
+ * Lazy collection for loading reference many associations.
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @package Gedmo\References\Mapping\Event
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class LazyCollection implements Collection
+{
+    private $results;
+    private $callback;
+
+    public function __construct($callback)
+    {
+        $this->callback = $callback;
+    }
+
+    public function add($element)
+    {
+        $this->initialize();
+        return $this->results->add($element);
+    }
+
+    public function clear()
+    {
+        $this->initialize();
+        return $this->results->clear();
+    }
+
+    public function contains($element)
+    {
+        $this->initialize();
+        return $this->results->contains($element);
+    }
+
+    public function containsKey($key)
+    {
+        $this->initialize();
+        return $this->results->containsKey($key);
+    }
+
+    public function current()
+    {
+        $this->initialize();
+        return $this->results->current();
+    }
+
+    public function exists(\Closure $p)
+    {
+        $this->initialize();
+        return $this->results->exists($p);
+    }
+
+    public function filter(\Closure $p)
+    {
+        $this->initialize();
+        return $this->results->filter($p);
+    }
+
+    public function first()
+    {
+        $this->initialize();
+        return $this->results->first();
+    }
+
+    public function forAll(\Closure $p)
+    {
+        $this->initialize();
+        return $this->results->forAll($p);
+    }
+
+    public function get($key)
+    {
+        $this->initialize();
+        return $this->results->get($key);
+    }
+
+    public function getKeys()
+    {
+        $this->initialize();
+        return $this->results->getKeys();
+    }
+
+    public function getValues()
+    {
+        $this->initialize();
+        return $this->results->getValues();
+    }
+
+    public function indexOf($element)
+    {
+        $this->initialize();
+        return $this->results->indexOf($element);
+    }
+
+    public function isEmpty()
+    {
+        $this->initialize();
+        return $this->results->isEmpty();
+    }
+
+    public function key()
+    {
+        $this->initialize();
+        return $this->results->key();
+    }
+
+    public function last()
+    {
+        $this->initialize();
+        return $this->results->last();
+    }
+
+    public function map(\Closure $func)
+    {
+        $this->initialize();
+        return $this->results->map($func);
+    }
+
+    public function next()
+    {
+        $this->initialize();
+        return $this->results->next();
+    }
+
+    public function partition(\Closure $p)
+    {
+        $this->initialize();
+        return $this->results->partition($p);
+    }
+
+    public function remove($key)
+    {
+        $this->initialize();
+        return $this->results->remove($key);
+    }
+
+    public function removeElement($element)
+    {
+        $this->initialize();
+        return $this->results->removeElement($element);
+    }
+
+    public function set($key, $value)
+    {
+        $this->initialize();
+        return $this->results->set($key, $value);
+    }
+
+    public function slice($offset, $length = null)
+    {
+        $this->initialize();
+        return $this->results->slice($offset, $length);
+    }
+
+    public function toArray()
+    {
+        $this->initialize();
+        return $this->results->toArray();
+    }
+
+    public function offsetExists($offset)
+    {
+        $this->initialize();
+        return $this->results->offsetExists($offset);
+    }
+
+    public function offsetGet($offset)
+    {
+        $this->initialize();
+        return $this->results->offsetGet($offset);
+    }
+
+    public function offsetSet($offset, $value)
+    {
+        $this->initialize();
+        return $this->results->offsetSet($offset, $value);
+    }
+
+    public function offsetUnset($offset)
+    {
+        $this->initialize();
+        return $this->results->offsetUnset($offset);
+    }
+
+    public function getIterator()
+    {
+        $this->initialize();
+        return $this->results->getIterator();
+    }
+
+    public function count()
+    {
+        $this->initialize();
+        return $this->results->count();
+    }
+
+    private function initialize()
+    {
+        if (null === $this->results) {
+            $this->results = call_user_func($this->callback);
+        }
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Driver/Annotation.php

+<?php
+
+namespace Gedmo\References\Mapping\Driver;
+
+use Gedmo\Mapping\Driver\AnnotationDriverInterface,
+    Doctrine\Common\Annotations\AnnotationReader,
+    Doctrine\Common\Persistence\Mapping\ClassMetadata,
+    Gedmo\Exception\InvalidMappingException;
+
+/**
+ * This is an annotation mapping driver for References
+ * behavioral extension.
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @package Gedmo.References.Mapping.Driver
+ * @subpackage Annotation
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class Annotation implements AnnotationDriverInterface
+{
+    /**
+     * Annotation to mark field as reference to one
+     */
+    const REFERENCE_ONE = 'Gedmo\\Mapping\\Annotation\\ReferenceOne';
+
+    /**
+     * Annotation to mark field as reference to many
+     */
+    const REFERENCE_MANY = 'Gedmo\\Mapping\\Annotation\\ReferenceMany';
+
+    private $annotations = array(
+        'referenceOne'  => self::REFERENCE_ONE,
+        'referenceMany' => self::REFERENCE_MANY,
+    );
+
+    /**
+     * Annotation reader instance
+     *
+     * @var object
+     */
+    private $reader;
+
+    /**
+     * original driver if it is available
+     */
+    protected $_originalDriver = null;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setAnnotationReader($reader)
+    {
+        $this->reader = $reader;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function readExtendedMetadata($meta, array &$config)
+    {
+        $class = $meta->getReflectionClass();
+        foreach($this->annotations as $key => $annotation) {
+            $config[$key] = array();
+            foreach ($class->getProperties() as $property) {
+                if ($meta->isMappedSuperclass && !$property->isPrivate() ||
+                    $meta->isInheritedField($property->name) ||
+                    isset($meta->associationMappings[$property->name]['inherited'])
+                ) {
+                    continue;
+                }
+
+                if ($reference = $this->reader->getPropertyAnnotation($property, $annotation)) {
+                    $config[$key][$property->getName()] = array(
+                        'field'      => $property->getName(),
+                        'type'       => $reference->type,
+                        'class'      => $reference->class,
+                        'identifier' => $reference->identifier,
+                        'mappedBy'   => $reference->mappedBy,
+                        'inversedBy' => $reference->inversedBy,
+                    );
+                }
+            }
+        }
+    }
+
+    /**
+     * Passes in the mapping read by original driver
+     *
+     * @param $driver
+     * @return void
+     */
+    public function setOriginalDriver($driver)
+    {
+        $this->_originalDriver = $driver;
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Event/Adapter/ODM.php

+<?php
+
+namespace Gedmo\References\Mapping\Event\Adapter;
+
+use Doctrine\Common\Persistence\ObjectManager;
+use Doctrine\ODM\MongoDB\DocumentManager;
+use Doctrine\ODM\MongoDB\Proxy\Proxy as MongoDBProxy;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\Proxy\Proxy as ORMProxy;
+use Gedmo\Exception\InvalidArgumentException;
+use Gedmo\Mapping\Event\Adapter\ODM as BaseAdapterODM;
+use Gedmo\References\Mapping\Event\ReferencesAdapter;
+
+/**
+ * Doctrine event adapter for ODM references behavior
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @package Gedmo\References\Mapping\Event\Adapter
+ * @subpackage ODM
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+final class ODM extends BaseAdapterODM implements ReferencesAdapter
+{
+    /**
+     * @inheritDoc
+     */
+    public function getIdentifier($om, $object, $single = true)
+    {
+        if ($om instanceof DocumentManager) {
+            return $this->extractIdentifier($om, $object, $single);
+        }
+
+        if ($om instanceof EntityManager) {
+            if ($object instanceof ORMProxy) {
+                $id = $om->getUnitOfWork()->getEntityIdentifier($object);
+            } else {
+                $meta = $om->getClassMetadata(get_class($object));
+                $id = array();
+                foreach ($meta->identifier as $name) {
+                    $id[$name] = $meta->getReflectionProperty($name)->getValue($object);
+                    // return null if one of identifiers is missing
+                    if (!$id[$name]) {
+                        return null;
+                    }
+                }
+            }
+
+            if ($single) {
+                $id = current($id);
+            }
+
+            return $id;
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getSingleReference($om, $class, $identifier)
+    {
+        $this->throwIfNotEntityManager($om);
+        $meta = $om->getClassMetadata($class);
+
+        if (!$meta->isInheritanceTypeNone()) {
+            return $om->find($class, $identifier);
+        }
+
+        return $om->getReference($class, $identifier);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function extractIdentifier($om, $object, $single = true)
+    {
+        $meta = $om->getClassMetadata(get_class($object));
+        if ($object instanceof MongoDBProxy) {
+            $id = $om->getUnitOfWork()->getDocumentIdentifier($object);
+        } else {
+            $id = $meta->getReflectionProperty($meta->identifier)->getValue($object);
+        }
+
+        if ($single || !$id) {
+            return $id;
+        } else {
+            return array($meta->identifier => $id);
+        }
+    }
+
+    /**
+     * Override so we don't get an exception. We want to allow this.
+     */
+    private function throwIfNotEntityManager(EntityManager $em)
+    {
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Event/Adapter/ORM.php

+<?php
+
+namespace Gedmo\References\Mapping\Event\Adapter;
+
+use Doctrine\Common\Persistence\ObjectManager;
+use Doctrine\ODM\MongoDB\DocumentManager;
+use Doctrine\ODM\MongoDB\Proxy\Proxy as MongoDBProxy;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\Proxy\Proxy as ORMProxy;
+use Gedmo\Mapping\Event\Adapter\ORM as BaseAdapterORM;
+use Gedmo\References\Mapping\Event\ReferencesAdapter;
+
+/**
+ * Doctrine event adapter for ORM references behavior
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @package Gedmo\References\Mapping\Event\Adapter
+ * @subpackage ORM
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+final class ORM extends BaseAdapterORM implements ReferencesAdapter
+{
+    /**
+     * @inheritDoc
+     */
+    public function getIdentifier($om, $object, $single = true)
+    {
+        if ($om instanceof EntityManager) {
+            return $this->extractIdentifier($om, $object, $single);
+        }
+
+        if ($om instanceof DocumentManager) {
+            $meta = $om->getClassMetadata(get_class($object));
+            if ($object instanceof MongoDBProxy) {
+                $id = $om->getUnitOfWork()->getDocumentIdentifier($object);
+            } else {
+                $id = $meta->getReflectionProperty($meta->identifier)->getValue($object);
+            }
+
+            if ($single || !$id) {
+                return $id;
+            }
+
+            return array($meta->identifier => $id);
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getSingleReference($om, $class, $identifier)
+    {
+        $this->throwIfNotDocumentManager($om);
+        $meta = $om->getClassMetadata($class);
+
+        if (!$meta->isInheritanceTypeNone()) {
+            return $om->find($class, $identifier);
+        }
+
+        return $om->getReference($class, $identifier);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function extractIdentifier($om, $object, $single = true)
+    {
+        if ($object instanceof ORMProxy) {
+            $id = $om->getUnitOfWork()->getEntityIdentifier($object);
+        } else {
+            $meta = $om->getClassMetadata(get_class($object));
+            $id = array();
+            foreach ($meta->identifier as $name) {
+                $id[$name] = $meta->getReflectionProperty($name)->getValue($object);
+                // return null if one of identifiers is missing
+                if (!$id[$name]) {
+                    return null;
+                }
+            }
+        }
+
+        if ($single) {
+            $id = current($id);
+        }
+
+        return $id;
+    }
+
+    /**
+     * Override so we don't get an exception. We want to allow this.
+     */
+    private function throwIfNotDocumentManager(DocumentManager $dm)
+    {
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Event/ReferencesAdapter.php

+<?php
+
+namespace Gedmo\References\Mapping\Event;
+
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+use Doctrine\Common\Persistence\ObjectManager;
+use Gedmo\Mapping\Event\AdapterInterface;
+
+/**
+ * Doctrine event adapter interface for References behavior
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @package Gedmo\References\Mapping\Event
+ * @subpackage ReferencesAdapter
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+interface ReferencesAdapter extends AdapterInterface
+{
+    /**
+     * Gets the identifier of the given object using the passed ObjectManager.
+     *
+     * @param ObjectManager $om
+     * @param object $object
+     * @param bool $single
+     * @return array|scalar $id - array or single identifier
+     */
+    function getIdentifier($om, $object, $single = true);
+
+    /**
+     * Gets a single reference for the given ObjectManager, class and identifier.
+     *
+     * @param ObjectManager $om
+     * @param string $class
+     * @param array|scalar $identifier
+     **/
+    function getSingleReference($om, $class, $identifier);
+
+    /**
+     * Extracts identifiers from object or proxy.
+     *
+     * @param DocumentManager $om
+     * @param object $object
+     * @param bool $single
+     * @return array|scalar - array or single identifier
+     */
+    function extractIdentifier($om, $object, $single = true);
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/ReferencesListener.php

+<?php
+
+namespace Gedmo\References;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\EventArgs;
+use Doctrine\ORM\Mapping\ClassMetadata as ORMClassMetadata;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ODM\MongoDB\DocumentManager;
+use Doctrine\ODM\MongoDB\Mapping\ClassMetadata as MongoDBClassMetadata;
+use Gedmo\Exception\InvalidArgumentException;
+use Gedmo\Mapping\MappedEventSubscriber;
+
+/**
+ * Listener for loading and persisting cross database references.
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @package Gedmo\References\Mapping\Event
+ * @subpackage MappedEventSubscriber
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class ReferencesListener extends MappedEventSubscriber
+{
+    private $managers;
+
+    public function __construct(array $managers = array())
+    {
+        $this->managers = $managers;
+    }
+
+    public function loadClassMetadata(EventArgs $eventArgs)
+    {
+        $ea = $this->getEventAdapter($eventArgs);
+        $this->loadMetadataForObjectClass(
+            $ea->getObjectManager(), $eventArgs->getClassMetadata()
+        );
+    }
+
+    public function postLoad(EventArgs $eventArgs)
+    {
+        $ea = $this->getEventAdapter($eventArgs);
+        $om = $ea->getObjectManager();
+        $object = $ea->getObject();
+        $meta = $om->getClassMetadata(get_class($object));
+        $config = $this->getConfiguration($om, $meta->name);
+        foreach ($config['referenceOne'] as $mapping) {
+            $property = $meta->reflClass->getProperty($mapping['field']);
+            $property->setAccessible(true);
+            if (isset($mapping['identifier'])) {
+                $referencedObjectId = $meta->getFieldValue($object, $mapping['identifier']);
+                if (null !== $referencedObjectId) {
+                    $property->setValue(
+                        $object,
+                        $ea->getSingleReference(
+                            $this->getManager($mapping['type']),
+                            $mapping['class'],
+                            $referencedObjectId
+                        )
+                    );
+                }
+            }
+        }
+
+        foreach ($config['referenceMany'] as $mapping) {
+            $property = $meta->reflClass->getProperty($mapping['field']);
+            $property->setAccessible(true);
+            if (isset($mapping['mappedBy'])) {
+                $id = $ea->extractIdentifier($om, $object);
+                $manager = $this->getManager($mapping['type']);
+                $class = $mapping['class'];
+                $refMeta = $manager->getClassMetadata($class);
+                $refConfig = $this->getConfiguration($manager, $refMeta->name);
+                if (isset($refConfig['referenceOne'][$mapping['mappedBy']])) {
+                    $refMapping = $refConfig['referenceOne'][$mapping['mappedBy']];
+                    $identifier = $refMapping['identifier'];
+                    $property->setValue(
+                        $object,
+                        new LazyCollection(
+                            function() use ($id, &$manager, $class, $identifier) {
+                                $results = $manager
+                                    ->getRepository($class)
+                                    ->findBy(array(
+                                        $identifier => $id,
+                                    ));
+
+                                return new ArrayCollection((is_array($results) ? $results : $results->toArray()));
+                            }
+                        )
+                    );
+                }
+            }
+        }
+    }
+
+    public function prePersist(EventArgs $eventArgs)
+    {
+        $this->updateReferences($eventArgs);
+    }
+
+    public function preUpdate(EventArgs $eventArgs)
+    {
+        $this->updateReferences($eventArgs);
+    }
+
+    public function getSubscribedEvents()
+    {
+        return array(
+            'postLoad',
+            'loadClassMetadata',
+            'prePersist',
+            'preUpdate',
+        );
+    }
+
+    public function registerManager($type, $manager)
+    {
+        $this->managers[$type] = $manager;
+    }
+
+    public function getManager($type)
+    {
+        return $this->managers[$type];
+    }
+
+    protected function getNamespace()
+    {
+        return __NAMESPACE__;
+    }
+
+    private function updateReferences(EventArgs $eventArgs)
+    {
+        $ea = $this->getEventAdapter($eventArgs);
+        $om = $ea->getObjectManager();
+        $object = $ea->getObject();
+        $meta = $om->getClassMetadata(get_class($object));
+        $config = $this->getConfiguration($om, $meta->name);
+        foreach ($config['referenceOne'] as $mapping) {
+            if (isset($mapping['identifier'])) {
+                $property = $meta->reflClass->getProperty($mapping['field']);
+                $property->setAccessible(true);
+                $referencedObject = $property->getValue($object);
+                if (is_object($referencedObject)) {
+                    $meta->setFieldValue(
+                        $object,
+                        $mapping['identifier'],
+                        $ea->getIdentifier(
+                            $this->getManager($mapping['type']),
+                            $referencedObject
+                        )
+                    );
+                }
+            }
+        }
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/SoftDeleteable/Mapping/Validator.php

         'date',
         'time',
         'datetime',
+        'datetimetz',
         'timestamp',
         'zenddate'
     );

vendor/gedmo/doctrine-extensions/lib/Gedmo/Sortable/SortableListener.php

     private function processInsert($em, $config, $meta, $object)
     {
         $uow = $em->getUnitOfWork();
-
+        
+        $old = $meta->getReflectionProperty($config['position'])->getValue($object);
         $newPosition = $meta->getReflectionProperty($config['position'])->getValue($object);
+        
         if (is_null($newPosition)) {
             $newPosition = -1;
         }
         call_user_func_array(array($this, 'addRelocation'), $relocation);
 
         // Set new position
-        $meta->getReflectionProperty($config['position'])->setValue($object, $newPosition);
-        $uow->recomputeSingleEntityChangeSet($meta, $object);
+        if ($old < 0 || is_null($old)) {
+            $meta->getReflectionProperty($config['position'])->setValue($object, $newPosition);
+            $uow->recomputeSingleEntityChangeSet($meta, $object);
+        }
     }
 
     /**

vendor/gedmo/doctrine-extensions/lib/Gedmo/Timestampable/Mapping/Driver/Annotation.php

         'date',
         'time',
         'datetime',
+        'datetimetz',
         'timestamp',
         'zenddate',
         'vardatetime',

vendor/gedmo/doctrine-extensions/lib/Gedmo/Timestampable/Mapping/Driver/Xml.php

         'date',
         'time',
         'datetime',
+        'datetimetz',
         'timestamp',
         'zenddate',
         'vardatetime',

vendor/gedmo/doctrine-extensions/lib/Gedmo/Timestampable/Mapping/Driver/Yaml.php

         'date',
         'time',
         'datetime',
+        'datetimetz',
         'timestamp',
         'zenddate',
         'vardatetime',

vendor/gedmo/doctrine-extensions/lib/Gedmo/Tool/Wrapper/EntityWrapper.php

      */
     public function hasValidIdentifier()
     {
-        return (bool)$this->getIdentifier();
+        return (null !== $this->getIdentifier());
     }
 
     /**
      */
     public function getIdentifier($single = true)
     {
-        if (!$this->identifier) {
+        if (null === $this->identifier) {
             if ($this->object instanceof Proxy) {
                 $uow = $this->om->getUnitOfWork();
                 if ($uow->isInIdentityMap($this->object)) {
                     $this->initialize();
                 }
             }
-            if (!$this->identifier) {
+            if (null === $this->identifier) {
                 $this->identifier = array();
                 $incomplete = false;
                 foreach ($this->meta->identifier as $name) {
                     $this->identifier[$name] = $this->getPropertyValue($name);
-                    if (!$this->identifier[$name]) {
+                    if (null === $this->identifier[$name]) {
                         $incomplete = true;
                     }
                 }
             }
         }
     }
-}
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/Translatable/TranslatableListener.php

 
             if ($translation) {
                 // set the translated field, take value using reflection
-                $value = $wrapped->getPropertyValue($field);
                 $content = $ea->getTranslationValue($object, $field);
                 $translation->setContent($content);
                 // check if need to update in database
                 $transWrapper = AbstractWrapper::wrap($translation, $om);
-                if ((is_bool($content) || is_int($content) || !empty($content)) && ($isInsert || !$transWrapper->getIdentifier() || isset($changeSet[$field]))) {
+                if ((is_bool($content) || is_int($content) || (is_string($content) && strlen($content) > 0) || !empty($content)) && ($isInsert || !$transWrapper->getIdentifier() || isset($changeSet[$field]))) {
                     if ($isInsert && !$objectId && !$ea->usesPersonalTranslation($translationClass)) {
                         // if we do not have the primary key yet available
                         // keep this translation in memory to insert it later with foreign key

vendor/gedmo/doctrine-extensions/lib/Gedmo/Tree/Mapping/Driver/Annotation.php

  * extension.
  *
  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author <rocco@roccosportal.com>
  * @package Gedmo.Tree.Mapping.Driver
  * @subpackage Annotation
  * @link http://www.gediminasm.org
     const PATH_SOURCE = 'Gedmo\\Mapping\\Annotation\\TreePathSource';
 
     /**
+     * Annotation to specify path hash class
+     */
+    const PATH_HASH = 'Gedmo\\Mapping\\Annotation\\TreePathHash';
+
+    /**
      * Annotation to mark the field to be used to hold the lock time
      */
     const LOCK_TIME = 'Gedmo\\Mapping\\Annotation\\TreeLockTime';
                 }
                 $config['path'] = $field;
                 $config['path_separator'] = $pathAnnotation->separator;
+                $config['path_append_id'] = $pathAnnotation->appendId;
+                $config['path_starts_with_separator'] = $pathAnnotation->startsWithSeparator;
+                $config['path_ends_with_separator'] = $pathAnnotation->endsWithSeparator;
             }
             // path source
             if ($this->reader->getPropertyAnnotation($property, self::PATH_SOURCE)) {
                 }
                 $config['path_source'] = $field;
             }
+
+             // path hash
+            if ($this->reader->getPropertyAnnotation($property, self::PATH_HASH)) {
+                $field = $property->getName();
+                if (!$meta->hasField($field)) {
+                    throw new InvalidMappingException("Unable to find 'path_hash' - [{$field}] as mapped property in entity - {$meta->name}");
+                }
+                if (!$validator->isValidFieldForPathHash($meta, $field)) {
+                    throw new InvalidMappingException("Tree PathHash field - [{$field}] type is not valid. It can be any of the integer variants, double, float or string in class - {$meta->name}");
+                }
+                $config['path_hash'] = $field;
+
+            }
             // lock time
 
             if ($this->reader->getPropertyAnnotation($property, self::LOCK_TIME)) {

vendor/gedmo/doctrine-extensions/lib/Gedmo/Tree/Mapping/Driver/Yaml.php

                         if (strlen($separator) > 1) {
                             throw new InvalidMappingException("Tree Path field - [{$field}] Separator {$separator} is invalid. It must be only one character long.");
                         }
+
+                        if (is_array($treePathInfo) && isset($treePathInfo['appendId'])) {
+                            $appendId = $treePathInfo['appendId'];
+                        } else {
+                            $appendId = null;
+                        }
+
+                        if (is_array($treePathInfo) && isset($treePathInfo['startsWithSeparator'])) {
+                            $startsWithSeparator = $treePathInfo['startsWithSeparator'];
+                        } else {
+                            $startsWithSeparator = false;
+                        }
+
+                        if (is_array($treePathInfo) && isset($treePathInfo['endsWithSeparator'])) {
+                            $endsWithSeparator = $treePathInfo['endsWithSeparator'];
+                        } else {
+                            $endsWithSeparator = true;
+                        }
+
                         $config['path'] = $field;
                         $config['path_separator'] = $separator;
+                        $config['path_append_id'] = $appendId;
+                        $config['path_starts_with_separator'] = $startsWithSeparator;
+                        $config['path_ends_with_separator'] = $endsWithSeparator;
                     } elseif (in_array('treePathSource', $fieldMapping['gedmo'])) {
                         if (!$validator->isValidFieldForPathSource($meta, $field)) {
                             throw new InvalidMappingException("Tree PathSource field - [{$field}] type is not valid. It can be any of the integer variants, double, float or string in class - {$meta->name}");
                         }
                         $config['path_source'] = $field;
+                    } elseif (in_array('treePathHash', $fieldMapping['gedmo'])) {
+                        if (!$validator->isValidFieldForPathSource($meta, $field)) {
+                            throw new InvalidMappingException("Tree PathHash field - [{$field}] type is not valid and must be 'string' in class - {$meta->name}");
+                        }
+                        $config['path_hash'] = $field;
                     } elseif (in_array('treeLockTime', $fieldMapping['gedmo'])) {
                         if (!$validator->isValidFieldForLocktime($meta, $field)) {
                             throw new InvalidMappingException("Tree LockTime field - [{$field}] type is not valid. It must be \"date\" in class - {$meta->name}");

vendor/gedmo/doctrine-extensions/lib/Gedmo/Tree/Mapping/Validator.php

  *
  * @author Gustavo Falco <comfortablynumb84@gmail.com>
  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author <rocco@roccosportal.com>
  * @package Gedmo.Tree.Mapping
  * @subpackage Validator
  * @link http://www.gediminasm.org
  * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
  */
-class Validator 
+class Validator
 {
     /**
      * List of types which are valid for tree fields
     );
 
     /**
+     * List of types which are valid for the path hash (materialized path strategy)
+     *
+     * @var array
+     */
+    private $validPathHashTypes = array(
+        'string'
+    );
+
+    /**
      * List of types which are valid for the path source (materialized path strategy)
      *
      * @var array
         'string'
     );
 
-    
-
     /**
      * Checks if $field type is valid
      *
     }
 
     /**
+     * Checks if $field type is valid for PathHash field
+     *
+     * @param object $meta
+     * @param string $field
+     * @return boolean
+     */
+    public function isValidFieldForPathHash($meta, $field)
+    {
+        $mapping = $meta->getFieldMapping($field);
+        return $mapping && in_array($mapping['type'], $this->validPathHashTypes);
+    }
+
+    /**
      * Checks if $field type is valid for LockTime field
      *
      * @param object $meta

vendor/gedmo/doctrine-extensions/lib/Gedmo/Tree/Strategy/AbstractMaterializedPath.php

  *
  * @author Gustavo Falco <comfortablynumb84@gmail.com>
  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author <rocco@roccosportal.com>
  * @package Gedmo.Tree.Strategy
  * @subpackage AbstractMaterializedPath
  * @link http://www.gediminasm.org
 
         $fieldMapping = $meta->getFieldMapping($config['path_source']);
 
-        // If PathSource field is a string, we append the ID to the path
-        if ($fieldMapping['type'] === 'string') {
+        // default behavior: if PathSource field is a string, we append the ID to the path
+        // path_append_id is true: always append id
+        // path_append_id is false: never append id
+        if ($config['path_append_id'] === true || ($fieldMapping['type'] === 'string' && $config['path_append_id']!==false)) {
             if (method_exists($meta, 'getIdentifierValue')) {
                 $identifier = $meta->getIdentifierValue($node);
             } else {
             $path .= '-'.$identifier;
         }
 
-        $path .= $config['path_separator'];
 
         if ($parent) {
             // Ensure parent has been initialized in the case where it's a proxy
             $om->initializeObject($parent);
-            
+
             $changeSet = $uow->isScheduledForUpdate($parent) ? $ea->getObjectChangeSet($uow, $parent) : false;
             $pathOrPathSourceHasChanged = $changeSet && (isset($changeSet[$config['path_source']]) || isset($changeSet[$config['path']]));
 
                 $this->updateNode($om, $parent, $ea);
             }
 
-            $path = $pathProp->getValue($parent).$path;
+            $parentPath = $pathProp->getValue($parent);
+            // if parent path not ends with separator
+            if ($parentPath[strlen($parentPath) - 1] !== $config['path_separator']) {
+                // add separator
+                $path = $pathProp->getValue($parent) . $config['path_separator'] . $path;
+            } else {
+                // don't add separator
+                $path = $pathProp->getValue($parent) . $path;
+            }
+
+        }
+
+
+        if ($config['path_starts_with_separator'] && (strlen($path) > 0 && $path[0] !== $config['path_separator'])) {
+            $path = $config['path_separator'] . $path;
+        }
+
+        if ($config['path_ends_with_separator'] && ($path[strlen($path) - 1] !== $config['path_separator'])) {
+            $path .= $config['path_separator'];
         }
-        
+
         $pathProp->setValue($node, $path);
         $changes = array(
             $config['path'] => array(null, $path)
         );
 
+        if (isset($config['path_hash'])) {
+            $pathHash = md5($path);
+            $pathHashProp = $meta->getReflectionProperty($config['path_hash']);
+            $pathHashProp->setAccessible(true);
+            $pathHashProp->setValue($node, $pathHash);
+            $changes[$config['path_hash']] = array(null, $pathHash);
+        }
+
+
         if (isset($config['level'])) {
             $level = substr_count($path, $config['path_separator']);
             $levelProp = $meta->getReflectionProperty($config['level']);
 
         $uow->scheduleExtraUpdate($node, $changes);
         $ea->setOriginalObjectProperty($uow, $oid, $config['path'], $path);
+
+        if(isset($config['path_hash'])){
+            $ea->setOriginalObjectProperty($uow, $oid, $config['path_hash'], $pathHash);
+        }
     }
 
     /**
 
                 $reflMethod->invoke($parentNode);
             }
-            
+
             // If tree is already locked, we throw an exception
             $lockTimeProp = $meta->getReflectionProperty($config['lock_time']);
             $lockTimeProp->setAccessible(true);
             }
         }
     }
-    
+
     /**
      * Locks all needed trees
      *

vendor/gedmo/doctrine-extensions/lib/Gedmo/Uploadable/FilenameGenerator/FilenameGeneratorAlphanumeric.php

     /**
      * @inheritDoc
      */
-    public static function generate($filename, $extension)
+    public static function generate($filename, $extension, $object = null)
     {
         return preg_replace('/[^a-z0-9]+/', '-', strtolower($filename)).$extension;
     }

vendor/gedmo/doctrine-extensions/lib/Gedmo/Uploadable/FilenameGenerator/FilenameGeneratorInterface.php

      *
      * @param string - Filename without extension
      * @param string - Extension with dot: .jpg, .gif, etc
+     * @param $object
      *
      * @return string
      */
-    public static function generate($filename, $extension);
+    public static function generate($filename, $extension, $object = null);
 }

vendor/gedmo/doctrine-extensions/lib/Gedmo/Uploadable/FilenameGenerator/FilenameGeneratorSha1.php

     /**
      * @inheritDoc
      */
-    public static function generate($filename, $extension)
+    public static function generate($filename, $extension, $object = null)
     {
         return sha1(uniqid($filename.$extension, true)).$extension;
     }

vendor/gedmo/doctrine-extensions/lib/Gedmo/Uploadable/UploadableListener.php

                 $generatorClass = $config['filenameGenerator'];
         }
 
-        $info = $this->moveFile($fileInfo, $path, $generatorClass, $config['allowOverwrite'], $config['appendNumber']);
+        $info = $this->moveFile($fileInfo, $path, $generatorClass, $config['allowOverwrite'], $config['appendNumber'], $object);
 
         // We override the mime type with the guessed one
         $info['fileMimeType'] = $mime;
      * @param bool $filenameGeneratorClass
      * @param bool $overwrite
      * @param bool $appendNumber
+     * @param $object
      * @return array
      * @throws \Gedmo\Exception\UploadableUploadException
      * @throws \Gedmo\Exception\UploadableNoFileException
      * @throws \Gedmo\Exception\UploadableNoTmpDirException
      * @throws \Gedmo\Exception\UploadableCantWriteException
      */
-    public function moveFile(FileInfoInterface $fileInfo, $path, $filenameGeneratorClass = false, $overwrite = false, $appendNumber = false)
+    public function moveFile(FileInfoInterface $fileInfo, $path, $filenameGeneratorClass = false, $overwrite = false, $appendNumber = false, $object)
     {
         if ($fileInfo->getError() > 0) {
             switch ($fileInfo->getError()) {
         if ($filenameGeneratorClass) {
             $filename = $filenameGeneratorClass::generate(
                 str_replace($path.'/', '', $info['fileWithoutExt']),
-                $info['fileExtension']
+                $info['fileExtension'],
+                $object
             );
             $info['filePath'] = str_replace(
                 '/'.$info['fileName'],

vendor/gedmo/doctrine-extensions/schemas/orm/doctrine-extensions-mapping.xsd

-<?xml version="1.0" encoding="UTF-8"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-    targetNamespace="http://gediminasm.org/schemas/orm/doctrine-extensions-mapping"
-    xmlns:gedmo="http://gediminasm.org/schemas/orm/doctrine-extensions-mapping"
-    elementFormDefault="qualified">
-
-  <xs:annotation>
-    <xs:documentation><![CDATA[
-       This is the XML Schema for the object/relational
-       mapping file used by the Doctrine Extensions by Gedmo
-       extensions
-       Doctrine component version support: 2.2.x
-     ]]></xs:documentation>
-  </xs:annotation>
-
-<!--
-It would be nice if we could force the gedmo with only necessary elements into each of doctrine elements.
-Patches that do that are more than welcome.
-Please note, that marking e.g filed element in xml document with xsi:type is not an option as we need to allow other
-people to push their own additional attributes/elements into the same field element and they should not extend our schema
--->
-
-  <!-- entity -->
-  <xs:element name="translation" type="gedmo:translation"/>
-  <xs:element name="tree" type="gedmo:tree"/>
-  <xs:element name="tree-closure" type="gedmo:tree-closure"/>
-  <xs:element name="loggable" type="gedmo:loggable"/>
-  <xs:element name="soft-deleteable" type="gedmo:soft-deleteable"/>
-  <xs:element name="uploadable" type="gedmo:uploadable"/>
-  <!-- field -->
-  <xs:element name="slug" type="gedmo:slug"/>
-  <xs:element name="translatable" type="gedmo:translatable"/>
-  <xs:element name="timestampable" type="gedmo:timestampable"/>
-  <xs:element name="versioned" type="gedmo:emptyType"/>
-  <xs:element name="tree-left" type="gedmo:emptyType"/>
-  <xs:element name="tree-right" type="gedmo:emptyType"/>
-  <xs:element name="tree-level" type="gedmo:emptyType"/>
-  <xs:element name="tree-root" type="gedmo:emptyType"/>
-  <xs:element name="tree-parent" type="gedmo:emptyType"/>
-  <xs:element name="tree-path-source" type="gedmo:emptyType"/>
-  <xs:element name="tree-lock-time" type="gedmo:emptyType"/>
-  <xs:element name="sortable-group" type="gedmo:emptyType"/>
-  <xs:element name="sortable-position" type="gedmo:emptyType"/>
-  <xs:element name="uploadable-file-mime-type" type="gedmo:emptyType"/>
-  <xs:element name="uploadable-file-path" type="gedmo:emptyType"/>
-  <xs:element name="uploadable-file-size" type="gedmo:emptyType"/>
-
-  <xs:complexType name="translation">
-    <xs:attribute name="entity" type="xs:string" use="optional" />
-    <xs:attribute name="locale" type="xs:string" use="optional" />
-    <xs:attribute name="language" type="xs:string" use="optional" />
-  </xs:complexType>
-
-  <xs:complexType name="tree">
-    <xs:attribute name="type" type="gedmo:tree-type" default="nested" />
-    <xs:attribute name="activate-locking" type="xs:boolean" default="false" />
-    <xs:attribute name="locking-timeout" type="xs:integer" default="3" />
-  </xs:complexType>
-
-  <xs:complexType name="tree-closure">
-    <xs:attribute name="class" type="xs:string" use="required" />
-  </xs:complexType>
-
-  <xs:complexType name="tree-path">
-    <xs:attribute name="separator" type="xs:string" use="optional" default="|" />
-  </xs:complexType>
-
-  <xs:complexType name="loggable">
-    <xs:attribute name="log-entry-class" type="xs:string" use="optional" />
-  </xs:complexType>
-
-  <xs:complexType name="slug">
-    <xs:sequence>
-      <xs:element name="handler" type="gedmo:handler" minOccurs="0" maxOccurs="unbounded"/>
-    </xs:sequence>
-    <xs:attribute name="fields" type="xs:string" use="required"/>
-    <xs:attribute name="unique" type="xs:boolean" use="optional" />
-    <xs:attribute name="updatable" type="xs:boolean" use="optional" />
-    <xs:attribute name="separator" type="xs:string" use="optional" />
-    <xs:attribute name="style" type="gedmo:slug-style" use="optional" />
-  </xs:complexType>
-
-  <xs:complexType name="soft-deleteable">
-    <xs:attribute name="field-name" type="xs:string" use="required" />
-  </xs:complexType>
-  
-  <xs:complexType name="handler">
-    <xs:sequence>
-      <xs:element name="handler-option" type="gedmo:handler-option" minOccurs="0" maxOccurs="unbounded"/>
-    </xs:sequence>
-    <xs:attribute name="class" type="xs:string" use="required"/>
-  </xs:complexType>
-  
-  <xs:complexType name="handler-option">
-    <xs:attribute name="name" type="xs:string" use="required"/>
-    <xs:attribute name="value" type="xs:string" use="required"/>
-  </xs:complexType>
-
-  <xs:complexType name="timestampable">
-    <xs:attribute name="on" type="gedmo:timestampable-action" use="optional" />
-    <xs:attribute name="field" type="xs:string" use="optional" />
-    <xs:attribute name="value" type="xs:string" use="optional" />
-  </xs:complexType>
-
-  <xs:complexType name="translatable">
-    <xs:attribute name="fallback" type="xs:boolean" use="optional" />
-  </xs:complexType>
-
-  <xs:complexType name="emptyType">
-  </xs:complexType>
-
-  <xs:simpleType name="tree-type">
-    <xs:restriction base="xs:token">
-      <xs:enumeration value="nested"/>
-      <xs:enumeration value="closure"/>
-      <xs:enumeration value="materializedPath"/>
-    </xs:restriction>
-  </xs:simpleType>
-
-  <xs:simpleType name="slug-style">
-    <xs:restriction base="xs:token">
-      <xs:enumeration value="default"/>
-      <xs:enumeration value="camel"/>
-    </xs:restriction>
-  </xs:simpleType>
-
-  <xs:simpleType name="timestampable-action">
-    <xs:restriction base="xs:token">
-      <xs:enumeration value="create"/>
-      <xs:enumeration value="update"/>
-      <xs:enumeration value="change"/>
-    </xs:restriction>
-  </xs:simpleType>
-
-  <xs:complexType name="uploadable">
-    <xs:attribute name="allow-overwrite" type="xs:boolean" use="optional" />
-    <xs:attribute name="append-number" type="xs:boolean" use="optional" />
-    <xs:attribute name="callback" type="xs:string" use="optional" />
-    <xs:attribute name="path" type="xs:string" use="optional" />
-    <xs:attribute name="path-method" type="xs:string" use="optional" />
-    <xs:attribute name="filename-generator" type="xs:string" use="optional" />
-    <xs:attribute name="max-size" type="xs:double" use="optional" default="0" />
-    <xs:attribute name="allowed-types" type="xs:string" use="optional" />
-    <xs:attribute name="disallowed-types" type="xs:string" use="optional" />
-  </xs:complexType>
-
-</xs:schema>

vendor/gedmo/doctrine-extensions/schemas/orm/doctrine-extensions-mapping.xsd

+doctrine-extensions-mapping-2-2.xsd

vendor/gedmo/doctrine-extensions/tests/Gedmo/References/Fixture/ODM/MongoDB/Product.php

+<?php
+
+namespace References\Fixture\ODM\MongoDB;
+
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM;
+use Gedmo\Mapping\Annotation as Gedmo;
+
+/**
+ * @ODM\Document
+ */
+class Product
+{
+    /**
+     * @ODM\Id
+     */
+    private $id;
+
+    /**
+     * @ODM\String
+     */
+    private $name;
+
+    /**
+     * @Gedmo\ReferenceMany(type="entity", class="References\Fixture\ORM\StockItem", mappedBy="product")
+     */
+    private $stockItems;
+
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    public function setId($id)
+    {
+        $this->id = $id;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    public function getStockItems()
+    {
+        return $this->stockItems;
+    }
+
+    public function setStockItems(Collection $stockItems)
+    {
+        $this->stockItems = $stockItems;
+    }
+}

vendor/gedmo/doctrine-extensions/tests/Gedmo/References/Fixture/ORM/StockItem.php

+<?php
+
+namespace References\Fixture\ORM;
+
+use Doctrine\ORM\Mapping as ORM;
+use Gedmo\Mapping\Annotation as Gedmo;
+use References\Fixture\ODM\MongoDB\Product;
+
+/**
+ * @ORM\Entity
+ */
+class StockItem
+{
+    /**
+     * @ORM\Id
+     * @ORM\Column(type="integer")
+     * @ORM\GeneratedValue(strategy="IDENTITY")
+     */
+    private $id;
+
+    /**
+     * @ORM\Column
+     */
+    private $name;
+
+    /**
+     * @ORM\Column
+     */
+    private $sku;
+
+    /**
+     * @ORM\Column(type="integer")
+     */
+    private $quantity;
+
+    /**
+     * @Gedmo\ReferenceOne(type="document", class="References\Fixture\ODM\MongoDB\Product", inversedBy="stockItems", identifier="productId")
+     */
+    private $product;
+
+    /**
+     * @ORM\Column(type="string")
+     */
+    private $productId;
+
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    public function setId($id)
+    {
+        $this->id = $id;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    public function getSku()
+    {
+        return $this->sku;
+    }
+
+    public function setSku($sku)
+    {
+        $this->sku = $sku;
+    }
+
+    public function getQuantity()
+    {
+        return $this->quantity;
+    }
+
+    public function setQuantity($quantity)
+    {
+        $this->quantity = $quantity;
+    }
+
+    public function setProduct(Product $product)
+    {
+        $this->product = $product;
+    }
+
+    public function getProduct()
+    {
+        return $this->product;
+    }
+
+    public function setProductId($productId)
+    {
+        $this->productId = $productId;
+    }
+
+    public function getProductId()
+    {
+        return $this->productId;
+    }
+}

vendor/gedmo/doctrine-extensions/tests/Gedmo/References/ReferencesListenerTest.php

+<?php
+
+namespace Gedmo\References;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver as MongoDBAnnotationDriver;
+use Doctrine\ODM\MongoDB\Configuration;
+use Doctrine\ORM\Mapping\Driver\AnnotationDriver as ORMAnnotationDriver;
+use References\Fixture\ODM\MongoDB\Product;
+use References\Fixture\ORM\StockItem;
+use Tool\BaseTestCaseOM;
+
+class ReferencesListenerTest extends BaseTestCaseOM
+{
+    private $em;
+    private $dm;
+
+    protected function setUp()
+    {
+        parent::setUp();
+
+        $reader = new AnnotationReader();
+
+        $this->dm = $this->getMockDocumentManager('test', new MongoDBAnnotationDriver($reader, __DIR__ . '/Fixture/ODM/MongoDB'));
+
+        $listener = new ReferencesListener(array(
+            'document' => $this->dm
+        ));
+
+        $this->evm->addEventSubscriber($listener);
+
+        $reader = new AnnotationReader();
+
+        $this->em = $this->getMockSqliteEntityManager(array('References\Fixture\ORM\StockItem'), new ORMAnnotationDriver($reader, __DIR__ . '/Fixture/ORM'));
+
+        $listener->registerManager('entity', $this->em);
+    }
+
+    public function testShouldPersistReferencedIdentifiersIntoIdentifierField()
+    {
+        $stockItem = new StockItem();
+        $stockItem->setName('Apple TV');
+        $stockItem->setSku('APP-TV');
+        $stockItem->setQuantity(25);
+
+        $product = new Product();
+        $product->setName('Apple TV');
+
+        $this->dm->persist($product);
+        $this->dm->flush();
+
+        $stockItem->setProduct($product);
+
+        $this->em->persist($stockItem);
+
+        $this->assertEquals($product->getId(), $stockItem->getProductId());
+    }
+
+    public function testShouldPopulateReferenceOneWithProxyFromIdentifierField()
+    {
+        $product = new Product();
+        $product->setName('Apple TV');
+
+        $this->dm->persist($product);
+        $this->dm->flush();
+
+        $stockItem = new StockItem();
+        $stockItem->setName('Apple TV');
+        $stockItem->setSku('APP-TV');
+        $stockItem->setQuantity(25);
+        $stockItem->setProductId($product->getId());
+
+        $this->em->persist($stockItem);
+        $this->em->flush();
+        $this->em->clear();
+
+        $stockItem = $this->em->find(get_class($stockItem), $stockItem->getId());
+
+        $this->assertSame($product, $stockItem->getProduct());
+    }
+
+    public function testShouldPopulateReferenceManyWithLazyCollectionInstance()
+    {
+        $product = new Product();
+        $product->setName('Apple TV');
+
+        $this->dm->persist($product);
+        $this->dm->flush();
+        $this->dm->clear();
+
+        $stockItem = new StockItem();
+        $stockItem->setName('Apple TV');
+        $stockItem->setSku('APP-TV');
+        $stockItem->setQuantity(25);
+        $stockItem->setProductId($product->getId());
+
+        $this->em->persist($stockItem);
+
+        $stockItem = new StockItem();
+        $stockItem->setName('Apple TV');
+        $stockItem->setSku('AMZN-APP-TV');
+        $stockItem->setQuantity(25);
+        $stockItem->setProductId($product->getId());
+
+        $this->em->persist($stockItem);
+        $this->em->flush();
+
+        $product = $this->dm->find(get_class($product), $product->getId());
+
+        $this->assertInstanceOf('Doctrine\Common\Collections\Collection', $product->getStockItems());
+        $this->assertEquals(2, $product->getStockItems()->count());
+
+        $first = $product->getStockItems()->first();
+
+        $this->assertInstanceOf(get_class($stockItem), $first);
+        $this->assertEquals('APP-TV', $first->getSku());
+
+        $last = $product->getStockItems()->last();
+
+        $this->assertInstanceOf(get_class($stockItem), $last);
+        $this->assertEquals('AMZN-APP-TV', $last->getSku());
+    }
+}

vendor/gedmo/doctrine-extensions/tests/Gedmo/Tool/BaseTestCaseOM.php

 
         $config
             ->expects($this->any())
+            ->method('getDefaultRepositoryClassName')
+            ->will($this->returnValue('Doctrine\\ORM\\EntityRepository'))
+        ;
+
+        $config
+            ->expects($this->any())
             ->method('getQuoteStrategy')
             ->will($this->returnValue(new DefaultQuoteStrategy()))
         ;

vendor/gedmo/doctrine-extensions/tests/Gedmo/Tree/Fixture/MPFeaturesCategory.php

+<?php
+
+namespace Tree\Fixture;
+
+use Gedmo\Tree\Node as NodeInterface;
+use Gedmo\Mapping\Annotation as Gedmo;
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity(repositoryClass="Gedmo\Tree\Entity\Repository\MaterializedPathRepository")
+ * @Gedmo\Tree(type="materializedPath")
+ */
+class MPFeaturesCategory
+{
+    /**
+     * @ORM\Column(name="id", type="integer")
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     */
+    private $id;
+
+    /**
+     * @Gedmo\TreePath(appendId=false, startsWithSeparator=true, endsWithSeparator=false)
+     * @ORM\Column(name="path", type="string", length=3000, nullable=true)
+     */
+    private $path;
+
+    /**
+     * @Gedmo\TreePathHash
+     * @ORM\Column(name="pathhash", type="string", length=32, nullable=true)
+     */
+    private $pathHash;
+
+    /**
+     * @Gedmo\TreePathSource
+     * @ORM\Column(name="title", type="string", length=64)
+     */
+    private $title;
+
+    /**
+     * @Gedmo\TreeParent
+     * @ORM\ManyToOne(targetEntity="MPFeaturesCategory", inversedBy="children")
+     * @ORM\JoinColumns({
+     *   @ORM\JoinColumn(name="parent_id", referencedColumnName="id", onDelete="SET NULL")
+     * })
+     */
+    private $parentId;
+
+    /**
+     * @Gedmo\TreeLevel
+     * @ORM\Column(name="lvl", type="integer", nullable=true)
+     */
+    private $level;
+
+    /**
+     * @ORM\OneToMany(targetEntity="MPFeaturesCategory", mappedBy="parent")
+     */
+    private $children;
+
+    /**
+     * @ORM\OneToMany(targetEntity="Article", mappedBy="category")
+     */
+    private $comments;
+
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    public function setTitle($title)
+    {
+        $this->title = $title;
+    }
+
+    public function getTitle()
+    {
+        return $this->title;
+    }
+
+    public function setParent(MPFeaturesCategory $parent = null)
+    {
+        $this->parentId = $parent;
+    }
+
+    public function getParent()
+    {
+        return $this->parentId;
+    }
+
+    public function setPath($path)
+    {
+        $this->path = $path;
+    }
+
+    public function getPath()
+    {
+        return $this->path;
+    }
+
+    public function getLevel()
+    {
+        return $this->level;
+    }
+
+    public function getPathHash(){
+        return $this->pathHash;
+    }
+}

vendor/gedmo/doctrine-extensions/tests/Gedmo/Tree/MaterializedPathORMFeaturesTest.php

+<?php
+
+namespace Gedmo\Tree;
+
+use Doctrine\Common\EventManager;
+use Tool\BaseTestCaseORM;
+
+/**
+ * These are tests for Tree behavior
+ *
+ * @author Gustavo Falco <comfortablynumb84@gmail.com>
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @package Gedmo.Tree
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class MaterializedPathORMFeaturesTest extends BaseTestCaseORM
+{
+    const CATEGORY = "Tree\\Fixture\\MPFeaturesCategory";
+
+    protected $config;
+    protected $listener;
+
+    protected function setUp()
+    {
+        parent::setUp();
+
+        $this->listener = new TreeListener;
+
+        $evm = new EventManager;
+        $evm->addEventSubscriber($this->listener);
+
+        $this->getMockSqliteEntityManager($evm);
+
+        $meta = $this->em->getClassMetadata(self::CATEGORY);
+        $this->config = $this->listener->getConfiguration($this->em, $meta->name);
+    }
+
+    /**
+     * @test
+     */
+    function checkPathsAndHash()
+    {
+        $category = $this->createCategory();
+        $category->setTitle('1');
+        $category2 = $this->createCategory();
+        $category2->setTitle('2');
+        $category3 = $this->createCategory();
+        $category3->setTitle('3');
+        $category4 = $this->createCategory();
+        $category4->setTitle('4');
+
+        $category2->setParent($category);
+        $category3->setParent($category2);
+
+        $this->em->persist($category4);
+        $this->em->persist($category3);
+        $this->em->persist($category2);
+        $this->em->persist($category);
+        $this->em->flush();
+
+        $this->em->refresh($category);
+        $this->em->refresh($category2);
+        $this->em->refresh($category3);
+        $this->em->refresh($category4);
+
+        $this->assertEquals($this->generatePath(array('1' => $category->getId())), $category->getPath());
+        $this->assertEquals($this->generatePath(array('1' => $category->getId(), '2' => $category2->getId())), $category2->getPath());
+        $this->assertEquals($this->generatePath(array('1' => $category->getId(), '2' => $category2->getId(), '3' => $category3->getId())), $category3->getPath());
+        $this->assertEquals($this->generatePath(array('4' => $category4->getId())), $category4->getPath());
+
+        $this->assertEquals($this->generatePathHash(array('1' => $category->getId())), $category->getPathHash());
+        $this->assertEquals($this->generatePathHash(array('1' => $category->getId(), '2' => $category2->getId())), $category2->getPathHash());
+        $this->assertEquals($this->generatePathHash(array('1' => $category->getId(), '2' => $category2->getId(), '3' => $category3->getId())), $category3->getPathHash());
+        $this->assertEquals($this->generatePathHash(array('4' => $category4->getId())), $category4->getPathHash());
+    }
+
+
+
+
+    public function createCategory()
+    {
+        $class = self::CATEGORY;
+        return new $class;
+    }
+
+    protected function getUsedEntityFixtures()
+    {
+        return array(
+            self::CATEGORY
+        );
+    }
+
+    public function generatePath(array $sources)
+    {
+        $path = '';
+        foreach ($sources as $p => $id) {
+            $path .= $this->config['path_separator'] . $p;
+        }
+
+        return $path;
+    }
+
+    public function generatePathHash(array $sources)
+    {
+
+        return md5($this->generatePath($sources));
+    }
+}

vendor/gedmo/doctrine-extensions/tests/Gedmo/Uploadable/FilenameGenerator/FilenameGeneratorAlphanumericTest.php

 
         $this->assertEquals('meganame-for-a-file-.exe', $generator->generate($filename, $extension));
     }
-}
+}

vendor/gedmo/doctrine-extensions/tests/Gedmo/Uploadable/UploadableEntityTest.php

 
 class FakeFilenameGenerator implements \Gedmo\Uploadable\FilenameGenerator\FilenameGeneratorInterface
 {
-    public static function generate($filename, $extension)
+    public static function generate($filename, $extension, $object = null)
     {
         return '123.txt';
     }
-}
+}

vendor/gedmo/doctrine-extensions/tests/bootstrap.php

 $loader->add('Uploadable\\Fixture', __DIR__ . '/Gedmo');
 $loader->add('Wrapper\\Fixture', __DIR__ . '/Gedmo');
 $loader->add('ReferenceIntegrity\\Fixture', __DIR__ . '/Gedmo');
+$loader->add('References\\Fixture', __DIR__ . '/Gedmo');
 // stubs
 $loader->add('Gedmo\\Uploadable\\Stub', __DIR__);
 

vendor/gedmo/doctrine-extensions/tests/phpunit.xml.dist

         <testsuite name="ReferenceIntegrity Extension">
             <directory suffix="Test.php">./Gedmo/ReferenceIntegrity/</directory>
         </testsuite>
+        <testsuite name="References Extension">
+            <directory suffix="Test.php">./Gedmo/References/</directory>
+        </testsuite>
     </testsuites>
 
     <filter>

vendor/gregwar/image-bundle/Gregwar/ImageBundle

-Subproject commit 3708563d5328aefe643e7c8a5dfe1591163dd2f0
+Subproject commit 55c372324c28c95f311d106ef75c01fb3b58cba3

vendor/jdorn/sql-formatter/README.md

 SqlFormatter
 =============
 
-A lightweight php class for formatting sql statements.
-
-It can automatically indent and add line breaks in addition to syntax highlighting.
+A lightweight php class for formatting sql statements.  Handles automatic
+indentation and syntax highlighting.
 
 History
 ============
 <?php
 require_once('SqlFormatter.php');
 
-$query = "SELECT count(*),`Column1`,`Testing`, `Testing Three` FROM `Table1`
-    WHERE Column1 = 'testing' AND ( (`Column2` = `Column3` OR Column4 >= NOW()) )
-    GROUP BY Column1 ORDER BY Column3 DESC LIMIT 5,10";
-
-echo SqlFormatter::format($query);
-```
-
-Output:
-
-![](http://jdorn.github.com/sql-formatter/format-highlight.png)
-
-Formatting Only
--------------------------
-If you don't want syntax highlighting and only want the indentations and 
-line breaks, pass in false as the second parameter.
-
-This is useful for outputting to error logs or other non-html formats.
-
-```php
-<?php
-echo SqlFormatter::format($query, false);
+echo SqlFormatter::format("SELECT * FROM MyTable LIMIT 10");
 ```
 
-Output:
+Sample output:
 
-![](http://jdorn.github.com/sql-formatter/format.png)
+![](http://github.com/jdorn/sql-formatter/raw/master/examples/SqlFormatterExample.png)
 
 Syntax Highlighting Only
 -------------------------
 
-There is a separate method 'highlight' that preserves all original whitespace
-and just adds syntax highlighting.
+There is also a static method 'highlight' that only does syntax highlighting 
+and preserves all original whitespace.
 
 This is useful for sql that is already well formatted and just needs to be a little
 easier to read.
 
 ```php
 <?php
-echo SqlFormatter::highlight($query);
-```
-
-Output:
-
-![](http://jdorn.github.com/sql-formatter/highlight.png)
-
-Remove Comments
-------------------------
-
-There is a removeComments method that, you guessed it, removes all comments from a query.
-
-```
-    SELECT
-    /* This is another comment
-    On more than one line */
-    Id #This is one final comment
-    as temp, DateCreated as Created FROM MyTable;
-```
-
-```php
-<?php
-echo SqlFormatter::removeComments($query);
-```
-
-Output:
-```
-
-    SELECT
-    
-    Id 
-    as temp, DateCreated as Created FROM MyTable;
+echo SqlFormatter::highlight("SELECT * FROM MyTable LIMIT 10");
 ```
 
 Split SQL String into Queries
 ```
 
 ```php
-<?php
 $queries = SqlFormatter::splitQuery($sql);
 ```
+$queries is now an array of the 4 queries without trailing semicolons.
 
-Result:
+Why not just use explode(';',$sql) or regular expressions?  The following example sql and others like it
+are impossible to split correctly using regular expressions.
 
-1.    `DROP TABLE IF EXISTS MyTable`;
-2.    `CREATE TABLE MyTable ( id int )`;
-3.    `INSERT INTO MyTable (id) VALUES (1),(2),(3),(4)`;
-4.    `SELECT * FROM MyTable`;
-
-### Why Not Regular Expressions?
-
-Why not just use `explode(';', $sql)` or a regular expression?
-
-The following example sql and others like it are _impossible_ to split correctly using regular expressions, no matter how complex.  
-
-```
+```sql
 SELECT ";"; SELECT ";\"; a;";
 SELECT ";
     abc";
 FROM test;
 ```
 
-SqlFormatter breaks the string into tokens instead of using regular expressions and will correctly produce:
-
-1.    `SELECT ";"`;
-2.    `SELECT ";\"; a;"`;
-3.    `SELECT "; abc"`;
-4.    `SELECT a,b #comment;
-FROM test`;
-
-Please note, the splitQuery method will still fail in the following cases:
+The splitQuery method will still fail in the following cases:
 *    The DELIMITER command can be used to change the delimiter from the default ';' to something else.  
-*    The CREATE PROCEDURE command has a ';' in the middle of it
-*    The USE command is not terminated with a ';'
+*    The CREATE PROCEDURE command

vendor/jdorn/sql-formatter/examples/examples.php

         abc\";
     SELECT a,b #comment;
     FROM test;",
-    
-    "
-    -- Drop the table first if it exists
-    DROP TABLE IF EXISTS MyTable;
-
-    -- Create the table
-    CREATE TABLE MyTable ( id int );
-
-    -- Insert values
-    INSERT INTO MyTable (id)
-        VALUES
-        (1),(2),(3),(4);
-
-    -- Done",
 );
 
 // Example statements for removing comments