MonoRail/NewGenerator/Castle.NewGenerator.Core/VSProject.cs

   1 namespace Castle.NewGenerator.Core
   2 {
   3         using System;
   4         using System.Collections.Generic;
   5         using System.IO;
   6         using System.Reflection;
   7         using System.Xml;
   8
   9         public enum ProjectType
  10         {
  11                 Web,
  12                 Test
  13         }
  14
  15         public class VSProject
  16         {
  17                 const string ns = "http://schemas.microsoft.com/developer/msbuild/2003";
  18
  19                 private readonly Guid id;
  20                 private readonly string name;
  21                 private readonly string targetFileName;
  22                 private readonly XmlDocument document;
  23                 private XmlElement referencesGroup, contentGroup, compileGroup, projectReferencesGroup, foldersGroup;
  24                 private List<Assembly> assemblyList = new List<Assembly>();
  25
  26                 public enum FileType
  27                 {
  28                         Undefined,
  29                         StaticContent,
  30                         SourceCode,
  31                         Folder,
  32                         None
  33                 }
  34
  35                 private VSProject(Guid id, string name, string targetFileName, XmlDocument document)
  36                 {
  37                         this.id = id;
  38                         this.name = name;
  39                         this.targetFileName = targetFileName;
  40                         this.document = document;
  41                 }
  42
  43                 public string Name
  44                 {
  45                         get { return name; }
  46                 }
  47
  48                 public string FileName
  49                 {
  50                         get { return targetFileName; }
  51                 }
  52
  53                 public Guid Id
  54                 {
  55                         get { return id; }
  56                 }
  57
  58                 public IList<Assembly> AssemblyReferences
  59                 {
  60                         get { return assemblyList; }
  61                 }
  62
  63                 public void AddAssemblyReference(string fileName, string hintPath)
  64                 {
  65                         Assembly assm = Assembly.Load(fileName);
  66
  67                         assemblyList.Add(assm);
  68
  69                         XmlElement refElem = (XmlElement) referencesGroup.AppendChild(document.CreateElement("Reference", ns));
  70                         refElem.SetAttribute("Include", assm.FullName);
  71
  72                         refElem.AppendChild(document.CreateElement("SpecificVersion", ns)).AppendChild(document.CreateTextNode("False"));
  73                         refElem.AppendChild(document.CreateElement("HintPath", ns)).AppendChild(document.CreateTextNode(hintPath));
  74                 }
  75
  76                 public void AddAssemblyReferenceShared(string assemblyName)
  77                 {
  78                         XmlElement refElem = (XmlElement)referencesGroup.AppendChild(document.CreateElement("Reference", ns));
  79                         refElem.SetAttribute("Include", assemblyName);
  80                 }
  81
  82                 public void AddProjectReference(VSProject project)
  83                 {
  84                         XmlElement refElem = (XmlElement) projectReferencesGroup.AppendChild(document.CreateElement("ProjectReference", ns));
  85                         refElem.SetAttribute("Include", project.FileName);
  86
  87                         refElem.AppendChild(document.CreateElement("Project", ns)).AppendChild(document.CreateTextNode(project.Id.ToString("P")));
  88                         refElem.AppendChild(document.CreateElement("Name", ns)).AppendChild(document.CreateTextNode(project.Name));
  89                 }
  90
  91                 public void Save()
  92                 {
  93                         File.Delete(targetFileName);
  94
  95                         document.Save(targetFileName);
  96                 }
  97
  98                 public static VSProject Create(string name, string folder, ProjectType type, XmlDocument templateFile)
  99                 {
 100                         Guid id = Guid.NewGuid();
 101
 102                         VSProject project = new VSProject(id, name, Path.Combine(folder, name + ".csproj"), templateFile);
 103
 104                         ImportExistingFilesFromFolder(project, folder, templateFile);
 105
 106                         SetUpProject(id, name, type, templateFile);
 107
 108                         return project;
 109                 }
 110
 111                 private static void SetUpProject(Guid id, string name, ProjectType type, XmlDocument doc)
 112                 {
 113                         XmlElement projectNode = doc.DocumentElement;
 114                         XmlElement pGroup = projectNode["PropertyGroup"];
 115                         XmlElement projectGuid = pGroup["ProjectGuid"];
 116                         XmlElement rootNamespace = pGroup["RootNamespace"];
 117                         XmlElement assemblyName = pGroup["AssemblyName"];
 118                         XmlElement typeGuids = pGroup["ProjectTypeGuids"];
 119
 120                         projectGuid.FirstChild.Value = id.ToString("P");
 121                         rootNamespace.FirstChild.Value = name;
 122                         assemblyName.FirstChild.Value = name;
 123
 124                         if (type == ProjectType.Web)
 125                         {
 126                                 typeGuids.FirstChild.Value = "{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}";
 127
 128                                 XmlElement importElement = doc.CreateElement("Import", ns);
 129                                 importElement.SetAttribute("Project", @"$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v8.0\WebApplications\Microsoft.WebApplication.targets");
 130                                 doc.DocumentElement.AppendChild(importElement);
 131
 132
 133                                 XmlElement propElement = (XmlElement) doc.DocumentElement.AppendChild(doc.CreateElement("ProjectExtensions", ns)).
 134                                         AppendChild(doc.CreateElement("VisualStudio", ns)).
 135                                         AppendChild(doc.CreateElement("FlavorProperties", ns));
 136
 137                                 propElement.SetAttribute("GUID", "{349c5851-65df-11da-9384-00065b846f21}");
 138
 139                                 XmlElement webProjectPropElem = (XmlElement) propElement.AppendChild(doc.CreateElement("WebProjectProperties", ns));
 140
 141                                 webProjectPropElem.AppendChild(doc.CreateElement("UseIIS", ns)).AppendChild(doc.CreateTextNode("False"));
 142                                 webProjectPropElem.AppendChild(doc.CreateElement("AutoAssignPort", ns)).AppendChild(doc.CreateTextNode("True"));
 143                                 webProjectPropElem.AppendChild(doc.CreateElement("DevelopmentServerVPath", ns)).AppendChild(doc.CreateTextNode("/"));
 144                                 webProjectPropElem.AppendChild(doc.CreateElement("IISUrl", ns));
 145                                 webProjectPropElem.AppendChild(doc.CreateElement("NTLMAuthentication", ns)).AppendChild(doc.CreateTextNode("False"));
 146
 147 //                              XmlDocumentFragment fragment = doc.CreateDocumentFragment();
 148 //                              fragment.InnerXml = "\r\n" +
 149 //                                                                      "  <ProjectExtensions>\r\n" +
 150 //                                                                      "    <VisualStudio>\r\n" +
 151 //                                                                      "      <FlavorProperties GUID=\"{349c5851-65df-11da-9384-00065b846f21}\">\r\n" +
 152 //                                                                      "        <WebProjectProperties>\r\n" +
 153 //                                                                      "          <UseIIS>False</UseIIS>\r\n" +
 154 //                                                                      "          <AutoAssignPort>True</AutoAssignPort>\r\n" +
 155 //                                                                      "          <DevelopmentServerVPath>/</DevelopmentServerVPath>\r\n" +
 156 //                                                                      "          <IISUrl>\r\n" +
 157 //                                                                      "          </IISUrl>\r\n" +
 158 //                                                                      "          <NTLMAuthentication>False</NTLMAuthentication>\r\n" +
 159 //                                                                      "        </WebProjectProperties>\r\n" +
 160 //                                                                      "      </FlavorProperties>\r\n" +
 161 //                                                                      "    </VisualStudio>\r\n" +
 162 //                                                                      "  </ProjectExtensions>\r\n";
 163 //
 164 //                              doc.DocumentElement.AppendChild(fragment);
 165                         }
 166                         else
 167                         {
 168                                 typeGuids.ParentNode.RemoveChild(typeGuids);
 169                         }
 170                 }
 171
 172                 private static void ImportExistingFilesFromFolder(VSProject project, string folder, XmlDocument templateFile)
 173                 {
 174                         project.referencesGroup = templateFile.CreateElement("ItemGroup", ns);
 175                         project.contentGroup = templateFile.CreateElement("ItemGroup", ns);
 176                         project.compileGroup = templateFile.CreateElement("ItemGroup", ns);
 177                         project.projectReferencesGroup = templateFile.CreateElement("ItemGroup", ns);
 178                         project.foldersGroup = templateFile.CreateElement("ItemGroup", ns);
 179
 180                         templateFile.DocumentElement.AppendChild(project.referencesGroup);
 181                         templateFile.DocumentElement.AppendChild(project.contentGroup);
 182                         templateFile.DocumentElement.AppendChild(project.compileGroup);
 183                         templateFile.DocumentElement.AppendChild(project.projectReferencesGroup);
 184                         templateFile.DocumentElement.AppendChild(project.foldersGroup);
 185
 186                         List<string> entries = new List<string>();
 187                         entries.AddRange(Directory.GetDirectories(folder, "*", SearchOption.AllDirectories));
 188                         entries.AddRange(Directory.GetFiles(folder, "*", SearchOption.AllDirectories));
 189
 190                         foreach(string entry in entries)
 191                         {
 192                                 string nodeName;
 193                                 XmlElement targetNode;
 194                                 string relativeFilePath = entry.Substring(folder.Length + 1);
 195                                 FileType fileType = ResolveFileType(entry);
 196
 197                                 switch(fileType)
 198                                 {
 199                                         case FileType.StaticContent:
 200                                                 nodeName = "Content";
 201                                                 targetNode = project.contentGroup;
 202                                                 break;
 203                                         case FileType.SourceCode:
 204                                                 nodeName = "Compile";
 205                                                 targetNode = project.compileGroup;
 206                                                 break;
 207                                         case FileType.Folder:
 208                                                 nodeName = "Folder";
 209                                                 targetNode = project.foldersGroup;
 210                                                 break;
 211                                         case FileType.None:
 212                                                 nodeName = "None";
 213                                                 targetNode = project.contentGroup;
 214                                                 break;
 215                                         default:
 216                                                 continue;
 217                                 }
 218
 219                                 XmlElement item = templateFile.CreateElement(nodeName, ns);
 220                                 item.SetAttribute("Include", relativeFilePath);
 221                                 targetNode.AppendChild(item);
 222                         }
 223                 }
 224
 225                 private static FileType ResolveFileType(string entry)
 226                 {
 227                         string ext = Path.GetExtension(entry);
 228
 229                         if (ext == "")
 230                         {
 231                                 if (new DirectoryInfo(entry).Exists)
 232                                 {
 233                                         return FileType.Folder;
 234                                 }
 235                         }
 236
 237                         switch(ext)
 238                         {
 239                                 case ".aspx":
 240                                 case ".config":
 241                                 case ".asax":
 242                                 case ".css":
 243                                 case ".htm":
 244                                 case ".html":
 245                                 case ".js":
 246                                 case ".txt":
 247                                         return FileType.StaticContent;
 248                                 case ".cs":
 249                                         return FileType.SourceCode;
 250                                 case ".vm":
 251                                 case ".njs":
 252                                 case ".brail":
 253                                         return FileType.None;
 254                                 default:
 255                                         return FileType.Undefined;
 256                         }
 257                 }
 258         }
 259 }