public void CreateProjectDetailsFile(IDesignerProject project, string folder)
{
string text = GetText(project, WriteProjectDetailsXML);
string filePath = folder.PathSlash(GetFilenameFor(project));
fileController.WriteAllText(filePath, text);
}
protected virtual void ProcessProjectReferences(XmlNodeList nodes, IDesignerProject project, string projectFilename)
{
if (nodes == null)
{
return;
}
List <ReferencedFile> referencedFiles = new List <ReferencedFile>();
foreach (XmlNode referenceNode in nodes)
{
NodeProcessor proc = new NodeProcessor(referenceNode);
string relativeFileName = proc.Attributes.GetString("filename");
bool mergeWithAssembly = proc.Attributes.GetBool("mergewithassembly");
bool useInWorkbench = proc.Attributes.GetBool("useinworkbench");
bool isProvider = proc.Attributes.GetBool("isprovider");
string fileName = controller.ToAbsolutePath(relativeFileName, projectFilename);
ReferencedFile file = new ReferencedFile(fileName, mergeWithAssembly, useInWorkbench);
file.IsProvider = isProvider;
referencedFiles.Add(file);
}
project.SetReferencedFiles(referencedFiles);
}
protected virtual void ProcessConfig(XmlNode node, IDesignerProject project, string projectFilename)
{
NodeProcessor proc = new NodeProcessor(node);
string relativeCompilePath = proc.GetString("RelativeCompilePath");
project.CompileFolderName = controller.ToAbsolutePath(relativeCompilePath, projectFilename);
project.Version = proc.GetString("Version");
project.ProjType = proc.GetEnum <ProjectTypes>("ProjectType");
string relativeDebugProjectFile = proc.GetString("DebugProjectFile");
project.DebugProjectFile = controller.ToAbsolutePath(relativeDebugProjectFile, projectFilename);
var relativeTestGenerateDirectory = proc.GetString("TestGenerateDirectory");
project.TestGenerateDirectory = controller.ToAbsolutePath(relativeTestGenerateDirectory, projectFilename);
var namespaceNodes = node.SelectNodes("IncludedNamespaces/Namespace");
if (namespaceNodes != null)
{
foreach (XmlNode namespaceNode in namespaceNodes)
{
project.AddNamespace(namespaceNode.InnerText);
}
}
var refereceNodes = node.SelectNodes("References/Reference");
ProcessProjectReferences(refereceNodes, project, projectFilename);
}
public void LoadProject(string projectFilename, IDesignerProject project)
{
LoadProjectFile(projectFilename, project);
string projectFolder = Path.GetDirectoryName(projectFilename).PathSlash(ProjectSerialiserV1.ProjectFilesFolder);
var apiExtensions = LoadApiExtensionFiles(projectFolder.PathSlash(ProjectSerialiserV1.ApiExtensionFolder));
var options = LoadUserOptions(projectFolder.PathSlash(ProjectSerialiserV1.UserOptionFolder));
var functions = LoadFunctionFiles(projectFolder.PathSlash(ProjectSerialiserV1.FunctionFilesFolder));
var rootFolder = LoadOutputsFile(projectFolder);
var includedFiles = LoadStaticFilenames(projectFolder.PathSlash(ProjectSerialiserV1.StaticFilesFolder));
project.ApiExtensions = apiExtensions;
project.SetUserOptions(options);
project.Functions.Clear();
project.Functions.AddRange(functions);
project.RootOutput = rootFolder;
project.ClearIncludedFiles();
project.AddIncludedFiles(includedFiles);
project.SetupDynamicfilesAndFolders();
}
public void The_Load_Method_Loads_Namespaces_Correctly()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
IDesignerProject project = MockRepository.GenerateMock <IDesignerProject>();
deserialiser.ReadProject(ExpectedXml.GetXmlDocRoot(), project, "Folder\\Project.aad");
project.AssertWasCalled(p => p.AddNamespace(Arg <string> .Is.Equal("Ns1")));
}
public void SetUp()
{
fileController = MockRepository.GenerateMock <IFileController>();
fileController.Stub(f => f.DirectoryExists("Folder")).Return(true);
fileController.Stub(f => f.CanCreateFilesIn("Folder")).Return(true);
project = MockRepository.GenerateStub <IDesignerProject>();
project.ProjectName = "Project";
project.Stub(p => p.Namespaces).Return(new List <string>());
project.Stub(p => p.References).Return(new List <ReferencedFile>().AsReadOnly());
}
public virtual void ReadProject(XmlNode projectElement, IDesignerProject project, string projectFilename)
{
if (projectElement == null)
{
throw new DeserialisationException("Could not find Project node");
}
NodeProcessor proc = new NodeProcessor(projectElement);
project.ProjectName = proc.GetString("Name");
project.ProjectDescription = proc.GetString("Description");
ProcessConfig(projectElement.SelectSingleNode("Config"), project, projectFilename);
}
private void ReadFunctions(XmlNode functions, IDesignerProject project)
{
var functionNodes = functions.SelectNodes("Function");
if (functionNodes == null)
{
return;
}
foreach (XmlElement fNode in functionNodes)
{
var func = ReadFunction(fNode);
project.Functions.Add(func);
}
}
public void SetUp()
{
fileController = MockRepository.GenerateMock <IFileController>();
project = MockRepository.GenerateStub <IDesignerProject>();
project.ProjectName = "Test";
project.ProjectDescription = "Desc";
project.DebugProjectFile = "debug.wbproj";
project.Stub(p => p.GetCompiledDLLDirectory()).Return("temp-compile");
project.Stub(p => p.GetPathRelativeToProjectFile("debug.wbproj")).Return("debug.wbproj");
project.Stub(p => p.GetPathRelativeToProjectFile("test gen")).Return("test gen");
project.Version = "1.2.3.2.1";
project.TestGenerateDirectory = "test gen";
project.Stub(p => p.Namespaces).Return(new List <string>());
project.Stub(p => p.References).Return(new List <ReferencedFile>().AsReadOnly());
}
public void The_Load_Method_Creates_The_Correct_Project()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
IDesignerProject project = MockRepository.GenerateMock <IDesignerProject>();
deserialiser.ReadProject(ExpectedXml.GetXmlDocRoot(), project, "Folder\\Project.aad");
project.AssertWasCalled(p => p.ProjectName = "Test");
project.AssertWasCalled(p => p.ProjectDescription = "Desc");
project.AssertWasCalled(p => p.CompileFolderName = "Folder\\temp-compile"); // This should be the absolute path.
project.AssertWasCalled(p => p.Version = "1.2.3.2.1");
project.AssertWasCalled(p => p.ProjType = ProjectTypes.None);
project.AssertWasCalled(p => p.DebugProjectFile = "Folder\\debug.wbproj"); // Absolute path
project.AssertWasCalled(p => p.TestGenerateDirectory = "Folder\\test gen"); // Absolute path
}
public void SetUp()
{
fileController = MockRepository.GenerateMock<IFileController>();
project = MockRepository.GenerateStub<IDesignerProject>();
project.ProjectName = "Test";
project.ProjectDescription = "Desc";
project.DebugProjectFile = "debug.wbproj";
project.Stub(p => p.GetCompiledDLLDirectory()).Return("temp-compile");
project.Stub(p => p.GetPathRelativeToProjectFile("debug.wbproj")).Return("debug.wbproj");
project.Stub(p => p.GetPathRelativeToProjectFile("test gen")).Return("test gen");
project.Version = "1.2.3.2.1";
project.TestGenerateDirectory = "test gen";
project.Stub(p => p.Namespaces).Return(new List<string>());
project.Stub(p => p.References).Return(new List<ReferencedFile>().AsReadOnly());
}
private void ReadAllApiExtensions(XmlNode extensions, IDesignerProject project)
{
if (extensions == null)
{
project.ApiExtensions = new List <ApiExtensionMethod>();
return;
}
var apiExtensions = new List <ApiExtensionMethod>();
foreach (XmlNode extNode in extensions)
{
apiExtensions.AddRange(ReadApiExtensions(extNode));
}
project.ApiExtensions = apiExtensions;
}
public void WriteProjectToDisk(IDesignerProject project, string projectFolder)
{
string projectFilesFolder = projectFolder.PathSlash(ProjectFilesFolder);
CheckFolder(projectFolder);
CheckFolder(projectFilesFolder);
CheckFolder(projectFilesFolder.PathSlash(ApiExtensionFolder));
CheckFolder(projectFilesFolder.PathSlash(FunctionFilesFolder), true);
CheckFolder(projectFilesFolder.PathSlash(UserOptionFolder));
CreateProjectDetailsFile(project, projectFolder);
CreateOutputFile(project.RootOutput, projectFilesFolder);
CreateApiExtensionFiles(project.ApiExtensions, projectFilesFolder.PathSlash(ApiExtensionFolder));
CreateFunctionFiles(project.Functions, projectFilesFolder.PathSlash(FunctionFilesFolder));
CreateUserOptionsFiles(project.UserOptions, projectFilesFolder.PathSlash(UserOptionFolder));
CreateUserOptionDetailsFile(project.UserOptions, projectFilesFolder.PathSlash(UserOptionFolder));
CreateStaticFiles(project.IncludedFiles, projectFilesFolder.PathSlash(StaticFilesFolder));
}
public virtual void LoadProjectFile(string projectFilePath, IDesignerProject project)
{
if (controller.FileExists(projectFilePath) == false)
{
throw new FileNotFoundException("Could not find project file at path " + projectFilePath);
}
if (controller.CanReadFile(projectFilePath) == false)
{
throw new IOException(string.Format("Cannot read from file {0}: Access Denied.", projectFilePath));
}
if (project == null)
{
throw new DeserialisationException("Cannot load into Project: The given Project was null.");
}
string projectFileXML = controller.ReadAllText(projectFilePath);
ReadProject(projectFileXML.GetXmlDocRoot(), project, projectFilePath);
}
private void WriteProjectToSingleXmlFile(IDesignerProject project, XmlWriter writer)
{
Document doc = new Document(writer);
using (doc.StartElement("MegaProject"))
{
WriteProjectDetailsXML(project, writer);
using (doc.StartElement("AllApiExtensions"))
{
var apiGroupsByType = project.ApiExtensions.GroupBy(a => a.ExtendedMethod.DeclaringType);
foreach (var extendedType in apiGroupsByType)
{
WriteApiExtensionMethodXML(extendedType, extendedType.Key, writer);
}
}
using (doc.StartElement("Functions"))
{
writer.WriteAttributeString("version", "1");
foreach (var function in project.Functions)
{
WriteFunctionXML(function, writer);
}
}
using (doc.StartElement("UserOptions"))
{
writer.WriteAttributeString("version", "1");
foreach (var uo in project.UserOptions)
{
WriteUserOptionXML(uo, writer);
}
WriteUserOptionDetailsXML(project.UserOptions, writer);
}
WriteStaticFilesDetails(project.IncludedFiles, writer);
WriteOutputsXML(project.RootOutput, writer);
}
}
private void ReadUserOptions(XmlNode options, IDesignerProject project)
{
var userOptionNodes = options.SelectNodes("Option");
if (userOptionNodes == null)
{
return;
}
List <UserOption> userOptions = new List <UserOption>();
foreach (XmlElement uoNode in userOptionNodes)
{
var uo = ReadUserOption(uoNode);
userOptions.Add(uo);
}
ReadUserOptionDetails(userOptions, options.SelectSingleNode("UserOptionDetails"));
project.SetUserOptions(userOptions);
}
public virtual void LoadDefaultApiFunctionBodies(XmlNode functionsElement, IDesignerProject project)
{
if (functionsElement == null)
{
throw new DeserialisationException("Could not find FunctionInformation element");
}
CheckVersion(functionsElement);
project.ClearOverriddenFunctionInformation();
var functionInformations = new List <OverriddenFunctionInformation>();
var functions = functionsElement.SelectNodes("Function");
if (functions == null)
{
return;
}
foreach (XmlNode funcNode in functions)
{
var proc = new NodeProcessor(funcNode);
var parameters = proc.GetStrings("Parameter").Select(p => GetTypeNamed(p));
string functionName = proc.Attributes.GetString("name");
string typeName = proc.Attributes.GetString("type");
string xmlcomments = proc.GetString("XmlComments");
string functionBody = proc.GetString("BodyText");
functionInformations.Add(
new OverriddenFunctionInformation(GetTypeNamed(typeName), functionName, parameters, xmlcomments, functionBody));
}
project.AddOverriddenFunctionInformation(functionInformations);
}
public void WriteProjectDetailsXML(IDesignerProject project, XmlWriter writer)
{
Document doc = new Document(writer);
using (doc.StartElement("Project"))
{
writer.WriteAttributeString("version", "1");
writer.WriteElementString("Name", project.ProjectName);
writer.WriteElementString("Description", project.ProjectDescription);
using (doc.StartElement("Config"))
{
writer.WriteElementString("RelativeCompilePath", project.GetCompiledDLLDirectory());
writer.WriteElementString("Version", project.Version);
writer.WriteElementString("ProjectType", project.ProjType.ToString());
writer.WriteElementString("DebugProjectFile", project.GetPathRelativeToProjectFile(project.DebugProjectFile));
writer.WriteElementString("TestGenerateDirectory", project.GetPathRelativeToProjectFile(project.TestGenerateDirectory));
using (doc.StartElement("IncludedNamespaces"))
{
foreach (var ns in project.Namespaces.OrderBy(n => n))
{
writer.WriteElementString("Namespace", ns);
}
}
using (doc.StartElement("References"))
{
foreach (var reference in project.References.OrderBy(r => r.FileName))
{
WriteProjectReference(reference, writer, project);
}
}
}
}
}
public virtual void LoadProjectFile(string projectFilePath, IDesignerProject project)
{
if (controller.FileExists(projectFilePath) == false)
throw new FileNotFoundException("Could not find project file at path " + projectFilePath);
if (controller.CanReadFile(projectFilePath) == false)
throw new IOException(string.Format("Cannot read from file {0}: Access Denied.", projectFilePath));
if (project == null)
throw new DeserialisationException("Cannot load into Project: The given Project was null.");
string projectFileXML = controller.ReadAllText(projectFilePath);
ReadProject(projectFileXML.GetXmlDocRoot(), project, projectFilePath);
}
public virtual void ReadProject(XmlNode projectElement, IDesignerProject project, string projectFilename)
{
if (projectElement == null) throw new DeserialisationException("Could not find Project node");
NodeProcessor proc = new NodeProcessor(projectElement);
project.ProjectName = proc.GetString("Name");
project.ProjectDescription = proc.GetString("Description");
ProcessConfig(projectElement.SelectSingleNode("Config"), project, projectFilename);
}
protected virtual void ProcessConfig(XmlNode node, IDesignerProject project, string projectFilename)
{
NodeProcessor proc = new NodeProcessor(node);
string relativeCompilePath = proc.GetString("RelativeCompilePath");
project.CompileFolderName = controller.ToAbsolutePath(relativeCompilePath, projectFilename);
project.Version = proc.GetString("Version");
project.ProjType = proc.GetEnum<ProjectTypes>("ProjectType");
string relativeDebugProjectFile = proc.GetString("DebugProjectFile");
project.DebugProjectFile = controller.ToAbsolutePath(relativeDebugProjectFile, projectFilename);
var relativeTestGenerateDirectory = proc.GetString("TestGenerateDirectory");
project.TestGenerateDirectory = controller.ToAbsolutePath(relativeTestGenerateDirectory, projectFilename);
var namespaceNodes = node.SelectNodes("IncludedNamespaces/Namespace");
if (namespaceNodes != null)
foreach (XmlNode namespaceNode in namespaceNodes)
project.AddNamespace(namespaceNode.InnerText);
var refereceNodes = node.SelectNodes("References/Reference");
ProcessProjectReferences(refereceNodes, project, projectFilename);
}
protected virtual void ProcessProjectReferences(XmlNodeList nodes, IDesignerProject project, string projectFilename)
{
if (nodes == null) return;
List<ReferencedFile> referencedFiles = new List<ReferencedFile>();
foreach (XmlNode referenceNode in nodes)
{
NodeProcessor proc = new NodeProcessor(referenceNode);
string relativeFileName = proc.Attributes.GetString("filename");
bool mergeWithAssembly = proc.Attributes.GetBool("mergewithassembly");
bool useInWorkbench = proc.Attributes.GetBool("useinworkbench");
bool isProvider = proc.Attributes.GetBool("isprovider");
string fileName = controller.ToAbsolutePath(relativeFileName, projectFilename);
ReferencedFile file = new ReferencedFile(fileName, mergeWithAssembly, useInWorkbench);
file.IsProvider = isProvider;
referencedFiles.Add(file);
}
project.SetReferencedFiles(referencedFiles);
}
private string GetFilenameFor(IDesignerProject project)
{
return(project.ProjectName + ".aad");
}
private void ReadFunctions(XmlNode functions, IDesignerProject project)
{
var functionNodes = functions.SelectNodes("Function");
if (functionNodes == null) return;
foreach (XmlElement fNode in functionNodes)
{
var func = ReadFunction(fNode);
project.Functions.Add(func);
}
}
private void ReadUserOptions(XmlNode options, IDesignerProject project)
{
var userOptionNodes = options.SelectNodes("Option");
if (userOptionNodes == null) return;
List<UserOption> userOptions = new List<UserOption>();
foreach (XmlElement uoNode in userOptionNodes)
{
var uo = ReadUserOption(uoNode);
userOptions.Add(uo);
}
ReadUserOptionDetails(userOptions, options.SelectSingleNode("UserOptionDetails"));
project.SetUserOptions(userOptions);
}
public string WriteProjectToSingleXmlFile(IDesignerProject project)
{
return(GetText(project, WriteProjectToSingleXmlFile));
}
public void LoadProject(string projectFilename, IDesignerProject project)
{
LoadProjectFile(projectFilename, project);
string projectFolder = Path.GetDirectoryName(projectFilename).PathSlash(ProjectSerialiserV1.ProjectFilesFolder);
var apiExtensions = LoadApiExtensionFiles(projectFolder.PathSlash(ProjectSerialiserV1.ApiExtensionFolder));
var options = LoadUserOptions(projectFolder.PathSlash(ProjectSerialiserV1.UserOptionFolder));
var functions = LoadFunctionFiles(projectFolder.PathSlash(ProjectSerialiserV1.FunctionFilesFolder));
var rootFolder = LoadOutputsFile(projectFolder);
var includedFiles = LoadStaticFilenames(projectFolder.PathSlash(ProjectSerialiserV1.StaticFilesFolder));
project.ApiExtensions = apiExtensions;
project.SetUserOptions(options);
project.Functions.Clear();
project.Functions.AddRange(functions);
project.RootOutput = rootFolder;
project.ClearIncludedFiles();
project.AddIncludedFiles(includedFiles);
project.SetupDynamicfilesAndFolders();
}
public void SetUp()
{
fileController = MockRepository.GenerateMock<IFileController>();
fileController.Stub(f => f.DirectoryExists("Folder")).Return(true);
fileController.Stub(f => f.CanCreateFilesIn("Folder")).Return(true);
project = MockRepository.GenerateStub<IDesignerProject>();
project.ProjectName = "Project";
project.Stub(p => p.Namespaces).Return(new List<string>());
project.Stub(p => p.References).Return(new List<ReferencedFile>().AsReadOnly());
}
private void ReadAllApiExtensions(XmlNode extensions, IDesignerProject project)
{
if (extensions == null)
{
project.ApiExtensions = new List<ApiExtensionMethod>();
return;
}
var apiExtensions = new List<ApiExtensionMethod>();
foreach (XmlNode extNode in extensions)
{
apiExtensions.AddRange(ReadApiExtensions(extNode));
}
project.ApiExtensions = apiExtensions;
}
public virtual void LoadDefaultApiFunctionBodies(XmlNode functionsElement, IDesignerProject project)
{
if (functionsElement == null)
throw new DeserialisationException("Could not find FunctionInformation element");
CheckVersion(functionsElement);
project.ClearOverriddenFunctionInformation();
var functionInformations = new List<OverriddenFunctionInformation>();
var functions = functionsElement.SelectNodes("Function");
if (functions == null) return;
foreach (XmlNode funcNode in functions)
{
var proc = new NodeProcessor(funcNode);
var parameters = proc.GetStrings("Parameter").Select(p => GetTypeNamed(p));
string functionName = proc.Attributes.GetString("name");
string typeName = proc.Attributes.GetString("type");
string xmlcomments = proc.GetString("XmlComments");
string functionBody = proc.GetString("BodyText");
functionInformations.Add(
new OverriddenFunctionInformation(GetTypeNamed(typeName), functionName, parameters, xmlcomments, functionBody));
}
project.AddOverriddenFunctionInformation(functionInformations);
}
private void WriteProjectReference(ReferencedFile reference, XmlWriter writer, IDesignerProject project)
{
writer.WriteStartElement("Reference");
writer.WriteAttributeString("filename", project.GetPathRelativeToProjectFile(reference.FileName));
writer.WriteAttributeString("mergewithassembly", reference.MergeWithAssembly.ToString(CultureInfo.InvariantCulture));
writer.WriteAttributeString("useinworkbench", reference.UseInWorkbench.ToString(CultureInfo.InvariantCulture));
writer.WriteAttributeString("isprovider", reference.IsProvider.ToString(CultureInfo.InvariantCulture));
writer.WriteEndElement();
}
