Smartgit руководство на русском


Как начать работать с GitHub: быстрый старт / Хабрахабр

Распределенные системы контроля версий (DVCS) постепенно замещают собой централизованные. Если вы еще не используете одну из них — самое время попробовать.

В статье я постараюсь показать, как можно быстро начать экспериментировать с git, используя сайт github.com.

В статье не будут рассмотрены различия между разными DVCS. Также не будет детально рассматриваться работа с git, по этой теме есть множество хороших источников, которые я приведу в конце статьи. Итак, сайт github.com позиционируется как веб-сервис хостинга проектов с использованием системы контроля версий git, а также как социальная сеть для разработчиков. Пользователи могут создавать неограниченное число репозиториев, для каждого из которых предоставляется wiki, система issue tracking-а, есть возможность проводить code review и многое другое. GitHub на данный момент является самым популярным сервисом такого рода, обогнав Sourceforge и Google Code.

Для open-souce проектов использование сайта бесплатно. При необходимости иметь приватные репозитории, есть возможность перейти на платный тарифный план:

Начнем с регистрации. Идем по ссылке github.com/signup/free и вводим свои данные. После регистрации мы попадаем на Dashboard нашего аккаунта:

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

Но для начала установим git и настроим его для работы с сайтом.

Если вы работаете в Windows, качаем и устанавливаем msysgit. Это консольная версия git для Windows (далее расказ будет вестись на примере этой ОС).Инструкция для MacOS X (eng)Инструкция для Linux (eng) Проблем возникнуть не должно, просто везде жмем Next. После установки выбираем в контекстном меню Проводника Git Bash:

или через Git Bash.lnk в папке с установленой программой:

Прописываем в консоли свои данные и настройки переносов строк:git config --global user.name "ваше имя" git config --global user.email "ваша почта" git config --global core.autocrlf true git config --global core.safecrlf true

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

Для тех, кто предпочитает gui — для Windows существует несколько таких инструментов для работы с git. Два основных — это SmartGit (кроссплатформенный) и TortoiseGit. Оба неплохие, и какой использовать — дело вкуса. Я опишу работу с TortoiseGit. Для маков выбор giu тоже имеется.

  • официальный клиент от GitHub — на мой взгляд пока достаточно сыроват.
  • GitX — лично мне не приглянулся
  • GitBox — наиболее следует mac-way, очень рекомендую попробовать именно его

Качаем по ссылке code.google.com/p/tortoisegit/downloads/list. При установке везде жмем Next.

Теперь возвращаемся к github и создадим новый репозиторий. Находясь на Dashboard, жмем New Repository (https://github.com/repositories/new), вводим данные и жмем Create Repository.

GitHub позволяет работать с репозиториями тремя способами: SSH, HTTP и Git Read-Only, соответственно предоставляя ссылки трех видов для нашего репозитория:1. [email protected]:habrauser/Hello-world.git 2. [email protected]/habrauser/Hello-world.git 3. git://github.com/habrauser/Hello-world.git

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

Если же мы захотим внести изменения в репозиторий на github, нужно пользоваться HTTP или SSH. Работа по http никаких трудностей не вызывает, в нужный момент просто используется пароль учетной записи на github.

Чтобы использовать SSH, нам нужно создать специальную пару ключей: публичный и приватный. Публичный будет размещен в настройках аккаунта на github, а приватный сохранен на локальной машине.

Для генерации ключей, можно воспользоваться инструментом ssh-keygen, который идет в комплекте с git (описание этого способа можно почитать тут). Мы же будем использовать PuTTY (а точнее небольшую программку puttygen, входящую в его состав). PuTTY — это такой клиент для удаленного доступа, в том числе и с использованием SSH.

Качаем последнюю версию с официального сайта (http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html). Кстати, puttygen более старой версии (2007 год) идет в составе TortoiseGit.

После установки PuTTY, запускаем puttygen из папки с установленной программой:

Жмем Generate, двигаем некоторое время курсором мыши, для получения случайных данных, необходимых алгоритму

Вводим пароль, защищающий наш приватный ключ в поле Key passphrase, вводим подтверждение, жмем Save private key, сохраняем.

Далее копируем публичный ключ в формате OpenSSH из текстовой области «Public key for pasting...» и идем в настройки нашего аккаунта на github (Account Settings) в раздел SSH Public Keys:

жмем Add another public Key, вставляем наш публичный ключ:

нажимаем Add key. Все, теперь мы готовы работать с github по ssh. Попробуем забрать наш пустой рерозиторий на локальную машину с использованием TortioшseGit. В контекстном меню проводника выбираем Git Clone…

В поле Url вставляем SSH-адрес нашего репозитория, в поле Load Putty Key указываем путь к нашему приватному ключу, жмем OK.

Pageant запросит у наc пароль для приватного ключа (потом этого делать не потребуется)

Pageant — это агент SSH-аутентификации в составе PuTTY, он позволяет управлять закрытыми ключами. В трее висит его значек:

Репозиторий успешно склонирован на локальную машину

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

Закоммитим изменения в локальный репозиторий

и синхронизируем его с репозиторием на github:

нажимаем Push

Теперь зайдя на страницу нашего репозитория мы увидим следующее:

Для каждого репозитория сайт предлагает wiki:

а также простую систему issue tracking-a:

кстати, для тех, кто использует в работе Eclipсe — есть соответствующий mylyn-коннектор для github:

и плагин EGit:

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

Резюмируя хочется сказать, что если вы начинающий разработчик, планирующий начать пользоваться системами контроля версий, или же более опытный и присматривающийся к распределенным VCS, но не знающий как начать, то есть смысл попробовать git, используя такой замечательный инструмент как github.com.

Полезные ссылки
Для работы с git:code.google.com/p/msysgit git для windowswww.syntevo.com/smartgit/index.html SmartGitcode.google.com/p/tortoisegit TortoiseGit http://www.chiark.greenend.org.uk/~sgtatham/putty/ PuTTY

Про git на русском:habrahabr.ru/blogs/Git/106912 «Удачная модель ветвления для git» — перевод хорошей англоязычной статьиgithowto.com интерактивный курс по работе с git из консолиhabrahabr.ru/blogs/Git/106912 «Почему git» + обсуждениеhabrahabr.ru/blogs/development/68341 «Git для переходящих с SVN» + обсуждениеhabrahabr.ru/blogs/Git/75990 «Командная работа в git» + обсуждениеprogit.org/book/ru русский перевод книги «Pro Git» (переведено не до конца)habrahabr.ru/blogs/Git/123111 инструкция-шпаргалка для начинающихlos-t.livejournal.com/tag/git%20guts цикл постов «внутренности git»lib.custis.ru/%D0%9B%D0%B8%D0%BD%D1%83%D1%81_%D0%A2%D0%BE%D1%80%D0%B2%D0%B0%D0%BB%D1%8C%D0%B4%D1%81_%D0%BE_GIT_%D0%BD%D0%B0_Google_Talks Линус Торвальдс о githabrahabr.ru/blogs/Git/80909 книга «Волшебство git»

Про git на английском: книги

видео другое

habrahabr.ru

Пошаговая инструкция по работе с git и github для студентов · andreiled/mipt-cs-4sem Wiki · GitHub

Необходимое ПО

В первую очередь надо установить клиент git: обязательно потребуется консольный клиент, доступный по ссылке http://git-scm.com/downloads (поддерживаются основные ОС), графический клиент можно установить по желанию, исходя из своих предпочтений. На Unix системах можно воспользоваться менеджером пакетов (yum на fedora и подобных или apt-get на debian, ubuntu и подобных) вместо того, чтобы скачивать установщик с сайта.

Далее работа с git будет объясняться на примере работы с консольным клиентом по следующим причинам:

  • Чтобы у вас складывалось понимание происходящего и при возникновении проблем вы могли четко объяснить, что вы делали, и было видно, что пошло не так.
  • Все нажатия кнопок в графических клиентах в итоге сводят к выполнению определнных команд консольного клиента, в то же время возможности графических клиентов ограничены по сравнению с консольным
  • У тех, кто будет работать в классе на стоящих там компьютерах, не будет другого выбора, кроме как пользоваться консольным клиентом (на сколько мне известно, никаких графических клиентов для git там не установлено)

Аккаунт и репозитории на github.com

Затем надо зарегистрироваться на https://github.com/. После чего можно будет создавать свои репозитории или присоединиться к работе над проектами коллег, сделав fork другого репозитория. Вам предлагается начать с создания fork-а к заведенному мной репозиторию https://github.com/andreiled/mipt-cs-4sem, где я буду выкладывать примеры кода к занятиям и задания. О механизме обмена кодом между пользователями мы поговорим на следующем занятии.

Работа с кодом из репозитория на локальном компьютере

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

Следующим шагом после создания репозитория на github, называемого далее удаленным репозиторием, является создание локальной копии этого репозитория на своем компьютере. Особенностью git явялется наличие на локальном компьютере полной копии репозитория со всей информацией об истории изменений.

  1. Открываем консольный клиент.
  • На Windows после установки клиента появляется пункт Git Bash в контекстом меню папки. Достаточно перейти в желаемую папку и воспользоваться этим пунктом меню.
  • На Unix системах достаточно открыть терминал и перейти в нужную директорию. При стандартной установке консольного клиента будет доступна команда git без дополнительных усилий.
  1. Выполняем команду git clone https://github.com/%user_login%/%repo_name%.git. Полную https ссылку на репозиторий для его выкачивания можно также найти на странице самого репозитория на github. После этого в текущей папке появится новая папка с именем %repo_name%, содержащая копию удаленного (remote) репозитория.
  2. Переходим в свежесозданную папку репозитория и настраиваем его:
  3. git config user.name ivan.ivanov
  4. git config user.email [email protected]

Внесение и оформление изменений в локальном репозитории

  1. Воспользовавшись командой git status можно узнать, на какой ветке (branch) репозитория вы сейчас находитесь, какие изменения присутствуют в вашей рабочей копии и другую информацию.Рабочей копией называется совокупность файлов в локальной папке репозитория за исключением служебных файлов.
  2. После внесения каких-либо изменений в рабочую копию их можно закоммитить в локальный репозиторий:
  3. сначала нужная часть изменений подготавливается к коммиту с использованием команды git add %file_path%
  4. после чего производится коммит командой git commitИспользование команды без аргументов откроет текстовый редактор, где надо будет написать комментарий для коммита, коммит обязательно должен иметь комментарий. Другим вариантом задания комментария к коммиту является использование команды git commit -m "%commit_message%"
  5. Историю изменений можно посмотреть командой git log или git log --name-only. Если вся история изменений не умещается на экране, то можно пользоваться клавишами прокрутки на клавиатуре ("стрелочки", PgUp, PgDown), выход из режима просмотра изменений осуществляется нажатием клавиши "q".

Загрузка локальных изменений в удаленный репозиторий

После того, как были выполнены нужные локальные коммиты, изменения можно загрузить в удаленный репозиторий с помощью команды git push origin master. GIT клиент при этом запросит имя пользователя и пароль для доступа к github.Выполнение этой команды может закончиться с ошибкой, если в локально репозитории отсутствуют последние изменения, имеющиеся в удаленном репозитории. Для решения этой проблемы надо выполнить команду git pull, которая скачает последние изменения из удаленного репозитория и смержит их с вашими локальными правками, после чего можно повторить команду git push.

github.com

GIT: Инструкция-шпаргалка для начинающих

webhamster.ru

Работа с Git репозиториями

Почему Git

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

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

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

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

Более подробно можно прочитать http://habrahabr.ru/blogs/Git/104198/

Общие сведения о Git

Подробно о работе с Git, что это такое можно прочитать в Git Book по адресу http://book.git-scm.com/

В классических VCS (Version Control System) (CVS, SVN), в рабочей копии хранится текущее состояние репозитория, и базовая копия текущей ревизии. На сервере хранятся все ревизии в виде изменений от предыдущей, либо в виде полных копий каждой ревизии с вычислением разницы по запросу. Все ревизии нумеруются по порядку начиная от первой.В случае CVS хранятся изменения и нумерая по каждому файлу независимо, в случае SVN, нумеруются изменения репозитория.Так как SVN хранит только изменения всего репозитория, «ветки» в нем реализуются через специальную организацию файлов в хранилище. Классически, это /trunk/ для последнего кода, /branch/somename/ для веток. Для создания ветки, делается копия /trunk/ в /branch/somename/, над которым уже работает разработчик.При этом, при каждом коммите, идёт обращение к центральному репозиторию, для сохранения изменения, отрабатывают скрипты на сервере, идет непрерывная нумерация изменений, запрос истории так же требует обращения на сервер и т.д.

Git относится к классу DVCS (Distributed Version Control System). При этом рабочая копия содержит все коммиты, историю, ветки, всё необходимое для ведения разработки без обращения к какому-либо серверу. Для синхронизации изменений между разными копиями репозитория, в нужный момент делается pull чтобы скопировать изменения удалённого репозитория к себе, либо push чтобы скопировать локальные изменения в удалённый репозиторий. В случае с Git, каждый коммит имеет уникальный ID в виде хеша, содержащий в себе все файлы, относящиеся к нему.

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

Чтобы поддерживать «плоскую» основную ветку (master), используется техника ребейза веток перед слиянием, и слияение без fast-forward'а.

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

Если теперь сделать слияние этой ветки с исходной, указатель головы исходной ветки будет просто передвинут на новое место, и мы потеряем информацию о том, что вообще существовала новая ветка. Именно поэтому используется слияние без fast-forward'а. При этом, даже если новая ветка начинается с конца предыдущей, создаётся специальный merge-commit, содержащий информацию о том, что в этом месте сливается текущая ветка с дополнительной.

Подробнее о том, что такое rebase в картиках тут: http://book.git-scm.com/4_rebasing.html

Алгоритм работы над задачей

Стандартный алгоритм работы над какой-либо задачей выглядит так:

  1. Создаётся ветка, основывающаяся на последней копии master ветки. Название новой ветки содержит класс задачи, краткое описание, номер задачи в БТ. Например feature/sessions_add_datetime_filter.5503
  2. Все изменения производятся внутри этой ветки. При каждом атомарном логическом изменении (например, добавили плагин – закоммитили добавление; поправили API одной функции во всех местах – закоммитили и тп) создаётся свой коммит. Это позволяет разделять какие были изменения, упрощается чтение и проверка на ошибки процесса разработки.
  3. После того как код в ветке сделан и отлажен, все изменения закоммичены, данная ветка ребейзится относительно последнего мастера, и пушится в центральный репозиторий.
  4. Второй человек, работающий над тем же проектом, делает к себе pull центрального репозитория. Если он уже смотрел – то удаляет свою локальную копию ветки, после чего переключается на указанную ветку. Прочитывает код, проверяет его работоспособность, после чего либо отдаёт на доработку, если там обнаружены проблемы, либо делает еще раз rebase поверх мастера, и слияние ветки с мастером.
  5. После слияния с мастером, ревьюер пушит новый мастер в центральный репозиторий, удаляет у себя локальную ветку задачи, пушит в мастер удаление ветки задачи.
  6. Разработчик удаляет локальную ветку задачи после того как задача была закрыта и изменения попали в master.

Правила ведения чистых коммитов

Все коммиты, которые попадают в центральную ветку, должны следовать следующим правилам:

  1. Автором должен быть прописан разработчик – Имя, Фамилия, рабочий e-mail.
  2. Текст комментария должен содержать краткое описание изменения. Для зарубежных проектов описание обязано быть на английском языке, для проектов российского бранча приемлемо комментировать на русском.
  3. Коммит не должен содержать в себе файлы, не относящиеся к изменениям. Если ваша IDE, OS, какой-то плагин какому-либо софту использующемуся при разработке создают технические файлы, либо добавьте их в .gitignore, либо не добавляйте к коммиту, либо удаляйте перед коммитом.
  4. Коммит не должен добавлять/убирать пустые строки, менять пробелы на табы и наоборот, менять число пробелов и т. п. нигде, кроме случаев, относящихся к сути коммита. То есть при рефакторинге это нормально, но если ваш редактор поменял во всем файлые пробелы на табы или наоборот – меняйте настройки редактора или перед коммитом приводите всё к виду «как было».
  5. Стиль исходного кода и отступов должен совпадать с текстом вокруг. То есть, если всюду в файле используются табы для отступа, не следует вставлять еще один case выровненный пробелами.
  6. Минимизация конфликтов. При добавлении кода следует стараться форматировать код так, чтобы модификация его приводила к минимуму конфликтов при слиянии.

Работа под Windows

Для работы с Git под Windows самое удобное – использовать TortoiseGit. Однако следует знать, что на 2017 год есть более удобный инструмент - SmartGit.

Подготовка к работе

  1. Устанавливается putty со страницы http://www.chiark.greenend.org.uk/~sgtatham/putty/Лучше всего ставить полный пакет, со всеми программами. По надобятся как минимум plink, puttygen.
  2. Устанавливается msysGit из проекта http://code.google.com/p/msysgit/Выбрать опции при установке «Add “Git Bash here”», «Run Git from the Windows Command Prompt», «Use Windows style line endings», когда спросит – дать путь до plink.exe
  3. Устанавливается TortoiseGit из проекта http://code.google.com/p/tortoisegit/После установки зайти в TortoiseGit → Settings → Git → Config, убедиться что путь до msysgit задан, и что опции AutoCRLF и SafeCRLF установлены, настроены имя, фамилия, email разработчика.
  4. С помощью puttygen создаётся пара приватный+публичный ключ.Публичный ключ высылается админам для добавления в доступы репозиториев и серверов.Приватный ключ добавляется в pagent через клик правой кнопкой → add key.

Получение репозитория

В папке, где будут размещаться все рабочие проекты, жмёмПравой кнопкой→TortoiseGit→Clone, вводим адрес центрального репозиторияssh://[email protected]СЕРВЕР:ПОРТ/РЕПОЗИТОРИЙ.gitВ поле «Load Putty Key» выбираем путь до приватного ключа.

Основные используемые функции

При работе используются либо консольные утилиты, аналогично linux, либо графический интерфейс.

  1. Обновление текущей ветки из центрального репозитория:В контекстном меню папки с исходниками TortoiseGit->Pull

  2. Отправка текущей ветки в центральный репозиторий:В контекстном меню TortoiseGit→PushВыбираем в Local сперва master, потом нашу текущую ветку.Remote заполняется при этом автоматически.Название remote ветки должно быть идентично local
  3. Переключение на некоторую ветку:В контекстном меню TortoiseGit→Switch/CheckoutВ меню Branch выбрать remotes/origin/<нужная ветка>[v] «Create new branch», название <нужная ветка>, [v] «Track»

  4. Создание новой веткиКонтекстное меню→TortoiseGit→Create BranchВ Name в Branch вводим нужное название веткиЧтобы ветка базировалась от текущей, в Base On выбираем HEADЧтобы ветка базировалась от мастера, выбираем Branch, в списке master.Ставим [v] Switch to new branch чтобы сразу переключиться на ветку.

  5. Удаление ветокОткрываем меню зажав кнопку Shift → TortoiseGit → Browse Referenceв разделе heads лежат локальные ветки, в разделе remotes\origin удалённые.Выбираем нужную ветку, жмём правой кнопкой → Delete Remote BranchДля локальной ветки, соответственно, Delete Branch.
  6. Слияние ветки с текущейКонтекстное меню → TortoiseGit → Mergeвыбираем Branch который нужно слить с текущей веткойставим обязательно галочку «No fast forward», Merge message не трогаем.
  7. Просмотр и сохранение измененийФайлы с изменениями помечены красными восклицательными знаками.Чтобы посмотреть общую картину изменений, Меню→Git Commit -> “ветка”Внизу список изменений в репозитории, обязательно нажимать галочку «View patch» и проверять изменения на предмет соответствия Правилам ведения чистых коммитов.

Стандартные процедуры работы

  1. «Начало работы над задачей»Выполняется перед началом работы над задачей. Дерево должно быть без изменений.Меню → TortoiseGit → Switch/Checkout,Branch: masterМеню → TortoiseGit → PullМеню → TortoiseGit → Create BranchName Branch: название новой веткиBase On: HEAD (master)[x] Switch to new branch
  2. «Коммит очередного кусочка работы»Выполняется после выполнения некого изменения, суть которого целостная.Меню → Git commit -> “имя ветки”Отметить файлы, только нужные для данного конкретного коммитаОбязательно щелкнуть на «View Patch», и убедиться в соответствии правилам ведения чистых коммитаВ message ввести описание изменения, соответствующее правилам
  3. «Отправка ветки на центральный репозиторий»Выполняется после завершения работы, либо в конце каждого дня (чтобы был бакап на сервере), либо если нужно какие-то изменения показать коллеге.Меню → TortoiseGit → Push Выбираем в Local сперва master, потом нашу текущую ветку.Remote заполняется при этом автоматически.Название remote ветки должно быть идентично localНе следует делать push после каждого коммита, так как это потребует доступа до удалённого сервера, и, соответственно, времени, потраченного впустую.
  4. «Ребейз относительно мастера»Выполняется перед заливкой на сервер законченной задачи, когда все изменения уже закоммичены.Меню → Git SyncLocal branch: masterRemote branch: masterПравая стрелочка вниз у первой кнопки (Pull по умолчанию), FetchМеню → TortoiseGit → *RebaseBranch: текущая веткаUpStream: masterЕсли будут конфликты – разобраться с ними через вкладку «Conflict File»На выбор, правой кнопкой файла, утилитыEdit Conflicts – позволяет по каждому расхождению выбратьиспользовать версию какую блокаResolve Conflicts Usingtheirs – использовать версию мастераmine – использовать версию текущей веткиOpen – открыть в редакторе, и исправить вручнуюПосле исправления сделать ResolveПосле исправления всех конфликтов нажать CommitПосле ребейза нажать Done
  5. «Кратковременное сохранение состояния изменений»Выполняется, если требуется временно приостановить работу над текущей веткой на короткое время (например, на ревью, или чтобы сделать какую-либо двухминутную задачу).Меню → TortoiseGit → Stash SaveПосле этого дерево чисто, можно переключиться на другую ветку/мастер и так далее, поработать, после чего восстановить состояние, если переключиться обратно на рабочую ветку, и сделатьМеню → TortoiseGit → Stash PopТем самым восстановив состояние изменения.
  6. «Длительное сохранение состояния изменений»Выполняется в конце рабочих суток, чтобы даже частичные изменения были забакаплены; либо при необходимости срочно переключиться на решение другой задачи, которая может занять значительно больше 5-10 минут.Меню → Git Commit -> “ветка”Отмечаем все-все изменения (Select/Deselect All)В текст сообщения пишем «Partial commit»Позже, для возврата к тому же состоянию как было до, переключаемся на рабочую ветку, и делаемМеню → TortoiseGit → Show LogВыделяем коммит, который идет в дереве сразу перед «Partial commit»Правой кнопкой → Reset <ветка> to thisReset type: Mixed
  7. «Ревью ветки»Выполняется на чистом дереве, временно сохраните изменения согласно пункта 5, если требуется.Меню → TortoiseGit → Switch/CheckoutBranch: masterМеню → TortoiseGit → PullМеню → TortoiseGit → Switch/CheckoutBranch: remotes/origin/нужнаяветка[x] Create new branch: нужнаяветка[x] Force[x] Track[x] Override branch if existsМеню → TortoiseGit → *RebaseBranch: нужнаяветкаUpStream: masterВетка ветка должна быть «up to date» или заребейзится без конфликтов.== Анализируем изменения просмотром лога изменений черезМеню → TortoiseGit → Show logи смотрим изменения от master до последнего== Смотрим общее изменение относительно мастераМеню → TortoiseGit → Diff with previous versionVersion 1: HEADVersion 2: master== если всё хорошо, делаемМеню → TortoiseGit → Switch/CheckoutBranch: masterМеню → TortoiseGit → MergeFrom: нужнаяветка[x] No fast forwardСообщение не редактируем.Меню → TortoiseGit → PushИ удаляем ветки:Shift + Меню → TortoiseGit → Browser Referenceв дереве слева Refs => heads => находим ветку, правой кнопкой, Delete branchв дереве слева remotes => origin => находим ветку, правой кнопкой,Delete remote branch

Работа под Linux

Подготовка к работе

  1. Устанавливаются системные пакеты ssh-client и git
  2. Создаётся приватный ключ:

    ssh-keygen -t dsa -C "Ivan Petrov <[email protected]>"

  3. Настраивается ФИО и Емейл автора:

    git config --global user.name "Ivan Petrov"git config --global user.email [email protected]"

  4. Админу отсылается файл ~/.ssh/id_dsa.pub для прописывания доступов до репозиториев и серверов.

Получение репозитория

Переходим в директорию для работы, и запускаем

git clone ssh://[email protected]СЕРВЕР:ПОРТ/РЕПОЗИТОРИЙ.git

Основные используемые функции

  1. Обновление текущей ветки из центрального репозитория:

    git pull

  2. Отправка текущей ветки в центральный репозиторий:

    git push origin branchname

  3. Переключение на некоторую ветку:

    git checkout branchname

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

  4. Создание новой ветки, базирующейся на текущей

    git checkout -b branchname

  5. Удаление веток

    git branch -d branchname == удаление локальной уже слитой веткиgit branch -D branchname == принудительное удаление локальной веткиgit push origin :branchname == удаление ветки с центрального репозитория

  6. Слияние ветки с текущей

    git merge --no-ff branchname

  7. Посмотреть какие файлы изменены в текущей директории:

    git status

  8. Просмотреть текущие изменения:

    git diff

  9. Сохранение текущих изменений:

    git add именафайлов == добавить измененные/созданные файлы/директорииgit rm именафайлов == добавить удаление файла/директорииgit commit == сохранить добавленные изменения. Откроется редактор, чтобы ввести комментарий к коммитуgit commit -a == сохранить все добавленные изменения и все измененные файлы. Позволяет сохранять все изменения, если файлы не добавлялись.

Стандартные процедуры работы

  1. «Начало работы над задачей».Выполняется перед началом работы над задачей. Дерево должно быть без изменений.

    git checkout mastergit pullgit checkout -b branchname

  2. «Коммит очередного кусочка работы».Выполняется после выполнения некого изменения, суть которого целостная.

    # проверяем, какие файлы изменились к текущему моменту# удаляем если что-то попало совсем лишееgit status

    # смотрим текст изменений, на предмет соответствия # правилам ведения чистых коммитов. удаляем, если какой-либо мусор попалgit diff

    # если какие-либо файлы не должны попасть в коммит (например,# относятся к другому атомарному изменению.)# то помечаем только те файлы, изменения которых нужно сохранитьgit add …git rm …

    # сохраняем. -m можно опустить, тогда комментарий через редактор git commit -m "Some commit message"

    # если все на текущий момент созданные изменения нужно сохранить, то# через git add добавляем новые файлы, а всё остальное сохраняем черезgit commit -a -m "Some commit message"

  3. «Отправка ветки на центральный репозиторий»Выполняется после завершения работы, либо в конце каждого дня (чтобы был бакап на сервере), либо если нужно какие-то изменения показать коллеге.

    git push origin branchname

    Не следует делать push после каждого коммита, так как это потребует доступа до удалённого сервера, и, соответственно, времени, потраченного впустую.

  4. «Ребейз относительно мастера».Выполняется перед заливкой на сервер законченной задачи, когда все изменения уже закоммичены:

    git checkout mastergit pullgit checkout branchnamegit rebase master

    При возникновении конфликтов, нужно:

    (*)git status == проверить файлы, для которых есть неразрешенные конфликты.

    Редактируем первый файл с конфликтом: находим в нем «<<<<<». То, что между <<<<< и ==== – содержит копию текста из master ветки, то что между ===== и >>>>> содержит текст из нашей ветки. Нужно на этом месте оставить одну единую версию, содержащую общий код и мастера и нашей ветки

    git add измененный_файл

    перейти на (*)

    После исправления конфликтов во всех файлах, запускаем

    git rebase --continue

    Если конфликты несовместимые с дальнейшим продолжением ребейза

    git rebase --abort == прерывает ребейз и возвращает ветку в исходное

    состояние (до начала ребейза)

    После ребейза обновляем состояние ветки в центральном репозитории

    git push origin branchname -f

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

    git stash save

    После этого дерево чисто, можно переключиться на другую ветку/мастер и так далее, поработать, после чего восстановить состояние с помощью

    git checkout originalbranchgit stash pop

    Тем самым восстановив состояние изменения.

  6. «Длительное сохранение состояния изменений».Выполняется в конце рабочих суток, чтобы даже частичные изменения были забакаплены; либо при необходимости срочно переключиться на решение другой задачи, которая может занять значительно больше 5-10 минут.

    git add . git commit -m "Partial commit"git push origin branchname

    Позже, для возврата к тому же состоянию как было до, выполняется

    git checkout branchnamegit reset --soft HEAD^git reset HEAD .Важно! После такой процедуры сохранения/восстановления, при следующем

    git push origin branchname

    Будет выдано предупреждение о непоследовательном изменении. Чтобы принудительно отправить изменения, следует добавить опцию -f.

    git push -f origin branchname

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

  7. «Ревью ветки».Выполняется на чистом дереве, временно сохраните изменения согласно пункта 5, если требуется.

    git checkout mastergit pullgit branch -D branchnamegit checkout branchnamegit rebase master == ветка обязана наложиться без конфликтовgit diff master == изучаем разницу от мастера или общим диффом, или git log master..HEAD == смотрим какие коммиты были между мастером и текущей веткой

    Если всё хорошо, делаем:git checkout mastergit merge --no-ff branchnamegit push origin mastergit push origin :branchnamegit branch -d branchname

Основы системы управления версиями Git для новичков на примере SmartGit

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

В общем, под катом статья, как используя SmartGit и BitBucket можно улучшить свою жизнь начинающего разработчика.

Маленький план того, что мы будем делать:

  1. Создание репозитория на Bitbucket и клонирование репозитория (добавление его в SmartGit).
  2. Создание комитов.
  3. Отмена изменений.
  4. Создание веток.
  5. Проталкивание веток на удаленный репозиторий (аплоад веток на удаленный сервер).
  6. Слияние веток.

Клонирование репозитария

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

Запустим SmartGit, выберем «Project» — «Clone» (или Ctrl + Alt + O) и заполним необходимые поля:

Система запросит ваш логин и пароль от Bitbucket:

В следующем окне доступны две опции клонирования «Include Submodules» и «Fetch all Heads and Tags». Git позволяет отдельные модули приложения хранить в разных репозиториях. Если вы отметите опцию «Include Submodules» — SmartGit автоматически подгрузит все модули. Если отметить опцию «Fetch all Heads and Tags», то SmartGit после создания папки проекта скачает все ветки и теги для данного репозитория:

Далее очень просто — в следующем окне необходимо выбрать директорию, куда клонировать репозиторий. После него появится окно, в котором задается имя проекта в SmartGit. И если вы клонировали пустой репозиторий (как в этой статье), то по завершению увидите следующее окно:

Сохранение измений (т.е. создание коммита)

Идем дальше. Создадим комит. Что такое комит? Это фиксация изменений. Каждый комит «запоминает» что именно вы изменили и в любой момент времени можно вернуть прежнее состояние файлов. Советую вам после каждого значимого изменения, например, исправление бага в функции, делать комит. Что бы создать комит, нужно что-то изменить в проекте. Добавьте парочку файлов в папку с проектом:

Теперь можно увидеть изменения нашего проекта в SmartGit:

Выберем оба файла и нажмем сначала «Stage», а потом «Commit». Зачем нужно нажимать «Stage»? Кнопка «Stage» добавляет в текущий индекс выбранные файлы. Если вы хотите создать комит для двух файлов, а изменили, предположим целых 5, достаточно выбрать эти два файла, нажать «Stage», что добавит их в индекс, а после «Commit». Таким образом только выбранные два файла попадут в комит.

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

После чего следует нажать кнопку «Commit». Кнопка «Commit & Push» делает тоже самое, но еще и  проталкивает (заливает) изменения в удаленный репозиторий (в нашей случае это Bitbucket). Пока не стоит этого делать. Проталкиванием мы займемся далее. Внизу, в списке веток, появится локальная ветка «master». Это основная ветка кода приложения. Что такое ветки, расскажу чуть позже.

Откат изменений

А сейчас сделаем что-нибудь с нашим проектом, а потом откатим изменения. Я удалю файл readme.txt, отредактирую файл index.php и добавлю новый файл confic.cfg и сделаю коммит.

А теперь откатим изменение после комита. Зайдем в Log:

Выберем комит, к которому хотим откатиться и нажмем «Reset»:

В следующем окне нам предлагают выбрать какой именно «Reset» мы хотим сделать:

Объясню. Вспомните, что при создании комита, вы сначала добавляете файлы в индекс (stage). Это позволяет закомитить только проиндексированные файлы. Soft reset сбрасывает только комиты. Индекс и физические изменения в файлах остаются. Mixed reset работает так же, как и софт, но еще удаляет индекс файлов. Hard reset удаляет комиты, индекс и физические изменения в файлах. Аккуратно используйте hard reset, что бы нечаянно не удалить лишнего.

Я сделал hard reset для наглядности:

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

Создание новой ветки

Теперь немного о создании веток. Зачем они вообще нужны? Ветка позволяет сохранить текущее состояние кода и безопасно экспериментировать с изменениями в коде. Например, вы пишите новый модуль. Логично делать это в отдельной ветке. Звонит начальство и говорит, что в проекте баг и срочно нужно пофиксить, а у вас модуль не дописан. Как же заливать нерабочие файлы? Просто переключитесь на рабочую ветку без модуля, пофиксите баг и заливайте файлы на сервер. А когда «опасность» миновала — продолжите работу над модулем. И это один из многих примеров пользы веток.

Попробуем создать свою ветку. У нас уже одна есть, это master. Она создается автоматически (если отсутствует) когда вы делаете первый комит. Создадим еще одну ветку и назовем ее «new_future1». Нажмите F7 или правым кликом внизу во вкладке «Branches» на надпись «Local Branches» и в выпадающем списке выберите «Add branch»:

Нажмите «Add branch & Switch» что бы сразу переключиться на созданную ветку. Теперь вы можете создавать новые комиты, изменять файлы и не беспокоиться. Так как у вас всегда есть ветка мастер, в которую можно вернуться. Когда вы переключаете ветку, Git меняет локальные файлы на те, которые есть в этой ветке. То есть, если вы создадите новую ветку поменяете что-то в файле index.php, а потом переключитесь на ветку master то все изменения, произведенные вами будут удалены. Если же переключиться обратно в созданную ветку — изменения вернутся.

Отправка изменений в удаленный репозитарий

До сих пор мы работали локально. Попробуем залить труды нашей работы на сервер. Создадим какой-нибудь комит в ветке new_future1.  В случае если репозитарий пуст, а он пуст, так как мы создали его некоторое время назад и на сервер ничего не залили, Bitbucket основной назначает ту ветку, которую залили первой. Поэтому переключимся на ветку «master» и нажмем кнопку «Push»:

... Картинка "Кнопка Push SmartGIt" ...

Дальше SmartGit спросит настроить ли отслеживание ветки (cofigure tracking). Отслеживание позволяет автоматически обновлять соответствующие ветки, когда вы скачиваете или загружаете обновления кода. Поэтому смело жмите «Configure»:

Теперь переключитесь на другую ветку и проделайте тоже самое. Зайдем на Bitbucket и посмотрим, что изменилось в разделе «Commits»:

Как видите все попало на удаленный сервер.

Слияние веток

Теперь сольем ветки. Зачем это нужно? Возьмем тот же пример с модулем. Рано или поздно вы допишите его и вам нужно будет добавить код модуля в основной код приложения. Достаточно просто слить ветки. Для этого переключитесь на ветку, в которую хотите слить код. В нашем случае это мастер. После чего нажмите правым кликом на ветку, с которой хотите слить код и выберите «Merge»:

 

Дальше SmartGit спросит каким именно образом нужно слить ветки. Выберите «Create Merge-Commit».

 

А теперь осталось протолкнуть изменения ветки master на сервер. Заливаем изменение на сервер так же, как мы делали это раньше и получаем:

Вот и все на этот раз. Из-за картинок статья вышла большой. Задавайте свои ответы. Пишите вопросы.

webhamster.ru

Установка git в Windows (на этот раз подробно)

Судя по всему, многие из посетителей приходят на этот блог в поисках руководства по установке Git в Windows. И, что самое печальное, всё что они находят — куцая страничка со ссылкой на англоязычный скринкаст. Пришло время исправить это недоразумение 🙂

Установка и настройка

Итак, установка git. Сразу оговорюсь что мы будем ставить msysgit, и заодно произведём необходимые действия для подключения к GitHub. Конечно, можно использовать git и в одиночку, для себя — но здесь, как и с играми, в онлайне намного интереснее 🙂

Идём на страницу git, в раздел Download и ищем там msysgit для Windows. Сайт git отправляет нас на Google Code. Берём Full Installer for official Git.

Запускаем, устанавливаем. При установке будет предложено выбрать тип запуска Git:

  • Git bash only: git ставится и вызывается командой контекстного меню «Git bash here»/»Git gui here»
  • Run from the Windows command prompt: Устанавливает Git и прописывает путь к консольной версии в PATH. Команду ‘Git Bash here’ всё равно можно использовать.
  • Run Git and tools from Windows Command Prompt: то же что предыдущий вариант, но дополнительно прописывает в Windows путь к различным Unix-утилитам типа find и sort. Git предупреждает нас что при этом вместо windows-приложений с соответствующими именами будут вызываться unix-аналоги

Я предпочитаю второй вариант, т.к. использую git исключительно из командной строки. Так что это руководство будет по большей части консольным 🙂

Продолжаем установку. В конце git предложит просмотреть файл примечаний к релизу. Собственно, на этом установка заканчивается 🙂 Теперь идём в командную строку (если Вы выбрали этот вариант) и вводим свои данные в git, чтобы он нормально подписывал коммиты.

git config --global user.name &quot;Ваше имя&quot; $ git config --global user.email &quot;ваш[email protected]&quot;

Не забудьте подставить своё имя/ник и email 🙂 Параметр --global говорит нам что мы изменяем глобальные настройки. Чтобы изменить настройки только одного репозитория, перейдите в его папку и сделайте то же без --global:

cd my_repo git config user.name &quot;Ваш ник&quot; $ git config user.email &quot;другой[email protected]&quot;

Кстати, создаётся репозиторий командой git init в нужной папке. Всё, git можно пользоваться в локальном режиме 🙂

Давайте теперь что нибудь утянем с Github. Идём туда, делаем поиск или Explore Github, открываем понравившийся проект. Прямо под названием проекта будет Clone URL:

Жмём, копируем команду. Получится примерно что то такое:

git clone git://github.com/quickredfox/jquery-builds.git

Переходим в каталог куда мы хотим положить проект, и выполняем команду. Имейте в виду, git создаст для проекта каталог чтобы его туда положить. То есть, если мы выполним эту команду в D:\Source, проект будет в папке D:\Source\jquery-builds.

Конфигурация для использования GitHub

Чтобы хранить свой проект в GitHub, надо ещё немного покопаться с настройкой 🙂 Нам понадобится пара ключей SSH. Открываем консоль Git bash, всё равно где. В msysgit процесс генерации пары ключей упрощён почти до предела. Делаем:

ssh-keygen -t rsa -C "ваш[email protected]"

У Вас спросят куда положить ключи (не потеряйте их, лучше выбрать предлагаемое программой место), дважды спросят пароль (passphrase). Пароль должен быть сложным. После этого Вы получите два файла и RSA fingerprint примерно такого вида:

e8:ae:60:8f:38:c2:98:1d:6d:84:60:8c:9e:dd:47:81 [email protected]

Теперь идём и регистрируемся на Гитхабе, в бесплатном варианте.

Внимание, бесплатный аккаунт на GitHub — аккаунт для Open-Source проектов. Вы не сможете закрыть свой код, или скрыть его от других. Не используйте его для проприетарного кода и рабочих проектов!

В поле SSH Public Key вставляем содержимое файла id_rsa.pub, или как Вы его там назвали при создании ключей. Если Вы создали ключи в своей папке пользователя, ssh самостоятельно его найдёт. Иначе, надо будет добавить ключи вручную:

ssh-add <путь к файлу ключей>

Завершаем регистрацию. Теперь можно уже проверить что получилось. В простой командной строке подключаемся к серверам github:

ssh github.com

В ответ должно прийти:

Hi username! You’ve successfully authenticated, but GitHub does not provide shell access.

Это значит что всё в порядке.

Если Вы видите No supported authentication methods available, значит Git не может найти программу, способную достучаться до сервера Гитхаба. Строка вызова используемой программы хранится в переменной GIT_SSH. Чтобы использовать программу ssh (самый простой способ), надо сделать в командной строке:

set GIT_SSH=ssh

Имейте в виду, после перезагрузки эта переменная вернётся в начальное состояние.

Ссылки по теме

Понравилось это:

Нравится Загрузка...

Похожее

kuroikaze85.wordpress.com

DVCS Git и TortoiseGit в картинках. Пособие для начинающих чайников. — Delphi в Internet

Не так давно проект «Google API в Delphi» успешно переехал на новый адрес и теперь находится под управлением распределенной системы контроля версий Git. Для чего и почему мы это сделали — это вопрос второстепенный, а вот работа с Git, по крайней мере для меня, стала основной. По сути этот пост ни что иное как шпаргалка для себя любимого по выполнению основных операций при работе Git, но может эта шпаргалка поможет кому-то как и мне начать работу с этой DVCS.

Небольшое введение. О чем вообще пойдет речь

Git — распределённая система управления версиями файлов. Проект был создан Линусом Торвальдсом для управления разработкой ядра Linux.

То обстоятельство, что система создавалась «под Linux» уже как бы намекает на то, что без консоли нам не обойтись. Но не стоит махать руками и кричать «консоль отстой, git — в печь» и все такое. Поверьте — консоль Linux и консоль Windows имеют для обычного пользователя только одно общее свойство — чёрный экран при первом запуске. Команды Linux (ИМХО) просты и запоминаются без проблем, а работать с консолью не составляет особого труда даже для такого чайникак как я.

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

Это обстоятельство и поставило меня в начале работы с Git в тупик.Как этот так commit и не в центральный репозиторий?Как правильно отправлять данные на сервер?Как вообще начинать работу?Эти и ещё многие другие вопросы посещали меня на сарте работы с Git. Сейчас я не буду углублятся далеко в теоретические вопросы Git, да и вообще любых систем контроля версия — всего этого полно в Сети. А затрону один практический момент — как начать работу вообще, чтобы потом не было мучительно больно за бесцельно потеряные исходники.

Качаем и устанавливаем софт

Для работы с Git под Windows имеются вполне работоспособные и юзабельные решения, например, msysgit. Однако если Вы ранее имели опыт работы с SVN и использовли в работе TortoiseSVN, то видимо, Вам захочется иметь аналог подоного интерфейса и для Git? Нет проблем вот аналог TortoiseSVN для Git — TortoiseGit.По сути TortoiseGit по после нажатия команды из контекстного меню запускает консольную команду из MSysGit и рисует в окошко ее вывод. Если вы не хотите или просто не хватает времени детально разобраться в консольных командах Git, то TortoiseGit — то, что Вам нужно.Итак, если Вы работаете под 32-х битной Windows, то Вам необходимо скачать следующий софт:1. msysgit — качаем Git-1.7.1-previewXXXXXXXX.exe (11,6 Mb)2. TortoiseGit. На момент написания статьи последней была версия TortoiseGit-1.5.2.0-32bit.msi (19.6 MB)Получается, что скачать нам надо чуть больше 30 Mb.Теперь устанавливаем скачанные программы.Вначале ставим msysgit, а потом TortoiseGit.При установке msysgit настройки по умолчанию можно не изменять.При установке TortoiseGit выбираем в окне «Choose SSH Client» второе значение:После успешной установки обоих продуктов работу над первым этапом можно считать завершенной. Приступим ко второму — получение доступа к репозиторию.

Получаем доступ к репозиторию

В качестве примера я буду рассматривать получение доступа к нашемо репозиторию, который располагается на github.com.Распишем все операции по шагам.1. Регистрация на GitHub’e.

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

Профиль на GitHub.com

2. Генерируем ключ для доступа по SSH.Вот тут хочешь-нехочешь, а надо запускать консоль. После учатновки msysgit у Вас на рабочем столе появился новый ярлык — Git Bush — вот с помощью него и запускаем консоль.

  1. Набираем в консоли следующую команду

    ssh-keygen -t rsa -C «E-Mail из Вашего профиля»

  2. На экране появится запрос «Enter file in which to save the key». Пока оставим значение по умолчанию. Жмем Enter.
  3. Нас попросят ввести пароль. Эту часть тоже пропускаем — впоследствии пароль можно будет установить, а пока — учимся. Жмем опять Enter.
  4. Сгенерируются два файла один из которых — публичный ключ для доступа.

Если Вы все делали с настройками по умолчанию то файлы будут располагаться в директории:

C:/Documents and Settings/UserName/.ssh/

Заходим в директорию, открываем с помощью «Блокнота» файл ida_rsa.pub и копируем все его содержимое в буфер обмена.

3. Заносим публичный ключ доступа в профиль.

Для записи публичного ключа в профиль:

  1. Заходим в свой профиль github и жмем ссылку Account Settings (сверху)
  2. Выбираем пункт «SSH Public Keys»
  3. Жмем ссылку «Add another public key»

Перед вами появится форма добавления нового публичного ключа. Вставляем из буфере весь скопированный ранее текст (из файла ida_rsa.pub) только в поле key — поле Title оставляем пустым.

На этом работа с публичными ключами закончена.

4. Просимся в проект.

Для этого достаточно найти наш проект на github и отправить одному из администраторов запрос на предоставление доступа к репозиторию. Или просто отправить мне email с логином на github. После того как вы будите записаны в список разработчиков проекта можно переходить к следующей фазе работы — получение исходников.

Работа со своим первым репозиорием Git

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

Итак, выбираем директорию на жестком диске где мы будем хранить все файлы. Далее действуем следующим образом:

1. Вызываем контекстное меню и выбираем пункт «TortoiseGit — Settings«:

В появившемся окне переходим сразу к пункту «Git — Config» и записываем свое имя и адрес элекронной почты. Эти данные должны в точности совпадать с теми, что записаны в Вашем аккаунте на github, иначе ваш ключ просто не подойдет.

2. Клонируем репозиторий. Для этого заходим на страницу проекта, и копируем в буфер адрес:

Теперь жмем правой кнопкой мыши на директории, в которой будем хранить исходники и в меню выбираем «Git Clone..«:

В открывшемся окне в поле URL вставляем скопированный адрес и жмем «Ok»:

Начнется процесс клонирования репозитория.

Всё вышесказанное можно было бы заменить всего двумя командами в консоли:

cd path/to/dirgit clone URL

После клонирования репозитория Вы автоматически переключитесь на нашу главную ветку (master). Так как каждый из нас занят определенной работой в проекте, то у каждого своя ветвь в репозитории, поэтому и Вам придется создвать свой branch. Делается это достаточно просто.

3. Создаем свою ветку. Для этого жмем правую кнопку мыши на директории в которую мы клонировали репозиторий и выбираем в меню «TortoiseGit — Create Branch«:

В открывшемся оке задаем название новой ветки и указываем на основании какой ветки репозитория мы будем создавать новую. Жмем «Ок», подтверждая создание ветки. Теперь переключаемся на свой новый branch.

Выбираем в меню «TortoiseGit — Switch/Checkout…«:

В открывшемся окне выбираем нашу новую ветку и жмем «Ок». Убеждаемся, что мы успешно переключились:

По сути, все что касалось создания нового branch’a в консоли решилось бы всего одной командой:

checkout -b new-branch

4. Программируем. Теперь, когда мы все настроили — открываем необходимый проект в Delphi, вносим свои коррективы, изменяем модули и т.д. Вобщем ведем нормальную плодотворную работу с проектом.

5. Вносим изменения в репозиторий. После того как внесены какие-то изменения нам необходимо их закрепить в Git. И здесь опять же проявляется отличие этой системы контроля версий от того же SVN. Дело в том, что Commit в Git не сбрасывается сразу на сервер. Для того, чтобы внести изменения в удаленный репозиторий используется команда PUSH. В общем виде работа может быть построена следующим образом:

1. Вносятся изменения в проект

2. Изменения закрепляюся в вашем локальном репозитории, используя команду Commit в меню или, используя консоль:

git commit

3. Когда Вам необходимо/удобно/требуется закрепить все изменения на сервере выполняем push в свою ветку (brunch). Команда консоли выглядит так:

git push origin <свое имя бранча>

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

Для этого выбираем новый файл, вызываем меню и выбираем «Add…»:

По рисунку можно видеть, что я вношу в индекс новый файл text.txt. Жмем «Ok».

После того как файл добавлен, можно сразу же сделать Commit — кнопка Commit появится в окне с выводом консоли. Жмем её и откроется окно для внесения Commit’a:

Заполняем поле с описанием, жмем «Ок»  и коммит готов. Если хотите сразу отправить эти изменения в репозиторий, то в окне с выводом консоли появится также кнопка PUSH. Если же Вас не устраивает таскать по 1 файлику туда-сюда или изменения столь незначительны, что их нет смысла отправлять на сервер, то просто продолжаете дальше кодить, а push выполним позднее.

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

1. Зажимаем Shift и вызываем контекстное меню. В меню должны появится дополнительные команды:

Выбираем команду Push. Перед Вами откроется окно следующего содержания:

Все, что от Вас требуется на данном этапе — нажать на кнопку (на рисунке она выделена красным) найти в списке удаленную ветку в которую вы делаете push и два раза нажать Ok. Все изменения, произведенные Вами в локальном репозитории отправятся в Сеть.

Вот пожалуй все, что мне пока потребовалось использовать при работе с новой для меня системой контроля версий. Надеюсь эта мини-шпаргалка поможет кому-нибудь кроме меня. А если Вас заинтересовала работа с консолью, то как раз сейчас я изучаю Вот такие топики на habrahabr.ru:1. Git Workflow.2. Git WizardryСтатьи написаны понятным простым языком и касаются как раз работы с Git с нуля.

Читайте также:

www.webdelphi.ru

8 советов для более эффективной работы с Git / Блог компании Softmart / Хабрахабр

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

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

Алиасы

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

Например, алиасы для команд checkout, commit и branch можно создать следующим образом:

git config --global alias.co checkout git config --global alias.ci commit git config --global alias.br branch

Теперь вместо git checkout master достаточно ввести git co master.

Также можно изменять и добавлять алиасы напрямую редактируя файл ~/.gitconfig:

[alias] co = checkout ci = commit br = branch

Скрытие (stashing) изменений до коммита

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

При помощи команды git stash можно временно отменить внесенные изменения, не удалив их окончательно:

$ git stash

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

Чтобы вернуть скрытую функциональность, достаточно ввести:

$ git stash pop

Если же скрытая функциональность больше не нужна, ее можно удалить с помощью:

$ git stash drop

Сравнение коммитов из командной строки

Быстрым и легким способом сравнения изменений между коммитами или версиями одного и того же файла является использование команды git diff.

Для сравнения состояний одного и того же файла между коммитами нужно ввести:

$ git diff $start_commit..$end_commit -- path/to/file

Для сравнения изменений между двумя коммитами:

$ git diff $start_commit..$end_commit

Эти команды выведут результат в текстовом виде прямо в окно терминала. Для более наглядного результата можно использовать git difftool. Данная команда запускает специальную программу для сравнения изменений. Одной из таких программ является Meld.

Для настройки Meld введите:

$ git config --global diff.tool git-meld

Теперь ее можно использовать:

$ git difftool $start_commit..$end_commit -- path/to/file # или $ git difftool $start_commit..$end_commit

Откат изменений

Иногда при работе над кодом становится понятно, что внесенные изменения оказались ненужными/неверными и их необходимо откатить. Вместо того, чтобы делать undo по каждому изменению, достаточно сделать reset файлов на HEAD-коммит ветки:

$ git reset --hard HEAD

Или, для одного конкретного файла:

$ git checkout HEAD -- path/to/file

Далее, если ненужные изменения уже были закоммичены, для их отката нужно ввести:

$ git reset --soft HEAD~1

Более эффективное использование Git blame

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

$ git blame -w # игнорировать знаки табуляции $ git blame -M # игнорировать перемещения текста $ git blame -C # игнорировать перемещения текста в другие файлы

Помимо описанных выше советов по работе с командами, существует несколько общих советов по работе с Git.

Делайте пулл часто

Если вы используете GitLab Workflow, значит вы работаете в ветках для выделенной функциональности (feature branches). Пока вы работаете над фичей в отдельной ветке, в мастер-ветке может произойти множество изменений, некоторые из которых могут конфликтовать с добавленными фичами.

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

Частые коммиты, редкие пуши

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

Пуш только после тестирования изменений

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

habrahabr.ru


Смотрите также