Working on Drupal core since dependencies were removed from git has seemed really fiddly. For a long time I thought I must have missed something, that there was some undocumented technique I wasn’t aware of.
But I’ve asked various people who work on core a lot more than I do, and they’ve confirmed that what I’ve been doing is pretty much the way that they do it:
- Get a git clone of Drupal core.
composer installon it.
- Write code!
- Make a patch (well, a merge request now!)
That all sounds simple, right? But wait! If you’re working on core, you’re going to want Devel module for its useful debugging and inspection tools, right? And Drush, for quick cache clearing. And probably Admin Toolbar so going around the UI is quicker.
But you have to install all those with Composer. And doing that dirties the composer.lock file that’s part of Drupal core’s git clone.
It’s fairly simple to keep changes to that file out of your merge request or patch, but pretty soon, you’re going to do a
git pull on core that’s going to include changes to the composer.lock file, because core will have updates to dependencies.
And that’s where it all starts to go wrong, because the
git pull will fail because of conflicts in the composer.lock file and in other Composer files, and conflicts in that file are really painful to resolve.
So maintaining an ongoing Drupal install that uses a Drupal core git clone quickly becomes a mess. As far as I know, most core developers frequently reset the whole thing and reinstall from scratch.
The problem is caused by using the git clone of Drupal core as the Composer project, so that Drupal core’s composer.json is being used as the project composer.json. But there’s a better way…
Using Composer with git clones
Composer has a way of using a git clone for a package in a project:
- Create your own git clone of the package
- Declare that git clone as a Composer package repository in the project’s composer.json
- Install the package
The result is that Composer creates a symlink from your git clone into the project, and doesn’t touch the git clone. You need to be fairly lax in the version requirement you give for the package, so that Composer doesn’t object to the git clone being on a feature branch later on.
This, as far as I know, is the standard way for working on a Composer package that you need to operate in the context of a project. It works for library packages and Composer plugins.
For Drupal core…? Well, it works, but as you might have guessed it’s a little more complicated.
Drupal has opinions about where it expects to be located in a project, and furthermore, has a scaffolding system which writes files into the webroot when you install it. All of that gets a bit confused if you put Drupal core out of the way and symlink it in.
But with a few symlinks, and one sneaky patch to a scaffold file, it works. It’s all quite fiddly and so I’ve made…
The Drupal Core development project
This is a Composer project template, available at https://github.com/joachim-n/drupal-core-composer. It handles all the necessary tweaks to get Drupal to work when symlinked into a project: just follow the instructions in the README.
It’s not posted to Packagist, so you need to
git clone it rather than use
There are still a few limitations: those are detailed in the README too.
Of course, I’ve now fallen down the rabbithole of doing more work towards making Drupal completely agnostic of its location, rather than the core issues I wanted to work on in the first place.
Please try it, report any problems, and happy coding on Drupal core!
Go to Source