can create and delete branches

Author: tclem

LibGit2Sharp.Tests/BranchFixture.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 
@@ -9,6 +10,42 @@ public class BranchFixture
     {
         private readonly List<string> expectedBranches = new List<string> {"packed-test", "packed", "br2", "master", "test"};
 
+        [Test]
+        public void CanCreateBranch()
+        {
+            using (var path = new TemporaryRepositoryPath())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                const string name = "unit_test";
+                var newBranch = repo.Branches.Create(name, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+                newBranch.ShouldNotBeNull();
+                newBranch.Name.ShouldEqual(name);
+                newBranch.Reference.Target.ShouldNotBeNull();
+                newBranch.Reference.Target.Sha.ShouldEqual("be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+                repo.Branches.SingleOrDefault(p => p.Name == name).ShouldNotBeNull();
+
+                newBranch.Delete();
+            }
+        }
+
+        [Test]
+        public void CanCreateBranchFromAnotherBranch()
+        {
+            using (var path = new TemporaryRepositoryPath())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                const string name = "unit_test";
+                var newBranch = repo.Branches.Create(name, "master");
+                newBranch.ShouldNotBeNull();
+                newBranch.Name.ShouldEqual(name);
+                newBranch.Reference.Target.ShouldNotBeNull();
+                newBranch.Reference.Target.Sha.ShouldEqual("be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+                repo.Branches.SingleOrDefault(p => p.Name == name).ShouldNotBeNull();
+
+                newBranch.Delete();
+            }
+        }
+
         [Test]
         public void CanListAllBranches()
         {
@@ -56,5 +93,42 @@ public void CanWalkCommitsFromBranch()
                 master.Commits.Count().ShouldEqual(6);
             }
         }
+
+        [Test]
+        public void CreatingBranchWithEmptyNameThrows()
+        {
+            using (var repo = new Repository(Constants.TestRepoPath))
+            {
+                Assert.Throws<ArgumentException>(() => repo.Branches.Create(string.Empty, "not_important_sha"));
+            }
+        }
+
+        [Test]
+        public void CreatingBranchWithEmptyTargetThrows()
+        {
+            using (var repo = new Repository(Constants.TestRepoPath))
+            {
+                Assert.Throws<ArgumentException>(() => repo.Branches.Create("bad_branch", string.Empty));
+            }
+        }
+
+        [Test]
+        public void CreatingBranchWithNullNameThrows()
+        {
+            using (var repo = new Repository(Constants.TestRepoPath))
+            {
+                Assert.Throws<ArgumentNullException>(() => repo.Branches.Create(null, "not_important_sha"));
+            }
+        }
+
+        [Test]
+        public void CreatingBranchWithNullTargetThrows()
+        {
+            using (var repo = new Repository(Constants.TestRepoPath))
+            {
+                Assert.Throws<ArgumentNullException>(() => repo.Branches.Create("bad_branch", (string) null));
+                Assert.Throws<ArgumentNullException>(() => repo.Branches.Create("bad_branch", (ObjectId) null));
+            }
+        }
     }
 }

LibGit2Sharp/Branch.cs

@@ -59,17 +59,25 @@ internal static Branch CreateBranchFromReference(Reference reference, Repository
                 return new Branch(repo)
                            {
                                Name = tokens[tokens.Length - 1],
-                               Reference = (DirectReference) reference,
+                               Reference = reference.ResolveToDirectReference(),
                                Type = BranchType.Local
                            };
             }
             return new Branch(repo)
                        {
                            Name = string.Join("/", tokens, tokens.Length - 2, 2),
                            RemoteName = tokens[tokens.Length - 2],
-                           Reference = (DirectReference) reference,
+                           Reference = reference.ResolveToDirectReference(),
                            Type = BranchType.Remote
                        };
         }
+
+        /// <summary>
+        /// Deletes this branch.
+        /// </summary>
+        public void Delete()
+        {
+            Reference.Delete();
+        }
     }
 }

LibGit2Sharp/BranchCollection.cs

@@ -27,19 +27,7 @@ public BranchCollection(Repository repo)
         /// </summary>
         public Branch this[string name]
         {
-            get
-            {
-                var tokens = name.Split('/');
-                if (tokens.Length == 1)
-                {
-                    return Branch.CreateBranchFromReference(repo.Refs[string.Format(CultureInfo.InvariantCulture, "refs/heads/{0}", name)], repo);
-                }
-                if (tokens.Length == 2)
-                {
-                    return Branch.CreateBranchFromReference(repo.Refs[string.Format(CultureInfo.InvariantCulture, "refs/{0}", name)], repo);
-                }
-                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Unable to parse branch name: {0}. Expecting local branches in the form <branchname> and remotes in the form <remote>/<branchname>.", name));
-            }
+            get { return Branch.CreateBranchFromReference(repo.Refs[ParseName(name)], repo); }
         }
 
         #region IEnumerable<Branch> Members
@@ -59,10 +47,70 @@ IEnumerator IEnumerable.GetEnumerator()
 
         #endregion
 
+        /// <summary>
+        ///   Create a new local branch with the specified name
+        /// </summary>
+        /// <param name = "name">The name of the branch.</param>
+        /// <param name = "target">The target sha, ref or branch name.</param>
+        /// <returns></returns>
+        public Branch Create(string name, string target)
+        {
+            Ensure.ArgumentNotNullOrEmptyString(target, "target");
+
+            GitOid oid;
+            if(NativeMethods.git_oid_mkstr(out oid, target) == (int)GitErrorCode.GIT_SUCCESS)
+            {
+                return Create(name, new ObjectId(oid));
+            }
+
+            var reference = repo.Refs.Create(EnsureValidBranchName(name), ParseName(target));
+            return Branch.CreateBranchFromReference(reference, repo);
+        }
+
+        /// <summary>
+        ///   Create a new local branch with the specified name.
+        /// </summary>
+        /// <param name = "name">The name of the branch.</param>
+        /// <param name = "target">The target.</param>
+        /// <returns></returns>
+        public Branch Create(string name, ObjectId target)
+        {
+            Ensure.ArgumentNotNull(target, "target");
+
+            var reference = repo.Refs.Create(EnsureValidBranchName(name), target);
+            return Branch.CreateBranchFromReference(reference, repo);
+        }
+
+        private static string EnsureValidBranchName(string name)
+        {
+            Ensure.ArgumentNotNullOrEmptyString(name, "name");
+
+            if (name.Contains("/"))
+            {
+                throw new ArgumentException("Branch names cannot contain the character '/'.");
+            }
+
+            return string.Format(CultureInfo.InvariantCulture, "refs/heads/{0}", name);
+        }
+
         private static bool IsABranch(Reference reference)
         {
-            return reference.Type == GitReferenceType.Oid
-                   && !reference.Name.StartsWith("refs/tags/");
+            return /*reference.Type == GitReferenceType.Oid
+                   &&*/ !reference.Name.StartsWith("refs/tags/");
+        }
+
+        private static string ParseName(string name)
+        {
+            var tokens = name.Split('/');
+            if (tokens.Length == 1)
+            {
+                return string.Format(CultureInfo.InvariantCulture, "refs/heads/{0}", name);
+            }
+            if (tokens.Length == 2)
+            {
+                return string.Format(CultureInfo.InvariantCulture, "refs/{0}", name);
+            }
+            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Unable to parse branch name: {0}. Expecting local branches in the form <branchname> and remotes in the form <remote>/<branchname>.", name));
         }
     }
 }