private TreeEntry RetrieveFromPath(FilePath relativePath) { if (relativePath.IsNullOrEmpty()) { return(null); } using (var obj = new ObjectSafeWrapper(Id, repo)) { GitObjectSafeHandle objectPtr; int res = NativeMethods.git_tree_get_subtree(out objectPtr, obj.ObjectPtr, relativePath); if (res == (int)GitErrorCode.GIT_ENOTFOUND) { return(null); } Ensure.Success(res); string posixPath = relativePath.Posix; string filename = posixPath.Split('/').Last(); TreeEntrySafeHandle handle = NativeMethods.git_tree_entry_byname(objectPtr, filename); objectPtr.SafeDispose(); if (handle.IsInvalid) { return(null); } string parentPath = posixPath.Substring(0, posixPath.Length - filename.Length); return(new TreeEntry(handle, Id, repo, path.Combine(parentPath))); } }
private static DiffListSafeHandle BuildDiffListFromTreeAndComparer(Repository repo, ObjectId treeId, TreeComparisonHandleRetriever comparisonHandleRetriever) { using (var osw = new ObjectSafeWrapper(treeId, repo)) { return(BuildDiffListFromComparer(osw.ObjectPtr, comparisonHandleRetriever)); } }
private TreeEntry RetrieveFromPath(string relativePath) { Ensure.ArgumentNotNullOrEmptyString(relativePath, "relativePath"); using (var obj = new ObjectSafeWrapper(Id, repo)) { IntPtr objectPtr; int res = NativeMethods.git_tree_get_subtree(out objectPtr, obj.ObjectPtr, relativePath); if (res == (int)GitErrorCode.GIT_ENOTFOUND) { return(null); } Ensure.Success(res); IntPtr e = NativeMethods.git_tree_entry_byname(objectPtr, relativePath.Split('/').Last()); if (e == IntPtr.Zero) { return(null); } return(new TreeEntry(e, Id, repo)); } }
unsafe TreeEntry byIndex(ObjectSafeWrapper obj, uint i, ObjectId parentTreeId, Repository repo, string parentPath) { using (var entryHandle = Proxy.git_tree_entry_byindex(obj.ObjectPtr, i)) { return(new TreeEntry(entryHandle, parentTreeId, repo, parentPath)); } }
/// <summary> /// Stores the content of the <see cref = "Repository.Index" /> as a new <see cref = "Commit" /> into the repository. /// </summary> /// <param name = "message">The description of why a change was made to the repository.</param> /// <param name = "author">The <see cref = "Signature" /> of who made the change.</param> /// <param name = "committer">The <see cref = "Signature" /> of who added the change to the repository.</param> /// <returns>The generated <see cref = "Commit" />.</returns> public Commit Create(string message, Signature author, Signature committer) { Ensure.ArgumentNotNull(message, "message"); Ensure.ArgumentNotNull(author, "author"); Ensure.ArgumentNotNull(committer, "committer"); GitOid treeOid; int res = NativeMethods.git_tree_create_fromindex(out treeOid, repo.Index.Handle); string encoding = null; Ensure.Success(res); Reference head = repo.Refs["HEAD"]; GitOid commitOid; using (var treePtr = new ObjectSafeWrapper(new ObjectId(treeOid), repo)) using (ObjectSafeWrapper headPtr = RetrieveHeadCommitPtr(head)) { IntPtr[] parentPtrs = BuildArrayFrom(headPtr); res = NativeMethods.git_commit_create(out commitOid, repo.Handle, head.CanonicalName, author.Handle, committer.Handle, encoding, message, treePtr.ObjectPtr, parentPtrs.Count(), parentPtrs); } Ensure.Success(res); return(repo.Lookup <Commit>(new ObjectId(commitOid))); }
/// <summary> /// Replaces entries in the <see cref="Index"/> with entries from the specified <see cref="Tree"/>. /// <para> /// This overwrites all existing state in the <see cref="Index"/>. /// </para> /// </summary> /// <param name="source">The <see cref="Tree"/> to read the entries from.</param> public virtual void Replace(Tree source) { using (var obj = new ObjectSafeWrapper(source.Id, repo.Handle)) { Proxy.git_index_read_fromtree(this, obj.ObjectPtr); } }
internal Commit CreateCommit(string message, Signature author, Signature committer, Tree tree, IEnumerable <Commit> parents, string referenceName) { Ensure.ArgumentNotNull(message, "message"); Ensure.ArgumentNotNull(author, "author"); Ensure.ArgumentNotNull(committer, "committer"); Ensure.ArgumentNotNull(tree, "tree"); Ensure.ArgumentNotNull(parents, "parents"); IEnumerable <ObjectId> parentIds = parents.Select(p => p.Id); GitOid commitOid; using (var treePtr = new ObjectSafeWrapper(tree.Id, repo)) using (var parentObjectPtrs = new DisposableEnumerable <ObjectSafeWrapper>(parentIds.Select(id => new ObjectSafeWrapper(id, repo)))) using (SignatureSafeHandle authorHandle = author.BuildHandle()) using (SignatureSafeHandle committerHandle = committer.BuildHandle()) { string encoding = null; //TODO: Handle the encoding of the commit to be created IntPtr[] parentsPtrs = parentObjectPtrs.Select(o => o.ObjectPtr.DangerousGetHandle()).ToArray(); int res = NativeMethods.git_commit_create(out commitOid, repo.Handle, referenceName, authorHandle, committerHandle, encoding, message, treePtr.ObjectPtr, parentObjectPtrs.Count(), parentsPtrs); Ensure.Success(res); } return(repo.Lookup <Commit>(new ObjectId(commitOid))); }
private static GitObjectSafeHandle GetParentCommitHandle(uint i, ObjectSafeWrapper obj) { GitObjectSafeHandle parentCommit; Ensure.Success(NativeMethods.git_commit_parent(out parentCommit, obj.ObjectPtr, i)); return(parentCommit); }
internal ContentChanges(Repository repo, Blob oldBlob, Blob newBlob, GitDiffOptions options) { using (var osw1 = new ObjectSafeWrapper(oldBlob.Id, repo)) using (var osw2 = new ObjectSafeWrapper(newBlob.Id, repo)) { Ensure.Success(NativeMethods.git_diff_blobs(osw1.ObjectPtr, osw2.ObjectPtr, options, IntPtr.Zero, FileCallback, HunkCallback, LineCallback)); } }
private static IntPtr[] BuildArrayFrom(ObjectSafeWrapper headPtr) { if (headPtr.ObjectPtr == IntPtr.Zero) { return(new IntPtr[] { }); } return(new[] { headPtr.ObjectPtr }); }
internal void ReplaceContentWithTree(Tree tree) { using (var nativeTree = new ObjectSafeWrapper(tree.Id, repo)) { int res = NativeMethods.git_index_read_tree(Handle, nativeTree.ObjectPtr); Ensure.Success(res); UpdatePhysicalIndex(); } }
/// <summary> /// Returns an enumerator that iterates through the collection. /// </summary> /// <returns>An <see cref="IEnumerator{T}"/> object that can be used to iterate through the collection.</returns> public virtual IEnumerator <TreeEntry> GetEnumerator() { using (var obj = new ObjectSafeWrapper(Id, repo.Handle)) { for (uint i = 0; i < Count; i++) { yield return(byIndex(obj, i, Id, repo, path)); } } }
/// <summary> /// Returns an enumerator that iterates through the collection. /// </summary> /// <returns>An <see cref="IEnumerator{T}"/> object that can be used to iterate through the collection.</returns> public virtual IEnumerator <TreeEntry> GetEnumerator() { using (var obj = new ObjectSafeWrapper(Id, repo.Handle)) { for (uint i = 0; i < Count; i++) { TreeEntrySafeHandle handle = Proxy.git_tree_entry_byindex(obj.ObjectPtr, i); yield return(new TreeEntry(handle, Id, repo, path)); } } }
/// <summary> /// Returns an enumerator that iterates through the collection. /// </summary> /// <returns>An <see cref = "IEnumerator{T}" /> object that can be used to iterate through the collection.</returns> public IEnumerator <TreeEntry> GetEnumerator() { using (var obj = new ObjectSafeWrapper(Id, repo)) { for (uint i = 0; i < Count; i++) { IntPtr e = NativeMethods.git_tree_entry_byindex(obj.ObjectPtr, i); yield return(new TreeEntry(e, Id, repo)); } } }
private DiffListSafeHandle BuildDiffListFromTrees(ObjectId oldTree, ObjectId newTree) { using (var osw1 = new ObjectSafeWrapper(oldTree, repo)) using (var osw2 = new ObjectSafeWrapper(newTree, repo)) { DiffListSafeHandle diff; GitDiffOptions options = DefaultOptions; Ensure.Success(NativeMethods.git_diff_tree_to_tree(repo.Handle, options, osw1.ObjectPtr, osw2.ObjectPtr, out diff)); return(diff); } }
private IEnumerable <Commit> RetrieveParentsOfCommit(ObjectId oid) { using (var obj = new ObjectSafeWrapper(oid, repo)) { uint parentsCount = NativeMethods.git_commit_parentcount(obj.ObjectPtr); for (uint i = 0; i < parentsCount; i++) { IntPtr parentCommit; Ensure.Success(NativeMethods.git_commit_parent(out parentCommit, obj.ObjectPtr, i)); yield return((Commit)CreateFromPtr(parentCommit, ObjectIdOf(parentCommit), repo)); } } }
/// <summary> /// Create a new local branch with the specified name /// </summary> /// <param name = "name">The name of the branch.</param> /// <param name = "shaOrReferenceName">The target which can be sha or a canonical reference name.</param> /// <param name = "allowOverwrite">True to allow silent overwriting a potentially existing branch, false otherwise.</param> /// <returns></returns> public Branch Create(string name, string shaOrReferenceName, bool allowOverwrite = false) { Ensure.ArgumentNotNullOrEmptyString(name, "name"); ObjectId commitId = repo.LookupCommit(shaOrReferenceName).Id; using (var osw = new ObjectSafeWrapper(commitId, repo)) { GitOid oid; Ensure.Success(NativeMethods.git_branch_create(out oid, repo.Handle, name, osw.ObjectPtr, allowOverwrite)); } return(this[ShortToLocalName(name)]); }
private IEnumerable <Commit> RetrieveParentsOfCommit(ObjectId oid) { using (var obj = new ObjectSafeWrapper(oid, repo)) { uint parentsCount = NativeMethods.git_commit_parentcount(obj.ObjectPtr); for (uint i = 0; i < parentsCount; i++) { using (var parentCommit = GetParentCommitHandle(i, obj)) { yield return(BuildFromPtr(parentCommit, ObjectIdOf(parentCommit), repo)); } } } }
private ICollection <Commit> RetrieveParentsOfCommit(Repository repo, ObjectId commitId) { using (var obj = new ObjectSafeWrapper(commitId, repo.Handle)) { int parentsCount = _count.Value; var parents = new List <Commit>(parentsCount); for (uint i = 0; i < parentsCount; i++) { ObjectId parentCommitId = Proxy.git_commit_parent_id(obj.ObjectPtr, i); parents.Add(new Commit(repo, parentCommitId)); } return(parents); } }
public TreeEntry this[string name] { get { using (var obj = new ObjectSafeWrapper(Id, repo)) { IntPtr e = NativeMethods.git_tree_entry_byname(obj.ObjectPtr, name); if (e == IntPtr.Zero) { return(null); } return(new TreeEntry(e, Id, repo)); } } }
/// <summary> /// Creates a lightweight tag with the specified name. /// </summary> /// <param name = "name">The name.</param> /// <param name = "target">The target which can be sha or a canonical reference name.</param> /// <param name = "allowOverwrite">True to allow silent overwriting a potentially existing tag, false otherwise.</param> /// <returns></returns> public Tag Create(string name, string target, bool allowOverwrite = false) { Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNullOrEmptyString(target, "target"); GitObject objectToTag = repo.Lookup(target, GitObjectType.Any, LookUpOptions.ThrowWhenNoGitObjectHasBeenFound); int res; using (var objectPtr = new ObjectSafeWrapper(objectToTag.Id, repo)) { GitOid oid; res = NativeMethods.git_tag_create_lightweight(out oid, repo.Handle, name, objectPtr.ObjectPtr, allowOverwrite); } Ensure.Success(res); return(this[name]); }
/// <summary> /// Creates an annotated tag with the specified name. /// </summary> /// <param name = "name">The name.</param> /// <param name = "target">The target which can be sha or a canonical reference name.</param> /// <param name = "tagger">The tagger.</param> /// <param name = "message">The message.</param> /// <param name = "allowOverwrite">True to allow silent overwriting a potentially existing tag, false otherwise.</param> /// <returns></returns> public Tag Create(string name, string target, Signature tagger, string message, bool allowOverwrite = false) { Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNullOrEmptyString(target, "target"); Ensure.ArgumentNotNull(tagger, "tagger"); Ensure.ArgumentNotNull(message, "message"); GitObject objectToTag = RetrieveObjectToTag(target); int res; using (var objectPtr = new ObjectSafeWrapper(objectToTag.Id, repo)) { GitOid oid; res = NativeMethods.git_tag_create(out oid, repo.Handle, name, objectPtr.ObjectPtr, tagger.Handle, message, allowOverwrite); } Ensure.Success(res); return(this[name]); }
/// <summary> /// Find the best possible common ancestor given two <see cref = "Commit"/>s. /// </summary> /// <param name = "first">The first <see cref = "Commit"/>.</param> /// <param name = "second">The second <see cref = "Commit"/>.</param> /// <returns>The common ancestor or null if none found.</returns> public Commit FindCommonAncestor(Commit first, Commit second) { Ensure.ArgumentNotNull(first, "first"); Ensure.ArgumentNotNull(second, "second"); using (var osw1 = new ObjectSafeWrapper(first.Id, repo)) using (var osw2 = new ObjectSafeWrapper(second.Id, repo)) { GitOid ret; int result = NativeMethods.git_merge_base(out ret, repo.Handle, osw1.ObjectPtr, osw2.ObjectPtr); if (result == (int)GitErrorCode.GIT_ENOTFOUND) { return(null); } Ensure.Success(result); return(repo.Lookup <Commit>(new ObjectId(ret))); } }