avoiding tree conflicts in controlled website

[Eric Horne <su...@box11.org>]

Hello subversion users. I have a 'how-would-you-do-this' question for 
you. An answer wasn't apparent on google or recent SVN mail archives, so 
I'm hoping you kind folks can help.

Subversion is controlling change to a website I manage (running the CMS 
Joomla!) , which is to say subversion holds the source of record for 
what is supposed to be public. We have third party extensions installed 
on the site as well. From time-to-time the extensions (and Joomla! 
itself) are altered to our specifications. The desire is to use 
subversion to track changes, and more importantly manage our localized 
changes against incoming changes from the third-party extensions (and 
updates from Joomla! )

What I have done is I've created a trunk for the base Joomla! release 
and branched that trunk into a site specific branch. Similarly, I would 
like to place the unbundled extensions into their own trunks in the same 
repo and branch them when a local change is needed, and then merge that 
branch into into the website's branch. For example, the website contains 
a top-level 'components' directory. An extension adds stuff inside that 
directory to make 'components/com_mystuff/...'.

Here's the rub: when I import the base extension code subversion wants 
to create the 'components' directory as a new entity creating an 'evil 
twin' (in ClearCase lingo). So when I go to merge the extension branch 
into the website branch, I get a tree-conflict and no merge of the 
directory. Note that extensions probably also go into more than just the 
'components' directory (they could also go into 
'administrator/components', 'plugins/content', 'languages', or any 
number of other places).

A solution that seems to work is to branch the Joomla! base into the 
extension branch first, then manually merge all the new directories (an 
extension should NEVER change an existing file, it will always be new) 
from the extension I want to add into the extension branch. Check in and 
merge into the website branch. While it works, it seems very 
heavy-handed (checking out 9000+ files/directories to add new structure 
that affects a very small percentage of those checked out items).

Another solution is to first create the common directory structure and 
import that first. Then add the new files, and merge from that revision 
forward (skipping the initial import). While it also works, it will 
break the first time a component update adds a new common directory and 
I don't catch it first. Plus it still creates the evil twins, they are 
just ignored; that seems less than robust.

Similar to the one above, I could branch the individual new directories, 
but I think I still end up with the contents of those directories (e.g. 
merging just 'components', I'd get 'components/com_notrelated1' and 
'components/com_notrelated2', ... so less than all the files in Joomla!, 
but still quite a few). This would also force me to individually branch 
each common directory, which seems like a lot of tedious and error-prone 
prework.

The final, and least attractive solution I thought of was to merge from 
the new directory levels and below. This is really not something I want 
to do because it requires remembering which directories are common and 
which aren't, and it would require 4 or 5 merge attempts (one for each 
new directory under a common directory). And if it starts adding files 
into common directories, I'd have to merge each individual file. yikes!

Ideally, there would be a way to merge the two top-level directories 
without getting a tree-conflict, in a single merge attempt without 
having to checkout files or directories that are not involved in the 
merge. Are there better approaches that I'm not thinking of?

Thanks for your help!

-Eric