Merged working branch that splits the RP project template into two projects: a web project and a class library.

Merge branch 'projecttemplateLib'

6 files changed, 333 insertions, 1 deletions

diff --git a/src/DotNetOpenAuth.BuildTasks/AddProjectItems.cs b/src/DotNetOpenAuth.BuildTasks/AddProjectItems.cs
new file mode 100644
index 0000000..30fa284
--- /dev/null
+++ b/src/DotNetOpenAuth.BuildTasks/AddProjectItems.cs
@@ -0,0 +1,62 @@
+//-----------------------------------------------------------------------
+// <copyright file="AddProjectItems.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.BuildTasks {
+	using System;
+	using System.Collections.Generic;
+	using System.Linq;
+	using System.Text;
+	using Microsoft.Build.BuildEngine;
+	using Microsoft.Build.Framework;
+	using Microsoft.Build.Utilities;
+	using System.Collections;
+
+	public class AddProjectItems : Task {
+		/// <summary>
+		/// Gets or sets the projects to add items to.
+		/// </summary>
+		/// <value>The projects.</value>
+		[Required]
+		public ITaskItem[] Projects { get; set; }
+
+		/// <summary>
+		/// Gets or sets the items to add to each project.
+		/// </summary>
+		/// <value>The items.</value>
+		/// <remarks>
+		/// Use the metadata "ItemType" on each item to specify the item type to use for the new
+		/// project item.  If the metadata is absent, "None" is used as the item type.
+		/// </remarks>
+		[Required]
+		public ITaskItem[] Items { get; set; }
+
+		/// <summary>
+		/// Executes this instance.
+		/// </summary>
+		public override bool Execute() {
+			foreach (var projectTaskItem in this.Projects) {
+				var project = new Project();
+				project.Load(projectTaskItem.ItemSpec);
+
+				foreach (var projectItem in this.Items) {
+					string itemType = projectItem.GetMetadata("ItemType");
+					if (string.IsNullOrEmpty(itemType)) {
+						itemType = "None";
+					}
+					BuildItem newItem = project.AddNewItem(itemType, projectItem.ItemSpec, false);
+					var customMetadata = projectItem.CloneCustomMetadata();
+					foreach (DictionaryEntry entry in customMetadata) {
+						newItem.SetMetadata((string)entry.Key, (string)entry.Value);
+					}
+				}
+
+				project.Save(projectTaskItem.ItemSpec);
+			}
+
+			return !this.Log.HasLoggedErrors;
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.BuildTasks/ChangeProjectReferenceToAssemblyReference.cs b/src/DotNetOpenAuth.BuildTasks/ChangeProjectReferenceToAssemblyReference.cs
index 973d8d6..f940a72 100644
--- a/src/DotNetOpenAuth.BuildTasks/ChangeProjectReferenceToAssemblyReference.cs
+++ b/src/DotNetOpenAuth.BuildTasks/ChangeProjectReferenceToAssemblyReference.cs
@@ -40,7 +40,7 @@ namespace DotNetOpenAuth.BuildTasks {
 					item => item.Name == "ProjectReference" && item.Include == ProjectReference).Single();
 				doc.RemoveItem(projectReference);
 
-				var newReference = doc.AddNewItem("Reference", Path.GetFileNameWithoutExtension(Reference));
+				var newReference = doc.AddNewItem("Reference", Path.GetFileNameWithoutExtension(Reference), true);
 				newReference.SetMetadata("HintPath", Reference);
 
 				doc.Save(project.ItemSpec);
diff --git a/src/DotNetOpenAuth.BuildTasks/DiscoverProjectTemplates.cs b/src/DotNetOpenAuth.BuildTasks/DiscoverProjectTemplates.cs
new file mode 100644
index 0000000..0162c16
--- /dev/null
+++ b/src/DotNetOpenAuth.BuildTasks/DiscoverProjectTemplates.cs
@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------
+// <copyright file="DiscoverProjectTemplates.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.BuildTasks {
+	using System;
+	using System.Collections.Generic;
+	using System.IO;
+	using System.Linq;
+	using System.Text;
+	using System.Xml.Linq;
+	using Microsoft.Build.Framework;
+	using Microsoft.Build.Utilities;
+
+	public class DiscoverProjectTemplates : Task {
+		public ITaskItem[] TopLevelTemplates { get; set; }
+
+		[Output]
+		public ITaskItem[] ProjectTemplates { get; set; }
+
+		[Output]
+		public ITaskItem[] ProjectTemplateContents { get; set; }
+
+		/// <summary>
+		/// Executes this instance.
+		/// </summary>
+		public override bool Execute() {
+			List<ITaskItem> projectTemplates = new List<ITaskItem>();
+			List<ITaskItem> projectTemplateContents = new List<ITaskItem>();
+			foreach (ITaskItem topLevelTemplate in this.TopLevelTemplates) {
+				var vsTemplate = XElement.Load(topLevelTemplate.ItemSpec);
+				var templateContent = vsTemplate.Element(XName.Get("TemplateContent", MergeProjectWithVSTemplate.VSTemplateNamespace));
+				var projectCollection = templateContent.Element(XName.Get("ProjectCollection", MergeProjectWithVSTemplate.VSTemplateNamespace));
+				var links = projectCollection.Elements(XName.Get("ProjectTemplateLink", MergeProjectWithVSTemplate.VSTemplateNamespace));
+				var subTemplates = links.Select(
+					link => (ITaskItem)new TaskItem(
+						link.Value,
+						new Dictionary<string, string> { 
+						{ "TopLevelTemplate", topLevelTemplate.ItemSpec },
+						{ "TopLevelTemplateFileName", Path.GetFileNameWithoutExtension(topLevelTemplate.ItemSpec) },
+					}));
+				projectTemplates.AddRange(subTemplates);
+
+				foreach (var link in links.Select(link => link.Value)) {
+					string[] files = Directory.GetFiles(Path.Combine(Path.GetDirectoryName(topLevelTemplate.ItemSpec), Path.GetDirectoryName(link)), "*.*", SearchOption.AllDirectories);
+					projectTemplateContents.AddRange(files.Select(file => (ITaskItem)new TaskItem(
+						file,
+						new Dictionary<string, string> { 
+						{ "TopLevelTemplate", topLevelTemplate.ItemSpec },
+						{ "TopLevelTemplateFileName", Path.GetFileNameWithoutExtension(topLevelTemplate.ItemSpec) },
+					})));
+				}
+			}
+
+			this.ProjectTemplates = projectTemplates.ToArray();
+			this.ProjectTemplateContents = projectTemplateContents.ToArray();
+
+			return !this.Log.HasLoggedErrors;
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.BuildTasks/DotNetOpenAuth.BuildTasks.csproj b/src/DotNetOpenAuth.BuildTasks/DotNetOpenAuth.BuildTasks.csproj
index 3b22fff..7f84787 100644
--- a/src/DotNetOpenAuth.BuildTasks/DotNetOpenAuth.BuildTasks.csproj
+++ b/src/DotNetOpenAuth.BuildTasks/DotNetOpenAuth.BuildTasks.csproj
@@ -21,6 +21,33 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>False</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly>
+    </CodeContractsCustomRewriterAssembly>
+    <CodeContractsCustomRewriterClass>
+    </CodeContractsCustomRewriterClass>
+    <CodeContractsLibPaths>
+    </CodeContractsLibPaths>
+    <CodeContractsPlatformPath>
+    </CodeContractsPlatformPath>
+    <CodeContractsExtraAnalysisOptions>
+    </CodeContractsExtraAnalysisOptions>
+    <CodeContractsBaseLineFile>
+    </CodeContractsBaseLineFile>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -36,6 +63,7 @@
     <Reference Include="Microsoft.Build.Utilities.v3.5">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
+    <Reference Include="Microsoft.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=736440c9b414ea16, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.Web.Administration, Version=7.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>$(SystemRoot)\System32\inetsrv\Microsoft.Web.Administration.dll</HintPath>
@@ -46,16 +74,23 @@
     </Reference>
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AddProjectItems.cs" />
     <Compile Include="ChangeProjectReferenceToAssemblyReference.cs" />
     <Compile Include="CompareFiles.cs" />
     <Compile Include="ChangeAssemblyReference.cs" />
     <Compile Include="CopyWithTokenSubstitution.cs" />
     <Compile Include="CreateWebApplication.cs" />
     <Compile Include="DeleteWebApplication.cs" />
+    <Compile Include="DiscoverProjectTemplates.cs" />
     <Compile Include="ECMAScriptPacker.cs" />
     <Compile Include="FilterItems.cs" />
+    <Compile Include="FixupReferenceHintPaths.cs" />
+    <Compile Include="MergeProjectWithVSTemplate.cs" />
     <Compile Include="GetBuildVersion.cs" />
     <Compile Include="CheckAdminRights.cs" />
     <Compile Include="JsPack.cs" />
diff --git a/src/DotNetOpenAuth.BuildTasks/FixupReferenceHintPaths.cs b/src/DotNetOpenAuth.BuildTasks/FixupReferenceHintPaths.cs
new file mode 100644
index 0000000..13a4b8f
--- /dev/null
+++ b/src/DotNetOpenAuth.BuildTasks/FixupReferenceHintPaths.cs
@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------
+// <copyright file="FixupReferenceHintPaths.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.BuildTasks {
+	using System;
+	using System.Collections.Generic;
+	using System.IO;
+	using System.Linq;
+	using System.Reflection;
+	using System.Text;
+	using Microsoft.Build.BuildEngine;
+	using Microsoft.Build.Framework;
+	using Microsoft.Build.Utilities;
+
+	public class FixupReferenceHintPaths : Task {
+		/// <summary>
+		/// Gets or sets the projects to fixup references for.
+		/// </summary>
+		[Required]
+		public ITaskItem[] Projects { get; set; }
+
+		/// <summary>
+		/// Gets or sets the set of full paths to assemblies that may be found in any of the <see cref="Projects"/>.
+		/// </summary>
+		[Required]
+		public ITaskItem[] References { get; set; }
+
+		/// <summary>
+		/// Executes this instance.
+		/// </summary>
+		public override bool Execute() {
+			if (this.References.Length == 0 || this.Projects.Length == 0) {
+				this.Log.LogMessage(MessageImportance.Low, "Skipping reference hintpath fixup because no projects or no references were supplied.");
+				return !this.Log.HasLoggedErrors;
+			}
+
+			// Figure out what the assembly names are of the references that are available.
+			AssemblyName[] availableReferences = new AssemblyName[this.References.Length];
+			for (int i = 0; i < this.References.Length; i++) {
+				availableReferences[i] = AssemblyName.GetAssemblyName(this.References[i].ItemSpec);
+			}
+
+			foreach (var projectTaskItem in this.Projects) {
+				var project = new Project();
+				Uri projectUri = new Uri(projectTaskItem.GetMetadata("FullPath"));
+				project.Load(projectTaskItem.ItemSpec);
+
+				foreach (BuildItem referenceItem in project.GetEvaluatedItemsByName("Reference")) {
+					var referenceAssemblyName = new AssemblyName(referenceItem.Include);
+					var matchingReference = availableReferences.FirstOrDefault(r => string.Equals(r.Name, referenceAssemblyName.Name, StringComparison.OrdinalIgnoreCase));
+					if (matchingReference != null) {
+						var originalSuppliedReferenceItem = this.References[Array.IndexOf(availableReferences, matchingReference)];
+						string hintPath = originalSuppliedReferenceItem.GetMetadata("HintPath");
+						if (string.IsNullOrEmpty(hintPath)) {
+							hintPath = projectUri.MakeRelativeUri(new Uri(matchingReference.CodeBase)).OriginalString.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+						}
+						this.Log.LogMessage("Fixing up HintPath to \"{0}\" in project \"{1}\".", referenceAssemblyName.Name, projectTaskItem.ItemSpec);
+						referenceItem.SetMetadata("HintPath", hintPath);
+					}
+				}
+
+				project.Save(projectTaskItem.ItemSpec);
+			}
+
+			return !this.Log.HasLoggedErrors;
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.BuildTasks/MergeProjectWithVSTemplate.cs b/src/DotNetOpenAuth.BuildTasks/MergeProjectWithVSTemplate.cs
new file mode 100644
index 0000000..a2fd46b
--- /dev/null
+++ b/src/DotNetOpenAuth.BuildTasks/MergeProjectWithVSTemplate.cs
@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------
+// <copyright file="MergeProjectWithVSTemplate.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.BuildTasks {
+	using System;
+	using System.Collections.Generic;
+	using System.Linq;
+	using System.Text;
+	using Microsoft.Build.Framework;
+	using Microsoft.Build.Utilities;
+	using System.Xml.Linq;
+	using System.IO;
+	using Microsoft.Build.BuildEngine;
+	using System.Diagnostics.Contracts;
+
+	public class MergeProjectWithVSTemplate : Task {
+		internal const string VSTemplateNamespace = "http://schemas.microsoft.com/developer/vstemplate/2005";
+
+		[Required]
+		public string[] ProjectItemTypes { get; set; }
+
+		[Required]
+		public string[] ReplaceParametersExtensions { get; set; }
+
+		[Required]
+		public ITaskItem[] Templates { get; set; }
+
+		/// <summary>
+		/// Executes this instance.
+		/// </summary>
+		public override bool Execute() {
+			foreach(ITaskItem sourceTemplateTaskItem in this.Templates) {
+				var template = XElement.Load(sourceTemplateTaskItem.ItemSpec);
+				var templateContentElement = template.Element(XName.Get("TemplateContent", VSTemplateNamespace));
+				var projectElement = templateContentElement.Element(XName.Get("Project", VSTemplateNamespace));
+				if (projectElement == null) {
+					Log.LogMessage("Skipping merge of \"{0}\" with a project because no project was referenced from the template.", sourceTemplateTaskItem.ItemSpec);
+					continue;
+				}
+
+				var projectPath = Path.Combine(Path.GetDirectoryName(sourceTemplateTaskItem.ItemSpec), projectElement.Attribute("File").Value);
+				Log.LogMessage("Merging project \"{0}\" with \"{1}\".", projectPath, sourceTemplateTaskItem.ItemSpec);
+				var sourceProject = new Project();
+				sourceProject.Load(projectPath);
+
+				// Collect the project items from the project that are appropriate
+				// to include in the .vstemplate file.
+				var itemsByFolder = from item in sourceProject.EvaluatedItems.Cast<BuildItem>()
+							where this.ProjectItemTypes.Contains(item.Name)
+							orderby item.Include
+							group item by Path.GetDirectoryName(item.Include);
+				foreach (var folder in itemsByFolder) {
+					XElement parentNode = FindOrCreateParent(folder.Key, projectElement);
+
+					foreach (var item in folder) {
+						bool replaceParameters = this.ReplaceParametersExtensions.Contains(Path.GetExtension(item.Include));
+						var projectItem = new XElement(
+							XName.Get("ProjectItem", VSTemplateNamespace),
+							Path.GetFileName(item.Include));
+						if (replaceParameters) {
+							projectItem.SetAttributeValue("ReplaceParameters", "true");
+						}
+						parentNode.Add(projectItem);
+					}
+				}
+
+				template.Save(sourceTemplateTaskItem.ItemSpec);
+			}
+
+			return !Log.HasLoggedErrors;
+		}
+
+		private static XElement FindOrCreateParent(string directoryName, XElement projectElement) {
+			Contract.Requires<ArgumentNullException>(projectElement != null);
+
+			if (string.IsNullOrEmpty(directoryName)) {
+				return projectElement;
+			}
+
+			string[] segments = directoryName.Split(Path.DirectorySeparatorChar);
+			XElement parent = projectElement;
+			for (int i = 0; i < segments.Length; i++) {
+				var candidateName = XName.Get("Folder", VSTemplateNamespace);
+				var candidate = parent.Elements(XName.Get("Folder", VSTemplateNamespace)).FirstOrDefault(n => n.Attribute("Name").Value == segments[i]);
+				if (candidate == null) {
+					candidate = new XElement(
+						candidateName,
+						new XAttribute("Name", segments[i]));
+					parent.Add(candidate);
+				}
+
+				parent = candidate;
+			}
+
+			return parent;
+		}
+	}
+}