Документация Engee

LibGit2

Модуль LibGit2 предоставляет привязки к libgit2, переносимой библиотеке C, реализующей базовые возможности работы с системой управления версиями Git. В настоящее время эти привязки применяются для обеспечения работы диспетчера пакетов Julia. Данный модуль планируется в конечном итоге вынести в отдельный пакет.

Функциональность

При ознакомлении с данной документацией предполагается наличие базовых знаний API libgit2. Дополнительные сведения о некоторых упоминаемых в ней объектах и методах см. в общем справочнике по API libgit2.

# LibGit2.Buffer — Type

LibGit2.Buffer

Буфер для экспорта данных из libgit2. Соответствует структуре git_buf.

Типичное использование при получении данных из LibGit2 выглядит так:

buf_ref = Ref(Buffer())
@check ccall(..., (Ptr{Buffer},), buf_ref)
# операция с buf_ref
free(buf_ref)

В частности, обратите внимание, что затем для объекта Ref следует вызвать LibGit2.free.

# LibGit2.CheckoutOptions — Type

LibGit2.CheckoutOptions

Соответствует структуре git_checkout_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • checkout_strategy: определяет то, как разрешаются конфликты и следует ли принудительно извлекать либо заново создавать отсутствующие файлы.

  • disable_filters: если значение отлично от нуля, фильтры, например CLRF (для преобразования символов новой строки в файле между форматами UNIX и DOS), не применяются.

  • dir_mode: режим чтения, записи или доступа для всех каталогов, участвующих в извлечении. Значение по умолчанию — 0755.

  • file_mode: режим чтения, записи или доступа для всех файлов, участвующих в извлечении. Значение по умолчанию — 0755 или 0644 в зависимости от BLOB-объекта.

  • file_open_flags: битовые флаги, используемые для открытия файлов во время извлечения.

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

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

  • notify_payload полезные данные для функции обратного вызова уведомления.

  • progress_cb необязательная функция обратного вызова для отображения хода извлечения.

  • progress_payload полезные данные для обратного вызова хода выполнения.

  • paths если это поле не пустое, в нем указываются пути, по которым осуществляется поиск во время извлечения. Если оно пустое, извлекаются все файлы в репозитории.

  • baseline ожидаемое содержимое workdir, зафиксированное в (указателе на) GitTree. По умолчанию это состояние дерева в HEAD.

  • baseline_index ожидаемое содержимое workdir, зафиксированное в (указателе на) GitIndex. По умолчанию это состояние индекса в HEAD.

  • target_directory если это поле не пустое, извлечение происходит в этот каталог вместо workdir.

  • ancestor_label в случае конфликтов имя стороны общего предка.

  • our_label в случае конфликтов имя «этой» стороны.

  • their_label в случае конфликтов имя «той» стороны.

  • perfdata_cb необязательная функция обратного вызова для отображения данных по производительности.

  • perfdata_payload полезные данные для обратного вызова, возвращающего данные по производительности.

# LibGit2.CloneOptions — Type

LibGit2.CloneOptions

Соответствует структуре git_clone_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • checkout_opts параметры для выполнения извлечения удаленного репозитория в рамках клонирования.

  • fetch_opts параметры для получения удаленного репозитория перед извлечением в рамках клонирования.

  • bare если значение равно 0, удаленный репозиторий клонируется полностью. Если значение отлично от нуля, выполняется клонирование чистого репозитория, при котором локальная копия исходных файлов в репозитории отсутствует, а gitdir и workdir совпадают.

  • localclone флаг, указывающий, следует ли клонировать локальную объектную базу данных или выполнить получение. По умолчанию решение принимает Git. Для локального клона транспорт с поддержкой Git применяться не будет, но он будет использоваться для URL-адресов, начинающихся с file://.

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

  • repository_cb необязательный обратный вызов, который служит для создания нового репозитория, в который выполняется клонирование.

  • repository_cb_payload полезные данные для обратного вызова создания репозитория.

  • remote_cb необязательный обратный вызов, который служит для создания GitRemote перед созданием клона из него.

  • remote_cb_payload полезные данные для обратного вызова создания удаленного репозитория.

# LibGit2.DescribeOptions — Type

LibGit2.DescribeOptions

Соответствует структуре git_describe_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • max_candidates_tags: количество учитываемых последних тегов в refs/tags для описания фиксации. Значение по умолчанию — 10 (10 последних тегов проверяются на предмет того, описывают ли они фиксацию).

  • describe_strategy: учитываются ли все элементы в refs/tags (эквивалентно git-describe --tags) или все элементы в refs/ (эквивалентно git-describe --all). По умолчанию отображаются только аннотированные теги. Если передается Consts.DESCRIBE_TAGS, учитываются все теги, как аннотированные, так и не аннотированные. Если передается Consts.DESCRIBE_ALL, учитываются все ссылки в refs/.

  • pattern: указывает, что учитываются только теги, соответствующие pattern. Поддерживается расширение маски.

  • only_follow_first_parent: при определении расстояния от соответствующей ссылки до описанного объекта учитывается расстояние только от первого предка.

  • show_commit_oid_as_fallback: если не удается найти соответствующую ссылку, описывающую фиксацию, отображается GitHash фиксации вместо вызова ошибки (поведение по умолчанию).

# LibGit2.DescribeFormatOptions — Type

LibGit2.DescribeFormatOptions

Соответствует структуре git_describe_format_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • abbreviated_size: нижняя граница размера сокращенного GitHash; по умолчанию 7.

  • always_use_long_format: если задано значение 1, длинный формат для строк применяется даже в том случае, если можно использовать краткий.

  • dirty_suffix: значение добавляется в конец строки с описанием, если каталог workdir «грязный» (содержит черновые изменения).

# LibGit2.DiffDelta — Type

LibGit2.DiffDelta

Описание изменений, внесенных в одну запись. Соответствует структуре git_diff_delta.

Доступны следующие поля.

  • status одно из значений Consts.DELTA_STATUS, указывающее, был ли файл добавлен, изменен или удален.

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

  • similarity указывает, был ли файл переименован или скопирован.

  • nfiles количество файлов в дельте (например, если дельта выполнялась для идентификатора фиксации подмодуля, она может содержать более одного файла).

  • old_file файл DiffFile с информацией о файлах до внесения изменений.

  • new_file файл DiffFile с информацией о файлах после внесения изменений.

# LibGit2.DiffFile — Type

LibGit2.DiffFile

Описание одной стороны дельты. Соответствует структуре git_diff_file.

Доступны следующие поля.

  • id: GitHash элемента в сравнении. Если элемент пуст на этой стороне сравнения (например, в случае удаления файла), значением будет GitHash(0).

  • path: путь к элементу (с символом NULL в конце) относительно рабочего каталога репозитория.

  • size: размер элемента в байтах.

  • flags: сочетание флагов git_diff_flag_t . i-й бит этого целого числа задает i-й флаг.

  • mode: режим stat для элемента.

  • id_abbrev: имеется только в версиях LibGit2 не ниже 0.25.0. Длина поля id при преобразовании с помощью string. Обычно равна OID_HEXSZ (40).

# LibGit2.DiffOptionsStruct — Type

LibGit2.DiffOptionsStruct

Соответствует структуре git_diff_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • flags: флаги, определяющие то, какие файлы будут включены в сравнение. По умолчанию DIFF_NORMAL.

  • ignore_submodules: указывает, следует ли учитывать файлы в подмодулях. По умолчанию

используется значение SUBMODULE_IGNORE_UNSPECIFIED. Оно означает, что конфигурация подмодуля определяет, будет ли он включаться в сравнение.

  • pathspec: путь к файлам, включаемым в сравнение. По умолчанию используются все файлы в репозитории.

  • notify_cb: необязательный обратный вызов, уведомляющий пользователя об изменениях в сравнении по мере добавления в него дельт файлов.

  • progress_cb: необязательный обратный вызов, отображающий ход сравнения. Действует только в версиях libgit2 не ниже 0.24.0.

  • payload: полезные данные, передаваемые в notify_cb и progress_cb.

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

  • interhunk_lines: максимальное количество неизменившихся строк между двумя отдельными блоками изменений, по достижении которого блоки объединяются. По умолчанию 0.

  • id_abbrev: задает длину сокращенного GitHash для вывода. Значение по умолчанию — 7.

  • max_size: максимальный размер файла BLOB-объекта. Выше этой границы данные будут рассматриваться как двоичный BLOB-объект. Значение по умолчанию — 512 МБ.

  • old_prefix: виртуальный каталог, в который помещаются старые файлы с одной стороны сравнения. По умолчанию "a".

  • new_prefix: виртуальный каталог, в который помещаются новые файлы с одной стороны сравнения. По умолчанию "b".

# LibGit2.FetchHead — Type

LibGit2.FetchHead

Содержит информацию о HEAD во время получения, включая имя и URL-адрес ветви, из которой происходит получение, oid ветви HEAD и состояние локального слияния получаемой ветви HEAD.

Доступны следующие поля.

  • name имя головной ветви получения в локальной базе данных ссылок, например "refs/heads/master".

  • url URL-адрес головной ветви получения.

  • oid GitHash вершины головной ветви получения.

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

# LibGit2.FetchOptions — Type

LibGit2.FetchOptions

Соответствует структуре git_fetch_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • callbacks: удаленные обратные вызовы, используемые во время получения.

  • prune: следует ли выполнить отсечение после получения. По умолчанию используется настройка из GitConfig.

  • update_fetchhead: следует ли обновлять FetchHead после получения. По умолчанию обновление выполняется, что является стандартным поведением в Git.

  • download_tags: следует ли скачивать теги, имеющиеся в удаленном репозитории. По умолчанию запрашиваются теги для объектов, которые в любом случае скачиваются с сервера.

  • proxy_opts: параметры для подключения к удаленному репозиторию через прокси. См. описание ProxyOptions. Имеется только в версиях libgit2 не ниже 0.25.0.

  • custom_headers: дополнительные заголовки, необходимые для получения. Имеется только в версиях libgit2 не ниже 0.24.0.

# LibGit2.GitAnnotated — Type

GitAnnotated(repo::GitRepo, commit_id::GitHash)
GitAnnotated(repo::GitRepo, ref::GitReference)
GitAnnotated(repo::GitRepo, fh::FetchHead)
GitAnnotated(repo::GitRepo, committish::AbstractString)

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

# LibGit2.GitBlame — Type

GitBlame(repo::GitRepo, path::AbstractString; options::BlameOptions=BlameOptions())

Создает объект GitBlame для файла по пути path с использованием информации об изменениях из истории репозитория repo. В объекте GitBlame записывается информация о том, кто изменил те или иные блоки файла, когда и как. options определяет то, как разделяется содержимое файла и какие фиксации исследуются. Дополнительные сведения см. в описании BlameOptions.

# LibGit2.GitBlob — Type

GitBlob(repo::GitRepo, hash::AbstractGitHash)
GitBlob(repo::GitRepo, spec::AbstractString)

Возвращает объект GitBlob из репозитория repo, определяемого значениями hash и spec.

  • hash — это полный (GitHash) или частичный (GitShortHash) хэш.

  • spec — это текстовая спецификация: полный список см. в документации Git.

# LibGit2.GitCommit — Type

GitCommit(repo::GitRepo, hash::AbstractGitHash)
GitCommit(repo::GitRepo, spec::AbstractString)

Возвращает объект GitCommit из репозитория repo, определяемого значениями hash и spec.

  • hash — это полный (GitHash) или частичный (GitShortHash) хэш.

  • spec — это текстовая спецификация: полный список см. в документации Git.

# LibGit2.GitConfig — Type

GitConfig(path::AbstractString, level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_APP, force::Bool=false)

Создает новую конфигурацию GitConfig, загружая сведения из файла по пути path. Дополнительные сведения о параметрах level, repo и force см. в разделе, посвященном addfile.

GitConfig(repo::GitRepo)

Возвращает конфигурацию, сохраненную для репозитория Git repo. Если для репозитория repo файл конфигурации не задан, используется конфигурация Git по умолчанию.

GitConfig(level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_DEFAULT)

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

# LibGit2.GitHash — Type

GitHash

Идентификатор объекта Git на основе хэша SHA-1. Это строка длиной 20 байтов (40 шестнадцатеричных цифр), которая служит для идентификации GitObject в репозитории.

# LibGit2.GitObject — Type

GitObject(repo::GitRepo, hash::AbstractGitHash)
GitObject(repo::GitRepo, spec::AbstractString)

Возвращает указанный объект (GitCommit, GitBlob, GitTree или GitTag) из репозитория repo, определяемого значением hash или spec.

  • hash — это полный (GitHash) или частичный (GitShortHash) хэш.

  • spec — это текстовая спецификация: полный список см. в документации Git.

# LibGit2.GitRemote — Type

GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString) -> GitRemote

Выполняет поиск удаленного репозитория Git по имени и URL-адресу. Использует refspec получения по умолчанию.

Примеры

repo = LibGit2.init(repo_path)
remote = LibGit2.GitRemote(repo, "upstream", repo_url)
GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString, fetch_spec::AbstractString) -> GitRemote

Выполняет поиск удаленного репозитория Git по имени и URL-адресу с использованием спецификаций получения из удаленного репозитория (например, указывающих, из какой удаленной ветви следует выполнить получение).

Примеры

repo = LibGit2.init(repo_path)
refspec = "+refs/heads/mybranch:refs/remotes/origin/mybranch"
remote = LibGit2.GitRemote(repo, "upstream", repo_url, refspec)

# LibGit2.GitRemoteAnon — Function

GitRemoteAnon(repo::GitRepo, url::AbstractString) -> GitRemote

Выполняет поиск удаленного репозитория Git только по URL-адресу, но не по имени.

Примеры

repo = LibGit2.init(repo_path)
remote = LibGit2.GitRemoteAnon(repo, repo_url)

# LibGit2.GitRepo — Type

LibGit2.GitRepo(path::AbstractString)

Открывает репозиторий Git по пути path.

# LibGit2.GitRepoExt — Function

LibGit2.GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))

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

# LibGit2.GitRevWalker — Type

GitRevWalker(repo::GitRepo)

GitRevWalker выполняет обход редакций (фиксаций) репозитория Git repo. Это коллекция фиксаций в репозитории, поддерживающая итерацию и вызывающая LibGit2.map и LibGit2.count (например, с помощью LibGit2.count можно определить процент фиксаций в репозитории, созданных определенным автором).

cnt = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    LibGit2.count((oid,repo)->(oid == commit_oid1), walker, oid=commit_oid1, by=LibGit2.Consts.SORT_TIME)
end

В данном случае LibGit2.count определяет количество фиксаций вместе с обходом с определенным GitHash. Так как значение GitHash уникально для фиксации, cnt будет иметь значение 1.

# LibGit2.GitShortHash — Type

GitShortHash(hash::GitHash, len::Integer)

Сокращенный идентификатор объекта Git, который может использоваться для идентификации уникального объекта Git. Состоит из первых len шестнадцатеричных цифр hash (остальные цифры игнорируются).

# LibGit2.GitSignature — Type

LibGit2.GitSignature

Оболочка Julia для указателя на объект git_signature.

# LibGit2.GitStatus — Type

LibGit2.GitStatus(repo::GitRepo; status_opts=StatusOptions())

Собирает информацию о статусе каждого файла в репозитории Git repo (изменен ли файл, проиндексирован и т. д.). status_opts можно использовать для задания различных параметров, например, определяющих, следует ли принимать во внимание неотслеживаемые файлы или включать подмодули. Дополнительные сведения см. в описании метода StatusOptions.

# LibGit2.GitTag — Type

GitTag(repo::GitRepo, hash::AbstractGitHash)
GitTag(repo::GitRepo, spec::AbstractString)

Возвращает объект GitTag из репозитория repo, определяемого значениями hash и spec.

  • hash — это полный (GitHash) или частичный (GitShortHash) хэш.

  • spec — это текстовая спецификация: полный список см. в документации Git.

# LibGit2.GitTree — Type

GitTree(repo::GitRepo, hash::AbstractGitHash)
GitTree(repo::GitRepo, spec::AbstractString)

Возвращает объект GitTree из репозитория repo, определяемого значениями hash и spec.

  • hash — это полный (GitHash) или частичный (GitShortHash) хэш.

  • spec — это текстовая спецификация: полный список см. в документации Git.

# LibGit2.IndexEntry — Type

LibGit2.IndexEntry

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

# LibGit2.IndexTime — Type

LibGit2.IndexTime

Соответствует структуре git_index_time.

# LibGit2.BlameOptions — Type

LibGit2.BlameOptions

Соответствует структуре git_blame_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • flags: один из флагов Consts.BLAME_NORMAL или Consts.BLAME_FIRST_PARENT (другие флаги поиска неисправностей пока не реализованы в libgit2).

  • min_match_characters: минимальное количество буквенно-цифровых символов, которое должно измениться в фиксации, чтобы изменение было связано с ней. По умолчанию 20. Действует только при использовании одного из флагов Consts.BLAME_*_COPIES, которые еще не реализованы в libgit2.

  • newest_commit: GitHash последней фиксации, из которой необходимо анализировать изменения.

  • oldest_commit: GitHash самой старой фиксации, из которой необходимо анализировать изменения.

  • min_line: первая строка файла, с которой необходимо начать поиск неисправностей. По умолчанию используется 1.

  • max_line: первая строка файла, до которой необходимо производить поиск неисправностей. По умолчанию 0, что означает последнюю строку в файле.

# LibGit2.MergeOptions — Type

LibGit2.MergeOptions

Соответствует структуре git_merge_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • flags: enum для флагов, описывающих режим слияния. Определено в git_merge_flag_t. Соответствующее перечисление в Julia — GIT_MERGE. Оно имеет следующие значения.

    • MERGE_FIND_RENAMES: определяет, был ли файл переименован между общим предком и «этой» либо «той» стороной слияния. Позволяет осуществлять слияния с переименованием файлов.

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

    • MERGE_SKIP_REUC: расширение REUC не записывается в индекс, полученный в результате слияния.

    • MERGE_NO_RECURSIVE: если фиксации, слияние которых производится, имеют несколько баз слияния, используется первая из них вместо попытки рекурсивного слияния баз.

  • rename_threshold: насколько схожи должны быть два файла, чтобы один из них считался переименованием второго. Значением является целое число, задающее сходство в процентах. По умолчанию 50.

  • target_limit: максимальное количество файлов, сравниваемых при поиске переименований. По умолчанию 200.

  • metric: необязательная пользовательская функция, используемая для определения сходства двух файлов при обнаружении переименования.

  • recursion_limit: максимальное количество слияний общих предков при попытке создать новую виртуальную базу слияния. По умолчанию не ограничено. Это поле имеется только в версиях libgit2 выше 0.24.0.

  • default_driver: драйвер слияния, используемый в случае, если изменились обе стороны. Это поле имеется только в версиях libgit2 выше 0.25.0.

  • file_favor: способ обработки конфликтующего содержимого файлов для драйвера text.

    • MERGE_FILE_FAVOR_NORMAL: если на обеих сторонах слияния есть изменения в разделе, запись о конфликте заносится в индекс, который команда git checkout будет использовать для создания файла слияния. Пользователь затем может обратиться к этому файлу, чтобы разрешить конфликты. Используется по умолчанию.

    • MERGE_FILE_FAVOR_OURS: если на обеих сторонах слияния есть изменения в разделе, в индексе используется версия на «этой» стороне слияния.

    • MERGE_FILE_FAVOR_THEIRS: если на обеих сторонах слияния есть изменения в разделе, в индексе используется версия на «той» стороне слияния.

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

  • file_flags: указания для слияния файлов.

# LibGit2.ProxyOptions — Type

LibGit2.ProxyOptions

Параметры для подключения через прокси.

Соответствует структуре git_proxy_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • proxytype: enum для типа используемого прокси. Определено в git_proxy_t. Соответствующее перечисление в Julia — GIT_PROXY. Оно имеет следующие значения.

    • PROXY_NONE: попытка подключения через прокси-сервер не производится.

    • PROXY_AUTO: выполняется попытка определить конфигурацию прокси-сервера на основе конфигурации Git.

    • PROXY_SPECIFIED: подключение выполняется с использованием URL-адреса, указанного в поле url данной структуры.

    По умолчанию тип прокси-сервера определяется автоматически.

  • url: URL-адрес прокси.

  • credential_cb: указатель на функцию обратного вызова, которая будет вызвана, если для подключения к удаленному репозиторию требуется проверка подлинности.

  • certificate_cb: указатель на функцию обратного вызова, которая будет вызвана, если сертификат не пройдет проверку. Позволяет пользователю решить, следует ли продолжать подключение. При возврате функцией значения 1 подключение будет разрешено. Если она возвращает 0, подключение будет запрещено. Для возврата ошибок можно использовать отрицательное значение.

  • payload: полезные данные, передаваемые в две функции обратного вызова.

Примеры

julia> fo = LibGit2.FetchOptions(
           proxy_opts = LibGit2.ProxyOptions(url = Cstring("https://my_proxy_url.com")))

julia> fetch(remote, "master", options=fo)

# LibGit2.PushOptions — Type

LibGit2.PushOptions

Соответствует структуре git_push_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • parallelism: если должен быть создан файл пакета, эта переменная задает количество рабочих потоков, порождаемых packbuilder. Если задано значение 0, packbuilder автоматически задает количество используемых потоков. По умолчанию используется 1.

  • callbacks: обратные вызовы, используемые при отправке (например, для проверки подлинности в удаленном репозитории).

  • proxy_opts: действует только в том случае, если используется версия LibGit2 не ниже 0.25.0. Задает параметры использования прокси для связи с удаленным репозиторием. Дополнительные сведения см. в описании ProxyOptions .

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

# LibGit2.RebaseOperation — Type

LibGit2.RebaseOperation

Описывает одну инструкцию или операцию, которая должна быть выполнена во время перебазирования. Соответствует структуре git_rebase_operation.

Доступны следующие поля.

  • optype: тип выполняемой в настоящее время операции перебазирования. Возможные значения:

    • REBASE_OPERATION_PICK: копирует изменения фиксации.

    • REBASE_OPERATION_REWORD: копирует изменения фиксации, но перезаписывает ее сообщение через командную строку.

    • REBASE_OPERATION_EDIT: копирует изменения фиксации, но позволяет пользователю изменить содержимое фиксации и ее сообщение.

    • REBASE_OPERATION_SQUASH: выполняет слияние фиксации с предыдущей фиксацией со сжатием. Сообщения двух фиксаций объединяются.

    • REBASE_OPERATION_FIXUP: выполняет слияние фиксации с предыдущей фиксацией со сжатием. Используется только сообщение предыдущей фиксации.

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

  • id: GitHash фиксации, обрабатываемой на данном этапе перебазирования.

  • exec: при использовании REBASE_OPERATION_EXEC определяет команду, которая должна быть выполнена на данном этапе (например, запуск набора тестов после каждой фиксации).

# LibGit2.RebaseOptions — Type

LibGit2.RebaseOptions

Соответствует структуре git_rebase_options.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • quiet: сообщает другим клиентам Git, выполняющим перебазирование или участвующим в нем, о том, что перебазирование должно выполняться без уведомления. Служит для обеспечения совместимости. По умолчанию используется 1.

  • inmemory: запускает перебазирование в памяти. Вызывающие стороны, выполняющие перебазирование, могут пройти по его шагам и зафиксировать все изменения, но не могут вернуть назад ветвь HEAD или обновить репозиторий. Каталог workdir не изменяется. Имеется только в версиях libgit2 не ниже 0.24.0.

  • rewrite_notes_ref: имя ссылки на примечания, которыми будут перезаписаны примечания к фиксации после завершения перебазирования.

  • merge_opts: параметры слияния, определяющие то, как будет выполняться слияние деревьев на каждом этапе перебазирования. Имеется только в версиях libgit2 не ниже 0.24.0.

  • checkout_opts: параметры извлечения для записи файлов при инициализации перебазирования, его поэтапном выполнении и прерывании. Дополнительные сведения см. в описании метода CheckoutOptions.

# LibGit2.RemoteCallbacks — Type

LibGit2.RemoteCallbacks

Настройки обратного вызова. Соответствует структуре git_remote_callbacks.

# LibGit2.SignatureStruct — Type

LibGit2.SignatureStruct

Сигнатура действия (например, для создания фиксаций, добавления тегов и т. д.). Соответствует структуре git_signature.

Доступны следующие поля.

  • name полное имя пользователя, добавившего фиксацию, или ее автора.

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

  • when: структура TimeStruct, указывающая, когда фиксация была создана или добавлена в репозиторий.

# LibGit2.StatusEntry — Type

LibGit2.StatusEntry

Предоставляет различия между файлом в HEAD и в индексе, а также различия между индексом и рабочим каталогом. Соответствует структуре git_status_entry.

Доступны следующие поля.

  • status: содержит флаги состояния для файла, указывающие, является ли он актуальным или был каким-либо образом изменен в индексе или рабочем дереве.

  • head_to_index: указатель на объект DiffDelta, инкапсулирующий различия между файлом в ветви HEAD и в индексе.

  • index_to_workdir: указатель на объект DiffDelta, инкапсулирующий различия между файлом в индексе и в каталоге workdir.

# LibGit2.StatusOptions — Type

LibGit2.StatusOptions

Параметры, определяющие то, как git_status_foreach_ext() осуществляет обратные вызовы. Соответствует структуре git_status_opt_t.

Доступны следующие поля.

  • version: используемая версия структуры на случай ее изменения в будущем. В настоящее время всегда имеет значение 1.

  • show: флаг, определяющий то, какие файлы следует проанализировать и в каком порядке. По умолчанию используется Consts.STATUS_SHOW_INDEX_AND_WORKDIR.

  • flags: флаги для управления обратными вызовами, используемыми при вызове определения состояния.

  • pathspec: массив путей, используемых для сопоставления. Поведение сопоставления путей зависит от значений show и flags.

  • baseline — это дерево, используемое для сравнения с рабочим каталогом и индексом; по умолчанию HEAD.

# LibGit2.StrArrayStruct — Type

LibGit2.StrArrayStruct

Представление массива строк в формате LibGit2. Соответствует структуре git_strarray.

Типичное использование при получении данных из LibGit2 выглядит так:

sa_ref = Ref(StrArrayStruct())
@check ccall(..., (Ptr{StrArrayStruct},), sa_ref)
res = convert(Vector{String}, sa_ref[])
free(sa_ref)

В частности, обратите внимание, что затем для объекта Ref следует вызвать LibGit2.free.

В свою очередь, при передаче в LibGit2 вектора строк обычно проще использовать неявное преобразование:

strs = String[...]
@check ccall(..., (Ptr{StrArrayStruct},), strs)

Обратите внимание, что вызов free не требуется, так как данные размещаются в памяти средой Julia.

# LibGit2.TimeStruct — Type

LibGit2.TimeStruct

Время в сигнатуре. Соответствует структуре git_time.

# LibGit2.addfile — Function

addfile(cfg::GitConfig, path::AbstractString,
        level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_APP,
        repo::Union{GitRepo, Nothing} = nothing,
        force::Bool=false)

Добавляет существующий файл конфигурации Git, находящийся по пути path, в текущую конфигурацию GitConfig cfg. Если файла еще нет, он создается.

  • level задает уровень приоритета конфигурации Git, который определяется значением

Consts.GIT_CONFIG.

  • repo — это необязательный репозиторий, позволяющий анализировать условные операторы include.

  • Если force имеет значение false и уже есть конфигурация с указанным уровнем приоритета,

addfile выдает ошибку. Если force имеет значение true, существующая конфигурация заменяется конфигурацией из файла по пути path.

# LibGit2.add! — Function

add!(repo::GitRepo, files::AbstractString...; flags::Cuint = Consts.INDEX_ADD_DEFAULT)
add!(idx::GitIndex, files::AbstractString...; flags::Cuint = Consts.INDEX_ADD_DEFAULT)

Добавляет все файлы с путями, определяемыми параметром files, в индекс idx (или индекс репозитория repo). Если файл уже существует, запись в индексе обновляется. Если файла еще нет, он добавляется в индекс. files может содержать маски, которые будут развернуты для добавления соответствующих им файлов (если не задана переменная INDEX_ADD_DISABLE_PATHSPEC_MATCH, см. ниже). Если файл игнорируется (посредством .gitignore или конфигурации), он не будет добавлен, если только он уже не отслеживается в индексе. В этом случае он будет обновлен. Именованный аргумент flags представляет собой набор битовых флагов, контролирующих поведение в отношении игнорируемых файлов:

  • Consts.INDEX_ADD_DEFAULT — по умолчанию, как описано выше.

  • Consts.INDEX_ADD_FORCE — существующие правила игнорирования не учитываются; файл принудительно добавляется в индекс, даже если он уже игнорируется.

  • Consts.INDEX_ADD_CHECK_PATHSPEC — нельзя использовать вместе с INDEX_ADD_FORCE. Проверяет каждый файл на диске, указанный в files, на предмет включения в список игнорируемых. Если один из файлов игнорируется, функция возвращает EINVALIDSPEC.

  • Consts.INDEX_ADD_DISABLE_PATHSPEC_MATCH — сопоставление по маске отключается, и добавляются только файлы, в точности совпадающие с путями, указанными в files.

# LibGit2.add_fetch! — Function

add_fetch!(repo::GitRepo, rmt::GitRemote, fetch_spec::String)

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

Примеры

julia> LibGit2.add_fetch!(repo, remote, "upstream");

julia> LibGit2.fetch_refspecs(remote)
String["+refs/heads/*:refs/remotes/upstream/*"]

# LibGit2.add_push! — Function

add_push!(repo::GitRepo, rmt::GitRemote, push_spec::String)

Добавляет refspec отправки для указанного репозитория rmt. Эта спецификация refspec будет содержать информацию о том, в какие ветви следует выполнить отправку.

Примеры

julia> LibGit2.add_push!(repo, remote, "refs/heads/master");

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, branch);

julia> LibGit2.push_refspecs(remote)
String["refs/heads/master"]

Вам может потребоваться закрыть (close) и снова открыть соответствующий репозиторий GitRemote после обновления его спецификаций refspec отправки, чтобы изменение вступило в силу и вызовы push выполнялись.

# LibGit2.addblob! — Function

LibGit2.addblob!(repo::GitRepo, path::AbstractString)

Считывает файл по пути path и добавляет его в объектную базу данных репозитория repo в качестве свободного BLOB-объекта. Возвращает GitHash итогового BLOB-объекта.

Примеры

hash_str = string(commit_oid)
blob_file = joinpath(repo_path, ".git", "objects", hash_str[1:2], hash_str[3:end])
id = LibGit2.addblob!(repo, blob_file)

# LibGit2.author — Function

author(c::GitCommit)

Возвращает Signature автора фиксации c. Автор — это человек, внесший изменения в соответствующие файлы. См. также описание committer.

# LibGit2.authors — Function

authors(repo::GitRepo) -> Vector{Signature}

Возвращает всех авторов фиксаций в репозитории repo.

Примеры

repo = LibGit2.GitRepo(repo_path)
repo_file = open(joinpath(repo_path, test_file), "a")

println(repo_file, commit_msg)
flush(repo_file)
LibGit2.add!(repo, test_file)
sig = LibGit2.Signature("TEST", "TEST@TEST.COM", round(time(), 0), 0)
commit_oid1 = LibGit2.commit(repo, "commit1"; author=sig, committer=sig)
println(repo_file, randstring(10))
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid2 = LibGit2.commit(repo, "commit2"; author=sig, committer=sig)

# будет вектором [sig, sig]
auths = LibGit2.authors(repo)

# LibGit2.branch — Function

branch(repo::GitRepo)

Эквивалентно git branch. Создает новую ветвь на основе текущей ветви HEAD.

# LibGit2.branch! — Function

branch!(repo::GitRepo, branch_name::AbstractString, commit::AbstractString=""; kwargs...)

Извлекает новую ветвь Git в репозитории repo. commit — это GitHash в строковой форме, который будет служить началом новой ветви. Если commit — это пустая строка, используется текущая ветвь HEAD.

Именованные аргументы:

  • track::AbstractString="": имя удаленной ветви (если есть), которую должна отслеживать эта новая ветвь. При пустом значении (по умолчанию) удаленные ветви не отслеживаются.

  • force::Bool=false: при значении true создание ветви будет принудительным.

  • set_head::Bool=true: при значении true после создания ветви головной указатель ветви будет задан в качестве указателя HEAD репозитория repo.

Эквивалентно git checkout [-b|-B] <branch_name> [<commit>] [--track <track>].

Примеры

repo = LibGit2.GitRepo(repo_path)
LibGit2.branch!(repo, "new_branch", set_head=false)

# LibGit2.checkout! — Function

checkout!(repo::GitRepo, commit::AbstractString=""; force::Bool=true)

Эквивалентно git checkout [-f] --detach <commit>. Извлекает фиксацию Git commit (GitHash в строковой форме) в repo. Если параметр force равен true, извлечение производится принудительно с отменой всех текущих изменений. Обратите внимание, что при этом текущая ветвь HEAD отсоединяется.

Примеры

repo = LibGit2.GitRepo(repo_path)
open(joinpath(LibGit2.path(repo), "file1"), "w") do f
    write(f, "111
")
end
LibGit2.add!(repo, "file1")
commit_oid = LibGit2.commit(repo, "add file1")
open(joinpath(LibGit2.path(repo), "file1"), "w") do f
    write(f, "112
")
end
# если не задано force=true, произойдет сбой,
# так как в файле есть изменения
LibGit2.checkout!(repo, string(commit_oid), force=true)

# LibGit2.clone — Function

clone(repo_url::AbstractString, repo_path::AbstractString, clone_opts::CloneOptions)

Клонирует удаленный репозиторий по адресу repo_url (это может быть удаленный URL-адрес или путь в локальной файловой системе) в repo_path (это должен быть путь в локальной файловой системе). Параметры клонирования, например, определяющие, следует ли выполнить чистое клонирование, задаются в CloneOptions.

Примеры

repo_url = "https://github.com/JuliaLang/Example.jl"
repo = LibGit2.clone(repo_url, "/home/me/projects/Example")
clone(repo_url::AbstractString, repo_path::AbstractString; kwargs...)

Клонирует удаленный репозиторий, находящийся по адресу repo_url, в расположение repo_path в локальной файловой системе.

Именованные аргументы:

  • branch::AbstractString="": ветвь удаленного репозитория, которую следует клонировать, если она не является ветвью репозитория по умолчанию (обычно master).

  • isbare::Bool=false: при значении true удаленный репозиторий клонируется как чистый репозиторий, в результате чего каталогом Git становится repo_path, а не repo_path/.git. Это означает, что рабочее дерево извлечь нельзя. Играет роль аргумента CLI Git --bare.

  • remote_cb::Ptr{Cvoid}=C_NULL: обратный вызов, который служит для создания удаленного репозитория перед его клонированием. Если задано значение C_NULL (по умолчанию), попытка создать удаленный репозиторий не производится, так как считается, что он уже существует.

  • credentials::Creds=nothing: предоставляет учетные данные и (или) настройки при проверке подлинности в частном репозитории.

  • callbacks::Callbacks=Callbacks(): предоставленные пользователем обратные вызовы и полезные данные.

Эквивалентно git clone [-b <branch>] [--bare] <repo_url> <repo_path>.

Примеры

repo_url = "https://github.com/JuliaLang/Example.jl"
repo1 = LibGit2.clone(repo_url, "test_path")
repo2 = LibGit2.clone(repo_url, "test_path", isbare=true)
julia_url = "https://github.com/JuliaLang/julia"
julia_repo = LibGit2.clone(julia_url, "julia_path", branch="release-0.6")

# LibGit2.commit — Function

commit(repo::GitRepo, msg::AbstractString; kwargs...) -> GitHash

Оболочка для git_commit_create. Создает фиксацию в репозитории repo. msg — это сообщение фиксации. Возвращает OID новой фиксации.

Именованные аргументы:

  • refname::AbstractString=Consts.HEAD_FILE: если значение отлично от NULL, представляет имя ссылки, которую следует изменить так, чтобы она указывала на новую фиксацию. Например, при значении "HEAD" будет обновлена ссылка HEAD текущей ветви. Если ссылки еще нет, она будет создана.

  • author::Signature = Signature(repo) — это Signature с информацией о пользователе, создавшем фиксацию.

  • committer::Signature = Signature(repo) — это Signature с информацией о пользователе, отправившем фиксацию в репозиторий. Может не совпадать с author, например, если пользователь author отправил исправление по электронной почте пользователю committer, который зафиксировал его.

  • tree_id::GitHash = GitHash() — это дерево Git, которое следует использовать для создания фиксации, с указанием его предка и связи с остальной историей. Дерево tree должно относиться к репозиторию repo.

  • parent_ids::Vector{GitHash}=GitHash[] — это список фиксаций с GitHash, которые должны использоваться как родительские для новой фиксации. Он может быть пустым. Фиксация может иметь несколько родительских фиксаций, например, если это фиксация слияния.

LibGit2.commit(rb::GitRebase, sig::GitSignature)

Фиксирует текущее исправление в перебазировании rb с указанием разработчика фиксации sig. Если фиксация уже применена, ничего не происходит.

# LibGit2.committer — Function

committer(c::GitCommit)

Возвращает Signature разработчика фиксации c. Разработчик фиксации — это пользователь, зафиксировавший изменения, изначально созданные автором (author). Он может отличаться от author, например, если пользователь author отправил исправление по электронной почте пользователю committer, который зафиксировал его.

# LibGit2.count — Function

LibGit2.count(f::Function, walker::GitRevWalker; oid::GitHash=GitHash(), by::Cint=Consts.SORT_NONE, rev::Bool=false)

Используя GitRevWalker walker для «обхода» каждой фиксации в истории репозитория, определяет количество фиксаций, которые возвращают true при применении к ним f. Именованные аргументы: * oid хэш GitHash фиксации, с которой должен начинаться обход. По умолчанию используется push_head! и, следовательно, фиксация HEAD и все ее предки. * by метод сортировки. По умолчанию сортировка не производится. Другие варианты: сортировка по топологии (LibGit2.Consts.SORT_TOPOLOGICAL), по возрастанию времени (LibGit2.Consts.SORT_TIME, сначала самая старая фиксация) или по убыванию времени (LibGit2.Consts.SORT_REVERSE, сначала самая новая фиксация). * rev следует ли обратить порядок сортировки (например, при сортировке по топологии).

Примеры

cnt = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    LibGit2.count((oid, repo)->(oid == commit_oid1), walker, oid=commit_oid1, by=LibGit2.Consts.SORT_TIME)
end

LibGit2.count определяет количество фиксаций при обходе с определенным GitHash commit_oid1; обход начинается с данной фиксации и продвигается далее по времени. Так как значение GitHash уникально для фиксации, cnt будет иметь значение 1.

# LibGit2.counthunks — Function

counthunks(blame::GitBlame)

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

# LibGit2.create_branch — Function

LibGit2.create_branch(repo::GitRepo, bname::AbstractString, commit_obj::GitCommit; force::Bool=false)

Создает в репозитории repo новую ветвь с именем bname, указывающую на фиксацию commit_obj (которая должна входить в repo). При параметр force равен true, перезаписывает существующую ветвь с именем bname, если она существует. Если параметр force равен false и ветвь с именем bname уже существует, эта функция выдает ошибку.

# LibGit2.credentials_callback — Function

credential_callback(...) -> Cint

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

allowed_types содержит битовую маску значений LibGit2.Consts.GIT_CREDTYPE, указывающих, какие методы проверки подлинности будут применяться.

Проверка подлинности учетных данных осуществляется в следующем порядке (если соответствующие методы поддерживаются):

  • агент SSH;

  • пара из закрытого и открытого ключей SSH;

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

Если пользователю выводится запрос учетных данных, он может отменить запрос, введя ^D (удерживая клавишу CONTROL, нажать клавишу d).

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

Дополнительные сведения см. в руководстве LibGit2 по проверке подлинности на сервере.

# LibGit2.credentials_cb — Function

Указатель функции C для credentials_callback

# LibGit2.default_signature — Function

Возвращает объект сигнатуры. После использования подлежит освобождению.

# LibGit2.delete_branch — Function

LibGit2.delete_branch(branch::GitReference)

Удаляет ветвь, на которую указывает branch.

# LibGit2.diff_files — Function

diff_files(repo::GitRepo, branch1::AbstractString, branch2::AbstractString; kwarg...) -> Vector{AbstractString}

Показывает, какие файлы изменились в репозитории Git repo между ветвями branch1 и branch2.

Именованный аргумент:

  • filter::Set{Consts.DELTA_STATUS}=Set([Consts.DELTA_ADDED, Consts.DELTA_MODIFIED, Consts.DELTA_DELETED])), задает параметры для сравнения. По умолчанию выводятся добавленные, измененные или удаленные файлы.

Возвращает только имена изменившихся файлов, но не их содержимое.

Примеры

LibGit2.branch!(repo, "branch/a")
LibGit2.branch!(repo, "branch/b")
# добавляем файл в репозиторий
open(joinpath(LibGit2.path(repo),"file"),"w") do f
    write(f, "hello repo
")
end
LibGit2.add!(repo, "file")
LibGit2.commit(repo, "add file")
# возвращает ["file"]
filt = Set([LibGit2.Consts.DELTA_ADDED])
files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)
# возвращает [], так как существующие файлы не изменились
filt = Set([LibGit2.Consts.DELTA_MODIFIED])
files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)

Эквивалентно git diff --name-only --diff-filter=<filter> <branch1> <branch2>.

# LibGit2.entryid — Function

entryid(te::GitTreeEntry)

Возвращает GitHash объекта, на который ссылается te.

# LibGit2.entrytype — Function

entrytype(te::GitTreeEntry)

Возвращает тип объекта, на который ссылается te. Результатом будет один из типов, возвращаемых objtype, например GitTree или GitBlob.

# LibGit2.fetch — Function

fetch(rmt::GitRemote, refspecs; options::FetchOptions=FetchOptions(), msg="")

Выполняет получение из указанного удаленного репозитория Git rmt, используя refspecs для определения удаленных ветвей, которые следует получить. Именованные аргументы:

  • options: определяет параметры получения, например, следует ли выполнить отсечение после него. Дополнительные сведения см. в описании FetchOptions.

  • msg: сообщение для вставки в журналы ссылок.

fetch(repo::GitRepo; kwargs...)

Получает обновления из репозитория, являющегося вышестоящим для repo.

Именованные аргументы:

  • remote::AbstractString="origin": из какой удаленной ветви репозитория repo, указанной по имени, следует выполнить получение. При пустом значении URL-адрес используется для создания анонимной удаленной ветви.

  • remoteurl::AbstractString="": URL-адрес репозитория remote. Если значение не указано, оно выводится исходя из указанного имени репозитория remote.

  • refspecs=AbstractString[]: определяет свойства получения.

  • credentials=nothing: предоставляет учетные данные и (или) настройки при проверке подлинности в частном репозитории remote.

  • callbacks=Callbacks(): предоставленные пользователем обратные вызовы и полезные данные.

Эквивалентно git fetch [<remoteurl>|<repo>] [<refspecs>].

# LibGit2.fetchheads — Function

fetchheads(repo::GitRepo) -> Vector{FetchHead}

Возвращает список всех головных указателей получения для repo, каждый из которых представлен как FetchHead, включая имя, URL-адрес и состояние слияния.

Примеры

julia> fetch_heads = LibGit2.fetchheads(repo);

julia> fetch_heads[1].name
"refs/heads/master"

julia> fetch_heads[1].ismerge
true

julia> fetch_heads[2].name
"refs/heads/test_branch"

julia> fetch_heads[2].ismerge
false

# LibGit2.fetch_refspecs — Function

fetch_refspecs(rmt::GitRemote) -> Vector{String}

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

Примеры

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.add_fetch!(repo, remote, "upstream");

julia> LibGit2.fetch_refspecs(remote)
String["+refs/heads/*:refs/remotes/upstream/*"]

# LibGit2.fetchhead_foreach_cb — Function

Указатель функции C для fetchhead_foreach_callback

# LibGit2.merge_base — Function

merge_base(repo::GitRepo, one::AbstractString, two::AbstractString) -> GitHash

Определяет базу слияния (общего предка) для фиксаций one и two. one и two могут быть в строковом формате. Возвращает GitHash базы слияния.

# LibGit2.merge! — Method

merge!(repo::GitRepo; kwargs...) -> Bool

Выполняет слияние Git для репозитория repo со слиянием фиксаций с отличающейся историей с текущей ветвью. Возвращает true. если слияние прошло успешно, или false в противном случае.

Именованные аргументы:

  • committish::AbstractString="" слияние именованных фиксаций в committish.

  • branch::AbstractString="" слияние ветви branch и всех ее фиксаций с момента расхождения с текущей ветвью.

  • fastforward::Bool=false если fastforward имеет значение true, слияние выполняется только в том случае, если оно неявное (головной указатель текущей ветви является предком фиксаций, подлежащих слиянию); в противном случае слияние не производится, и возвращается значение false. Эквивалентно параметру CLI Git --ff-only.

  • merge_opts::MergeOptions=MergeOptions() merge_opts задает параметры слияния, например стратегию слияния в случае конфликтов.

  • checkout_opts::CheckoutOptions=CheckoutOptions() checkout_opts задает параметры для этапа извлечения.

Эквивалентно git merge [--ff-only] [<committish> | <branch>].

При указании branch следует использовать формат ссылки, так как строка будет преобразована в GitReference. Например, чтобы выполнить слияние ветви branch_a, необходимо вызвать merge!(repo, branch="refs/heads/branch_a").

# LibGit2.merge! — Method

merge!(repo::GitRepo, anns::Vector{GitAnnotated}; kwargs...) -> Bool

Выполняет слияние изменений из аннотированных фиксаций (зарегистрированных как объекты GitAnnotated) anns с ветвью HEAD репозитория repo. Именованные аргументы:

  • merge_opts::MergeOptions = MergeOptions(): параметры, определяющие способ слияния, например, разрешено ли неявное слияние. Дополнительные сведения см. в описании MergeOptions .

  • checkout_opts::CheckoutOptions = CheckoutOptions(): параметры, определяющие способ извлечения. Дополнительные сведения см. в описании метода CheckoutOptions.

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

Примеры

upst_ann = LibGit2.GitAnnotated(repo, "branch/a")

# слияние ветви
LibGit2.merge!(repo, [upst_ann])

# LibGit2.merge! — Method

merge!(repo::GitRepo, anns::Vector{GitAnnotated}, fastforward::Bool; kwargs...) -> Bool

Выполняет слияние изменений из аннотированных фиксаций (зарегистрированных как объекты GitAnnotated) anns с ветвью HEAD репозитория repo. Если fastforward имеет значение true, допустимо только неявное (fast-forward) слияние. В данном случае при возникновении конфликтов слияние не выполнится. В противном случае, если fastforward имеет значение false, в результате слияния может быть получен файл с конфликтами, которые пользователь должен будет устранить.

Именованные аргументы:

  • merge_opts::MergeOptions = MergeOptions(): параметры, определяющие способ слияния, например, разрешено ли неявное слияние. Дополнительные сведения см. в описании MergeOptions .

  • checkout_opts::CheckoutOptions = CheckoutOptions(): параметры, определяющие способ извлечения. Дополнительные сведения см. в описании метода CheckoutOptions.

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

Примеры

upst_ann_1 = LibGit2.GitAnnotated(repo, "branch/a")

# неявное слияние ветви
LibGit2.merge!(repo, [upst_ann_1], true)

# слияние конфликтов!
upst_ann_2 = LibGit2.GitAnnotated(repo, "branch/b")
# попытка слияния ветви в неявном режиме
LibGit2.merge!(repo, [upst_ann_2], true) # возвращает false
LibGit2.merge!(repo, [upst_ann_2], false) # возвращает true

# LibGit2.ffmerge! — Function

ffmerge!(repo::GitRepo, ann::GitAnnotated)

Выполняет неявное слияние изменений с текущей ветвью HEAD. Возможно, только если фиксация, на которую указывает ann, произошла от текущей ветви HEAD (например, при вытягивании изменений из удаленной ветви, которая опережает вершину локальной ветви).

# LibGit2.fullname — Function

LibGit2.fullname(ref::GitReference)

Возвращает имя ссылки, на которую указывает символьная ссылка ref. Если ref не является символьной ссылкой, возвращает пустую строку.

# LibGit2.features — Function

features()

Возвращает список функций Git, поддерживаемых текущей версией libgit2, таких как многопоточность или использование протоколов HTTPS и SSH.

# LibGit2.filename — Function

filename(te::GitTreeEntry)

Возвращает имя файла объекта на диске, на который ссылается te.

# LibGit2.filemode — Function

filemode(te::GitTreeEntry) -> Cint

Возвращает режимный код файла UNIX для объекта на диске, на который ссылается te, в виде целого числа.

# LibGit2.gitdir — Function

LibGit2.gitdir(repo::GitRepo)

Возвращает расположение файлов Git для репозитория repo:

 — для обычных репозиториев это расположение папки .git;  — для чистых репозиториев это расположение самого репозитория.

См. также описание workdir и path.

# LibGit2.git_url — Function

LibGit2.git_url(; kwargs...) -> String

Создает строку на основе предоставленных компонентов URL-адреса. Если именованный аргумент scheme не указан, URL-адрес будет создан с использованием альтернативного синтаксиса наподобие scp.

Ключевые слова

  • scheme::AbstractString="": схема URL-адреса, определяющая используемый протокол. Для HTTP используйте http, для SSH — ssh и т. д. Если аргумент scheme не указан, используется формат выходных данных ssh, но с синтаксисом наподобие scp.

  • username::AbstractString="": имя пользователя, которое должно использоваться в выходных данных (если указано).

  • password::AbstractString="": пароль, который должен использоваться в выходных данных (если указан).

  • host::AbstractString="": имя хоста, которое должно использоваться в выходных данных. Имя хоста должно быть указано.

  • port::Union{AbstractString,Integer}="": номер порта, который должен использоваться в выходных данных, если указан. Нельзя указать при использовании синтаксиса наподобие scp.

  • path::AbstractString="": путь, который должен использоваться в выходных данных (если указан).

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

Примеры

julia> LibGit2.git_url(username="git", host="github.com", path="JuliaLang/julia.git")
"git@github.com:JuliaLang/julia.git"

julia> LibGit2.git_url(scheme="https", host="github.com", path="/JuliaLang/julia.git")
"https://github.com/JuliaLang/julia.git"

julia> LibGit2.git_url(scheme="ssh", username="git", host="github.com", port=2222, path="JuliaLang/julia.git")
"ssh://git@github.com:2222/JuliaLang/julia.git"

# LibGit2.@githash_str — Macro

@githash_str -> AbstractGitHash

Создает объект хэша Git на основе указанной строки, возвращая GitShortHash, если строка короче 40 шестнадцатеричных цифр, или GitHash в противном случае.

Примеры

julia> LibGit2.githash"d114feb74ce633"
GitShortHash("d114feb74ce633")

julia> LibGit2.githash"d114feb74ce63307afe878a5228ad014e0289a85"
GitHash("d114feb74ce63307afe878a5228ad014e0289a85")

# LibGit2.head — Function

LibGit2.head(repo::GitRepo) -> GitReference

Возвращает ссылку GitReference на текущую ветвь HEAD репозитория repo.

head(pkg::AbstractString) -> String

Возвращает GitHash текущей ветви HEAD репозитория pkg в виде строки.

# LibGit2.head! — Function

LibGit2.head!(repo::GitRepo, ref::GitReference) -> GitReference

Задает в качестве ветви HEAD репозитория repo объект, на который указывает ref.

# LibGit2.head_oid — Function

LibGit2.head_oid(repo::GitRepo) -> GitHash

Выполняет поиск идентификатора объекта текущей ветви HEAD для Git repo.

# LibGit2.headname — Function

LibGit2.headname(repo::GitRepo)

Выполняет поиск имени текущей ветви HEAD для Git repo. Если репозиторий repo в настоящее время отсоединен, возвращает имя ветви HEAD, от которой он отсоединен.

# LibGit2.init — Function

LibGit2.init(path::AbstractString, bare::Bool=false) -> GitRepo

Открывает новый репозиторий Git по пути path. Если bare имеет значение false, рабочее дерево будет создано в path/.git. Если bare имеет значение true, рабочий каталог не создается.

# LibGit2.is_ancestor_of — Function

is_ancestor_of(a::AbstractString, b::AbstractString, repo::GitRepo) -> Bool

Возвращает true, если a (GitHash в строковом формате) является предком b (GitHash в строковом формате).

Примеры

julia> repo = GitRepo(repo_path);

julia> LibGit2.add!(repo, test_file1);

julia> commit_oid1 = LibGit2.commit(repo, "commit1");

julia> LibGit2.add!(repo, test_file2);

julia> commit_oid2 = LibGit2.commit(repo, "commit2");

julia> LibGit2.is_ancestor_of(string(commit_oid1), string(commit_oid2), repo)
true

# LibGit2.isbinary — Function

isbinary(blob::GitBlob) -> Bool

Использует эвристику для определения того, является ли файл двоичным: ищет NULL-байты и приемлемое соотношение печатаемых и непечатаемых символов среди первых 8000 байтов.

# LibGit2.iscommit — Function

iscommit(id::AbstractString, repo::GitRepo) -> Bool

Проверяет, находится ли фиксация id (GitHash в строковом формате) в репозитории.

Примеры

julia> repo = GitRepo(repo_path);

julia> LibGit2.add!(repo, test_file);

julia> commit_oid = LibGit2.commit(repo, "add test_file");

julia> LibGit2.iscommit(string(commit_oid), repo)
true

# LibGit2.isdiff — Function

LibGit2.isdiff(repo::GitRepo, treeish::AbstractString, pathspecs::AbstractString=""; cached::Bool=false)

Проверяет, имеются ли различия между деревом, указанным в treeish, и отслеживаемыми файлами в рабочем дереве (если cached=false) или индексе (если cached=true). pathspecs — это спецификации параметров для сравнения.

Примеры

repo = LibGit2.GitRepo(repo_path)
LibGit2.isdiff(repo, "HEAD") # должно быть false
open(joinpath(repo_path, new_file), "a") do f
    println(f, "here's my cool new file")
end
LibGit2.isdiff(repo, "HEAD") # теперь true

Эквивалентно git diff-index <treeish> [-- <pathspecs>].

# LibGit2.isdirty — Function

LibGit2.isdirty(repo::GitRepo, pathspecs::AbstractString=""; cached::Bool=false) -> Bool

Проверяет, были ли внесены изменения в отслеживаемые файлы в рабочем дереве (если cached=false) или индексе (если cached=true). pathspecs — это спецификации параметров для сравнения.

Примеры

repo = LibGit2.GitRepo(repo_path)
LibGit2.isdirty(repo) # должно быть false
open(joinpath(repo_path, new_file), "a") do f
    println(f, "here's my cool new file")
end
LibGit2.isdirty(repo) # теперь true
LibGit2.isdirty(repo, new_file) # теперь true

Эквивалентно git diff-index HEAD [-- <pathspecs>].

# LibGit2.isorphan — Function

LibGit2.isorphan(repo::GitRepo)

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

# LibGit2.isset — Function

isset(val::Integer, flag::Integer)

Проверяет, заданы ли (1) биты значения val, индексируемого по flag, или не заданы (0).

# LibGit2.iszero — Function

iszero(id::GitHash) -> Bool

Определяет, являются ли все шестнадцатеричные цифры данного хэша GitHash нулями.

# LibGit2.lookup_branch — Function

lookup_branch(repo::GitRepo, branch_name::AbstractString, remote::Bool=false) -> Union{GitReference, Nothing}

Определяет, существует ли ветвь, указанная в branch_name, в репозитории repo. Если remote имеет значение true, repo считается удаленным репозиторием Git. В противном случае он находится в локальной файловой системе.

Возвращает либо ссылку GitReference на запрошенную ветвь, если она существует, либо nothing в противном случае.

# LibGit2.map — Function

LibGit2.map(f::Function, walker::GitRevWalker; oid::GitHash=GitHash(), range::AbstractString="", by::Cint=Consts.SORT_NONE, rev::Bool=false)

Используя GitRevWalker walker для «обхода» каждой фиксации в истории репозитория, применяет f к каждой фиксации. Именованные аргументы: * oid хэш GitHash фиксации, с которой должен начинаться обход. По умолчанию используется push_head! и, следовательно, фиксация HEAD и все ее предки. * range диапазон хэшей GitHash в формате oid1..oid2. f будет применяться ко всем фиксациям между границами диапазона. * by метод сортировки. По умолчанию сортировка не производится. Другие варианты: сортировка по топологии (LibGit2.Consts.SORT_TOPOLOGICAL), по возрастанию времени (LibGit2.Consts.SORT_TIME, сначала самая старая фиксация) или по убыванию времени (LibGit2.Consts.SORT_REVERSE, сначала самая новая фиксация). * rev следует ли обратить порядок сортировки (например, при сортировке по топологии).

Примеры

oids = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    LibGit2.map((oid, repo)->string(oid), walker, by=LibGit2.Consts.SORT_TIME)
end

В данном случае LibGit2.map обращается к каждой фиксации с помощью GitRevWalker и определяет ее GitHash.

# LibGit2.mirror_callback — Function

Функция обратного вызова для зеркалирования

Задает спецификации refspec +refs/:refs/ и флаг mirror для удаленной ссылки.

# LibGit2.mirror_cb — Function

Указатель функции C для mirror_callback

# LibGit2.message — Function

message(c::GitCommit, raw::Bool=false)

Возвращает сообщение фиксации, описывающее изменения, внесенные в фиксации c. При raw имеет значение false, возвращает немного «очищенное» сообщение (без начальных символов начала строки). Если raw имеет значение true, такие символы начальной строки из сообщения не удаляются.

# LibGit2.merge_analysis — Function

merge_analysis(repo::GitRepo, anns::Vector{GitAnnotated}) -> analysis, preference

Проводит анализ ветвей, на которые указывают вершины аннотированных ветвей anns, и определяют, при каких условиях можно выполнить их слияние. Например, если anns[1] — это просто предок ann[2], merge_analysis сообщит, что возможно неявное слияние.

Возвращает два результата: analysis и preference. У analysis несколько возможных значений: * MERGE_ANALYSIS_NONE: выполнить слияние элементов anns невозможно. * MERGE_ANALYSIS_NORMAL: обычное слияние, когда и ветвь HEAD, и фиксации, слияние которых хочет выполнить пользователь, разошлись с общим предком. В этом случае необходимо разрешить изменения и возможны конфликты. * MERGE_ANALYSIS_UP_TO_DATE: все входные фиксации, слияние которых хочет выполнить пользователь, достижимы из ветви HEAD, поэтому слияние не требуется. * MERGE_ANALYSIS_FASTFORWARD: входная фиксация является потомком ветви HEAD, поэтому слияние не требуется. Вместо этого пользователь может просто извлечь входные фиксации. * MERGE_ANALYSIS_UNBORN: ветвь HEAD репозитория ссылается на несуществующую фиксацию. Выполнить слияние входных фиксаций невозможно, но их можно извлечь. У preference также несколько возможных значений: * MERGE_PREFERENCE_NONE: у пользователя нет предпочтений. * MERGE_PREFERENCE_NO_FASTFORWARD: неявные слияния запрещены. * MERGE_PREFERENCE_FASTFORWARD_ONLY: разрешено только неявное слияние (во избежание конфликтов). preference можно контролировать посредством репозитория или глобальной конфигурации Git.

# LibGit2.name — Function

LibGit2.name(ref::GitReference)

Возвращает полное имя ref.

name(rmt::GitRemote)

Возвращает имя удаленного репозитория, например "origin". Если удаленный репозиторий анонимный (см. GitRemoteAnon), именем будет пустая строка "".

Примеры

julia> repo_url = "https://github.com/JuliaLang/Example.jl";

julia> repo = LibGit2.clone(cache_repo, "test_directory");

julia> remote = LibGit2.GitRemote(repo, "origin", repo_url);

julia> name(remote)
"origin"
LibGit2.name(tag::GitTag)

Имя тега tag (например, "v0.5").

# LibGit2.need_update — Function

need_update(repo::GitRepo)

Эквивалентно git update-index. Возвращает true. если репозиторий repo требует обновления.

# LibGit2.objtype — Function

objtype(obj_type::Consts.OBJECT)

Возвращает тип, соответствующий значению перечисления.

# LibGit2.path — Function

LibGit2.path(repo::GitRepo)

Возвращает путь к базовому файлу репозитория repo.

 — для обычных репозиториев это обычно родительский каталог каталога .git (он может отличаться от рабочего каталога; дополнительные сведения см. в описании workdir ).  — для чистых репозиториев это расположение файлов Git.

См. также описание gitdir и workdir.

# LibGit2.peel — Function

peel([T,] ref::GitReference)

Рекурсивно очищает ref, пока не будет получен объект типа T. Если аргумент T не указан, ref будет очищаться до тех пор, пока не будет получен объект, отличный от GitTag.

  • Объект GitTag будет очищен до объекта, на который он ссылается.

  • Объект GitCommit будет очищен до GitTree.

!!! Примечание До объектов GitTag могут очищаться только аннотированные теги. Легковесные теги (по умолчанию) —  это ссылки в refs/tags/, которые указывают непосредственно на объекты GitCommit.

peel([T,] obj::GitObject)

Рекурсивно очищает obj, пока не будет получен объект типа T. Если аргумент T не указан, obj будет очищаться до тех пор, пока тип не изменится.

  • Объект GitTag будет очищен до объекта, на который он ссылается.

  • Объект GitCommit будет очищен до GitTree.

# LibGit2.posixpath — Function

LibGit2.posixpath(path)

Стандартизирует строку пути path для использования разделителей POSIX.

# LibGit2.push — Function

push(rmt::GitRemote, refspecs; force::Bool=false, options::PushOptions=PushOptions())

Выполняет отправку в указанный удаленный репозиторий Git rmt, используя refspecs для определения удаленных ветвей, в которые следует выполнить отправку. Именованные аргументы:

  • force: если задано значение true, отправка производится принудительно без учета конфликтов.

  • options: определяет параметры отправки, например используемые заголовки прокси. Дополнительные сведения см. в описании PushOptions.

Добавить информацию о спецификациях refspec отправки можно двумя другими способами: задав параметр в GitConfig репозитория (с ключом push.default) или вызвав add_push!. В противном случае потребуется явным образом указать refspec отправки в вызове push, чтобы он подействовал, например так: LibGit2.push(repo, refspecs=["refs/heads/master"]).

 
push(repo::GitRepo; kwargs...)

Отправляет обновления в репозиторий, являющийся вышестоящим для repo.

Именованные аргументы:

  • remote::AbstractString="origin": имя вышестоящего удаленного репозитория, в который должна быть выполнена отправка.

  • remoteurl::AbstractString="": URL-адрес репозитория remote.

  • refspecs=AbstractString[]: определяет свойства отправки.

  • force::Bool=false: определяет, будет ли отправка принудительной с перезаписью удаленной ветви.

  • credentials=nothing: предоставляет учетные данные и (или) настройки при проверке подлинности в частном репозитории remote.

  • callbacks=Callbacks(): предоставленные пользователем обратные вызовы и полезные данные.

Эквивалентно git push [<remoteurl>|<repo>] [<refspecs>].

# LibGit2.push! — Method

LibGit2.push!(w::GitRevWalker, cid::GitHash)

Запускает GitRevWalker walker с фиксации cid. Эту функцию можно использовать для применения функции ко всем фиксациям с определенного года, передав первую фиксацию за этот год в cid, а затем передав полученное значение w в LibGit2.map.

# LibGit2.push_head! — Function

LibGit2.push_head!(w::GitRevWalker)

Отправляет фиксацию HEAD и ее предков в GitRevWalker w. Таким образом гарантируется, что во время обхода не будет пропущена ветвь HEAD и ее предки.

# LibGit2.push_refspecs — Function

push_refspecs(rmt::GitRemote) -> Vector{String}

Возвращает спецификации refspec отправки для указанного репозитория rmt. Эти спецификации refspec содержат информацию о том, в какие ветви следует выполнить отправку.

Примеры

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.add_push!(repo, remote, "refs/heads/master");

julia> close(remote);

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.push_refspecs(remote)
String["refs/heads/master"]

# LibGit2.raw — Function

raw(id::GitHash) -> Vector{UInt8}

Получает необработанные байты GitHash в виде вектора длиной 20.

# LibGit2.read_tree! — Function

LibGit2.read_tree!(idx::GitIndex, tree::GitTree)
LibGit2.read_tree!(idx::GitIndex, treehash::AbstractGitHash)

Считывает дерево tree (или дерево, на которое указывает treehash, в репозитории, принадлежащем idx) в индекс idx. Текущее содержимое индекса заменяется.

# LibGit2.rebase! — Function

LibGit2.rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractString="")

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

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

git rebase --merge [<upstream>]
if [ -d ".git/rebase-merge" ]; then
    git rebase --abort
fi

# LibGit2.ref_list — Function

LibGit2.ref_list(repo::GitRepo) -> Vector{String}

Возвращает список всех имен ссылок в репозитории repo.

# LibGit2.reftype — Function

LibGit2.reftype(ref::GitReference) -> Cint

Возвращает Cint, соответствующий типу ref:

  • 0, если ссылка недопустима;

  • 1, если ссылка представляет собой идентификатор объекта;

  • 2, если ссылка является символьной.

# LibGit2.remotes — Function

LibGit2.remotes(repo::GitRepo)

Возвращает вектор имен удаленных репозиториев repo.

# LibGit2.remove! — Function

remove!(repo::GitRepo, files::AbstractString...)
remove!(idx::GitIndex, files::AbstractString...)

Удаляет все файлы с путями, определяемыми параметром files, в индексе idx (или индексе репозитория repo).

# LibGit2.reset — Function

reset(val::Integer, flag::Integer)

Восстанавливает значение 0 для заданных битов значения val, индексируемого по flag.

# LibGit2.reset! — Function

reset!(payload, [config]) -> CredentialPayload

Восстанавливает исходное состояние объекта payload, чтобы его можно было снова использовать в обратном вызове учетных данных. Если указан аргумент config, конфигурация также будет обновлена.

Обновляет некоторые записи, определяемые аргументом pathspecs, в индексе из целевого дерева фиксаций.

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

git reset [] [--] ...

reset!(repo::GitRepo, id::GitHash, mode::Cint=Consts.RESET_MIXED)

Восстанавливает состояние репозитория repo на момент id с использованием одного из трех режимов, который задается аргументом mode:

  1. Consts.RESET_SOFT — HEAD перемещается на id.

  2. Consts.RESET_MIXED — режим по умолчанию; HEAD перемещается на id, и индекс сбрасывается в состояние id.

  3. Consts.RESET_HARD — HEAD перемещается на id, индекс сбрасывается в состояние id, а все рабочие изменения отменяются.

Примеры

# получаем изменения
LibGit2.fetch(repo)
isfile(joinpath(repo_path, our_file)) # будет false

# неявное слияние изменений
LibGit2.merge!(repo, fastforward=true)

# так как в локальной системе файла не было, но есть
# удаленный файл, необходимо сбросить ветвь
head_oid = LibGit2.head_oid(repo)
new_head = LibGit2.reset!(repo, head_oid, LibGit2.Consts.RESET_HARD)

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

Эквивалентно git reset [--soft | --mixed | --hard] <id>.

Примеры

repo = LibGit2.GitRepo(repo_path)
head_oid = LibGit2.head_oid(repo)
open(joinpath(repo_path, "file1"), "w") do f
    write(f, "111
")
end
LibGit2.add!(repo, "file1")
mode = LibGit2.Consts.RESET_HARD
# изменения в файле file1 и его индексация
# будут отменены
new_head = LibGit2.reset!(repo, head_oid, mode)

# LibGit2.restore — Function

restore(s::State, repo::GitRepo)

Возвращает репозиторий repo в предыдущее состояние (State) s, например HEAD ветви перед попыткой слияния. s можно сгенерировать с помощью функции snapshot.

# LibGit2.revcount — Function

LibGit2.revcount(repo::GitRepo, commit1::AbstractString, commit2::AbstractString)

Возвращает количество редакций между commit1 и commit2 (идентификаторов OID выходов фиксаций в строковом формате). Так как commit1 и commit2 могут относиться к разным ветвям, revcount перечисляет (и подсчитывает) редакции «слева направо», возвращая кортеж значений Int — количество фиксаций слева и справа соответственно. Является ли фиксация левой или правой, зависит от того, с какой стороны симметричного различия в дереве она доступна.

Эквивалентно git rev-list --left-right --count <commit1> <commit2>.

Примеры

repo = LibGit2.GitRepo(repo_path)
repo_file = open(joinpath(repo_path, test_file), "a")
println(repo_file, "hello world")
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid1 = LibGit2.commit(repo, "commit 1")
println(repo_file, "hello world again")
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid2 = LibGit2.commit(repo, "commit 2")
LibGit2.revcount(repo, string(commit_oid1), string(commit_oid2))

Возвращает (-1, 0).

# LibGit2.set_remote_url — Function

set_remote_url(repo::GitRepo, remote_name, url)
set_remote_url(repo::String, remote_name, url)

Задает url получения и отправки для remote_name объекта GitRepo или репозитория Git, находящегося по пути path. Обычно в качестве имени удаленного репозитория Git используется "origin".

Примеры

repo_path = joinpath(tempdir(), "Example")
repo = LibGit2.init(repo_path)
LibGit2.set_remote_url(repo, "upstream", "https://github.com/JuliaLang/Example.jl")
LibGit2.set_remote_url(repo_path, "upstream2", "https://github.com/JuliaLang/Example2.jl")

# LibGit2.shortname — Function

LibGit2.shortname(ref::GitReference)

Возвращает сокращенную версию имени ref, удобную для восприятия человеком.

julia> repo = GitRepo(path_to_repo);

julia> branch_ref = LibGit2.head(repo);

julia> LibGit2.name(branch_ref)
"refs/heads/master"

julia> LibGit2.shortname(branch_ref)
"master"

# LibGit2.snapshot — Function

snapshot(repo::GitRepo) -> State

Делает снимок текущего состояния репозитория repo, сохраняя текущую ветвь HEAD, индекс и все незафиксированные изменения. Результат State можно использовать позднее в вызове restore для возврата репозитория в сохраненное состояние.

# LibGit2.split_cfg_entry — Function

LibGit2.split_cfg_entry(ce::LibGit2.ConfigEntry) -> Tuple{String,String,String,String}

Разделяет ConfigEntry на следующие части: раздел, подраздел, имя и значение.

Примеры

Для файла конфигурации Git со следующим содержимым:

[credential "https://example.com"]
    username = me

ConfigEntry будет выглядеть следующим образом:

julia> entry
ConfigEntry("credential.https://example.com.username", "me")

julia> LibGit2.split_cfg_entry(entry)
("credential", "https://example.com", "username", "me")

Дополнительные сведения см. в документации по синтаксису конфигурации Git.

# LibGit2.status — Function

LibGit2.status(repo::GitRepo, path::String) -> Union{Cuint, Cvoid}

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

# LibGit2.stage — Function

stage(ie::IndexEntry) -> Cint

Возвращает номер этапа ie. Номер этапа 0 представляет текущее состояние рабочего дерева, но в случае конфликта слияния можно использовать и другие номера. В таком случае различные номера этапов в IndexEntry описывают то, к каким сторонам конфликта относится текущее состояние файла. Этап 0 — это состояние перед попыткой слияния, этап 1 — это изменения, внесенные локально, а этапы 2 и далее предназначены для изменений из других ветвей (например, этапы 2, 3 и 4 могут использоваться в случае слияния нескольких ветвей методом «осьминога»).

# LibGit2.tag_create — Function

LibGit2.tag_create(repo::GitRepo, tag::AbstractString, commit; kwargs...)

Создает новый тег Git tag (например, "v0.5") в репозитории repo для фиксации commit.

Именованные аргументы:

  • msg::AbstractString="": сообщение для тега.

  • force::Bool=false: при значении true существующие ссылки перезаписываются.

  • sig::Signature=Signature(repo): подпись добавляющего тег.

# LibGit2.tag_delete — Function

LibGit2.tag_delete(repo::GitRepo, tag::AbstractString)

Удаляет тег Git tag из репозитория repo.

# LibGit2.tag_list — Function

LibGit2.tag_list(repo::GitRepo) -> Vector{String}

Возвращает список всех тегов в репозитории Git repo.

# LibGit2.target — Function

LibGit2.target(tag::GitTag)

GitHash целевого объекта tag.

# LibGit2.toggle — Function

toggle(val::Integer, flag::Integer)

Обращает биты значения val, индексируемого по flag, так что если бит был равен 0, он станет равен 1, и наоборот.

# LibGit2.transact — Function

transact(f::Function, repo::GitRepo)

Применяет функцию f к репозиторию Git repo, делая снимок (snapshot) перед применением f. Если в f происходит ошибка, repo возвращается в сохраненное состояние с помощью restore. Произошедшая ошибка будет вызвана повторно, но состояние repo не будет повреждено.

# LibGit2.treewalk — Function

treewalk(f, tree::GitTree, post::Bool=false)

Обходит элементы в дереве tree и его поддеревьях в обратном или прямом порядке. При прямом порядке обход начинается с корня, продолжается в самом левом поддереве, а затем рекурсивно вниз от его самых левых поддеревьев к правым, после чего движется вправо через поддеревья. При обратном порядке обход начинается с самого низа левого поддерева в направлении вверх, затем продолжается в поддереве справа от него (снова от самого низа) и заканчивается в корне дерева.

Параметр функции f должен иметь следующую сигнатуру:

(String, GitTreeEntry) -> Cint

Если f возвращает отрицательное значение, обход дерева заканчивается. Положительное значение означает, что элемент будет пропущен, если post имеет значение false.

# LibGit2.upstream — Function

upstream(ref::GitReference) -> Union{GitReference, Nothing}

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

Возвращает либо ссылку GitReference на вышестоящую ветвь, если она существует, либо nothing, если у запрошенной ветви нет соответствующей вышестоящей ветви.

# LibGit2.update! — Function

update!(repo::GitRepo, files::AbstractString...)
update!(idx::GitIndex, files::AbstractString...)

Обновляет все файлы с путями, определяемыми параметром files, в индексе idx (или индексе репозитория repo). Сопоставляет состояние каждого файла в индексе с текущим состоянием на диске, удаляя файл, если он был удален на диске, или обновляя его запись в объектной базе данных.

# LibGit2.url — Function

url(rmt::GitRemote)

Возвращает URL-адрес получения для удаленного репозитория Git.

Примеры

julia> repo_url = "https://github.com/JuliaLang/Example.jl";

julia> repo = LibGit2.init(mktempdir());

julia> remote = LibGit2.GitRemote(repo, "origin", repo_url);

julia> LibGit2.url(remote)
"https://github.com/JuliaLang/Example.jl"

# LibGit2.version — Function

version() -> VersionNumber

Возвращает используемую версию libgit2 в виде VersionNumber.

# LibGit2.with — Function

with(f::Function, obj)

Вспомогательная функция для управления ресурсами. Применяет функцию f к obj, вызывая close для obj после того, как f успешно возвращает управление или выдает ошибку. Обеспечивает высвобождение выделенных Git ресурсов, когда они больше не нужны.

# LibGit2.with_warn — Function

with_warn(f::Function, ::Type{T}, args...)

Вспомогательная функция для управления ресурсами. Применяет функцию f к args, сначала создавая экземпляр типа T на основе args. Вызывает close для полученного объекта после того, как f успешно возвращает управление или выдает ошибку. Обеспечивает высвобождение выделенных Git ресурсов, когда они больше не нужны. Если f выдает ошибку, выводится соответствующее предупреждение.

# LibGit2.workdir — Function

LibGit2.workdir(repo::GitRepo)

Возвращает расположение рабочего каталога repo. Для чистых репозиториев выдает ошибку.

Обычно это родительский каталог gitdir(repo), но в ряде случаев расположение может быть иным, например, если задана переменная конфигурации core.worktree или переменная среды GIT_WORK_TREE.

См. также описание gitdir и path.

# LibGit2.GitObject — Method

(::Type{T})(te::GitTreeEntry) where T<:GitObject

Получает объект Git, на который ссылается te, и возвращает его фактический тип (выводимый функцией entrytype), например GitBlob или GitTag.

Примеры

tree = LibGit2.GitTree(repo, "HEAD^{tree}")
tree_entry = tree[1]
blob = LibGit2.GitBlob(tree_entry)

# LibGit2.UserPasswordCredential — Type

Учетные данные, поддерживающие только параметры user и password

# LibGit2.SSHCredential — Type

Тип учетных данных SSH

# LibGit2.isfilled — Function

isfilled(cred::AbstractCredential) -> Bool

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

# LibGit2.CachedCredentials — Type

Кэширует информацию об учетных данных для повторного использования

# LibGit2.CredentialPayload — Type

LibGit2.CredentialPayload

Сохраняет состояние при совершении нескольких обратных вызовов получения учетных данных для одного и того же URL-адреса. Предполагается, что экземпляр CredentialPayload сбрасывается посредством reset! при использовании с другим URL-адресом.

# LibGit2.approve — Function

approve(payload::CredentialPayload; shred::Bool=true) -> Nothing

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

Именованный аргумент shred определяет то, должна ли уничтожаться конфиденциальная информация в поле учетных данных. Значение false должно задаваться только во время тестирования.

# LibGit2.reject — Function

reject(payload::CredentialPayload; shred::Bool=true) -> Nothing

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

Именованный аргумент shred определяет то, должна ли уничтожаться конфиденциальная информация в поле учетных данных. Значение false должно задаваться только во время тестирования.

# LibGit2.Consts.GIT_CONFIG — Type

Уровень приоритета файла конфигурации.

Эти уровни приоритета соответствуют естественной логике определения степени важности (от самой высокой к самой низкой) при поиске элементов конфигурации в Git.

  • CONFIG_LEVEL_DEFAULT — открываются глобальные файлы конфигурации, файлы XDG и системные файлы, если они есть.

  • CONFIG_LEVEL_PROGRAMDATA — действует на уровне системы в Windows, обеспечивая совместимость с переносимой системой Git.

  • CONFIG_LEVEL_SYSTEM — файл конфигурации на уровне системы; /etc/gitconfig в системах Linux.

  • CONFIG_LEVEL_XDG — файл конфигурации, совместимый с XDG; обычно ~/.config/git/config.

  • CONFIG_LEVEL_GLOBAL — пользовательский файл конфигурации (также называется глобальным); обычно ~/.gitconfig.

  • CONFIG_LEVEL_LOCAL — файл конфигурации на уровне репозитория; $WORK_DIR/.git/config для репозиториев, не являющихся чистыми.

  • CONFIG_LEVEL_APP — файл конфигурации на уровне приложения; свободно определяется самим приложением.

  • CONFIG_HIGHEST_LEVEL — представляет файл конфигурации самого высокого уровня из доступных (то есть наиболее специфичный файл, который и будет загружен).