uppgrade to 2.0.17

app/autoload.php

     'FOS'              => __DIR__.'/../vendor/bundles',
     'Gregwar'          => __DIR__.'/../vendor/bundles',
     'Doctrine\\Common\\DataFixtures' => __DIR__.'/../vendor/doctrine-fixtures/lib',
-    'Doctrine\\Common' => __DIR__.'/../vendor/doctrine-common/lib',
-    'Stof'  => __DIR__.'/../vendor/bundles',
-    'Gedmo' => __DIR__.'/../vendor/gedmo-doctrine-extensions/lib',
-    'WhiteOctober' => __DIR__.'/../vendor/bundles',
-    'Pagerfanta'   => __DIR__.'/../vendor/pagerfanta/src',
-    'Sonata'                         => __DIR__.'/../vendor/bundles',
-    'Knp'                             => array(
-        __DIR__.'/../vendor/bundles',
-        __DIR__.'/../vendor/knp/menu/src',
+    'Doctrine\\Common'               => __DIR__.'/../vendor/doctrine-common/lib',
+    'Stof'             => __DIR__.'/../vendor/bundles',
+    'Gedmo'            => __DIR__.'/../vendor/gedmo-doctrine-extensions/lib',
+    'WhiteOctober'     => __DIR__.'/../vendor/bundles',
+    'Pagerfanta'       => __DIR__.'/../vendor/pagerfanta/src',
+    'Sonata'           => __DIR__.'/../vendor/bundles',
+    'Knp'              => array(
+                         __DIR__.'/../vendor/bundles',
+                         __DIR__.'/../vendor/knp/menu/src',
     ),
 ));
 $loader->registerPrefixes(array(
 
 // Swiftmailer needs a special autoloader to allow
 // the lazy loading of the init file (which is expensive)
-require_once __DIR__.'/../vendor/swiftmailer/lib/classes/Swift.php';
+
+//require_once __DIR__.'/../vendor/swiftmailer/lib/classes/Swift.php';
+require __DIR__.'/../vendor/swiftmailer/lib/swift_required.php';
 Swift::registerAutoload(__DIR__.'/../vendor/swiftmailer/lib/swift_init.php');
 

app/bootstrap.php.cache

 interface ContainerAwareInterface
 {
     
-    function setContainer(ContainerInterface $container = null);
+    public function setContainer(ContainerInterface $container = null);
 }
 }
  
     const SCOPE_PROTOTYPE                = 'prototype';
 
     
-    function set($id, $service, $scope = self::SCOPE_CONTAINER);
+    public function set($id, $service, $scope = self::SCOPE_CONTAINER);
 
     
-    function get($id, $invalidBehavior = self::EXCEPTION_ON_INVALID_REFERENCE);
+    public function get($id, $invalidBehavior = self::EXCEPTION_ON_INVALID_REFERENCE);
 
     
-    function has($id);
+    public function has($id);
 
     
-    function getParameter($name);
+    public function getParameter($name);
 
     
-    function hasParameter($name);
+    public function hasParameter($name);
 
     
-    function setParameter($name, $value);
+    public function setParameter($name, $value);
 
     
-    function enterScope($name);
+    public function enterScope($name);
 
     
-    function leaveScope($name);
+    public function leaveScope($name);
 
     
-    function addScope(ScopeInterface $scope);
+    public function addScope(ScopeInterface $scope);
 
     
-    function hasScope($name);
+    public function hasScope($name);
 
     
-    function isScopeActive($name);
+    public function isScopeActive($name);
 }
 }
  
         $ids = array();
         $r = new \ReflectionClass($this);
         foreach ($r->getMethods() as $method) {
-            if (preg_match('/^get(.+)Service$/', $method->getName(), $match)) {
+            if (preg_match('/^get(.+)Service$/', $method->name, $match)) {
                 $ids[] = self::underscore($match[1]);
             }
         }
     }
 
     
-    static public function camelize($id)
+    public static function camelize($id)
     {
         return preg_replace_callback('/(^|_|\.)+(.)/', function ($match) { return ('.' === $match[1] ? '_' : '').strtoupper($match[2]); }, $id);
     }
 
     
-    static public function underscore($id)
+    public static function underscore($id)
     {
         return strtolower(preg_replace(array('/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'), array('\\1_\\2', '\\1_\\2'), strtr($id, '_', '.')));
     }
     const SUB_REQUEST = 2;
 
     
-    function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true);
+    public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true);
 }
 }
  
 interface KernelInterface extends HttpKernelInterface, \Serializable
 {
     
-    function registerBundles();
+    public function registerBundles();
 
     
-    function registerContainerConfiguration(LoaderInterface $loader);
+    public function registerContainerConfiguration(LoaderInterface $loader);
 
     
-    function boot();
+    public function boot();
 
     
-    function shutdown();
+    public function shutdown();
 
     
-    function getBundles();
+    public function getBundles();
 
     
-    function isClassInActiveBundle($class);
+    public function isClassInActiveBundle($class);
 
     
-    function getBundle($name, $first = true);
+    public function getBundle($name, $first = true);
 
     
-    function locateResource($name, $dir = null, $first = true);
+    public function locateResource($name, $dir = null, $first = true);
 
     
-    function getName();
+    public function getName();
 
     
-    function getEnvironment();
+    public function getEnvironment();
 
     
-    function isDebug();
+    public function isDebug();
 
     
-    function getRootDir();
+    public function getRootDir();
 
     
-    function getContainer();
+    public function getContainer();
 
     
-    function getStartTime();
+    public function getStartTime();
 
     
-    function getCacheDir();
+    public function getCacheDir();
 
     
-    function getLogDir();
+    public function getLogDir();
 }
 }
  
 use Symfony\Component\HttpKernel\Config\FileLocator;
 use Symfony\Component\HttpKernel\DependencyInjection\MergeExtensionConfigurationPass;
 use Symfony\Component\HttpKernel\DependencyInjection\AddClassesToCachePass;
-use Symfony\Component\HttpKernel\DependencyInjection\Extension as DIExtension;
 use Symfony\Component\HttpKernel\Debug\ErrorHandler;
 use Symfony\Component\HttpKernel\Debug\ExceptionHandler;
 use Symfony\Component\Config\Loader\LoaderResolver;
     protected $startTime;
     protected $classes;
 
-    const VERSION = '2.0.13';
+    const VERSION         = '2.0.17';
+    const VERSION_ID      = '20017';
+    const MAJOR_VERSION   = '2';
+    const MINOR_VERSION   = '0';
+    const RELEASE_VERSION = '17';
+    const EXTRA_VERSION   = '';
 
     
     public function __construct($environment, $debug)
     {
         if (null === $this->rootDir) {
             $r = new \ReflectionObject($this);
-            $this->rootDir = dirname($r->getFileName());
+            $this->rootDir = str_replace('\\', '/', dirname($r->getFileName()));
         }
 
         return $this->rootDir;
     }
 
     
-    static public function stripComments($source)
+    public static function stripComments($source)
     {
         if (!function_exists('token_get_all')) {
             return $source;
 
 class ClassCollectionLoader
 {
-    static private $loaded;
+    private static $loaded;
 
     
-    static public function load($classes, $cacheDir, $name, $autoReload, $adaptive = false, $extension = '.php')
+    public static function load($classes, $cacheDir, $name, $autoReload, $adaptive = false, $extension = '.php')
     {
                 if (isset(self::$loaded[$name])) {
             return;
     }
 
     
-    static public function fixNamespaceDeclarations($source)
+    public static function fixNamespaceDeclarations($source)
     {
         if (!function_exists('token_get_all')) {
             return $source;
     }
 
     
-    static private function writeCacheFile($file, $content)
+    private static function writeCacheFile($file, $content)
     {
         $tmpFile = tempnam(dirname($file), basename($file));
         if (false !== @file_put_contents($tmpFile, $content) && @rename($tmpFile, $file)) {
     }
 
     
-    static private function stripComments($source)
+    private static function stripComments($source)
     {
         if (!function_exists('token_get_all')) {
             return $source;
 interface BundleInterface
 {
     
-    function boot();
+    public function boot();
 
     
-    function shutdown();
+    public function shutdown();
 
     
-    function build(ContainerBuilder $container);
+    public function build(ContainerBuilder $container);
 
     
-    function getContainerExtension();
+    public function getContainerExtension();
 
     
-    function getParent();
+    public function getParent();
 
     
-    function getName();
+    public function getName();
 
     
-    function getNamespace();
+    public function getNamespace();
 
     
-    function getPath();
+    public function getPath();
 }
 }
  

deps

 [symfony]
     git=http://github.com/symfony/symfony.git
-    version=v2.0.13
+    version=v2.0.17
 
 [twig]
     git=http://github.com/fabpot/Twig.git
-    version=v1.7.0
+    version=v1.9.2
 
 [monolog]
     git=http://github.com/Seldaek/monolog.git
 
 [doctrine-dbal]
     git=http://github.com/doctrine/dbal.git
-    version=2.1.6
+    version=2.1.7
 
 [doctrine]
     git=http://github.com/doctrine/doctrine2.git
-    version=2.1.6
+    version=2.1.7
 
 [swiftmailer]
     git=http://github.com/swiftmailer/swiftmailer.git
-    version=v4.1.7
+    version=v4.2.1
 
 [assetic]
     git=http://github.com/kriswallsmith/assetic.git
 [AsseticBundle]
     git=http://github.com/symfony/AsseticBundle.git
     target=/bundles/Symfony/Bundle/AsseticBundle
-    version=v1.0.1
+    version=origin/2.0

deps.lock

-symfony v2.0.13
-twig v1.7.0
+symfony v2.0.17
+twig v1.9.2
 monolog 1.0.2
 doctrine-common 2.1.4
-doctrine-dbal 2.1.6
-doctrine 2.1.6
-swiftmailer v4.1.7
+doctrine-dbal 2.1.7
+doctrine 2.1.7
+swiftmailer v4.2.1
 assetic v1.0.3
-twig-extensions 446d870272cd87a720e95242eade38a2acf56eaa
+twig-extensions feb6d3f10c411e2631997c0a905aa581c80305c1
 metadata 1.0.0
-SensioFrameworkExtraBundle cb61b92ed55241d93ed9726bc3f5f47c7d2ce8fe
+SensioFrameworkExtraBundle v2.0.17
 JMSSecurityExtraBundle e752f888c51425f71382c056961f10f2be642102
-SensioDistributionBundle 20b66a408084ad8752f98e50f10533f5245310bf
-SensioGeneratorBundle b1ccb78c1743f30817b0fce9bb5c6baff6ed7bf8
-AsseticBundle v1.0.1
+SensioDistributionBundle v2.0.17
+SensioGeneratorBundle v2.0.17
+AsseticBundle 6f15728c1aefa5246caa83730e3dbf70b0d46052

vendor/bundles/Sensio/Bundle/DistributionBundle/Resources/bin/build.sh

 
 DIR=`php -r "echo realpath(dirname(\\$_SERVER['argv'][0]));"`
 cd $DIR
-VERSION=`grep 'VERSION' vendor/symfony/src/Symfony/Component/HttpKernel/Kernel.php | sed -E "s/.*'(.+)'.*/\1/g"`
+VERSION=`grep ' VERSION ' vendor/symfony/src/Symfony/Component/HttpKernel/Kernel.php | sed -E "s/.*'(.+)'.*/\1/g"`
 
 if [ ! -d "$DIR/build" ]; then
     mkdir -p $DIR/build

vendor/bundles/Sensio/Bundle/FrameworkExtraBundle/Request/ParamConverter/DoctrineParamConverter.php

 
         $options = $this->getOptions($configuration);
 
-        if (false === isset($options['entity_manager'])) { 
-            return false; 
-        }
-
         // Doctrine Entity?
         try {
             $this->registry->getEntityManager($options['entity_manager'])->getClassMetadata($configuration->getClass());

vendor/bundles/Sensio/Bundle/FrameworkExtraBundle/Resources/doc/annotations/cache.rst

     {
     }
 
-You can also use the annotation on a class to define caching for all methods::
-
-    /**
-     * @Cache(expires="tomorrow")
-     */
-    class BlogController extends Controller
-    {
-    }
-
-When there is a conflict between the class configuration and the method
-configuration, the latter overrides the former::
-
-    /**
-     * @Cache(expires="tomorrow")
-     */
-    class BlogController extends Controller
-    {
-        /**
-         * @Cache(expires="+2 days")
-         */
-        public function indexAction()
-        {
-        }
-    }
-
 Attributes
 ----------
 

vendor/bundles/Sensio/Bundle/FrameworkExtraBundle/Resources/doc/annotations/converters.rst

 
 .. tip::
 
-   Use the ``DoctrineConverter`` class as a template for your own converters.
+   Use the ``DoctrineParamConverter`` class as a template for your own converters.

vendor/bundles/Sensio/Bundle/FrameworkExtraBundle/composer.json

         }
     ],
     "require": {
-        "symfony/framework-bundle": "2.*",
-        "doctrine/common": ">=2.0"
+        "symfony/framework-bundle": "2.0.*",
+        "doctrine/common": ">=2.1,<2.4-dev"
     },
     "autoload": {
         "psr-0": { "Sensio\\Bundle\\FrameworkExtraBundle": "" }

vendor/bundles/Sensio/Bundle/GeneratorBundle/Command/GenerateDoctrineEntityCommand.php

 <info>php app/console doctrine:generate:entity --entity=AcmeBlogBundle:Blog/Post --format=yml</info>
 
 To deactivate the interaction mode, simply use the `--no-interaction` option
-whitout forgetting to pass all needed options:
+without forgetting to pass all needed options:
 
 <info>php app/console doctrine:generate:entity --entity=AcmeBlogBundle:Blog/Post --format=annotation --fields="title:string(255) body:text" --with-repository --no-interaction</info>
 EOT

vendor/bundles/Sensio/Bundle/GeneratorBundle/Resources/skeleton/crud/views/index.html.twig

 
         {%- elseif metadata.type in ['date', 'datetime'] %}
 
-            <td>{{ '{% if entity.'~ field|replace({'_': ''}) ~' %}{{ entity.'~ field|replace({'_': ''}) ~'|date(\'Y-m-d H:i:s\') }}{% endif%}' }}</td>
+            <td>{{ '{% if entity.'~ field|replace({'_': ''}) ~' %}{{ entity.'~ field|replace({'_': ''}) ~'|date(\'Y-m-d H:i:s\') }}{% endif %}' }}</td>
 
         {%- else %}
 

vendor/bundles/Sensio/Bundle/GeneratorBundle/composer.json

         }
     ],
     "require": {
-        "symfony/framework-bundle": "2.*"
-    },
-    "recommend": {
-        "symfony/doctrine-bundle": "2.*"
+        "symfony/framework-bundle": "2.0.*",
+        "symfony/doctrine-bundle": "2.0.*"
     },
     "autoload": {
         "psr-0": { "Sensio\\Bundle\\GeneratorBundle": "" }

vendor/bundles/Symfony/Bundle/AsseticBundle/AsseticBundle.php

 
 namespace Symfony\Bundle\AsseticBundle;
 
+use Symfony\Bundle\AsseticBundle\DependencyInjection\Compiler\TemplateResourcesPass;
 use Symfony\Bundle\AsseticBundle\DependencyInjection\Compiler\AssetFactoryPass;
 use Symfony\Bundle\AsseticBundle\DependencyInjection\Compiler\AssetManagerPass;
 use Symfony\Bundle\AsseticBundle\DependencyInjection\Compiler\CheckYuiFilterPass;
     {
         parent::build($container);
 
+        $container->addCompilerPass(new TemplateResourcesPass());
         $container->addCompilerPass(new CheckClosureFilterPass());
         $container->addCompilerPass(new CheckCssEmbedFilterPass());
         $container->addCompilerPass(new CheckYuiFilterPass());

vendor/bundles/Symfony/Bundle/AsseticBundle/Command/DumpCommand.php

     protected function execute(InputInterface $input, OutputInterface $output)
     {
         $output->writeln(sprintf('Dumping all <comment>%s</comment> assets.', $input->getOption('env')));
-        $output->writeln(sprintf('Debug mode is <comment>%s</comment>.', $input->getOption('no-debug') ? 'off' : 'on'));
+        $output->writeln(sprintf('Debug mode is <comment>%s</comment>.', $this->am->isDebug() ? 'on' : 'off'));
         $output->writeln('');
 
         if (!$input->getOption('watch')) {

vendor/bundles/Symfony/Bundle/AsseticBundle/Controller/AsseticController.php

         }
 
         $response = $this->createResponse();
+        $response->setExpires(new \DateTime());
 
         // last-modified
         if (null !== $lastModified = $asset->getLastModified()) {

vendor/bundles/Symfony/Bundle/AsseticBundle/DependencyInjection/AsseticExtension.php

 
         $container->setParameter('assetic.java.bin', $config['java']);
         $container->setParameter('assetic.node.bin', $config['node']);
+        $container->setParameter('assetic.ruby.bin', $config['ruby']);
         $container->setParameter('assetic.sass.bin', $config['sass']);
 
         // register formulae
             $loader->load('asset_writer.xml');
         }
 
-        // bundle and kernel resources
-        foreach ($container->getParameterBag()->resolveValue($config['bundles']) as $bundle) {
-            $rc = new \ReflectionClass($bundles[$bundle]);
-            foreach (array('twig', 'php') as $engine) {
-                $container->setDefinition(
-                    'assetic.'.$engine.'_directory_resource.'.$bundle,
-                    new DirectoryResourceDefinition($bundle, $engine, array(
-                        $container->getParameter('kernel.root_dir').'/Resources/'.$bundle.'/views',
-                        dirname($rc->getFileName()).'/Resources/views',
-                    ))
-                );
-            }
-        }
-        foreach (array('twig', 'php') as $engine) {
-            $container->setDefinition(
-                'assetic.'.$engine.'_directory_resource.kernel',
-                new DirectoryResourceDefinition('', $engine, array($container->getParameter('kernel.root_dir').'/Resources/views'))
-            );
-        }
+        $container->setParameter('assetic.bundles', $config['bundles']);
     }
 
     /**

vendor/bundles/Symfony/Bundle/AsseticBundle/DependencyInjection/Compiler/TemplateResourcesPass.php

+<?php
+
+/*
+ * This file is part of the Symfony framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Symfony\Bundle\AsseticBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Bundle\AsseticBundle\DependencyInjection\DirectoryResourceDefinition;
+
+/**
+ * This pass adds directory resources to scan for assetic assets.
+ *
+ * @author Kris Wallsmith <kris@symfony.com>
+ * @author Lukas Kahwe Smith <smith@pooteeweet.org>
+ */
+class TemplateResourcesPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('assetic.asset_manager')) {
+            return;
+        }
+
+        $engines = $container->getParameter('templating.engines');
+
+        // bundle and kernel resources
+        $bundles = $container->getParameter('kernel.bundles');
+        $asseticBundles = $container->getParameterBag()->resolveValue($container->getParameter('assetic.bundles'));
+        foreach ($asseticBundles as $bundleName) {
+            $rc = new \ReflectionClass($bundles[$bundleName]);
+            foreach ($engines as $engine) {
+                $this->setBundleDirectoryResources($container, $engine, dirname($rc->getFileName()), $bundleName);
+            }
+        }
+
+        foreach ($engines as $engine) {
+            $this->setAppDirectoryResources($container, $engine);
+        }
+    }
+
+    protected function setBundleDirectoryResources(ContainerBuilder $container, $engine, $bundleDirName, $bundleName)
+    {
+        $container->setDefinition(
+            'assetic.'.$engine.'_directory_resource.'.$bundleName,
+            new DirectoryResourceDefinition($bundleName, $engine, array(
+                $container->getParameter('kernel.root_dir').'/Resources/'.$bundleName.'/views',
+                $bundleDirName.'/Resources/views',
+            ))
+        );
+    }
+
+    protected function setAppDirectoryResources(ContainerBuilder $container, $engine)
+    {
+        $container->setDefinition(
+            'assetic.'.$engine.'_directory_resource.kernel',
+            new DirectoryResourceDefinition('', $engine, array($container->getParameter('kernel.root_dir').'/Resources/views'))
+        );
+    }
+}

vendor/bundles/Symfony/Bundle/AsseticBundle/DependencyInjection/DirectoryResourceDefinition.php

             ->addArgument(new Reference('templating.loader'))
             ->addArgument($bundle)
             ->addArgument($dir)
-            ->addArgument('/^[^.]+\.[^.]+\.'.$engine.'$/')
+            ->addArgument('/\.[^.]+\.'.$engine.'$/')
             ->setPublic(false)
         ;
     }

vendor/bundles/Symfony/Bundle/AsseticBundle/DependencyInjection/MainConfiguration.php

                 ->booleanNode('dump_on_warmup')->end()
                 ->scalarNode('java')->defaultValue(function() use($finder) { return $finder->find('java', '/usr/bin/java'); })->end()
                 ->scalarNode('node')->defaultValue(function() use($finder) { return $finder->find('node', '/usr/bin/node'); })->end()
+                ->scalarNode('ruby')->defaultValue(function() use($finder) { return $finder->find('ruby', '/usr/bin/ruby'); })->end()
                 ->scalarNode('sass')->defaultValue(function() use($finder) { return $finder->find('sass', '/usr/bin/sass'); })->end()
             ->end()
 

vendor/bundles/Symfony/Bundle/AsseticBundle/Factory/Resource/FileResource.php

 
     public function getContent()
     {
-        return $this->loader->load($this->getTemplate())->getContent();
+        $templateReference = $this->getTemplate();
+        $fileResource = $this->loader->load($templateReference);
+
+        if (!$fileResource) {
+            throw new \InvalidArgumentException(sprintf('Unable to find template "%s".', $templateReference));
+        }
+
+        return $fileResource->getContent();
     }
 
     public function __toString()
     {
         $parts = explode('/', strtr($file, '\\', '/'));
         $elements = explode('.', array_pop($parts));
+        $engine = array_pop($elements);
+        $format = array_pop($elements);
+        $name = implode('.', $elements);
 
-        return new TemplateReference($bundle, implode('/', $parts), $elements[0], $elements[1], $elements[2]);
+        return new TemplateReference($bundle, implode('/', $parts), $name, $format, $engine);
     }
 }

vendor/bundles/Symfony/Bundle/AsseticBundle/Resources/config/assetic.xml

 
         <parameter key="assetic.node.paths" type="collection"></parameter>
         <parameter key="assetic.cache_dir">%kernel.cache_dir%/assetic</parameter>
+        <parameter key="assetic.bundles" type="collection"></parameter>
     </parameters>
 
     <services>

vendor/bundles/Symfony/Bundle/AsseticBundle/Resources/config/filters/sprockets.xml

 
     <parameters>
         <parameter key="assetic.filter.sprockets.class">Assetic\Filter\SprocketsFilter</parameter>
-        <parameter key="assetic.filter.sprockets.bin">/usr/bin/sprocketize</parameter>
+        <parameter key="assetic.filter.sprockets.lib">null</parameter>
+        <parameter key="assetic.filter.sprockets.ruby">%assetic.ruby.bin%</parameter>
         <parameter key="assetic.filter.sprockets.asset_root">%assetic.write_to%</parameter>
         <parameter key="assetic.filter.sprockets.include_dirs" type="collection" />
     </parameters>
     <services>
         <service id="assetic.filter.sprockets" class="%assetic.filter.sprockets.class%">
             <tag name="assetic.filter" alias="sprockets" />
-            <argument>%assetic.filter.sprockets.bin%</argument>
+            <argument>%assetic.filter.sprockets.lib%</argument>
+            <argument>%assetic.filter.sprockets.ruby%</argument>
             <call method="setAssetRoot"><argument>%assetic.filter.sprockets.asset_root%</argument></call>
         </service>
     </services>

vendor/bundles/Symfony/Bundle/AsseticBundle/composer.json

+{
+    "name": "symfony/assetic-bundle",
+    "version": "2.0.2",
+    "description": "Integrates Assetic into Symfony2",
+    "keywords": ["assets", "compression", "minification"],
+    "homepage": "https://github.com/symfony/AsseticBundle",
+    "type": "symfony-bundle",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Kris Wallsmith",
+            "email": "kris.wallsmith@gmail.com",
+            "homepage": "http://kriswallsmith.net/"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.0",
+        "symfony/framework-bundle": "2.0.*",
+        "kriswallsmith/assetic": "1.0.*"
+    },
+    "suggest": {
+        "symfony/twig-bundle": "2.0.*"
+    },
+    "autoload": {
+        "psr-0": { "Symfony\\Bundle\\AsseticBundle": "" }
+    },
+    "target-dir": "Symfony/Bundle/AsseticBundle"
+}

vendor/doctrine-dbal/.gitignore

-build.properties
 build/
 logs/
 reports/

vendor/doctrine-dbal/.gitmodules

 [submodule "lib/vendor/Symfony/Component/Console"]
 	path = lib/vendor/Symfony/Component/Console
 	url = git://github.com/symfony/Console.git
+[submodule "lib/vendor/doctrine-build-common"]
+	path = lib/vendor/doctrine-build-common
+	url = git://github.com/doctrine/doctrine-build-common.git

vendor/doctrine-dbal/build.properties

+# Project Name
+project.name=DoctrineDBAL
+
+# Dependency minimum versions
+dependencies.common=2.0.1
+dependencies.sfconsole=2.0.0
+
+# Version class and file
+project.version_class = Doctrine\DBAL\Version
+project.version_file = lib/Doctrine/DBAL/Version.php

vendor/doctrine-dbal/build.properties.dev

-version_name=2.0.2
-stability=stable
-build.dir=build
-dist.dir=dist
-report.dir=reports
-project.pirum_dir=
-project.download_dir=
-log.archive.dir=logs
-svn.path=/usr/bin/svn
-test.phpunit_configuration_file=
-test.phpunit_generate_coverage=0
-test.pmd_reports=0
-test.pdepend_exec=
-test.phpmd_exec=
-dependencies.common=2.0.1
-dependencies.sfconsole=2.0.0

vendor/doctrine-dbal/build.xml

 <?xml version="1.0"?>
-
-<!--
-    Doctrine 2 build file.
--->
-
-<project name="Doctrine DBAL" default="build" basedir=".">
+<project name="DoctrineDBAL" default="build" basedir=".">
     <taskdef classname="phing.tasks.ext.d51PearPkg2Task" name="d51pearpkg2" />
+    <import file="${project.basedir}/lib/vendor/doctrine-build-common/packaging.xml" />
 
     <property file="build.properties" />
 
     <!--
       Fileset for source of the Symfony YAML and Console components.
     -->
-    <fileset id="symfony-sources" dir="./lib/vendor">
+    <fileset id="external-sources" dir="./lib/vendor">
         <include name="Symfony/Component**"/>
     </fileset>
 
-    <!--
-        Clean the directory for the next build.
-    -->
-    <target name="clean">
-        <available file="./build.properties" property="build_properties_exist" value="true"/>
-        <fail unless="build_properties_exist" message="The build.properties file is missing." />
-
-        <delete dir="${build.dir}" includeemptydirs="true" />
-        <delete dir="${dist.dir}" includeemptydirs="true" />
-        <delete dir="${report.dir}" includeemptydirs="true" />
-    </target>
-
-    <!--
-        Prepare the new build directories after cleaning
-    -->
-    <target name="prepare" depends="clean">
-        <echo msg="Creating build directory: ${build.dir}" />
-        <mkdir dir="${build.dir}" />
-        <echo msg="Creating distribution directory: ${dist.dir}" />
-        <mkdir dir="${dist.dir}" />
-        <echo msg="Creating report directory: ${report.dir}" />
-        <mkdir dir="${report.dir}" />
-        <mkdir dir="${build.dir}/logs"/>
-        <mkdir dir="${report.dir}/tests"/>
-    </target>
-
-    <!--
-        Builds DBAL package, preparing it for distribution.
-    -->
-    <target name="build-dbal" depends="prepare">
-        <exec command="grep '${version}' ${project.basedir}/lib/Doctrine/DBAL/Version.php" checkreturn="true"/>
-        <copy todir="${build.dir}/doctrine-dbal">
+    <target name="copy-files" depends="prepare">
+        <echo msg="Checking for ${version} in ${project.version_file}" />
+        <exec command="grep '${version}' ${project.basedir}/${project.version_file}" checkreturn="true"/>
+        <copy todir="${build.dir}/${project.name}-${version}">
             <fileset refid="shared-artifacts"/>
         </copy>
-        <copy todir="${build.dir}/doctrine-dbal">
+        <copy todir="${build.dir}/${project.name}-${version}">
             <fileset refid="common-sources"/>
             <fileset refid="dbal-sources"/>
         </copy>
-        <copy todir="${build.dir}/doctrine-dbal/Doctrine">
-            <fileset refid="symfony-sources"/>
+        <copy todir="${build.dir}/${project.name}-${version}/Doctrine">
+            <fileset refid="external-sources"/>
         </copy>
-        <copy todir="${build.dir}/doctrine-dbal/bin">
+        <copy todir="${build.dir}/${project.name}-${version}/bin">
             <fileset refid="bin-scripts"/>
         </copy>
-        <exec command="sed 's/${version}-DEV/${version}/' ${build.dir}/doctrine-dbal/Doctrine/DBAL/Version.php > ${build.dir}/doctrine-dbal/Doctrine/DBAL/Version2.php" passthru="true" />
-        <exec command="mv ${build.dir}/doctrine-dbal/Doctrine/DBAL/Version2.php ${build.dir}/doctrine-dbal/Doctrine/DBAL/Version.php" passthru="true" />
-    </target>
-
-    <target name="build" depends="test,build-dbal"/>
-
-    <!--
-        Runs the full test suite.
-    -->
-    <target name="test" depends="prepare">
-        <if><equals arg1="${test.phpunit_generate_coverage}" arg2="1" />
-            <then>
-                <property name="test.phpunit_coverage_option" value="--coverage-clover ${build.dir}/logs/clover.xml" />
-            </then>
-            <else>
-                <property name="test.phpunit_coverage_option" value="" />
-            </else>
-        </if>
-
-        <if><equals arg1="${test.phpunit_configuration_file}" arg2="" />
-            <then>
-                <property name="test.phpunit_configuration_option" value="" />
-            </then>
-            <else>
-                <property name="test.phpunit_configuration_option" value="--configuration ${test.phpunit_configuration_file}" />
-            </else>
-        </if>
-
-        <exec command="phpunit ${test.phpunit_configuration_option} ${test.phpunit_coverage_option} --log-junit ../${build.dir}/logs/testsuites.xml Doctrine/Tests/AllTests.php" dir="./tests" />
-        <phpunitreport infile="${build.dir}/logs/testsuites.xml" format="frames" todir="${report.dir}/tests" />
-
-        <tstamp/>
-        <copy file="${build.dir}/logs/testsuites.xml" tofile="${log.archive.dir}/latest/log.xml" overwrite="true"/>
-
-        <if><equals arg1="${test.pmd_reports}" arg2="1" />
-            <then>
-                <exec command="${test.pdepend_exec} --jdepend-xml=${build.dir}/logs/jdepend.xml ./lib/Doctrine" />
-                <exec command="${test.phpmd_exec} ./lib/Doctrine xml codesize --reportfile ${build.dir}/logs/phpmd.xml" />
-
-                <copy file="${build.dir}/logs/jdepend.xml" tofile="${log.archive.dir}/latest/jdepend.xml" overwrite="true"/>
-                <copy file="${build.dir}/logs/phpmd.xml" tofile="${log.archive.dir}/latest/phpmd.xml" overwrite="true"/>
-            </then>
-        </if>
     </target>
 
-    <!--
-        Builds distributable PEAR packages.
-    -->
-    <target name="build-packages" depends="build-dbal">
-        <d51pearpkg2 baseinstalldir="/" dir="${build.dir}/doctrine-dbal">
-           <name>DoctrineDBAL</name>
-           <summary>Doctrine Database Abstraction Layer</summary>
-           <channel>pear.doctrine-project.org</channel>
-           <description>The Doctrine DBAL package is the database abstraction layer used to power the ORM package.</description>
-           <lead user="jwage" name="Jonathan H. Wage" email="jonwage@gmail.com" />
-           <lead user="guilhermeblanco" name="Guilherme Blanco" email="guilhermeblanco@gmail.com" />
-           <lead user="romanb" name="Roman Borschel" email="roman@code-factory.org" />
-           <lead user="beberlei" name="Benjamin Eberlei" email="kontakt@beberlei.de" />
-           <license>LGPL</license>
-           <version release="${version}" api="${version}" />
-           <stability release="${stability}" api="${stability}" />
-           <notes>-</notes>
-           <dependencies>
-               <php minimum_version="5.3.2" />
-               <pear minimum_version="1.6.0" recommended_version="1.6.1" />
-               <package name="DoctrineCommon" channel="pear.doctrine-project.org" minimum_version="${dependencies.common}" />
-               <!-- Doctrine Symfony Console PEAR package is generated in ORM build.xml process -->
-               <package name="DoctrineSymfonyConsole" channel="pear.doctrine-project.org" minimum_version="${dependencies.sfconsole}" />
-           </dependencies>
-           <dirroles key="bin">script</dirroles>
-           <ignore>Doctrine/Common/</ignore>
-           <ignore>Doctrine/Symfony/</ignore>
-           <release>
+    <target name="define-pear-package" depends="copy-files">
+        <d51pearpkg2 baseinstalldir="/" dir="${build.dir}/${project.name}-${version}">
+            <name>${project.name}</name>
+            <summary>Doctrine Database Abstraction Layer</summary>
+            <channel>pear.doctrine-project.org</channel>
+            <description>The Doctrine DBAL package is the database abstraction layer used to power the ORM package.</description>
+            <lead user="jwage" name="Jonathan H. Wage" email="jonwage@gmail.com" />
+            <lead user="guilhermeblanco" name="Guilherme Blanco" email="guilhermeblanco@gmail.com" />
+            <lead user="romanb" name="Roman Borschel" email="roman@code-factory.org" />
+            <lead user="beberlei" name="Benjamin Eberlei" email="kontakt@beberlei.de" />
+            <license>LGPL</license>
+            <version release="${pear.version}" api="${pear.version}" />
+            <stability release="${pear.stability}" api="${pear.stability}" />
+            <notes>-</notes>
+            <dependencies>
+                <php minimum_version="5.3.2" />
+                <pear minimum_version="1.6.0" recommended_version="1.6.1" />
+                <package name="DoctrineCommon" channel="pear.doctrine-project.org" minimum_version="${dependencies.common}" />
+                <package name="Console" channel="pear.symfony.com" minimum_version="${dependencies.sfconsole}" />
+            </dependencies>
+            <dirroles key="bin">script</dirroles>
+            <ignore>Doctrine/Common/</ignore>
+            <ignore>Doctrine/Symfony/</ignore>
+            <release>
                 <install as="doctrine-dbal" name="bin/doctrine-dbal" />
                 <install as="doctrine-dbal.php" name="bin/doctrine-dbal.php" />
-           </release>
+            </release>
         </d51pearpkg2>
-        <exec command="pear package" dir="${build.dir}/doctrine-dbal" passthru="true" />
-        <exec command="mv DoctrineDBAL-${version}.tgz ../../dist" dir="${build.dir}/doctrine-dbal" passthru="true" />
-        <tar destfile="dist/DoctrineDBAL-${version}-full.tar.gz" compression="gzip" basedir="${build.dir}">
-            <fileset dir="${build.dir}">
-                <include name="**/**" />
-                <exclude name="logs/" />
-            </fileset>
-        </tar>
     </target>
-
-    <target name="git-tag">
-        <exec command="grep '${version}' ${project.basedir}/lib/Doctrine/DBAL/Version.php" checkreturn="true"/>
-        <exec command="git tag -a ${version}" passthru="true" />
-    </target>
-
-    <target name="pirum-release">
-        <exec command="sudo pirum add ${project.pirum_dir} ${project.basedir}/dist/DoctrineDBAL-${version}.tgz" dir="."  passthru="true" />
-        <exec command="sudo pirum build ${project.pirum_dir}" passthru="true" />
-    </target>
-
-    <target name="distribute-download">
-        <copy file="dist/DoctrineDBAL-${version}-full.tar.gz" todir="${project.download_dir}" />
-    </target>
-
-    <target name="update-dev-version">
-        <exec command="grep '${version}' ${project.basedir}/lib/Doctrine/DBAL/Version.php" checkreturn="true"/>
-        <propertyprompt propertyName="next_version" defaultValue="${version}" promptText="Enter next version string (without -DEV)" />
-        <exec command="sed 's/${version}-DEV/${next_version}-DEV/' ${project.basedir}/lib/Doctrine/DBAL/Version.php > ${project.basedir}/lib/Doctrine/DBAL/Version2.php" passthru="true" />
-        <exec command="mv ${project.basedir}/lib/Doctrine/DBAL/Version2.php ${project.basedir}/lib/Doctrine/DBAL/Version.php" passthru="true" />
-        <exec command="git add ${project.basedir}/lib/Doctrine/DBAL/Version.php" passthru="true" />
-        <exec command="git commit -m 'Bump Dev Version to ${next_version}'" passthru="true" />
-    </target>
-
-    <target name="release" depends="git-tag,build-packages,distribute-download,pirum-release,update-dev-version" />
 </project>

vendor/doctrine-dbal/composer.json

 {
     "name": "doctrine/dbal",
-    "type": "library",
+    "type": "library","version":"2.1.7",
     "description": "Database Abstraction Layer",
     "keywords": ["dbal", "database", "persistence", "queryobject"],
     "homepage": "http://www.doctrine-project.org",

vendor/doctrine-dbal/lib/Doctrine/DBAL/Driver/PDOSqlsrv/Driver.php

         if (isset($params['port']) && !empty($params['port'])) {
             $dsn .= ',' . $params['port'];
         }
-		
-		if (isset($params['dbname'])) {
-			$dsn .= ';Database=' .  $params['dbname'];
-		}
-		
+
+        if (isset($params['dbname'])) {;
+            $dsn .= ';Database=' .  $params['dbname'];
+        }
+
+        if (isset($params['MultipleActiveResultSets'])) {
+            $dsn .= '; MultipleActiveResultSets=' . ($params['MultipleActiveResultSets'] ? 'true' : 'false');
+        }
+
         return $dsn;
     }
 
         $params = $conn->getParams();
         return $params['dbname'];
     }
-}
+}

vendor/doctrine-dbal/lib/Doctrine/DBAL/SQLParserUtils.php

                 } else {
                     $name = "";
                     // TODO: Something faster/better to match this than regex?
-                    for ($j = $i; ($j < $stmtLen && preg_match('(([:a-zA-Z0-9]{1}))', $statement[$j])); $j++) {
+                    for ($j = $i; ($j < $stmtLen && preg_match('(([:a-zA-Z0-9_]{1}))', $statement[$j])); $j++) {
                         $name .= $statement[$j];
                     }
                     $paramMap[$name][] = $i; // named parameters can be duplicated!
         $bindIndex = -1;
         foreach ($types AS $name => $type) {
             ++$bindIndex;
-            if ($type === Connection::PARAM_INT_ARRAY || $type == Connection::PARAM_STR_ARRAY) {
+            if ($type === Connection::PARAM_INT_ARRAY || $type === Connection::PARAM_STR_ARRAY) {
                 if ($isPositional) {
                     $name = $bindIndex;
                 }
         
         return array($query, $params, $types);
     }
-}
+}

vendor/doctrine-dbal/lib/Doctrine/DBAL/Schema/MySqlSchemaManager.php

             case 'mediumblob':
             case 'longblob':
             case 'blob':
-            case 'binary':
-            case 'varbinary':
             case 'year':
                 $length = null;
                 break;

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

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

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Driver/OCI8/OCI8StatementTest.php

  
 class OCI8StatementTest extends \Doctrine\Tests\DbalTestCase
 {
+    public function setUp()
+    {
+        if ( ! extension_loaded('oci8')) {
+            $this->markTestSkipped();
+        }
+    }
 
     protected function getMockOCI8Statement()
     {

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/Functional/TemporaryTableTest.php

     {
         parent::setUp();
         try {
-            $this->_conn->exec($this->_conn->getDatabasePlatform()->getDropTableSQL("non_temporary"));
+            $this->_conn->exec($this->_conn->getDatabasePlatform()->getDropTableSQL("nontemporary"));
         } catch(\Exception $e) {
 
         }
     }
 
+    public function tearDown()
+    {
+        if ($this->_conn) {
+            try {
+                $tempTable = $this->_conn->getDatabasePlatform()->getTemporaryTableName("temporary");
+                $this->_conn->exec($this->_conn->getDatabasePlatform()->getDropTemporaryTableSQL($tempTable));
+            } catch(\Exception $e) { }
+        }
+    }
+
     /**
      * @group DDC-1337
      * @return void
      */
-    public function testDropTemporaryTableNotAbortsTransaction()
+    public function testDropTemporaryTableNotAutoCommitTransaction()
     {
         $platform = $this->_conn->getDatabasePlatform();
         $columnDefinitions = array("id" => array("type" => Type::getType("integer"), "notnull" => true));
         $tempTable = $platform->getTemporaryTableName("temporary");
 
-        $tempTableSQL = $platform->getCreateTemporaryTableSnippetSQL() . ' ' . $tempTable . ' ('
+        $createTempTableSQL = $platform->getCreateTemporaryTableSnippetSQL() . ' ' . $tempTable . ' ('
                 . $platform->getColumnDeclarationListSQL($columnDefinitions) . ')';
+        $this->_conn->executeUpdate($createTempTableSQL);
 
-        $table = new Table("non_temporary");
+        $table = new Table("nontemporary");
         $table->addColumn("id", "integer");
+        $table->setPrimaryKey(array('id'));
 
-        $this->_conn->getSchemaManager()->createTable($table);
-        $this->_conn->beginTransaction();
-        $this->_conn->insert("non_temporary", array("id" => 1));
+        foreach ($platform->getCreateTableSQL($table) AS $sql) {
+            $this->_conn->executeQuery($sql);
+        }
 
-        $this->_conn->exec($tempTableSQL);
+        $this->_conn->beginTransaction();
+        $this->_conn->insert("nontemporary", array("id" => 1));
         $this->_conn->exec($platform->getDropTemporaryTableSQL($tempTable));
-
-        $this->_conn->insert("non_temporary", array("id" => 2));
+        $this->_conn->insert("nontemporary", array("id" => 2));
 
         $this->_conn->rollback();
 
-        $rows = $this->_conn->fetchAll('SELECT * FROM non_temporary');
-        $this->assertEquals(array(), $rows);
+        $rows = $this->_conn->fetchAll('SELECT * FROM nontemporary');
+        $this->assertEquals(array(), $rows, "In an event of an error this result has one row, because of an implicit commit.");
     }
 
     /**
      * @group DDC-1337
      * @return void
      */
-    public function testCreateTemporaryTableNotAbortsTransaction()
+    public function testCreateTemporaryTableNotAutoCommitTransaction()
     {
         $platform = $this->_conn->getDatabasePlatform();
         $columnDefinitions = array("id" => array("type" => Type::getType("integer"), "notnull" => true));
         $tempTable = $platform->getTemporaryTableName("temporary");
 
-        $tempTableSQL = $platform->getCreateTemporaryTableSnippetSQL() . ' ' . $tempTable . ' ('
+        $createTempTableSQL = $platform->getCreateTemporaryTableSnippetSQL() . ' ' . $tempTable . ' ('
                 . $platform->getColumnDeclarationListSQL($columnDefinitions) . ')';
 
-        $table = new Table("non_temporary");
+        $table = new Table("nontemporary");
         $table->addColumn("id", "integer");
+        $table->setPrimaryKey(array('id'));
+
+        foreach ($platform->getCreateTableSQL($table) AS $sql) {
+            $this->_conn->executeQuery($sql);
+        }
 
-        $this->_conn->getSchemaManager()->createTable($table);
         $this->_conn->beginTransaction();
-        $this->_conn->insert("non_temporary", array("id" => 1));
+        $this->_conn->insert("nontemporary", array("id" => 1));
 
-        $this->_conn->exec($tempTableSQL);
-        $this->_conn->insert("non_temporary", array("id" => 2));
+        $this->_conn->exec($createTempTableSQL);
+        $this->_conn->insert("nontemporary", array("id" => 2));
 
         $this->_conn->rollback();
 
         try {
             $this->_conn->exec($platform->getDropTemporaryTableSQL($tempTable));
         } catch(\Exception $e) {
-            
+
         }
 
-        $rows = $this->_conn->fetchAll('SELECT * FROM non_temporary');
-        $this->assertEquals(array(), $rows);
+        $rows = $this->_conn->fetchAll('SELECT * FROM nontemporary');
+        $this->assertEquals(array(), $rows, "In an event of an error this result has one row, because of an implicit commit.");
     }
 }

vendor/doctrine-dbal/tests/Doctrine/Tests/DBAL/SQLParserUtilsTest.php

             array('SELECT * FROM Foo WHERE bar IN (:name1, :name2)', false, array(':name1' => array(32), ':name2' => array(40))),
             array('SELECT ":foo" FROM Foo WHERE bar IN (:name1, :name2)', false, array(':name1' => array(37), ':name2' => array(45))),
             array("SELECT ':foo' FROM Foo WHERE bar IN (:name1, :name2)", false, array(':name1' => array(37), ':name2' => array(45))),
+            array('SELECT :foo_id', false, array(':foo_id' => array(7))), // Ticket DBAL-231
         );
     }
     
         $this->assertEquals($expectedParams, $params, "Params dont match");
         $this->assertEquals($expectedTypes, $types, "Types dont match");
     }
-}
+}

vendor/doctrine/composer.json

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

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

             foreach ($mapping['joinColumns'] as $key => &$joinColumn) {
                 if ($mapping['type'] === self::ONE_TO_ONE) {
                     if (count($mapping['joinColumns']) == 1) {
-                        $joinColumn['unique'] = true;
+                        if (! isset($mapping['id']) || ! $mapping['id']) {
+                            $joinColumn['unique'] = true;
+                        }
                     } else {
                         $uniqueContraintColumns[] = $joinColumn['name'];
                     }
                 if ( ! class_exists($className)) {
                     throw MappingException::invalidClassInDiscriminatorMap($className, $this->name);
                 }
-                if (is_subclass_of($className, $this->name)) {
+                if (is_subclass_of($className, $this->name) && ! in_array($className, $this->subClasses)) {
                     $this->subClasses[] = $className;
                 }
             }

vendor/doctrine/lib/Doctrine/ORM/Mapping/Driver/DatabaseDriver.php

         $fieldMappings = array();
         foreach ($columns as $column) {
             $fieldMapping = array();
-            if ($primaryKeyColumns && in_array($column->getName(), $primaryKeyColumns)) {
-                $fieldMapping['id'] = true;
-            } else if (in_array($column->getName(), $allForeignKeyColumns)) {
+            
+            if (in_array($column->getName(), $allForeignKeyColumns)) {
                 continue;
+            } else if ($primaryKeyColumns && in_array($column->getName(), $primaryKeyColumns)) {
+                $fieldMapping['id'] = true;
             }
-
+            
             $fieldMapping['fieldName'] = $this->getFieldNameForColumn($tableName, $column->getName(), false);
             $fieldMapping['columnName'] = $column->getName();
             $fieldMapping['type'] = strtolower((string) $column->getType());
             $associationMapping['fieldName'] = $this->getFieldNameForColumn($tableName, $localColumn, true);
             $associationMapping['targetEntity'] = $this->getClassNameForTable($foreignTable);
 
+            if ($primaryKeyColumns && in_array($localColumn, $primaryKeyColumns)) {
+                $associationMapping['id'] = true;
+            }
+
             for ($i = 0; $i < count($cols); $i++) {
                 $associationMapping['joinColumns'][] = array(
                     'name' => $cols[$i],
                     'referencedColumnName' => $fkCols[$i],
                 );
             }
-            $metadata->mapManyToOne($associationMapping);
+            
+            //Here we need to check if $cols are the same as $primaryKeyColums
+            if (!array_diff($cols,$primaryKeyColumns)) {
+                $metadata->mapOneToOne($associationMapping);
+            } else {
+                $metadata->mapManyToOne($associationMapping);
+            }
         }
     }
 

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

         if ( ! $this->isDirty) {
             $this->isDirty = true;
             if ($this->association !== null && $this->association['isOwningSide'] && $this->association['type'] == ClassMetadata::MANY_TO_MANY &&
-                    $this->em->getClassMetadata(get_class($this->owner))->isChangeTrackingNotify()) {
+                    $this->owner && $this->em->getClassMetadata(get_class($this->owner))->isChangeTrackingNotify()) {
                 $this->em->getUnitOfWork()->scheduleForDirtyCheck($this->owner);
             }
         }
         $this->initialize();
         return $this->coll->slice($offset, $length);
     }
+
+    /**
+     * Cleanup internal state of cloned persistent collection.
+     *
+     * The following problems have to be prevented:
+     * 1. Added entities are added to old PC
+     * 2. New collection is not dirty, if reused on other entity nothing
+     * changes.
+     * 3. Snapshot leads to invalid diffs being generated.
+     * 4. Lazy loading grabs entities from old owner object.
+     * 5. New collection is connected to old owner and leads to duplicate keys.
+     */
+    public function __clone()
+    {
+        if (is_object($this->coll)) {
+            $this->coll = clone $this->coll;
+        }
+
+        $this->initialize();
+        $this->owner = null;
+
+        $this->snapshot = array();
+        $this->changed();
+    }
 }

vendor/doctrine/lib/Doctrine/ORM/Persisters/AbstractCollectionPersister.php

      * @param mixed $element
      */
     abstract protected function _getInsertRowSQLParameters(PersistentCollection $coll, $element);
-}
+}

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

     {
         if (is_numeric($literal) && !is_string($literal)) {
             return (string) $literal;
+        } else if (is_bool($literal)) {
+            return $literal ? "true" : "false";
         } else {
             return "'" . str_replace("'", "''", $literal) . "'";
         }

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

      * @var string
      */
     const HINT_DISTINCT = 'doctrine.distinct';
-  
+
     /**
      * @var ResultSetMapping
      */
         switch (true) {
             case ($AST instanceof AST\DeleteStatement):
                 $primaryClass = $this->_em->getClassMetadata($AST->deleteClause->abstractSchemaName);
-                
+
                 return ($primaryClass->isInheritanceTypeJoined())
                     ? new Exec\MultiTableDeleteExecutor($AST, $this)
                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
-                
+
             case ($AST instanceof AST\UpdateStatement):
                 $primaryClass = $this->_em->getClassMetadata($AST->updateClause->abstractSchemaName);
-                
-                return ($primaryClass->isInheritanceTypeJoined()) 
+
+                return ($primaryClass->isInheritanceTypeJoined())
                     ? new Exec\MultiTableUpdateExecutor($AST, $this)
                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
-                
+
             default:
                 return new Exec\SingleSelectExecutor($AST, $this);
         }
                 $sql .= ' LEFT JOIN ' . $subClass->getQuotedTableName($this->_platform)
                         . ' ' . $tableAlias . ' ON ';
                 $first = true;
-                
+
                 foreach ($class->getQuotedIdentifierColumnNames($this->_platform) as $columnName) {
                     if ($first) $first = false; else $sql .= ' AND ';
 
                     $encapsulate = true;
                 }
 
-                $sql .= ($sql != '' ? ' AND ' : '')
-                      . (($this->_useSqlTableAliases) ? $this->getSQLTableAlias($class->table['name'], $dqlAlias) . '.' : '')
+                $sql .= (($this->_useSqlTableAliases) ? $this->getSQLTableAlias($class->table['name'], $dqlAlias) . '.' : '')
                       . $class->discriminatorColumn['name'] . ' IN (' . implode(', ', $values) . ')';
             }
         }
                     throw QueryException::associationPathInverseSideNotSupported();
                 }
                 break;
-                
+
             default:
                 throw QueryException::invalidPathExpression($pathExpr);
         }
                 $tblAlias = $this->getSQLTableAlias($rootClass->table['name'], $dqlAlias);
                 $discrColumn = $rootClass->discriminatorColumn;
                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
-                
+
                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
 
                 $columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
                             } else {
                                 $sqlTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
                             }
-                            
+
                             foreach ($assoc['targetToSourceKeyColumns'] as $srcColumn) {
                                 $columnAlias = $this->getSQLColumnAlias($srcColumn);
-                                
+
                                 $sqlSelectExpressions[] = $sqlTableAlias . '.' . $srcColumn . ' AS ' . $columnAlias;
-                                
+
                                 $columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
                                 $this->_rsm->addMetaResult($dqlAlias, $this->_platform->getSQLResultCasing($columnAlias), $srcColumn, (isset($assoc['id']) && $assoc['id'] === true));
                             }
                         if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
                             foreach ($assoc['targetToSourceKeyColumns'] as $srcColumn) {
                                 $columnAlias = $this->getSQLColumnAlias($srcColumn);
-                                
+
                                 $sqlSelectExpressions[] = $sqlTableAlias . '.' . $srcColumn . ' AS ' . $columnAlias;
-                                
+
                                 $columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
                                 $this->_rsm->addMetaResult($dqlAlias, $this->_platform->getSQLResultCasing($columnAlias), $srcColumn, (isset($assoc['id']) && $assoc['id'] === true));
                             }
                 }
             }
         }
-        
+
         $sql .= implode(', ', $sqlSelectExpressions);
 
         return $sql;
 
             $rangeDecl = $identificationVariableDecl->rangeVariableDeclaration;
             $dqlAlias = $rangeDecl->aliasIdentificationVariable;
-        
+
             $this->_rootAliases[] = $dqlAlias;
 
             $class = $this->_em->getClassMetadata($rangeDecl->abstractSchemaName);
 
         return $sql;
     }
-    
+
     /**
      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
      *
     public function walkCoalesceExpression($coalesceExpression)
     {
         $sql = 'COALESCE(';
-        
+
         $scalarExpressions = array();
-        
+
         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
         }
-        
+
         $sql .= implode(', ', $scalarExpressions) . ')';
-        
+
         return $sql;
     }
-    
+
     public function walkCaseExpression($expression)
     {
         switch (true) {
             case ($expression instanceof AST\CoalesceExpression):
                 return $this->walkCoalesceExpression($expression);
-                
+
             case ($expression instanceof AST\NullIfExpression):
                 return $this->walkNullIfExpression($expression);
-                
+
             default:
                 return '';
         }
     }
-    
+
     /**
      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
      *
      */
     public function walkNullIfExpression($nullIfExpression)
     {
-        $firstExpression = is_string($nullIfExpression->firstExpression) 
+        $firstExpression = is_string($nullIfExpression->firstExpression)
             ? $this->_conn->quote($nullIfExpression->firstExpression)
             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
-        
-        $secondExpression = is_string($nullIfExpression->secondExpression) 
+
+        $secondExpression = is_string($nullIfExpression->secondExpression)
             ? $this->_conn->quote($nullIfExpression->secondExpression)
             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
-        
+
         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
     }
 
                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
                 $columnName = $class->getQuotedColumnName($fieldName, $this->_platform);
 
-                $columnAlias = $this->getSQLColumnAlias($columnName);
+                $columnAlias = $this->getSQLColumnAlias($class->fieldMappings[$fieldName]['columnName']);
                 $sql .= $sqlTableAlias . '.' . $columnName . ' AS ' . $columnAlias;
                 $columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
                 $this->_rsm->addScalarResult($columnAlias, $resultAlias);
             }
 
             $columnAlias = 'sclr' . $this->_aliasCounter++;
-            
+
             if ($expr instanceof AST\Literal) {
                 $sql .= $this->walkLiteral($expr) . ' AS ' .$columnAlias;
             } else {
                 $sql .= $this->walkSimpleArithmeticExpression($expr) . ' AS ' . $columnAlias;
             }
-            
+
             $this->_scalarResultAliasMap[$resultAlias] = $columnAlias;
 
             $columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
             }
 
             $columnAlias = 'sclr' . $this->_aliasCounter++;
-            
+
             $sql .= $this->walkCaseExpression($expr) . ' AS ' . $columnAlias;
-            
+
             $this->_scalarResultAliasMap[$resultAlias] = $columnAlias;
 
             $columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
     {
         $expr = $simpleSelectExpression->expression;
         $sql  = ' ';
-        
+
         switch (true) {
             case ($expr instanceof AST\PathExpression):
                 $sql .= $this->walkPathExpression($expr);
                 break;
-            
+
             case ($expr instanceof AST\AggregateExpression):
                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->_scalarResultCounter++;
-                
+
                 $sql .= $this->walkAggregateExpression($expr) . ' AS dctrn__' . $alias;
                 break;
-            
+
             case ($expr instanceof AST\Subselect):
                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->_scalarResultCounter++;
-                
+
                 $columnAlias = 'sclr' . $this->_aliasCounter++;
                 $this->_scalarResultAliasMap[$alias] = $columnAlias;
-                
+
                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
                 break;
-            
+
             case ($expr instanceof AST\Functions\FunctionNode):
                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->_scalarResultCounter++;
-                
+
                 $columnAlias = 'sclr' . $this->_aliasCounter++;
                 $this->_scalarResultAliasMap[$alias] = $columnAlias;
-                
+
                 $sql .= $this->walkFunction($expr) . ' AS ' . $columnAlias;
                 break;
-            
+
             case ($expr instanceof AST\SimpleArithmeticExpression):
             case ($expr instanceof AST\ArithmeticTerm):
             case ($expr instanceof AST\ArithmeticFactor):
             case ($expr instanceof AST\ArithmeticPrimary):
             case ($expr instanceof AST\Literal):
                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->_scalarResultCounter++;
-                
+
                 $columnAlias = 'sclr' . $this->_aliasCounter++;
                 $this->_scalarResultAliasMap[$alias] = $columnAlias;
-                
+
                 $sql .= $this->walkSimpleArithmeticExpression($expr) . ' AS ' . $columnAlias;
                 break;
-                
+
             case ($expr instanceof AST\NullIfExpression):
             case ($expr instanceof AST\CoalesceExpression):
             case ($expr instanceof AST\GeneralCaseExpression):
             case ($expr instanceof AST\SimpleCaseExpression):
                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->_scalarResultCounter++;
-                
+
                 $columnAlias = 'sclr' . $this->_aliasCounter++;
                 $this->_scalarResultAliasMap[$alias] = $columnAlias;
-                
+
                 $sql .= $this->walkCaseExpression($expr) . ' AS ' . $columnAlias;
                 break;
-            
+
             default: // IdentificationVariable
                 $class      = $this->_queryComponents[$expr]['metadata'];
                 $tableAlias = $this->getSQLTableAlias($class->getTableName(), $expr);
                 foreach ($class->getQuotedIdentifierColumnNames($this->_platform) as $columnName) {
                     $sqlParts[] = $tableAlias . '.' . $columnName;
                 }
-                
+
                 $sql .= implode(', ', $sqlParts);
                 break;
         }
-        
+
         return $sql;
     }
 
     public function walkGroupByClause($groupByClause)
     {
         $sqlParts = array();
-        
+
         foreach ($groupByClause->groupByItems AS $groupByItem) {
             if ( ! is_string($groupByItem)) {
                 $sqlParts[] = $this->walkGroupByItem($groupByItem);
-                
+
                 continue;
             }
-            
+
             foreach ($this->_queryComponents[$groupByItem]['metadata']->identifier AS $idField) {
                 $groupByItem = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $idField);
                 $groupByItem->type = AST\PathExpression::TYPE_STATE_FIELD;
-                
+
                 $sqlParts[] = $this->walkGroupByItem($groupByItem);
             }
         }
-        
+
         return ' GROUP BY ' . implode(', ', $sqlParts);
     }
 
         $class     = $this->_em->getClassMetadata($deleteClause->abstractSchemaName);
         $tableName = $class->getTableName();
         $sql       = 'DELETE FROM ' . $class->getQuotedTableName($this->_platform);
-        
+
         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
         $this->_rootAliases[] = $deleteClause->aliasIdentificationVariable;
 
         $class     = $this->_em->getClassMetadata($updateClause->abstractSchemaName);
         $tableName = $class->getTableName();
         $sql       = 'UPDATE ' . $class->getQuotedTableName($this->_platform);
-        
+
         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
         $this->_rootAliases[] = $updateClause->aliasIdentificationVariable;
 
             case ($newValue instanceof AST\Node):
                 $sql .= $newValue->dispatch($this);
                 break;
-            
+
             case ($newValue === null):
                 $sql .= 'NULL';
                 break;
-            
+
             default:
                 $sql .= $this->_conn->quote($newValue);
                 break;
 
         if ($condSql) {
             return ' WHERE ' . (( ! $discrSql) ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
-        } 
-        
+        }
+
         if ($discrSql) {
             return ' WHERE ' . $discrSql;
         }
         if ( ! ($condExpr instanceof AST\ConditionalExpression)) {
             return $this->walkConditionalTerm($condExpr);
         }
-        
+
         return implode(' OR ', array_map(array($this, 'walkConditionalTerm'), $condExpr->conditionalTerms));
     }
 
         if ( ! ($condTerm instanceof AST\ConditionalTerm)) {
             return $this->walkConditionalFactor($condTerm);
         }
-        
+
         return implode(' AND ', array_map(array($this, 'walkConditionalFactor'), $condTerm->conditionalFactors));
     }
 
     {
         if ($primary->isSimpleConditionalExpression()) {
             return $primary->simpleConditionalExpression->dispatch($this);
-        } 
-        
+        }
+
         if ($primary->isConditionalExpression()) {
             $condExpr = $primary->conditionalExpression;
 
         $sql .= 'EXISTS (SELECT 1 FROM ';
         $entityExpr = $collMemberExpr->entityExpression;
         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
-        
+
         $fieldName = $collPathExpr->field;
         $dqlAlias = $collPathExpr->identificationVariable;
-        
+
         $class = $this->_queryComponents[$dqlAlias]['metadata'];
-        
+
         if ($entityExpr instanceof AST\InputParameter) {
             $dqlParamKey = $entityExpr->name;
             $entity = $this->_query->getParameter($dqlParamKey);
             //TODO
             throw new \BadMethodCallException("Not implemented");
         }
-        
+
         $assoc = $class->associationMappings[$fieldName];
-        
+
         if ($assoc['type'] == ClassMetadata::ONE_TO_MANY) {
             $targetClass = $this->_em->getClassMetadata($assoc['targetEntity']);
             $targetTableAlias = $this->getSQLTableAlias($targetClass->table['name']);
             $sourceTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
-            
+
             $sql .= $targetClass->getQuotedTableName($this->_platform)
                   . ' ' . $targetTableAlias . ' WHERE ';
-                    
+
             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
-            
+
             $first = true;
-            
+
             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
                 if ($first) $first = false; else $sql .= ' AND ';
-                
-                $sql .= $sourceTableAlias . '.' . $class->getQuotedColumnName($class->fieldNames[$targetColumn], $this->_platform) 
-                      . ' = ' 
+
+                $sql .= $sourceTableAlias . '.' . $class->getQuotedColumnName($class->fieldNames[$targetColumn], $this->_platform)
+                      . ' = '
                       . $targetTableAlias . '.' . $sourceColumn;
             }
-            
+
             $sql .= ' AND ';
             $first = true;
-            
+
             foreach ($targetClass->getQuotedIdentifierColumnNames($this->_platform) as $targetColumnName) {
                 if ($first) $first = false; else $sql .= ' AND ';
-                
+
                 $this->_parserResult->addParameterMapping($dqlParamKey, $this->_sqlParamIndex++);
                 $sql .= $targetTableAlias . '.'  . $targetColumnName . ' = ?';
             }
         } else { // many-to-many
             $targetClass = $this->_em->getClassMetadata($assoc['targetEntity']);
-            
+
             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
             $joinTable = $owningAssoc['joinTable'];
 
             $joinTableAlias = $this->getSQLTableAlias($joinTable['name']);
             $targetTableAlias = $this->getSQLTableAlias($targetClass->table['name']);
             $sourceTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
-            
+
             // join to target table
             $sql .= $targetClass->getQuotedJoinTableName($owningAssoc, $this->_platform)
                   . ' ' . $joinTableAlias . ' INNER JOIN '
                   . $targetClass->getQuotedTableName($this->_platform)
                   . ' ' . $targetTableAlias . ' ON ';
-            
+
             // join conditions
             $joinColumns = $assoc['isOwningSide']
                 ? $joinTable['inverseJoinColumns']
             foreach ($joinColumns as $joinColumn) {
                 if ($first) $first = false; else $sql .= ' AND ';
 
-                $sql .= $joinTableAlias . '.' . $joinColumn['name'] . ' = ' 
+                $sql .= $joinTableAlias . '.' . $joinColumn['name'] . ' = '
                       . $sourceTableAlias . '.' . $class->getQuotedColumnName(
                               $class->fieldNames[$joinColumn['referencedColumnName']],
                               $this->_platform);
             }
-            
+
             $sql .= ' AND ';
             $first = true;
-            
+
             foreach ($targetClass->getQuotedIdentifierColumnNames($this->_platform) as $targetColumnName) {
                 if ($first) $first = false; else $sql .= ' AND ';
-                
+
                 $this->_parserResult->addParameterMapping($dqlParamKey, $this->_sqlParamIndex++);
                 $sql .= $targetTableAlias . '.' . $targetColumnName . ' = ?';
             }
 
         return $sql . ')';
     }
-    
+
     /**
      * Walks down an EmptyCollectionComparisonExpression AST node, thereby generating the appropriate SQL.
      *
      */
     public function walkInExpression($inExpr)
     {
-        $sql = $this->walkPathExpression($inExpr->pathExpression) 
+        $sql = $this->walkPathExpression($inExpr->pathExpression)
              . ($inExpr->not ? ' NOT' : '') . ' IN (';
 
-        $sql .= ($inExpr->subselect) 
+        $sql .= ($inExpr->subselect)
             ? $this->walkSubselect($inExpr->subselect)
             : implode(', ', array_map(array($this, 'walkInParameter'), $inExpr->literals));
 
             // We need to modify the parameter value to be its correspondent mapped value
             $dqlParamKey = $instanceOfExpr->value->name;
             $paramValue  = $this->_query->getParameter($dqlParamKey);
-            
+
             if ( ! ($paramValue instanceof \Doctrine\ORM\Mapping\ClassMetadata)) {
                 throw QueryException::invalidParameterType('ClassMetadata', get_class($paramValue));
             }
-            
+
             $entityClassName = $paramValue->name;
         } else {
             // Get name from ClassMetadata to resolve aliases.
             if (!isset($discrMap[$entityClassName])) {
                 throw QueryException::instanceOfUnrelatedClass($entityClassName, $class->rootEntityName);
             }
-            
+
             $sql .= $this->_conn->quote($discrMap[$entityClassName]);
         }
 
      */
     public function walkInParameter($inParam)
     {
-        return $inParam instanceof AST\InputParameter 
-            ? $this->walkInputParameter($inParam) 
+        return $inParam instanceof AST\InputParameter
+            ? $this->walkInputParameter($inParam)
             : $this->walkLiteral($inParam);
     }
 
         $leftExpr  = $compExpr->leftExpression;
         $rightExpr = $compExpr->rightExpression;
         $sql       = '';
-        
-        $sql .= ($leftExpr instanceof AST\Node) 
+
+        $sql .= ($leftExpr instanceof AST\Node)
             ? $leftExpr->dispatch($this)
             : (is_numeric($leftExpr) ? $leftExpr : $this->_conn->quote($leftExpr));
 
         $sql .= ' ' . $compExpr->operator . ' ';
 
-        $sql .= ($rightExpr instanceof AST\Node) 
+        $sql .= ($rightExpr instanceof AST\Node)
             ? $rightExpr->dispatch($this)
             : (is_numeric($rightExpr) ? $rightExpr : $this->_conn->quote($rightExpr));
 
         if ( ! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
             return $this->walkArithmeticTerm($simpleArithmeticExpr);
         }
-        
+
         return implode(' ', array_map(array($this, 'walkArithmeticTerm'), $simpleArithmeticExpr->arithmeticTerms));
     }
 
         if (is_string($term)) {
             if (isset($this->_queryComponents[$term])) {
                 $columnName = $this->_queryComponents[$term]['token']['value'];
-                
+
                 return $this->_scalarResultAliasMap[$columnName];
             }
-            
+
             return $term;
         }
 
         if ( ! ($term instanceof AST\ArithmeticTerm)) {
             return $this->walkArithmeticFactor($term);
         }
-        
+
         return implode(' ', array_map(array($this, 'walkArithmeticFactor'), $term->arithmeticFactors));
     }
 
         if (is_string($factor)) {
             return $factor;
         }
-        
+
         // Phase 2 AST optimization: Skip processment of ArithmeticFactor
         // if only one ArithmeticPrimary is defined
         if ( ! ($factor instanceof AST\ArithmeticFactor)) {
             return $this->walkArithmeticPrimary($factor);
         }
-        
+
         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
-        
+
         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
     }
 
     {
         if ($primary instanceof AST\SimpleArithmeticExpression) {
             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
-        } 
-        
+        }
+
         if ($primary instanceof AST\Node) {
             return $primary->dispatch($this);
         }

vendor/doctrine/lib/Doctrine/ORM/Tools/EntityGenerator.php

         $this->_staticReflection[$metadata->name]['methods'][] = $methodName;
 
         $replacements = array(
-            '<name>'        => $this->_annotationsPrefix . $name,
+            '<name>'        => $this->_annotationsPrefix . ucfirst($name),
             '<methodName>'  => $methodName,
         );
 
 
         if ($this->_generateAnnotations) {
             $lines[] = $this->_spaces . ' *';
+            
+            if (isset($associationMapping['id']) && $associationMapping['id']) {
+                $lines[] = $this->_spaces . ' * @' . $this->_annotationsPrefix . 'Id';
+            
+                if ($generatorType = $this->_getIdGeneratorTypeString($metadata->generatorType)) {
+                    $lines[] = $this->_spaces . ' * @' . $this->_annotationsPrefix . 'GeneratedValue(strategy="' . $generatorType . '")';
+                }
+            }
 
             $type = null;
             switch ($associationMapping['type']) {

vendor/doctrine/lib/Doctrine/ORM/Tools/Export/Driver/YamlExporter.php

                 );
 
                 $associationMappingArray = array_merge($associationMappingArray, $oneToOneMappingArray);
-                $array['oneToOne'][$name] = $associationMappingArray;
+
+                if ($associationMapping['type'] & ClassMetadataInfo::ONE_TO_ONE) {
+                    $array['oneToOne'][$name] = $associationMappingArray;
+                } else {
+                    $array['manyToOne'][$name] = $associationMappingArray;
+                }
+
             } else if ($associationMapping['type'] == ClassMetadataInfo::ONE_TO_MANY) {
                 $oneToManyMappingArray = array(
                     'mappedBy'      => $associationMapping['mappedBy'],

vendor/doctrine/lib/Doctrine/ORM/UnitOfWork.php

                             $this->collectionDeletions[] = $orgValue;
                             $changeSet[$propName] = $orgValue; // Signal changeset, to-many assocs will be ignored.
                         }
+
+                        // Persistent collection was exchanged with the "originally"
+                        // created one. This can only mean it was cloned and replaced
+                        // on another entity.
+                        if ($actualValue instanceof PersistentCollection) {
+                            $owner = $actualValue->getOwner();
+                            if ($owner === null) { // cloned
+                                $actualValue->setOwner($entity, $assoc);
+                            } else if ($owner !== $entity) { // no clone, we have to fix
+                                if (!$actualValue->isInitialized()) {
+                                    $actualValue->initialize(); // we have to do this otherwise the cols share state
+                                }
+                                $newValue = clone $actualValue;
+                                $newValue->setOwner($entity, $assoc);
+                                $class->reflFields[$propName]->setValue($entity, $newValue);
+                            }
+                        }
                     }
                 } else if ($isChangeTrackingNotify) {
                     continue;
             $val = $class->reflFields[$field]->getValue($entity);
             if ($val !== null) {
                 $this->computeAssociationChanges($assoc, $val);
+                if (!isset($this->entityChangeSets[$oid]) &&
+                    $assoc['isOwningSide'] &&
+                    $assoc['type'] == ClassMetadata::MANY_TO_MANY &&
+                    $val instanceof PersistentCollection &&
+                    $val->isDirty()) {
+                    $this->entityChangeSets[$oid]   = array();
+                    $this->originalEntityData[$oid] = $actualData;
+                    $this->entityUpdates[$oid]      = $entity;
+                }
             }
         }
     }
         $className = $classMetadata->rootEntityName;
         if (isset($this->identityMap[$className][$idHash])) {
             unset($this->identityMap[$className][$idHash]);
+            unset($this->readOnlyObjects[$oid]);
+
             //$this->entityStates[$oid] = self::STATE_DETACHED;
             return true;
         }
                     } else {
                         throw new EntityNotFoundException;
                     }
-
-                    $managedCopy = $this->newInstance($class);
-                    $class->setIdentifierValues($managedCopy, $id);
-
-                    $this->persistNew($class, $managedCopy);
                 } else {
                     if ($managedCopy instanceof Proxy && ! $managedCopy->__isInitialized__) {
                         $managedCopy->__load();
         $this->collectionDeletions =
         $this->collectionUpdates =
         $this->extraUpdates =
+        $this->readOnlyObjects =
         $this->orphanRemovals = array();
         if ($this->commitOrderCalculator !== null) {
             $this->commitOrderCalculator->clear();

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

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

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/ManyToManyEventTest.php

+<?php
+namespace Doctrine\Tests\ORM\Functional;
+use Doctrine\Tests\Models\CMS\CmsUser;
+use Doctrine\Tests\Models\CMS\CmsGroup;
+use Doctrine\ORM\Events;
+require_once __DIR__ . '/../../TestInit.php';
+
+/**
+ * ManyToManyEventTest
+ *
+ * @author Francisco Facioni <fran6co@gmail.com>
+ */
+class ManyToManyEventTest extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    /**
+     * @var PostUpdateListener
+     */
+    private $listener;
+
+    protected function setUp()
+    {
+        $this->useModelSet('cms');
+        parent::setUp();
+        $this->listener = new PostUpdateListener();
+        $evm = $this->_em->getEventManager();
+        $evm->addEventListener(Events::postUpdate, $this->listener);
+    }
+
+    public function testListenerShouldBeNotifiedOnlyWhenUpdating()
+    {
+        $user = $this->createNewValidUser();
+        $this->_em->persist($user);
+        $this->_em->flush();
+        $this->assertFalse($this->listener->wasNotified);
+
+        $group = new CmsGroup();
+        $group->name = "admins";
+        $user->addGroup($group);
+        $this->_em->persist($user);
+        $this->_em->flush();
+
+        $this->assertTrue($this->listener->wasNotified);
+    }
+
+    /**
+     * @return CmsUser
+     */
+    private function createNewValidUser()
+    {
+        $user = new CmsUser();
+        $user->username = 'fran6co';
+        $user->name = 'Francisco Facioni';
+        $user->status = 'foo';
+        $group = new CmsGroup();
+        $group->name = "users";
+        $user->addGroup($group);
+        return $user;
+    }
+}
+
+class PostUpdateListener
+{
+    /**
+     * @var bool
+     */
+    public $wasNotified = false;
+
+    /**
+     * @param $args
+     */
+    public function postUpdate($args)
+    {
+        $this->wasNotified = true;
+    }
+}
+
+

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/PersistentCollectionTest.php

+<?php
+
+namespace Doctrine\Tests\ORM\Functional;
+
+use Doctrine\Common\Persistence\PersistentObject;
+
+/**
+ */
+class PersistentCollectionTest extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    protected function setUp()
+    {
+        parent::setUp();
+        try {
+            $this->_schemaTool->createSchema(array(
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\PersistentCollectionHolder'),
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\PersistentCollectionContent'),
+            ));
+        } catch (\Exception $e) {
+        }
+    }
+
+    public function testPersist()
+    {
+        $collectionHolder = new PersistentCollectionHolder();
+        $content = new PersistentCollectionContent('first element');
+        $collectionHolder->addElement($content);
+
+        $this->_em->persist($collectionHolder);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $collectionHolder = $this->_em->find(__NAMESPACE__ . '\PersistentCollectionHolder', $collectionHolder->id);
+        $collectionHolder->getCollection();
+
+        $content = new PersistentCollectionContent('second element');
+        $collectionHolder->addElement($content);
+
+        $this->assertEquals(2, $collectionHolder->getCollection()->count());
+    }
+
+}
+
+/**
+ * @Entity
+ */
+class PersistentCollectionHolder
+{
+    /**
+     * @Id @Column(type="integer") @GeneratedValue
+     * @var int
+     */
+    public $id;
+
+    /**
+     * @var \Doctrine\Common\Collections\Collection
+     * @ManyToMany(targetEntity="PersistentCollectionContent", cascade={"all"})
+     * @JoinTable(name="pcholder_content_mm")
+     */
+    public $collection;
+
+    public function __construct()
+    {
+        $this->collection = new \Doctrine\Common\Collections\ArrayCollection();
+    }
+
+    /**
+     * @param PersistentCollectionContent $element
+     */
+    public function addElement(PersistentCollectionContent $element)
+    {
+        $this->collection->add($element);
+    }
+
+    /**
+     * @return \Doctrine\Common\Collections\Collection
+     */
+    public function getCollection()
+    {
+        return clone $this->collection;
+    }
+
+}
+
+/**
+ * @Entity
+ */
+class PersistentCollectionContent
+{
+
+    /**
+     * @Id @Column(type="integer") @GeneratedValue
+     * @var int
+     */
+    public $id;
+
+}

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/ReadOnlyTest.php

     {
         parent::setUp();
 
-        $this->_schemaTool->createSchema(array(
-            $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\ReadOnlyEntity'),
-        ));
+        try {
+            $this->_schemaTool->createSchema(array(
+                $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\ReadOnlyEntity'),
+            ));
+        } catch(\Exception $e) {
+        }
     }
 
     public function testReadOnlyEntityNeverChangeTracked()
         $this->assertEquals("Test1", $dbReadOnly->name);
         $this->assertEquals(1234, $dbReadOnly->number);
     }
+
+    /**
+     * @group DDC-1659
+     */
+    public function testClearReadOnly()
+    {
+        $readOnly = new ReadOnlyEntity("Test1", 1234);
+        $this->_em->persist($readOnly);
+        $this->_em->flush();
+        $this->_em->getUnitOfWork()->markReadOnly($readOnly);
+
+        $this->_em->clear();
+
+        $this->assertFalse($this->_em->getUnitOfWork()->isReadOnly($readOnly));
+    }
 }
 
 /**
     public $id;
     /** @column(type="string") */
     public $name;
-    /** @Column(type="integer") */
+    /** @Column(type="integer", name="number_col") */
     public $number;
 
     public function __construct($name, $number)
         $this->name = $name;
         $this->number = $number;
     }
-}
+}

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/SingleTableInheritanceTest.php

 
         $this->assertNotInstanceOf('Doctrine\ORM\Proxy\Proxy', $contract->getSalesPerson());
     }
+
+    /**
+     * @group DDC-1770
+     */
+    public function testTwoSingleTableInheritanceInFromClause()
+    {
+        $dql = 'SELECT f1,f2 FROM Doctrine\Tests\Models\Company\CompanyFixContract f1, Doctrine\Tests\Models\Company\CompanyFixContract f2';
+        $result = $this->_em->createQuery($dql)->getResult();
+    }
 }

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1040Test.php

                   ->setParameter('author', $user)
                   ->getResult();
 
-        $dql = "SELECT a FROM Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.topic = :topic AND a.user = :author AND a.user = :author  AND a.text = :text";
+        $dql = "SELECT a FROM Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.topic = :topic AND a.user = :author AND a.user = :author";
         $farticle = $this->_em->createQuery($dql)
                   ->setParameter('author', $user)
                   ->setParameter('topic', 'This is John Galt speaking!')
-                  ->setParameter('text', 'Yadda Yadda!')
                   ->getSingleResult();
 
         $this->assertSame($article, $farticle);
         $this->_em->persist($article);
         $this->_em->flush();
 
-        $dql = "SELECT a FROM Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.topic = ?1 AND a.user = ?2 AND a.user = ?3 AND a.text = ?4";
+        $dql = "SELECT a FROM Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.topic = ?1 AND a.user = ?2 AND a.user = ?3";
         $farticle = $this->_em->createQuery($dql)
                   ->setParameter(1, 'This is John Galt speaking!')
                   ->setParameter(2, $user)
                   ->setParameter(3, $user)
-                  ->setParameter(4, 'Yadda Yadda!')
                   ->getSingleResult();
 
         $this->assertSame($article, $farticle);
     }
-}
+}

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1209Test.php

 {
     /**
      * @Id
-     * @Column(type="datetime")
+     * @Column(type="datetime", name="ddc1203_date")
      */
     private $date;
 
     {
         return $this->format('Y');
     }
-}
+}

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1228Test.php

                 $this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC1228User'),
                 $this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC1228Profile'),
             ));
-        } catch(\PDOException $e) {
-            
+        } catch(\Exception $e) {
+
         }
     }
-    
+
     public function testOneToOnePersist()
     {
         $user = new DDC1228User;
+        $user->name = "Foo";
         $profile = new DDC1228Profile();
         $profile->name = "Foo";
         $user->profile = $profile;
-        
+
         $this->_em->persist($user);
         $this->_em->persist($profile);
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $user = $this->_em->find(__NAMESPACE__ . '\\DDC1228User', $user->id);
-        
+
         $this->assertFalse($user->getProfile()->__isInitialized__, "Proxy is not initialized");
         $user->getProfile()->setName("Bar");
         $this->assertTrue($user->getProfile()->__isInitialized__, "Proxy is not initialized");
-        
+
         $this->assertEquals("Bar", $user->getProfile()->getName());
         $this->assertEquals(array("id" => 1, "name" => "Foo"), $this->_em->getUnitOfWork()->getOriginalEntityData($user->getProfile()));
-        
+
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $user = $this->_em->find(__NAMESPACE__ . '\\DDC1228User', $user->id);
         $this->assertEquals("Bar", $user->getProfile()->getName());
     }
-    
+
     public function testRefresh()
     {
         $user = new DDC1228User;
+        $user->name = "Foo";
         $profile = new DDC1228Profile();
         $profile->name = "Foo";
         $user->profile = $profile;
-        
+
         $this->_em->persist($user);
         $this->_em->persist($profile);
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $user = $this->_em->getReference(__NAMESPACE__ . '\\DDC1228User', $user->id);
-        
+
         $this->_em->refresh($user);
         $user->name = "Baz";
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $user = $this->_em->find(__NAMESPACE__ . '\\DDC1228User', $user->id);
         $this->assertEquals("Baz", $user->name);
     }
      * @var int
      */
     public $id;
-    
+
     /**
      * @column(type="string")
      * @var string
      */
     public $name = '';
-    
+
     /**
      * @OneToOne(targetEntity="DDC1228Profile")
      * @var Profile
      */
     public $profile;
-    
-    public function getProfile()   
+
+    public function getProfile()
     {
         return $this->profile;
     }
      * @var int
      */
     public $id;
-    
+
     /**
      * @column(type="string")
      * @var string
      */
     public $name;
-    
+
     public function getName()
     {
         return $this->name;
     {
         $this->name = $name;
     }
-}
+}

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1238Test.php

             $this->_schemaTool->createSchema(array(
                 $this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC1238User'),
             ));
-        } catch(\PDOException $e) {
-            
+        } catch(\Exception $e) {
+
         }
     }
-    
+
     public function testIssue()
     {
         $user = new DDC1238User;
         $user->setName("test");
-        
+
         $this->_em->persist($user);
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $userId = $user->getId();
         $this->_em->clear();
-        
+
         $user = $this->_em->getReference(__NAMESPACE__ . '\\DDC1238User', $userId);
         $this->_em->clear();
-        
+
         $userId2 = $user->getId();
         $this->assertEquals($userId, $userId2, "This proxy can still be initialized.");
     }
-    
+
     public function testIssueProxyClear()
     {
         $user = new DDC1238User;
         $user->setName("test");
-        
+
         $this->_em->persist($user);
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $userId = $user->getId();
         $this->_em->clear();
-        
+
         $user = $this->_em->getReference(__NAMESPACE__ . '\\DDC1238User', $userId);
         $this->_em->clear();
-        
+
         $user2 = $this->_em->getReference(__NAMESPACE__ . '\\DDC1238User', $userId);
-        
+
         $this->assertNull($user->getId(), "Now this is null, we already have a user instance of that type");
     }
 }
 {
     /** @Id @GeneratedValue @Column(type="integer") */
     private $id;
-    
+
     /**
      * @Column
      * @var string
      */
     private $name;
-    
+
     public function getId()
     {
         return $this->id;
     }
-    
+
     public function getName()
     {
         return $this->name;

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1514Test.php

         $dql = "SELECT a, b, ba, c FROM " . __NAMESPACE__ . "\DDC1514EntityA AS a LEFT JOIN a.entitiesB AS b LEFT JOIN b.entityATo AS ba LEFT JOIN a.entityC AS c";
         $results = $this->_em->createQuery($dql)->getResult();
 
+        $this->assertInstanceOf(__NAMESPACE__ . "\DDC1514EntityA", $results[1]);
+        $this->assertInstanceOf(__NAMESPACE__ . "\DDC1514EntityC", $results[1]->entityC);
         $this->assertEquals($c->title, $results[1]->entityC->title);
     }
 }
     public $entitiesB;
     /** @ManyToOne(targetEntity="DDC1514EntityC") */
     public $entityC;
-    
+
     public function __construct()
     {
         $this->entitiesB = new ArrayCollection();

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1643Test.php

+<?php
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\Tests\Models\CMS\CmsUser;
+use Doctrine\Tests\Models\CMS\CmsGroup;
+
+/**
+ * @group DDC-1643
+ */
+class DDC1643Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    private $user1;
+    private $user2;
+
+    public function setUp()
+    {
+        $this->useModelSet('cms');
+        parent::setUp();
+
+        $user1 = new CmsUser();
+        $user1->username = "beberlei";
+        $user1->name = "Benjamin";
+        $user1->status = "active";
+        $group1 = new CmsGroup();
+        $group1->name = "test";
+        $group2 = new CmsGroup();
+        $group2->name = "test";
+        $user1->addGroup($group1);
+        $user1->addGroup($group2);
+        $user2 = new CmsUser();
+        $user2->username = "romanb";
+        $user2->name = "Roman";
+        $user2->status = "active";
+
+        $this->_em->persist($user1);
+        $this->_em->persist($user2);
+        $this->_em->persist($group1);
+        $this->_em->persist($group2);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $this->user1 = $this->_em->find(get_class($user1), $user1->id);
+        $this->user2 = $this->_em->find(get_class($user1), $user2->id);
+    }
+
+    public function testClonePersistentCollectionAndReuse()
+    {
+        $user1 = $this->user1;
+
+        $user1->groups = clone $user1->groups;
+
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $user1 = $this->_em->find(get_class($user1), $user1->id);
+
+        $this->assertEquals(2, count($user1->groups));
+    }
+
+    public function testClonePersistentCollectionAndShare()
+    {
+        $user1 = $this->user1;
+        $user2 = $this->user2;
+
+        $user2->groups = clone $user1->groups;
+
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $user1 = $this->_em->find(get_class($user1), $user1->id);
+        $user2 = $this->_em->find(get_class($user1), $user2->id);
+
+        $this->assertEquals(2, count($user1->groups));
+        $this->assertEquals(2, count($user2->groups));
+    }
+
+    public function testCloneThenDirtyPersistentCollection()
+    {
+        $user1 = $this->user1;
+        $user2 = $this->user2;
+
+        $group3 = new CmsGroup();
+        $group3->name = "test";
+        $user2->groups = clone $user1->groups;
+        $user2->groups->add($group3);
+
+        $this->_em->persist($group3);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $user1 = $this->_em->find(get_class($user1), $user1->id);
+        $user2 = $this->_em->find(get_class($user1), $user2->id);
+
+        $this->assertEquals(3, count($user2->groups));
+        $this->assertEquals(2, count($user1->groups));
+    }
+
+    public function testNotCloneAndPassAroundFlush()
+    {
+        $user1 = $this->user1;
+        $user2 = $this->user2;
+
+        $group3 = new CmsGroup();
+        $group3->name = "test";
+        $user2->groups = $user1->groups;
+        $user2->groups->add($group3);
+
+        $this->assertEQuals(1, count($user1->groups->getInsertDiff()));
+
+        $this->_em->persist($group3);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $user1 = $this->_em->find(get_class($user1), $user1->id);
+        $user2 = $this->_em->find(get_class($user1), $user2->id);
+
+        $this->assertEquals(3, count($user2->groups));
+        $this->assertEquals(3, count($user1->groups));
+    }
+}
+

vendor/doctrine/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1695Test.php

+<?php
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+/**
+ * @group DDC-1695
+ */
+class DDC1695Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    public function testIssue()
+    {
+        if ($this->_em->getConnection()->getDatabasePlatform()->getName() != "sqlite") {
+            $this->markTestSkipped("Only with sqlite");
+        }
+        $dql = "SELECT n.smallText, n.publishDate FROM " . __NAMESPACE__ . "\\DDC1695News n";
+        $sql = $this->_em->createQuery($dql)->getSQL();
+
+        $this->assertEquals(
+            'SELECT d0_."SmallText" AS SmallText0, d0_."PublishDate" AS PublishDate1 FROM "DDC1695News" d0_',
+            $sql
+        );
+    }
+}
+
+/**
+ * @Table(name="`DDC1695News`")
+ * @Entity
+ */
+class DDC1695News
+{
+    /**
+     * @var integer $idNews
+     *
+     * @Column(name="`IdNews`", type="integer", nullable=false)
+     * @Id
+     * @GeneratedValue
+     */
+    private $idNews;
+
+    /**
+     * @var bigint $iduser
+     *
+     * @Column(name="`IdUser`", type="bigint", nullable=false)
+     */
+    private $idUser;
+
+    /**
+     * @var integer $idLanguage
+     *
+     * @Column(name="`IdLanguage`", type="integer", nullable=false)
+     */
+    private $idLanguage;
+
+    /**
+     * @var integer $idCondition
+     *
+     * @Column(name="`IdCondition`", type="integer", nullable=true)
+     */
+    private $idCondition;
+
+    /**
+     * @var integer $idHealthProvider
+     *
+     * @Column(name="`IdHealthProvider`", type="integer", nullable=true)
+     */
+    private $idHealthProvider;
+
+    /**
+     * @var integer $idSpeciality
+     *
+     * @Column(name="`IdSpeciality`", type="integer", nullable=true)
+     */
+    private $idSpeciality;
+
+    /**
+     * @var integer $idMedicineType
+     *
+     * @Column(name="`IdMedicineType`", type="integer", nullable=true)
+     */
+    private $idMedicineType;
+
+    /**
+     * @var integer $idTreatment
+     *
+     * @Column(name="`IdTreatment`", type="integer", nullable=true)
+     */
+    private $idTreatment;
+
+    /**
+     * @var string $title
+     *
+     * @Column(name="`Title`", type="string", nullable=true)
+     */
+    private $title;
+
+    /**
+     * @var string $smallText
+     *
+     * @Column(name="`SmallText`", type="string", nullable=true)
+     */
+    private $smallText;
+
+    /**
+     * @var string $longText
+     *
+     * @Column(name="`LongText`", type="string", nullable=true)
+     */
+    private $longText;
+
+    /**
+     * @var datetimetz $publishDate
+     *
+     * @Column(name="`PublishDate`", type="datetimetz", nullable=true)
+     */
+    private $publishDate;
+
+    /**
+     * @var tsvector $idxNews
+     *
+     * @Column(name="`IdxNews`", type="tsvector", nullable=true)
+     */
+    private $idxNews;
+
+    /**
+     * @var boolean $highlight
+     *
+     * @Column(name="`Highlight`", type="boolean", nullable=false)
+     */
+    private $highlight;
+
+    /**
+     * @var integer $order
+     *
+     * @Column(name="`Order`", type="integer", nullable=false)
+     */
+    private $order;
+
+    /**
+     * @var boolean $deleted
+     *
+     * @Column(name="`Deleted`", type="boolean", nullable=false)
+     */
+    private $deleted;
+
+    /**
+     * @var boolean $active
+     *
+     * @Column(name="`Active`", type="boolean", nullable=false)
+     */
+    private $active;
+
+    /**
+     * @var boolean $updateToHighlighted
+     *
+     * @Column(name="`UpdateToHighlighted`", type="boolean", nullable=true)
+     */
+    private $updateToHighlighted;
+}

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

         $orExpr = $this->_expr->orx();
         $orExpr->add($this->_expr->quot(5, 2));
     }
-}
+
+    /**
+     * @group DDC-1683
+     */
+    public function testBooleanLiteral()
+    {
+        $this->assertEquals('true', $this->_expr->literal(true));
+        $this->assertEquals('false', $this->_expr->literal(false));
+    }
+}

vendor/doctrine/tests/Doctrine/Tests/ORM/Tools/Export/AbstractClassMetadataExporterTest.php

     protected function _createMetadataDriver($type, $path)
     {
         $mappingDriver = array(
-            'php' => 'PHPDriver',
+            'php'        => 'PHPDriver',
             'annotation' => 'AnnotationDriver',
-            'xml' => 'XmlDriver',
-            'yaml' => 'YamlDriver',
+            'xml'        => 'XmlDriver',
+            'yaml'       => 'YamlDriver',
         );
         $this->assertArrayHasKey($type, $mappingDriver, "There is no metadata driver for the type '" . $type . "'.");
         $driverName = $mappingDriver[$type];
      * @depends testIdentifierIsExported
      * @param ClassMetadataInfo $class
      */
-    public function testFieldsAreExpored($class)
+    public function testFieldsAreExported($class)
     {
         $this->assertTrue(isset($class->fieldMappings['id']['id']) && $class->fieldMappings['id']['id'] === true);
         $this->assertEquals('id', $class->fieldMappings['id']['fieldName']);
     }
 
     /**
-     * @depends testFieldsAreExpored
+     * @depends testFieldsAreExported
      * @param ClassMetadataInfo $class
      */
     public function testOneToOneAssociationsAreExported($class)
     {
         $this->assertTrue(isset($class->associationMappings['address']));
-        //$this->assertTrue($class->associationMappings['address'] instanceof \Doctrine\ORM\Mapping\OneToOneMapping);
         $this->assertEquals('Doctrine\Tests\ORM\Tools\Export\Address', $class->associationMappings['address']['targetEntity']);
         $this->assertEquals('address_id', $class->associationMappings['address']['joinColumns'][0]['name']);
         $this->assertEquals('id', $class->associationMappings['address']['joinColumns'][0]['referencedColumnName']);
     }
 
     /**
+     * @depends testFieldsAreExported
+     */
+    public function testManyToOneAssociationsAreExported($class)
+    {
+        $this->assertTrue(isset($class->associationMappings['mainGroup']));
+        $this->assertEquals('Doctrine\Tests\ORM\Tools\Export\Group', $class->associationMappings['mainGroup']['targetEntity']);
+    }
+
+    /**
      * @depends testOneToOneAssociationsAreExported
      * @param ClassMetadataInfo $class
      */
             return rmdir($path);
         }
     }
-}
+}

vendor/doctrine/tests/Doctrine/Tests/ORM/Tools/Export/annotation/Doctrine.Tests.ORM.Tools.Export.User.php

     public $address;
 
     /**
+     * @ManyToOne(targetEntity="Doctrine\Tests\ORM\Tools\Export\Group")
+     */
+    public $mainGroup;
+
+    /**
      *
      * @OneToMany(targetEntity="Doctrine\Tests\ORM\Tools\Export\Phonenumber", mappedBy="user", cascade={"persist", "merge"}, orphanRemoval=true)
      * @OrderBy({"number"="ASC"})

vendor/doctrine/tests/Doctrine/Tests/ORM/Tools/Export/php/Doctrine.Tests.ORM.Tools.Export.User.php

    'columnDefinition' => 'CHAR(32) NOT NULL',
   ));
 $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
+$metadata->mapManyToOne(array(
+    'fieldName' => 'mainGroup',
+    'targetEntity' => 'Doctrine\\Tests\\ORM\Tools\\Export\\Group',
+));
 $metadata->mapOneToOne(array(
    'fieldName' => 'address',
    'targetEntity' => 'Doctrine\\Tests\\ORM\\Tools\\Export\\Address',
    ),
    ),
    'orderBy' => NULL,
-  ));
+  ));

vendor/doctrine/tests/Doctrine/Tests/ORM/Tools/Export/xml/Doctrine.Tests.ORM.Tools.Export.User.dcm.xml

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping
                           http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
-                              
+
     <entity name="Doctrine\Tests\ORM\Tools\Export\User" table="cms_users">
-        
+
         <lifecycle-callbacks>
             <lifecycle-callback type="prePersist" method="doStuffOnPrePersist"/>
             <lifecycle-callback type="prePersist" method="doOtherStuffOnPrePersistToo"/>
         <id name="id" type="integer" column="id">
             <generator strategy="AUTO"/>
         </id>
-        
+
         <field name="name" column="name" type="string" length="50" nullable="true" unique="true" />
         <field name="email" column="user_email" type="string" column-definition="CHAR(32) NOT NULL" />
-        
+
         <one-to-one field="address" target-entity="Doctrine\Tests\ORM\Tools\Export\Address" inversed-by="user" orphan-removal="true">
             <cascade><cascade-persist /></cascade>
             <join-column name="address_id" referenced-column-name="id" on-delete="CASCADE" on-update="CASCADE"/>
         </one-to-one>
-        
+
+        <many-to-one field="mainGroup" target-entity="Doctrine\Tests\ORM\Tools\Export\Group" />
+
         <one-to-many field="phonenumbers" target-entity="Doctrine\Tests\ORM\Tools\Export\Phonenumber" mapped-by="user" orphan-removal="true">
             <cascade>
                 <cascade-persist/>
                 <order-by-field name="number" direction="ASC" />
             </order-by>
         </one-to-many>
-        
+
+        <one-to-many field="interests" target-entity="Doctrine\Tests\ORM\Tools\Export\Interests" mapped-by="user" orphan-removal="true">
+            <cascade>
+                <cascade-refresh/>
+                <cascade-persist/>
+                <cascade-merge/>
+                <cascade-detach/>
+                <cascade-remove/>
+            </cascade>
+        </one-to-many>
+
         <many-to-many field="groups" target-entity="Doctrine\Tests\ORM\Tools\Export\Group">
             <cascade>
                 <cascade-all/>
                 </inverse-join-columns>
             </join-table>
         </many-to-many>
-        
+
     </entity>
 
 </doctrine-mapping>

vendor/doctrine/tests/Doctrine/Tests/ORM/Tools/Export/yaml/Doctrine.Tests.ORM.Tools.Export.User.dcm.yml

       cascade: [ remove, persist ]
       inversedBy: user
       orphanRemoval: true
+  manyToOne:
+    mainGroup:
+      targetEntity: Doctrine\Tests\ORM\Tools\Export\Group
   oneToMany:
     phonenumbers:
       targetEntity: Doctrine\Tests\ORM\Tools\Export\Phonenumber

vendor/doctrine/tests/Doctrine/Tests/OrmFunctionalTestCase.php

 
     /* Shared connection when a TestCase is run alone (outside of it's functional suite) */
     protected static $_sharedConn;
-    
+
     /**
      * @var \Doctrine\ORM\EntityManager
      */
     {
         $this->_usedModelSets[$setName] = true;
     }
-    
+
     /**
      * Sweeps the database tables and clears the EntityManager.
      */
     protected function setUp()
     {
         $forceCreateTables = false;
-        
+
         if ( ! isset(static::$_sharedConn)) {
             static::$_sharedConn = TestUtil::getConnection();
-            
+
             if (static::$_sharedConn->getDriver() instanceof \Doctrine\DBAL\Driver\PDOSqlite\Driver) {
                 $forceCreateTables = true;
             }
                 static::$_sharedConn->executeQuery('SELECT 1 /*' . get_class($this) . '*/ FROM dual');
             }
         }
-        
+
         if ( ! $this->_em) {
             $this->_em = $this->_getEntityManager();
             $this->_schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->_em);
         }
 
         $classes = array();
-        
+
         foreach ($this->_usedModelSets as $setName => $bool) {
             if ( ! isset(static::$_tablesCreated[$setName])/* || $forceCreateTables*/) {
                 foreach (static::$_modelSets[$setName] as $className) {
                     $classes[] = $this->_em->getClassMetadata($className);
                 }
-                
+
                 static::$_tablesCreated[$setName] = true;
             }
         }
-        
+
         if ($classes) {
             $this->_schemaTool->createSchema($classes);
         }
 
         $this->_sqlLoggerStack = new \Doctrine\DBAL\Logging\DebugStack();
         $this->_sqlLoggerStack->enabled = false;
-        
+
         //FIXME: two different configs! $conn and the created entity manager have
         // different configs.
         $config = new \Doctrine\ORM\Configuration();
         $config->setProxyNamespace('Doctrine\Tests\Proxies');
 
         $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
-        
+
         $conn = static::$_sharedConn;
         $conn->getConfiguration()->setSQLLogger($this->_sqlLoggerStack);
 
                 $evm->removeEventListener(array($event), $listener);
             }
         }
-        
+
         if (isset($GLOBALS['db_event_subscribers'])) {
             foreach (explode(",", $GLOBALS['db_event_subscribers']) AS $subscriberClass) {
                 $subscriberInstance = new $subscriberClass();
                 $evm->addEventSubscriber($subscriberInstance);
             }
         }
-        
+
         return \Doctrine\ORM\EntityManager::create($conn, $config);
     }
 
                 $params = array_map(function($p) { if (is_object($p)) return get_class($p); else return "'".$p."'"; }, $query['params'] ?: array());
                 $queries .= ($i+1).". SQL: '".$query['sql']."' Params: ".implode(", ", $params).PHP_EOL;
             }
-            
+
             $trace = $e->getTrace();
             $traceMsg = "";
             foreach($trace AS $part) {
 
     /**
      * Using the SQL Logger Stack this method retrieves the current query count executed in this test.
-     * 
+     *
      * @return int
      */
     protected function getCurrentQueryCount()

vendor/swiftmailer/CHANGES

-Changelog since Version 4.1.x
+Changelog since Version 4.x.x
 =============================
 
+4.2.1 (2012-07-13)
+------------------
+
+ * changed the coding standards to PSR-1/2
+ * fixed issue with autoloading
+ * added NativeQpContentEncoder to enhance performance (for PHP 5.3+)
+
+4.2.0 (2012-06-29)
+------------------
+
+ * added documentation about how to use the Japanese support introduced in 4.1.8
+ * added a way to override the default configuration in a lazy way
+ * changed the PEAR init script to lazy-load the initialization
+ * fixed a bug when calling Swift_Preferences before anything else (regression introduced in 4.1.8)
+
+4.1.8 (2012-06-17)
+------------------
+
+ * added Japanese iso-2022-jp support
+ * changed the init script to lazy-load the initialization
+ * fixed docblocks (@id) which caused some problems with libraries parsing the dobclocks
+ * fixed Swift_Mime_Headers_IdentificationHeader::setId() when passed an array of ids
+ * fixed encoding of email addresses in headers
+ * added replacements setter to the Decorator plugin
+
 4.1.7 (2012-04-26)
 ------------------