My VirtualHosts in /etc/apache2/extra/httpd-vhosts.conf were kept, but going to http://localhost/ took me to the default “It Works!” page. I quickly discovered that the httpd.conf file was reset. Stuff I had to do to fix it below.

• In httpd.conf, uncomment Include /private/etc/apache2/extra/httpd-vhosts.conf
• In httpd.conf, include the path to mod_php, in my case LoadModule php5_module /usr/local/Cellar/php54/5.4.19/libexec/apache2/libphp5.so
• Create a file <yourusername>.conf in /etc/apache2/users with content

1
2
3
4
5
6

<Directory "/path/to/your/sites/">
Options Indexes MultiViews FollowSymLinks
AllowOverride All
Order allow,deny
Allow from all
</Directory>

• Chown the file sudo chown root:wheel /etc/apache2/users/<yourusername>.conf
• Restart Apache with sudo apachectl restart

That fixed it for me.

So I threw the bundle in my composer.json file and decided I’d only load it for the dev environment and only if xhprof was installed.

1
2
3
4
5
6

if (in_array($this->getEnvironment(), array('dev', 'test'))) {
    // ...
    if (function_exists('xhprof_enable')) {
       $bundles[] = new Jns\Bundle\XhprofBundle\JnsXhprofBundle();
    }
}

Now, the issue with this is: the jns/xhprof-bundle requires some configuration. You can’t just leave the configuration inside your config.yml, because then Symfony would complain that it doesn’t know why those configuration values are there.

I got the answer on the Symfony IRC channel from jrobeson: use a closure loader. Where you load your configuration file, add the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public function registerContainerConfiguration(LoaderInterface $loader)
{
    $loader->load(__DIR__.'/config/config_'.$this->getEnvironment().'.yml');

    if (in_array($this->getEnvironment(), array('dev', 'test')) && function_exists('xhprof_enable')) {
        $closureLoader = function(ContainerBuilder $container) {
            $container->loadFromExtension('jns_xhprof', array(
                'location_lib'    => '/path/to/xhprof_lib.php',
                'location_runs'   => '/path/to/xhprof_runs.php',
                'location_config' => null,
                'location_web'    => 'http://localhost/xhprof/',
                'enabled'         => true,
            ));
        };
        $loader->load($closureLoader);
    }
}

Note: I know I could have used a different environment, but using this way, if xhprof was installed on the server, I could use it there as well (we have a staging environment on the server that runs the app in dev mode).

• Doing git status or git branch just to know which branch was active
• Doing git checkout dTab in the hopes of getting git checkout develop

This might be horribly obvious to some people and don’t ask me why, but only after months of cursing at this, I decided to Google these two things and make my Git life easier.

Git auto-complete

For the auto-complete, I found this stackexchange question: git auto-complete for branches at the command line?. Michael Durrant’s answer is surprisingly simple, but works just fine: download a git-autocomplete bash script and call it in your ~/.bash_profile file.

curl https://raw.github.com/git/git/master/contrib/completion/git-completion.bash -o ~/.git-completion.bash

Edit (or create) your ~/.bash_profile file with your favorite editor (Vim, Nano or maybe even Sublime?) and paste the following:

if [ -f ~/.git-completion.bash ]; then
    . ~/.git-completion.bash
fi

Note that this not only works for branches. If you do git TabTab (note the space after git), you get a list of all git sub-commands. git blTab would auto-complete to git blame.

Displaying branch names in Terminal

To display branch names in terminal (next to the current directory), I used a solution found here. Simply copy/paste the following lines in the same ~/.bash_profile as before

parse_git_branch() {
    git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}
export PS1="\u@\h \W\[\033[32m\]\$(parse_git_branch)\[\033[00m\] $ "

Notes

• If you already have a PS1 variable, just add the \$(parse_git_branch) somewhere in there.
• \[\033[32m\] sets the color of the branch name to green. \[\033[00m\] sets everything back to black. To change the color of the branch name, change the 2 in the [32m\] bit. You can find the color codes on Wikipedia.
• You do not need to restart Terminal or anything for the changes to take effect, just do source ~/.bash_profile.

I wanted to use jonaswouters’ XHProfBundle, but out of the box, this would have caused a bit of an issue when deploying: I couldn’t simply enable the bundle in AppKernel.php because Staging also runs the dev environment and XHProf isn’t installed on the server.

I decided to wrap the bundle loading in if():

1
2
3
4
5
6
7
8

if (in_array($this->getEnvironment(), array('dev', 'test'))) {
    $bundles[] = new Symfony\Bundle\WebProfilerBundle\WebProfilerBundle();
    $bundles[] = new Sensio\Bundle\DistributionBundle\SensioDistributionBundle();
    $bundles[] = new Sensio\Bundle\GeneratorBundle\SensioGeneratorBundle();
    if (function_exists('xhprof_enable')) {
        $bundles[] = new Jns\Bundle\XhprofBundle\JnsXhprofBundle();
    }
}

This would load the bundle only if XHProf was installed on the server.

However, the bundle needs a bit of configuration in config.yml. Trying to work with a configuration file that has configuration for bundles that aren’t loaded will result in an InvalidArgumentException:

There is no extension able to load the configuration for “jns_xhprof”

As I couldn’t repeat the above if() in config.yml, I went looking for another solution. jrobeson over on IRC suggested a closure loader. In AppKernel.php, in registerContainerConfiguration() your config file is loaded using $loader->load($resource). The resource being the path to your config file.

You can also pass a closure to the same method. That closure will receive an instance of ContainerBuilder which provides the method loadFromExtension(), which in turn can be used to load configuration from an array. This works like so:

1
2
3
4
5
6
7
8
9
10
11

public function registerContainerConfiguration(LoaderInterface $loader)
{
    $loader->load(__DIR__.'/config/config_'.$this->getEnvironment().'.yml');

    $closureLoader = function($container) {
        $container->loadFromExtension('extension_name', array(
            // Config here
        ));
    };
    $loader->load($closureLoader);
}

extension_name is the name you would put in your config file, jns_xhprof in my case. All that’s left to do was wrap the $closureLoader stuff in the same if() as the bundle loading and I was done. Now I can use XHProf locally and the server won’t error on my next deploy.

1
2
3

$ composer update
...
Installing assets using the hard copy option

Ugh fuck. Now I have to make sure I don’t forget app/console assets:install --symlink, or I’m gonna be cursing next time I’m adjusting CSS and I don’t see my changes happening, because I forgot they’re no longer symlinked.

By fumbling around, I noticed you can set an environment variable, called SYMFONY_ASSETS_INSTALL that will define the method used when installing assets after a composer update.

To do this on Mac OS X, add this to your ~/.bash_profile:

1

export SYMFONY_ASSETS_INSTALL=symlink" to ~/.bash_profile

This is trivial when all emails are sent from within the browser and Symfony has an active request. However, when trying to send mails from the spool via command line, you’ll be hit by an exception.

You cannot create a service (“request”) of an inactive scope (“request”).

There’s a cookbook entry that gives a hint, but not a solution. By setting the context parameters in your parameters.yml file, you can keep using the url() function in your Twig templates, but trying to use app.request.host (or similar) will still end with the same exception.

The simplest solution, in my opinion, is a Twig extension that will receive an instance of the Router:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

namespace Acme\DemoBundle\Twig;

use Symfony\Component\Routing\RouterInterface;

class TwigExtension extends \Twig_Extension
{
    protected $router;

    /**
     * Receive Router instance
     */
    public function __construct(RouterInterface $router)
    {
        $this->router = $router;
    }

    /**
     * Declare the asset_url function
     */
    public function getFunctions()
    {
        return array(
            'asset_url' => new \Twig_Function_Method($this, 'assetUrl'),
        );
    }

    /**
     * Implement asset_url function
     * We get the router context. This will default to settings in
     * parameters.yml if there is no active request
     */
    public function assetUrl($path)
    {
        $context = $this->router->getContext();
        $host = $context->getScheme().'://'.$context->getHost();

        return $host.$path;
    }

    /**
     * Set a name for the extension
     */
    public function getName()
    {
        return 'twig_extension';
    }
}

Declare the extension in your services.yml and pass it the router service.

1
2
3
4
5
6

services:
    twigextension:
        class:     Acme\DemoBundle\Twig\TwigExtension
        arguments: [@router]
        tags:
            - { name: twig.extension }

Make sure you don’t forget the context parameters in parameters.yml

1
2
3
4

parameters.yml
    router.request_context.host: example.com
    router.request_context.scheme: http
    router.request_context.base_url:

Now you can use this in your views:

1

{{ asset_url('/path/to/asset.png') }}

And it will generate a url like “http://example.com/path/to/asset.png”, doesn’t matter if the view was generated during an actual request, or from command line.