Deprecate repo.Refs.Move() in favor of repo.Refs.Rename()

JPaulDuncan · nulltoken · commit ad02fede9f16 · 2014-09-13T19:01:04.000+02:00
Fix #752
diff --git a/LibGit2Sharp.Tests/ReferenceFixture.cs b/LibGit2Sharp.Tests/ReferenceFixture.cs
@@ -601,21 +601,21 @@ public void UpdatingADirectReferenceTargetWithARevparsePointingAtAnUnknownObject
         }
 
         [Fact]
-        public void CanMoveAReferenceToADeeperReferenceHierarchy()
+        public void CanRenameAReferenceToADeeperReferenceHierarchy()
         {
             string path = CloneBareTestRepo();
             using (var repo = new Repository(path))
             {
                 const string newName = "refs/tags/test/deep";
 
-                Reference moved = repo.Refs.Move("refs/tags/test", newName);
-                Assert.NotNull(moved);
-                Assert.Equal(newName, moved.CanonicalName);
+                Reference renamed = repo.Refs.Rename("refs/tags/test", newName);
+                Assert.NotNull(renamed);
+                Assert.Equal(newName, renamed.CanonicalName);
             }
         }
 
         [Fact]
-        public void CanMoveAReferenceToAUpperReferenceHierarchy()
+        public void CanRenameAReferenceToAUpperReferenceHierarchy()
         {
             string path = CloneBareTestRepo();
             using (var repo = new Repository(path))
@@ -624,14 +624,14 @@ public void CanMoveAReferenceToAUpperReferenceHierarchy()
                 const string oldName = newName + "/mio";
 
                 repo.Refs.Add(oldName, repo.Head.CanonicalName);
-                Reference moved = repo.Refs.Move(oldName, newName);
-                Assert.NotNull(moved);
-                Assert.Equal(newName, moved.CanonicalName);
+                Reference renamed = repo.Refs.Rename(oldName, newName);
+                Assert.NotNull(renamed);
+                Assert.Equal(newName, renamed.CanonicalName);
             }
         }
 
         [Fact]
-        public void CanMoveAReferenceToADifferentReferenceHierarchy()
+        public void CanRenameAReferenceToADifferentReferenceHierarchy()
         {
             string path = CloneBareTestRepo();
             using (var repo = new Repository(path))
@@ -643,38 +643,38 @@ public void CanMoveAReferenceToADifferentReferenceHierarchy()
 
                 var oldId = repo.Refs[oldName].ResolveToDirectReference().Target.Id;
 
-                Reference moved = repo.Refs.Move(oldName, newName);
-                Assert.NotNull(moved);
-                Assert.Equal(newName, moved.CanonicalName);
-                Assert.Equal(oldId, moved.ResolveToDirectReference().Target.Id);
+                Reference renamed = repo.Refs.Rename(oldName, newName);
+                Assert.NotNull(renamed);
+                Assert.Equal(newName, renamed.CanonicalName);
+                Assert.Equal(oldId, renamed.ResolveToDirectReference().Target.Id);
 
-                AssertRefLogEntry(repo, newName, moved.ResolveToDirectReference().Target.Id,
+                AssertRefLogEntry(repo, newName, renamed.ResolveToDirectReference().Target.Id,
                     string.Format("reference: renamed {0} to {1}", oldName, newName));
             }
         }
 
         [Fact]
-        public void MovingANonExistingReferenceThrows()
+        public void RenamingANonExistingReferenceThrows()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Refs.Move("refs/tags/i-am-void", "refs/atic/tagtest"));
+                Assert.Throws<LibGit2SharpException>(() => repo.Refs.Rename("refs/tags/i-am-void", "refs/atic/tagtest"));
             }
         }
 
         [Fact]
-        public void CanMoveAndOverWriteAExistingReference()
+        public void CanRenameAndOverWriteAExistingReference()
         {
             string path = CloneBareTestRepo();
             using (var repo = new Repository(path))
             {
                 const string oldName = "refs/heads/packed";
                 const string newName = "refs/heads/br2";
 
-                Reference moved = repo.Refs.Move(oldName, newName, allowOverwrite: true);
+                Reference renamed = repo.Refs.Rename(oldName, newName, allowOverwrite: true);
 
                 Assert.Null(repo.Refs[oldName]);
-                Assert.NotNull(repo.Refs[moved.CanonicalName]);
+                Assert.NotNull(repo.Refs[renamed.CanonicalName]);
             }
         }
 
@@ -683,12 +683,12 @@ public void BlindlyOverwritingAExistingReferenceThrows()
         {
             using (var repo = new Repository(BareTestRepoPath))
             {
-                Assert.Throws<NameConflictException>(() => repo.Refs.Move("refs/heads/packed", "refs/heads/br2"));
+                Assert.Throws<NameConflictException>(() => repo.Refs.Rename("refs/heads/packed", "refs/heads/br2"));
             }
         }
 
         [Fact]
-        public void MovingAReferenceDoesNotDecreaseTheRefsCount()
+        public void RenamingAReferenceDoesNotDecreaseTheRefsCount()
         {
             string path = CloneBareTestRepo();
             using (var repo = new Repository(path))
@@ -699,7 +699,7 @@ public void MovingAReferenceDoesNotDecreaseTheRefsCount()
                 List<string> refs = repo.Refs.Select(r => r.CanonicalName).ToList();
                 Assert.True(refs.Contains(oldName));
 
-                repo.Refs.Move(oldName, newName);
+                repo.Refs.Rename(oldName, newName);
 
                 List<string> refs2 = repo.Refs.Select(r => r.CanonicalName).ToList();
                 Assert.False(refs2.Contains(oldName));
@@ -710,18 +710,18 @@ public void MovingAReferenceDoesNotDecreaseTheRefsCount()
         }
 
         [Fact]
-        public void CanLookupAMovedReference()
+        public void CanLookupARenamedReference()
         {
             string path = CloneBareTestRepo();
             using (var repo = new Repository(path))
             {
                 const string oldName = "refs/tags/test";
                 const string newName = "refs/atic/tagtest";
 
-                Reference moved = repo.Refs.Move(oldName, newName);
+                Reference renamed = repo.Refs.Rename(oldName, newName);
 
                 Reference lookedUp = repo.Refs[newName];
-                Assert.Equal(lookedUp, moved);
+                Assert.Equal(lookedUp, renamed);
             }
         }
 
diff --git a/LibGit2Sharp/Core/HistoryRewriter.cs b/LibGit2Sharp/Core/HistoryRewriter.cs
@@ -181,8 +181,8 @@ private Reference RewriteReference<TRef, TTarget>(
                 return refMap[oldRef] = newRef;
             }
 
-            var movedRef = repo.Refs.Move(newRef, newRefName);
-            rollbackActions.Enqueue(() => repo.Refs.Move(newRef, oldRef.CanonicalName));
+            var movedRef = repo.Refs.Rename(newRef, newRefName);
+            rollbackActions.Enqueue(() => repo.Refs.Rename(newRef, oldRef.CanonicalName));
             return refMap[oldRef] = movedRef;
         }
 
diff --git a/LibGit2Sharp/ReferenceCollection.cs b/LibGit2Sharp/ReferenceCollection.cs
@@ -151,7 +151,35 @@ public virtual void Remove(Reference reference)
         /// <param name="logMessage">Message added to the reflog.</param>
         /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param>
         /// <returns>A new <see cref="Reference"/>.</returns>
+        [Obsolete("This method will be removed in the next release. Please use Rename() instead.")]
         public virtual Reference Move(Reference reference, string newName, Signature signature, string logMessage = null, bool allowOverwrite = false)
+        {
+            return Rename(reference, newName, signature, logMessage, allowOverwrite);
+        }
+
+        /// <summary>
+        /// Rename an existing reference with a new name
+        /// </summary>
+        /// <param name="reference">The reference to rename.</param>
+        /// <param name="newName">The new canonical name.</param>
+        /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param>
+        /// <returns>A new <see cref="Reference"/>.</returns>
+        [Obsolete("This method will be removed in the next release. Please use Rename() instead.")]
+        public virtual Reference Move(Reference reference, string newName, bool allowOverwrite = false)
+        {
+            return Rename(reference, newName, null, null, allowOverwrite);
+        }
+
+        /// <summary>
+        /// Rename an existing reference with a new name, and update the reflog
+        /// </summary>
+        /// <param name="reference">The reference to rename.</param>
+        /// <param name="newName">The new canonical name.</param>
+        /// <param name="signature">Identity used for updating the reflog.</param>
+        /// <param name="logMessage">Message added to the reflog.</param>
+        /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param>
+        /// <returns>A new <see cref="Reference"/>.</returns>
+        public virtual Reference Rename(Reference reference, string newName, Signature signature, string logMessage = null, bool allowOverwrite = false)
         {
             Ensure.ArgumentNotNull(reference, "reference");
             Ensure.ArgumentNotNullOrEmptyString(newName, "newName");
@@ -176,9 +204,9 @@ public virtual Reference Move(Reference reference, string newName, Signature sig
         /// <param name="newName">The new canonical name.</param>
         /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param>
         /// <returns>A new <see cref="Reference"/>.</returns>
-        public virtual Reference Move(Reference reference, string newName, bool allowOverwrite = false)
+        public virtual Reference Rename(Reference reference, string newName, bool allowOverwrite = false)
         {
-            return Move(reference, newName, null, null, allowOverwrite);
+            return Rename(reference, newName, null, null, allowOverwrite);
         }
 
         internal T Resolve<T>(string name) where T : Reference
diff --git a/LibGit2Sharp/ReferenceCollectionExtensions.cs b/LibGit2Sharp/ReferenceCollectionExtensions.cs
@@ -134,8 +134,25 @@ public static Reference UpdateTarget(this ReferenceCollection refsColl, Referenc
         /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param>
         /// <param name="refsColl">The <see cref="ReferenceCollection"/> being worked with.</param>
         /// <returns>A new <see cref="Reference"/>.</returns>
+        [Obsolete("This method will be removed in the next release. Please use Rename() instead.")]
         public static Reference Move(this ReferenceCollection refsColl, string currentName, string newName,
             Signature signature = null, string logMessage = null, bool allowOverwrite = false)
+        {
+            return refsColl.Rename(currentName, newName, signature, logMessage, allowOverwrite);
+        }
+
+        /// <summary>
+        /// Rename an existing reference with a new name
+        /// </summary>
+        /// <param name="currentName">The canonical name of the reference to rename.</param>
+        /// <param name="newName">The new canonical name.</param>
+        /// <param name="signature">The identity used for updating the reflog</param>
+        /// <param name="logMessage">The optional message to log in the <see cref="ReflogCollection"/></param>
+        /// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param>
+        /// <param name="refsColl">The <see cref="ReferenceCollection"/> being worked with.</param>
+        /// <returns>A new <see cref="Reference"/>.</returns>
+        public static Reference Rename(this ReferenceCollection refsColl, string currentName, string newName,
+            Signature signature = null, string logMessage = null, bool allowOverwrite = false)
         {
             Ensure.ArgumentNotNullOrEmptyString(currentName, "currentName");
 
@@ -148,7 +165,7 @@ public static Reference Move(this ReferenceCollection refsColl, string currentNa
                         "Reference '{0}' doesn't exist. One cannot move a non existing reference.", currentName));
             }
 
-            return refsColl.Move(reference, newName, signature, logMessage, allowOverwrite);
+            return refsColl.Rename(reference, newName, signature, logMessage, allowOverwrite);
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -601,21 +601,21 @@ public void UpdatingADirectReferenceTargetWithARevparsePointingAtAnUnknownObject`
`601`	`601`	`}`
`602`	`602`
`603`	`603`	`[Fact]`
`604`		`- public void CanMoveAReferenceToADeeperReferenceHierarchy()`
	`604`	`+ public void CanRenameAReferenceToADeeperReferenceHierarchy()`
`605`	`605`	`{`
`606`	`606`	`string path = CloneBareTestRepo();`
`607`	`607`	`using (var repo = new Repository(path))`
`608`	`608`	`{`
`609`	`609`	`const string newName = "refs/tags/test/deep";`
`610`	`610`
`611`		`- Reference moved = repo.Refs.Move("refs/tags/test", newName);`
`612`		`- Assert.NotNull(moved);`
`613`		`- Assert.Equal(newName, moved.CanonicalName);`
	`611`	`+ Reference renamed = repo.Refs.Rename("refs/tags/test", newName);`
	`612`	`+ Assert.NotNull(renamed);`
	`613`	`+ Assert.Equal(newName, renamed.CanonicalName);`
`614`	`614`	`}`
`615`	`615`	`}`
`616`	`616`
`617`	`617`	`[Fact]`
`618`		`- public void CanMoveAReferenceToAUpperReferenceHierarchy()`
	`618`	`+ public void CanRenameAReferenceToAUpperReferenceHierarchy()`
`619`	`619`	`{`
`620`	`620`	`string path = CloneBareTestRepo();`
`621`	`621`	`using (var repo = new Repository(path))`
`@@ -624,14 +624,14 @@ public void CanMoveAReferenceToAUpperReferenceHierarchy()`
`624`	`624`	`const string oldName = newName + "/mio";`
`625`	`625`
`626`	`626`	`repo.Refs.Add(oldName, repo.Head.CanonicalName);`
`627`		`- Reference moved = repo.Refs.Move(oldName, newName);`
`628`		`- Assert.NotNull(moved);`
`629`		`- Assert.Equal(newName, moved.CanonicalName);`
	`627`	`+ Reference renamed = repo.Refs.Rename(oldName, newName);`
	`628`	`+ Assert.NotNull(renamed);`
	`629`	`+ Assert.Equal(newName, renamed.CanonicalName);`
`630`	`630`	`}`
`631`	`631`	`}`
`632`	`632`
`633`	`633`	`[Fact]`
`634`		`- public void CanMoveAReferenceToADifferentReferenceHierarchy()`
	`634`	`+ public void CanRenameAReferenceToADifferentReferenceHierarchy()`
`635`	`635`	`{`
`636`	`636`	`string path = CloneBareTestRepo();`
`637`	`637`	`using (var repo = new Repository(path))`
`@@ -643,38 +643,38 @@ public void CanMoveAReferenceToADifferentReferenceHierarchy()`
`643`	`643`
`644`	`644`	`var oldId = repo.Refs[oldName].ResolveToDirectReference().Target.Id;`
`645`	`645`
`646`		`- Reference moved = repo.Refs.Move(oldName, newName);`
`647`		`- Assert.NotNull(moved);`
`648`		`- Assert.Equal(newName, moved.CanonicalName);`
`649`		`- Assert.Equal(oldId, moved.ResolveToDirectReference().Target.Id);`
	`646`	`+ Reference renamed = repo.Refs.Rename(oldName, newName);`
	`647`	`+ Assert.NotNull(renamed);`
	`648`	`+ Assert.Equal(newName, renamed.CanonicalName);`
	`649`	`+ Assert.Equal(oldId, renamed.ResolveToDirectReference().Target.Id);`
`650`	`650`
`651`		`- AssertRefLogEntry(repo, newName, moved.ResolveToDirectReference().Target.Id,`
	`651`	`+ AssertRefLogEntry(repo, newName, renamed.ResolveToDirectReference().Target.Id,`
`652`	`652`	`string.Format("reference: renamed {0} to {1}", oldName, newName));`
`653`	`653`	`}`
`654`	`654`	`}`
`655`	`655`
`656`	`656`	`[Fact]`
`657`		`- public void MovingANonExistingReferenceThrows()`
	`657`	`+ public void RenamingANonExistingReferenceThrows()`
`658`	`658`	`{`
`659`	`659`	`using (var repo = new Repository(BareTestRepoPath))`
`660`	`660`	`{`
`661`		`- Assert.Throws<LibGit2SharpException>(() => repo.Refs.Move("refs/tags/i-am-void", "refs/atic/tagtest"));`
	`661`	`+ Assert.Throws<LibGit2SharpException>(() => repo.Refs.Rename("refs/tags/i-am-void", "refs/atic/tagtest"));`
`662`	`662`	`}`
`663`	`663`	`}`
`664`	`664`
`665`	`665`	`[Fact]`
`666`		`- public void CanMoveAndOverWriteAExistingReference()`
	`666`	`+ public void CanRenameAndOverWriteAExistingReference()`
`667`	`667`	`{`
`668`	`668`	`string path = CloneBareTestRepo();`
`669`	`669`	`using (var repo = new Repository(path))`
`670`	`670`	`{`
`671`	`671`	`const string oldName = "refs/heads/packed";`
`672`	`672`	`const string newName = "refs/heads/br2";`
`673`	`673`
`674`		`- Reference moved = repo.Refs.Move(oldName, newName, allowOverwrite: true);`
	`674`	`+ Reference renamed = repo.Refs.Rename(oldName, newName, allowOverwrite: true);`
`675`	`675`
`676`	`676`	`Assert.Null(repo.Refs[oldName]);`
`677`		`- Assert.NotNull(repo.Refs[moved.CanonicalName]);`
	`677`	`+ Assert.NotNull(repo.Refs[renamed.CanonicalName]);`
`678`	`678`	`}`
`679`	`679`	`}`
`680`	`680`
`@@ -683,12 +683,12 @@ public void BlindlyOverwritingAExistingReferenceThrows()`
`683`	`683`	`{`
`684`	`684`	`using (var repo = new Repository(BareTestRepoPath))`
`685`	`685`	`{`
`686`		`- Assert.Throws<NameConflictException>(() => repo.Refs.Move("refs/heads/packed", "refs/heads/br2"));`
	`686`	`+ Assert.Throws<NameConflictException>(() => repo.Refs.Rename("refs/heads/packed", "refs/heads/br2"));`
`687`	`687`	`}`
`688`	`688`	`}`
`689`	`689`
`690`	`690`	`[Fact]`
`691`		`- public void MovingAReferenceDoesNotDecreaseTheRefsCount()`
	`691`	`+ public void RenamingAReferenceDoesNotDecreaseTheRefsCount()`
`692`	`692`	`{`
`693`	`693`	`string path = CloneBareTestRepo();`
`694`	`694`	`using (var repo = new Repository(path))`
`@@ -699,7 +699,7 @@ public void MovingAReferenceDoesNotDecreaseTheRefsCount()`
`699`	`699`	`List<string> refs = repo.Refs.Select(r => r.CanonicalName).ToList();`
`700`	`700`	`Assert.True(refs.Contains(oldName));`
`701`	`701`
`702`		`- repo.Refs.Move(oldName, newName);`
	`702`	`+ repo.Refs.Rename(oldName, newName);`
`703`	`703`
`704`	`704`	`List<string> refs2 = repo.Refs.Select(r => r.CanonicalName).ToList();`
`705`	`705`	`Assert.False(refs2.Contains(oldName));`
`@@ -710,18 +710,18 @@ public void MovingAReferenceDoesNotDecreaseTheRefsCount()`
`710`	`710`	`}`
`711`	`711`
`712`	`712`	`[Fact]`
`713`		`- public void CanLookupAMovedReference()`
	`713`	`+ public void CanLookupARenamedReference()`
`714`	`714`	`{`
`715`	`715`	`string path = CloneBareTestRepo();`
`716`	`716`	`using (var repo = new Repository(path))`
`717`	`717`	`{`
`718`	`718`	`const string oldName = "refs/tags/test";`
`719`	`719`	`const string newName = "refs/atic/tagtest";`
`720`	`720`
`721`		`- Reference moved = repo.Refs.Move(oldName, newName);`
	`721`	`+ Reference renamed = repo.Refs.Rename(oldName, newName);`
`722`	`722`
`723`	`723`	`Reference lookedUp = repo.Refs[newName];`
`724`		`- Assert.Equal(lookedUp, moved);`
	`724`	`+ Assert.Equal(lookedUp, renamed);`
`725`	`725`	`}`
`726`	`726`	`}`
`727`	`727`
Original file line number	Diff line number	Diff line change
`@@ -181,8 +181,8 @@ private Reference RewriteReference<TRef, TTarget>(`
`181`	`181`	`return refMap[oldRef] = newRef;`
`182`	`182`	`}`
`183`	`183`
`184`		`- var movedRef = repo.Refs.Move(newRef, newRefName);`
`185`		`- rollbackActions.Enqueue(() => repo.Refs.Move(newRef, oldRef.CanonicalName));`
	`184`	`+ var movedRef = repo.Refs.Rename(newRef, newRefName);`
	`185`	`+ rollbackActions.Enqueue(() => repo.Refs.Rename(newRef, oldRef.CanonicalName));`
`186`	`186`	`return refMap[oldRef] = movedRef;`
`187`	`187`	`}`
`188`	`188`