private void IntegrateIntoConfiguration(VCConfiguration configuration)
{
string absPropFilePath = GetPropsFilePath(configuration);
string relativePropFilePath = ConanPathHelper.GetRelativePath(configuration.project.ProjectDirectory, absPropFilePath);
IVCCollection tools = (IVCCollection)configuration.Tools;
if (tools != null)
{
VCLinkerTool ltool = (VCLinkerTool)tools.Item("VCLinkerTool");
if (ltool != null)
{
string deps = ltool.AdditionalDependencies;
ltool.AdditionalDependencies = deps.Replace("$(NOINHERIT)", "");
}
}
foreach (VCPropertySheet sheet in configuration.PropertySheets)
{
if (ConanPathHelper.NormalizePath(sheet.PropertySheetFile) == ConanPathHelper.NormalizePath(absPropFilePath))
{
return;
}
}
configuration.AddPropertySheet(relativePropFilePath);
configuration.CollectIntelliSenseInfo();
}
private async System.Threading.Tasks.Task InspectAsync(EnvDTE.Project project)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
string projectConanConfig = ConanPathHelper.GetNearestConanConfig(project.FileName);
var conanProject = new ConanProject
{
Path = project.FileName,
ConfigFile = projectConanConfig
};
await TaskScheduler.Default;
var conanRunner = new ConanRunner(_settingsService.LoadSettingFile(conanProject), _conanPath);
var process = await conanRunner.Inspect(conanProject);
Logger.Log(
$"[Conan.VisualStudio] Calling process '{process.StartInfo.FileName}' " +
$"with arguments '{process.StartInfo.Arguments}'");
using (var reader = process.StandardOutput)
{
string line;
while ((line = await reader.ReadLineAsync()) != null)
{
Logger.Log(line);
}
}
}
public async Task IntegrateAsync(VCProject vcProject)
{
var projectDirectory = vcProject.ProjectDirectory;
var conanfileDirectory = await ConanPathHelper.GetNearestConanfilePathAsync(projectDirectory);
if (conanfileDirectory == null)
{
_errorListService.WriteError("unable to locate conanfile directory!");
return;
}
if (_settingsService.GetConanInstallOnlyActiveConfiguration())
{
string relativePropFilePath = GetPropsFilePath(vcProject.ActiveConfiguration);
vcProject.ActiveConfiguration.AddPropertySheet(relativePropFilePath);
vcProject.ActiveConfiguration.CollectIntelliSenseInfo();
}
else
{
foreach (VCConfiguration configuration in vcProject.Configurations)
{
string relativePropFilePath = GetPropsFilePath(configuration);
configuration.AddPropertySheet(relativePropFilePath);
configuration.CollectIntelliSenseInfo();
}
}
}
public ConanProject ExtractConanProject(VCProject vcProject, ISettingsService settingsService)
{
var projectPath = ConanPathHelper.GetNearestConanfilePath(vcProject.ProjectDirectory); // TODO: Instead of nearest, use the one added to the project (be explicit)
if (projectPath == null)
{
return(null);
}
string projectConanConfig = ConanPathHelper.GetNearestConanConfig(vcProject.ProjectDirectory);
var project = new ConanProject
{
Path = projectPath,
ConfigFile = projectConanConfig
};
if (settingsService != null && settingsService.GetConanInstallOnlyActiveConfiguration())
{
project.Configurations.Add(ExtractConanConfiguration(settingsService, vcProject.ActiveConfiguration));
}
else
{
foreach (VCConfiguration configuration in vcProject.Configurations)
{
project.Configurations.Add(ExtractConanConfiguration(settingsService, configuration));
}
}
return(project);
}
public ConanProject ExtractConanProject(VCProject vcProject, ISettingsService settingsService)
{
var projectPath = ConanPathHelper.GetNearestConanfilePath(vcProject.ProjectDirectory);
if (projectPath == null)
{
return(null);
}
var project = new ConanProject
{
Path = projectPath,
};
if (settingsService != null && settingsService.GetConanInstallOnlyActiveConfiguration())
{
project.Configurations.Add(ExtractConanConfiguration(settingsService, vcProject.ActiveConfiguration));
}
else
{
foreach (VCConfiguration configuration in vcProject.Configurations)
{
project.Configurations.Add(ExtractConanConfiguration(settingsService, configuration));
}
}
return(project);
}
public async Task GetNearestConanfilePathWorksForDiskRootAsync()
{
var root = FileSystemUtils.CreateTempDirectory();
var dir = Directory.CreateDirectory(Path.Combine(root, Path.GetRandomFileName())).FullName;
FileSystemUtils.CreateTempFile(root, "conanfile.txt");
Assert.AreEqual(Path.Combine(root, "conanfile.txt"), await ConanPathHelper.GetNearestConanfilePathAsync(dir));
Assert.AreEqual(Path.Combine(root, "conanfile.txt"), await ConanPathHelper.GetNearestConanfilePathAsync(root));
}
public async Task GetNearestConanfilePathWorksForDiskRootAsync()
{
var dir = FileSystemUtils.CreateTempDirectory();
var root = Path.GetPathRoot(dir);
FileSystemUtils.CreateTempFile(root, "conanfile.txt");
Assert.AreEqual(root, await ConanPathHelper.GetNearestConanfilePathAsync(dir));
Assert.AreEqual(root, await ConanPathHelper.GetNearestConanfilePathAsync(root));
}
public async Task GetNearestConanfilePathReturnsParentPathIfValidAsync()
{
var dir = FileSystemUtils.CreateTempDirectory();
var subdir = Path.Combine(dir, "test");
Directory.CreateDirectory(subdir);
FileSystemUtils.CreateTempFile(dir, "conanfile.txt");
Assert.AreEqual(dir, await ConanPathHelper.GetNearestConanfilePathAsync(subdir));
}
protected internal override async Task MenuItemCallback()
{
var project = _vcProjectService.GetActiveProject();
var projectDirectory = project.ProjectDirectory;
var conanfileDirectory = await ConanPathHelper.GetNearestConanfilePath(projectDirectory);
var propFilePath = Path.Combine(conanfileDirectory, @"conan\conanbuildinfo_multi.props");
var relativePropFilePath = ConanPathHelper.GetRelativePath(projectDirectory, propFilePath);
await _vcProjectService.AddPropsImport(project.ProjectFile, relativePropFilePath);
}
private bool ValidateConanExecutableAndShowMessage(string exe)
{
if (!ConanPathHelper.ValidateConanExecutable(exe, out string errorMessage))
{
MessageBox.Show(errorMessage, "Conan extension: invalid conan executable",
MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
return(true);
}
public async Task GetNearestConanfilePathReturnsCurrentPathIfValidAsync()
{
var dir = FileSystemUtils.CreateTempDirectory();
var conanfile = FileSystemUtils.CreateTempFile(dir, "conanfile.txt");
Assert.AreEqual(dir, await ConanPathHelper.GetNearestConanfilePathAsync(dir));
File.Delete(conanfile);
FileSystemUtils.CreateTempFile(dir, "conanfile.py");
Assert.AreEqual(dir, await ConanPathHelper.GetNearestConanfilePathAsync(dir));
}
public void ConanPathIsDeterminedAutomatically()
{
var directory = FileSystemUtils.CreateTempDirectory();
const string extension = ".cmd";
var conanShim = FileSystemUtils.CreateTempFile(directory, "conan" + extension);
Environment.SetEnvironmentVariable("PATH", directory);
Environment.SetEnvironmentVariable("PATHEXT", extension);
Assert.AreEqual(conanShim, ConanPathHelper.DetermineConanPathFromEnvironment());
}
public void PathDeterminerRespectPathExtOrder()
{
var directory = FileSystemUtils.CreateTempDirectory();
var comShim = FileSystemUtils.CreateTempFile(directory, "conan.com");
FileSystemUtils.CreateTempFile(directory, "conan.exe");
var batShim = FileSystemUtils.CreateTempFile(directory, "conan.bat");
Environment.SetEnvironmentVariable("PATH", directory);
Environment.SetEnvironmentVariable("PATHEXT", ".COM;.EXE;.BAT");
Assert.AreEqual(comShim, ConanPathHelper.DetermineConanPathFromEnvironment());
Environment.SetEnvironmentVariable("PATHEXT", ".BAT;.EXE;.COM");
Assert.AreEqual(batShim, ConanPathHelper.DetermineConanPathFromEnvironment());
}
public async Task <ConanProject> ExtractConanProject(VCProject vcProject)
{
var projectPath = await ConanPathHelper.GetNearestConanfilePath(vcProject.ProjectDirectory);
var project = new ConanProject
{
Path = projectPath,
InstallPath = Path.Combine(projectPath, "conan")
};
foreach (VCConfiguration configuration in vcProject.Configurations)
{
project.Configurations.Add(ExtractConanConfiguration(configuration));
}
return(project);
}
private string GetPropsFilePath(VCConfiguration configuration)
{
string installPath = _vcProjectService.GetInstallationDirectory(_settingsService, configuration);
string propFileName;
if (_settingsService.GetConanGenerator() == ConanGeneratorType.visual_studio)
{
propFileName = @"conanbuildinfo.props";
}
else
{
propFileName = @"conanbuildinfo_multi.props";
}
string propFilePath = Path.Combine(installPath, propFileName);
return(ConanPathHelper.GetRelativePath(configuration.project.ProjectDirectory, propFilePath));
}
private void IntegrateIntoConfiguration(IVCConfiguration configuration)
{
string absPropFilePath = GetPropsFilePath(configuration);
string relativePropFilePath = ConanPathHelper.GetRelativePath(configuration.ProjectDirectory, absPropFilePath);
configuration.AdditionalDependencies = configuration.AdditionalDependencies.Replace("$(NOINHERIT)", "");
foreach (IVCPropertySheet sheet in configuration.PropertySheets)
{
if (ConanPathHelper.NormalizePath(sheet.PropertySheetFile) == ConanPathHelper.NormalizePath(absPropFilePath))
{
string msg = $"[Conan.VisualStudio] Property sheet '{absPropFilePath}' already added to project {configuration.ProjectName}";
Logger.Log(msg);
return;
}
}
configuration.AddPropertySheet(relativePropFilePath);
Logger.Log($"[Conan.VisualStudio] Property sheet '{absPropFilePath}' added to project {configuration.ProjectName}");
configuration.CollectIntelliSenseInfo();
}
public async Task IntegrateAsync(IVCProject vcProject)
{
var projectDirectory = vcProject.ProjectDirectory;
var conanfileDirectory = await ConanPathHelper.GetNearestConanfilePathAsync(projectDirectory);
if (conanfileDirectory == null)
{
_errorListService.WriteError("unable to locate conanfile directory!");
return;
}
if (_settingsService.GetConanInstallOnlyActiveConfiguration())
{
IntegrateIntoConfiguration(vcProject.ActiveConfiguration);
}
else
{
foreach (IVCConfiguration configuration in vcProject.Configurations)
{
IntegrateIntoConfiguration(configuration);
}
}
}
public async Task GetNearestConanfilePathReturnsNullIfThereIsNoConanfileAsync()
{
var dir = FileSystemUtils.CreateTempDirectory();
Assert.IsNull(await ConanPathHelper.GetNearestConanfilePathAsync(dir));
}
public void GetRelativePathTests(string basePath, string location, string expectedRelativePath) => Assert.AreEqual(expectedRelativePath, ConanPathHelper.GetRelativePath(basePath, location));
public bool IsConanProject(Project project)
{
ThreadHelper.ThrowIfNotOnUIThread();
return(IsCppProject(project) && null != ConanPathHelper.GetNearestConanfilePath(AsVCProject(project).ProjectDirectory));
}
