Да, вы можете использовать Mercurial для этого. Вот как это будет работать.
Допустим, ваш текущий клон называется new-dot-net, так как он
Поддержка новой версии .Net. Вы делаете клон этого и называете это
old-dot-net или что-то в этом роде. Два клона теперь идентичны
и обе цели .Net 3.5.
Теперь аккуратно внесите небольшие изменения в old-dot-net, чтобы сделать это
Совместим с .Net 2.0. Когда вы сделаете изменения, два клона
начать расходиться:
new-dot-net: ... [a] --- [b]
old-dot-net: ... [a] --- [b] --- [c] --- [d]
Здесь вы сделали [c] и [d] наборы изменений, чтобы добавить .Net 2.0
совместимость. Обратите внимание, что клон old-dot-net содержит больше
наборов изменений, чем new-dot-net, поскольку он имеет обратную совместимость
изменения, которые вы не хотите видеть в new-dot-net. Как вы продолжаете
работая, важно подумать об этом: net-dot-net будет содержать
подмножество наборов изменений в old-dot-net. Изменения текут из
new-dot-net до old-dot-net, но никогда в обратном направлении.
Допустим, вы вносите новое изменение в new-dot-net. Вы делаете изменения
в new-dot-net и теперь ситуация выглядит так:
new-dot-net: ... [a] --- [b] --- [x]
old-dot-net: ... [a] --- [b] --- [c] --- [d]
Теперь вы хотите перенести изменение на old-dot-net, вы
изменить на old-dot-net и вытащить с net-dot-net:
% cd old-dot-net
% hg pull ../new-dot-net
Это создаст новую головку в old-dot-net:
[x]
/
old-dot-net: ... [a] --- [b] --- [c] --- [d]
, поскольку [x] changeset имеет [b] как родительский набор изменений. Ты сейчас
имеют несколько головок и должны объединиться, чтобы уменьшить количество
головы. Объединяя, вы создаете новую ревизию, которая является вашим способом
говоря "это то, как [x] и [d] должны быть объединены". Если [x]
changeset касается только кода, который также не затрагивается в [c] и
[d], тогда слияние должно просто сработать. В противном случае вы будете представлены
с инструментом слияния и должны разрешить конфликт. Вы совершаете
объединить как chageset [e]:
[x] --------------.
/ \
old-dot-net: ... [a] --- [b] --- [c] --- [d] --- [e]
И все готово - теперь вы включили [x] изменение в
ваш .Net 2.0 совместимый код.
Вы повторяете это каждый раз, когда в new-dot-net вносятся изменения.
Допустим, добавлено больше функций:
new-dot-net: ... [a] --- [b] --- [x] --- [y] --- [z]
Потянув их в old-dot-net, вы получите
[x] --------------.---- [y] --- [z]
/ \
old-dot-net: ... [a] --- [b] --- [c] --- [d] --- [e]
И теперь вы объединяете [e] и [z]:
[x] --------------.---- [y] --- [z]
/ \ \
old-dot-net: ... [a] --- [b] --- [c] --- [d] --- [e] ----------- [f]
Важные части, которые следует запомнить:
- делает любые новые функции в
new-dot-net.
- pull изменяется на
old-dot-net
- никогда не нажимайте от
old-dot-net до new-dot-net.
Если вы когда-нибудь обнаружите, что изменение new-dot-net не является
необходимо в old-dot-net, тогда вам все еще нужно вытащить его и объединить
Это. Но тогда вы сделаете фиктивное слияние . Если головы [w] и
[g], и вы хотите сохранить [g], затем выполните
% HGMERGE=true hg merge -y
% hg revert --all --rev g
% hg commit -m 'Dummy merge with y.'
Хитрость состоит в том, чтобы выполнить слияние, не заботясь о результатах,
затем отменить все изменения и зафиксировать неизмененную рабочую копию как
слияния. Таким образом, вы говорите миру, что «комбинация [w] и
[g] - это [g] ", т.е. вы отбрасываете изменения в [w]. Новый
изменения, сделанные в new-dot-net после [w], могут быть объединены как
нормальный.