I added settings.php to a .gitignore file and checked the whole thing in to master, because I don’t ever want my sites folders to track the settings for a given location. Then, I moved up the sites code I developed earlier and checked it into a dev and production branch in git/sites. I created the bare repository for git/drupal now too.

Then, I went back to my local machine and removed the sites I had developed. I added them in as submodules instead:
$ git submodule add ssh://<snip>/git/sites sites/dev.my-project.local
$ git submodule add ssh://<snip>/git/sites sites/my-project.local
$ git submodule init

I made sure that each site was tracking the right branch and then checked the changes into the application branch of my project. Next, I added the remote repository:
$ git remote add origin ssh://<snip>/git/drupal
$ git push origin master
$ git push origin modules-and-themes
$ git push origin application

Now, I’m ready to clone this onto my host machine
$ git clone -l git/drupal/ production
$ cd production
$ git fetch
$ git checkout -b modules-and-themes
$ git rebase origin/modules-and-themes
$ git checkout -b application
$ git rebase origin/application

and check in its application
$ git submodule add ssh://<snip>/git/sites sites/www.my-project.com
$ git submodule init

I pushed this up and pulled it down to my local machine, so now both repositories know all about my three sites. I will only serve the two local sites locally and the www.my-project.com from my host, but I can live with that. I like that I can work on the two branches (dev and production) on the various sites, merge changes and commit the results as submodules into the application branch of my Drupal site.

One thing I really like about how Version Control Blog illustrates this process, is setting up the project with an older version of Drupal and then upgrading at the end, to show how simple it is. I will definitely follow that path.

So, to begin with, create a folder with a fresh download of Drupal and commit it to Git. At the command line:

$ drush dl drupal-6.15
$ mv drupal-6.15 my-project
$ cd my-project
$ git init
$ git add .
$ git commit -m "Drupal 6.15 imported"

Now create the branch for your modules and download some modules for it:
$ git checkout -b "modules"
$ drush dl cck
$ git add .
$ git commit -m "CCK 6.x-2.6 imported"
$ drush dl views
$ git add .
$ git commit -m "Views 6.x-2.8 imported"
$ git status

Now create the branch for your actual Drupal project:
$ git checkout -b application

Create two sites folders, one for a dev site, one for production:
$ mkdir sites/dev.my-projectlocal
$ mkdir sites/my-project.local

Copy and rename sites/default/default.settings.php over to the two new sites folders:
$ cp sites/default/default.settings.php sites/dev.my-project.local/settings.php
$ cp sites/default/default.settings.php sites/my-project.local/settings.php

Create the two databases in mysql:
mysql> create database my_project;
mysql> create database my_project_development;

The next step is to configure Passenger to send requests for my-project.local and dev.my-project.local to our Drupal application. For this, I need to edit my /etc/hosts file, adding these lines:
127.0.0.1 my-project.local
127.0.0.1 dev.my-project.local

I setup Passenger via Peepcode’s Phusion Passenger screencast, so my VirtualHost entry goes in a passenger_vhost.conf file and looks like this:
<VirtualHost *:80>
ServerName my-project.local
DocumentRoot /Library/WebServer/Documents/my-project
</VirtualHost *:80>
<VirtualHost *:80>
ServerName dev. my-project.local
DocumentRoot /Library/WebServer/Documents/my-project
</VirtualHost *:80>

Don’t forget to restart your server:
$ sudo apachectl graceful

Now you should be able to navigate to http://my-project.local and http://dev.my-project.local and install these apps as usual.

When you are done, check the two sites folders into Git:
$ git add .
$ git commit -m "Setting up development and production sites"

Don’t forget to block your webserver from exposing your Git files. Add this line to your .htaccess file:
RewriteRule ^\.git - [F]

Check it into Git as well. When I update from Drupal 6.15 to Drupal 6.16, Git nicely merges the changes to htaccess from the upgrade with my manual addition of this RewriteRule.

Now, here’s how to upgrade Drupal core. I have a copy of the latest Drupal release in my Downloads directory. I first switch back to my master branch, then copy the new Drupal files over to my project and then see what the changes are, just out of curiosity. I add them all in to master, then checkout modules and merge master into that. Then, I checkout application and merge modules into it.

$ git checkout master
$ cp -Rf ~/Downloads/drupal-6.16/ .
$ git status
$ git add .
$ git commit -m "Drupal 6.16 imported"
$ git checkout modules
$ git merge master
$ git checkout application
$ git merge modules

I’ll need to run the update.php script for each site, to update the databases, then I’m all set.

 I discovered today what happens when you add and commit with git while you are not on any branch.  You get a dangling commit and it looks for all the world like there is no way to get that work back.  But all is not lost!  Between  this great post in Mathieu Martin’s blog and Eric available just when I needed him even though he’s over in France, I figured out that you can use “git fsck –lost-found” to get the sha code and then “git rebase sha” to merge that commit into your working branch.  Phew.  I had a ton of tiny, picky changes and was really not looking forward to redoing them all!