Attach finalizers to LibGit2 methods

base/deprecated.jl

@@ -1512,4 +1512,8 @@ unsafe_wrap(::Type{String}, p::Cstring, own::Bool=false) = unsafe_wrap(String, c
 unsafe_wrap(::Type{String}, p::Cstring, len::Integer, own::Bool=false) =
     unsafe_wrap(String, convert(Ptr{UInt8}, p), len, own)
 
+# #19660
+@deprecate finalize(sa::LibGit2.StrArrayStruct) close(sa)
+@deprecate finalize(sa::LibGit2.Buffer) close(sa)
+
 # End deprecations scheduled for 0.6

base/libgit2/callbacks.jl

@@ -14,11 +14,11 @@ function mirror_callback(remote::Ptr{Ptr{Void}}, repo_ptr::Ptr{Void},
     err != 0 && return Cint(err)
 
     # And set the configuration option to true for the push command
-    config = GitConfig(GitRepo(repo_ptr))
+    config = GitConfig(GitRepo(repo_ptr,false))
     name_str = unsafe_string(name)
     err= try set!(config, "remote.$name_str.mirror", true)
          catch -1
-         finally finalize(config)
+         finally close(config)
          end
     err != 0 && return Cint(err)
     return Cint(0)

base/libgit2/commit.jl

@@ -79,11 +79,11 @@ function commit(repo::GitRepo, msg::AbstractString;
         commit_id = commit(repo, refname, msg, auth_sig, comm_sig, tree, parents...)
     finally
         for parent in parents
-            finalize(parent)
+            close(parent)
         end
-        finalize(tree)
-        finalize(auth_sig)
-        finalize(comm_sig)
+        close(tree)
+        close(auth_sig)
+        close(comm_sig)
     end
     return commit_id
 end

base/libgit2/config.jl

@@ -10,17 +10,17 @@ function GitConfig(path::AbstractString,
     try
         addfile(cfg, path, level, force)
     catch ex
-        finalize(cfg)
-        throw(ex)
+        close(cfg)
+        rethrow(ex)
     end
     return cfg
 end
 
-function GitConfig(r::GitRepo)
+function GitConfig(repo::GitRepo)
     cfg_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_repository_config, :libgit2), Cint,
-                  (Ptr{Ptr{Void}}, Ptr{Void}), cfg_ptr_ptr, r.ptr)
-    return GitConfig(cfg_ptr_ptr[])
+                  (Ptr{Ptr{Void}}, Ptr{Void}), cfg_ptr_ptr, repo.ptr)
+    return GitConfig(repo, cfg_ptr_ptr[])
 end
 
 function GitConfig(level::Consts.GIT_CONFIG = Consts.CONFIG_LEVEL_DEFAULT)
@@ -37,7 +37,7 @@ function GitConfig(level::Consts.GIT_CONFIG = Consts.CONFIG_LEVEL_DEFAULT)
                           glb_cfg_ptr_ptr, cfg.ptr, Cint(level))
             cfg = GitConfig(glb_cfg_ptr_ptr[])
         finally
-            finalize(tmpcfg)
+            close(tmpcfg)
         end
     end
     return cfg

base/libgit2/diff.jl

@@ -18,17 +18,17 @@ function diff_tree(repo::GitRepo, tree::GitTree, pathspecs::AbstractString=""; c
                            diff_ptr_ptr, repo.ptr, tree.ptr, emptypathspec ? C_NULL : Ref(diff_opts))
         end
     finally
-        !emptypathspec && finalize(sa)
+        !emptypathspec && close(sa)
     end
-    return GitDiff(diff_ptr_ptr[])
+    return GitDiff(repo, diff_ptr_ptr[])
 end
 
 function diff_tree(repo::GitRepo, oldtree::GitTree, newtree::GitTree)
     diff_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_diff_tree_to_tree, :libgit2), Cint,
                   (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{DiffOptionsStruct}),
                    diff_ptr_ptr, repo.ptr, oldtree.ptr, newtree.ptr, C_NULL)
-    return GitDiff(diff_ptr_ptr[])
+    return GitDiff(repo, diff_ptr_ptr[])
 end
 
 function Base.count(diff::GitDiff)

base/libgit2/index.jl

@@ -4,7 +4,7 @@ function GitIndex(repo::GitRepo)
     idx_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_repository_index, :libgit2), Cint,
                  (Ptr{Ptr{Void}}, Ptr{Void}), idx_ptr_ptr, repo.ptr)
-    return GitIndex(idx_ptr_ptr[])
+    return GitIndex(repo, idx_ptr_ptr[])
 end
 
 function read!(idx::GitIndex, force::Bool = false)
@@ -25,9 +25,8 @@ function write_tree!(idx::GitIndex)
 end
 
 function owner(idx::GitIndex)
-    repo_ptr = ccall((:git_index_owner, :libgit2), Ptr{Void},
-                     (Ptr{Void},), idx.ptr)
-    return GitRepo(repo_ptr)
+    isnull(idx.nrepo) && throw(GitError(Error.Index, Error.ENOTFOUND, "Index does not have an owning repository."))
+    return Base.get(idx.nrepo)
 end
 
 function read_tree!(idx::GitIndex, tree_id::Oid)
@@ -37,7 +36,7 @@ function read_tree!(idx::GitIndex, tree_id::Oid)
         @check ccall((:git_index_read_tree, :libgit2), Cint,
                      (Ptr{Void}, Ptr{Void}), idx.ptr, tree.ptr)
     finally
-        finalize(tree)
+        close(tree)
     end
 end
 
@@ -49,7 +48,7 @@ function add!{T<:AbstractString}(idx::GitIndex, files::T...;
                      (Ptr{Void}, Ptr{StrArrayStruct}, Cuint, Ptr{Void}, Ptr{Void}),
                       idx.ptr, Ref(sa), flags, C_NULL, C_NULL)
     finally
-        finalize(sa)
+        close(sa)
     end
 end
 
@@ -60,7 +59,7 @@ function update!{T<:AbstractString}(idx::GitIndex, files::T...)
                      (Ptr{Void}, Ptr{StrArrayStruct}, Ptr{Void}, Ptr{Void}),
                       idx.ptr, Ref(sa), C_NULL, C_NULL)
     finally
-        finalize(sa)
+        close(sa)
     end
 end
 
@@ -71,7 +70,7 @@ function remove!{T<:AbstractString}(idx::GitIndex, files::T...)
                      (Ptr{Void}, Ptr{StrArrayStruct}, Ptr{Void}, Ptr{Void}),
                       idx.ptr, Ref(sa), C_NULL, C_NULL)
     finally
-        finalize(sa)
+        close(sa)
     end
 end
 

base/libgit2/libgit2.jl

@@ -63,7 +63,7 @@ function iscommit(id::AbstractString, repo::GitRepo)
         if c === nothing
             res = false
         else
-            finalize(c)
+            close(c)
         end
     catch
         res = false
@@ -84,11 +84,11 @@ function isdiff(repo::GitRepo, treeish::AbstractString, paths::AbstractString=""
     try
         diff = diff_tree(repo, tree, paths)
         result = count(diff) > 0
-        finalize(diff)
+        close(diff)
     catch err
         result = true
     finally
-        finalize(tree)
+        close(tree)
     end
     return result
 end
@@ -110,10 +110,10 @@ function diff_files(repo::GitRepo, branch1::AbstractString, branch2::AbstractStr
                 push!(files, unsafe_string(delta.new_file.path))
             end
         end
-        finalize(diff)
+        close(diff)
     finally
-        finalize(tree1)
-        finalize(tree2)
+        close(tree1)
+        close(tree2)
     end
     return files
 end
@@ -163,7 +163,7 @@ function fetch{T<:AbstractString, P<:AbstractCredentials}(repo::GitRepo;
         fo = FetchOptions(callbacks=RemoteCallbacks(credentials_cb(), payload))
         fetch(rmt, refspecs, msg="from $(url(rmt))", options = fo)
     finally
-        finalize(rmt)
+        close(rmt)
     end
 end
 
@@ -184,7 +184,7 @@ function push{T<:AbstractString, P<:AbstractCredentials}(repo::GitRepo;
         push_opts=PushOptions(callbacks=RemoteCallbacks(credentials_cb(), payload))
         push(rmt, refspecs, force=force, options=push_opts)
     finally
-        finalize(rmt)
+        close(rmt)
     end
 end
 
@@ -194,7 +194,7 @@ function branch(repo::GitRepo)
     try
         branch(head_ref)
     finally
-        finalize(head_ref)
+        close(head_ref)
     end
 end
 
@@ -220,7 +220,7 @@ function branch!(repo::GitRepo, branch_name::AbstractString,
                 tmpcmt = with(peel(GitCommit, branch_rmt_ref)) do hrc
                     Oid(hrc)
                 end
-                finalize(branch_rmt_ref)
+                close(branch_rmt_ref)
                 tmpcmt
             end
         else
@@ -232,7 +232,7 @@ function branch!(repo::GitRepo, branch_name::AbstractString,
         try
             new_branch_ref = create_branch(repo, branch_name, cmt, force=force)
         finally
-            finalize(cmt)
+            close(cmt)
             new_branch_ref === nothing && throw(GitError(Error.Object, Error.ERROR, "cannot create branch `$branch_name` with `$commit_id`"))
             branch_ref = new_branch_ref
         end
@@ -260,7 +260,7 @@ function branch!(repo::GitRepo, branch_name::AbstractString,
             head!(repo, branch_ref)
         end
     finally
-        finalize(branch_ref)
+        close(branch_ref)
     end
     return
 end
@@ -296,15 +296,15 @@ function checkout!(repo::GitRepo, commit::AbstractString = "";
             obj_oid = Oid(peeled)
             ref = GitReference(repo, obj_oid, force=force,
                 msg="libgit2.checkout: moving from $head_name to $(string(obj_oid))")
-            finalize(ref)
+            close(ref)
 
             # checkout commit
             checkout_tree(repo, peeled, options = opts)
         finally
-            finalize(peeled)
+            close(peeled)
         end
     finally
-        finalize(obj)
+        close(obj)
     end
 end
 
@@ -335,7 +335,7 @@ function reset!(repo::GitRepo, committish::AbstractString, pathspecs::AbstractSt
     try
         reset!(repo, Nullable(obj), pathspecs...)
     finally
-        finalize(obj)
+        close(obj)
     end
 end
 
@@ -347,7 +347,7 @@ function reset!(repo::GitRepo, commit::Oid, mode::Cint = Consts.RESET_MIXED)
     try
         reset!(repo, obj, mode)
     finally
-        finalize(obj)
+        close(obj)
     end
 end
 
@@ -433,24 +433,26 @@ function merge!(repo::GitRepo;
                 return true
             else
                 with(head(repo)) do head_ref
-                    with(upstream(head_ref)) do tr_brn_ref
-                        if tr_brn_ref === nothing
-                            throw(GitError(Error.Merge, Error.ERROR,
-                                           "There is no tracking information for the current branch."))
-                        end
+                    tr_brn_ref = upstream(head_ref)
+                    if tr_brn_ref === nothing
+                        throw(GitError(Error.Merge, Error.ERROR,
+                                       "There is no tracking information for the current branch."))
+                    end
+                    try
                         [GitAnnotated(repo, tr_brn_ref)]
+                    finally
+                        close(tr_brn_ref)
                     end
                 end
             end
         end
     end
-
     try
         merge!(repo, upst_anns, fastforward,
                merge_opts=merge_opts,
                checkout_opts=checkout_opts)
     finally
-        map(finalize, upst_anns)
+        map(close, upst_anns)
     end
 end
 
@@ -474,12 +476,15 @@ function rebase!(repo::GitRepo, upstream::AbstractString="")
     with(head(repo)) do head_ref
         head_ann = GitAnnotated(repo, head_ref)
         upst_ann  = if isempty(upstream)
-            with(LibGit2.upstream(head_ref)) do brn_ref
-                if brn_ref === nothing
-                    throw(GitError(Error.Rebase, Error.ERROR,
-                                   "There is no tracking information for the current branch."))
-                end
+            brn_ref = LibGit2.upstream(head_ref)
+            if brn_ref === nothing
+                throw(GitError(Error.Rebase, Error.ERROR,
+                               "There is no tracking information for the current branch."))
+            end
+            try
                 GitAnnotated(repo, brn_ref)
+            finally
+                close(brn_ref)
             end
         else
             GitAnnotated(repo, upstream)
@@ -497,15 +502,15 @@ function rebase!(repo::GitRepo, upstream::AbstractString="")
                     abort(rbs)
                     rethrow(err)
                 finally
-                    finalize(rbs)
+                    close(rbs)
                 end
             finally
-                #!isnull(onto_ann) && finalize(get(onto_ann))
-                finalize(sig)
+                #!isnull(onto_ann) && close(get(onto_ann))
+                close(sig)
             end
         finally
-            finalize(upst_ann)
-            finalize(head_ann)
+            close(upst_ann)
+            close(head_ann)
         end
     end
     return nothing
@@ -563,7 +568,7 @@ function transact(f::Function, repo::GitRepo)
         restore(state, repo)
         rethrow()
     finally
-        finalize(repo)
+        close(repo)
     end
 end