public CSharpProject(Solution solution, string title, string fileName)
{
this.Solution = solution;
this.Title = title;
this.FileName = fileName;
var p = new Microsoft.Build.Evaluation.Project(fileName);
this.AssemblyName = p.GetPropertyValue("AssemblyName");
this.CompilerSettings.AllowUnsafeBlocks = GetBoolProperty(p, "AllowUnsafeBlocks") ?? false;
this.CompilerSettings.CheckForOverflow = GetBoolProperty(p, "CheckForOverflowUnderflow") ?? false;
foreach (string symbol in p.GetPropertyValue("DefineConstants").Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries)) {
this.CompilerSettings.ConditionalSymbols.Add(symbol.Trim());
}
foreach (var item in p.GetItems("Compile")) {
Files.Add(new CSharpFile(this, Path.Combine(p.DirectoryPath, item.EvaluatedInclude)));
}
List<IAssemblyReference> references = new List<IAssemblyReference>();
string mscorlib = FindAssembly(Program.AssemblySearchPaths, "mscorlib");
if (mscorlib != null) {
references.Add(Program.LoadAssembly(mscorlib));
} else {
Console.WriteLine("Could not find mscorlib");
}
bool hasSystemCore = false;
foreach (var item in p.GetItems("Reference")) {
string assemblyFileName = null;
if (item.HasMetadata("HintPath")) {
assemblyFileName = Path.Combine(p.DirectoryPath, item.GetMetadataValue("HintPath"));
if (!File.Exists(assemblyFileName))
assemblyFileName = null;
}
if (assemblyFileName == null) {
assemblyFileName = FindAssembly(Program.AssemblySearchPaths, item.EvaluatedInclude);
}
if (assemblyFileName != null) {
if (Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase))
hasSystemCore = true;
references.Add(Program.LoadAssembly(assemblyFileName));
} else {
Console.WriteLine("Could not find referenced assembly " + item.EvaluatedInclude);
}
}
if (!hasSystemCore && FindAssembly(Program.AssemblySearchPaths, "System.Core") != null)
references.Add(Program.LoadAssembly(FindAssembly(Program.AssemblySearchPaths, "System.Core")));
foreach (var item in p.GetItems("ProjectReference")) {
references.Add(new ProjectReference(solution, item.GetMetadataValue("Name")));
}
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(this.AssemblyName)
.SetCompilerSettings(this.CompilerSettings)
.AddAssemblyReferences(references)
.UpdateProjectContent(null, Files.Select(f => f.ParsedFile));
}
public CSharpProject(Solution solution, string title, string fileName)
{
this.Solution = solution;
this.Title = title;
this.FileName = fileName;
var p = new Microsoft.Build.Evaluation.Project(fileName);
this.AssemblyName = p.GetPropertyValue("AssemblyName");
this.AllowUnsafeBlocks = GetBoolProperty(p, "AllowUnsafeBlocks") ?? false;
this.CheckForOverflowUnderflow = GetBoolProperty(p, "CheckForOverflowUnderflow") ?? false;
this.PreprocessorDefines = p.GetPropertyValue("DefineConstants").Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var item in p.GetItems("Compile"))
{
Files.Add(new CSharpFile(this, Path.Combine(p.DirectoryPath, item.EvaluatedInclude)));
}
List <IAssemblyReference> references = new List <IAssemblyReference>();
string mscorlib = FindAssembly(Program.AssemblySearchPaths, "mscorlib");
if (mscorlib != null)
{
references.Add(Program.LoadAssembly(mscorlib));
}
else
{
Console.WriteLine("Could not find mscorlib");
}
foreach (var item in p.GetItems("Reference"))
{
string assemblyFileName = null;
if (item.HasMetadata("HintPath"))
{
assemblyFileName = Path.Combine(p.DirectoryPath, item.GetMetadataValue("HintPath"));
if (!File.Exists(assemblyFileName))
{
assemblyFileName = null;
}
}
if (assemblyFileName == null)
{
assemblyFileName = FindAssembly(Program.AssemblySearchPaths, item.EvaluatedInclude);
}
if (assemblyFileName != null)
{
references.Add(Program.LoadAssembly(assemblyFileName));
}
else
{
Console.WriteLine("Could not find referenced assembly " + item.EvaluatedInclude);
}
}
foreach (var item in p.GetItems("ProjectReference"))
{
references.Add(new ProjectReference(solution, item.GetMetadataValue("Name")));
}
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(this.AssemblyName)
.AddAssemblyReferences(references)
.UpdateProjectContent(null, Files.Select(f => f.ParsedFile));
}
public CSharpProject(Solution solution, string title, string fileName)
{
// Normalize the file name
fileName = Path.GetFullPath(fileName);
this.Solution = solution;
this.Title = title;
this.FileName = fileName;
// Use MSBuild to open the .csproj
var msbuildProject = new Microsoft.Build.Evaluation.Project(fileName);
// Figure out some compiler settings
this.AssemblyName = msbuildProject.GetPropertyValue("AssemblyName");
this.CompilerSettings.AllowUnsafeBlocks = GetBoolProperty(msbuildProject, "AllowUnsafeBlocks") ?? false;
this.CompilerSettings.CheckForOverflow = GetBoolProperty(msbuildProject, "CheckForOverflowUnderflow") ?? false;
string defineConstants = msbuildProject.GetPropertyValue("DefineConstants");
foreach (string symbol in defineConstants.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
this.CompilerSettings.ConditionalSymbols.Add(symbol.Trim());
}
// Initialize the unresolved type system
IProjectContent pc = new CSharpProjectContent();
pc = pc.SetAssemblyName(this.AssemblyName);
pc = pc.SetProjectFileName(fileName);
pc = pc.SetCompilerSettings(this.CompilerSettings);
// Parse the C# code files
foreach (var item in msbuildProject.GetItems("Compile"))
{
var file = new CSharpFile(this, Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude));
Files.Add(file);
}
// Add parsed files to the type system
pc = pc.AddOrUpdateFiles(Files.Select(f => f.UnresolvedTypeSystemForFile));
// Add referenced assemblies:
foreach (string assemblyFile in ResolveAssemblyReferences(msbuildProject))
{
IUnresolvedAssembly assembly = solution.LoadAssembly(assemblyFile);
pc = pc.AddAssemblyReferences(new [] { assembly });
}
// Add project references:
foreach (var item in msbuildProject.GetItems("ProjectReference"))
{
string referencedFileName = Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude);
// Normalize the path; this is required to match the name with the referenced project's file name
referencedFileName = Path.GetFullPath(referencedFileName);
pc = pc.AddAssemblyReferences(new[] { new ProjectReference(referencedFileName) });
}
this.ProjectContent = pc;
}
protected bool IsDocumentGenerated(MSB.Framework.ITaskItem documentItem)
{
if (_documents == null)
{
_documents = new Dictionary <string, MSB.Evaluation.ProjectItem>();
foreach (var item in _loadedProject.GetItems(ItemNames.Compile))
{
_documents[GetAbsolutePathRelativeToProject(item.EvaluatedInclude)] = item;
}
}
return(!_documents.ContainsKey(GetAbsolutePathRelativeToProject(documentItem.ItemSpec)));
}
public ArrayList GetItems(Microsoft.Build.Evaluation.Project pc, string name, bool folds)
{
ArrayList L = new ArrayList();
if (pc == null)
{
return(L);
}
string folder = Path.GetDirectoryName(FileName);
ICollection <Microsoft.Build.Evaluation.ProjectItem> s = pc.GetItems(name);
foreach (Microsoft.Build.Evaluation.ProjectItem p in s)
{
string file = Path.GetFullPath(folder + "\\" + p.EvaluatedInclude);
if (folds == false)
{
file = p.EvaluatedInclude;
}
L.Add(file);
}
pc.ProjectCollection.UnloadAllProjects();
return(L);
}
public ArrayList GetProjectReferences(string name)
{
ArrayList L = new ArrayList();
Microsoft.Build.Evaluation.Project pc = new Microsoft.Build.Evaluation.Project(FileName);
if (pc == null)
{
return(L);
}
string folder = Path.GetDirectoryName(FileName);
ICollection <Microsoft.Build.Evaluation.ProjectItem> s = pc.GetItems(name);
foreach (Microsoft.Build.Evaluation.ProjectItem p in s)
{
string file = Path.GetFullPath(folder + "\\" + p.EvaluatedInclude);
string project = Path.GetFileNameWithoutExtension(file);
file = project;
L.Add(file);
}
pc.ProjectCollection.UnloadAllProjects();
return(L);
}
public Microsoft.Build.Evaluation.ProjectItem GetReference(string name, string refs)
{
ArrayList L = new ArrayList();
Microsoft.Build.Evaluation.Project pc = null;
try
{
pc = new Microsoft.Build.Evaluation.Project(FileName);
}
catch (Exception e) { }
if (pc == null)
{
return(null);
}
string folder = Path.GetDirectoryName(FileName);
ICollection <Microsoft.Build.Evaluation.ProjectItem> s = pc.GetItems(name);
foreach (Microsoft.Build.Evaluation.ProjectItem p in s)
{
if (p.EvaluatedInclude == refs)
{
return(p);
}
}
pc.ProjectCollection.UnloadAllProjects();
return(null);
}
private static void AddStepDefinitonToIntelliSenseProject(List <NodeFeature> features, string pathToFeatureFile, string pathToIntelliSenseProject)
{
foreach (var feature in features)
{
List <StepInstance> si = new List <StepInstance>();
var steps = new List <NodeStep>();
feature.Scenarios.ForEach(s => steps.AddRange(s.Steps));
var uniqueSteps = GeneratorHelper.FindUniqueSteps(new List <NodeStep>(), steps);
foreach (var step in uniqueSteps)
{
StepDefinitionType type;
StepDefinitionKeyword keyword;
string stepNameWithoutType;
if (step.Name.StartsWith("Given"))
{
type = StepDefinitionType.Given;
keyword = StepDefinitionKeyword.Given;
stepNameWithoutType = step.Name.Substring("Given".Length);
}
else if (step.Name.StartsWith("When"))
{
type = StepDefinitionType.When;
keyword = StepDefinitionKeyword.When;
stepNameWithoutType = step.Name.Substring("When".Length);
}
else
{
type = StepDefinitionType.Then;
keyword = StepDefinitionKeyword.Then;
stepNameWithoutType = step.Name.Substring("Then".Length);
}
string scenarioName = feature.Scenarios.First(scenario => scenario.Steps.Contains(step)).Name;
si.Add(new StepInstance(type, keyword, stepNameWithoutType, stepNameWithoutType, new StepContext(feature.Name, scenarioName, new List <string>(), CultureInfo.CurrentCulture)));
}
var stepDefSkeleton = new StepDefinitionSkeletonProvider(new SpecFlowCSkeletonTemplateProvider(), new StepTextAnalyzer());
var template = stepDefSkeleton.GetBindingClassSkeleton(TechTalk.SpecFlow.ProgrammingLanguage.CSharp, si.ToArray(), "CppUnitTest", feature.Name, StepDefinitionSkeletonStyle.MethodNamePascalCase, CultureInfo.CurrentCulture);
string basePathToFeatures = Path.GetDirectoryName(pathToFeatureFile);
string basePathToIntelliSenseProject = Path.GetDirectoryName(pathToIntelliSenseProject);
_csProj = _csProj ?? GetUnloadedProject(pathToIntelliSenseProject);
var stepDefinitionDirPathInProj = string.Format("Steps\\{0}\\", PROJECT_NAME);
var stepDefinitionDirPath = string.Format("{0}\\{1}", basePathToIntelliSenseProject, stepDefinitionDirPathInProj);
var filePathInProjFile = string.Format("{0}{1}_step.cs", stepDefinitionDirPathInProj, feature.Name);
var filePath = string.Format("{0}{1}_step.cs", stepDefinitionDirPath, feature.Name);
if (!_csProj.GetItems("Compile").Any(item => item.UnevaluatedInclude == filePathInProjFile))
{
Console.WriteLine(string.Format("Generating Step Definition file for IntelliSense support: {0}", filePathInProjFile));
Directory.CreateDirectory(stepDefinitionDirPath);
File.WriteAllText(filePath, template);
_csProj.AddItem("Compile", filePathInProjFile);
_isDirtyCsProj = true;
}
}
}
void AddCSharpFiles(Microsoft.Build.Evaluation.Project p)
{
foreach (var item in p.GetItems("Compile"))
{
try
{
string path = _fileSystem.Path.Combine(p.DirectoryPath, item.EvaluatedInclude).ForceNativePathSeparator();
if (_fileSystem.File.Exists(path))
{
string file = _fileSystem.FileInfo.FromFileName(path).FullName;
_logger.Debug("Loading " + file);
Files.Add(new CSharpFile(this, file));
}
else
{
_logger.Error("File does not exist - " + path);
}
}
catch (NullReferenceException e)
{
_logger.Error(e);
}
}
}
public void BuildSyntTree()
{
foreach (var item in msbuildProject.GetItems("Compile"))
{
var file = new CSharpFile(this, Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude));
Files.Add(file);
}
}
void AddProjectReferences(Microsoft.Build.Evaluation.Project p)
{
foreach (Microsoft.Build.Evaluation.ProjectItem item in p.GetItems("ProjectReference"))
{
var projectName = item.GetMetadataValue("Name");
var referenceGuid = Guid.Parse(item.GetMetadataValue("Project"));
_logger.Debug("Adding project reference {0}, {1}", projectName, referenceGuid);
AddReference(new ProjectReference(_solution, projectName, referenceGuid));
}
}
public async Task Basic_EmptyProjectCannotBuild()
{
// This test focuses on a completely empty project.
nuproj.RemoveItems(nuproj.GetItems("Content"));
var result = await MSBuild.ExecuteAsync(nuproj.CreateProjectInstance(), this.logger);
// Verify that the build fails and tells the user why.
Assert.Equal(BuildResultCode.Failure, result.Result.OverallResult);
Assert.NotEqual(0, result.ErrorEvents.Count());
}
private static void RemoveProjectJsonReference(Microsoft.Build.Evaluation.Project buildProject, string projectJsonFilePath)
{
ThreadHelper.ThrowIfNotOnUIThread();
var projectJsonItem = buildProject.GetItems("None")
.Where(t => string.Equals(t.EvaluatedInclude, Path.GetFileName(projectJsonFilePath), StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
if (projectJsonItem != null)
{
buildProject.RemoveItem(projectJsonItem);
}
}
void AddProjectReferences(Microsoft.Build.Evaluation.Project p)
{
foreach (Microsoft.Build.Evaluation.ProjectItem item in p.GetItems("ProjectReference"))
{
var projectName = item.HasMetadata("Name")
? item.GetMetadataValue("Name")
: Path.GetFileNameWithoutExtension(item.EvaluatedInclude);
var referenceGuid = Guid.Parse(item.GetMetadataValue("Project"));
_logger.Debug("Adding project reference {0}, {1}", projectName, referenceGuid);
AddReference(new ProjectReference(_solution, projectName, referenceGuid));
}
}
private static void AddFilesToCppProject(string pathToFile, string featureDir, string pathToCppProject)
{
_cppProj = _cppProj ?? GetUnloadedProject(pathToCppProject);
pathToFile = MakeFeatureDirRelativeToCppProject(pathToFile, featureDir);
string type = CppFileType(pathToFile);
if (!_cppProj.GetItems(type).Any(item => item.UnevaluatedInclude == pathToFile))
{
_cppProj.AddItem(type, pathToFile);
_isDirtyCppProj = true;
}
}
private static void AddFilesToCppProject(string pathToFile, string featureDir, string pathToCppProject)
{
_cppProj = _cppProj ?? GetUnloadedProject(pathToCppProject);
pathToFile = MakeFeatureDirRelativeToCppProject(pathToFile, featureDir);
string type = CppFileType(pathToFile);
if (!_cppProj.GetItems(type).Any(item => item.UnevaluatedInclude == pathToFile))
{
_cppProj.AddItem(type, pathToFile);
_isDirtyCppProj = true;
}
}
IReadOnlyList <AttributeData> EvaluateAssemblyAttributes()
{
// note: the reason we open the project and examine the items rather than just emumerate the
// file system is that the process would miss linked files. we should be able to assemble the
// assembly attributes from all assembly info files, even they are linked files or imported
// from a source that cannot be evaluated by looking at the file system alone.
var regex = new Regex(assemblyInfoFilePattern, IgnoreCase | Singleline);
var assemblyInfos = from item in project.GetItems("Compile")
let include = item.EvaluatedInclude
where regex.IsMatch(include)
let itemPath = GetFullPath(Combine(project.DirectoryPath, include))
let code = ReadAllText(itemPath)
select ParseText(code);
var references = new[] { CreateFromFile(typeof(object).Assembly.Location) };
var compilation = Create(project.GetPropertyValue("AssemblyName"), assemblyInfos, references);
return(compilation.Assembly.GetAttributes().ToArray());
}
public void FileProperties()
{
using (PackageTestEnvironment testEnv = new PackageTestEnvironment())
{
PropertyInfo buildProjectInfo = typeof(VisualStudio.Project.ProjectNode).GetProperty("BuildProject", BindingFlags.Instance | BindingFlags.NonPublic);
Microsoft.Build.Evaluation.Project buildProject = buildProjectInfo.GetValue(testEnv.Project, new object[0]) as Microsoft.Build.Evaluation.Project;
// Add a node to the project map so it can be resolved
IEnumerable <Microsoft.Build.Evaluation.ProjectItem> itemGroup = buildProject.GetItems("Compile");
Microsoft.Build.Evaluation.ProjectItem item = null;
foreach (Microsoft.Build.Evaluation.ProjectItem currentItem in itemGroup)
{
if (currentItem.EvaluatedInclude == "OtherFile.cs")
{
item = currentItem;
break;
}
}
VisualStudio.Project.FileNode node = new VisualStudio.Project.FileNode(testEnv.Project, testEnv.Project.GetProjectElement(item));
MethodInfo itemMapGetter = typeof(VisualStudio.Project.ProjectNode).GetProperty("ItemIdMap", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(true);
Microsoft.VisualStudio.Shell.EventSinkCollection itemMap = (Microsoft.VisualStudio.Shell.EventSinkCollection)itemMapGetter.Invoke(testEnv.Project, new object[0]);
uint itemID = itemMap.Add(node);
IVsBuildPropertyStorage buildProperty = testEnv.Project as IVsBuildPropertyStorage;
Assert.IsNotNull(buildProperty, "Project does not implements IVsBuildPropertyStorage.");
// Get
string propertyName = "Metadata";
string value = null;
int hr = buildProperty.GetItemAttribute(itemID, propertyName, out value);
Assert.AreEqual <int>(VSConstants.S_OK, hr, "GetItemAttribute failed");
Assert.AreEqual("OtherFileProperty", value);
// Set (with get to confirm)
string newValue = "UpdatedFileProperty";
hr = buildProperty.SetItemAttribute(itemID, propertyName, newValue);
Assert.AreEqual <int>(VSConstants.S_OK, hr, "SetPropertyValue failed");
hr = buildProperty.GetItemAttribute(itemID, propertyName, out value);
Assert.AreEqual <int>(VSConstants.S_OK, hr, "GetItemAttribute failed");
Assert.AreEqual(newValue, value);
}
}
/// <summary>
/// The resolved type system for this project.
/// This field is initialized once all projects have been loaded (in Solution constructor).
/// </summary>
public CSharpProject(Solution solution, string title, string fileName)
{
// Normalize the file name
fileName = Path.GetFullPath(fileName);
this.Solution = solution;
this.Title = title;
this.FileName = fileName;
// Use MSBuild to open the .csproj
var msbuildProject = new Microsoft.Build.Evaluation.Project(fileName);
// Figure out some compiler settings
this.AssemblyName = msbuildProject.GetPropertyValue("AssemblyName");
// Parse the C# code files
foreach (var item in msbuildProject.GetItems("Compile"))
{
var file = new CSharpFile(this, Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude));
Files.Add(file);
}
}
private Configuration ImportConfiguration(Microsoft.Build.Evaluation.Project msbuildProject)
{
Configuration config = new Configuration()
{
Name = "Release"
};
var files = msbuildProject.GetItems("ClCompile");
config.Defines = ImportMetaData("PreprocessorDefinitions", files);
config.Includes = ImportMetaData("AdditionalIncludeDirectories", files).ConvertAll(i => i);
foreach (var file in files)
{
if (file.DirectMetadata.FirstOrDefault(m => m.Name == "PrecompiledHeader") != null)
{
config.PrecompiledHeader = Path.GetFullPath(Path.Combine(msbuildProject.DirectoryPath, file.EvaluatedInclude));
}
}
return(config);
}
public void FileProperties()
{
using (PackageTestEnvironment testEnv = new PackageTestEnvironment())
{
Microsoft.Build.Evaluation.Project buildProject = testEnv.Project.BuildProject;
// Add a node to the project map so it can be resolved
IEnumerable <Microsoft.Build.Evaluation.ProjectItem> itemGroup = buildProject.GetItems("Compile");
Microsoft.Build.Evaluation.ProjectItem item = null;
foreach (Microsoft.Build.Evaluation.ProjectItem currentItem in itemGroup)
{
if (currentItem.EvaluatedInclude == "OtherFile.cs")
{
item = currentItem;
break;
}
}
VisualStudio.Project.FileNode node = new VisualStudio.Project.FileNode(testEnv.Project, testEnv.Project.GetProjectElement(item));
uint itemID = node.Id;
IVsBuildPropertyStorage buildProperty = testEnv.Project as IVsBuildPropertyStorage;
Assert.IsNotNull(buildProperty, "Project does not implements IVsBuildPropertyStorage.");
// Get
string propertyName = "Metadata";
string value = null;
int hr = buildProperty.GetItemAttribute(itemID, propertyName, out value);
Assert.AreEqual <int>(VSConstants.S_OK, hr, "GetItemAttribute failed");
Assert.AreEqual("OtherFileProperty", value);
// Set (with get to confirm)
string newValue = "UpdatedFileProperty";
hr = buildProperty.SetItemAttribute(itemID, propertyName, newValue);
Assert.AreEqual <int>(VSConstants.S_OK, hr, "SetPropertyValue failed");
hr = buildProperty.GetItemAttribute(itemID, propertyName, out value);
Assert.AreEqual <int>(VSConstants.S_OK, hr, "GetItemAttribute failed");
Assert.AreEqual(newValue, value);
}
}
public CSharpProject(Solution solution, string title, string fileName)
{
// Normalize the file name
fileName = Path.GetFullPath(fileName);
this.Solution = solution;
this.Title = title;
this.FileName = fileName;
// Use MSBuild to open the .csproj
var msbuildProject = new Microsoft.Build.Evaluation.Project(fileName);
// Figure out some compiler settings
this.AssemblyName = msbuildProject.GetPropertyValue("AssemblyName");
this.CompilerSettings.AllowUnsafeBlocks = GetBoolProperty(msbuildProject, "AllowUnsafeBlocks") ?? false;
this.CompilerSettings.CheckForOverflow = GetBoolProperty(msbuildProject, "CheckForOverflowUnderflow") ?? false;
string defineConstants = msbuildProject.GetPropertyValue("DefineConstants");
foreach (string symbol in defineConstants.Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries))
this.CompilerSettings.ConditionalSymbols.Add(symbol.Trim());
// Initialize the unresolved type system
IProjectContent pc = new CSharpProjectContent();
pc = pc.SetAssemblyName(this.AssemblyName);
pc = pc.SetProjectFileName(fileName);
pc = pc.SetCompilerSettings(this.CompilerSettings);
// Parse the C# code files
foreach (var item in msbuildProject.GetItems("Compile")) {
var file = new CSharpFile(this, Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude));
Files.Add(file);
}
// Add parsed files to the type system
pc = pc.AddOrUpdateFiles(Files.Select(f => f.UnresolvedTypeSystemForFile));
// Add referenced assemblies:
foreach (string assemblyFile in ResolveAssemblyReferences(msbuildProject)) {
IUnresolvedAssembly assembly = solution.LoadAssembly(assemblyFile);
pc = pc.AddAssemblyReferences(new [] { assembly });
}
// Add project references:
foreach (var item in msbuildProject.GetItems("ProjectReference")) {
string referencedFileName = Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude);
// Normalize the path; this is required to match the name with the referenced project's file name
referencedFileName = Path.GetFullPath(referencedFileName);
pc = pc.AddAssemblyReferences(new[] { new ProjectReference(referencedFileName) });
}
this.ProjectContent = pc;
}
public CSharpProject(ISolution solution, string title, string fileName, Guid id)
{
_solution = solution;
Title = title;
FileName = fileName.ForceNativePathSeparator();
ProjectId = id;
Files = new List<CSharpFile>();
var p = new Microsoft.Build.Evaluation.Project(FileName);
AssemblyName = p.GetPropertyValue("AssemblyName");
_compilerSettings = new CompilerSettings
{
AllowUnsafeBlocks = GetBoolProperty(p, "AllowUnsafeBlocks") ?? false,
CheckForOverflow = GetBoolProperty(p, "CheckForOverflowUnderflow") ?? false,
};
string[] defines = p.GetPropertyValue("DefineConstants").Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string define in defines)
_compilerSettings.ConditionalSymbols.Add(define);
foreach (var item in p.GetItems("Compile"))
{
try
{
string path = Path.Combine(p.DirectoryPath, item.EvaluatedInclude).ForceNativePathSeparator();
if (File.Exists(path))
{
Files.Add(new CSharpFile(this, new FileInfo(path).FullName));
}
else
{
Console.WriteLine("File does not exist - " + path);
}
}
catch (NullReferenceException e)
{
Console.WriteLine(e);
}
}
References = new List<IAssemblyReference>();
string mscorlib = FindAssembly(AssemblySearchPaths, "mscorlib");
if (mscorlib != null)
AddReference(LoadAssembly(mscorlib));
else
Console.WriteLine("Could not find mscorlib");
bool hasSystemCore = false;
foreach (var item in p.GetItems("Reference"))
{
string assemblyFileName = null;
if (item.HasMetadata("HintPath"))
{
assemblyFileName = Path.Combine(p.DirectoryPath, item.GetMetadataValue("HintPath")).ForceNativePathSeparator();
if (!File.Exists(assemblyFileName))
assemblyFileName = null;
}
//If there isn't a path hint or it doesn't exist, try searching
if (assemblyFileName == null)
assemblyFileName = FindAssembly(AssemblySearchPaths, item.EvaluatedInclude);
//If it isn't in the search paths, try the GAC
if (assemblyFileName == null)
assemblyFileName = FindAssemblyInNetGac(item.EvaluatedInclude);
if (assemblyFileName != null)
{
if (Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase))
hasSystemCore = true;
Console.WriteLine("Loading assembly " + item.EvaluatedInclude);
try
{
AddReference(LoadAssembly(assemblyFileName));
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
else
Console.WriteLine("Could not find referenced assembly " + item.EvaluatedInclude);
}
if (!hasSystemCore && FindAssembly(AssemblySearchPaths, "System.Core") != null)
AddReference(LoadAssembly(FindAssembly(AssemblySearchPaths, "System.Core")));
foreach (var item in p.GetItems("ProjectReference"))
AddReference(new ProjectReference(_solution, item.GetMetadataValue("Name")));
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddAssemblyReferences(References)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
}
private static void AddStepDefinitonToIntelliSenseProject(List<NodeFeature> features, string pathToFeatureFile, string pathToIntelliSenseProject)
{
foreach (var feature in features)
{
List<StepInstance> si = new List<StepInstance>();
var steps = new List<NodeStep>();
feature.Scenarios.ForEach(s => steps.AddRange(s.Steps));
var uniqueSteps = GeneratorHelper.FindUniqueSteps(new List<NodeStep>(), steps);
foreach (var step in uniqueSteps)
{
StepDefinitionType type;
StepDefinitionKeyword keyword;
string stepNameWithoutType;
if (step.Name.StartsWith("Given"))
{
type = StepDefinitionType.Given;
keyword = StepDefinitionKeyword.Given;
stepNameWithoutType = step.Name.Substring("Given".Length);
}
else if (step.Name.StartsWith("When"))
{
type = StepDefinitionType.When;
keyword = StepDefinitionKeyword.When;
stepNameWithoutType = step.Name.Substring("When".Length);
}
else
{
type = StepDefinitionType.Then;
keyword = StepDefinitionKeyword.Then;
stepNameWithoutType = step.Name.Substring("Then".Length);
}
string scenarioName = feature.Scenarios.First(scenario => scenario.Steps.Contains(step)).Name;
si.Add(new StepInstance(type, keyword, stepNameWithoutType, stepNameWithoutType, new StepContext(feature.Name, scenarioName, new List<string>(), CultureInfo.CurrentCulture)));
}
var stepDefSkeleton = new StepDefinitionSkeletonProvider(new SpecFlowCSkeletonTemplateProvider(), new StepTextAnalyzer());
var template = stepDefSkeleton.GetBindingClassSkeleton(TechTalk.SpecFlow.ProgrammingLanguage.CSharp, si.ToArray(), "CppUnitTest", feature.Name, StepDefinitionSkeletonStyle.MethodNamePascalCase, CultureInfo.CurrentCulture);
string basePathToFeatures = Path.GetDirectoryName(pathToFeatureFile);
string basePathToIntelliSenseProject = Path.GetDirectoryName(pathToIntelliSenseProject);
_csProj = _csProj ?? GetUnloadedProject(pathToIntelliSenseProject);
var stepDefinitionDirPathInProj = string.Format("Steps\\{0}\\", PROJECT_NAME);
var stepDefinitionDirPath = string.Format("{0}\\{1}", basePathToIntelliSenseProject, stepDefinitionDirPathInProj);
var filePathInProjFile = string.Format("{0}{1}_step.cs", stepDefinitionDirPathInProj, feature.Name);
var filePath = string.Format("{0}{1}_step.cs", stepDefinitionDirPath, feature.Name);
if (!_csProj.GetItems("Compile").Any(item => item.UnevaluatedInclude == filePathInProjFile))
{
Console.WriteLine(string.Format("Generating Step Definition file for IntelliSense support: {0}", filePathInProjFile));
Directory.CreateDirectory(stepDefinitionDirPath);
File.WriteAllText(filePath, template);
_csProj.AddItem("Compile", filePathInProjFile);
_isDirtyCsProj = true;
}
}
}
public CSharpProject(ISolution solution,
IFileSystem fileSystem,
Logger logger,
string title,
string fileName,
Guid id)
: base(fileSystem, logger)
{
_fileSystem = fileSystem;
_logger = logger;
_solution = solution;
Title = title;
if (fileSystem is FileSystem)
{
fileName = fileName.ForceNativePathSeparator();
}
FileName = fileName;
ProjectId = id;
Files = new List <CSharpFile>();
Microsoft.Build.Evaluation.Project project;
try
{
project = new Microsoft.Build.Evaluation.Project(_fileSystem, fileName);
}
catch (DirectoryNotFoundException)
{
logger.Error("Directory not found - " + FileName);
return;
}
catch (FileNotFoundException)
{
logger.Error("File not found - " + FileName);
return;
}
AssemblyName = project.GetPropertyValue("AssemblyName");
SetCompilerSettings(project);
AddCSharpFiles(project);
References = new List <IAssemblyReference>();
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
AddMsCorlib();
bool hasSystemCore = false;
foreach (var item in project.GetItems("Reference"))
{
var assemblyFileName = GetAssemblyFileNameFromHintPath(project, item);
//If there isn't a path hint or it doesn't exist, try searching
if (assemblyFileName == null)
{
assemblyFileName = FindAssembly(item.EvaluatedInclude);
}
//If it isn't in the search paths, try the GAC
if (assemblyFileName == null && PlatformService.IsWindows)
{
assemblyFileName = FindAssemblyInNetGac(item.EvaluatedInclude);
}
if (assemblyFileName != null)
{
if (_fileSystem.Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase))
{
hasSystemCore = true;
}
_logger.Debug("Loading assembly " + item.EvaluatedInclude);
try
{
AddReference(LoadAssembly(assemblyFileName));
}
catch (Exception e)
{
_logger.Error(e);
}
}
else
{
_logger.Error("Could not find referenced assembly " + item.EvaluatedInclude);
}
}
if (!hasSystemCore && FindAssembly("System.Core") != null)
{
AddReference(LoadAssembly(FindAssembly("System.Core")));
}
AddProjectReferences(project);
}
public CSharpProject(ISolution solution, string title, string fileName, Guid id)
{
_solution = solution;
Title = title;
FileName = fileName;
ProjectId = id;
Files = new List <CSharpFile>();
var p = new Microsoft.Build.Evaluation.Project(FileName);
_assemblyName = p.GetPropertyValue("AssemblyName");
_compilerSettings = new CompilerSettings()
{
AllowUnsafeBlocks = GetBoolProperty(p, "AllowUnsafeBlocks") ?? false,
CheckForOverflow = GetBoolProperty(p, "CheckForOverflowUnderflow") ?? false,
};
string[] defines = p.GetPropertyValue("DefineConstants").Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string define in defines)
{
_compilerSettings.ConditionalSymbols.Add(define);
}
foreach (var item in p.GetItems("Compile"))
{
try
{
string path = Path.Combine(p.DirectoryPath, item.EvaluatedInclude).FixPath();
if (File.Exists(path))
{
Files.Add(new CSharpFile(this, new FileInfo(path).FullName));
}
}
catch (NullReferenceException)
{
}
}
References = new List <IAssemblyReference>();
string mscorlib = FindAssembly(AssemblySearchPaths, "mscorlib");
if (mscorlib != null)
{
AddReference(LoadAssembly(mscorlib));
}
else
{
Console.WriteLine("Could not find mscorlib");
}
bool hasSystemCore = false;
foreach (var item in p.GetItems("Reference"))
{
string assemblyFileName = null;
if (item.HasMetadata("HintPath"))
{
assemblyFileName = Path.Combine(p.DirectoryPath, item.GetMetadataValue("HintPath")).FixPath();
if (!File.Exists(assemblyFileName))
{
assemblyFileName = null;
}
}
//If there isn't a path hint or it doesn't exist, try searching
if (assemblyFileName == null)
{
assemblyFileName = FindAssembly(AssemblySearchPaths, item.EvaluatedInclude);
}
//If it isn't in the search paths, try the GAC
if (assemblyFileName == null)
{
assemblyFileName = FindAssemblyInNetGac(item.EvaluatedInclude);
}
if (assemblyFileName != null)
{
if (Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase))
{
hasSystemCore = true;
}
Console.WriteLine("Loading assembly " + item.EvaluatedInclude);
try
{
AddReference(LoadAssembly(assemblyFileName));
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
else
{
Console.WriteLine("Could not find referenced assembly " + item.EvaluatedInclude);
}
}
if (!hasSystemCore && FindAssembly(AssemblySearchPaths, "System.Core") != null)
{
AddReference(LoadAssembly(FindAssembly(AssemblySearchPaths, "System.Core")));
}
foreach (var item in p.GetItems("ProjectReference"))
{
AddReference(new ProjectReference(_solution, item.GetMetadataValue("Name")));
}
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(this._assemblyName)
.AddAssemblyReferences(References)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
}
/// <summary>
/// Loads each MSBuild project in this solution and looks for its project-to-project references so that
/// we know what build order we should use when building the solution.
/// </summary>
private void ScanProjectDependencies(string childProjectToolsVersion, string fullSolutionConfigurationName)
{
// Don't bother with all this if the solution configuration doesn't even exist.
if (fullSolutionConfigurationName == null)
{
return;
}
foreach (ProjectInSolution project in _solutionFile.ProjectsInOrder)
{
// We only need to scan .wdproj projects: Everything else is either MSBuildFormat or
// something we don't know how to do anything with anyway
if (project.ProjectType == SolutionProjectType.WebDeploymentProject)
{
// Skip the project if we don't have its configuration in this solution configuration
if (!project.ProjectConfigurations.ContainsKey(fullSolutionConfigurationName))
{
continue;
}
try
{
Project msbuildProject = new Project(project.AbsolutePath, _globalProperties, childProjectToolsVersion);
// ProjectDependency items work exactly like ProjectReference items from the point of
// view of determining that project B depends on project A. This item must cause
// project A to be built prior to project B.
//
// This has the format
// <ProjectDependency Include="DependentProjectRelativePath">
// <Project>{GUID}</Project>
// </Project>
IEnumerable<ProjectItem> references = msbuildProject.GetItems("ProjectDependency");
foreach (ProjectItem reference in references)
{
string referencedProjectGuid = reference.GetMetadataValue("Project");
AddDependencyByGuid(project, referencedProjectGuid);
}
// If this is a web deployment project, we have a reference specified as a property
// "SourceWebProject" rather than as a ProjectReference item. This has the format
// {GUID}|PATH_TO_CSPROJ
// where
// GUID is the project guid for the "source" project
// PATH_TO_CSPROJ is the solution-relative path to the csproj file.
//
// NOTE: This is obsolete and is intended only for backward compatability with
// Whidbey-generated web deployment projects. New projects should use the
// ProjectDependency item above.
string referencedWebProjectGuid = msbuildProject.GetPropertyValue("SourceWebProject");
if (!string.IsNullOrEmpty(referencedWebProjectGuid))
{
// Grab the guid with its curly braces...
referencedWebProjectGuid = referencedWebProjectGuid.Substring(0, 38);
AddDependencyByGuid(project, referencedWebProjectGuid);
}
}
catch (Exception e)
{
// We don't want any problems scanning the project file to result in aborting the build.
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
_loggingService.LogWarning
(
_projectBuildEventContext,
"SubCategoryForSolutionParsingErrors",
new BuildEventFileInfo(project.RelativePath),
"SolutionScanProjectDependenciesFailed",
project.RelativePath,
e.Message
);
}
}
}
}
public CSharpProject(ISolution solution,
IFileSystem fileSystem,
Logger logger,
string title,
string fileName,
Guid id)
: base(fileSystem, logger)
{
_fileSystem = fileSystem;
_logger = logger;
_solution = solution;
Title = title;
if (fileSystem is FileSystem)
{
fileName = fileName.ForceNativePathSeparator();
}
FileName = fileName;
ProjectId = id;
Files = new List<CSharpFile>();
Microsoft.Build.Evaluation.Project project;
try
{
project = new Microsoft.Build.Evaluation.Project(_fileSystem, fileName);
}
catch (DirectoryNotFoundException)
{
logger.Error("Directory not found - " + FileName);
return;
}
catch (FileNotFoundException)
{
logger.Error("File not found - " + FileName);
return;
}
AssemblyName = project.GetPropertyValue("AssemblyName");
SetCompilerSettings(project);
AddCSharpFiles(project);
References = new List<IAssemblyReference>();
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
AddMsCorlib();
bool hasSystemCore = false;
foreach (var item in project.GetItems("Reference"))
{
var assemblyFileName = GetAssemblyFileNameFromHintPath(project, item);
//If there isn't a path hint or it doesn't exist, try searching
if (assemblyFileName == null)
assemblyFileName = FindAssembly(item.EvaluatedInclude);
//If it isn't in the search paths, try the GAC
if (assemblyFileName == null && PlatformService.IsWindows)
assemblyFileName = FindAssemblyInNetGac(item.EvaluatedInclude);
if (assemblyFileName != null)
{
if (_fileSystem.Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase))
hasSystemCore = true;
_logger.Debug("Loading assembly " + item.EvaluatedInclude);
try
{
AddReference(LoadAssembly(assemblyFileName));
}
catch (Exception e)
{
_logger.Error(e);
}
}
else
_logger.Error("Could not find referenced assembly " + item.EvaluatedInclude);
}
if (!hasSystemCore && FindAssembly("System.Core") != null)
AddReference(LoadAssembly(FindAssembly("System.Core")));
AddProjectReferences(project);
}