Является ли git-svn dcommit после слияния в git опасным?

создание локальных ветвей определенно возможно с помощью git-svn. Пока вы просто используете локальные ветви для себя, а не пытаетесь использовать git для слияния между ветвями SVN вверх по течению, вы должны быть в порядке.

У меня есть ветка" master", которую я использую для отслеживания сервера svn. Это единственная ветка, из которой я dcommit. Если я делаю какую-то работу, я создаю ветку темы и работаю над ней. Когда я хочу совершить его, я делаю следующее:

1. совершить все в ветку темы
2. git svn rebase (разрешите любые конфликты между вашей работой и svn)
3. git checkout master
4. git svn rebase (это делает следующий шаг быстрого слияния, см. комментарии Аарона ниже)
5. git merge topic_branch
6. разрешить любые конфликты слияния (там не должно быть в этот момент)
7. git svn dcommit

У меня тоже есть еще ситуация, когда мне нужно поддерживать некоторые локальные изменения (для отладки), которые никогда не должны подталкиваться к svn. Для этого у меня есть вышеупомянутая главная ветвь, но также ветвь под названием "работа", где я обычно работаю. Ветви темы разветвлены от работы. Когда я хочу совершить работу там, я проверяю master и использую cherry-pick, чтобы выбрать коммиты из рабочей ветви, которую я хочу совершить в svn. Это потому, что я хочу избежать совершения трех локальных изменений. Затем, я dcommit от мастера ветви и перебазировать все.

стоит работает git svn dcommit -n во-первых, чтобы убедиться, что вы собираетесь совершить именно то, что вы намерены совершить. В отличие от git, переписывать историю в svn сложно!

Я чувствую, что должен быть лучший способ объединить изменения в ветке темы, пропуская эти локальные изменения, чем использовать cherry-pick, поэтому, если у кого-то есть идеи, они будут приветствоваться.

простое решение: удалите ветку "работа" после слияния

короткий ответ: вы можете использовать git, как вам нравится (см. ниже для простого рабочего процесса), включая слияние. Просто убедитесь, что следовать каждому'git merge work "С"git branch-d work ' для удаления временной рабочей ветви.

фон объяснение: Проблема слияния/dcommit заключается в том, что всякий раз, когда вы "git svn dcommit" ветвь, история слияния этой ветви "сплющена": git забывает обо всех операциях слияния, которые вошли в эту ветвь: сохраняется только содержимое файла, но тот факт, что это содержимое (частично) пришло из определенной другой ветви, теряется. Смотрите:почему ГИТ внесение изменений через dcommit СВН потерять историю коммитов слияния для местных филиалов?

(Примечание: существует не так много, что git-svn может сделать об этом: svn просто не понимает гораздо более мощные слияния git. Итак, внутри SVN репозиторий эта информация слияния не может быть представлена каким-либо образом.)

но это весь проблема. Если вы удалите ветвь "работа" после того, как она была объединена в "главную ветвь", то ваш репозиторий git на 100% чист и выглядит точно так же, как ваш репозиторий svn.

мой рабочий процесс: Конечно, я сначала клонировал удаленный репозиторий svn в локальный репозиторий git (это может занять некоторое время):

$> git svn clone <svn-repository-url> <local-directory>

все затем работа происходит внутри "local-directory". Всякий раз, когда мне нужно получить обновления с сервера (например, "svn update"), я делаю:

$> git checkout master
$> git svn rebase

я делаю всю свою работу по разработке в отдельной ветке "работа", которая создается следующим образом:

$> git checkout -b work

конечно, вы можете создать столько ветвей для своей работы, сколько вам нравится, и объединить и перебазировать между ними, как вам нравится (просто удалите их, когда вы закончите с ними-как описано ниже). В моей нормальной работе, я совершаю очень часто:

$> git commit -am '-- finished a little piece of work'

следующий шаг (git rebase-i) является необязательным --- это просто очистка истории перед архивированием ее на svn: как только я достиг стабильного камня мили, который я хочу поделиться с другими, я переписываю историю этой ветви "работы" и очищаю сообщения фиксации (другим разработчикам не нужно видеть все маленькие шаги и ошибки, которые я сделал по пути --- просто результат). Для этого я делаю

$> git log

и скопируйте хэш sha-1 последнего коммита то есть жить в репозитории svn (как указано в git-svn-id). Тогда я звоню

$> git rebase -i 74e4068360e34b2ccf0c5869703af458cde0cdcb

просто вставьте SHA-1 хэш нашего последнего svn commit вместо моего. Вы можете прочитать документацию с помощью "Git help rebase" для получения подробной информации. Короче говоря: эта команда сначала открывает редактор, представляющий ваши коммиты ---- просто измените "pick" на "squash" для всех тех коммитов, которые вы хотите раздавить с предыдущими коммитами. Конечно, первая строка должна остаться в качестве "выбора". Таким образом, вы может сконденсировать ваши многочисленные маленькие коммиты в одну или несколько значимых единиц. Сохраните и выйдите из редактора. Вы получите другой редактор с просьбой переписать сообщения журнала фиксации.

чтобы внести изменения в репозиторий svn, я делать:

$> git checkout master
$> git svn rebase

теперь мы вернулись в старую ветку "master", обновленную со всеми изменениями, которые произошли за это время в репозитории svn (ваши новые изменения скрыты в ветке "work").

если есть изменения, которые могут конфликтовать с вашими новыми изменениями "работы", вы должны решить их локально, прежде чем вы можете подтолкнуть свою новую работу (см. подробности ниже). Затем мы можем нажать наши изменения в svn:

$> git checkout master
$> git merge work        # (1) merge your 'work' into 'master'
$> git branch -d work    # (2) remove the work branch immediately after merging
$> git svn dcommit       # (3) push your changes to the svn repository

Примечание 1: команда 'git branch-d work' это довольно безопасно: он позволяет только удалять ветви, которые вам больше не нужны (потому что они уже объединены в вашу текущую ветку). Если вы выполняете эту команду по ошибке, прежде чем объединить свою работу с веткой "master", вы получите сообщение об ошибке.

примечание 2: обязательно удалите свою ветку с помощью "git branch-d work"между слияние и внесение изменений через dcommit: если вы попытаетесь удалить ветку после внесение изменений через dcommit, вы получите сообщение об ошибке: когда вы делаете 'в Git с SVN внесение изменений через dcommit', git забывает, что ваша ветвь была объединена с "мастером". Вы должны удалить его с помощью "git branch-D work", который не выполняет проверку безопасности.

теперь я сразу создаю новую ветку "работа", чтобы избежать случайного взлома на ветке "мастер":

$> git checkout -b work
$> git branch            # show my branches:
  master
* work

интеграция вашей "работы" с изменениями на SVN: Вот что я делаю, когда "git svn rebase" показывает, что другие изменили репозиторий svn, пока я работал над своей "работой" филиал:

$> git checkout master
$> git svn rebase              # 'svn pull' changes
$> git checkout work           # go to my work
$> git checkout -b integration # make a copy of the branch
$> git merge master            # integrate my changes with theirs
$> ... check/fix/debug ...
$> ... rewrite history with rebase -i if needed

$> git checkout master         # try again to push my changes
$> git svn rebase              # hopefully no further changes to merge
$> git merge integration       # (1) merge your work with theirs
$> git branch -d work          # (2) remove branches that are merged
$> git branch -d integration   # (2) remove branches that are merged
$> git svn dcommit             # (3) push your changes to the svn repository

существуют более мощные решения: Представленный рабочий процесс упрощен: он использует полномочия git только в каждом раунде "update/hack / dcommit" - - - но оставляет долгосрочную историю проекта такой же линейной, как и репозиторий svn. Это нормально, если вы просто хотите начать использовать git merges в небольших первых шагах в устаревшем проекте svn.

когда вы познакомитесь с слиянием git, не стесняйтесь исследовать другие рабочие процессы: Если вы знаете что ты делаешь, ты можете смесь сливается в Git с SVN сливает (используя git-svn (или аналогичный) просто, чтобы помочь с слиянием svn?)

Грег Хьюгилл ответ на вершине не является безопасным! Если какие-либо новые коммиты появились на транке между двумя "git svn rebase", слияние не будет перемотано вперед.

Это может быть обеспечено с помощью флага" --ff-only "для git-merge, но я обычно не запускаю" git svn rebase "в ветке, только" git rebase master " на нем (предполагая, что это только локальная ветвь). Затем после этого" git merge thebranch " гарантированно будет перемотан вперед.

безопасный способ объединить ветви svn в git-использовать git merge --squash. Это создаст одну фиксацию и остановит вас, чтобы добавить сообщение.

допустим, у вас есть тема svn branch, называемая svn-branch.

git svn fetch
git checkout remotes/trunk -b big-merge
git merge --squash svn-branch

на данный момент у вас есть все изменения из svn-ветви, сжатой в один фиксатор, ожидающий в индексе

git commit

Перебазируйте локальную ветвь git на главную ветвь git, затем dcommit, и таким образом похоже, что вы сделали все эти коммиты последовательно, чтобы люди svn могли видеть это линейно, как они привыкли. Поэтому, предполагая, что у вас есть локальная ветвь под названием topic, вы можете сделать

git rebase master topic

который затем будет воспроизводить ваши коммиты над главной веткой, готовой для вас к dcommit