Deconstructing Symfony: Part I – Getting Rid of Bad Practices Takes Effort

I tried to avoid the bad practice of generating code. So I decided it was enough and created a custom Application.php class on my app/ folder and use that instead inside the console script. Something like this:

#!/usr/bin/env php
require_once __DIR__.'/bootstrap.php.cache';
require_once __DIR__.'/AppKernel.php';
require_once __DIR__.'/Application.php';
use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Debug\Debug;
$input = new ArgvInput();
$env = $input->getParameterOption(array('--env', '-e'), getenv('SYMFONY_ENV') ?: 'dev');
$debug = getenv('SYMFONY_DEBUG') !== '0' && !$input->hasParameterOption(array('--no-debug', '')) && $env !== 'prod';
if ($debug) {
$kernel = new AppKernel($env, $debug);
$application = new Application($kernel);

The Application.php class basically extends the regular application but overrides this method:

use Symfony\Bundle\FrameworkBundle\Console\Application as BaseApplication;
class Application extends BaseApplication
    protected function registerCommands()
        $container = $this->getKernel()->getContainer();
        if ($container->hasParameter('console.command.ids')) {
            foreach ($container->getParameter('console.command.ids') as $id) {

The only extra step is to basically register by hand the Commands that you actually:

– care about
– are good commands for your project
– are actually used often
– are safe for your developers
– are within your flow
– are good practices

So the method looks like this:

    public function getCommands()
        $containerAwares = [
            new CacheClearCommand(),
            new DumpCommand(),
            new AssetsInstallCommand(),
            new CacheWarmupCommand(),
            new ConfigDumpReferenceCommand(),
            new ContainerDebugCommand(),
            new RouterDebugCommand(),
            new RouterMatchCommand(),
            new ServerRunCommand(),
            new LintCommand(),
            new CreateDatabaseDoctrineCommand(),
            new DropDatabaseDoctrineCommand(),
            new InfoDoctrineODMCommand(),
            new LoadDataFixturesDoctrineODMCommand(),
            new DebugCommand(),
            new SendEmailCommand(),
        $regularCommands = [
            new UpdateSchemaDoctrineCommand(),
            new UpdateSchemaDoctrineODMCommand(),
            new ClearMetadataCacheDoctrineCommand(),
            new ClearMetadataCacheDoctrineODMCommand(),
            new ClearQueryCacheDoctrineCommand(),
            new ClearResultCacheDoctrineCommand(),
            new EnsureProductionSettingsCommand(),
            new QueryDoctrineODMCommand(),
            new CreateSchemaDoctrineODMCommand(),
            new DropSchemaDoctrineODMCommand(),
            new TailCursorDoctrineODMCommand(),
            new RunDqlDoctrineCommand(),
            new RunSqlDoctrineCommand(),
            new CreateSchemaDoctrineCommand(),
            new DropSchemaDoctrineCommand(),
            new UpdateSchemaDoctrineCommand(),
            new ValidateSchemaCommand(),
        foreach ($containerAwares as $command) {
        return array_merge($containerAwares, $regularCommands);

You can let go of the commands that are mongodb if you don’t use mongodb. This actually feels faster and I don’t have to worry about generators.

That is it, let the reader understand 🙂

Encouragements in all good.


3 thoughts on “Deconstructing Symfony: Part I – Getting Rid of Bad Practices Takes Effort

  1. Nice initiative! I’d gladly do without a majority of the commands I never use.

    One thing though: why not check if the commands implement ContainerAwareInterface instead of keeping two separate lists?

  2. Greetings! I know this is kinda off topic but I
    was wondering if you knew where I could get a captcha plugin for my comment form?

    I’m using the same blog platform as yours and I’m having problems finding one?

    Thanks a lot!

Leave a Reply to Tobias Sjösten Cancel reply

Your email address will not be published. Required fields are marked *