rebased, moved libgit2 to base, updated to 0.23 & tests

base/REPL.jl

@@ -743,7 +743,7 @@ function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_rep
  complete = ShellCompletionProvider(repl),
  on_done = respond(repl, julia_prompt) do line
  line = strip(line)
- :(Pkg.LibGit2.repl_cmd($line))
+ :(LibGit2.repl_cmd($line))
  end)
 
  ################################# Stage II #############################

base/exports.jl

@@ -7,6 +7,7 @@ export
  Meta,
  Operators,
  Pkg,
+ LibGit2,
  Profile,
  Dates,
  Sys,

base/pkg/libgit2.jl → base/libgit2.jl

@@ -2,13 +2,9 @@
 
 module LibGit2
 
-import ...Pkg.PkgError
+import Base: merge!, cat
 
-export with, with_warn
-export GitRepo, GitConfig, GitIndex
-
-const GITHUB_REGEX =
- r"^(?:git@|git:https://|https://(?:[\w\.\+\-]+@)?)github.com[:/](([^/].+)/(.+?))(?:\.git)?$"i
+export with, GitRepo, GitConfig
 
 include("libgit2/const.jl")
 include("libgit2/types.jl")
@@ -29,19 +25,14 @@ include("libgit2/blob.jl")
 include("libgit2/diff.jl")
 include("libgit2/rebase.jl")
 include("libgit2/repl.jl")
-
+include("libgit2/utils.jl")
 
 immutable State
  head::Oid
  index::Oid
  work::Oid
 end
 
-function normalize_url(url::AbstractString)
- m = match(GITHUB_REGEX,url)
- m == nothing ? url : "https://github.com/$(m.captures[1]).git"
-end
-
 """Return HEAD Oid as string"""
 function head(pkg::AbstractString)
  with(GitRepo, pkg) do repo
@@ -115,22 +106,6 @@ function diff_files(repo::GitRepo, branch1::AbstractString, branch2::AbstractStr
  return files
 end
 
-function merge_base(one::AbstractString, two::AbstractString, repo::GitRepo)
- oid1_ptr = Ref(Oid(one))
- oid2_ptr = Ref(Oid(two))
- moid_ptr = Ref(Oid())
- moid = try
- @check ccall((:git_merge_base, :libgit2), Cint,
- (Ptr{Oid}, Ptr{Void}, Ptr{Oid}, Ptr{Oid}),
- moid_ptr, repo.ptr, oid1_ptr, oid2_ptr)
- moid_ptr[]
- catch e
- #warn("Pkg:",path(repo),"=>",e.msg)
- Oid()
- end
- return moid
-end
-
 function is_ancestor_of(a::AbstractString, b::AbstractString, repo::GitRepo)
  A = revparseid(repo, a)
  merge_base(a, b, repo) == A
@@ -187,9 +162,7 @@ function fetch{T<:AbstractString}(repo::GitRepo;
  GitRemoteAnon(repo, remoteurl)
  end
  try
- with(default_signature(repo)) do sig
- fetch(rmt, sig, refspecs, msg="from $(url(rmt))")
- end
+ fetch(rmt, refspecs, msg="from $(url(rmt))")
  catch err
  warn("fetch: $err")
  finally
@@ -209,9 +182,7 @@ function push{T<:AbstractString}(repo::GitRepo;
  GitRemoteAnon(repo, remoteurl)
  end
  try
- with(default_signature(repo)) do sig
- push(rmt, sig, refspecs, force=force, msg="to $(url(rmt))")
- end
+ push(rmt, refspecs, force=force, msg="to $(url(rmt))")
  catch err
  warn("push: $err")
  finally
@@ -222,13 +193,13 @@ end
 """ git branch """
 function branch(repo::GitRepo)
  head_ref = head(repo)
- brnch = ""
  try
- brnch = branch(head_ref)
+ branch(head_ref)
+ catch
+ ""
  finally
  finalize(head_ref)
  end
- return brnch
 end
 
 """ git checkout [-b|-B] <branch> [<start-point>] [--track <remote>/<branch>] """
@@ -306,8 +277,8 @@ function checkout!(repo::GitRepo, commit::AbstractString = "";
  try
  peeled = peel(obj, GitConst.OBJ_COMMIT)
  peeled == nothing && return
- opts = force ? CheckoutOptionsStruct(checkout_strategy = GitConst.CHECKOUT_FORCE) :
-  CheckoutOptionsStruct()
+ opts = force ? CheckoutOptions(checkout_strategy = GitConst.CHECKOUT_FORCE) :
+ CheckoutOptions()
  try
  # detach commit
  obj_oid = Oid(peeled)
@@ -327,24 +298,18 @@ function checkout!(repo::GitRepo, commit::AbstractString = "";
 end
 
 """ git clone [-b <branch>] [--bare] <url> <dir> """
-function clone(url::AbstractString, path::AbstractString;
- branch::AbstractString="",
- bare::Bool = false,
+function clone(repo_url::AbstractString, repo_path::AbstractString;
+ checkout_branch::AbstractString="",
+ isbare::Bool = false,
  remote_cb::Ptr{Void} = C_NULL)
  # setup colne options
- clone_opts = CloneOptionsStruct(
- bare = Int32(bare),
- checkout_branch = isempty(branch) ? Ptr{UInt8}(C_NULL) : pointer(branch),
+ clone_opts = CloneOptions(
+ bare = Int32(isbare),
+ checkout_branch = isempty(checkout_branch) ? Cstring_NULL :
+ convert(Cstring, pointer(checkout_branch)),
  remote_cb = remote_cb
  )
-
- # start cloning
- clone_opts_ref = Ref(clone_opts)
- repo_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
- @check ccall((:git_clone, :libgit2), Cint,
- (Ptr{Ptr{Void}}, Cstring, Cstring, Ref{CloneOptionsStruct}),
- repo_ptr_ptr, url, path, clone_opts_ref)
- return GitRepo(repo_ptr_ptr[])
+ return clone(repo_url, repo_path, clone_opts)
 end
 
 """ git reset [<committish>] [--] <pathspecs>... """
@@ -417,7 +382,7 @@ function merge!(repo::GitRepo, committish::AbstractString=""; fast_forward::Bool
  reset!(repo, brn_ref_oid, GitConst.RESET_HARD)
  elseif (ma & GitConst.MERGE_ANALYSIS_NORMAL == GitConst.MERGE_ANALYSIS_NORMAL)
  fast_forward && return false # do not do merge
- merge(repo, hua)
+ merge!(repo, hua)
  cleanup(repo)
  info("Review and commit merged changes.")
  else
@@ -507,7 +472,7 @@ function restore(s::State, repo::GitRepo)
  reset!(repo, GitConst.HEAD_FILE, "*") # unstage everything
  with(GitIndex, repo) do idx
  read_tree!(idx, s.work) # move work tree to index
- opts = CheckoutOptionsStruct(
+ opts = CheckoutOptions(
  checkout_strategy = GitConst.CHECKOUT_FORCE | # check the index out to work
  GitConst.CHECKOUT_REMOVE_UNTRACKED) # remove everything else
  checkout_index(repo, Nullable(idx), options = opts)
@@ -530,7 +495,7 @@ end
 
 function __init__()
  err = ccall((:git_libgit2_init, :libgit2), Cint, ())
- err > 0 || throw(PkgError("error initializing LibGit2 module"))
+ err > 0 || throw(ErrorException("error initializing LibGit2 module"))
  atexit() do
  ccall((:git_libgit2_shutdown, :libgit2), Cint, ())
  end

base/pkg/libgit2/commit.jl → base/libgit2/commit.jl

@@ -1,10 +1,10 @@
 # This file is a part of Julia. License is MIT: http:https://julialang.org/license
 
 function message(c::GitCommit, raw::Bool=false)
- local msg_ptr::Ptr{UInt8}
- msg_ptr = raw? ccall((:git_commit_message_raw, :libgit2), CString, (Ptr{Void},), c.ptr) :
- ccall((:git_commit_message, :libgit2), CString, (Ptr{Void},), c.ptr)
- if msg_ptr == C_NULL
+ local msg_ptr::Cstring
+ msg_ptr = raw? ccall((:git_commit_message_raw, :libgit2), Cstring, (Ptr{Void},), c.ptr) :
+ ccall((:git_commit_message, :libgit2), Cstring, (Ptr{Void},), c.ptr)
+ if msg_ptr == Cstring_NULL
  return nothing
  end
  return bytestring(msg_ptr)

base/pkg/libgit2/config.jl → base/libgit2/config.jl

@@ -3,7 +3,7 @@
 function GitConfig(path::AbstractString)
  cfg_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
  err = ccall((:git_config_open_ondisk, :libgit2), Cint,
- (Ptr{Ptr{Void}}, Ptr{UInt8}), cfg_ptr_ptr, path)
+ (Ptr{Ptr{Void}}, Cstring), cfg_ptr_ptr, path)
  err !=0 && return nothing
  return GitConfig(cfg_ptr_ptr[])
 end

base/pkg/libgit2/const.jl → base/libgit2/const.jl

@@ -40,8 +40,8 @@ module GitConst
  # checkout
  const CHECKOUT_NONE = Cuint(0)
  const CHECKOUT_SAFE = Cuint(1 << 0)
- const CHECKOUT_SAFE_CREATE = Cuint(1 << 1)
- const CHECKOUT_FORCE  = Cuint(1 << 2)
+ const CHECKOUT_FORCE  = Cuint(1 << 1)
+ const CHECKOUT_RECREATE_MISSING = Cuint(1 << 2)
  const CHECKOUT_ALLOW_CONFLICTS = Cuint(1 << 4)
  const CHECKOUT_REMOVE_UNTRACKED = Cuint(1 << 5)
  const CHECKOUT_REMOVE_IGNORED = Cuint(1 << 6)
@@ -54,6 +54,9 @@ module GitConst
  const CHECKOUT_DISABLE_PATHSPEC_MATCH = Cuint(1 << 13)
  const CHECKOUT_SKIP_LOCKED_DIRECTORIES = Cuint(1 << 18)
  const CHECKOUT_DONT_OVERWRITE_IGNORED = Cuint(1 << 19)
+ const CHECKOUT_CONFLICT_STYLE_MERGE = Cuint(1 << 20)
+ const CHECKOUT_CONFLICT_STYLE_DIFF3 = Cuint(1 << 21)
+ const CHECKOUT_DONT_REMOVE_EXISTING = Cuint(1 << 22)
 
  const CHECKOUT_UPDATE_SUBMODULES = Cuint(1 << 16)
  const CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED = Cuint(1 << 17)
@@ -191,4 +194,21 @@ module GitConst
  const CREDTYPE_SSH_KEY = Cuint(1 << 1)
  const CREDTYPE_SSH_CUSTOM = Cuint(1 << 2)
  const CREDTYPE_DEFAULT = Cuint(1 << 3)
+
+ # fetch_prune
+ const FETCH_PRUNE_UNSPECIFIED = Cint(0)
+ const FETCH_PRUNE = Cint(1)
+ const FETCH_NO_PRUNE = Cint(2)
+
+ # remote_autotag
+ const REMOTE_DOWNLOAD_TAGS_UNSPECIFIED = Cint(0)
+ const REMOTE_DOWNLOAD_TAGS_AUTO = Cint(1)
+ const REMOTE_DOWNLOAD_TAGS_NONE = Cint(2)
+ const REMOTE_DOWNLOAD_TAGS_ALL = Cint(3)
+
+ # clone
+ const CLONE_LOCAL_AUTO = Cint(0)
+ const CLONE_LOCAL = Cint(1)
+ const CLONE_NO_LOCAL = Cint(2)
+ const CLONE_LOCAL_NO_LINKS = Cint(3)
 end

base/pkg/libgit2/error.jl → base/libgit2/error.jl

@@ -23,9 +23,7 @@ module Error
  EPEEL = Cint(-19), # the requested peel operation is not possible
  PASSTHROUGH = Cint(-30), # internal only
  ITEROVER = Cint(-31)) # signals end of iteration
-
-Base.(:(==))(c::Code, e::Integer) = c.val == e
-Base.(:(==))(e::Integer, c::Code) = c.val == e
+Base.getindex(c::Code) = c.val
 
 @enum(Class, None,
  NoMemory,

base/pkg/libgit2/merge.jl → base/libgit2/merge.jl

@@ -41,12 +41,28 @@ function merge_analysis(repo::GitRepo, ann::GitAnnotated)
 end
 
 """ Merge changes into current head """
-function merge(repo::GitRepo, their_head::GitAnnotated;
+function merge!(repo::GitRepo, their_head::GitAnnotated;
  merge_opts = MergeOptionsStruct(),
- checkout_opts = CheckoutOptionsStruct(checkout_strategy = GitConst.CHECKOUT_SAFE))
+ checkout_opts = CheckoutOptions(checkout_strategy = GitConst.CHECKOUT_SAFE))
  return @check ccall((:git_merge, :libgit2), Cint,
  (Ptr{Void}, Ptr{Ptr{Void}}, Csize_t,
- Ptr{MergeOptionsStruct}, Ptr{CheckoutOptionsStruct}),
+ Ptr{MergeOptionsStruct}, Ptr{CheckoutOptions}),
  repo.ptr, Ref{Ptr{Void}}(their_head.ptr), 1,
  Ref(merge_opts), Ref(checkout_opts))
 end
+
+function merge_base(repo::GitRepo, one::AbstractString, two::AbstractString)
+ oid1_ptr = Ref(Oid(one))
+ oid2_ptr = Ref(Oid(two))
+ moid_ptr = Ref(Oid())
+ moid = try
+ @check ccall((:git_merge_base, :libgit2), Cint,
+ (Ptr{Oid}, Ptr{Void}, Ptr{Oid}, Ptr{Oid}),
+ moid_ptr, repo.ptr, oid1_ptr, oid2_ptr)
+ moid_ptr[]
+ catch e
+ #warn("Pkg:",path(repo),"=>",e.msg)
+ Oid()
+ end
+ return moid
+end

base/pkg/libgit2/rebase.jl → base/libgit2/rebase.jl

@@ -3,13 +3,13 @@
 function GitRebase(repo::GitRepo, branch::GitAnnotated, upstream::GitAnnotated;
  onto::Nullable{GitAnnotated}=Nullable{GitAnnotated}(),
  sig::Nullable{GitSignature}=Nullable{GitSignature}(),
- opts::RebaseOptionsStruct = RebaseOptionsStruct())
+ opts::RebaseOptions = RebaseOptions())
  rebase_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
  sig_obj = isnull(sig) ? default_signature(repo) : Base.get(sig)
  try
  @check ccall((:git_rebase_init, :libgit2), Cint,
  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}, Ptr{Void},
- Ptr{Void}, Ptr{SignatureStruct}, Ptr{RebaseOptionsStruct}),
+ Ptr{Void}, Ptr{SignatureStruct}, Ptr{RebaseOptions}),
  rebase_ptr_ptr, repo.ptr, branch.ptr, upstream.ptr,
  isnull(onto) ? C_NULL : Base.get(onto).ptr, sig_obj.ptr, Ref(opts))
  finally
@@ -34,21 +34,20 @@ function Base.getindex(rb::GitRebase, i::Csize_t)
 end
 Base.getindex(rb::GitRebase, i::Int) = getindex(rb, Csize_t(i))
 
-function Base.next(rb::GitRebase; opts::CheckoutOptionsStruct = CheckoutOptionsStruct())
+function Base.next(rb::GitRebase; opts::CheckoutOptions = CheckoutOptions())
  rb_op_ptr_ptr = Ref{Ptr{RebaseOperation}}(C_NULL)
  try
  @check ccall((:git_rebase_next, :libgit2), Cint,
- (Ptr{Ptr{RebaseOperation}}, Ptr{Void}, Ptr{CheckoutOptionsStruct}),
+ (Ptr{Ptr{RebaseOperation}}, Ptr{Void}, Ptr{CheckoutOptions}),
  rb_op_ptr_ptr, rb.ptr, Ref(opts))
  catch err
- err.code == Error.ITEROVER && return nothing
+ err.code == Error.ITEROVER[] && return nothing
  rethrow(err)
  end
  return unsafe_load(convert(Ptr{RebaseOperation}, rb_op_ptr_ptr[]), 1)
 end
 
-function commit(rb::GitRebase, sig::GitSignature;
- opts::CheckoutOptionsStruct = CheckoutOptionsStruct())
+function commit(rb::GitRebase, sig::GitSignature)
  oid_ptr = Ref(Oid())
  @check ccall((:git_rebase_commit, :libgit2), Cint,
  (Ptr{Oid}, Ptr{Void}, Ptr{SignatureStruct}, Ptr{SignatureStruct}, Ptr{UInt8}, Ptr{UInt8}),
@@ -61,8 +60,8 @@ function abort(rb::GitRebase, sig::GitSignature)
  (Ptr{Void}, Ptr{SignatureStruct}), rb.ptr, sig.ptr)
 end
 
-function finish(rb::GitRebase, sig::GitSignature; opts::RebaseOptionsStruct = RebaseOptionsStruct())
+function finish(rb::GitRebase, sig::GitSignature; opts::RebaseOptions = RebaseOptions())
  return ccall((:git_rebase_finish, :libgit2), Csize_t,
- (Ptr{Void}, Ptr{SignatureStruct}, Ptr{RebaseOptionsStruct}),
+ (Ptr{Void}, Ptr{SignatureStruct}, Ptr{RebaseOptions}),
  rb.ptr, sig.ptr, Ref(opts))
 end

base/pkg/libgit2/reference.jl → base/libgit2/reference.jl

@@ -53,9 +53,9 @@ function peel(ref::GitReference, obj_type::Cint)
  obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
  err = ccall((:git_reference_peel, :libgit2), Cint,
  (Ptr{Ptr{Void}}, Ptr{Void}, Cint), obj_ptr_ptr, ref.ptr, obj_type)
- if err == Error.ENOTFOUND
+ if err == Error.ENOTFOUND[]
  return Oid()
- elseif err != Error.GIT_OK
+ elseif err != Error.GIT_OK[]
  if obj_ptr_ptr[] != C_NULL
  finalize(GitAnyObject(obj_ptr_ptr[]))
  end
@@ -116,9 +116,9 @@ function lookup_branch(repo::GitRepo, branch_name::AbstractString, remote::Bool=
  err = ccall((:git_branch_lookup, :libgit2), Cint,
  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{UInt8}, Cint),
  ref_ptr_ptr, repo.ptr, branch_name, branch_type)
- if err == Error.ENOTFOUND
+ if err == Error.ENOTFOUND[]
  return nothing
- elseif err != Error.GIT_OK
+ elseif err != Error.GIT_OK[]
  if repo_ptr_ptr[] != C_NULL
  finalize(GitReference(ref_ptr_ptr[]))
  end