#37474

pending completion

Build # #37474

Build Type

push

local

Committed by

web-flow

Commit Message

irinterp: Allow setting all IR flags (#48993)

Currently, `IR_FLAG_NOTHROW` is the only flag that irinterp is allowed to
set on statements, under the assumption that in order for a call to
be irinterp-eligible, it must have been proven `:foldable`, thus `:effect_free`,
and thus `IR_FLAG_EFFECT_FREE` was assumed to have been set. That reasoning
was sound at the time this code was written, but have since introduced
`EFFECT_FREE_IF_INACCESSIBLEMEMONLY`, which breaks the reasoning that
an `:effect_free` inference for the whole function implies the flag on
every statement. As a result, we were failing to DCE otherwise dead
statements if the IR came from irinterp.

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

70258 of 82316 relevant lines covered (85.35%)

32461773.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

19.14

/stdlib/LibGit2/src/repository.jl

# This file is a part of Julia. License is MIT: https://julialang.org/license

"""
    LibGit2.GitRepo(path::AbstractString)

Open a git repository at `path`.
"""
function GitRepo(path::AbstractString)
    ensure_initialized()
    repo_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)
    @check ccall((:git_repository_open, :libgit2), Cint,
                 (Ptr{Ptr{Cvoid}}, Cstring), repo_ptr_ptr, path)
    return GitRepo(repo_ptr_ptr[])
end

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

Open a git repository at `path` with extended controls (for instance, if the current
user must be a member of a special access group to read `path`).
"""
function GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))
    ensure_initialized()
    separator = @static Sys.iswindows() ? ";" : ":"
    repo_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)
    @check ccall((:git_repository_open_ext, :libgit2), Cint,
                 (Ptr{Ptr{Cvoid}}, Cstring, Cuint, Cstring),
                 repo_ptr_ptr, path, flags, separator)
    return GitRepo(repo_ptr_ptr[])
end

function cleanup(r::GitRepo)
    if r.ptr != C_NULL
        ensure_initialized()
        @check ccall((:git_repository__cleanup, :libgit2), Cint, (Ptr{Cvoid},), r.ptr)
    end
end

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

Open a new git repository at `path`. If `bare` is `false`,
the working tree will be created in `path/.git`. If `bare`
is `true`, no working directory will be created.
"""
function init(path::AbstractString, bare::Bool=false)
    ensure_initialized()
    repo_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)
    @check ccall((:git_repository_init, :libgit2), Cint,
                (Ptr{Ptr{Cvoid}}, Cstring, Cuint), repo_ptr_ptr, path, bare)
    return GitRepo(repo_ptr_ptr[])
end

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

Lookup the object id of the current HEAD of git
repository `repo`.
"""
function head_oid(repo::GitRepo)
    head_ref = head(repo)
    try
        return GitHash(head_ref)
    finally
        close(head_ref)
    end
end

"""
    LibGit2.headname(repo::GitRepo)

Lookup the name of the current HEAD of git
repository `repo`. If `repo` is currently
detached, return the name of the HEAD it's
detached from.
"""
function headname(repo::GitRepo)
    with(head(repo)) do href
        if isattached(repo)
            shortname(href)
        else
            "(detached from $(string(GitHash(href))[1:7]))"
        end
    end
end

"""
    isbare(repo::GitRepo) -> Bool

Determine if `repo` is bare. Suppose the top level directory of `repo` is `DIR`.
A non-bare repository is one in which the git directory (see [`gitdir`](@ref)) is
`DIR/.git`, and the working tree can be checked out. A bare repository is one in
which all of git's administrative files are simply in `DIR`, rather than "hidden"
in the `.git` subdirectory. This means that there is nowhere to check out the working
tree, and no tracking information for remote branches or configurations is present.
"""
function isbare(repo::GitRepo)
    ensure_initialized()
    @assert repo.ptr != C_NULL
    return ccall((:git_repository_is_bare, :libgit2), Cint, (Ptr{Cvoid},), repo.ptr) == 1
end

"""
    isattached(repo::GitRepo) -> Bool

Determine if `repo` is detached - that is, whether its HEAD points to a commit
(detached) or whether HEAD points to a branch tip (attached).
"""
function isattached(repo::GitRepo)
    ensure_initialized()
    @assert repo.ptr != C_NULL
    ccall((:git_repository_head_detached, :libgit2), Cint, (Ptr{Cvoid},), repo.ptr) != 1
end

@doc """
    GitObject(repo::GitRepo, hash::AbstractGitHash)
    GitObject(repo::GitRepo, spec::AbstractString)

Return the specified object ([`GitCommit`](@ref), [`GitBlob`](@ref), [`GitTree`](@ref) or [`GitTag`](@ref)) from `repo`
specified by `hash`/`spec`.

- `hash` is a full (`GitHash`) or partial (`GitShortHash`) hash.
- `spec` is a textual specification: see [the git docs](https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions) for a full list.
""" GitObject

for T in (:GitCommit, :GitBlob, :GitTree, :GitTag)
    @eval @doc $"""
    $T(repo::GitRepo, hash::AbstractGitHash)
    $T(repo::GitRepo, spec::AbstractString)

Return a `$T` object from `repo` specified by `hash`/`spec`.

- `hash` is a full (`GitHash`) or partial (`GitShortHash`) hash.
- `spec` is a textual specification: see [the git docs](https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions) for a full list.
""" $T
end

function (::Type{T})(repo::GitRepo, spec::AbstractString) where T<:GitObject
    ensure_initialized()
    obj_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)
    @assert repo.ptr != C_NULL
    @check ccall((:git_revparse_single, :libgit2), Cint,
                 (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cstring), obj_ptr_ptr, repo.ptr, spec)
    # check object is of correct type
    if T != GitObject && T != GitUnknownObject
        t = Consts.OBJECT(obj_ptr_ptr[])
        t == Consts.OBJECT(T) || throw(GitError(Error.Object, Error.ERROR, "Expected object of type $T, received object of type $(objtype(t))"))
    end
    return T(repo, obj_ptr_ptr[])
end

function (::Type{T})(repo::GitRepo, oid::GitHash) where T<:GitObject
    ensure_initialized()
    oid_ptr  = Ref(oid)
    obj_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)

    @assert repo.ptr != C_NULL
    @check ccall((:git_object_lookup, :libgit2), Cint,
                 (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{GitHash}, Consts.OBJECT),
                 obj_ptr_ptr, repo.ptr, oid_ptr, Consts.OBJECT(T))

    return T(repo, obj_ptr_ptr[])
end
function (::Type{T})(repo::GitRepo, oid::GitShortHash) where T<:GitObject
    ensure_initialized()
    oid_ptr  = Ref(oid.hash)
    obj_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)

    @assert repo.ptr != C_NULL
    @check ccall((:git_object_lookup_prefix, :libgit2), Cint,
                 (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{GitHash}, Csize_t, Consts.OBJECT),
                 obj_ptr_ptr, repo.ptr, oid_ptr, oid.len, Consts.OBJECT(T))

    return T(repo, obj_ptr_ptr[])
end

# TODO: deprecate this function
revparseid(repo::GitRepo, spec) = GitHash(GitUnknownObject(repo, spec))

"""
    LibGit2.gitdir(repo::GitRepo)

Return the location of the "git" files of `repo`:

 - for normal repositories, this is the location of the `.git` folder.
 - for bare repositories, this is the location of the repository itself.

See also [`workdir`](@ref), [`path`](@ref).
"""
function gitdir(repo::GitRepo)
    ensure_initialized()
    @assert repo.ptr != C_NULL
    return unsafe_string(ccall((:git_repository_path, :libgit2), Cstring,
                        (Ptr{Cvoid},), repo.ptr))
end

"""
    LibGit2.workdir(repo::GitRepo)

Return the location of the working directory of `repo`.
This will throw an error for bare repositories.

!!! note

    This will typically be the parent directory of `gitdir(repo)`, but can be different in
    some cases: e.g. if either the `core.worktree` configuration variable or the
    `GIT_WORK_TREE` environment variable is set.

See also [`gitdir`](@ref), [`path`](@ref).
"""
function workdir(repo::GitRepo)
    ensure_initialized()
    @assert repo.ptr != C_NULL
    sptr = ccall((:git_repository_workdir, :libgit2), Cstring,
                (Ptr{Cvoid},), repo.ptr)
    sptr == C_NULL && throw(GitError(Error.Object, Error.ERROR, "No working directory found."))
    return unsafe_string(sptr)
end

"""
    LibGit2.path(repo::GitRepo)

Return the base file path of the repository `repo`.

 - for normal repositories, this will typically be the parent directory of the ".git"
   directory (note: this may be different than the working directory, see `workdir` for
   more details).
 - for bare repositories, this is the location of the "git" files.

See also [`gitdir`](@ref), [`workdir`](@ref).
"""
function path(repo::GitRepo)
    d = gitdir(repo)
    if isdirpath(d)
        d = dirname(d) # strip trailing separator
    end
    if isbare(repo)
        return d
    else
        parent, base = splitdir(d)
        return base == ".git" ? parent : d
    end
end

"""
    peel([T,] obj::GitObject)

Recursively peel `obj` until an object of type `T` is obtained. If no `T` is provided,
then `obj` will be peeled until the type changes.

- A `GitTag` will be peeled to the object it references.
- A `GitCommit` will be peeled to a `GitTree`.
"""
function peel(::Type{T}, obj::GitObject) where T<:GitObject
    ensure_initialized()
    new_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)

    @check ccall((:git_object_peel, :libgit2), Cint,
                (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), new_ptr_ptr, obj.ptr, Consts.OBJECT(T))

    return T(obj.owner, new_ptr_ptr[])
end
peel(obj::GitObject) = peel(GitObject, obj)

"""
    LibGit2.GitDescribeResult(committish::GitObject; kwarg...)

Produce a `GitDescribeResult` of the `committish` `GitObject`, which
contains detailed information about it based on the keyword argument:

  * `options::DescribeOptions=DescribeOptions()`

A git description of a `committish` object looks for the tag (by default, annotated,
although a search of all tags can be performed) which can be reached from `committish`
which is most recent. If the tag is pointing to `committish`, then only the tag is
included in the description. Otherwise, a suffix is included which contains the
number of commits between `committish` and the most recent tag. If there is no such
tag, the default behavior is for the description to fail, although this can be
changed through `options`.

Equivalent to `git describe <committish>`. See [`DescribeOptions`](@ref) for more
information.
"""
function GitDescribeResult(committish::GitObject;
                           options::DescribeOptions=DescribeOptions())
    ensure_initialized()
    result_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)
    @check ccall((:git_describe_commit, :libgit2), Cint,
                 (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{DescribeOptions}),
                 result_ptr_ptr, committish.ptr, Ref(options))
    return GitDescribeResult(committish.owner, result_ptr_ptr[])
end

"""
    LibGit2.GitDescribeResult(repo::GitRepo; kwarg...)

Produce a `GitDescribeResult` of the repository `repo`'s working directory.
The `GitDescribeResult` contains detailed information about the workdir based
on the keyword argument:

  * `options::DescribeOptions=DescribeOptions()`

In this case, the description is run on HEAD, producing the most recent tag
which is an ancestor of HEAD. Afterwards, a status check on
the [`workdir`](@ref) is performed and if the `workdir` is dirty
(see [`isdirty`](@ref)) the description is also considered dirty.

Equivalent to `git describe`. See [`DescribeOptions`](@ref) for more
information.
"""
function GitDescribeResult(repo::GitRepo; options::DescribeOptions=DescribeOptions())
    ensure_initialized()
    result_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)
    @assert repo.ptr != C_NULL
    @check ccall((:git_describe_workdir, :libgit2), Cint,
                 (Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{DescribeOptions}),
                 result_ptr_ptr, repo.ptr, Ref(options))
    return GitDescribeResult(repo, result_ptr_ptr[])
end

"""
    LibGit2.format(result::GitDescribeResult; kwarg...) -> String

Produce a formatted string based on a `GitDescribeResult`.
Formatting options are controlled by the keyword argument:

  * `options::DescribeFormatOptions=DescribeFormatOptions()`
"""
function format(result::GitDescribeResult; options::DescribeFormatOptions=DescribeFormatOptions())
    ensure_initialized()
    buf_ref = Ref(Buffer())
    @check ccall((:git_describe_format, :libgit2), Cint,
                 (Ptr{Buffer}, Ptr{Cvoid}, Ptr{DescribeFormatOptions}),
                 buf_ref, result.ptr, Ref(options))
    buf = buf_ref[]
    str = unsafe_string(buf.ptr, buf.size)
    free(buf_ref)
    return str
end

function Base.show(io::IO, result::GitDescribeResult)
    fmt_desc = format(result)
    println(io, "GitDescribeResult:")
    println(io, fmt_desc)
end

"""
    checkout_tree(repo::GitRepo, obj::GitObject; options::CheckoutOptions = CheckoutOptions())

Update the working tree and index of `repo` to match the tree pointed to by `obj`.
`obj` can be a commit, a tag, or a tree. `options` controls how the checkout will
be performed. See [`CheckoutOptions`](@ref) for more information.
"""
function checkout_tree(repo::GitRepo, obj::GitObject;
                       options::CheckoutOptions = CheckoutOptions())
    ensure_initialized()
    @assert repo.ptr != C_NULL
    @check ccall((:git_checkout_tree, :libgit2), Cint,
                 (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{CheckoutOptions}),
                 repo.ptr, obj.ptr, Ref(options))
end

"""
    checkout_index(repo::GitRepo, idx::Union{GitIndex, Nothing} = nothing; options::CheckoutOptions = CheckoutOptions())

Update the working tree of `repo` to match the index `idx`. If `idx` is `nothing`, the
index of `repo` will be used. `options` controls how the checkout will be performed.
See [`CheckoutOptions`](@ref) for more information.
"""
function checkout_index(repo::GitRepo, idx::Union{GitIndex, Nothing} = nothing;
                        options::CheckoutOptions = CheckoutOptions())
    ensure_initialized()
    @assert repo.ptr != C_NULL
    @check ccall((:git_checkout_index, :libgit2), Cint,
                 (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{CheckoutOptions}),
                 repo.ptr,
                 idx === nothing ? C_NULL : idx.ptr,
                 Ref(options))
end

"""
    checkout_head(repo::GitRepo; options::CheckoutOptions = CheckoutOptions())

Update the index and working tree of `repo` to match the commit pointed to by HEAD.
`options` controls how the checkout will be performed. See [`CheckoutOptions`](@ref) for more information.

!!! warning
    *Do not* use this function to switch branches! Doing so will cause checkout
    conflicts.
"""
function checkout_head(repo::GitRepo; options::CheckoutOptions = CheckoutOptions())
    ensure_initialized()
    @assert repo.ptr != C_NULL
    @check ccall((:git_checkout_head, :libgit2), Cint,
                 (Ptr{Cvoid}, Ptr{CheckoutOptions}),
                 repo.ptr, Ref(options))
end

"""
    LibGit2.cherrypick(repo::GitRepo, commit::GitCommit; options::CherrypickOptions = CherrypickOptions())

Cherrypick the commit `commit` and apply the changes in it to the current state of `repo`.
The keyword argument `options` sets checkout and merge options for the cherrypick.

!!! note
    `cherrypick` will *apply* the changes in `commit` but not *commit* them, so `repo` will
    be left in a dirty state. If you want to also commit the changes in `commit` you must
    call [`commit`](@ref) yourself.
"""
function cherrypick(repo::GitRepo, commit::GitCommit; options::CherrypickOptions = CherrypickOptions())
    ensure_initialized()
    @assert repo.ptr != C_NULL
    @check ccall((:git_cherrypick, :libgit2), Cint,
                 (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{CherrypickOptions}),
                 repo.ptr, commit.ptr, Ref(options))
end

"""Updates some entries, determined by the `pathspecs`, in the index from the target commit tree."""
function reset!(repo::GitRepo, obj::Union{GitObject, Nothing}, pathspecs::AbstractString...)
    ensure_initialized()
    @assert repo.ptr != C_NULL
    @check ccall((:git_reset_default, :libgit2), Cint,
                 (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{StrArrayStruct}),
                 repo.ptr,
                 obj === nothing ? C_NULL : obj.ptr,
                 collect(pathspecs))
    return head_oid(repo)
end

"""Sets the current head to the specified commit oid and optionally resets the index and working tree to match."""
function reset!(repo::GitRepo, obj::GitObject, mode::Cint;
               checkout_opts::CheckoutOptions = CheckoutOptions())
    ensure_initialized()
    @assert repo.ptr != C_NULL
    @check ccall((:git_reset, :libgit2), Cint,
                 (Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{CheckoutOptions}),
                  repo.ptr, obj.ptr, mode, Ref(checkout_opts))
    return head_oid(repo)
end

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

Clone the remote repository at `repo_url` (which can be a remote URL or a path on the local
filesystem) to `repo_path` (which must be a path on the local filesystem). Options for the
clone, such as whether to perform a bare clone or not, are set by [`CloneOptions`](@ref).

# Examples
```julia
repo_url = "https://github.com/JuliaLang/Example.jl"
repo = LibGit2.clone(repo_url, "/home/me/projects/Example")
```
"""
function clone(repo_url::AbstractString, repo_path::AbstractString,
               clone_opts::CloneOptions)
    ensure_initialized()
    clone_opts_ref = Ref(clone_opts)
    repo_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)
    @check ccall((:git_clone, :libgit2), Cint,
            (Ptr{Ptr{Cvoid}}, Cstring, Cstring, Ref{CloneOptions}),
            repo_ptr_ptr, repo_url, repo_path, clone_opts_ref)
    return GitRepo(repo_ptr_ptr[])
end

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

Return the list of all the fetch heads for `repo`, each represented as a [`FetchHead`](@ref),
including their names, URLs, and merge statuses.

# Examples
```julia-repl
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
```
"""
function fetchheads(repo::GitRepo)
    ensure_initialized()
    fh = FetchHead[]
    ffcb = fetchhead_foreach_cb()
    @assert repo.ptr != C_NULL
    @check ccall((:git_repository_fetchhead_foreach, :libgit2), Cint,
                 (Ptr{Cvoid}, Ptr{Cvoid}, Any),
                 repo.ptr, ffcb, fh)
    return fh
end

"""
    LibGit2.remotes(repo::GitRepo)

Return a vector of the names of the remotes of `repo`.
"""
function remotes(repo::GitRepo)
    ensure_initialized()
    sa_ref = Ref(StrArrayStruct())
    @assert repo.ptr != C_NULL
    @check ccall((:git_remote_list, :libgit2), Cint,
                  (Ptr{StrArrayStruct}, Ptr{Cvoid}), sa_ref, repo.ptr)
    res = convert(Vector{String}, sa_ref[])
    free(sa_ref)
    return res
end

function Base.show(io::IO, repo::GitRepo)
    print(io, "LibGit2.GitRepo(")
    if repo.ptr == C_NULL
        print(io, "<closed>")
    else
        show(io, path(repo))
    end
    print(io, ")")
end

1	# This file is a part of Julia. License is MIT: https://julialang.org/license
2
3	"""
4	LibGit2.GitRepo(path::AbstractString)
5
6	Open a git repository at `path`.
7	"""
8	function GitRepo(path::AbstractString)	×
9	ensure_initialized()	×
10	repo_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	×
11	@check ccall((:git_repository_open, :libgit2), Cint,	×
12	(Ptr{Ptr{Cvoid}}, Cstring), repo_ptr_ptr, path)
13	return GitRepo(repo_ptr_ptr[])	×
14	end
15
16	"""
17	LibGit2.GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))
18
19	Open a git repository at `path` with extended controls (for instance, if the current
20	user must be a member of a special access group to read `path`).
21	"""
22	function GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))	78✔
23	ensure_initialized()	78✔
24	separator = @static Sys.iswindows() ? ";" : ":"	39✔
25	repo_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	39✔
26	@check ccall((:git_repository_open_ext, :libgit2), Cint,	39✔
27	(Ptr{Ptr{Cvoid}}, Cstring, Cuint, Cstring),
28	repo_ptr_ptr, path, flags, separator)
29	return GitRepo(repo_ptr_ptr[])	18✔
30	end
31
32	function cleanup(r::GitRepo)	×
33	if r.ptr != C_NULL	×
34	ensure_initialized()	×
35	@check ccall((:git_repository__cleanup, :libgit2), Cint, (Ptr{Cvoid},), r.ptr)	×
36	end
37	end
38
39	"""
40	LibGit2.init(path::AbstractString, bare::Bool=false) -> GitRepo
41
42	Open a new git repository at `path`. If `bare` is `false`,
43	the working tree will be created in `path/.git`. If `bare`
44	is `true`, no working directory will be created.
45	"""
46	function init(path::AbstractString, bare::Bool=false)	×
47	ensure_initialized()	×
48	repo_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	×
49	@check ccall((:git_repository_init, :libgit2), Cint,	×
50	(Ptr{Ptr{Cvoid}}, Cstring, Cuint), repo_ptr_ptr, path, bare)
51	return GitRepo(repo_ptr_ptr[])	×
52	end
53
54	"""
55	LibGit2.head_oid(repo::GitRepo) -> GitHash
56
57	Lookup the object id of the current HEAD of git
58	repository `repo`.
59	"""
60	function head_oid(repo::GitRepo)	18✔
61	head_ref = head(repo)	18✔
62	try	18✔
63	return GitHash(head_ref)	18✔
64	finally
65	close(head_ref)	18✔
66	end
67	end
68
69	"""
70	LibGit2.headname(repo::GitRepo)
71
72	Lookup the name of the current HEAD of git
73	repository `repo`. If `repo` is currently
74	detached, return the name of the HEAD it's
75	detached from.
76	"""
77	function headname(repo::GitRepo)	×
78	with(head(repo)) do href	×
79	if isattached(repo)	×
80	shortname(href)	×
81	else
82	"(detached from $(string(GitHash(href))[1:7]))"	×
83	end
84	end
85	end
86
87	"""
88	isbare(repo::GitRepo) -> Bool
89
90	Determine if `repo` is bare. Suppose the top level directory of `repo` is `DIR`.
91	A non-bare repository is one in which the git directory (see [`gitdir`](@ref)) is
92	`DIR/.git`, and the working tree can be checked out. A bare repository is one in
93	which all of git's administrative files are simply in `DIR`, rather than "hidden"
94	in the `.git` subdirectory. This means that there is nowhere to check out the working
95	tree, and no tracking information for remote branches or configurations is present.
96	"""
97	function isbare(repo::GitRepo)	×
98	ensure_initialized()	18✔
99	@assert repo.ptr != C_NULL	18✔
100	return ccall((:git_repository_is_bare, :libgit2), Cint, (Ptr{Cvoid},), repo.ptr) == 1	18✔
101	end
102
103	"""
104	isattached(repo::GitRepo) -> Bool
105
106	Determine if `repo` is detached - that is, whether its HEAD points to a commit
107	(detached) or whether HEAD points to a branch tip (attached).
108	"""
109	function isattached(repo::GitRepo)	×
110	ensure_initialized()	×
111	@assert repo.ptr != C_NULL	×
112	ccall((:git_repository_head_detached, :libgit2), Cint, (Ptr{Cvoid},), repo.ptr) != 1	×
113	end
114
115	@doc """
116	GitObject(repo::GitRepo, hash::AbstractGitHash)
117	GitObject(repo::GitRepo, spec::AbstractString)
118
119	Return the specified object ([`GitCommit`](@ref), [`GitBlob`](@ref), [`GitTree`](@ref) or [`GitTag`](@ref)) from `repo`
120	specified by `hash`/`spec`.
121
122	- `hash` is a full (`GitHash`) or partial (`GitShortHash`) hash.
123	- `spec` is a textual specification: see [the git docs](https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions) for a full list.
124	""" GitObject
125
126	for T in (:GitCommit, :GitBlob, :GitTree, :GitTag)
127	@eval @doc $"""
128	$T(repo::GitRepo, hash::AbstractGitHash)
129	$T(repo::GitRepo, spec::AbstractString)
130
131	Return a `$T` object from `repo` specified by `hash`/`spec`.
132
133	- `hash` is a full (`GitHash`) or partial (`GitShortHash`) hash.
134	- `spec` is a textual specification: see [the git docs](https://git-scm.com/docs/git-rev-parse.html#_specifying_revisions) for a full list.
135	""" $T
136	end
137
138	function (::Type{T})(repo::GitRepo, spec::AbstractString) where T<:GitObject	×
139	ensure_initialized()	×
140	obj_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	×
141	@assert repo.ptr != C_NULL	×
142	@check ccall((:git_revparse_single, :libgit2), Cint,	×
143	(Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cstring), obj_ptr_ptr, repo.ptr, spec)
144	# check object is of correct type
145	if T != GitObject && T != GitUnknownObject	×
146	t = Consts.OBJECT(obj_ptr_ptr[])	×
147	t == Consts.OBJECT(T) \|\| throw(GitError(Error.Object, Error.ERROR, "Expected object of type $T, received object of type $(objtype(t))"))	×
148	end
149	return T(repo, obj_ptr_ptr[])	×
150	end
151
152	function (::Type{T})(repo::GitRepo, oid::GitHash) where T<:GitObject	×
153	ensure_initialized()	×
154	oid_ptr = Ref(oid)	×
155	obj_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	×
156
157	@assert repo.ptr != C_NULL	×
158	@check ccall((:git_object_lookup, :libgit2), Cint,	×
159	(Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{GitHash}, Consts.OBJECT),
160	obj_ptr_ptr, repo.ptr, oid_ptr, Consts.OBJECT(T))
161
162	return T(repo, obj_ptr_ptr[])	×
163	end
164	function (::Type{T})(repo::GitRepo, oid::GitShortHash) where T<:GitObject	×
165	ensure_initialized()	×
166	oid_ptr = Ref(oid.hash)	×
167	obj_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	×
168
169	@assert repo.ptr != C_NULL	×
170	@check ccall((:git_object_lookup_prefix, :libgit2), Cint,	×
171	(Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{GitHash}, Csize_t, Consts.OBJECT),
172	obj_ptr_ptr, repo.ptr, oid_ptr, oid.len, Consts.OBJECT(T))
173
174	return T(repo, obj_ptr_ptr[])	×
175	end
176
177	# TODO: deprecate this function
178	revparseid(repo::GitRepo, spec) = GitHash(GitUnknownObject(repo, spec))	×
179
180	"""
181	LibGit2.gitdir(repo::GitRepo)
182
183	Return the location of the "git" files of `repo`:
184
185	- for normal repositories, this is the location of the `.git` folder.
186	- for bare repositories, this is the location of the repository itself.
187
188	See also [`workdir`](@ref), [`path`](@ref).
189	"""
190	function gitdir(repo::GitRepo)	18✔
191	ensure_initialized()	18✔
192	@assert repo.ptr != C_NULL	18✔
193	return unsafe_string(ccall((:git_repository_path, :libgit2), Cstring,	18✔
194	(Ptr{Cvoid},), repo.ptr))
195	end
196
197	"""
198	LibGit2.workdir(repo::GitRepo)
199
200	Return the location of the working directory of `repo`.
201	This will throw an error for bare repositories.
202
203	!!! note
204
205	This will typically be the parent directory of `gitdir(repo)`, but can be different in
206	some cases: e.g. if either the `core.worktree` configuration variable or the
207	`GIT_WORK_TREE` environment variable is set.
208
209	See also [`gitdir`](@ref), [`path`](@ref).
210	"""
211	function workdir(repo::GitRepo)	×
212	ensure_initialized()	×
213	@assert repo.ptr != C_NULL	×
214	sptr = ccall((:git_repository_workdir, :libgit2), Cstring,	×
215	(Ptr{Cvoid},), repo.ptr)
216	sptr == C_NULL && throw(GitError(Error.Object, Error.ERROR, "No working directory found."))	×
217	return unsafe_string(sptr)	×
218	end
219
220	"""
221	LibGit2.path(repo::GitRepo)
222
223	Return the base file path of the repository `repo`.
224
225	- for normal repositories, this will typically be the parent directory of the ".git"
226	directory (note: this may be different than the working directory, see `workdir` for
227	more details).
228	- for bare repositories, this is the location of the "git" files.
229
230	See also [`gitdir`](@ref), [`workdir`](@ref).
231	"""
232	function path(repo::GitRepo)	18✔
233	d = gitdir(repo)	18✔
234	if isdirpath(d)	18✔
235	d = dirname(d) # strip trailing separator	18✔
236	end
237	if isbare(repo)	18✔
238	return d	×
239	else
240	parent, base = splitdir(d)	18✔
241	return base == ".git" ? parent : d	18✔
242	end
243	end
244
245	"""
246	peel([T,] obj::GitObject)
247
248	Recursively peel `obj` until an object of type `T` is obtained. If no `T` is provided,
249	then `obj` will be peeled until the type changes.
250
251	- A `GitTag` will be peeled to the object it references.
252	- A `GitCommit` will be peeled to a `GitTree`.
253	"""
254	function peel(::Type{T}, obj::GitObject) where T<:GitObject	×
255	ensure_initialized()	×
256	new_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	×
257
258	@check ccall((:git_object_peel, :libgit2), Cint,	×
259	(Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Cint), new_ptr_ptr, obj.ptr, Consts.OBJECT(T))
260
261	return T(obj.owner, new_ptr_ptr[])	×
262	end
263	peel(obj::GitObject) = peel(GitObject, obj)	×
264
265	"""
266	LibGit2.GitDescribeResult(committish::GitObject; kwarg...)
267
268	Produce a `GitDescribeResult` of the `committish` `GitObject`, which
269	contains detailed information about it based on the keyword argument:
270
271	* `options::DescribeOptions=DescribeOptions()`
272
273	A git description of a `committish` object looks for the tag (by default, annotated,
274	although a search of all tags can be performed) which can be reached from `committish`
275	which is most recent. If the tag is pointing to `committish`, then only the tag is
276	included in the description. Otherwise, a suffix is included which contains the
277	number of commits between `committish` and the most recent tag. If there is no such
278	tag, the default behavior is for the description to fail, although this can be
279	changed through `options`.
280
281	Equivalent to `git describe <committish>`. See [`DescribeOptions`](@ref) for more
282	information.
283	"""
284	function GitDescribeResult(committish::GitObject;	×
285	options::DescribeOptions=DescribeOptions())
286	ensure_initialized()	×
287	result_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	×
288	@check ccall((:git_describe_commit, :libgit2), Cint,	×
289	(Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{DescribeOptions}),
290	result_ptr_ptr, committish.ptr, Ref(options))
291	return GitDescribeResult(committish.owner, result_ptr_ptr[])	×
292	end
293
294	"""
295	LibGit2.GitDescribeResult(repo::GitRepo; kwarg...)
296
297	Produce a `GitDescribeResult` of the repository `repo`'s working directory.
298	The `GitDescribeResult` contains detailed information about the workdir based
299	on the keyword argument:
300
301	* `options::DescribeOptions=DescribeOptions()`
302
303	In this case, the description is run on HEAD, producing the most recent tag
304	which is an ancestor of HEAD. Afterwards, a status check on
305	the [`workdir`](@ref) is performed and if the `workdir` is dirty
306	(see [`isdirty`](@ref)) the description is also considered dirty.
307
308	Equivalent to `git describe`. See [`DescribeOptions`](@ref) for more
309	information.
310	"""
311	function GitDescribeResult(repo::GitRepo; options::DescribeOptions=DescribeOptions())	×
312	ensure_initialized()	×
313	result_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	×
314	@assert repo.ptr != C_NULL	×
315	@check ccall((:git_describe_workdir, :libgit2), Cint,	×
316	(Ptr{Ptr{Cvoid}}, Ptr{Cvoid}, Ptr{DescribeOptions}),
317	result_ptr_ptr, repo.ptr, Ref(options))
318	return GitDescribeResult(repo, result_ptr_ptr[])	×
319	end
320
321	"""
322	LibGit2.format(result::GitDescribeResult; kwarg...) -> String
323
324	Produce a formatted string based on a `GitDescribeResult`.
325	Formatting options are controlled by the keyword argument:
326
327	* `options::DescribeFormatOptions=DescribeFormatOptions()`
328	"""
329	function format(result::GitDescribeResult; options::DescribeFormatOptions=DescribeFormatOptions())	×
330	ensure_initialized()	×
331	buf_ref = Ref(Buffer())	×
332	@check ccall((:git_describe_format, :libgit2), Cint,	×
333	(Ptr{Buffer}, Ptr{Cvoid}, Ptr{DescribeFormatOptions}),
334	buf_ref, result.ptr, Ref(options))
335	buf = buf_ref[]	×
336	str = unsafe_string(buf.ptr, buf.size)	×
337	free(buf_ref)	×
338	return str	×
339	end
340
341	function Base.show(io::IO, result::GitDescribeResult)	×
342	fmt_desc = format(result)	×
343	println(io, "GitDescribeResult:")	×
344	println(io, fmt_desc)	×
345	end
346
347	"""
348	checkout_tree(repo::GitRepo, obj::GitObject; options::CheckoutOptions = CheckoutOptions())
349
350	Update the working tree and index of `repo` to match the tree pointed to by `obj`.
351	`obj` can be a commit, a tag, or a tree. `options` controls how the checkout will
352	be performed. See [`CheckoutOptions`](@ref) for more information.
353	"""
354	function checkout_tree(repo::GitRepo, obj::GitObject;	×
355	options::CheckoutOptions = CheckoutOptions())
356	ensure_initialized()	×
357	@assert repo.ptr != C_NULL	×
358	@check ccall((:git_checkout_tree, :libgit2), Cint,	×
359	(Ptr{Cvoid}, Ptr{Cvoid}, Ptr{CheckoutOptions}),
360	repo.ptr, obj.ptr, Ref(options))
361	end
362
363	"""
364	checkout_index(repo::GitRepo, idx::Union{GitIndex, Nothing} = nothing; options::CheckoutOptions = CheckoutOptions())
365
366	Update the working tree of `repo` to match the index `idx`. If `idx` is `nothing`, the
367	index of `repo` will be used. `options` controls how the checkout will be performed.
368	See [`CheckoutOptions`](@ref) for more information.
369	"""
370	function checkout_index(repo::GitRepo, idx::Union{GitIndex, Nothing} = nothing;	×
371	options::CheckoutOptions = CheckoutOptions())
372	ensure_initialized()	×
373	@assert repo.ptr != C_NULL	×
374	@check ccall((:git_checkout_index, :libgit2), Cint,	×
375	(Ptr{Cvoid}, Ptr{Cvoid}, Ptr{CheckoutOptions}),
376	repo.ptr,
377	idx === nothing ? C_NULL : idx.ptr,
378	Ref(options))
379	end
380
381	"""
382	checkout_head(repo::GitRepo; options::CheckoutOptions = CheckoutOptions())
383
384	Update the index and working tree of `repo` to match the commit pointed to by HEAD.
385	`options` controls how the checkout will be performed. See [`CheckoutOptions`](@ref) for more information.
386
387	!!! warning
388	Do not use this function to switch branches! Doing so will cause checkout
389	conflicts.
390	"""
391	function checkout_head(repo::GitRepo; options::CheckoutOptions = CheckoutOptions())	×
392	ensure_initialized()	×
393	@assert repo.ptr != C_NULL	×
394	@check ccall((:git_checkout_head, :libgit2), Cint,	×
395	(Ptr{Cvoid}, Ptr{CheckoutOptions}),
396	repo.ptr, Ref(options))
397	end
398
399	"""
400	LibGit2.cherrypick(repo::GitRepo, commit::GitCommit; options::CherrypickOptions = CherrypickOptions())
401
402	Cherrypick the commit `commit` and apply the changes in it to the current state of `repo`.
403	The keyword argument `options` sets checkout and merge options for the cherrypick.
404
405	!!! note
406	`cherrypick` will apply the changes in `commit` but not commit them, so `repo` will
407	be left in a dirty state. If you want to also commit the changes in `commit` you must
408	call [`commit`](@ref) yourself.
409	"""
410	function cherrypick(repo::GitRepo, commit::GitCommit; options::CherrypickOptions = CherrypickOptions())	×
411	ensure_initialized()	×
412	@assert repo.ptr != C_NULL	×
413	@check ccall((:git_cherrypick, :libgit2), Cint,	×
414	(Ptr{Cvoid}, Ptr{Cvoid}, Ptr{CherrypickOptions}),
415	repo.ptr, commit.ptr, Ref(options))
416	end
417
418	"""Updates some entries, determined by the `pathspecs`, in the index from the target commit tree."""
419	function reset!(repo::GitRepo, obj::Union{GitObject, Nothing}, pathspecs::AbstractString...)	×
420	ensure_initialized()	×
421	@assert repo.ptr != C_NULL	×
422	@check ccall((:git_reset_default, :libgit2), Cint,	×
423	(Ptr{Cvoid}, Ptr{Cvoid}, Ptr{StrArrayStruct}),
424	repo.ptr,
425	obj === nothing ? C_NULL : obj.ptr,
426	collect(pathspecs))
427	return head_oid(repo)	×
428	end
429
430	"""Sets the current head to the specified commit oid and optionally resets the index and working tree to match."""
431	function reset!(repo::GitRepo, obj::GitObject, mode::Cint;	×
432	checkout_opts::CheckoutOptions = CheckoutOptions())
433	ensure_initialized()	×
434	@assert repo.ptr != C_NULL	×
435	@check ccall((:git_reset, :libgit2), Cint,	×
436	(Ptr{Cvoid}, Ptr{Cvoid}, Cint, Ptr{CheckoutOptions}),
437	repo.ptr, obj.ptr, mode, Ref(checkout_opts))
438	return head_oid(repo)	×
439	end
440
441	"""
442	clone(repo_url::AbstractString, repo_path::AbstractString, clone_opts::CloneOptions)
443
444	Clone the remote repository at `repo_url` (which can be a remote URL or a path on the local
445	filesystem) to `repo_path` (which must be a path on the local filesystem). Options for the
446	clone, such as whether to perform a bare clone or not, are set by [`CloneOptions`](@ref).
447
448	# Examples
449	```julia
450	repo_url = "https://github.com/JuliaLang/Example.jl"
451	repo = LibGit2.clone(repo_url, "/home/me/projects/Example")
452	```
453	"""
454	function clone(repo_url::AbstractString, repo_path::AbstractString,	5✔
455	clone_opts::CloneOptions)
456	ensure_initialized()	5✔
457	clone_opts_ref = Ref(clone_opts)	5✔
458	repo_ptr_ptr = Ref{Ptr{Cvoid}}(C_NULL)	5✔
459	@check ccall((:git_clone, :libgit2), Cint,	5✔
460	(Ptr{Ptr{Cvoid}}, Cstring, Cstring, Ref{CloneOptions}),
461	repo_ptr_ptr, repo_url, repo_path, clone_opts_ref)
462	return GitRepo(repo_ptr_ptr[])	2✔
463	end
464
465	"""
466	fetchheads(repo::GitRepo) -> Vector{FetchHead}
467
468	Return the list of all the fetch heads for `repo`, each represented as a [`FetchHead`](@ref),
469	including their names, URLs, and merge statuses.
470
471	# Examples
472	```julia-repl
473	julia> fetch_heads = LibGit2.fetchheads(repo);
474
475	julia> fetch_heads[1].name
476	"refs/heads/master"
477
478	julia> fetch_heads[1].ismerge
479	true
480
481	julia> fetch_heads[2].name
482	"refs/heads/test_branch"
483
484	julia> fetch_heads[2].ismerge
485	false
486	```
487	"""
488	function fetchheads(repo::GitRepo)	×
489	ensure_initialized()	×
490	fh = FetchHead[]	×
491	ffcb = fetchhead_foreach_cb()	×
492	@assert repo.ptr != C_NULL	×
493	@check ccall((:git_repository_fetchhead_foreach, :libgit2), Cint,	×
494	(Ptr{Cvoid}, Ptr{Cvoid}, Any),
495	repo.ptr, ffcb, fh)
496	return fh	×
497	end
498
499	"""
500	LibGit2.remotes(repo::GitRepo)
501
502	Return a vector of the names of the remotes of `repo`.
503	"""
504	function remotes(repo::GitRepo)	×
505	ensure_initialized()	×
506	sa_ref = Ref(StrArrayStruct())	×
507	@assert repo.ptr != C_NULL	×
508	@check ccall((:git_remote_list, :libgit2), Cint,	×
509	(Ptr{StrArrayStruct}, Ptr{Cvoid}), sa_ref, repo.ptr)
510	res = convert(Vector{String}, sa_ref[])	×
511	free(sa_ref)	×
512	return res	×
513	end
514
515	function Base.show(io::IO, repo::GitRepo)	×
516	print(io, "LibGit2.GitRepo(")	×
517	if repo.ptr == C_NULL	×
518	print(io, "<closed>")	×
519	else
520	show(io, path(repo))	×
521	end
522	print(io, ")")	×
523	end

JuliaLang / julia / #37474

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous