public void Compile (PythonProject project, FilePath fileName, PythonConfiguration config, BuildResult result) { if (String.IsNullOrEmpty (fileName)) throw new ArgumentNullException ("fileName"); else if (config == null) throw new ArgumentNullException ("config"); else if (result == null) throw new ArgumentNullException ("result"); else if (Runtime == null) throw new InvalidOperationException ("No supported runtime!"); // Get our relative path within the project if (!fileName.IsChildPathOf (project.BaseDirectory)) { Console.WriteLine ("File is not within our project!"); return; } FilePath relName = fileName.ToRelative (project.BaseDirectory); string outFile = relName.ToAbsolute (config.OutputDirectory); if (!outFile.EndsWith (".py")) return; // Create the destination directory FileInfo fileInfo = new FileInfo (outFile); if (!fileInfo.Directory.Exists) fileInfo.Directory.Create (); // Create and start our process to generate the byte code Process process = BuildCompileProcess (fileName, outFile, config.Optimize); process.Start (); process.WaitForExit (); // Parse errors and warnings string output = process.StandardError.ReadToEnd (); // Extract potential Warnings foreach (Match m in m_WarningRegex.Matches (output)) { string lineNum = m.Groups[m_WarningRegex.GroupNumberFromName ("line")].Value; string message = m.Groups[m_WarningRegex.GroupNumberFromName ("message")].Value; result.AddWarning (fileName, Int32.Parse (lineNum), 0, String.Empty, message); } // Extract potential SyntaxError foreach (Match m in m_ErrorRegex.Matches (output)) { string lineNum = m.Groups[m_ErrorRegex.GroupNumberFromName ("line")].Value; result.AddError (fileName, Int32.Parse (lineNum), 0, String.Empty, "SyntaxError"); } }
private void OnProjectLoaded(object sender, ProjectEventArgs e) { var pyProj = PythonProject.FromObject(e.Project); if (pyProj != null) { var analyzer = pyProj.Analyzer; if (analyzer != null) { _projectInfo[pyProj] = new ProjectInfo(this, pyProj); } } TestContainersUpdated?.Invoke(this, EventArgs.Empty); }
public TestContainer GetTestContainer(PythonProject project, string path) { ProjectInfo projectInfo; if (_projectInfo.TryGetValue(project, out projectInfo)) { TestContainer container; if (projectInfo.TryGetContainer(path, out container)) { return(container); } } return(null); }
public void SetUpFixture() { MSBuildEngineHelper.InitMSBuildEngine(); List <LanguageBindingDescriptor> bindings = new List <LanguageBindingDescriptor>(); using (TextReader reader = PythonBindingAddInFile.ReadAddInFile()) { AddIn addin = AddIn.Load(reader, String.Empty); bindings.Add(new LanguageBindingDescriptor(AddInHelper.GetCodon(addin, "/SharpDevelop/Workbench/LanguageBindings", "Python"))); } LanguageBindingService.SetBindings(bindings); // Set up IProjectContent so the ConvertProjectToPythonProjectCommand can // locate the startup object and determine it's filename. mockProjectContent = new MockProjectContent(); MockClass mainClass = new MockClass(mockProjectContent, startupObject); mainClass.CompilationUnit.FileName = @"d:\projects\test\src\Main2.cs"; mockProjectContent.ClassToReturnFromGetClass = mainClass; mockTextEditorProperties = new MockTextEditorProperties(); convertProjectCommand = new DerivedConvertProjectToPythonProjectCommand(mockTextEditorProperties); convertProjectCommand.ProjectContent = mockProjectContent; mockTextEditorProperties.Encoding = Encoding.Unicode; Solution solution = new Solution(); sourceProject = new MSBuildBasedProject(solution.BuildEngine); sourceProject.Parent = solution; sourceProject.FileName = @"d:\projects\test\source.csproj"; sourceProject.SetProperty(null, null, "StartupObject", startupObject, PropertyStorageLocations.Base, true); mainFile = new FileProjectItem(sourceProject, ItemType.Compile, @"src\Main.cs"); targetProject = (PythonProject)convertProjectCommand.CallCreateProject(@"d:\projects\test\converted", sourceProject); convertProjectCommand.CallCopyProperties(sourceProject, targetProject); targetMainFile = new FileProjectItem(targetProject, mainFile.ItemType, mainFile.Include); mainFile.CopyMetadataTo(targetMainFile); main2File = new FileProjectItem(sourceProject, ItemType.Compile, @"src\Main2.cs"); targetMain2File = new FileProjectItem(targetProject, main2File.ItemType, main2File.Include); main2File.CopyMetadataTo(targetMain2File); convertProjectCommand.AddParseableFileContent(mainFile.FileName, mainSource); convertProjectCommand.AddParseableFileContent(main2File.FileName, main2Source); convertProjectCommand.CallConvertFile(mainFile, targetMainFile); convertProjectCommand.CallConvertFile(main2File, targetMain2File); }
private async Task OnProjectLoadedAsync(IVsProject project) { var pyProj = PythonProject.FromObject(project); if (pyProj != null) { var analyzer = await pyProj.GetAnalyzerAsync(); if (analyzer != null) { _projectInfo[pyProj] = new ProjectInfo(this, pyProj); } } TestContainersUpdated?.Invoke(this, EventArgs.Empty); }
private void OnProjectUnloaded(object sender, ProjectEventArgs e) { if (e.Project != null) { var pyProj = PythonProject.FromObject(e.Project); ProjectInfo events; if (pyProj != null && _projectInfo.TryGetValue(pyProj, out events) && _projectInfo.Remove(pyProj)) { events.Dispose(); } } TestContainersUpdated?.Invoke(this, EventArgs.Empty); }
public override void Apply() { Project.SetProjectProperty(CommonConstants.StartupFile, _control.StartupFile); Project.SetProjectProperty(CommonConstants.WorkingDirectory, _control.WorkingDirectory); Project.SetProjectProperty(CommonConstants.IsWindowsApplication, _control.IsWindowsApplication.ToString()); var interp = _control.DefaultInterpreter; if (interp != null && !PythonProject.InterpreterFactories.Contains(interp)) { PythonProject.AddInterpreter(interp.Configuration.Id); } PythonProject.SetInterpreterFactory(_control.DefaultInterpreter); IsDirty = false; LoadSettings(); }
private static TestFrameworkType GetTestFramework(PythonProject pyProj) { var testFrameworkType = TestFrameworkType.None; try { string testFrameworkStr = pyProj.GetProperty(PythonConstants.TestFrameworkSetting); if (Enum.TryParse <TestFrameworkType>(testFrameworkStr, ignoreCase: true, out TestFrameworkType parsedFramework)) { testFrameworkType = parsedFramework; } } catch (Exception ex) when(!ex.IsCriticalException()) { Trace.WriteLine("Exception : " + ex.Message); } return(testFrameworkType); }
public void SetUp() { PythonMSBuildEngineHelper.InitMSBuildEngine(); ProjectCreateInformation info = new ProjectCreateInformation(); info.Solution = new Solution(new MockProjectChangeWatcher()); info.ProjectName = "Test"; info.OutputProjectFileName = @"C:\Projects\Test\Test.pyproj"; info.RootNamespace = "Test"; project = new PythonProject(info); compilingOptionsPanel = new DerivedCompilingOptionsPanel(); compilingOptionsPanel.Owner = project; compilingOptionsPanel.LoadPanelContents(); }
public void SetUp() { MSBuildEngineHelper.InitMSBuildEngine(); ProjectCreateInformation info = new ProjectCreateInformation(); info.Solution = new Solution(); info.ProjectName = "Test"; info.OutputProjectFileName = @"C:\Projects\Test\Test.pyproj"; info.RootNamespace = "Test"; project = new PythonProject(info); appSettingsPanel = new DerivedApplicationSettingsPanel(); appSettingsPanel.CustomizationObject = project; appSettingsPanel.LoadPanelContents(); }
public void SetUpFixture() { MSBuildEngineHelper.InitMSBuildEngine(); List <LanguageBindingDescriptor> bindings = new List <LanguageBindingDescriptor>(); using (TextReader reader = PythonBindingAddInFile.ReadAddInFile()) { AddIn addin = AddIn.Load(reader, String.Empty); bindings.Add(new LanguageBindingDescriptor(AddInHelper.GetCodon(addin, "/SharpDevelop/Workbench/LanguageBindings", "Python"))); } LanguageBindingService.SetBindings(bindings); mockTextEditorProperties = new MockTextEditorProperties(); convertProjectCommand = new DerivedConvertProjectToPythonProjectCommand(mockTextEditorProperties); mockTextEditorProperties.Encoding = Encoding.Unicode; sourceProject = new MockProject(); sourceProject.Directory = @"d:\projects\test"; source = new FileProjectItem(sourceProject, ItemType.Compile, @"src\Program.cs"); targetProject = (PythonProject)convertProjectCommand.CallCreateProject(@"d:\projects\test\converted", sourceProject); target = new FileProjectItem(targetProject, source.ItemType, source.Include); source.CopyMetadataTo(target); textFileSource = new FileProjectItem(sourceProject, ItemType.None, @"src\readme.txt"); textFileTarget = new FileProjectItem(targetProject, textFileSource.ItemType, textFileSource.Include); textFileSource.CopyMetadataTo(textFileTarget); foreach (ProjectItem item in targetProject.Items) { ReferenceProjectItem reference = item as ReferenceProjectItem; if ((reference != null) && (reference.Name == "IronPython")) { ironPythonReference = reference; break; } } convertProjectCommand.AddParseableFileContent(source.FileName, sourceCode); convertProjectCommand.CallConvertFile(source, target); convertProjectCommand.CallConvertFile(textFileSource, textFileTarget); }
public void Generate(Builder builder, PythonProject project, List <Project.Configuration> configurations, string projectFile, List <string> generatedFiles, List <string> skipFiles) { _builder = builder; FileInfo fileInfo = new FileInfo(projectFile); string projectPath = fileInfo.Directory.FullName; string projectFileName = fileInfo.Name; bool updated; string projectFileResult = Generate(project, configurations, projectPath, projectFileName, out updated); if (updated) { generatedFiles.Add(projectFileResult); } else { skipFiles.Add(projectFileResult); } _builder = null; }
private void OnProjectUnloaded(object sender, ProjectEventArgs e) { if (e.Project == null) { return; } if (RemoveTestContainers(e.Project.GetProjectHome())) { NotifyContainerChanged(); } // Unregister Properties handler var pyProj = PythonProject.FromObject(e.Project); if (pyProj != null) { pyProj.ProjectPropertyChanged -= OnTestPropertiesChanged; pyProj.ActiveInterpreterChanged -= OnActiveInterpreterChanged; } }
public string GetCurrentTest(string filePath, int line, int lineCharOffset) { var pyProj = PythonProject.FromObject(PathToProject(filePath)); if (pyProj != null) { var container = _discoverer.GetTestContainer(pyProj, filePath); if (container != null) { foreach (var testCase in container.TestCases) { if (testCase.StartLine >= line && line <= testCase.EndLine) { var moduleName = PathUtils.CreateFriendlyFilePath(pyProj.ProjectHome, testCase.Filename); return(moduleName + "::" + testCase.ClassName + "::" + testCase.MethodName); } } } } return(null); }
private string Generate(PythonProject project, List <Project.Configuration> unsortedConfigurations, string projectPath, string projectFile, out bool updated) { var itemGroups = new ItemGroups(); // Need to sort by name and platform List <Project.Configuration> configurations = new List <Project.Configuration>(); configurations.AddRange(unsortedConfigurations.OrderBy(conf => conf.Name + conf.Platform)); string sourceRootPath = project.IsSourceFilesCaseSensitive ? Util.GetCapitalizedPath(project.SourceRootPath) : project.SourceRootPath; Resolver resolver = new Resolver(); using (resolver.NewScopedParameter("guid", configurations.First().ProjectGuid)) using (resolver.NewScopedParameter("projectHome", Util.PathGetRelative(projectPath, sourceRootPath))) using (resolver.NewScopedParameter("startupFile", project.StartupFile)) using (resolver.NewScopedParameter("searchPath", project.SearchPaths.JoinStrings(";"))) { _project = project; _projectConfigurationList = configurations; DevEnvRange devEnvRange = new DevEnvRange(unsortedConfigurations); bool needsPypatching = devEnvRange.MinDevEnv >= DevEnv.vs2017; if (!needsPypatching && (devEnvRange.MinDevEnv != devEnvRange.MaxDevEnv)) { Builder.Instance.LogWarningLine("There are mixed devEnvs for one project. VS2017 or higher Visual Studio solutions will require manual updates."); } MemoryStream memoryStream = new MemoryStream(); StreamWriter writer = new StreamWriter(memoryStream); // xml begin header Write(Template.Project.ProjectBegin, writer, resolver); string defaultInterpreterRegisterKeyName = $@"Software\Microsoft\VisualStudio\{ devEnvRange.MinDevEnv.GetVisualVersionString() }\PythonTools\Options\Interpreters"; var defaultInterpreter = GetRegistryCurrentUserSubKeyValue(defaultInterpreterRegisterKeyName, "DefaultInterpreter", "{00000000-0000-0000-0000-000000000000}"); var defaultInterpreterVersion = GetRegistryCurrentUserSubKeyValue(defaultInterpreterRegisterKeyName, "DefaultInterpreterVersion", "2.7"); string currentInterpreterId = defaultInterpreter; string currentInterpreterVersion = defaultInterpreterVersion; string ptvsTargetsFile = $@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets"; // environments foreach (PythonEnvironment pyEnvironment in _project.Environments) { if (pyEnvironment.IsActivated) { string interpreterRegisterKeyName = $@"Software\Microsoft\VisualStudio\{ devEnvRange.MinDevEnv.GetVisualVersionString() }\PythonTools\Interpreters\{{{pyEnvironment.Guid}}}"; string interpreterDescription = GetRegistryCurrentUserSubKeyValue(interpreterRegisterKeyName, "Description", ""); if (interpreterDescription != string.Empty) { currentInterpreterId = $"{{{pyEnvironment.Guid}}}"; currentInterpreterVersion = GetRegistryCurrentUserSubKeyValue(interpreterRegisterKeyName, "Version", currentInterpreterVersion); } } } // virtual environments foreach (PythonVirtualEnvironment virtualEnvironment in _project.VirtualEnvironments) { if (virtualEnvironment.IsDefault) { string baseInterpreterRegisterKeyName = $@"Software\Microsoft\VisualStudio\{ devEnvRange.MinDevEnv.GetVisualVersionString() }\PythonTools\Interpreters\{{{virtualEnvironment.BaseInterpreterGuid}}}"; string baseInterpreterDescription = GetRegistryCurrentUserSubKeyValue(baseInterpreterRegisterKeyName, "Description", ""); if (baseInterpreterDescription != string.Empty) { currentInterpreterId = $"{{{virtualEnvironment.Guid}}}"; currentInterpreterVersion = GetRegistryCurrentUserSubKeyValue(baseInterpreterRegisterKeyName, "Version", currentInterpreterVersion); } } } // Project description if (needsPypatching) { currentInterpreterId = $"MSBuild|debug|$(MSBuildProjectFullPath)"; ptvsTargetsFile = FileGeneratorUtilities.RemoveLineTag; } using (resolver.NewScopedParameter("interpreterId", currentInterpreterId)) using (resolver.NewScopedParameter("interpreterVersion", currentInterpreterVersion)) using (resolver.NewScopedParameter("ptvsTargetsFile", ptvsTargetsFile)) { Write(Template.Project.ProjectDescription, writer, resolver); } GenerateItems(writer, resolver); string baseGuid = FileGeneratorUtilities.RemoveLineTag; foreach (PythonVirtualEnvironment virtualEnvironment in _project.VirtualEnvironments) { baseGuid = needsPypatching ? baseGuid : virtualEnvironment.BaseInterpreterGuid.ToString(); string pyVersion = string.IsNullOrEmpty(virtualEnvironment.Version) ? currentInterpreterVersion : virtualEnvironment.Version; Write(Template.Project.ProjectItemGroupBegin, writer, resolver); using (resolver.NewScopedParameter("name", virtualEnvironment.Name)) using (resolver.NewScopedParameter("version", pyVersion)) using (resolver.NewScopedParameter("basePath", virtualEnvironment.Path)) using (resolver.NewScopedParameter("baseGuid", baseGuid)) using (resolver.NewScopedParameter("guid", virtualEnvironment.Guid)) { Write(Template.Project.VirtualEnvironmentInterpreter, writer, resolver); } Write(Template.Project.ProjectItemGroupEnd, writer, resolver); } Write(Template.Project.ProjectItemGroupBegin, writer, resolver); if (_project.Environments.Count > 0) { foreach (PythonEnvironment pyEnvironment in _project.Environments) { // Verify if the interpreter exists in the register. string interpreterRegisterKeyName = $@"Software\Microsoft\VisualStudio\{ devEnvRange.MinDevEnv.GetVisualVersionString() }\PythonTools\Interpreters\{{{pyEnvironment.Guid}}}"; string interpreterDescription = GetRegistryCurrentUserSubKeyValue(interpreterRegisterKeyName, "Description", ""); if (interpreterDescription != string.Empty) { string interpreterVersion = GetRegistryCurrentUserSubKeyValue(interpreterRegisterKeyName, "Version", currentInterpreterVersion); using (resolver.NewScopedParameter("guid", $"{{{pyEnvironment.Guid}}}")) using (resolver.NewScopedParameter("version", interpreterVersion)) { Write(Template.Project.InterpreterReference, writer, resolver); } } } } else if (_project.VirtualEnvironments.Count == 0) // Set the default interpreter { using (resolver.NewScopedParameter("guid", currentInterpreterId)) using (resolver.NewScopedParameter("version", currentInterpreterVersion)) { Write(Template.Project.InterpreterReference, writer, resolver); } } Write(Template.Project.ProjectItemGroupEnd, writer, resolver); // configuration general foreach (Project.Configuration conf in _projectConfigurationList) { foreach (var dependencies in new[] { conf.ResolvedPublicDependencies, conf.DotNetPrivateDependencies.Select(x => x.Configuration) }) { foreach (var dependency in dependencies) { string relativeToProjectFile = Util.PathGetRelative(sourceRootPath, dependency.ProjectFullFileNameWithExtension); bool privateDependency = project.DependenciesCopyLocal.HasFlag(Project.DependenciesCopyLocalTypes.ProjectReferences); conf.GetDependencySetting(dependency.Project.GetType()); itemGroups.ProjectReferences.Add(new ItemGroups.ProjectReference { Include = relativeToProjectFile, Name = dependency.ProjectName, Private = privateDependency ? "True" : "False", Project = new Guid(dependency.ProjectGuid) }); } } } GenerateFolders(writer, resolver); // Import native Python Tools project if (needsPypatching) { Write(Template.Project.ImportPythonTools, writer, resolver); } writer.Write(itemGroups.Resolve(resolver)); Write(Template.Project.ProjectEnd, writer, resolver); // Write the project file writer.Flush(); // remove all line that contain RemoveLineTag memoryStream = Util.RemoveLineTags(memoryStream, FileGeneratorUtilities.RemoveLineTag); memoryStream.Seek(0, SeekOrigin.Begin); FileInfo projectFileInfo = new FileInfo(projectPath + @"\" + projectFile + ProjectExtension); updated = _builder.Context.WriteGeneratedFile(project.GetType(), projectFileInfo, memoryStream); writer.Close(); _project = null; return(projectFileInfo.FullName); } }
public void Compile(PythonProject project, FilePath fileName, PythonConfiguration config, BuildResult result) { if (String.IsNullOrEmpty(fileName)) { throw new ArgumentNullException("fileName"); } else if (config == null) { throw new ArgumentNullException("config"); } else if (result == null) { throw new ArgumentNullException("result"); } else if (Runtime == null) { throw new InvalidOperationException("No supported runtime!"); } // Get our relative path within the project if (!fileName.IsChildPathOf(project.BaseDirectory)) { Console.WriteLine("File is not within our project!"); return; } FilePath relName = fileName.ToRelative(project.BaseDirectory); string outFile = relName.ToAbsolute(config.OutputDirectory); if (!outFile.EndsWith(".py")) { return; } // Create the destination directory FileInfo fileInfo = new FileInfo(outFile); if (!fileInfo.Directory.Exists) { fileInfo.Directory.Create(); } // Create and start our process to generate the byte code Process process = BuildCompileProcess(fileName, outFile, config.Optimize); process.Start(); process.WaitForExit(); // Parse errors and warnings string output = process.StandardError.ReadToEnd(); // Extract potential Warnings foreach (Match m in m_WarningRegex.Matches(output)) { string lineNum = m.Groups[m_WarningRegex.GroupNumberFromName("line")].Value; string message = m.Groups[m_WarningRegex.GroupNumberFromName("message")].Value; result.AddWarning(fileName, Int32.Parse(lineNum), 0, String.Empty, message); } // Extract potential SyntaxError foreach (Match m in m_ErrorRegex.Matches(output)) { string lineNum = m.Groups[m_ErrorRegex.GroupNumberFromName("line")].Value; result.AddError(fileName, Int32.Parse(lineNum), 0, String.Empty, "SyntaxError"); } }
private string Generate(PythonProject project, List <Project.Configuration> unsortedConfigurations, string projectPath, string projectFile, out bool updated) { var itemGroups = new ItemGroups(); // Need to sort by name and platform List <Project.Configuration> configurations = new List <Project.Configuration>(); configurations.AddRange(unsortedConfigurations.OrderBy(conf => conf.Name + conf.Platform)); string sourceRootPath = project.IsSourceFilesCaseSensitive ? Util.GetCapitalizedPath(project.SourceRootPath) : project.SourceRootPath; Resolver resolver = new Resolver(); using (resolver.NewScopedParameter("guid", configurations.First().ProjectGuid)) using (resolver.NewScopedParameter("projectHome", Util.PathGetRelative(projectPath, sourceRootPath))) using (resolver.NewScopedParameter("startupFile", project.StartupFile)) using (resolver.NewScopedParameter("searchPath", project.SearchPaths.JoinStrings(";"))) { _project = project; _projectConfigurationList = configurations; DevEnvRange devEnvRange = new DevEnvRange(unsortedConfigurations); MemoryStream memoryStream = new MemoryStream(); StreamWriter writer = new StreamWriter(memoryStream); // xml begin header Write(Template.Project.ProjectBegin, writer, resolver); string defaultInterpreterRegisterKeyName = $@"HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\{ devEnvRange.MinDevEnv.GetVisualVersionString() }\PythonTools\Options\Interpreters"; var defaultInterpreter = (string)Registry.GetValue(defaultInterpreterRegisterKeyName, "DefaultInterpreter", "{}") ?? "{00000000-0000-0000-0000-000000000000}"; var defaultInterpreterVersion = (string)Registry.GetValue(defaultInterpreterRegisterKeyName, "DefaultInterpreterVersion", "2.7") ?? "2.7"; string currentInterpreterId = defaultInterpreter; string currentInterpreterVersion = defaultInterpreterVersion; foreach (PythonEnvironment pyEnvironment in _project.Environments) { if (pyEnvironment.IsActivated) { string interpreterRegisterKeyName = $@"HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\{ devEnvRange.MinDevEnv.GetVisualVersionString() }\PythonTools\Interpreters\{{{pyEnvironment.Guid}}}"; string interpreterDescription = (string)Registry.GetValue(interpreterRegisterKeyName, "Description", ""); if (interpreterDescription != string.Empty) { currentInterpreterId = $"{{{pyEnvironment.Guid}}}"; currentInterpreterVersion = (string)Registry.GetValue(interpreterRegisterKeyName, "Version", currentInterpreterVersion); } } } foreach (PythonVirtualEnvironment virtualEnvironment in _project.VirtualEnvironments) { if (virtualEnvironment.IsDefault) { string baseInterpreterRegisterKeyName = $@"HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\{ devEnvRange.MinDevEnv.GetVisualVersionString() }\PythonTools\Interpreters\{{{virtualEnvironment.BaseInterpreterGuid}}}"; string baseInterpreterDescription = (string)Registry.GetValue(baseInterpreterRegisterKeyName, "Description", ""); if (baseInterpreterDescription != string.Empty) { currentInterpreterId = $"{{{virtualEnvironment.Guid}}}"; currentInterpreterVersion = (string)Registry.GetValue(baseInterpreterRegisterKeyName, "Version", currentInterpreterVersion); } } } using (resolver.NewScopedParameter("interpreterId", currentInterpreterId)) using (resolver.NewScopedParameter("interpreterVersion", currentInterpreterVersion)) { Write(Template.Project.ProjectDescription, writer, resolver); } GenerateItems(writer, resolver); foreach (PythonVirtualEnvironment virtualEnvironment in _project.VirtualEnvironments) { Write(Template.Project.ProjectItemGroupBegin, writer, resolver); using (resolver.NewScopedParameter("name", virtualEnvironment.Name)) using (resolver.NewScopedParameter("version", currentInterpreterVersion)) using (resolver.NewScopedParameter("basePath", virtualEnvironment.Path)) using (resolver.NewScopedParameter("baseGuid", virtualEnvironment.BaseInterpreterGuid)) using (resolver.NewScopedParameter("guid", virtualEnvironment.Guid)) { Write(Template.Project.VirtualEnvironmentInterpreter, writer, resolver); } Write(Template.Project.ProjectItemGroupEnd, writer, resolver); } Write(Template.Project.ProjectItemGroupBegin, writer, resolver); if (_project.Environments.Count > 0) { foreach (PythonEnvironment pyEnvironment in _project.Environments) { // Verify if the interpreter exists in the register. string interpreterRegisterKeyName = $@"HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\{ devEnvRange.MinDevEnv.GetVisualVersionString() }\PythonTools\Interpreters\{{{pyEnvironment.Guid}}}"; string interpreterDescription = (string)Registry.GetValue(interpreterRegisterKeyName, "Description", ""); if (interpreterDescription != string.Empty) { string interpreterVersion = (string)Registry.GetValue(interpreterRegisterKeyName, "Version", currentInterpreterVersion); using (resolver.NewScopedParameter("guid", $"{{{pyEnvironment.Guid}}}")) using (resolver.NewScopedParameter("version", interpreterVersion)) { Write(Template.Project.InterpreterReference, writer, resolver); } } } } else if (_project.VirtualEnvironments.Count == 0) // Set the default interpreter { using (resolver.NewScopedParameter("guid", currentInterpreterId)) using (resolver.NewScopedParameter("version", currentInterpreterVersion)) { Write(Template.Project.InterpreterReference, writer, resolver); } } Write(Template.Project.ProjectItemGroupEnd, writer, resolver); // configuration general foreach (Project.Configuration conf in _projectConfigurationList) { foreach (var dependencies in new[] { conf.ResolvedPublicDependencies, conf.DotNetPrivateDependencies.Select(x => x.Configuration) }) { foreach (var dependency in dependencies) { string relativeToProjectFile = Util.PathGetRelative(sourceRootPath, dependency.ProjectFullFileNameWithExtension); bool privateDependency = project.DependenciesCopyLocal.HasFlag(Project.DependenciesCopyLocalTypes.ProjectReferences); conf.GetDependencySetting(dependency.Project.GetType()); itemGroups.ProjectReferences.Add(new ItemGroups.ProjectReference { Include = relativeToProjectFile, Name = dependency.ProjectName, Private = privateDependency ? "True" : "False", Project = new Guid(dependency.ProjectGuid) }); } } } GenerateFolders(writer, resolver); writer.Write(itemGroups.Resolve(resolver)); Write(Template.Project.ProjectEnd, writer, resolver); // Write the project file writer.Flush(); // remove all line that contain RemoveLineTag memoryStream.Seek(0, SeekOrigin.Begin); FileInfo projectFileInfo = new FileInfo(projectPath + @"\" + projectFile + ProjectExtension); updated = _builder.Context.WriteGeneratedFile(project.GetType(), projectFileInfo, memoryStream); writer.Close(); _project = null; return(projectFileInfo.FullName); } }
public void IsTestProjectReturnsFalseForNullPythonProject() { PythonProject project = null; Assert.IsFalse(testFramework.IsTestProject(project)); }
public void Generate(Builder builder, PythonProject project, List <Project.Configuration> configurations, string projectFile, List <string> generatedFiles, List <string> skipFiles) { PyprojGenerator.Generate(builder, project, configurations, projectFile, generatedFiles, skipFiles); }
internal bool IsProjectKnown(IVsProject project) { var pyProj = PythonProject.FromObject(project); return(pyProj != null && _projectInfo.ContainsKey(pyProj)); }