Add get-project cmdlet.

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

@@ -45,9 +45,11 @@
     <Compile Include="Configuration\AssemblyInfo.cs" />
     <Compile Include="Src\CmdletTerminatingError.cs" />
     <Compile Include="Src\GetPackageCmdlet.cs" />
+    <Compile Include="Src\GetProjectCmdlet.cs" />
     <Compile Include="Src\ICmdletTerminatingError.cs" />
     <Compile Include="Src\InstallPackageCmdlet.cs" />
     <Compile Include="Src\ITerminatingCmdlet.cs" />
+    <Compile Include="Src\OpenProjects.cs" />
     <Compile Include="Src\PackageManagementCmdlet.cs" />
     <Compile Include="Src\RuntimeExceptionErrorMessage.cs" />
     <Compile Include="Src\UninstallPackageCmdlet.cs" />

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/GetProjectCmdlet.cs

@@ -0,0 +1,92 @@
+// 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 System.Linq;
+using System.Management.Automation;
+
+using ICSharpCode.PackageManagement.EnvDTE;
+using ICSharpCode.PackageManagement.Scripting;
+using ICSharpCode.SharpDevelop.Project;
+
+namespace ICSharpCode.PackageManagement.Cmdlets
+{
+	[Cmdlet(VerbsCommon.Get, "Project", DefaultParameterSetName = ParameterAttribute.AllParameterSets)]
+	public class GetProjectCmdlet : PackageManagementCmdlet
+	{
+		public GetProjectCmdlet()
+			: this(
+				PackageManagementServices.ConsoleHost,
+				null)
+		{
+		}
+		
+		public GetProjectCmdlet(
+			IPackageManagementConsoleHost consoleHost,
+			ICmdletTerminatingError terminatingError)
+			: base(consoleHost, terminatingError)
+		{
+		}
+		
+		[Parameter(ParameterSetName = "AllProjects")]
+		public SwitchParameter All { get; set; }
+		
+		[Parameter(ParameterSetName = "ProjectsFilteredByName")]
+		public string[] Name { get; set; }
+		
+		protected override void ProcessRecord()
+		{
+			ThrowErrorIfProjectNotOpen();
+			
+			if (All.IsPresent) {
+				WriteAllProjectsToPipeline();
+			} else if (Name != null) {
+				WriteFilteredProjectsToPipeline();
+			} else {
+				WriteDefaultProjectToPipeline();
+			}
+		}
+		
+		void WriteAllProjectsToPipeline()
+		{
+			IEnumerable<Project> allProjects = GetAllProjects();
+			WriteProjectsToPipeline(allProjects);
+		}
+
+		IEnumerable<Project> GetAllProjects()
+		{
+			var projects = new OpenProjects(ConsoleHost);
+			return projects.GetAllProjects();
+		}
+		
+		void WriteProjectsToPipeline(IEnumerable<Project> projects)
+		{
+			bool enumerateCollection = true;
+			WriteObject(projects, enumerateCollection);
+		}
+		
+		void WriteFilteredProjectsToPipeline()
+		{
+			IEnumerable<Project> projects = GetFilteredProjects();
+			WriteProjectsToPipeline(projects);
+		}
+		
+		IEnumerable<Project> GetFilteredProjects()
+		{
+			var projects = new OpenProjects(ConsoleHost);
+			return projects.GetFilteredProjects(Name);
+		}
+		
+		void WriteDefaultProjectToPipeline()
+		{
+			Project project = GetDefaultProject();
+			WriteObject(project);
+		}
+		
+		Project GetDefaultProject()
+		{
+			return new Project(DefaultProject);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/OpenProjects.cs

@@ -0,0 +1,52 @@
+// 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 System.Management.Automation;
+
+using ICSharpCode.PackageManagement.EnvDTE;
+using ICSharpCode.PackageManagement.Scripting;
+using ICSharpCode.SharpDevelop.Project;
+
+namespace ICSharpCode.PackageManagement.Cmdlets
+{
+	public class OpenProjects
+	{
+		IPackageManagementConsoleHost consoleHost;
+		
+		public OpenProjects(IPackageManagementConsoleHost consoleHost)
+		{
+			this.consoleHost = consoleHost;
+		}
+		
+		public IEnumerable<Project> GetAllProjects()
+		{
+			foreach (IProject project in consoleHost.GetOpenProjects()) {
+				yield return CreateProject(project);
+			}
+		}
+		
+		Project CreateProject(IProject project)
+		{
+			return new Project(project as MSBuildBasedProject);
+		}
+		
+		public IEnumerable<Project> GetFilteredProjects(string[] projectNames)
+		{
+			foreach (string projectName in projectNames) {
+				WildcardPattern wildcard = CreateWildcard(projectName);
+				foreach (Project project in GetAllProjects()) {
+					if (wildcard.IsMatch(project.Name)) {
+						yield return project;
+					}
+				}
+			}
+		}
+		
+		WildcardPattern CreateWildcard(string pattern)
+		{
+			return new WildcardPattern(pattern, WildcardOptions.IgnoreCase);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Helpers/FakeCommandRuntime.cs

@@ -11,6 +11,9 @@ namespace PackageManagement.Cmdlets.Tests.Helpers
 	public class FakeCommandRuntime : ICommandRuntime
 	{
 		public List<object> ObjectsPassedToWriteObject = new List<object>();
+		public object FirstObjectPassedToWriteObject {
+			get { return ObjectsPassedToWriteObject[0]; }
+		}
 		
 		public PSHost Host {
 			get {
@@ -39,9 +42,12 @@ namespace PackageManagement.Cmdlets.Tests.Helpers
 			ObjectsPassedToWriteObject.Add(sendToPipeline);
 		}
 		
+		public bool EnumerateCollectionPassedToWriteObject;
+		
 		public void WriteObject(object sendToPipeline, bool enumerateCollection)
 		{
-			throw new NotImplementedException();
+			EnumerateCollectionPassedToWriteObject = enumerateCollection;
+			ObjectsPassedToWriteObject.Add(sendToPipeline);
 		}
 		
 		public void WriteProgress(ProgressRecord progressRecord)

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Helpers/TestableGetPackageCmdlet.cs

@@ -14,7 +14,6 @@ namespace PackageManagement.Cmdlets.Tests.Helpers
 	{
 		public FakeRegisteredPackageRepositories FakeRegisteredPackageRepositories;
 		public FakeCommandRuntime FakeCommandRuntime;
-		public List<IPackage> PackagesPassedToWriteObject = new List<IPackage>();
 		public FakePackageManagementConsoleHost FakePackageManagementConsoleHost;
 		public FakeCmdletTerminatingError FakeCmdletTerminatingError;
 		

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Helpers/TestableGetProjectCmdlet.cs

@@ -0,0 +1,41 @@
+// 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 ICSharpCode.PackageManagement.Cmdlets;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Cmdlets.Tests.Helpers
+{
+	public class TestableGetProjectCmdlet : GetProjectCmdlet
+	{
+		public FakeCmdletTerminatingError FakeCmdletTerminatingError;
+		public FakePackageManagementConsoleHost FakePackageManagementConsoleHost;
+		public FakeCommandRuntime FakeCommandRuntime;
+		
+		public TestableGetProjectCmdlet()
+			: this(
+				new FakePackageManagementConsoleHost(),
+				new FakeCommandRuntime(),
+				new FakeCmdletTerminatingError())
+		{
+		}
+		
+		public TestableGetProjectCmdlet(
+			FakePackageManagementConsoleHost consoleHost,
+			FakeCommandRuntime commandRuntime,
+			FakeCmdletTerminatingError cmdletTerminatingError)
+			: base(consoleHost, cmdletTerminatingError)
+		{
+			this.FakePackageManagementConsoleHost = consoleHost;
+			this.FakeCommandRuntime = commandRuntime;
+			this.CommandRuntime = commandRuntime;
+			this.FakeCmdletTerminatingError = cmdletTerminatingError;
+		}
+		
+		public void CallProcessRecord()
+		{
+			base.ProcessRecord();
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Cmdlets/Test/PackageManagement.Cmdlets.Tests.csproj

@@ -47,12 +47,14 @@
     <Compile Include="Helpers\FakeCommandRuntime.cs" />
     <Compile Include="Helpers\FakeTerminatingCmdlet.cs" />
     <Compile Include="Helpers\TestableGetPackageCmdlet.cs" />
+    <Compile Include="Helpers\TestableGetProjectCmdlet.cs" />
     <Compile Include="Helpers\TestableInstallPackageCmdlet.cs" />
     <Compile Include="Helpers\TestablePackageManagementCmdlet.cs" />
     <Compile Include="Helpers\TestableUninstallPackageCmdlet.cs" />
     <Compile Include="Helpers\TestableUpdatePackageCmdlet.cs" />
     <Compile Include="Src\CmdletTerminatorErrorTests.cs" />
     <Compile Include="Src\GetPackageCmdletTests.cs" />
+    <Compile Include="Src\GetProjectCmdletTests.cs" />
     <Compile Include="Src\InstallPackageCmdletTests.cs" />
     <Compile Include="Src\CmdletTestsBase.cs" />
     <Compile Include="Src\PackageManagementCmdletTests.cs" />

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Src/GetProjectCmdletTests.cs

@@ -0,0 +1,214 @@
+// 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 System.Management.Automation;
+using ICSharpCode.PackageManagement.EnvDTE;
+using NUnit.Framework;
+using PackageManagement.Cmdlets.Tests.Helpers;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Cmdlets.Tests
+{
+	[TestFixture]
+	public class GetProjectCmdletTests : CmdletTestsBase
+	{
+		TestableGetProjectCmdlet cmdlet;
+		FakeCmdletTerminatingError fakeTerminatingError;
+		TestableProject defaultProject;
+		FakeCommandRuntime fakeCommandRuntime;
+		
+		void CreateCmdletWithoutActiveProject()
+		{
+			cmdlet = new TestableGetProjectCmdlet();
+			fakeTerminatingError = cmdlet.FakeCmdletTerminatingError;
+		}
+		
+		void CreateCmdlet()
+		{
+			cmdlet = new TestableGetProjectCmdlet();
+			fakeTerminatingError = cmdlet.FakeCmdletTerminatingError;
+			fakeCommandRuntime = cmdlet.FakeCommandRuntime;
+			fakeConsoleHost = cmdlet.FakePackageManagementConsoleHost;
+			defaultProject = base.AddDefaultProjectToConsoleHost();
+		}
+		
+		void RunCmdlet()
+		{
+			cmdlet.CallProcessRecord();
+		}
+		
+		void EnableAllParameter()
+		{
+			cmdlet.All = new SwitchParameter(true);
+		}
+		
+		void ProjectCollectionAssertAreEqual(IEnumerable<TestableProject> expectedProjects, IEnumerable<Project> actualProjects)
+		{
+			var expectedProjectNames = new List<string>();
+			foreach (TestableProject testableProject in expectedProjects) {
+				expectedProjectNames.Add(testableProject.Name);
+			}
+			
+			var actualProjectNames = new List<string>();			
+			foreach (Project project in actualProjects) {
+				actualProjectNames.Add(project.Name);
+			}
+			
+			CollectionAssert.AreEqual(expectedProjectNames, actualProjectNames);
+		}
+		
+		[Test]
+		public void ProcessRecord_NoActiveProject_ThrowsNoProjectOpenTerminatingError()
+		{
+			CreateCmdletWithoutActiveProject();
+			RunCmdlet();
+						
+			Assert.IsTrue(fakeTerminatingError.IsThrowNoProjectOpenErrorCalled);
+		}
+		
+		[Test]
+		public void ProcessRecord_HostHasDefaultProject_DTEProjectWrittenToPipeline()
+		{
+			CreateCmdlet();
+			defaultProject.Name = "MyProject";
+			RunCmdlet();
+			
+			Project project = fakeCommandRuntime.FirstObjectPassedToWriteObject as Project;
+			string projectName = project.Name;
+			
+			Assert.AreEqual("MyProject", projectName);
+		}
+		
+		[Test]
+		public void ProcessRecord_AllParameterSetAndConsoleHostHasTwoProjects_TwoProjectsWrittenToPipeline()
+		{
+			CreateCmdlet();
+			EnableAllParameter();
+			
+			fakeConsoleHost.AddFakeProject("A");
+			fakeConsoleHost.AddFakeProject("B");
+			
+			RunCmdlet();
+			
+			var expectedProjects = fakeConsoleHost.FakeOpenProjects;
+			var projects = fakeCommandRuntime.FirstObjectPassedToWriteObject as IEnumerable<Project>;
+			
+			ProjectCollectionAssertAreEqual(expectedProjects, projects);
+		}
+		
+		[Test]
+		public void ProcessRecord_AllParameterSetAndConsoleHostHasTwoProjects_ProjectsWrittenToPipelineAreEnumerated()
+		{
+			CreateCmdlet();
+			EnableAllParameter();
+			
+			fakeConsoleHost.AddFakeProject("A");
+			fakeConsoleHost.AddFakeProject("B");
+			
+			RunCmdlet();
+			
+			bool enumerated = fakeCommandRuntime.EnumerateCollectionPassedToWriteObject;
+			
+			Assert.IsTrue(enumerated);
+		}
+		
+		[Test]
+		public void ProcessRecord_TwoProjectsOpenAndNameParameterMatchesOneProject_OneProjectWrittenToPipeline()
+		{
+			CreateCmdlet();
+			cmdlet.Name = new string[] { "B" };
+			
+			fakeConsoleHost.AddFakeProject("A");
+			var projectB = fakeConsoleHost.AddFakeProject("B");
+			
+			RunCmdlet();
+			
+			var projects = fakeCommandRuntime.FirstObjectPassedToWriteObject as IEnumerable<Project>;
+			var expectedProjects = new TestableProject[] {
+				projectB
+			};
+			
+			ProjectCollectionAssertAreEqual(expectedProjects, projects);
+		}
+		
+		[Test]
+		public void ProcessRecord_TwoProjectsOpenAndNameParameterMatchesOneProjectButWithDifferentCase_OneProjectWrittenToPipeline()
+		{
+			CreateCmdlet();
+			cmdlet.Name = new string[] { "b" };
+			
+			fakeConsoleHost.AddFakeProject("A");
+			var projectB = fakeConsoleHost.AddFakeProject("B");
+			
+			RunCmdlet();
+			
+			var projects = fakeCommandRuntime.FirstObjectPassedToWriteObject as IEnumerable<Project>;
+			var expectedProjects = new TestableProject[] {
+				projectB
+			};
+			
+			ProjectCollectionAssertAreEqual(expectedProjects, projects);
+		}
+		
+		[Test]
+		public void ProcessRecord_ThreeProjectsOpenAndTwoNameParametersMatchesTwoProjects_TwoProjectsWrittenToPipeline()
+		{
+			CreateCmdlet();
+			cmdlet.Name = new string[] { "B", "C" };
+			
+			fakeConsoleHost.AddFakeProject("A");
+			var projectB = fakeConsoleHost.AddFakeProject("B");
+			var projectC = fakeConsoleHost.AddFakeProject("C");
+			
+			RunCmdlet();
+			
+			var projects = fakeCommandRuntime.FirstObjectPassedToWriteObject as IEnumerable<Project>;
+			var expectedProjects = new TestableProject[] {
+				projectB,
+				projectC
+			};
+			
+			ProjectCollectionAssertAreEqual(expectedProjects, projects);
+		}
+		
+		[Test]
+		public void ProcessRecord_ThreeProjectsOpenAndTwoNameParametersMatchesTwoProjects_ProjectsWrittenToPipelineAreEnumerated()
+		{
+			CreateCmdlet();
+			cmdlet.Name = new string[] { "B", "C" };
+			
+			fakeConsoleHost.AddFakeProject("A");
+			var projectB = fakeConsoleHost.AddFakeProject("B");
+			var projectC = fakeConsoleHost.AddFakeProject("C");
+			
+			RunCmdlet();
+			
+			bool enumerated = fakeCommandRuntime.EnumerateCollectionPassedToWriteObject;
+			
+			Assert.IsTrue(enumerated);
+		}
+		
+		[Test]
+		public void ProcessRecord_ThreeProjectsAndTwoWildcardsUsedThatMatchTwoProjects_TwoProjectsWrittenToPipeline()
+		{
+			CreateCmdlet();
+			cmdlet.Name = new string[] { "B*", "C*" };
+			
+			fakeConsoleHost.AddFakeProject("A");
+			var projectB = fakeConsoleHost.AddFakeProject("B");
+			var projectC = fakeConsoleHost.AddFakeProject("C");
+			
+			RunCmdlet();
+			
+			var projects = fakeCommandRuntime.FirstObjectPassedToWriteObject as IEnumerable<Project>;
+			var expectedProjects = new TestableProject[] {
+				projectB,
+				projectC
+			};
+			
+			ProjectCollectionAssertAreEqual(expectedProjects, projects);			
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManagementProjectService.cs

@@ -53,16 +53,16 @@ namespace ICSharpCode.PackageManagement.Design
 			}
 		}
 		
-		public List<IProject> OpenProjects = new List<IProject>();
+		public List<IProject> FakeOpenProjects = new List<IProject>();
 		
 		public void AddFakeProject(IProject project)
 		{
-			OpenProjects.Add(project);
+			FakeOpenProjects.Add(project);
 		}
 		
 		public IEnumerable<IProject> GetOpenProjects()
 		{
-			return OpenProjects;
+			return FakeOpenProjects;
 		}
 		
 		public void AddProjectItem(IProject project, ProjectItem item)

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/IPackageManagementConsoleHost.cs

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using ICSharpCode.AvalonEdit;
 using ICSharpCode.Scripting;
 using ICSharpCode.SharpDevelop.Project;
@@ -16,6 +17,8 @@ namespace ICSharpCode.PackageManagement.Scripting
 		IScriptingConsole ScriptingConsole { get; set; }
 		IPackageManagementProjectService ProjectService { get; }
 		
+		IEnumerable<IProject> GetOpenProjects();
+		
 		void Clear();
 		void Run();
 		

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/PackageManagementConsoleHost.cs

@@ -198,5 +198,10 @@ namespace ICSharpCode.PackageManagement.Scripting
 			projectName = GetActiveProjectName(projectName);
 			return solution.GetProject(sourceRepository, projectName);
 		}
+		
+		public IEnumerable<IProject> GetOpenProjects()
+		{
+			return projectService.GetOpenProjects();
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementConsoleHost.cs

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using ICSharpCode.AvalonEdit;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
@@ -85,5 +86,19 @@ namespace PackageManagement.Tests.Helpers
 			PackageSourcePassedToGetActivePackageSource = source;
 			return PackageSourceToReturnFromGetActivePackageSource;
 		}
+		
+		public List<TestableProject> FakeOpenProjects = new List<TestableProject>();
+		
+		public TestableProject AddFakeProject(string name)
+		{
+			var project = ProjectHelper.CreateTestProject(name);
+			FakeOpenProjects.Add(project);
+			return project;
+		}
+		
+		public IEnumerable<IProject> GetOpenProjects()
+		{
+			return FakeOpenProjects;
+		}
 	}
 }

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

@@ -55,7 +55,7 @@ namespace PackageManagement.Tests
 		TestableProject AddProjectToOpenProjects(string projectName)
 		{
 			var project = ProjectHelper.CreateTestProject(projectName);
-			fakeProjectService.OpenProjects.Add(project);
+			fakeProjectService.FakeOpenProjects.Add(project);
 			return project;
 		}
 		

src/AddIns/Misc/PackageManagement/Test/Src/Scripting/PackageManagementConsoleHostTests.cs

@@ -377,5 +377,18 @@ namespace PackageManagement.Tests.Scripting
 			
 			Assert.AreEqual("MyProject", projectName);
 		}
+		
+		[Test]
+		public void GetOpenProjects_TwoProjectsInOpenSolution_ReturnsTwoProjects()
+		{
+			CreateHost();
+			fakeProjectService.AddFakeProject(ProjectHelper.CreateTestProject("A"));
+			fakeProjectService.AddFakeProject(ProjectHelper.CreateTestProject("B"));
+			
+			var projects = host.GetOpenProjects();
+			var expectedProjects = fakeProjectService.FakeOpenProjects;
+			
+			CollectionAssert.AreEqual(expectedProjects, projects);
+		}
 	}
 }