Improvements to libgit2

base/libgit2/blob.jl

@@ -1,5 +1,19 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+function GitBlob(path::AbstractString)
+    blob_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    apath = abspath(path)
+    ccall((:git_blob_create_fromdisk, :libgit2), Ptr{Void},
+                  (Ptr{Ptr{Void}}, Ptr{UInt8}), blob_ptr_ptr, apath)
+    blob_ptr_ptr == C_NULL && throw(Error.GitError(Error.ERROR))
+    return GitBlob(blob_ptr_ptr[])
+end
+
+function owner(blob::GitBlob)
+    repo_ptr = @check ccall((:git_blob_owner, :libgit2), Ptr{Void}, (Ptr{Void},), blob.ptr)
+    return GitRepo(repo_ptr)
+end
+
 function content(blob::GitBlob)
     return ccall((:git_blob_rawcontent, :libgit2), Ptr{Void}, (Ptr{Void},), blob.ptr)
 end

base/libgit2/diff.jl

@@ -36,9 +36,12 @@ function Base.count(diff::GitDiff)
 end
 
 function Base.getindex(diff::GitDiff, i::Csize_t)
+    if i < 1 || i > count(diff)
+        throw(BoundsError(diff, i))
+    end
     delta_ptr = ccall((:git_diff_get_delta, :libgit2), Ptr{Void},
                        (Ptr{Void}, Csize_t), diff.ptr, i-1)
-    delta_ptr == C_NULL && return nothing
+    delta_ptr == C_NULL && throw(BoundsError(diff, i))
     return unsafe_load(convert(Ptr{DiffDelta}, delta_ptr), 1)
 end
 Base.getindex(diff::GitDiff, i::Int) = getindex(diff, Csize_t(i))

base/libgit2/index.jl

@@ -112,9 +112,12 @@ function Base.count(idx::GitIndex)
 end
 
 function Base.getindex(idx::GitIndex, i::Csize_t)
+    if i < 1 || i > count(idx)
+        throw(BoundsError(idx,i))
+    end
     ie_ptr = ccall((:git_index_get_byindex, :libgit2), Ptr{Void},
                   (Ptr{Void}, Csize_t), idx.ptr, i-1)
-    ie_ptr == C_NULL && return nothing
+    ie_ptr == C_NULL && throw(BoundsError(idx,i))
     return unsafe_load(convert(Ptr{IndexEntry}, ie_ptr), 1)
 end
 Base.getindex(idx::GitIndex, i::Int) = getindex(idx, Csize_t(i))

base/libgit2/libgit2.jl

@@ -118,11 +118,13 @@ function diff_files(repo::GitRepo, branch1::AbstractString, branch2::AbstractStr
     return files
 end
 
+""" Determines if `b` is a child of `a`. `a` and `b` should be OIDs converted to `String`s. """
 function is_ancestor_of(a::AbstractString, b::AbstractString, repo::GitRepo)
     A = revparseid(repo, a)
     merge_base(repo, a, b) == A
 end
 
+""" Set a `remote`'s `url` for the `repo`, with default `remote` name `origin`. Uses SSH protocol, not HTTPS."""
 function set_remote_url(repo::GitRepo, url::AbstractString; remote::AbstractString="origin")
     with(GitConfig, repo) do cfg
         set!(cfg, "remote.$remote.url", url)
@@ -137,6 +139,7 @@ function set_remote_url(repo::GitRepo, url::AbstractString; remote::AbstractStri
     end
 end
 
+""" Set a `remote`'s `url` for the `repo` located at `path`, with default `remote` name `origin`. Uses SSH protocol, not HTTPS."""
 function set_remote_url(path::AbstractString, url::AbstractString; remote::AbstractString="origin")
     with(GitRepo, path) do repo
         set_remote_url(repo, url, remote=remote)
@@ -459,6 +462,8 @@ function authors(repo::GitRepo)
     end
 end
 
+""" Makes a record of the repository's current state so that it can be
+restored to that state later, if needed. """
 function snapshot(repo::GitRepo)
     head = Oid(repo, Consts.HEAD_FILE)
     index = with(GitIndex, repo) do idx; write_tree!(idx) end
@@ -480,6 +485,7 @@ function snapshot(repo::GitRepo)
     State(head, index, work)
 end
 
+""" Returns a repository to a state previously recorded with `snapshot`."""
 function restore(s::State, repo::GitRepo)
     reset!(repo, Consts.HEAD_FILE, "*")  # unstage everything
     with(GitIndex, repo) do idx

base/libgit2/rebase.jl

@@ -21,9 +21,12 @@ function current(rb::GitRebase)
 end
 
 function Base.getindex(rb::GitRebase, i::Csize_t)
+    if i < 1 || i > count(rb)
+        throw(BoundsError(rb,i))
+    end
     rb_op_ptr = ccall((:git_rebase_operation_byindex, :libgit2), Ptr{Void},
                        (Ptr{Void}, Csize_t), rb.ptr, i-1)
-    rb_op_ptr == C_NULL && return nothing
+    rb_op_ptr == C_NULL && throw(BoundsError(rb,i))
     return unsafe_load(convert(Ptr{RebaseOperation}, rb_op_ptr), 1)
 end
 Base.getindex(rb::GitRebase, i::Int) = getindex(rb, Csize_t(i))

base/libgit2/remote.jl

@@ -88,3 +88,9 @@ function push{T<:AbstractString}(rmt::GitRemote, refspecs::Vector{T};
         !no_refs && finalize(sa)
     end
 end
+
+function name(rmt::GitRemote)
+    str_ptr = ccall((:git_remote_name, :libgit2), Cstring, (Ptr{Void}, ), rmt.ptr)
+    str_ptr == C_NULL && return nothing
+    return unsafe_string(str_ptr)
+end

base/libgit2/status.jl

@@ -15,11 +15,11 @@ end
 
 function Base.getindex(status::GitStatus, i::Csize_t)
     if i < 1 || i > length(status)
-        throw(BoundsError())
+        throw(BoundsError(status,i))
     end
     entry_ptr = ccall((:git_status_byindex, :libgit2), Ptr{Void},
                        (Ptr{Void}, Csize_t), status.ptr, i-1)
-    entry_ptr == C_NULL && throw(Error.GitError(Error.ERROR))
+    entry_ptr == C_NULL && throw(BoundsError(status,i))
     return unsafe_load(convert(Ptr{StatusEntry}, entry_ptr), 1)
 end
 Base.getindex(status::GitStatus, i::Int) = getindex(status, Csize_t(i))

base/libgit2/tree.jl

@@ -18,8 +18,8 @@ end
 
 function filename(te::GitTreeEntry)
     str = ccall((:git_tree_entry_name, :libgit2), Cstring, (Ptr{Void},), te.ptr)
-    str != C_NULL && return unsafe_string(str)
-    return nothing
+    str == C_NULL && throw(Error.GitError(Error.ERROR))
+    return unsafe_string(str)
 end
 
 function filemode(te::GitTreeEntry)

base/libgit2/walker.jl

@@ -50,8 +50,8 @@ end
 
 function repository(w::GitRevWalker)
     ptr = ccall((:git_revwalk_repository, :libgit2), Ptr{Void}, (Ptr{Void},), w.ptr)
-    ptr != C_NULL && return GitRepo(ptr)
-    return  nothing
+    ptr == C_NULL && throw(Error.GitError(Error.ERROR))
+    return GitRepo(ptr)
 end
 
 function Base.map(f::Function, walker::GitRevWalker;

test/libgit2.jl

@@ -52,6 +52,16 @@ const LIBGIT2_VER = v"0.23.0"
     finally
         finalize(sa2)
     end
+    vs = vec([p1,p2])
+    sa4 = LibGit2.StrArrayStruct(vs)
+    try
+        arr3 = convert(Vector{AbstractString}, sa4)
+        @test arr3[1] == p1
+        @test arr3[2] == p2
+    finally
+        finalize(sa4)
+    end
+
 #end
 
 #@testset "Signature" begin
@@ -119,8 +129,30 @@ mktempdir() do dir
 
                 config = joinpath(cache_repo, ".git", "config")
                 lines = split(open(readstring, config, "r"), "\n")
-                @test any(map(x->x == "[remote \"upstream\"]", lines))
+                @test any(x->x == "[remote \"upstream\"]", lines)
+
+                remote = LibGit2.get(LibGit2.GitRemote, repo, branch)
+                @test LibGit2.url(remote) == repo_url
+                @test LibGit2.isattached(repo)
+                finalize(remote)
+            finally
+                finalize(repo)
+            end
+        #end
+
+        #@testset "with remote branch and refspec" begin
+            repo = LibGit2.init(cache_repo)
+            try
+                @test isdir(cache_repo)
+                @test isdir(joinpath(cache_repo, ".git"))
 
+                # set a remote branch
+                branch = "upstream2"
+                LibGit2.GitRemote(repo, branch, repo_url,"+refs/heads/$branch:refs/remotes/origin/$branch") |> finalize
+
+                config = joinpath(cache_repo, ".git", "config")
+                lines = split(open(readstring, config, "r"), "\n")
+                @test any(x->x == "[remote \"upstream\"]", lines)
                 remote = LibGit2.get(LibGit2.GitRemote, repo, branch)
                 @test LibGit2.url(remote) == repo_url
                 @test LibGit2.isattached(repo)
@@ -130,6 +162,24 @@ mktempdir() do dir
             end
         #end
 
+        #@testset "anonymous" begin
+            repo = LibGit2.init(cache_repo)
+            try
+                @test isdir(cache_repo)
+                @test isdir(joinpath(cache_repo, ".git"))
+
+                # set a remote branch
+                branch = "upstream3"
+                LibGit2.GitRemoteAnon(repo, repo_url) |> finalize
+
+                config = joinpath(cache_repo, ".git", "config")
+                lines = split(open(readstring, config, "r"), "\n")
+                @test any(x->x == "[remote \"upstream\"]", lines)
+            finally
+                finalize(repo)
+            end
+        #end
+
         #@testset "bare" begin
             path = joinpath(dir, "Example.Bare")
             repo = LibGit2.init(path, true)
@@ -177,6 +227,7 @@ mktempdir() do dir
                     @test LibGit2.fetch_refspecs(rmt)[1] == "+refs/*:refs/*"
                     @test LibGit2.isattached(repo)
                     @test LibGit2.remotes(repo) == ["origin"]
+                    @test LibGit2.name(rmt) == "origin"
                 finally
                     finalize(rmt)
                 end
@@ -229,6 +280,10 @@ mktempdir() do dir
                     @test auth.email == test_sig.email
                 end
 
+                @test LibGit2.iscommit(string(commit_oid1),repo)
+                @test LibGit2.iscommit(string(commit_oid2),repo)
+                @test LibGit2.is_ancestor_of(string(commit_oid1),string(commit_oid2),repo)
+                @test LibGit2.revcount(repo, string(commit_oid1), string(commit_oid2)) == (-1,1)
                 # lookup commits
                 cmt = LibGit2.get(LibGit2.GitCommit, repo, commit_oid1)
                 try