Fix old NuGet packages not being removed on updating.

Updating to a new NuGet package or installing a new NuGet
package with the old one still installed would leave the
old unused NuGet package in the packages folder.

src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj

@@ -246,6 +246,7 @@
     <Compile Include="Src\ProjectBuilder.cs" />
     <Compile Include="Src\ProjectRootElementExtensions.cs" />
     <Compile Include="Src\ReducedPackageOperations.cs" />
+    <Compile Include="Src\RemovedPackageReferenceMonitor.cs" />
     <Compile Include="Src\ResolveFileConflictEventArgs.cs" />
     <Compile Include="Src\RestorePackagesCommand.cs" />
     <Compile Include="Src\Scripting\ConsoleHostFileConflictResolver.cs" />

src/AddIns/Misc/PackageManagement/Project/Src/RemovedPackageReferenceMonitor.cs

@@ -0,0 +1,35 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class RemovedPackageReferenceMonitor : IDisposable
+	{
+		ISharpDevelopProjectManager projectManager;
+		List<IPackage> packagesRemoved = new List<IPackage>();
+		
+		public RemovedPackageReferenceMonitor(ISharpDevelopProjectManager projectManager)
+		{
+			this.projectManager = projectManager;
+			projectManager.PackageReferenceRemoved += PackageReferenceRemoved;
+		}
+		
+		void PackageReferenceRemoved(object sender, PackageOperationEventArgs e)
+		{
+			packagesRemoved.Add(e.Package);
+		}
+		
+		public void Dispose()
+		{
+			projectManager.PackageReferenceRemoved -= PackageReferenceRemoved;
+		}
+		
+		public List<IPackage> PackagesRemoved {
+			get { return packagesRemoved; }
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/SharpDevelopPackageManager.cs

@@ -72,7 +72,12 @@ namespace ICSharpCode.PackageManagement
 		
 		void AddPackageReference(IPackage package, bool ignoreDependencies, bool allowPrereleaseVersions)
 		{
-			ProjectManager.AddPackageReference(package.Id, package.Version, ignoreDependencies, allowPrereleaseVersions);			
+			var monitor = new RemovedPackageReferenceMonitor(ProjectManager);
+			using (monitor) {
+				ProjectManager.AddPackageReference(package.Id, package.Version, ignoreDependencies, allowPrereleaseVersions);
+			}
+			
+			monitor.PackagesRemoved.ForEach(packageRemoved => UninstallPackageFromSolutionRepository(packageRemoved));
 		}
 		
 		public override void InstallPackage(IPackage package, bool ignoreDependencies, bool allowPrereleaseVersions)
@@ -94,6 +99,13 @@ namespace ICSharpCode.PackageManagement
 			}
 		}
 		
+		public void UninstallPackageFromSolutionRepository(IPackage package)
+		{
+			if (!IsPackageReferencedByOtherProjects(package)) {
+				ExecuteUninstall(package);
+			}
+		}
+		
 		bool IsPackageReferencedByOtherProjects(IPackage package)
 		{
 			var sharedRepository = LocalRepository as ISharedPackageRepository;
@@ -128,7 +140,19 @@ namespace ICSharpCode.PackageManagement
 		
 		void UpdatePackageReference(IPackage package, bool updateDependencies, bool allowPrereleaseVersions)
 		{
-			ProjectManager.UpdatePackageReference(package.Id, package.Version, updateDependencies, allowPrereleaseVersions);
+			var monitor = new RemovedPackageReferenceMonitor(ProjectManager);
+			using (monitor) {
+				ProjectManager.UpdatePackageReference(package.Id, package.Version, updateDependencies, allowPrereleaseVersions);
+			}
+			
+			monitor.PackagesRemoved.ForEach(packageRemoved => UninstallPackageFromSolutionRepository(packageRemoved));
+		}
+		
+		void ExecuteUninstallIfPackageNotReferencedByOtherProjects(IPackage package)
+		{
+			if (!IsPackageReferencedByOtherProjects(package)) {
+				ExecuteUninstall(package);
+			}
 		}
 		
 		public void UpdatePackages(UpdatePackagesAction updateAction)

src/AddIns/Misc/PackageManagement/Test/Src/SharpDevelopPackageManagerTests.cs

@@ -12,6 +12,7 @@ using NuGet;
 using NUnit.Framework;
 using PackageManagement.Tests.Helpers;
 using Rhino.Mocks;
+using Rhino.Mocks.Expectations;
 
 namespace PackageManagement.Tests
 {
@@ -310,6 +311,34 @@ namespace PackageManagement.Tests
 			fakePackageOperationResolverFactory.UpdatePackageOperationsResolver = fakePackageOperationResolver;
 		}
 		
+		void RaisePackageRemovedEventWhenPackageReferenceUpdated(
+			ISharpDevelopProjectManager projectManager,
+			FakePackage updatedPackage,
+			params PackageOperationEventArgs[] eventArgs)
+		{
+			projectManager
+				.Stub(manager => manager.UpdatePackageReference(
+					Arg<string>.Is.Equal(updatedPackage.Id),
+					Arg<SemanticVersion>.Is.Equal(updatedPackage.Version),
+					Arg<bool>.Is.Anything,
+					Arg<bool>.Is.Anything))
+				.WhenCalled(call => eventArgs.ToList().ForEach(eventArg => projectManager.Raise(manager => manager.PackageReferenceRemoved += null, projectManager, eventArg)));
+		}
+		
+		void RaisePackageRemovedEventWhenPackageReferenceAdded(
+			ISharpDevelopProjectManager projectManager,
+			FakePackage newPackage,
+			params PackageOperationEventArgs[] eventArgs)
+		{
+			projectManager
+				.Stub(manager => manager.AddPackageReference(
+					Arg<string>.Is.Equal(newPackage.Id),
+					Arg<SemanticVersion>.Is.Equal(newPackage.Version),
+					Arg<bool>.Is.Anything,
+					Arg<bool>.Is.Anything))
+				.WhenCalled(call => eventArgs.ToList().ForEach(eventArg => projectManager.Raise(manager => manager.PackageReferenceRemoved += null, projectManager, eventArg)));
+		}
+		
 		[Test]
 		public void ProjectManager_InstanceCreated_SourceRepositoryIsSharedRepositoryPassedToPackageManager()
 		{
@@ -968,5 +997,108 @@ namespace PackageManagement.Tests
 			
 			PackageCollectionAssert.AreEqual(expectedPackages, fakeSolutionSharedRepository.PackagesAdded);
 		}
+		
+		[Test]
+		public void UpdatePackage_OldPackageReferenceIsRemovedOnUpdating_OldPackageIsUninstalled()
+		{
+			CreatePackageManager();
+			var fakeProjectManager = MockRepository.GenerateStub<ISharpDevelopProjectManager>();
+			packageManager.ProjectManager = fakeProjectManager;
+			FakePackage installedPackage = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage", "1.0");
+			FakePackage updatedPackage = fakeFeedSourceRepository.AddFakePackageWithVersion("MyPackage", "1.1");
+			var eventArgs = new PackageOperationEventArgs(installedPackage, null, null);
+			RaisePackageRemovedEventWhenPackageReferenceUpdated(fakeProjectManager, updatedPackage, eventArgs);
+			var updateAction = new FakeUpdatePackageAction {
+				Operations = new List<PackageOperation>(),
+				UpdateDependencies = false
+			};
+			
+			packageManager.UpdatePackage(updatedPackage, updateAction);
+			
+			Assert.IsFalse(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage));
+		}
+		
+		[Test]
+		public void UpdatePackage_TwoOldPackageReferencesAreRemovedOnUpdating_BothOldPackagesAreUninstalled()
+		{
+			CreatePackageManager();
+			var fakeProjectManager = MockRepository.GenerateStub<ISharpDevelopProjectManager>();
+			packageManager.ProjectManager = fakeProjectManager;
+			FakePackage installedPackage1 = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage-Core", "1.0");
+			FakePackage installedPackage2 = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage", "1.0");
+			FakePackage updatedPackage = fakeFeedSourceRepository.AddFakePackageWithVersion("MyPackage", "1.1");
+			var eventArgs1 = new PackageOperationEventArgs(installedPackage1, null, null);
+			var eventArgs2 = new PackageOperationEventArgs(installedPackage2, null, null);
+			RaisePackageRemovedEventWhenPackageReferenceUpdated(fakeProjectManager, updatedPackage, eventArgs1, eventArgs2);
+			var updateAction = new FakeUpdatePackageAction {
+				Operations = new List<PackageOperation>(),
+				UpdateDependencies = false
+			};
+			
+			packageManager.UpdatePackage(updatedPackage, updateAction);
+			
+			Assert.IsFalse(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage2));
+			Assert.IsFalse(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage1));
+		}
+		
+		[Test]
+		public void UpdatePackage_OldPackageReferenceIsRemovedOnUpdatingButAnotherProjectStillReferencesThePackage_OldPackageIsNotUninstalled()
+		{
+			CreatePackageManager();
+			var fakeProjectManager = MockRepository.GenerateStub<ISharpDevelopProjectManager>();
+			packageManager.ProjectManager = fakeProjectManager;
+			FakePackage installedPackage = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage-Core", "1.0");
+			FakePackage updatedPackage = fakeFeedSourceRepository.AddFakePackageWithVersion("MyPackage", "1.1");
+			var eventArgs = new PackageOperationEventArgs(installedPackage, null, null);
+			RaisePackageRemovedEventWhenPackageReferenceUpdated(fakeProjectManager, updatedPackage, eventArgs);
+			var updateAction = new FakeUpdatePackageAction {
+				Operations = new List<PackageOperation>(),
+				UpdateDependencies = false
+			};
+			fakeSolutionSharedRepository.PackageIdsReferences.Add("MyPackage-Core");
+			
+			packageManager.UpdatePackage(updatedPackage, updateAction);
+			
+			Assert.IsTrue(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage));
+		}
+		
+		[Test]
+		public void InstallPackage_OldPackageReferenceIsRemovedOnInstalling_OldPackageIsUninstalled()
+		{
+			CreatePackageManager();
+			var fakeProjectManager = MockRepository.GenerateStub<ISharpDevelopProjectManager>();
+			packageManager.ProjectManager = fakeProjectManager;
+			FakePackage installedPackage = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage", "1.0");
+			FakePackage newPackage = fakeFeedSourceRepository.AddFakePackageWithVersion("MyPackage", "1.1");
+			var eventArgs = new PackageOperationEventArgs(installedPackage, null, null);
+			RaisePackageRemovedEventWhenPackageReferenceAdded(fakeProjectManager, newPackage, eventArgs);
+			var installAction = new FakeInstallPackageAction {
+				Operations = new List<PackageOperation>()
+			};
+			
+			packageManager.InstallPackage(newPackage, installAction);
+			
+			Assert.IsFalse(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage));
+		}
+		
+		[Test]
+		public void InstallPackage_OldPackageReferenceIsRemovedOnInstallingButOtherProjectsReferencesOldPackage_OldPackageIsNotUninstalled()
+		{
+			CreatePackageManager();
+			var fakeProjectManager = MockRepository.GenerateStub<ISharpDevelopProjectManager>();
+			packageManager.ProjectManager = fakeProjectManager;
+			FakePackage installedPackage = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage.Core", "1.0");
+			FakePackage newPackage = fakeFeedSourceRepository.AddFakePackageWithVersion("MyPackage", "1.1");
+			fakeSolutionSharedRepository.PackageIdsReferences.Add("MyPackage.Core");
+			var eventArgs = new PackageOperationEventArgs(installedPackage, null, null);
+			RaisePackageRemovedEventWhenPackageReferenceAdded(fakeProjectManager, newPackage, eventArgs);
+			var installAction = new FakeInstallPackageAction {
+				Operations = new List<PackageOperation>()
+			};
+			
+			packageManager.InstallPackage(newPackage, installAction);
+			
+			Assert.IsTrue(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage));
+		}
 	}
 }