Как создать ветку на github

Введем в открывшийся редактор кусок кода:

git branch 2> /dev/null | sed -n -e ‘s/^\* \(.*\)/[\1]/p’

Сохраним изменения в файле и вернемся в терминал.

Вводим команду source

/.zchrc. Обозначение ветки появилось.

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

Как создать ветку в Git

Представим, что мы хотим добавить в код input, чтобы пользователь вводил свое имя с клавиатуры. Пробовать изменения мы будем в отдельной ветке.

Создать новую ветку можно с помощью команды git branch <название ветки>. Важно, чтобы название было понятным для вас и других участников проекта.

Создадим новую ветку для проекта: git branch input.

Переключимся на новую ветку с помощью команды git checkout input. (Чтобы создать ветку и переключиться на нее за одно действие, можно воспользоваться флагом -b: git checkout -b <название ветки>.)

Внесем изменения в наш файл в ветке input. Для этого перейдем в редактор. Пусть код запрашивает имя пользователя, а потом здоровается с ним.

Добавим в начало запрос на ввод: name = input(«What’s your name? «)

И изменим первую строку вывода: print(«Hello, «, name,»!»)

Проверим, как работает наш код. Для этого нужно нажать на значок play в верхнем правом углу редактора. Код сначала просит нас ввести имя, а потом выводит нужную информацию. Изменения удались.

Закоммитим изменения: git commit -a -m “Add input”.

Проверим git status, убедимся, что рабочее дерево чистое. Проверим историю: git log. Видим весь путь работы: последнее изменение и все изменения, которые были еще до ответвления. Чтобы выйти из истории, нужно нажать q в английской раскладке.

Вернемся в основную ветку с помощью команды git checkout main и зайдем в редактор. Изменения пропали, потому что в основную ветку мы их еще не добавляли. Проверяем историю: git log. В ветке main видим только старые коммиты, до ответвления.

Как сливать ветки и решать конфликты

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

Сначала нужно переключиться на основную ветку: git checkout main.

Теперь можем забрать изменения из ветки input: git merge —no-ff <название ветки, изменения из которой забираем> -m “Сообщение о слиянии веток”.

Такая команда создаст новый коммит, в котором объединятся две ветки.

Флаг —no-ff отменяет механизм fast-forward, который стоит в git по умолчанию. Если его не отменить, git не будет создавать новый коммит, в котором объединятся две ветки, а просто сделает дополнительную ветку веткой main. Иногда такой механизм полезен, но сейчас он нас запутает, поэтому отключаем его. Вы можете поэкспериментировать и посмотреть, в какой ситуации какой механизм вам больше подходит.

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

Иногда Git не понимает, как именно нужно объединить ветки и выводит сообщение о конфликте. В таких ситуациях, мы должны показать ему это. Для этого переходим в редактор, удаляем лишние символы и приводим код к тому виду, который нам нужен. Сохраняем файл в редакторе, проверяем git status — увидим сообщение о конфликте. Чтобы показать Git, что мы разрешили конфликт, просто закоммитим изменения: git commit -a -m «Add input in main».

Проверим историю: git log. Если видим сообщение о коммите, в котором сливаются две ветки, значит, все получилось.

Историю изменений, создания новых веток и слияния можно визуализировать: git log —oneline —graph.

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

Как залить изменения на GitHub

Отправляем изменения на удаленный репозиторий: git push.

Проверяем GitHub. Изменения появились, но залилась только ветка main. Другие ветки нужно заливать отдельно: git push -u origin <название ветки>.

Зальем ветку input: git push -u origin input. Видим, что на GitHub появились две ветки. Переключиться между ветками можно в меню branch.

Как перемещаться по коммитам

Еще один важный указатель в git — это head. Он указывает, на какой ветке мы находимся. Если мы перейдем в историю, увидим, что head указывает на ветку main и на удаленную ветку origin_main. Это значит, наш локальный и удаленный репозитории синхронизированы.

Перейдем на другую ветку командой git checkout input, и в истории head будет указывать уже на input.

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

Посмотрим историю изменений: git log —oneline. (Эта команда дает более компактное отображение истории по сравнению с git log.)

Переходим на один из первых коммитов: git checkout <первые символы кода идентификатора>. Head уже будет указывать на отдельный коммит, а в редакторе код тоже вернулся на тот этап.

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

Создадим новую ветку и переключимся на нее в одно действие с помощью флага -b: git checkout -b calc.

Добавим изменения в редактор: допишем строку 2+2. Сохраняем изменения в редакторе.

Добавим файл в отслеживание и коммитим изменения: git commit -a -m “Add calculation”.

Вернемся в основную ветку: git checkout main. Посмотрим все ветки: git branch. Видим, что появилась новая ветка calc.

Сделаем визуализацию наших изменений: git log —oneline —graph —all. Видим, что со второго коммита ответвилась еще одна ветка.

Как удалить ветку в Git

Если мы понимаем, что ветка больше не нужна, можно ее удалить. При этом удаляемая ветка не должна быть той веткой, в которой мы находимся. Удалим ветку calc: git branch -d calc. Git предупреждает, что ветка еще не объединена с основной веткой и что удалять ее опасно. Но мы уверены, что хотим удалить ветку, поэтому вводим еще одну команду, которую нам подсказывает git: git branch -D calc.

Теперь удалим ветку input. Она уже залита на GitHub, поэтому сначала удалим ее с удаленного репозитория: git push —delete origin input

Проверим Git Hub: ветка удалилась. Теперь удаляем ветку локально: git branch -d input.

Проверим наши ветки: git branch. Ветки удалились, осталась только ветка main.

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

Git для начинающих. Урок 7.
Работа с ветками

Краткое содержание урока, основные инструкции для командной строки, полезные ссылки и советы.

Ветки — главная фишка git

Git стал стандартом в системах контроля версий благодаря простой и удобной работе с ветками.

Какие проблемы решают ветки

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

Внезапно прилетает задача — срочно поправить багу в верстке шапки. Мы не можем чинить багу прямо сейчас, в текущем состоянии проекта. У нас много изменений, но работа над большой фичей не завершена — поэтому мешать код новой фичи и код с починкой срочной баги нельзя. Как быть?

Было бы здорово, если бы могли разрабатывать новую фичу независимо от основного кода проекта. То есть взять и зафиксировать рабочее состояние сайта, а делать новый функционал отдельно, не боясь поломать рабочий код. И еще чтобы можно было переключаться между основным кодом (для правки баги) и кодом новой фичи (для продолжения работы над ней)

Когда я не пользовался git, то решал эту проблему созданием архивов проекта. Довел сайт до какого-то рабочего состояния — сделал архив. Реализовал новую фичу — сделал еще один архив. Нужно переключиться на старый код для правки баги — сохранил текущую работу в новый «временный» архив, выбрал старый «стабильный» архив, распаковал, починил там багу, вернулся обратно во «временный» архив.

Схема рабочая, но слишком много суеты и неудобств:

• нужно постоянно создавать архивы с рабочим кодом
• сложно «переключаться» между архивами
• сложно перетаскивать изменения между архивами
• легко что-то напутать или потерять — все мы люди

Все эти проблемы git решает механизмом веток.

Как работают ветки

Представим код проекта в виде дерева. Посередине ствол — это рабочее состояние проекта, тот код, который выложен на боевом сервере. Этот ствол в терминах git называется основной веткой разработки — веткой master. Эта ветка есть всегда в любом проекте. Как только мы клонировали или создали новый репозиторий, мы попали в ветку master. Все, что мы делали на предыдущих уроках, мы делали в мастере.

Когда мы начинаем работать над новым функционалом, мы создаем новую ветку на основе master. Это называется «ответвиться от мастера». После этого мы можем работать, создавать новые файлы, вносить изменения в старые, можем хоть удалить половину проекта — главное, что это будет изолировано от основного мастера. То есть в своей ветке мы можем как угодно ломать проект, основной код при этом не пострадает.

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

Так как git хранит всю историю проекта, то он хранит все коммиты всех веток и со всеми изменениями. То есть вернувшись в свою ветку мы увидим уже сделанные коммиты и можем посмотреть изменения по ним.

Когда мы заканчиваем работать над новым функционалом, то нужно наши изменения перенести в мастер, чтобы залить на боевой сайт. Это называется слить ветку в мастер, или залить в мастер, или смерджить в мастер. При этом после мерджа в мастере оказываются не только наши изменения, но и те, которые были в мастере, но не были в нашей ветке (правка баги в мастере). То есть нам даже не обязательно после правки баги в мастере переносить эти изменения в свою ветку. При мердже git наш новый код «положит» поверх того, что было в мастере, не стирая старый.

Чтобы было нагляднее и понятнее, как это работает, смотрите видео. А в тексте ниже краткое описание команд для работы с ветками.

Ветка master

Еще раз закрепим. Ветка master — это, как правило, основная ветка проекта. Она появляется сразу после клонирования или инициализации репозитория. Есть разные варианты ведения веток, но мы будем считать, что master — наша основная рабочая ветка, от которой ответвляются другие.

Как создать новую ветку

Так мы создали новую ветку news, имея в виду, что будем разрабатывать в ней блок новостей.

Как переключаться между ветками

Для этого используется команда checkout

Вот что при этом вы увидите

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

Как посмотреть все ветки

Этой командой мы выведем список всех локальных веток. Звездочка у news означает текущую ветку, в которой мы сейчас находимся.

Коммитим в новую ветку

Коммиты в ветку добавляются точно так же, как и раньше. Делаем изменения в файлах, потом git add, потом git commit -m ‘commit message’.

Как запушить новую ветку

Вспомним, как мы пушили раньше

Точно так же мы пушим и новую ветку, только вместо master указываем свое название

Если такой ветки на сервере нет, то она создастся. Если мы ее уже пушили раньше, то просто отправятся новые коммиты.

Как переименовать ветку

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

Это переименует текущую ветку news в block-news. Чтобы убедиться, посмотрим список веток

Как удалить ветку

Удаляется ветка командой git branch -d branch_name. Но здесь могут быть варианты. Рассмотрим, что может пойти не так

Здесь просто — мы не можем удалить ветку, потому что в ней находимся. Сначала нужно перелючиться в мастер

Опять ошибка — здесь git говорит о том, что в удаляемой ветке есть код, который не залит в мастер. То есть при удалении ветки этот код потеряется. Поэтому если мы уверены в своих действиях и ветка действительно не нужна, то вместо флага -d нужен -D

Теперь удалено без вопросов.

Как работать с ветками в PhpStorm

В правом нижнем углу есть пункт «Git:master». Там пишется название текущей ветки. Чтобы создать новую, нужно кликнуть на этот пункт и выбрать New Branch. Чтобы переключиться, выбрать в списке Local Branches нужную ветку и Checkout. Чтобы удалить или переименовать соотвественно Delete или Rename.

Наглядно это показывается в видеоуроке

Раздел Remote Branches мы рассмотрим в следующем уроке

Что могу посоветовать

• научитесь легко оперировать ветками
• создавайте больше веток
• называйте ветки по общим правилам
• пушьте ветки почаще, их легко потом удалить

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

6.2 GitHub — Внесение собственного вклада в проекты

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

Создание ответвлений (fork)

Если вы хотите вносить свой вклад в уже существующие проекты, в которых у нас нет прав на внесения изменений путём отправки (push) изменений, вы можете создать своё собственное ответвление (fork) проекта. Это означает, что GitHub создаст вашу собственную копию проекта, данная копия будет находиться в вашем пространстве имён и вы сможете легко делать изменения путём отправки (push) изменений.

Исторически так сложилось, что англоязычный термин «fork» (создание ветвления проекта) имел негативный контекстный смысл, данный термин означал, что кто-то повёл или ведёт проект с открытым исходным кодом в другом, отличном от оригинала, направлении, иногда данный термин так же означал создание конкурирующего проекта с раздельными авторами. В контексте GitHub, «fork» (создание ветвления проекта) просто означает создание ветвления проекта в собственном пространстве имён, что позволяет вносить публичные изменения и делать свой собственный вклад в более открытом виде.

Таким образом, проекты не обеспокоены тем, чтобы пользователи, которые хотели бы выступать в роли соавторов, имели право на внесение изменений путём их отправки (push). Люди просто могут создавать свои собственные ветвления (fork), вносить туда изменения, а затем отправлять свои внесённые изменения в оригинальный репозиторий проекта путём создания запроса на принятие изменений (Pull Request), сами же запросы на принятие изменений (Pull Request) будут описаны далее. Запрос на принятие изменений (Pull Request) откроет новую ветвь с обсуждением отправляемого кода, и автор оригинального проекта, а так же другие его участники, могут принимать участие в обсуждении предлагаемых изменений до тех пор, пока автор проекта не будет ими доволен, после чего автор проекта может добавить предлагаемые изменения в проект.

Для того, чтобы создать ответвление проекта, зайдите на страницу проекта и нажмите кнопку «Создать ответвление» («Fork»), которая расположена в правом верхнем углу.

Через несколько секунд вы будете перенаправлены на собственную новую проектную страницу, содержащую вашу копию, в которой у вас есть права на запись.

Рабочий процесс с использованием GitHub

GitHub разработан с прицелом на определённый рабочий процесс с использованием запросов на слияния. Этот рабочий процесс хорошо подходит всем: и маленьким, сплочённым вокруг одного репозитория, командам; и крупным распределённым компаниям, и группам незнакомцев, сотрудничающих над проектом с сотней копий. Рабочий процесс GitHub основан на тематических ветках, о которых мы говорили в главе Ветвление в Git.

Вот как это обычно работает:

Создайте форк проекта.

Создайте тематическую ветку на основании ветки master .

Создайте один или несколько коммитов с изменениями, улучшающих проект.

Отправьте эту ветку в ваш проект на GitHub.

Откройте запрос на слияние на GitHub.

Обсуждайте его, вносите изменения, если нужно.

Владелец проекта принимает решение о принятии изменений, либо об их отклонении.

Получите обновлённую ветку master и отправьте её в свой форк.

Очень напоминает подход, описанный в разделе Диспетчер интеграции главы 5, но вместо использования электронной почты, команда сотрудничает через веб-интерфейс.

Давайте посмотрим, как можно предложить изменения в проект, размещённый на GitHub.

В большинстве случаев можно использовать официальный инструмент GitHub CLI вместо веб-интерфейса GitHub. Инструмент доступен в системах Windows, MacOS и Linux. Посетите страницу GitHub CLI homepage для получения инструкций по установке и использованию.

Создание запроса на слияние

Тони ищет, чего бы запустить на своём новеньком Arduino. Кажется, он нашёл классный пример на https://github.com/schacon/blink.

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

Для начала, нажмите кнопку «Fork», как было сказано выше, чтобы заполучить собственную копию проекта. Мы зарегистрированы на GitHub под именем «tonychacon», так что наша копия окажется по адресу https://github.com/tonychacon/blink , где мы сможем редактировать её. Мы клонируем его, создадим тематическую ветку, внесём необходимые изменения и, наконец, отправим их на GitHub.

Клонируем нашу копию

Создаём тематическую ветку

Вносим свои изменения

Фиксируем изменения в тематической ветку

Отправляем новую ветку в нашу копию на GitHub

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

Также можно зайти на страницу «Branches», по адресу https://github.com/<user>/<project>/branches , найти интересующую ветку и открыть запрос оттуда.

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

Также мы видим список коммитов в нашей тематической ветке, «опередивших» ветку master (в данном случае всего один коммит) и предпросмотр всех изменений, вносимых этими коммитами.

После создания запроса на слияние (путём нажатия кнопки «Create pull request» на этой странице) владелец форкнутого проекта получит уведомление о предложенных изменениях со ссылкой на страницу с информацией о запросе.

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

Обработка запроса на слияние

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

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

Как только владелец прокомментирует изменения, автор запроса на слияние (а также все подписавшиеся на этот репозиторий) получат уведомления. Далее мы рассмотрим как настроить уведомления, но сейчас, если Тони включил уведомления через электронную почту, он получит следующее письмо:

Кто угодно может оставлять комментарии к запросу на слияние. На Страница обсуждения запроса на слияние можно увидеть пример, где владелец проекта оставил комментарии как к строке кода, так и в основной секции обсуждения. Как вы могли заметить, комментарии к коду так же приведены в виде обсуждения.

Теперь участник может видеть что ему необходимо сделать для того, чтобы его изменения были приняты. К счастью, это тоже легко сделать. Используя почту, вам потребуется заново отправить свои изменения в список рассылки, а при использовании GitHub вы просто делаете коммит в тематическую ветку и повторяете push, что автоматически обновляет запрос на слияние. На рисунке Финальная стадия запроса на слияние также видно, что в обновленном запросе на слияние старый комментарий к коду был свёрнут, так как он относится к строке, которая с тех пор изменилась.

Когда участник сделает это, владелец проекта снова получит уведомление, а на странице запроса будет отмечено, что проблема решена. Фактически, как только строка кода имеющая комментарий будет изменена, GitHub заметит это и удалит устаревшее отличие.

Примечательно, что если вы перейдёте на вкладку «Files Changed» в этом запросе на слияние, то увидите «унифицированную» разницу — это суммарные изменения, которые будут включены в основную ветку при слиянии тематической ветки. В терминологии git diff это эквивалентно команде git diff master…​<branch> для ветки, на которой основан этот запрос на слияние. В Определение применяемых изменений детальнее описан данный тип отличий.

GitHub так же проверяет может ли запрос на слияние быть применён без конфликтов и предоставляет кнопку для осуществления слияния на сервере. Эта кнопка отображается только если у вас есть права на запись в репозиторий и возможно простейшее слияние. По нажатию на неё GitHub произведёт «non-fast-forward» слияние, что значит даже если слияние может быть осуществлено перемоткой вперед, всё равно будет создан коммит слияния.

При желании, можно стянуть ветку и произвести слияние локально. Если эта ветка будет слита в master ветку и отправлена на сервер, то GitHub автоматически закроет запрос на слияние.

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

Важно отметить, что можно открывать запросы на слияние между двумя ветками в одном репозитории. Если вы работаете над функционалом с кем-то ещё и у вас обоих есть права записи, то вы можете отправить свою тематическую ветку в репозиторий и открыть запрос на слияние в master ветку в рамках одного проекта, что позволит инициировать процедуру проверки кода и его обсуждения. Создание ответвлений проекта не является обязательным.

Продвинутые запросы на слияние

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

Запросы слияния как Патчи

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

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

Например, если вы вернётесь и посмотрите на Финальная стадия запроса на слияние, то увидите, что участник не делал перебазирование своего коммита и не отправлял новый запрос на слияние. Вместо этого были сделаны новые коммиты и отправлены в существующую ветку. Таким образом, если вы в будущем вернётесь к этому запросу слияния, то легко найдёте весь контекст принятого решения. По нажатию кнопки «Merge» целенаправленно создаётся коммит слияния, который указывает на запрос слияния, оставляя возможность возврата к цепочке обсуждения.

Следование за исходным репозиторием

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

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

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

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

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

Предположим, что в примере «tonychacon», который мы использовали ранее, основной автор сделал изменения, которые конфликтуют с запросом на слияние. Рассмотрим это пошагово.

Добавляем исходный репозиторий как удалённый с именем upstream .

Получаем последние изменения из него.

Сливаем основную ветку в нашу тематическую.

Исправляем указанный конфликт.

Отправляем изменения в ту же тематическую ветку.

Как только это будет сделано, запрос на слияние будет автоматически обновлён и перепроверен на возможность слияния.

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

Если вы очень хотите перебазировать ветку, чтобы её почистить, то, конечно, вы можете это сделать, но настоятельно не рекомендуется переписывать ветку, к которой уже открыт запрос на слияние. Если другие люди уже стянули её и проделали много работы, то вы столкнётесь со всеми проблемами, описанными в разделе Опасности перемещения главы 3. Вместо этого, отправьте перебазированную ветку в новую на GitHub и откройте новый запрос на слияние, который указывает на предыдущий, затем закройте исходный.

Ссылки

Возможно, ваш следующий вопрос будет: «Как мне сослаться на предыдущий запрос слияния?» Оказывается, существует много способов ссылаться на другие вещи практически везде, где у вас есть права записи на GitHub.

Давайте начнём с перекрёстных ссылок для запросов слияния или проблем. Всем запросам слияния и проблемам присваиваются уникальные номера в пределах проекта. Например, у вас не может быть запроса на слияние с номером #3 и проблемы с номером #3. Если вы хотите сослаться на любой запрос слияния или проблему из другого места, просто добавьте #<num> в комментарий или описание. Так же можно указывать более конкретно, если проблема или запрос слияния находятся где-то ещё; пишите username#<num> если ссылаетесь на проблему или запрос слияния, находящиеся в ответвлённом репозитории, или username/repo#<num> если ссылаетесь на другой репозиторий.

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

Когда мы отправим запрос на слияние, то увидим что-то вроде Отображение перекрёстных ссылок в запросе слияния.

Заметьте, что указанная полная ссылка на GitHub была сокращена до необходимого минимума.

Если Тони сейчас вернётся назад и закроет оригинальный запрос слияния, то мы это увидим, так как он упомянут в новом, а GitHub автоматически создаст отслеживающее событие в хронике запроса слияния. Это значит, что все, кто просматривает закрытый запрос слияния, могут легко перейти к запросу слияния, который его заменил. Ссылка будет выглядеть как указано на Отображение перекрёстных ссылок в закрытом запросе слияния.

Кроме идентификационных номеров, можно ссылаться на конкретный коммит используя SHA-1. Следует указывать полный 40 символьный хеш SHA-1, но если GitHub увидит его в комментарии, то автоматически подставит ссылку на коммит. Как было сказано выше, вы можете ссылаться на коммиты как в других, так и в ответвлённых репозиториях точно так же, как делали это с Проблемами.

GitHub-версия разметки Markdown

Ссылки на другие Проблемы — это лишь часть интереснейших вещей, которые вы можете делать в текстовых полях на GitHub. Для «проблемы» или «запроса слияния» в полях описания, комментария, комментария кода и других вы можете использовать так называемую «GitHub-версию разметки Markdown». Разметка похожа на обычный текст, который основательно преобразуется.

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

GitHub расширил возможности обычной разметки. Эти возможности могут быть очень полезными при создании запросов слияния или комментариев и описаний к проблемам.

Списки задач

Список задач — это первая действительно важная возможность специфической разметки GitHub, особенно для запросов слияния. Список задач представляет собой список флажков для задач, которые вы хотите выполнить. Размещение его в описании Проблемы или запроса на слияние обычно указывает на то, что должно быть сделано до того, как проблема будет считаться решённой.

Список задач можно добавить следующим образом:

Если добавить этот список в описание запроса на слияние или проблемы, то он будет отображён следующим образом Отображение списка задач в комментарии

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

Так же GitHub ищет списки задач в запросах на слияние и проблемах и отображает их как метаданные на страницах, где они упоминаются. Например, если в вашем запросе на слияние есть задачи и вы просматриваете список всех запросов, то можно увидеть на сколько готов каждый из них. Это позволяет разбивать запрос на слияние на несколько подзадач и помогает другим людям отслеживать прогресс ветки. Пример приведён на Статистика задач в списке запросов слияния.

Такая возможность невероятно полезна когда вы открываете запрос на слияние на раннем этапе реализации и отслеживаете прогресс с помощью него.

Отрывки кода

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

Для добавления отрывка кода следует обрамить его обратными кавычками.

Если вы укажете название языка, как показано на примере, GitHub попробует применить к нему подсветку синтаксиса. Для приведённого примера код будет выглядеть как на Отображение обрамленного кода.

Цитирование

Если вы отвечаете только на часть большого комментария, то можно цитировать только выбранную часть, предваряя её символом > . Это настолько часто используется, что даже существует комбинация клавиш для этого. Если в комментарии выделить текст, на который вы собираетесь ответить, и нажать клавишу r , то выделенный текст будет включён как цитата в ваш комментарий.

Цитаты выглядят примерно так:

После обработки комментарий будет выглядеть как Пример отображения цитаты.

Смайлики

Наконец, вы можете использовать смайлики. На GitHub вы можете часто встретить их в комментариях или запросах на слияние. Для них есть даже помощник. Например, если при наборе комментария ввести символ двоеточия : , то будут предложены варианты автодополнения.

Смайлы имеют вид :<name>: и могут располагаться в любом месте комментария. Например, вы можете написать что-нибудь вроде этого:

Такой комментарий будет выглядеть как на Перегруженный смайликами комментарий.

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

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

Картинки

Технически, картинки не относятся к разметке GitHub, но их использование очень полезно. В дополнение к ссылкам на картинки в комментариях, GitHub позволяет встраивать картинки в комментарии.

Если вернуться немного назад к Перекрёстные ссылки в запросе слияния, то над областью редактирования вы увидите небольшую подсказку «Parsed as Markdown». Нажав не неё, вы получите полную подсказку по использованию GitHub разметки.

Поддержание GitHub репозитория в актуальном состоянии

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

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

Первый способ не требует конфигурации. Например, если вы сделали форк репозитория https://github.com/progit/progit2.git , то актуализировать ветку master можно следующим образом:

Если вы находитесь на другой ветке — перейти на ветку master .

Получить изменения из репозитория https://github.com/progit/progit2.git и слить их с веткой master .

Отправить локальную ветку master в ваш форк origin .

Каждый раз писать URL репозитория для получения изменений достаточно утомительно. Этот процесс можно автоматизировать слегка изменив настройки:

Добавить исходный репозиторий как удалённый и назвать его progit .

Получить ветки репозитория progit , в частности ветку master .

Настроить локальную ветку master на получение изменений из репозитория progit .

Установить origin как репозиторий по умолчанию для отправки.

После этого, процесс обновления становится гораздо проще:

Если вы находитесь на другой ветке — перейти на ветку master .

Получить изменения из репозитория progit и слить их с веткой master .

Отправить локальную ветку master в ваш форк origin .

Данный подход не лишён недостатков. Git будет молча выполнять указанные действия и не предупредит вас в случае, когда вы добавили коммит в master , получили изменения из progit и отправили всё вместе в origin — все эти операции абсолютно корректны. Поэтому вам стоит исключить прямое добавление коммитов в ветку master , поскольку эта ветка фактически принадлежит другому репозиторию.