AnyMath 文档

LibGit2

LibGit2模块提供绑定到https://libgit2.org/[libgit2]，一个可移植的c库，为https://git-scm.com/[Git]版本控制系统。 这些绑定目前用于支持Julia的包管理器。 预计该模块最终将被移入一个单独的包中。

功能

本文档的一些内容假定您事先了解libgit2API。 有关此处引用的某些对象和方法的更多信息，请参阅上游https://libgit2.org/libgit2/#v1.0.0[libgit2API参考]。

LibGit2.Buffer

用于从libgit2导出数据的数据缓冲区。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_buf[脧锚脧赂`git_buf`]结构。

从LibGit2获取数据时，典型的用法如下所示:

buf_ref = Ref(Buffer())
@check ccall(..., (Ptr{Buffer},), buf_ref)
# operation on buf_ref
free(buf_ref)

特别要注意的是 LibGit2.免费 应在 参考书 对象。

LibGit2.CheckoutOptions

匹配的https://libgit2.org/libgit2/#HEAD/type/git_checkout_options[脧锚脧赂`git_checkout_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * checkout_策略：确定如何处理冲突以及是否强制签出/重新创建丢失的文件。 * 禁用过滤器：如果非零，不要应用像CLRF这样的过滤器（在UNIX和DOS之间转换文件换行符）。 * dir_mode：检出中涉及的任何目录的读/写/访问模式。 默认值为 0755. * 文件_mode：检出中涉及的任何文件的读/写/访问模式。 默认值为 0755 或 0644，取决于blob。 * 文件_open_flags：用于在签出期间打开任何文件的bitflags。 * 通知书_flags：应该通知用户什么样的冲突的标志。 * 通知书_cb：一个可选的回调函数，用于在发生签出冲突时通知用户。 如果此函数返回非零值，则签出将被取消。 * 通知/通知：Notify回调函数的有效负载。 * 进展_cb：一个可选的回调函数，用于显示结账进度。 * 进度/进度：进度回调的有效载荷。 * 路径:如果不为空，则说明在结账时要搜索哪些路径。 如果为空，则检出将发生在存储库中的所有文件上。 * 基线：预期的内容 n.工作,工作，捕获在a（指向a的指针）中 吉特里. 默认为HEAD树的状态。 * baseline_index：预期的内容 n.工作,工作，捕获在a（指向a的指针）中 GitIndex,GitIndex. 默认为HEAD处索引的状态。 * 目标_目标：如果不是空的，签出到这个目录，而不是 n.工作,工作. * n.祖先,祖先：在冲突的情况下，共同祖先方的名称。 * 我们的_label：在冲突的情况下，"我们"一方的名称。 * 他们的标签：在冲突的情况下，"他们"一方的名称。 * [医]配药：一个可选的回调函数，用于显示性能数据。 * [医]全负荷：性能回调的有效负载。

LibGit2.CloneOptions

匹配的https://libgit2.org/libgit2/#HEAD/type/git_clone_options[脧锚脧赂`git_clone_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 签出_opts：作为克隆的一部分执行远程签出的选项。 * fetch_opts：作为克隆的一部分执行远程签出前提取的选项。 * 光秃秃的：如果 0，克隆完整的远程存储库。 如果非零，则执行裸克隆，其中存储库中没有源文件的本地副本，并且 吉特迪尔和 n.工作,工作都是一样的。 * 本地克隆:标志是克隆本地对象数据库还是执行fetch。 默认是让git决定。 它不会将git感知传输用于本地克隆，而是将其用于以 档案://. * 签出-支：要结帐的分支的名称。 如果为空字符串，则将检出远程的默认分支。 * 重新定位_cb：一个可选的回调，用于创建克隆的_new_存储库。 * 重新定位_cb_payload：存储库回调的有效负载。 * 远程_cb：一个可选的回调，用于创建 [医吉特雷莫特]在从中制作克隆之前。 * 远程_cb_payload：远程回调的有效负载。

LibGit2.DescribeOptions

匹配的https://libgit2.org/libgit2/#HEAD/type/git_describe_options[脧锚脧赂`git_describe_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * max_candidates_tags：考虑这许多最近的标签在 裁判/标签 描述一个提交。 默认值为10（以便检查最近的10个标签以查看它们是否描述了提交）。 * 描述策略：是否考虑所有参赛作品 裁判/标签 （相当于 git-描述-标签)或所有参赛作品 裁判/ （相当于 git-描述-所有). 默认值是只显示带注释的标签。 如果 缺点。描述/描述 被传递，所有标签，注释或不，将被考虑。 如果 缺点。描述_ALL 通过，任何ref 裁判/ 将被考虑。 * 模式：只考虑匹配的标签 模式. 支持glob扩展。 * 只有_follow_first_parent：当查找匹配引用到所描述对象的距离时，只考虑与第一个父级的距离。 * show_commit_oid_as_fallback：如果找不到描述提交的匹配引用，请显示提交的 吉斯卡什而不是抛出错误（默认行为）。

LibGit2.DescribeFormatOptions

匹配的https://libgit2.org/libgit2/#HEAD/type/git_describe_format_options[脧锚脧赂`git_describe_format_options`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 缩写_大小：缩写大小的下界 吉斯卡什 使用，默认使用 7. * always_use_long_format：设置为 1 为字符串使用长格式，即使可以使用短格式。 * 肮脏的,肮脏的：如果设置，这将被附加到描述字符串的末尾，如果 n.工作,工作是脏的。

LibGit2.DiffDelta

一个条目的更改说明。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_diff_delta[脧锚脧赂`git_diff_delta`]结构。

字段代表:

* 状况：其中一个 缺点。DELTA_STATUS，表示文件是否已添加/修改/删除。 * 旗帜：三角旗和每边的对象。 确定是否将文件视为二进制/文本，它们是否存在于差异的每一侧，以及已知对象id是否正确。 * 相似度：用于指示文件是否已重命名或复制。 * nfiles/nfiles：增量中的文件数（例如，如果增量是在子模块提交id上运行的，则它可能包含多个文件）。 * 旧文件：A 扩散文件包含有关更改前文件的信息。 * 新文件：A 扩散文件包含有关更改后的文件的信息。

LibGit2.DiffFile

三角洲的一侧的描述。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_diff_file[脧锚脧赂`git_diff_file`]结构。

字段代表:

* 身份证： 吉斯卡什 差异中的项目。 如果项在差异的这一侧为空（例如，如果差异是删除文件），则这将是 吉斯卡什(0). * 路径：a NULL 相对于存储库的工作目录的项的终止路径。 * 大小：项目的大小，以字节为单位。 * 旗帜：组合的https://libgit2.org/libgit2/#HEAD/type/git_diff_flag_t[脧锚脧赂`git_diff_flag_t`旗帜。 该 i该整数的th位设置 i国旗。 * 模式： 统计资料项目的模式。 * id_abbrev：仅存在于LibGit2版本更新或等于 0.25.0. 的长度 身份证 字段转换时使用 字符串. 通常等于 OID_HEXSZ (40).

LibGit2.DiffOptionsStruct

匹配的https://libgit2.org/libgit2/#HEAD/type/git_diff_options[脧锚脧赂`git_diff_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 旗帜：控制哪些文件将出现在差异中的标志。 默认值为 N.正常,正常. * ignore_submodules：是否查看子模块中的文件。 默认值为 SUBMODULE_IGNORE_UNSPECIFIED，这意味着子模块的配置将控制它是否出现在diff中。 * 路径规格:要包含在差异中的文件的路径。 默认是使用存储库中的所有文件。 * 通知书_cb:可选回调，当文件增量被添加到diff时，它将通知用户对diff的更改。 * 进展_cb：可选回调，将显示差异进度。 仅适用于libgit2版本，至少与0.24.0一样新。 * 有效载荷：要传递到的有效载荷 通知书_cb 和 进展_cb. * 上下文_线:用于定义大块边的_unchanged_行数。 这也是在大块之前/之后显示的行数，以提供上下文。 默认值为3。 * 联线/联线:在合并两个单独的大块头之前允许的最大_unchanged_行数_between_。 默认值为0。 * id_abbrev：设置缩写的长度 吉斯卡什来打印。 默认值为 7. * 最大尺寸：blob的最大文件大小。 高于此大小，它将被视为二进制blob。 默认值为512MB。 * 旧的修复：将旧文件放在差异一侧的虚拟文件目录。 默认值为 "一个". * new_prefix：将新文件放置在差异一侧的虚拟文件目录。 默认值为 "b".

LibGit2.FetchHead

包含在获取过程中有关HEAD的信息，包括从中获取的分支的名称和URL、HEAD的oid以及获取的HEAD是否已在本地合并。

字段代表:

* 姓名：取头本地引用数据库中的名称，例如, "裁判/头/主". * 网址：获取头的URL。 * oid： xref:stdlib/LibGit2.adoc#LibGit2.GitHash[吉斯卡什 取头的尖端。 * 伊斯默日：布尔标志，指示远程更改是否已合并到本地副本中。 如果 真的，本地副本与远程获取头是最新的。

LibGit2.FetchOptions

匹配的https://libgit2.org/libgit2/#HEAD/type/git_fetch_options[脧锚脧赂`git_fetch_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 回调:远程回调以在读取过程中使用。 * 修剪/修剪：是否在提取后执行修剪。 默认是使用从设置 [医]吉特康菲格. * update_fetchhead：是否更新 鹿FetchHead 取完后。 默认是执行更新，这是正常的git行为。 * 下载*标签：是否下载标签存在于远程或不。 默认值是为正在从服务器下载的对象请求标记。 * 代理_opts：通过代理连接到远程的选项。 见 xref:stdlib/LibGit2.adoc#LibGit2.ProxyOptions[代理操作. 仅存在于libgit2版本更新或等于0.25.0。 * 自定义装载机：获取所需的任何额外标题。 仅存在于libgit2版本更新或等于0.24.0。

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

带注释的git提交带有有关如何查找以及原因的信息，以便rebase或merge操作具有有关提交上下文的更多信息。 例如，冲突文件包含有关合并中发生冲突的源/目标分支的信息。 带注释的提交可以引用远程分支的尖端，例如当 鹿FetchHead被传递，或到使用描述的分支头 [医]GitReference.

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

构建一个 [医]吉布兰姆 文件的对象 路径，使用从 回购协议. 该 [医]吉布兰姆 对象记录谁在何时以及如何更改文件的块。 选项 控制如何分离文件的内容以及提交到probe-see的内容 [医引言]了解更多信息。

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

返回a 吉特布洛布 对象来自 回购协议 指定的 哈希/规格.

* 哈希 是一个完整的（吉斯卡什）或部分（GitShortHash）哈希。 * 规格 是一个文本规范：见https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions[git文档]获取完整列表。

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

返回a GitCommit,GitCommit 对象来自 回购协议 指定的 哈希/规格.

* 哈希 是一个完整的（吉斯卡什）或部分（GitShortHash）哈希。 * 规格 是一个文本规范：见https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions[git文档]获取完整列表。

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

创建一个新的 [医]吉特康菲格 通过从文件中加载配置信息 路径. 见 添加文件有关 水平, 回购协议 和 警队 选择。

GitConfig(repo::GitRepo)

获取git存储库的存储配置 回购协议. 如果 回购协议 没有设置特定的配置文件，将使用默认的git配置。

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

通过将全局和系统配置文件加载到优先级配置中来获取默认git配置。 这可用于访问特定git存储库之外的默认配置选项。

GitHash

基于sha-1哈希的git对象标识符。 它是一个20字节的字符串（40个十六进制数字），用于标识一个 Git对象 存储库中。

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

返回指定的对象(GitCommit,GitCommit, 吉特布洛布, 吉特里或 吉塔格)从 回购协议 指定的 哈希/规格.

* 哈希 是一个完整的（吉斯卡什）或部分（GitShortHash）哈希。 * 规格 是一个文本规范：见https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions[git文档]获取完整列表。

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

使用其名称和URL查找远程git存储库。 使用默认的fetch 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

使用存储库的名称和URL查找远程git存储库，以及如何从远程获取的规范（例如从哪个远程分支获取）。

*例子*

repo = LibGit2.init(repo_path)
refspec = "+refs/heads/mybranch:refs/remotes/origin/mybranch"
remote = LibGit2.GitRemote(repo, "upstream", repo_url, refspec)
GitRemoteAnon(repo::GitRepo, url::AbstractString) -> GitRemote

只使用其URL而不是其名称查找远程git存储库。

*例子*

repo = LibGit2.init(repo_path)
remote = LibGit2.GitRemoteAnon(repo, repo_url)
LibGit2.GitRepo(path::AbstractString)

在以下位置打开git存储库 路径.

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

在以下位置打开git存储库 路径 使用扩展控件（例如，如果当前用户必须是要读取的特殊访问组的成员 路径).

GitRevWalker(repo::GitRepo)

A 吉特雷瓦尔克 通过git存储库的_revisions_（即提交） 回购协议. 它是存储库中提交的集合，支持迭代和调用 LibGit2.地图和 LibGit2.计数（例如, LibGit2.计数 可用于确定某个作者在存储库中提交的百分比）。

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.计数 找到沿着步行的提交数 吉斯卡什. 自 吉斯卡什 对于提交来说是唯一的, cnt 将是 1.

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

一个缩短的git对象标识符，当git对象是唯一的时，它可以用来标识它，由初始的 伦 十六进制数字 哈希 （其余数字将被忽略）。

LibGit2.GitSignature

这是一个围绕一个指针的Julia包装器https://libgit2.org/libgit2/#HEAD/type/git_signature[脧锚脧赂`git_签名`]对象。

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

收集有关git存储库中每个文件状态的信息 回购协议 （例如文件是否被修改，暂存等。). 状态-状态 可用于设置各种选项，例如是否查看未跟踪的文件或是否包含子模块。 见 状态选择了解更多信息。

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

返回a 吉塔格 对象来自 回购协议 指定的 哈希/规格.

* 哈希 是一个完整的（吉斯卡什）或部分（GitShortHash）哈希。 * 规格 是一个文本规范：见https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions[git文档]获取完整列表。

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

返回a 吉特里 对象来自 回购协议 指定的 哈希/规格.

* 哈希 是一个完整的（吉斯卡什）或部分（GitShortHash）哈希。 * 规格 是一个文本规范：见https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions[git文档]获取完整列表。

LibGit2.IndexEntry

索引中的文件条目的内存中表示。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_index_entry[脧锚脧赂`git_index_入口`]结构。

LibGit2.IndexTime

匹配的https://libgit2.org/libgit2/#HEAD/type/git_index_time[脧锚脧赂`git_index_时间`]结构。

LibGit2.BlameOptions

匹配的https://libgit2.org/libgit2/#HEAD/type/git_blame_options[脧锚脧赂`git_blame_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 旗帜：其中一个 缺点。正常人,正常人 或 缺点。BLAME_FIRST_PARENT （其他blame标志尚未由libgit2实现）。 * min_match_字符:在提交中更改的_alphanumeric_字符的最小数量，以便将更改与该提交关联。 默认值为20。 只有在 缺点。BLAME_*_COPIES 使用了标志，libgit2还没有实现。 * 新闻通讯： 吉斯卡什查看更改的最新提交。 * 旧的，旧的： 吉斯卡什查看更改的最古老的提交。 * 最小线：文件的第一行，从中开始指责。 默认值为 1. * 最大线：归咎于文件的最后一行。 默认值为 0，表示文件的最后一行。

LibGit2.MergeOptions

匹配的https://libgit2.org/libgit2/#HEAD/type/git_merge_options[脧锚脧赂`git_merge_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 旗帜：安 枚举 用于描述合并行为的标志。 定义于https://github.com/libgit2/libgit2/blob/HEAD/include/git2/merge.h#L95[脧锚脧赂`git_merge_flag_t`]. 对应的Julia枚举是 吉特*默格 并具有价值: ** MERGE_FIND_RENAMES：检测一个文件是否在合并的共同祖先和"我们的"或"他们的"一侧之间被重命名。 允许文件重命名的合并。 ** MERGE_FAIL_ON_CONFLICT：立即退出，如果发现冲突，而不是试图解决它。 ** 合并_SKIP_REUC：不要在合并产生的索引上写入REUC扩展。 ** 合并_NO_回复：如果正在合并的提交有多个合并基，请使用第一个，而不是尝试递归合并基。 * 重命名-重命名：如何相似的两个文件必须考虑一个重命名另一个。 这是一个设置百分比相似度的整数。 默认值为50。 * 目标-目标：要与之比较以查找重命名的文件的最大数量。 默认值为200。 * 米制：可选的自定义函数，用于确定两个文件之间的相似性以进行重命名检测。 * 递归_limit：共同祖先执行的合并次数上限，以尝试为合并构建新的虚拟合并基础。 默认值为无限制。 此字段仅存在于比0.24.0更新的libgit2版本上。 * default_driver：合并驱动程序使用，如果双方都改变了。 此字段仅存在于比0.25.0更新的libgit2版本上。 * n.文件,文件：如何处理冲突的文件内容 文本 司机。 ** MERGE_FILE_FAVOR_正常：如果合并的双方都对某个部分进行了更改，请记下索引中的冲突。 git签出 将用于创建一个合并文件，然后用户可以引用该文件来解决冲突。 这是默认设置。 ** MERGE_FILE_FAVOR_OURS：如果合并的双方都对某个部分进行了更改，请在索引中使用合并的"我们的"一侧的版本。 ** MERGE_FILE_FAVOR_THEIRS：如果合并的双方都对某个部分进行了更改，请在索引中使用合并的"他们的"一侧的版本。 ** 合并_FILE_FAVOR_UNION：如果合并的两边都对一个部分进行了更改，请在放入索引的文件中包含两边的每个唯一行。 * 文件_flags：合并文件的准则。

LibGit2.ProxyOptions

通过代理连接的选项。

匹配的https://libgit2.org/libgit2/#HEAD/type/git_proxy_options[脧锚脧赂`git_proxy_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 代理类型：安 枚举 供代理的类型使用。 定义于https://libgit2.org/libgit2/#HEAD/type/git_proxy_t[脧锚脧赂`git_proxy_t`]. 对应的Julia枚举是 GIT_PROXY 并具有价值: ** 代理_NONE：不要尝试通过代理连接。 ** 代理,代理：尝试从git配置中找出代理配置。 ** 代理_指定：使用 网址 此结构的字段。

+ 默认是自动检测代理类型。 * 网址：代理的URL。 * 认证_cb：指向回调函数的指针，如果远程需要身份验证才能连接，该函数将被调用。 * 证书_cb：指向回调函数的指针，如果证书验证失败，将调用该函数。 这允许用户决定是否继续连接。 如果函数返回 1，连接将被允许。 如果它返回 0，将不允许连接。 负值可用于返回错误。 * 有效载荷：要提供给两个回调函数的有效负载。

*例子*

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

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

匹配的https://libgit2.org/libgit2/#HEAD/type/git_push_options[脧锚脧赂`git_push_选项`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 并行性:如果必须创建包文件，则此变量设置将由packbuilder生成的工作线程数。 如果 0，packbuilder将自动设置要使用的线程数。 默认值为 1. * 回调：用于推送的回调（例如用于远程身份验证）。 * 代理_opts：仅当LibGit2版本大于或等于时才相关 0.25.0. 设置使用代理与远程通信的选项。 见 代理操作了解更多信息。 * 自定义装载机：仅当LibGit2版本大于或等于时才相关 0.24.0. 推送操作所需的额外标头。 * remote_push_options：只有在LibGit2版本大于或等于时才相关 1.8.0. "推送选项"交付到远程。

LibGit2.RebaseOperation

描述在rebase期间要执行的单个指令/操作。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_rebase_operation_t[脧锚脧赂`git_rebase_operation`]结构。

字段代表:

* 选择类型：当前正在执行的rebase操作的类型。 选项是: ** 再平衡_操作_选择：樱桃-挑选有问题的提交。 ** REBASE_OPERATION_REWORD:cherry-选择有问题的提交，但使用提示符重写其消息。 ** REBASE_OPERATION_编辑:cherry-选择有问题的提交，但允许用户编辑提交的内容及其消息。 ** REBASE_OPERATION_SQUASH：将有问题的提交压缩到前一个提交中。 两个提交的提交消息将被合并。 ** REBASE_OPERATION_FIXUP：将有问题的提交压缩到前一个提交中。 只会使用前一个提交的提交消息。 ** REBASE_OPERATION_EXEC：不要樱桃选择一个承诺。 如果命令成功退出，请运行命令并继续。 * 身份证： xref:stdlib/LibGit2.adoc#LibGit2.GitHash[吉斯卡什 在这个rebase步骤中正在处理的提交。 * 执行董事：万一 REBASE_OPERATION_EXEC 使用此步骤期间运行的命令（例如，在每次提交后运行测试套件）。

LibGit2.RebaseOptions

匹配的 git_rebase_选项 结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 安静：通知其他帮助/处理rebase的git客户端，rebase应该"安静地"完成。 用于互操作性。 默认值为 1. * [医]记忆：启动内存中rebase。 在rebase上工作的调用者可以通过它的步骤并提交任何更改，但不能倒回HEAD或更新存储库。 该 n.工作,工作不会被修改。 仅存在于libgit2版本更新或等于0.24.0。 * rewrite_notes_ref：在rebase完成后，用于重写提交注释的注释引用的名称。 * 合并_opts：合并选项控制在每个rebase步骤中如何合并树。 仅存在于libgit2版本更新或等于0.24.0。 * 签出_opts:检出用于在初始化rebase、单步执行和中止它时写入文件的选项。 见 退房选项了解更多信息。

LibGit2.RemoteCallbacks

回调设置。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_remote_callbacks[脧锚脧赂`git_remote_callbacks`]结构。

LibGit2.SignatureStruct

动作签名（例如提交者、标记者等）。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_signature[脧锚脧赂`git_签名`]结构。

字段代表:

* 姓名：提交者或提交者的全名。 * 电邮：可以联系提交者/作者的电子邮件。 * 何时：a 时间结构指示提交何时创作/提交到存储库。

LibGit2.StatusEntry

提供HEAD和索引中存在的文件之间的差异，并提供索引和工作目录之间的差异。 匹配的 git_status_入口 结构。

字段代表:

* 状况：包含文件的状态标志，指示它是当前的，还是在索引或工作树中以某种方式更改过。 * head_to_index：指向a的指针 迪夫德尔塔它封装了文件在HEAD和索引中存在的差异。 * 索引_to_workdir：指向a的指针 迪夫德尔塔 它封装了文件之间的差异，因为它存在于索引和 n.工作,工作.

LibGit2.StatusOptions

控制方式的选项 git_status_foreach_ext() 会发出回调。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_status_opt_t[脧锚脧赂`git_status_opt_t`]结构。

字段代表:

* 版本：正在使用的结构的版本，以防稍后更改。 现在，永远 1. * 展览：要检查哪些文件以及按哪个顺序检查的标志。 默认值为 缺点。STATUS_SHOW_INDEX_AND_WORKDIR. * 旗帜:用于控制状态调用中使用的任何回调的标志。 * 路径规格:用于路径匹配的路径数组。 路径匹配的行为将根据 展览 和 旗帜. * 基线 用于与工作目录和索引进行比较的树；默认为HEAD。

LibGit2.StrArrayStruct

字符串数组的LibGit2表示形式。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_strarray[脧锚脧赂`git_strarray`]结构。

从LibGit2获取数据时，典型的用法如下所示:

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

特别要注意的是 LibGit2.免费 应在 参考书 对象。

相反，当将字符串的向量传递给LibGit2时，通常最简单的是依赖隐式转换:

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

请注意，没有调用 免费 是必需的，因为数据是由Julia分配的。

LibGit2.TimeStruct

签名中的时间。 匹配的https://libgit2.org/libgit2/#HEAD/type/git_time[脧锚脧赂`git_时间`]结构。

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

添加位于以下位置的现有git配置文件 路径 到电流 [医]吉特康菲格 [医]cfg. 如果文件不存在，它将被创建。

* 水平 设置git配置优先级，并由

缺点。GIT_CONFIG.

* 回购协议 是一个可选的存储库，以允许解析条件包含。 *如果 警队 是 错误 并且已经存在给定优先级的配置,

添加文件 会出错。 如果 警队 是 真的，现有的配置将被文件中的配置替换为 路径.

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

添加所有路径指定的文件 档案 到索引 idx （或 回购协议). 如果文件已经存在，则索引条目将被更新。 如果该文件不存在，它将被新添加到索引中。 档案 可能包含glob模式，这些模式将被扩展，并且将添加任何匹配的文件（除非 INDEX_ADD_DISABLE_PATHSPEC_MATCH 被设置，见下文）。 如果文件已被忽略（在 .吉蒂尼诺尔 或者在配置中），它不会被添加，它已经在索引中被跟踪，在这种情况下它会被更新。 关键字参数 旗帜 是一组位标志，用于控制被忽略文件的行为:

* 缺点。INDEX_ADD_DEFAULT -默认，如上所述。 * 缺点。索引_ADD_压力 -忽略现有的忽略规则，并强制将文件添加到索引中，即使它已经被忽略。 * 缺点。索引_ADD_CHECK_PATHSPEC -不能在同一时间使用 索引_ADD_压力. 检查每个文件在 档案 存在于磁盘上的不在忽略列表中。 如果其中一个文件被忽略，函数将返回 EINVALIDSPEC,EINVALIDSPEC. * 缺点。INDEX_ADD_DISABLE_PATHSPEC_MATCH -关闭glob匹配，只向索引中添加与指定路径完全匹配的文件 档案.

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

为指定的添加_fetch_refspec rmt. 此refspec将包含有关从哪个分支获取的信息。

*例子*

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

julia> LibGit2.fetch_refspecs(remote)
String["+refs/heads/*:refs/remotes/upstream/*"]
add_push!(repo::GitRepo, rmt::GitRemote, push_spec::String)

为指定的添加_push_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"]

注意您可能需要 接近/接近并重新打开 [医]吉特雷莫特 在更新其推送refspecs以使更改生效并调用 推,推工作。

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

阅读文件在 路径 并将其添加到 回购协议 作为一个松散的斑点。 归还 吉斯卡什的所得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)
author(c::GitCommit)

归还 签名 提交人的资料 c. 作者是对相关文件进行更改的人。 请参阅 提交人.

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

将提交的所有作者返回 回购协议 存储库。

*例子*

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)

# will be a Vector of [sig, sig]
auths = LibGit2.authors(repo)
branch(repo::GitRepo)

相当于 git分支. 从当前HEAD创建一个新分支。

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

在 回购协议 存储库。 承诺 是 吉斯卡什，以字符串形式，这将是新分支的开始。 如果 承诺 是一个空字符串，将使用当前HEAD。

关键字参数是:

* 轨道::AbstractString=""：远程分支的名称这个新分支应该跟踪，如果有的话。 如果为空（默认值），则不会跟踪任何远程分支。 * 力::Bool=false：如果 真的，分支创建将被强制。 * set_head::Bool=true：如果 真的，在分支创建完成后，分支头将被设置为 回购协议.

相当于 git checkout[-b/-B]<branch_name>[<commit>][--track<track>].

*例子*

repo = LibGit2.GitRepo(repo_path)
LibGit2.branch!(repo, "new_branch", set_head=false)
checkout!(repo::GitRepo, commit::AbstractString=""; force::Bool=true)

相当于 git checkout[-f]--detach<commit>. 签出git提交 承诺 （一 吉斯卡什以字符串形式）在 回购协议. 如果 警队 是 真的，强制结帐并放弃任何当前更改。 请注意，这会分离当前的头部。

*例子*

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
# would fail without the force=true
# since there are modifications to the file
LibGit2.checkout!(repo, string(commit_oid), force=true)
clone(repo_url::AbstractString, repo_path::AbstractString, clone_opts::CloneOptions)

克隆远程存储库 [医]repo_url （可以是远程URL或本地文件系统上的路径） repo_path （必须是本地文件系统上的路径）。 克隆的选项，例如是否执行裸克隆，由 [医克隆].

*例子*

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.

关键字参数是:

* 分支::AbstractString=""：要克隆远程的哪个分支，如果不是默认的存储库分支（通常 师父). * isbare::Bool=false：如果 真的，将远程克隆为裸存储库，这将使 repo_path 本身的git目录，而不是 repo_path/。git的. 这意味着无法检出工作树。 起到git CLI参数的作用 --光秃秃的. * remote_cb::Ptr{Cvoid}=C_NULL：一个回调，它将用于在克隆之前创建远程。 如果 C_NULL （默认），将不尝试创建远程-它将被假定已经存在。 * 凭据::Creds=无：在对私有存储库进行身份验证时提供凭据和/或设置。 * 回调::回调=回调()：用户提供回调和有效载荷。

相当于 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")
commit(repo::GitRepo, msg::AbstractString; kwargs...) -> GitHash

包装周围https://libgit2.org/libgit2/#HEAD/group/commit/git_commit_create[脧锚脧赂`git_commit_创建`]. 在存储库中创建提交 回购协议. 味精 是提交消息。 返回新提交的OID。

关键字参数是:

* refname::AbstractString=Conts。头文件:如果不为NULL，则更新引用的名称以指向新提交。 例如, "头" 将更新当前分支的头部。 如果引用尚不存在，则将创建它。 * 作者::Signature=Signature(repo) 是一个 签名 包含有关提交作者的信息。 * 提交者::签名=签名(回购协议) 是一个 签名 包含有关将提交提交到存储库的人员的信息。 不一定与 作者，例如，如果 作者 电邮至 提交人 是谁干的。 * 吉斯卡什=吉斯卡什() 是用于创建提交的git树，显示其祖先以及与任何其他历史记录的关系。 树 必须属于 回购协议. * parent_ids::向量{GitHash}=吉斯卡什[] 是提交的列表 吉斯卡什用作新提交的父提交，并且可能为空。 例如，如果提交是合并提交，则提交可能有多个父级。

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

将当前补丁提交到rebase rb，使用 sig 作为提交者。 如果提交已经被应用，则保持沉默。

committer(c::GitCommit)

归还 签名 提交人的提交人 c. 提交者是提交最初由 作者，但不必与 作者，例如，如果 作者 通过电子邮件将补丁发送到 提交人 是谁干的。

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

使用 吉特雷瓦尔克 沃克 要"遍历"存储库历史记录中的每个提交，请查找返回的提交数 真的 何时 f 被应用于它们。 关键字参数是: * oid： xref:stdlib/LibGit2.adoc#LibGit2.GitHash[吉斯卡什 开始步行的承诺。 默认为使用 xref:stdlib/LibGit2.adoc#LibGit2.push_head![推头！ 因此，头犯和它所有的祖先。 * 由：排序方法。 默认为不排序。 其他选项是按拓扑排序（LibGit2.缺点。SORT_TOPOLOGICAL碌录潞陆），及时向前排序（LibGit2.缺点。SORT_时间，最古老的第一个）或在时间上向后排序（LibGit2.缺点。SORT_REVERSE，最近的第一个）。 * 牧师：是否反转排序顺序（例如，如果使用拓扑排序）。

*例子*

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.计数 找到沿着步行的提交数 吉斯卡什 提交_oid1，从该提交开始步行，并从中及时向前移动。 自 吉斯卡什 对于提交来说是唯一的, cnt 将是 1.

counthunks(blame::GitBlame)

用一个文件返回不同的"大块头"的数量。 一个大块可能包含多行。 大块通常是一起添加/更改/删除的文件的一部分，例如，添加到源文件的函数或稍后从该函数中优化的内部循环。

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

在存储库中创建新分支 回购协议 带名字 姓名，哪些点提交 提交_obj （这必须是 回购协议). 如果 警队 是 真的，复盖名为的现有分支 姓名 如果存在的话。 如果 警队 是 错误 并且已经存在一个名为 姓名，这个函数会抛出一个错误。

credential_callback(...) -> Cint

一个LibGit2凭证回调函数，它提供不同的凭证获取功能w.r.t.a连接协议。 该 薪俸税 需要包含一个 LibGit2.[计]信用额 对象，将跟踪状态和设置。

该 允许的类型 包含的位掩码 LibGit2.缺点。GIT_CREDTYPE 指定应尝试哪些身份验证方法的值。

凭据身份验证按以下顺序完成（如果支持）:

*SSH代理 *SSH私钥/公钥对 *用户名/密码纯文本

如果用户收到凭据提示，他们可以通过键入内容来中止提示 ^D （按下控制键与 d 键）。

注：由于 libgit2 身份验证过程，当身份验证失败时，再次调用此函数，而不指示身份验证是否成功。 为了避免无限循环重复使用相同的错误凭据，我们将使用有效负载跟踪状态。

有关添加细节，请参阅LibGit2指南https://libgit2.org/docs/guides/authentication/[针对服务器进行身份验证]。

C函数指针 credentials_callback

返回签名对象。 使用后免费。

LibGit2.delete_branch(branch::GitReference)

删除由指向的分支 分行.

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

显示git存储库中哪些文件已更改 回购协议 分支之间 分支1 和 分支2.

关键字参数是:

* 过滤器::Set{Consts.DELTA_STATUS}=设置（[Conts。DELTA_ADDED，Conts。DELTA_MODIFIED，Consts。DELTA_DELETED]))，并为差异设置选项。 默认为显示添加、修改或删除的文件。

只返回已更改的文件的_names_，_not_其内容。

*例子*

LibGit2.branch!(repo, "branch/a")
LibGit2.branch!(repo, "branch/b")
# add a file to repo
open(joinpath(LibGit2.path(repo),"file"),"w") do f
    write(f, "hello repo
")
end
LibGit2.add!(repo, "file")
LibGit2.commit(repo, "add file")
# returns ["file"]
filt = Set([LibGit2.Consts.DELTA_ADDED])
files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)
# returns [] because existing files weren't modified
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>.

entryid(te::GitTreeEntry)

归还 吉斯卡什[目的 特 指的。

entrytype(te::GitTreeEntry)

返回对象的类型 特 指的。 结果将是其中一种类型。 obj类型返回，例如a 吉特里 或 吉特布洛布.

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

从指定的获取 rmt 远程git仓库，使用 refspecs 确定要获取哪个远程分支。 关键字参数是:

* 选项:确定获取的选项，例如是否事后修剪。 见 [医胎儿]了解更多信息。 * 味精：要插入回流的消息。

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

从存储库的上游获取更新 回购协议.

关键字参数是:

* 远程::AbstractString="起源"：哪个远程，按名称指定， 回购协议 去取。 如果这是空的，URL将用于构造一个匿名远程。 * remoteurl::AbstractString=""：网址 远程. 如果没有指定，将根据给定的名称假定 远程. * refspecs=抽象字符串[]:确定读取的属性。 * 凭据=没有：在针对私有身份验证时提供凭据和/或设置 远程. * 回调=回调()：用户提供回调和有效载荷。

相当于 git fetch[<remoteurl>|<repo>][<refspecs>].

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

返回所有获取头的列表 回购协议，每个表示为 鹿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]。伊斯默日
错误
fetch_refspecs(rmt::GitRemote) -> Vector{String}

获取指定的_fetch_refspecs 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/&ast;:refs/remotes/upstream/&ast;"]

C函数指针 fetchhead_foreach_callback

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

在提交之间找到一个合并基础（一个共同的祖先） 一个 和 二. 一个 和 二 可能都是字符串形式。 归还 吉斯卡什 的合并基。

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

在存储库上执行git合并 回购协议，将具有不同历史记录的提交合并到当前分支中。 回来吧 真的 如果合并成功, 错误 如果没有。

关键字参数是:

* committish::AbstractString=""：合并命名提交 n.犯罪,犯罪. * 分支::AbstractString=""：合并分支 分行 以及它的所有提交，因为它偏离了当前的分支。 * fastforward::Bool=false：如果 快速前向 是 真的，只有当合并是快进（当前分支头是要合并的提交的祖先）时才合并，否则拒绝合并并返回 错误. 这相当于git CLI选项 --ff-只. * merge_opts::MergeOptions=MergeOptions(): 合并_opts 指定合并的选项，例如发生冲突时的合并策略。 * checkout_opts::CheckoutOptions=CheckoutOptions(): 签出_opts 指定签出步骤的选项。

相当于 git merge[--ff-only][<committish>|<branch>].

注意如果您指定 分行，这必须以引用格式完成，因为字符串将被转换为 [医]GitReference. 例如，如果你想合并分支 分支_a，你会打电话 合并！（repo，branch="refs/heads/branch_a"）.

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

合并来自注释提交的更改（捕获为 鹿GitAnnotated对象) 安斯 进入存储库的头部 回购协议. 关键字参数是:

* merge_opts::MergeOptions=MergeOptions()：如何执行合并的选项，包括是否允许fastforwarding。 见 合并操作了解更多信息。 * checkout_opts::CheckoutOptions=CheckoutOptions()：如何执行结帐的选项。 见 退房选项了解更多信息。

安斯 可以指远程或本地分支头。 回来吧 真的 如果合并成功，否则返回 错误 （例如，如果没有合并是可能的，因为分支没有共同的祖先）。

*例子*

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

# merge the branch in
LibGit2.merge!(repo, [upst_ann])
merge!(repo::GitRepo, anns::Vector{GitAnnotated}, fastforward::Bool; kwargs...) -> Bool

合并来自注释提交的更改（捕获为 鹿GitAnnotated对象) 安斯 进入存储库的头部 回购协议. 如果 快速前向 是 真的,_only_允许fastforward合并。 在这种情况下，如果发生冲突，合并将失败。 否则，如果 快速前向 是 错误，合并可能会产生用户需要解决的冲突文件。

关键字参数是:

* merge_opts::MergeOptions=MergeOptions()：如何执行合并的选项，包括是否允许fastforwarding。 见 合并操作了解更多信息。 * checkout_opts::CheckoutOptions=CheckoutOptions()：如何执行结帐的选项。 见 退房选项了解更多信息。

安斯 可以指远程或本地分支头。 回来吧 真的 如果合并成功，否则返回 错误 （例如，如果没有合并是可能的，因为分支没有共同的祖先）。

*例子*

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

# merge the branch in, fastforward
LibGit2.merge!(repo, [upst_ann_1], true)

# merge conflicts!
upst_ann_2 = LibGit2.GitAnnotated(repo, "branch/b")
# merge the branch in, try to fastforward
LibGit2.merge!(repo, [upst_ann_2], true) # will return false
LibGit2.merge!(repo, [upst_ann_2], false) # will return true
ffmerge!(repo::GitRepo, ann::GitAnnotated)

Fastforward将更改合并为当前HEAD。 这只有在以下情况下才可能 安 是从当前头的后代（例如，如果从远程分支拉动更改，该分支只是在本地分支尖端之前）。

LibGit2.fullname(ref::GitReference)

返回符号引用指向的引用的名称 参考书. 如果 参考书 不是符号引用，返回空字符串。

features()

返回当前版本libgit2支持的git功能列表，例如线程或使用HTTPS或SSH。

filename(te::GitTreeEntry)

返回磁盘上对象的文件名。 特 指的。

filemode(te::GitTreeEntry) -> Cint

返回磁盘上对象的UNIX文件码。 特 指为整数。

LibGit2.gitdir(repo::GitRepo)

返回"git"文件的位置 回购协议:

*对于普通存储库，这是 .git的 文件夹。 *对于裸存储库，这是存储库本身的位置。

请参阅 n.工作,工作, 路径.

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

根据提供的URL组件创建字符串。 当 计划 关键字不提供产生的URL将使用替代https://git-scm.com/docs/git-clone#_git_urls_a_id_urls_a[类似scp的语法]。

*关键字*

* 方案::AbstractString=""：标识要使用的协议的URL方案。 对于HTTP使用"http"，SSH使用"ssh"等。 何时 计划 没有提供输出格式将是"ssh"，但使用类似scp的语法。 * 用户名::AbstractString=""：在输出中使用的用户名（如果提供）。 * 密码::AbstractString=""：在输出中使用的密码（如果提供）。 * 主机::AbstractString="":要在输出中使用的主机名。 需要指定主机名。 * 港口::联合{AbstractString,Integer}=""：在输出中使用的端口号（如果提供）。 使用类scp语法时无法指定。 * 路径::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"
@githash_str -> AbstractGitHash

从给定的字符串构造一个git哈希对象，返回一个 GitShortHash 如果字符串短于40个十六进制数字，否则 吉斯卡什.

*例子*

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

julia> LibGit2.githash"d114feb74ce63307afe878a5228ad014e0289a85"
GitHash("d114feb74ce63307afe878a5228ad014e0289a85")
LibGit2.head(repo::GitRepo) -> GitReference

返回a GitReference,GitReference 致现任 回购协议.

head(pkg::AbstractString) -> String

返回电流头 吉斯卡什的 pkg,pkg 回购作为字符串。

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

设置的头 回购协议 指向由 参考书.

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

查找git仓库当前HEAD的对象id 回购协议.

LibGit2.headname(repo::GitRepo)

查找git仓库当前HEAD的名称 回购协议. 如果 回购协议 当前已分离，返回其分离的头部的名称。

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

在以下位置打开新的git存储库 路径. 如果 光秃秃的 是 错误，工作树将在 路径/。git的. 如果 光秃秃的 是 真的，不会创建任何工作目录。

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

回来吧 真的 如果 a，一 吉斯卡什以字符串形式，是 b，一 吉斯卡什以字符串形式。

*例子*

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
isbinary(blob::GitBlob) -> Bool

使用启发式方法来猜测文件是否为二进制文件：搜索空字节并在前8000个字节中寻找可打印字符与不可打印字符的合理比例。

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

检查是否提交 身份证 （这是一个 吉斯卡什以字符串形式）在存储库中。

*例子*

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(repo::GitRepo, treeish::AbstractString, pathspecs::AbstractString=""; cached::Bool=false)

检查指定的树之间是否有任何差异 树,树 和工作树中跟踪的文件（如果 缓存=错误）或索引（如果 缓存=true). 路径谱 是差异选项的规格。

*例子*

repo = LibGit2.GitRepo(repo_path)
LibGit2.isdiff(repo, "HEAD") # should be false
open(joinpath(repo_path, new_file), "a") do f
    println(f, "here's my cool new file")
end
LibGit2.isdiff(repo, "HEAD") # now true

相当于 git diff-index<treeish>[--<pathspecs>].

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

检查工作树中跟踪的文件是否有任何更改（如果 缓存=错误）或索引（如果 缓存=true). 路径谱 是差异选项的规格。

*例子*

repo = LibGit2.GitRepo(repo_path)
LibGit2.isdirty(repo) # should be false
open(joinpath(repo_path, new_file), "a") do f
    println(f, "here's my cool new file")
end
LibGit2.isdirty(repo) # now true
LibGit2.isdirty(repo, new_file) # now true

相当于 git diff-index HEAD[--<pathspecs>].

LibGit2.isorphan(repo::GitRepo)

检查当前分支是否是"孤儿"分支，即没有提交。 第一个提交到这个分支将没有父母。

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

测试是否位 瓦尔 索引 旗帜 被设置(1）或未设置（0).

iszero(id::GitHash) -> Bool

确定是否给定的所有十六进制数字 吉斯卡什均为零。

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

确定是否由指定的分支 分支名称 存在于存储库中 回购协议. 如果 远程 是 真的, 回购协议 被假定为远程git存储库。 否则，它是本地文件系统的一部分。

返回任何一个 [医]GitReference 到所请求的分支（如果存在），或者 什么都没有如果没有。

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

使用 吉特雷瓦尔克 沃克 要"遍历"存储库历史记录中的每个提交，请应用 f 在步行中每个提交。 关键字参数是: * oid： xref:stdlib/LibGit2.adoc#LibGit2.GitHash[吉斯卡什 开始步行的承诺。 默认为使用 xref:stdlib/LibGit2.adoc#LibGit2.push_head![推头！ 因此，头犯和它所有的祖先。 * 范围：一系列 吉斯卡什s的格式 oid1。.oid2. f 将应用于两者之间的所有提交。 * 由：排序方法。 默认为不排序。 其他选项是按拓扑排序（LibGit2.缺点。SORT_TOPOLOGICAL碌录潞陆），及时向前排序（LibGit2.缺点。SORT_时间，最古老的第一个）或在时间上向后排序（LibGit2.缺点。SORT_REVERSE，最近的第一个）。 * 牧师：是否反转排序顺序（例如，如果使用拓扑排序）。

*例子*

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

这里, LibGit2.地图 访问每个提交使用 吉特雷瓦尔克 并找到它的 吉斯卡什.

镜像回调函数

功能集 +裁判/*:裁判/* 参考及 镜子 标志进行远程参考。

C函数指针 反光镜/反光镜

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

返回描述commit中所做更改的commit消息 c. 如果 生的 是 错误，返回一个稍微"清理"的消息（其中删除了任何前导换行符）。 如果 生的 是 真的，该消息不剥离任何此类换行符。

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

对带注释的分支提示所指向的分支运行分析 安斯 并确定在什么情况下它们可以合并。 例如，如果 安斯[1] 只是一个祖先。 安[2]，则 合并分析 将报告快进合并是可能的。

返回两个输出, 分析 和 优先选择. 分析 有几个可能的值: * 合并，合并：不可能合并 安斯. * MERGE_ANALYSIS_正常:一个常规的合并，当HEAD和用户希望合并的提交都与一个共同的祖先不同时。 在这种情况下，必须解决更改，并可能发生冲突。 * MERGE_ANALYSIS_UP_TO_DATE：用户希望合并的所有输入都可以从HEAD到达，因此不需要执行合并。 * 合并，合并：输入提交是HEAD的后代，因此不需要执行合并-相反，用户可以简单地检出输入提交。 * 合并，合并：存储库的头部是指不存在的提交。 不可能合并，但可能可以检出输入提交。 优先选择 也有几个可能的值: * 合并_PREFERENCE_NONE：用户没有偏好。 * MERGE_PREFERENCE_NO_FASTFORWARD：不允许任何快进合并。 * MERGE_PREFERENCE_FASTFORWARD_ONLY：只允许快进合并，不允许其他类型（可能会引入冲突）。 优先选择 可以通过存储库或全局git配置进行控制。

LibGit2.name(ref::GitReference)

返回的全名 参考书.

name(rmt::GitRemote)

获取远程存储库的名称，例如 "起源". 如果远程是匿名的（请参阅 [医吉特雷莫泰农])名称将是一个空字符串 "".

*例子*

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)

的名称 标签 （例如 "v0.5").

need_update(repo::GitRepo)

相当于 git更新-索引. 回来吧 真的 如果 回购协议 需要更新。

objtype(obj_type::Consts.OBJECT)

返回枚举值对应的类型。

LibGit2.path(repo::GitRepo)

返回存储库的基本文件路径 回购协议.

*对于普通存储库，这通常是"的父目录。git"目录（注意：这可能与工作目录不同，请参阅 n.工作,工作 欲了解更多详情）。 *对于裸存储库，这是"git"文件的位置。

请参阅 吉特迪尔, n.工作,工作.

peel([T,] ref::GitReference)

递归剥离 参考书 直到类型的对象 T 被获得。 如果没有 T 被提供，则 参考书 将被剥离，直到一个对象以外的 吉塔格而获得。

*一个 吉塔格 将被剥离到它引用的对象。 *一个 GitCommit,GitCommit将被剥离到一个 吉特里.

注意只有带注释的标签可以剥离到 吉塔格 物体。 轻量级标签（默认）是下面的引用 裁判/标签/ 哪个直接指向 GitCommit,GitCommit 物体。

 
peel([T,] obj::GitObject)

递归剥离 反对 直到类型的对象 T 被获得。 如果没有 T 被提供，则 反对 将被剥离，直到类型改变。

*一个 吉塔格 将被剥离到它引用的对象。 *一个 GitCommit,GitCommit 将被剥离到一个 吉特里.

LibGit2.posixpath(path)

标准化路径字符串 路径 使用POSIX分隔符。

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

推送到指定的 rmt 远程git仓库，使用 refspecs 确定要推送到哪个远程分支。 关键字参数是:

* 警队：如果 真的，将发生力推，无视冲突。 * 选项:确定推送的选项，例如要使用的代理标头。 见 推手/推手了解更多信息。

注意您可以通过另外两种方式添加有关推送refspecs的信息：通过在存储库的 [医]吉特康菲格 （与 推。违约情况 作为关键）或通过调用 add_push！. 否则，您将需要在调用中显式指定push refspec 推,推 为了它有任何效果，就像这样: LibGit2.推（repo，refspecs=["refs/heads/master"]）.

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

将更新推送到 回购协议.

关键字参数是:

* 远程::AbstractString="起源"：要推送到的上游远程的名称。 * remoteurl::AbstractString=""：网址 远程. * refspecs=抽象字符串[]:确定推送的属性。 * 力::Bool=false:确定推送是否为强制推送，复盖远程分支。 * 凭据=没有：在针对私有身份验证时提供凭据和/或设置 远程. * 回调=回调()：用户提供回调和有效载荷。

相当于 git push[<remoteurl>|<repo>][<refspecs>].

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

启动 吉特雷瓦尔克 沃克 在提交 cid. 此函数可用于将函数应用于自某一年以来的所有提交，方法是将该年的第一个提交传递为 cid 然后通过所得到的 w 到 LibGit2.地图.

LibGit2.push_head!(w::GitRevWalker)

把头颅和它的祖先推到 吉特雷瓦尔克 w. 这确保了在步行过程中会遇到HEAD及其所有祖先提交。

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

获取指定的_push_refspecs 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"]
raw(id::GitHash) -> Vector{UInt8}

获取原始字节的 吉斯卡什作为长度为20的向量。

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

阅读树 树 （或者指着的那棵树 树丛,树丛 在所拥有的存储库中 idx）进入索引 idx. 当前索引内容将被替换。

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

尝试当前分支的自动合并rebase，从 上游 如果提供，或以其他方式从上游跟踪分支。 新基地 是要重新绑定的分支。 默认情况下，这是 上游.

如果出现任何无法自动解决的冲突，rebase将中止，使存储库和工作树保持原始状态，并且函数将抛出 吉特罗尔. 这大致相当于下面的命令行语句:

git rebase --merge [<upstream>]
if [ -d ".git/rebase-merge" ]; then
    git rebase --abort
fi
LibGit2.ref_list(repo::GitRepo) -> Vector{String}

获取所有参考名称的列表 回购协议 存储库。

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

返回a 辛特 对应的类型 参考书:

* 0 如果引用无效 * 1 如果引用是对象id * 2 如果引用是符号的

LibGit2.remotes(repo::GitRepo)

返回遥控器名称的向量 回购协议.

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

删除所有路径指定的文件 档案 在索引中 idx （或 回购协议).

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

取消设置的位 瓦尔 索引 旗帜，把它们还给 0.

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

重置 有效载荷 状态回到初始值，以便可以在凭据回调中再次使用它。 如果一个 配置；配置 如果配置也将被更新。

更新一些条目，由 路径谱，在目标提交树的索引中。

将当前头设置为指定的提交oid，并可选地重置索引和工作树以匹配。

git reset[] [--] \。..</committish>+

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

重置存储库 回购协议 到其状态在 身份证，使用以下三种模式之一 模式:

  1. 缺点。重置_SOFT -头部移动到 身份证.

  2. 缺点。RESET_混合 -默认，移动头到 身份证 并将索引重置为 身份证.

  3. 缺点。RESET_HARD -头部移动到 身份证，将索引重置为 身份证，并丢弃所有工作更改。

*例子*

# fetch changes
LibGit2.fetch(repo)
isfile(joinpath(repo_path, our_file)) # will be false

# fastforward merge the changes
LibGit2.merge!(repo, fastforward=true)

# because there was not any file locally, but there is
# a file remotely, we need to reset the branch
head_oid = LibGit2.head_oid(repo)
new_head = LibGit2.reset!(repo, head_oid, LibGit2.Consts.RESET_HARD)

在这个例子中，从_does_获取的远程有一个名为 我们的文件 在它的索引，这就是为什么我们必须重置。

相当于 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
# will discard the changes to file1
# and unstage it
new_head = LibGit2.reset!(repo, head_oid, mode)
restore(s::State, repo::GitRepo)

返回存储库 回购协议 到上一个 国家 s，例如在合并尝试之前分支的头部。 s 可使用 快照功能。

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

列出之间的修订次数 承诺1 和 承诺2 （以字符串形式提交）。 自 承诺1 和 承诺2 可能在不同的分支上, 重新计票 执行"左右"修订列表（和计数），返回 Int型s-分别为左和右提交的数量。 左（或右）提交指的是树中对称差异的哪一侧可以到达提交。

相当于 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).

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

设置取和推 网址 为 remote_name 为 吉特雷波或位于 路径. 通常git repos使用 "起源" 作为远程名称。

*例子*

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(ref::GitReference)

返回的名称的缩短版本 参考书 这是"人类可读"。

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"
snapshot(repo::GitRepo) -> State

获取存储库当前状态的快照 回购协议，存储当前HEAD、索引和任何未提交的工作。 输出 国家 可以在以后的通话过程中使用 还原以将存储库返回到snapshotted状态。

# *`LibGit2.分裂_cfg_进入`*-函数

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

打破 配置入口 最多以下部分：节，小节，名称和值。

*例子*

给定包含的git配置文件:

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

该 配置入口 如下所示:

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

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

请参阅https://git-scm.com/docs/git-config#_syntax[git config语法文档]获取更多详细信息。

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

查找文件的状态 路径 在git仓库中 回购协议. 例如，这可以用来检查文件是否在 路径 已被修改，需要分阶段和提交。

stage(ie::IndexEntry) -> Cint

获取的阶段编号 即. 舞台编号 0 表示工作树的当前状态，但在合并冲突的情况下可以使用其他数字。 在这种情况下，在一个不同的阶段数字 索引入口 描述文件的当前状态属于冲突的哪一方。 舞台 0 是尝试合并之前的状态，阶段 1 是在本地进行的更改，阶段 2 更大的是来自其他分支的变化（例如，在多分支"章鱼"合并的情况下，阶段 2, 3，而 4 可能会使用）。

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

创建一个新的git标签 标签 （例如 "v0.5"）在存储库中 回购协议，在提交 承诺.

关键字参数是:

* 味精::AbstractString=""：标签的消息。 * 力::Bool=false：如果 真的，现有的引用将被复盖。 * 签名=签名(回购协议)：标签者的签名。

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

删除git标签 标签 从存储库 回购协议.

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

获取git存储库中所有标签的列表 回购协议.

LibGit2.target(tag::GitTag)

该 吉斯卡什 的目标对象的 标签.

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

翻转的位 瓦尔 索引 旗帜，这样，如果有点是 0 会的 1 切换后，反之亦然。

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

应用功能 f 到git仓库 回购协议，以 快照申请前 f. 如果内发生错误 f, 回购协议 将返回到其快照状态使用 还原. 发生的错误将被重新抛出，但 回购协议 不会被腐化。

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

遍历条目 树 及其后序或前序的子树。 预排序意味着从根开始，然后遍历最左边的子树（并递归地向下遍历该子树的最左边的子树），然后向右移动子树。 Postorder意味着从最左边的子树的底部开始，向上遍历它，然后遍历下一个右子树（再次从底部开始），最后访问树根。

函数参数 f 应具有以下签名:

(String, GitTreeEntry) -> Cint

从返回的负值 f 停止树木行走。 正值表示如果 职位 是 错误.

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

确定分支是否包含 参考书 具有指定的上游分支。

返回任何一个 GitReference,GitReference 到上游分支，如果它存在，或 什么都没有如果请求的分支没有上游对应项。

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

使用以下指定的路径更新所有文件 档案 在索引中 idx （或 回购协议). 将索引中每个文件的状态与磁盘上的当前状态相匹配，如果它已在磁盘上删除，则将其删除，或更新其在对象数据库中的条目。

url(rmt::GitRemote)

获取远程git存储库的获取URL。

*例子*

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

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

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

朱莉娅>LibGit2.url(远程)
"https://github.com/JuliaLang/Example.jl"
version() -> VersionNumber

返回使用中的libgit2版本，作为 版本号.

with(f::Function, obj)

资源管理辅助功能。 适用于 f 到 反对，确保打电话 接近/接近 上 反对 之后 f 成功返回或抛出错误。 确保分配的git资源在不再需要时尽快完成。

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

资源管理助手功能。 申请 f 到 阿格斯，首先构造一个type的实例 T 从 阿格斯. 一定要打电话 接近/接近 后的结果对象上 f 成功返回或抛出错误。 确保分配的git资源在不再需要时尽快完成。 如果抛出错误 f，显示包含错误的警告。

LibGit2.workdir(repo::GitRepo)

返回工作目录的位置 回购协议. 这将引发裸存储库的错误。

请注意，这通常是 吉迪尔(回购协议)，但在某些情况下可能会有所不同：例如，如果 核心。工作树 配置变量或 GIT_WORK_TREE 环境变量设置。

请参阅 吉特迪尔, 路径.

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

获取git对象 特 引用并将其返回为其实际类型（类型 入口类型会显示），例如a 吉特布洛布 或 吉塔格.

*例子*

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

仅支持的凭证 用户 和 密码 参数

SSH凭证类型

isfilled(cred::AbstractCredential) -> Bool

验证凭据是否已准备好用于身份验证。

缓存凭据信息以供重复使用

LibGit2.CredentialPayload

保留对同一URL的凭据回调的多次调用之间的状态。 A [医]信用负荷 实例预计为 重置！ 每当它将与不同的URL一起使用时。

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

储存 有效载荷 凭据，以便在将来的身份验证中重复使用。 应仅在身份验证成功时调用。

该 切丝,切丝 关键字控制是否应销毁有效负载凭据字段中的敏感信息。 应只设置为 错误 在测试期间。

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

弃置 有效载荷 凭据从开始重新用于未来的身份验证。 应仅在身份验证不成功时调用。

该 切丝,切丝 关键字控制是否应销毁有效负载凭据字段中的敏感信息。 应只设置为 错误 在测试期间。

配置文件的优先级。

这些优先级对应于在git中搜索配置条目时的自然升级逻辑（从高到低）。

* CONFIG_LEVEL_DEFAULT -打开全局，XDG和系统配置文件（如果有）。 * 配置_LEVEL_PROGRAMDATA -Windows上的系统范围，与便携式git兼容 * 配置_LEVEL_系统 -系统范围的配置文件; /etc/gitconfig 在Linux系统上 * 配置_LEVEL_XDG -Xdg兼容的配置文件;通常 ~/.配置/git/配置 * 配置_LEVEL_GLOBAL -用户特定的配置文件（也称为全局配置文件）;通常 ~/.[医]吉特康菲格 * 配置_LEVEL_LOCAL -存储库特定配置文件; $WORK_DIR/.git/配置 在非裸地回购 * CONFIG_LEVEL_WORKTREE -Worktree特定配置文件; $GIT_DIR/config.工作树 * 配置_LEVEL_APP -应用程序特定的配置文件;由应用程序自由定义 * CONFIG_HIGHEST_LEVEL -表示最高级别的可用配置文件（即实际加载的最具体的可用配置文件）