rebase current onto selected в idea что значит

21.11.202314.07.2022 admin 0 Comments

Простое объяснение Git Rebase

Перевод статьи «Git Rebase Explained Simply».

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

Забавно, но rebase это одна из нескольких команд git, которыми я лично пользуюсь практически ежедневно. По большому счету, я делаю rebase по крайней мере единожды для каждого пул-реквеста на GitHub.

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

Использование команды git rebase перестанет быть чем-то сложным или пугающим, как только вы поймете, как она работает и чем полезна.

Итак, представьте, что у вас есть две ветки.

Первая выглядит так:

Если присмотреться, можно заметить, что вплоть до 13363dd3 основа веток (base) одинакова, а дальше они расходятся.

Первая ветка, которую мы будем считать нашей рабочей веткой, содержит три коммита, которых нет во второй ветке.

Вторая ветка (в нашем примере — master) содержит восемь коммитов, не имеющихся в нашей рабочей ветке.

В реальной жизни подобные ситуации происходят постоянно. Вы можете это прочувствовать, поработав над проектом в составе большого коллектива разработчиков.

Допустим, вы занимаетесь разработкой какой-нибудь отдельной фичи и делаете это в отдельной ветке. Если эта ваша ветка просуществует хотя бы несколько дней, скорее всего за это время ветка master успеет измениться (т. е., еще до того, как вы вольете свою ветку обратно в master).

В таком случае очень пригодилась бы возможность сначала привести свою ветку в соответствие с master, а уж затем добавить свои изменения на верхушку git history.

Если мы «уравняем» нашу рабочую ветку с веткой master в ее теперешнем состоянии, а затем поместим три своих коммита сверху, мы получим следующую историю:

Таким образом пул-реквест в master будет куда чище, кроме того, это поможет избежать конфликтов слияния.

К счастью, все это возможно благодаря перебазированию ветки!

Давайте обратим внимание на само название команды: Rebase. Что оно означает?

Применяя эту команду, мы заменяем основу (базу) нашей рабочей ветки на на ветку master. Т.е., мы «перебазируем» («re-base») рабочую ветку, меняем ее основу.

Использование git rebase

Давайте теперь познакомимся поближе с самой командой.

Предположим, у нас есть working-branch (рабочая ветка), проверенная на нашей локальной машине. В таком случае rebase выглядит просто:

Вы увидите в консоли некий output:

Как мы видим, git заново «проигрывает» нашу работу, как своего рода музыкальную запись, сверху ветки master.

Если вывести лог истории git, вы увидите, что наши изменения записаны поверх ветки master.

То есть, мы «перебазировали» нашу ветку, заменив ее основу на ветку master.

Если использование rebase все еще пугает вас, попробуйте делать копию своей рабочей ветки, прежде чем запускать команду rebase — просто на всякий случай!

Источник

Руководство по Git. Часть №2: золотое правило и другие основы rebase

Посмотрим, что происходит, когда вы выполняете git rebase и почему нужно быть внимательным.

Это вторая и третья части гайда по Git из блога Pierre de Wulf в переводе команды Mail.ru Cloud Solutions. Первую часть можно почитать тут.

Суть rebase

Как именно происходит rebase:

Можно сказать, что rebase — это открепить ветку (branch), которую вы хотите переместить, и подключить ее к другой ветке. Такое определение соответствует действительности, но попробуем заглянуть чуть глубже. Если вы посмотрите документацию, вот что там написано относительно rebase: «Применить коммиты к другой ветке (Reapply commits on top of another base tip)».

Главное слово здесь — применить, потому что rebase — это не просто копипаст ветки в другую ветку. Rebase последовательно берет все коммиты из выбранной ветки и заново применяет их к новой ветке.

Такое поведение приводит к двум моментам:

Как видите, ветка feature содержит абсолютно новые коммиты. Как было сказано ранее, тот же самый набор изменений, но абсолютно новые объекты с точки зрения Git.

Это также означает, что старые коммиты не уничтожаются. Они становятся просто недоступными напрямую. Если вы помните, ветка — всего лишь ссылка на коммит. Таким образом, если ни ветка, ни тег не ссылаются на коммит, к нему невозможно получить доступ средствами Git, хотя на диске он продолжает присутствовать.

Теперь давайте обсудим «Золотое правило».

Золотое правило rebase

Золотое правило rebase звучит так — «НИКОГДА не выполняйте rebase расшаренной ветки!». Под расшаренной веткой понимается ветка, которая существует в сетевом репозитории и с которой могут работать другие люди, кроме вас.

Часто это правило применяют без должного понимания, поэтому разберем, почему оно появилось, тем более что это поможет лучше понять работу Git.

Давайте рассмотрим ситуацию, когда разработчик нарушает золотое правило, и что происходит в этом случае.

Предположим, Боб и Анна вместе работают над проектом. Ниже представлено, как выглядят репозитории Боба и Анны и исходный репозиторий на GitHub:

У всех пользователей репозитории синхронизируются с GitHub.

Теперь Боб, нарушая золотое правило, выполняет rebase, и в это же время Анна, работая в ветке feature, создает новый коммит:

Вы видите, что произойдет?

Боб пытается выполнить пуш коммита, ему приходит отказ примерно такого содержания:

Выполнение Git не было успешным, потому что Git не знает, как объединить feature ветку Боба с feature веткой GitHub.

Единственным решением, позволяющим Бобу выполнить push, станет использование ключа force, который говорит GitHub-репозиторию удалить у себя ветку feature и принять за эту ветку ту, которая пушится Бобом. После этого мы получим следующую ситуацию:

Теперь Анна хочет запушить свои изменения, и вот что будет:

Это нормально, Git сказал Анне, что у нее нет синхронизированной версии ветки feature, то есть ее версия ветки и версия ветки в GitHub — разные. Анна должна выполнить pull. Точно таким же образом, как Git сливает локальную ветку с веткой в репозитории, когда вы выполняете push, Git пытается слить ветку в репозитории с локальной веткой, когда вы выполняете pull.

Перед выполнением pull коммиты в локальной и GitHub-ветках выглядят так:

Когда вы выполняете pull, Git выполняет слияние для устранения разности репозиториев. И вот, к чему это приводит:

Коммит M — это коммит слияния (merge commit). Наконец, ветки feature Анны и GitHub полностью объединены. Анна вздохнула с облегчением, все конфликты устранены, она может выполнить push.

Боб выполняет pull, теперь все синхронизированы:

Глядя на получившийся беспорядок, вы должны были убедиться в важности золотого правила. Также учтите, что подобный беспорядок был создан всего одним разработчиком и на ветке, которая расшарена всего между двумя людьми. Представьте, что будет в команде из десяти человек.

Одним из многочисленных достоинств Git является то, что можно без проблем откатиться на любое время назад. Но чем больше допущено ошибок, подобных описанной, тем сложнее это сделать.

Также учтите, что появляются дубликаты коммитов в сетевом репозитории. В нашем случае — D и D’, содержащие одни и те же данные. По сути, количество дублированных коммитов может быть таким же большим, как и количество коммитов в вашей rebased ветке.

Если вы все еще не убеждены, давайте представим Эмму — третью разработчицу. Она работает в ветке feature перед тем, как Боб совершает свою ошибку, и в настоящий момент хочет выполнить push. Предположим, что к моменту ее push наш маленький предыдущий сценарий уже завершился. Вот что выйдет:

Этот текст мог заставить вас подумать, что rebase используют только для перемещения одной ветки на верхушку другой ветки. Это необязательно — вы можете выполнять rebase и на одной ветке.

Красота pull rebase

Как вы видели выше, проблем Анны можно было избежать, если бы она использовала pull rebase. Рассмотрим этот вопрос подробнее.

Допустим, Боб работает в ветке, отходящей от мастера, тогда его история может выглядеть вот так:

Боб решает, что настало время выполнить pull, что, как вы уже поняли, приведет к некоторым неясностям. Поскольку репозиторий Боба отходил от GitHub, Git спросит делать ли объединение, и результат будет таким:

Это решение подходит и работает нормально, однако, вам может быть полезно знать, что есть другие варианты решения проблемы. Одним из них является pull-rebase.

Когда вы делаете pull-rebase, Git пытается выяснить, какие коммиты есть только в вашей ветке, а какие — в сетевом репозитории. Затем Git объединяет коммиты из сетевого репозитория с самым свежим коммитом, присутствующим и в локальном, и в сетевом репозитории. После чего выполняет rebase ваших локальных коммитов в конец ветки.

Звучит сложно, поэтому проиллюстрируем:

Как вы помните, при rebase Git применяет коммиты один за одним, то есть в данном случаем применяет в конец ветки master коммит E, потом F. Получился rebase сам в себя. Выглядит неплохо, но возникает вопрос — зачем так делать?

По моему мнению, самая большая проблема с объединением веток в том, что загрязняется история коммитов. Поэтому pull-rebase — более элегантное решение. Я бы даже пошел дальше и сказал, что когда нужно скачать последние изменения в вашу ветку, вы всегда должны использовать pull-rebase. Но нужно помнить: поскольку rebase применяет все коммиты по очереди, то когда вы делаете rebase 20 коммитов, вам, возможно, придется решать один за другим 20 конфликтов.

Как правило, можно использовать следующий подход: одно большое изменение, сделанное давно — merge, два маленьких изменения, сделанных недавно — pull-rebase.

Сила rebase onto

Предположим, история ваших коммитов выглядит так:

Итак, вы хотите выполнить rebase ветки feature 2 в ветку master. Если вы выполните обычный rebase в ветку master, получите это:

Нелогично выглядит то, что коммит D существует в обоих ветках: в feature 1 и feature 2. Если вы переместите ветку feature 1 в конец ветки мастер, получится, что коммит D будет применен два раза.

Предположим, что вам нужно получить другой результат:

Для реализации подобного сценария как раз и предназначен git rebase onto.

Сначала прочтем документацию:

Нас интересует вот это:

С помощью этой опции указывается, в какой точке создавать новые коммиты.

Если эта опция не указана, то стартовой точкой станет upstream.

Для понимания приведу еще один рисунок:

То есть ветка master — это newbase, а ветка feature 1 — upstream.

Источник

Git Rebase: руководство по использованию

Rebase — один из двух способов объединить изменения, сделанные в одной ветке, с другой веткой. Начинающие и даже опытные пользователи git иногда испытывают нежелание пользоваться ей, так как не видят смысла осваивать еще один способ объединять изменения, когда уже и так прекрасно владеют операцией merge. В этой статье я бы хотел подробно разобрать теорию и практику использования rebase.

Теория

Итак, освежим теоретические знания о том, что же такое rebase. Для начала вкратце — у вас есть две ветки — master и feature, обе локальные, feature была создана от master в состоянии A и содержит в себе коммиты C, D и E. В ветку master после отделения от нее ветки feature был сделан 1 коммит B.

После применения операции rebase master в ветке feature, дерево коммитов будет иметь вид:

Обратите внимание, что коммиты C’, D’ и E’ — не равны C, D и E, они имеют другие хеши, но изменения (дельты), которые они в себе несут, в идеале точно такие же. Отличие в коммитах обусловлено тем, что они имеют другую базу (в первом случае — A, во втором — B), отличия в дельтах, если они есть, обусловлены разрешением конфликтных ситуаций, возникших при rebase. Об этом чуть подробнее далее.

Такое состояние имеет одно важное преимущество перед первым, при слиянии ветки feature в master ветка может быть объединена по fast-forward, что исключает возникновение конфликтов при выполнении этой операции, кроме того, код в ветке feature более актуален, так как учитывает изменения сделанные в ветке master в коммите B.

Процесс rebase-а детально

Давайте теперь разберемся с механикой этого процесса, как именно дерево 1 превратилось в дерево 2?

Напомню, перед rebase вы находтесь в ветке feature, то есть ваш HEAD смотрит на указатель feature, который в свою очередь смотрит на коммит E. Идентификатор ветки master вы передаете в команду как аргумент:

Для начала git находит базовый коммит — общий родитель этих двух состояний. В данном случае это коммит A. Далее двигаясь в направлении вашего текущего HEAD git вычисляет разницу для каждой пары коммитов, на первом шаге между A и С, назовем ее Δ_AC. Эта дельта применяется к текущему состоянию ветки master. Если при этом не возникает конфликтное состояние, создается коммит C’, таким образом C’ = B + Δ_AC. Ветки master и feature при этом не смещаются, однако, HEAD перемещается на новый коммит (C’), приводя ваш репозитарий состояние «отделеной головы» (detached HEAD).

Успешно создав коммит C’, git переходит к переносу следующих изменений — Δ_CD. Предположим, что при наложении этих изменний на коммит C’ возник конфликт. Процесс rebase останавливается (именно в этот момент, набрав git status вы можете обнаружить, что находитесь в состоянии detached HEAD). Изменения, внесенные Δ_CD находятся в вашей рабочей копии и (кроме конфликтных) подготовлены к коммиту (пунктиром обозначена stage-зона):

Далее вы можете предпринять следующие шаги:

1. Отменить процесс rebase набрав в консоли

При этом маркер HEAD, будет перенесен обратно на ветку feature, а уже добавленные коммиты повиснут в воздухе (на них не будет указывать ни один указатель) и будут вскоре удалены.

При этом, если все конфликты действительно разрешены, будет создан коммит D’ и rebase перейдет к следующему, в данном примере последнему шагу.

После применения изменений Δ_DE будет создан последний коммит E’, указатель ветки feature будет установлен на коммит E’, а HEAD станет показывать на ветку feature — теперь, вы находитесь в состоянии на втором рисунке, rebase окончен. Старые коммиты C, D и E вам больше не нужны.

При этом коммиты, созданные в процессе rebase-а, будут содержать данные как об оригинальном авторе и дате изменений (Author), так и о пользователе, сделавшем rebase (Commiter):

С небес на землю — rebase в реальных условиях

На самом деле обычно вы работаете не с двумя ветками, а с четырьмя в самом простом случае: master, origin/master, feature и origin/feature. При этом rebase возможен как между веткой и ее origin-ом, например feature и origin/feature, так и между локальными ветками feature и master.

Rebase ветки с origin-ом

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

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

Как поделиться веткой, к которой применен rebase, с коллегой

Тут все просто, наберите в консоли команду:

Force-режим просто копирует отсутствующие родительские коммиты ветки feature на origin и насильно устанавливает указатель ветки на тот же коммит, что и ваш локальный.

Будьте внимательны! Если вы забудете указать идентификатор ветки, то force-push будет выполнен для всех локальных веток, имеющих удаленный оригинал. При этом нужно понимать, что некоторые локальные ветки могут быть в неактуальном состоянии. То есть измененения, которые вы не успели затянуть будут удалены в origin-е. Конечно, сами коммиты не будут удалены — сбросятся только указатели ветки. Эта ситуация поправима — достаточно для каждой ветки найти человека, который последним пушил изменения в нее или уже успел их забрать. Он может сделать обычный push, вновь передав их на origin. Но вся эта морока вам ни к чему, так что лучше просто будьте внимательны.

Реинтеграция тематической ветки в master

Мы рассмотрели все необходимые операции для работы с ветками в стиле rebase. Осталось только переключиться в ветку master и сделать git merge feature. Ветка, подготовленная rebase-ом вольется в master по fast-forward, то есть указатель будет просто перемещен вперед.

В данном случае, на мой взгляд, merge-коммиты полезны и несут в себе информацию о моменте объединения веток. Этот граф выглядит как учебный пример, но такая структура вполне реальна при соблюдении некоторых простых правил всеми членами команды.

Заключение

Мы видим, что читаемость графа изменений может быть улучшена на порядок при соблюдении нескольких простых правил, хотя они и требуют небольших дополнительных временных затрат.

В данной статье сделано одно допущение. Все это верно при простой модели ветвления — есть одна главная ветка master и несколько тематических, которые создаются от нее. Когда от тематической ветки создается другая тематическая ветка, есть свои нюансы при rebase-е первичной и вторичной ветки. О них можно прочитать в том самом официальном руководстве.

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

PS. Хочу поблагодарить своих коллег, продуктивные беседы с которыми позволили мне лучше разобраться в материале, положенном в основу этой статьи.

Источник

Edit Git project history

Git allows you to edit your project history. This is useful when you’re working on a feature branch and want to clean it up and make it look the way you want before you share it with others. For example, you can edit commit messages, squash together smaller commits related to the same functionality, or split a commit that contains unrelated changes into separate commits, add changes to a previous commit, and so on.

Avoid modifying the history for a remote branch with multiple contributors unless absolutely necessary, for example, if you accidentally pushed some sensitive data.

Pushing modifications that rewrite a branch history to the remote repository will be rejected to prevent data loss, so you will have to force push your changes.

Also, you cannot perform actions that modify a branch history for commits that are not contained in the branch currently checked out.

Edit a commit message

If the only thing you need to change is a commit message, you can edit it before you push this commit.

Amend the previous commit

Sometimes you may commit too early and forget to add some files, or notice an error in the last commit that you want to fix without creating a separate commit.

You can do this by using the Amend commit option that appends staged changes to the previous commit. As a result, you end up with a single commit instead of two different ones.

Select the Amend checkbox so that the Commit button changes to Amend Commit and click it.

Amend any earlier commit

If you need to add changes to any earlier commit instead of committing them separately, you can do this by using the fixup or the squash action. Both commands append staged changes to the selected commit, but handle commit messages differently:

squash adds the new commit message to the original commit

fixup discards the new commit message, leaving only the message from the original commit

Both commands require a rebase because they change the commit hashes.

Modify the commit message if necessary if you’ve chosen to squash changes.

Squash commits

If you need to meld any two commits related to the same functionality, you can squash them into one for the sake of cleaner branch history.

In the Log tab of the Git tool window Alt+9 select the commits that you want to combine into one and choose Squash Commits from the context menu.

Push Ctrl+Shift+K the changes to the remote branch.

Drop a commit

You can discard a pushed commit in the current branch without creating an additional commit that reverts the changes.

Select a commit you want to discard in the Log view and choose Drop Commit from the context menu.

Edit project history by performing interactive rebase

Edit the history of the current branch

IntelliJ IDEA allows you to edit the commits history in the current branch before you apply the changes to a different branch.

Open the Git tool window Alt+9 and switch to the Log tab.

Filter the log so that it only displays commits from the current branch:

The Interactive Rebase dialog will be displayed containing the list of all commits in the current branch that were made after the selected commit:

If the Interactively Rebase from Here option is disabled, this may be due to one of the following reasons:

the selected commit has several parents

the selected commit is not in the current branch

the selected commit is pushed to a protected branch

To identify the reason, hover the action in the context menu and look for the message in the status bar:

You can perform the following changes to the branch history:

When rebase is stopped at a commit, a notification pops up in the bottom-right corner of the IntelliJ IDEA window letting you continue or abort the rebase:

If you’ve closed the notification, from the main menu choose Git | Continue rebase to resume it.

Reword the commit message : click Reword or double-click a commit and edit the text in the mini-editor that opens.

In both cases, you will be able to edit the commit message in the mini editor that opens when you apply one of these actions.

Ignore a commit : click Drop so that the changes from the selected commit are not applied.

Undo all changes : click Reset to discard all actions you’ve applied to the commits.

As a result, the Rebasing Commits dialog shows a graph illustrating all actions you’ve applied to commits in your branch, so that you can review them before starting the rebase:

Edit a branch history and integrate it into another branch

IntelliJ IDEA allows you to rebase a branch on top of another branch and edit the source branch history before you apply the changes.

From the main menu select Git | Rebase :

From the list, select the target branch onto which you want to rebase the current branch:

IntelliJ IDEA will check out this branch before starting the rebase operation.

The Interactive Rebase dialog will be displayed containing the list of all commits in the current branch that were made after the selected commit.