/// <summary> /// Sets up a limited service provider which can be used for testing. /// /// This will not include many of the services which are typically available in /// VS but is suitable for simple test cases which need just some base functionality. /// </summary> public static MockServiceProvider CreateMockServiceProvider() { var serviceProvider = new MockServiceProvider(); serviceProvider.ComponentModel.AddExtension( typeof(IErrorProviderFactory), () => new MockErrorProviderFactory() ); serviceProvider.ComponentModel.AddExtension( typeof(IContentTypeRegistryService), () => new MockClassificationTypeRegistryService() ); #if DEV14_OR_LATER serviceProvider.ComponentModel.AddExtension( typeof(IInteractiveWindowCommandsFactory), () => new MockInteractiveWindowCommandsFactory() ); #endif serviceProvider.AddService(typeof(ErrorTaskProvider), CreateTaskProviderService, true); serviceProvider.AddService(typeof(CommentTaskProvider), CreateTaskProviderService, true); serviceProvider.AddService(typeof(UIThreadBase), new MockUIThread()); var optionsService = new MockPythonToolsOptionsService(); serviceProvider.AddService(typeof(IPythonToolsOptionsService), optionsService, true); var ptvsService = new PythonToolsService(serviceProvider); serviceProvider.AddService(typeof(PythonToolsService), ptvsService); return(serviceProvider); }
public UserSpecifiedCondaLocator( [Import(typeof(SVsServiceProvider), AllowDefault = true)] IServiceProvider site = null ) { _site = site; _pythonToolsService = site?.GetPythonToolsService(); }
/// <summary> /// Sets up a limited service provider which can be used for testing. /// /// This will not include many of the services which are typically available in /// VS but is suitable for simple test cases which need just some base functionality. /// </summary> public static MockServiceProvider CreateMockServiceProvider() { var serviceProvider = new MockServiceProvider(); var errorProvider = new MockErrorProviderFactory(); serviceProvider.AddService(typeof(MockErrorProviderFactory), errorProvider, true); serviceProvider.AddService(typeof(SComponentModel), new MockComponentModel()); serviceProvider.AddService( typeof(ErrorTaskProvider), (container, type) => new ErrorTaskProvider(serviceProvider, null, errorProvider), true ); serviceProvider.AddService( typeof(CommentTaskProvider), (container, type) => new CommentTaskProvider(serviceProvider, null, errorProvider), true ); serviceProvider.AddService(typeof(IUIThread), new MockUIThread()); var optionsService = new MockPythonToolsOptionsService(); serviceProvider.AddService(typeof(IPythonToolsOptionsService), optionsService, true); var ptvsService = new PythonToolsService(serviceProvider); serviceProvider.AddService(typeof(PythonToolsService), ptvsService); return(serviceProvider); }
public PythonExperimentalGeneralOptionsSetter( PythonToolsService pyService, bool?noDatabaseFactory = null, bool?autoDetectCondaEnvironments = null, bool?useCondaPackageManager = null ) { _pyService = pyService; var options = _pyService.ExperimentalOptions; if (noDatabaseFactory.HasValue) { _noDatabaseFactory = options.NoDatabaseFactory; options.NoDatabaseFactory = noDatabaseFactory.Value; } if (autoDetectCondaEnvironments.HasValue) { _autoDetectCondaEnvironments = options.AutoDetectCondaEnvironments; options.AutoDetectCondaEnvironments = autoDetectCondaEnvironments.Value; } if (useCondaPackageManager.HasValue) { _useCondaPackageManager = options.UseCondaPackageManager; options.UseCondaPackageManager = useCondaPackageManager.Value; } }
public void Initialize() { // Specifiy PythonTools\NoInterpreterFactories to suppress loading // all providers in tests. var settings = (IVsSettingsManager)_serviceContainer.GetService(typeof(SVsSettingsManager)); IVsWritableSettingsStore store; ErrorHandler.ThrowOnFailure(settings.GetWritableSettingsStore((uint)SettingsScope.Configuration, out store)); ErrorHandler.ThrowOnFailure(store.CreateCollection(@"PythonTools\NoInterpreterFactories")); _serviceContainer.AddService(typeof(IPythonToolsOptionsService), new MockPythonToolsOptionsService()); var errorProvider = new MockErrorProviderFactory(); _serviceContainer.AddService(typeof(MockErrorProviderFactory), errorProvider, true); _serviceContainer.AddService(typeof(IClipboardService), new MockClipboardService()); UIThread.EnsureService(_serviceContainer); _serviceContainer.AddService(typeof(ErrorTaskProvider), CreateTaskProviderService, true); _serviceContainer.AddService(typeof(CommentTaskProvider), CreateTaskProviderService, true); var pyService = new PythonToolsService(_serviceContainer); _onDispose.Add(() => ((IDisposable)pyService).Dispose()); _serviceContainer.AddService(typeof(PythonToolsService), pyService, true); _serviceContainer.AddService(typeof(IPythonLibraryManager), (object)null); // register our project factory... var regProjectTypes = (IVsRegisterProjectTypes)_serviceContainer.GetService(typeof(SVsRegisterProjectTypes)); uint cookie; var guid = Guid.Parse(PythonConstants.ProjectFactoryGuid); regProjectTypes.RegisterProjectType( ref guid, new PythonProjectFactory(_serviceContainer), out cookie ); }
protected override void OnCreate() { base.OnCreate(); _site = (IServiceProvider)this; _pyService = _site.GetPythonToolsService(); #if DEV14_OR_LATER // TODO: Get PYEnvironment added to image list BitmapImageMoniker = KnownMonikers.DockPanel; #else BitmapResourceID = PythonConstants.ResourceIdForReplImages; BitmapIndex = 0; #endif Caption = SR.GetString(SR.Environments); _service = _site.GetComponentModel().GetService<IInterpreterOptionsService>(); _outputWindow = OutputWindowRedirector.GetGeneral(_site); Debug.Assert(_outputWindow != null); _statusBar = _site.GetService(typeof(SVsStatusbar)) as IVsStatusbar; var list = new ToolWindow(); list.ViewCreated += List_ViewCreated; list.CommandBindings.Add(new CommandBinding( EnvironmentView.OpenInteractiveWindow, OpenInteractiveWindow_Executed, OpenInteractiveWindow_CanExecute )); list.CommandBindings.Add(new CommandBinding( EnvironmentView.OpenInteractiveOptions, OpenInteractiveOptions_Executed, OpenInteractiveOptions_CanExecute )); list.CommandBindings.Add(new CommandBinding( EnvironmentPathsExtension.StartInterpreter, StartInterpreter_Executed, StartInterpreter_CanExecute )); list.CommandBindings.Add(new CommandBinding( EnvironmentPathsExtension.StartWindowsInterpreter, StartInterpreter_Executed, StartInterpreter_CanExecute )); list.CommandBindings.Add(new CommandBinding( ApplicationCommands.Help, OnlineHelp_Executed, OnlineHelp_CanExecute )); list.CommandBindings.Add(new CommandBinding( ToolWindow.UnhandledException, UnhandledException_Executed, UnhandledException_CanExecute )); list.Service = _service; Content = list; }
public TemplateCompletionControllerProvider([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider, ICompletionBroker completionBroker, IQuickInfoBroker quickInfoBroker, ISignatureHelpBroker signatureHelpBroker) { _completionBroker = completionBroker; _quickInfoBroker = quickInfoBroker; _signatureHelpBroker = signatureHelpBroker; _pyService = (PythonToolsService)serviceProvider.GetService(typeof(PythonToolsService)); }
private static IEnumerable <string> GetGlobalDebuggerOptions( PythonToolsService pyService, bool allowPauseAtEnd = true, bool alwaysPauseAtEnd = false ) { var options = pyService.DebuggerOptions; if (alwaysPauseAtEnd || allowPauseAtEnd && options.WaitOnAbnormalExit) { yield return(AD7Engine.WaitOnAbnormalExitSetting + "=True"); } if (alwaysPauseAtEnd || allowPauseAtEnd && options.WaitOnNormalExit) { yield return(AD7Engine.WaitOnNormalExitSetting + "=True"); } if (options.TeeStandardOutput) { yield return(AD7Engine.RedirectOutputSetting + "=True"); } if (options.BreakOnSystemExitZero) { yield return(AD7Engine.BreakSystemExitZero + "=True"); } if (options.DebugStdLib) { yield return(AD7Engine.DebugStdLib + "=True"); } }
private EditFilter( IVsTextView vsTextView, ITextView textView, IEditorOperations editorOps, IServiceProvider serviceProvider, IComponentModel model, IOleCommandTarget next ) { _vsTextView = vsTextView; _textView = textView; _editorOps = editorOps; _serviceProvider = serviceProvider; _componentModel = model; _pyService = _serviceProvider.GetPythonToolsService(); _entryService = _componentModel.GetService <AnalysisEntryService>(); _next = next; BraceMatcher.WatchBraceHighlights(textView, _componentModel); if (_next == null) { ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next)); } }
public PythonServiceGeneralOptionsSetter( PythonToolsService pyService, bool?updateSearchPathsWhenAddingLinkedFiles = null, bool?unresolvedImportWarning = null, bool?invalidEncodingWarning = null, bool?clearGlobalPythonPath = null ) { _pyService = pyService; var options = _pyService.GeneralOptions; if (updateSearchPathsWhenAddingLinkedFiles.HasValue) { _updateSearchPathsWhenAddingLinkedFiles = options.UpdateSearchPathsWhenAddingLinkedFiles; options.UpdateSearchPathsWhenAddingLinkedFiles = updateSearchPathsWhenAddingLinkedFiles.Value; } if (unresolvedImportWarning.HasValue) { _unresolvedImportWarning = options.UnresolvedImportWarning; options.UnresolvedImportWarning = unresolvedImportWarning.Value; } if (invalidEncodingWarning.HasValue) { _invalidEncodingWarning = options.InvalidEncodingWarning; options.InvalidEncodingWarning = invalidEncodingWarning.Value; } if (clearGlobalPythonPath.HasValue) { _clearGlobalPythonPath = options.ClearGlobalPythonPath; options.ClearGlobalPythonPath = clearGlobalPythonPath.Value; } }
public PythonVisualStudioApp(DTE dte = null) : base(dte) { var shell = (IVsShell)ServiceProvider.GetService(typeof(SVsShell)); var pkg = new Guid("6dbd7c1e-1f1b-496d-ac7c-c55dae66c783"); IVsPackage pPkg; ErrorHandler.ThrowOnFailure(shell.LoadPackage(ref pkg, out pPkg)); System.Threading.Thread.Sleep(1000); PythonToolsService = ServiceProvider.GetPythonToolsService_NotThreadSafe(); Assert.IsNotNull(PythonToolsService, "Failed to get PythonToolsService"); // Disable AutoListIdentifiers for tests var ao = PythonToolsService.AdvancedOptions; Assert.IsNotNull(ao, "Failed to get AdvancedOptions"); var oldALI = ao.AutoListIdentifiers; ao.AutoListIdentifiers = false; var orwoodProp = Dte.Properties["Environment", "ProjectsAndSolution"].Item("OnRunWhenOutOfDate"); Assert.IsNotNull(orwoodProp, "Failed to get OnRunWhenOutOfDate property"); var oldOrwood = orwoodProp.Value; orwoodProp.Value = 1; OnDispose(() => { ao.AutoListIdentifiers = oldALI; orwoodProp.Value = oldOrwood; }); }
internal void SyncPageWithControlSettings(PythonToolsService pyService) { pyService.DebugInteractiveOptions.ReplSmartHistory = _smartReplHistory.Checked; pyService.DebugInteractiveOptions.PrimaryPrompt = _priPrompt.Text; pyService.DebugInteractiveOptions.SecondaryPrompt = _secPrompt.Text; pyService.DebugInteractiveOptions.LiveCompletionsOnly = _liveCompletionsOnly.Checked; pyService.DebugInteractiveOptions.UseInterpreterPrompts = !_useUserDefinedPrompts.Checked; }
public PythonVisualStudioApp(IServiceProvider site) : base(site) { var shell = (IVsShell)ServiceProvider.GetService(typeof(SVsShell)); var pkg = new Guid("6dbd7c1e-1f1b-496d-ac7c-c55dae66c783"); IVsPackage pPkg; ErrorHandler.ThrowOnFailure(shell.LoadPackage(ref pkg, out pPkg)); System.Threading.Thread.Sleep(1000); PythonToolsService = ServiceProvider.GetPythonToolsService_NotThreadSafe(); Assert.IsNotNull(PythonToolsService, "Failed to get PythonToolsService"); // Disable AutoListIdentifiers for tests var ao = PythonToolsService.AdvancedOptions; Assert.IsNotNull(ao, "Failed to get AdvancedOptions"); var oldALI = ao.AutoListIdentifiers; ao.AutoListIdentifiers = false; var orwoodProp = Dte.Properties["Environment", "ProjectsAndSolution"].Item("OnRunWhenOutOfDate"); Assert.IsNotNull(orwoodProp, "Failed to get OnRunWhenOutOfDate property"); var oldOrwood = orwoodProp.Value; orwoodProp.Value = 1; OnDispose(() => { ao.AutoListIdentifiers = oldALI; orwoodProp.Value = oldOrwood; }); }
/// <summary> /// Sets up a limited service provider which can be used for testing. /// /// This will not include many of the services which are typically available in /// VS but is suitable for simple test cases which need just some base functionality. /// </summary> public static MockServiceProvider CreateMockServiceProvider() { var serviceProvider = new MockServiceProvider(); serviceProvider.ComponentModel.AddExtension( typeof(IErrorProviderFactory), () => new MockErrorProviderFactory() ); serviceProvider.ComponentModel.AddExtension( typeof(IContentTypeRegistryService), CreateContentTypeRegistryService ); serviceProvider.ComponentModel.AddExtension( typeof(IInteractiveWindowCommandsFactory), () => new MockInteractiveWindowCommandsFactory() ); serviceProvider.AddService(typeof(ErrorTaskProvider), CreateTaskProviderService, true); serviceProvider.AddService(typeof(CommentTaskProvider), CreateTaskProviderService, true); serviceProvider.AddService(typeof(UIThreadBase), new MockUIThread()); var optionsService = new MockPythonToolsOptionsService(); serviceProvider.AddService(typeof(IPythonToolsOptionsService), optionsService, true); var ptvsService = new PythonToolsService(serviceProvider); serviceProvider.AddService(typeof(PythonToolsService), ptvsService); return serviceProvider; }
public LanguagePreferences(PythonToolsService service, Guid languageGuid) { _service = service; _service.Site.AssertShellIsInitialized(); _textMgr = (IVsTextManager)service.Site.GetService(typeof(SVsTextManager)); if (_textMgr == null) { throw new NotSupportedException(""); } var langPrefs = new LANGPREFERENCES[1]; langPrefs[0].guidLang = languageGuid; ErrorHandler.ThrowOnFailure(_textMgr.GetUserPreferences(null, null, langPrefs, null)); _preferences = langPrefs[0]; var guid = typeof(IVsTextManagerEvents2).GUID; IConnectionPoint connectionPoint = null; (_textMgr as IConnectionPointContainer)?.FindConnectionPoint(ref guid, out connectionPoint); if (connectionPoint != null) { connectionPoint.Advise(this, out _cookie); } }
public DefaultPythonLauncher(IServiceProvider serviceProvider, PythonToolsService pyService, IPythonProject/*!*/ project) { Utilities.ArgumentNotNull("project", project); _serviceProvider = serviceProvider; _pyService = pyService; _project = project; }
public void Initialize() { // Specifiy PythonTools\NoInterpreterFactories to suppress loading // all providers in tests. var settings = (IVsSettingsManager)_serviceContainer.GetService(typeof(SVsSettingsManager)); IVsWritableSettingsStore store; ErrorHandler.ThrowOnFailure(settings.GetWritableSettingsStore((uint)SettingsScope.Configuration, out store)); ErrorHandler.ThrowOnFailure(store.CreateCollection(@"PythonTools\NoInterpreterFactories")); _serviceContainer.AddService(typeof(IPythonToolsOptionsService), new MockPythonToolsOptionsService()); var errorProvider = new MockErrorProviderFactory(); _serviceContainer.AddService(typeof(MockErrorProviderFactory), errorProvider, true); _serviceContainer.AddService(typeof(IClipboardService), new MockClipboardService()); UIThread.EnsureService(_serviceContainer); _serviceContainer.AddService( typeof(Microsoft.PythonTools.Intellisense.ErrorTaskProvider), new ServiceCreatorCallback((container, type) => { var p = new Microsoft.PythonTools.Intellisense.ErrorTaskProvider(_serviceContainer, null, errorProvider); lock (_onDispose) { _onDispose.Add(() => p.Dispose()); } return(p); }), true ); _serviceContainer.AddService( typeof(Microsoft.PythonTools.Intellisense.CommentTaskProvider), new ServiceCreatorCallback((container, type) => { var p = new Microsoft.PythonTools.Intellisense.CommentTaskProvider(_serviceContainer, null, errorProvider); lock (_onDispose) { _onDispose.Add(() => p.Dispose()); } return(p); }), true ); var pyService = new PythonToolsService(_serviceContainer); _serviceContainer.AddService(typeof(PythonToolsService), pyService, true); _serviceContainer.AddService(typeof(IPythonLibraryManager), (object)null); // register our project factory... var regProjectTypes = (IVsRegisterProjectTypes)_serviceContainer.GetService(typeof(SVsRegisterProjectTypes)); uint cookie; var guid = Guid.Parse(PythonConstants.ProjectFactoryGuid); regProjectTypes.RegisterProjectType( ref guid, new PythonProjectFactory(_serviceContainer), out cookie ); }
internal SmartIndentProvider( [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider, PythonEditorServices editorServices ) { _pyService = serviceProvider.GetPythonToolsService(); _editorServices = editorServices; }
internal void SyncPageWithControlSettings(PythonToolsService pyService) { pyService.DebuggerOptions.PromptBeforeRunningWithBuildError = _promptOnBuildError.Checked; pyService.DebuggerOptions.WaitOnAbnormalExit = _waitOnAbnormalExit.Checked; pyService.DebuggerOptions.WaitOnNormalExit = _waitOnNormalExit.Checked; pyService.DebuggerOptions.TeeStandardOutput = _teeStdOut.Checked; pyService.DebuggerOptions.BreakOnSystemExitZero = _breakOnSystemExitZero.Checked; pyService.DebuggerOptions.DebugStdLib = _debugStdLib.Checked; }
internal PythonInteractiveOptions(PythonToolsService pyService, string category) { _pyService = pyService; _category = category; _completionMode = ReplIntellisenseMode.DontEvaluateCalls; _smartHistory = true; _scripts = string.Empty; Load(); }
internal void SetPythonToolsService(PythonToolsService service) { if (_python != null) { throw new InvalidOperationException("Multiple services created"); } _python = service; }
internal void SyncControlWithPageSettings(PythonToolsService pyService) { _smartReplHistory.Checked = pyService.DebugInteractiveOptions.ReplSmartHistory; ReplIntellisenseMode = pyService.DebugInteractiveOptions.ReplIntellisenseMode; _priPrompt.Text = pyService.DebugInteractiveOptions.PrimaryPrompt; _secPrompt.Text = pyService.DebugInteractiveOptions.SecondaryPrompt; EnableUserDefinedPrompts(!pyService.DebugInteractiveOptions.UseInterpreterPrompts); _liveCompletionsOnly.Checked = pyService.DebugInteractiveOptions.LiveCompletionsOnly; }
public DefaultPythonLauncher(IServiceProvider serviceProvider, PythonToolsService pyService, IPythonProject /*!*/ project) { Utilities.ArgumentNotNull("project", project); _serviceProvider = serviceProvider; _pyService = pyService; _project = project; }
internal void SyncControlWithPageSettings(PythonToolsService pyService) { _promptOnBuildError.Checked = pyService.DebuggerOptions.PromptBeforeRunningWithBuildError; _waitOnAbnormalExit.Checked = pyService.DebuggerOptions.WaitOnAbnormalExit; _waitOnNormalExit.Checked = pyService.DebuggerOptions.WaitOnNormalExit; _teeStdOut.Checked = pyService.DebuggerOptions.TeeStandardOutput; _breakOnSystemExitZero.Checked = pyService.DebuggerOptions.BreakOnSystemExitZero; _debugStdLib.Checked = pyService.DebuggerOptions.DebugStdLib; }
internal PythonInteractiveOptions(PythonToolsService pyService, string category) { _pyService = pyService; _category = category; _completionMode = ReplIntellisenseMode.DontEvaluateCalls; _smartHistory = true; _scripts = string.Empty; }
protected override void OnCreate() { base.OnCreate(); _site = (IServiceProvider)this; _pyService = _site.GetPythonToolsService(); // TODO: Get PYEnvironment added to image list BitmapImageMoniker = KnownMonikers.DockPanel; Caption = Strings.Environments; _service = _site.GetComponentModel().GetService <IInterpreterOptionsService>(); _outputWindow = OutputWindowRedirector.GetGeneral(_site); Debug.Assert(_outputWindow != null); _statusBar = _site.GetService(typeof(SVsStatusbar)) as IVsStatusbar; var list = new ToolWindow(); list.Site = _site; list.ViewCreated += List_ViewCreated; list.CommandBindings.Add(new CommandBinding( EnvironmentView.OpenInteractiveWindow, OpenInteractiveWindow_Executed, OpenInteractiveWindow_CanExecute )); list.CommandBindings.Add(new CommandBinding( EnvironmentView.OpenInteractiveOptions, OpenInteractiveOptions_Executed, OpenInteractiveOptions_CanExecute )); list.CommandBindings.Add(new CommandBinding( EnvironmentPathsExtension.StartInterpreter, StartInterpreter_Executed, StartInterpreter_CanExecute )); list.CommandBindings.Add(new CommandBinding( EnvironmentPathsExtension.StartWindowsInterpreter, StartInterpreter_Executed, StartInterpreter_CanExecute )); list.CommandBindings.Add(new CommandBinding( ApplicationCommands.Help, OnlineHelp_Executed, OnlineHelp_CanExecute )); list.CommandBindings.Add(new CommandBinding( ToolWindow.UnhandledException, UnhandledException_Executed, UnhandledException_CanExecute )); list.Service = _service; Content = list; }
public ProfiledProcess(PythonToolsService pyService, string exe, string args, string dir, Dictionary <string, string> envVars) { var arch = NativeMethods.GetBinaryType(exe); if (arch != ProcessorArchitecture.X86 && arch != ProcessorArchitecture.Amd64) { throw new InvalidOperationException(Strings.UnsupportedArchitecture.FormatUI(arch)); } dir = PathUtils.TrimEndSeparator(dir); if (string.IsNullOrEmpty(dir)) { dir = "."; } _pyService = pyService; _exe = exe; _args = args; _dir = dir; _arch = arch; ProcessStartInfo processInfo; string pythonInstallDir = Path.GetDirectoryName(PythonToolsInstallPath.GetFile("VsPyProf.dll", typeof(ProfiledProcess).Assembly)); string dll = _arch == ProcessorArchitecture.Amd64 ? "VsPyProf.dll" : "VsPyProfX86.dll"; string arguments = string.Join(" ", ProcessOutput.QuoteSingleArgument(Path.Combine(pythonInstallDir, "proflaun.py")), ProcessOutput.QuoteSingleArgument(Path.Combine(pythonInstallDir, dll)), ProcessOutput.QuoteSingleArgument(dir), _args ); processInfo = new ProcessStartInfo(_exe, arguments); if (_pyService.DebuggerOptions.WaitOnNormalExit) { processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_NORMAL_EXIT"] = "1"; } if (_pyService.DebuggerOptions.WaitOnAbnormalExit) { processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_ABNORMAL_EXIT"] = "1"; } processInfo.CreateNoWindow = false; processInfo.UseShellExecute = false; processInfo.RedirectStandardOutput = false; processInfo.WorkingDirectory = _dir; if (envVars != null) { foreach (var keyValue in envVars) { processInfo.EnvironmentVariables[keyValue.Key] = keyValue.Value; } } _process = new Process(); _process.StartInfo = processInfo; }
private async Task AddDropDownBarAsync(PythonToolsService service) { var prefs = await _pyService.GetLangPrefsAsync(); if (prefs.NavigationBar) { AddDropDownBar(false); } }
public LibraryNodeVisitor(PythonToolsService pyService, PythonNavigateToItemProvider itemProvider, INavigateToCallback navCallback, string searchValue) { _pyService = pyService; _itemProvider = itemProvider; _navCallback = navCallback; _searchValue = searchValue; _path.Push(null); _comparer = new FuzzyStringMatcher(_pyService.AdvancedOptions.SearchMode); _regexComparer = new FuzzyStringMatcher(FuzzyMatchMode.RegexIgnoreCase); }
internal void SyncPageWithControlSettings(PythonToolsService pyService) { pyService.GeneralOptions.ShowOutputWindowForVirtualEnvCreate = _showOutputWindowForVirtualEnvCreate.Checked; pyService.GeneralOptions.ShowOutputWindowForPackageInstallation = _showOutputWindowForPackageInstallation.Checked; pyService.GeneralOptions.PromptForEnvCreate = _promptForEnvCreate.Checked; pyService.GeneralOptions.PromptForPackageInstallation = _promptForPackageInstallation.Checked; pyService.GeneralOptions.PromptForTestFrameWorkInfoBar = _promptForPytestEnableAndInstall.Checked; pyService.GeneralOptions.ElevatePip = _elevatePip.Checked; pyService.GeneralOptions.ClearGlobalPythonPath = _clearGlobalPythonPath.Checked; }
internal void SyncControlWithPageSettings(PythonToolsService pyService) { _showOutputWindowForVirtualEnvCreate.Checked = pyService.GeneralOptions.ShowOutputWindowForVirtualEnvCreate; _showOutputWindowForPackageInstallation.Checked = pyService.GeneralOptions.ShowOutputWindowForPackageInstallation; _promptForEnvCreate.Checked = pyService.GeneralOptions.PromptForEnvCreate; _promptForPackageInstallation.Checked = pyService.GeneralOptions.PromptForPackageInstallation; _promptForPytestEnableAndInstall.Checked = pyService.GeneralOptions.PromptForTestFrameWorkInfoBar; _elevatePip.Checked = pyService.GeneralOptions.ElevatePip; _clearGlobalPythonPath.Checked = pyService.GeneralOptions.ClearGlobalPythonPath; }
public TemplateCompletionController( PythonToolsService pyService, ITextView textView, IList<ITextBuffer> subjectBuffers, ICompletionBroker completionBroker, IQuickInfoBroker quickInfoBroker, ISignatureHelpBroker signatureBroker) : base(textView, subjectBuffers, completionBroker, quickInfoBroker, signatureBroker) { _pyService = pyService; }
internal PythonInteractiveCommonOptions(PythonToolsService pyService, string category, string id) { _pyService = pyService; _category = category; _id = id; _priPrompt = DefaultPrompt; _secPrompt = DefaultSecondaryPrompt; _interpreterPrompts = true; _replIntellisenseMode = ReplIntellisenseMode.DontEvaluateCalls; _smartHistory = true; }
public EditFilter(ITextView textView, IEditorOperations editorOps, IServiceProvider serviceProvider) { _textView = textView; _textView.Properties[typeof(EditFilter)] = this; _editorOps = editorOps; _serviceProvider = serviceProvider; _componentModel = _serviceProvider.GetComponentModel(); _pyService = _serviceProvider.GetPythonToolsService(); BraceMatcher.WatchBraceHighlights(textView, _componentModel); }
/// <summary> /// Sets up a limited service provider which can be used for testing. /// /// This will not include many of the services which are typically available in /// VS but is suitable for simple test cases which need just some base functionality. /// </summary> public static MockServiceProvider CreateMockServiceProvider( bool suppressTaskProvider = true ) { var serviceProvider = new MockServiceProvider(); serviceProvider.ComponentModel.AddExtension( typeof(IErrorProviderFactory), () => new MockErrorProviderFactory() ); serviceProvider.ComponentModel.AddExtension( typeof(IContentTypeRegistryService), CreateContentTypeRegistryService ); serviceProvider.ComponentModel.AddExtension( typeof(IInteractiveWindowCommandsFactory), () => new MockInteractiveWindowCommandsFactory() ); var optService = new Lazy <MockInterpreterOptionsService>(() => new MockInterpreterOptionsService()); serviceProvider.ComponentModel.AddExtension <IInterpreterRegistryService>(() => optService.Value); serviceProvider.ComponentModel.AddExtension <IInterpreterOptionsService>(() => optService.Value); var editorServices = CreatePythonEditorServices(serviceProvider, serviceProvider.ComponentModel); serviceProvider.ComponentModel.AddExtension(() => editorServices); var analysisEntryServiceCreator = new Lazy <AnalysisEntryService>(() => new AnalysisEntryService(new Lazy <PythonEditorServices>(() => editorServices))); serviceProvider.ComponentModel.AddExtension <IAnalysisEntryService>(() => analysisEntryServiceCreator.Value); serviceProvider.ComponentModel.AddExtension(() => analysisEntryServiceCreator.Value); if (suppressTaskProvider) { serviceProvider.AddService(typeof(ErrorTaskProvider), null, true); serviceProvider.AddService(typeof(CommentTaskProvider), null, true); } else { serviceProvider.AddService(typeof(ErrorTaskProvider), CreateTaskProviderService, true); serviceProvider.AddService(typeof(CommentTaskProvider), CreateTaskProviderService, true); } serviceProvider.AddService(typeof(UIThreadBase), new MockUIThread()); var optionsService = new MockPythonToolsOptionsService(); serviceProvider.AddService(typeof(IPythonToolsOptionsService), optionsService, true); var ptvsService = new PythonToolsService(serviceProvider); serviceProvider.AddService(typeof(PythonToolsService), ptvsService); return(serviceProvider); }
internal void SyncControlWithPageSettings(PythonToolsService pyService) { _enterCommits.Checked = pyService.AdvancedOptions.EnterCommitsIntellisense; _intersectMembers.Checked = pyService.AdvancedOptions.IntersectMembers; _filterCompletions.Checked = pyService.AdvancedOptions.FilterCompletions; _completionCommitedBy.Text = pyService.AdvancedOptions.CompletionCommittedBy; _newLineAfterCompleteCompletion.Checked = pyService.AdvancedOptions.AddNewLineAtEndOfFullyTypedWord; _outliningOnOpen.Checked = pyService.AdvancedOptions.EnterOutliningModeOnOpen; _pasteRemovesReplPrompts.Checked = pyService.AdvancedOptions.PasteRemovesReplPrompts; _colorNames.Checked = pyService.AdvancedOptions.ColorNames; _autoListIdentifiers.Checked = pyService.AdvancedOptions.AutoListIdentifiers; }
internal void SyncPageWithControlSettings(PythonToolsService pyService) { pyService.AdvancedOptions.EnterCommitsIntellisense = _enterCommits.Checked; pyService.AdvancedOptions.IntersectMembers = _intersectMembers.Checked; pyService.AdvancedOptions.FilterCompletions = _filterCompletions.Checked; pyService.AdvancedOptions.CompletionCommittedBy = _completionCommitedBy.Text; pyService.AdvancedOptions.AddNewLineAtEndOfFullyTypedWord = _newLineAfterCompleteCompletion.Checked; pyService.AdvancedOptions.EnterOutliningModeOnOpen = _outliningOnOpen.Checked; pyService.AdvancedOptions.PasteRemovesReplPrompts = _pasteRemovesReplPrompts.Checked; pyService.AdvancedOptions.ColorNames = _colorNames.Checked; pyService.AdvancedOptions.AutoListIdentifiers = _autoListIdentifiers.Checked; }
public ProfiledProcess(PythonToolsService pyService, string exe, string args, string dir, Dictionary <string, string> envVars, ProcessorArchitecture arch) { if (arch != ProcessorArchitecture.X86 && arch != ProcessorArchitecture.Amd64) { throw new InvalidOperationException(String.Format("Unsupported architecture: {0}", arch)); } if (dir.EndsWith("\\")) { dir = dir.Substring(0, dir.Length - 1); } if (String.IsNullOrEmpty(dir)) { dir = "."; } _pyService = pyService; _exe = exe; _args = args; _dir = dir; _arch = arch; ProcessStartInfo processInfo; string pythonInstallDir = Path.GetDirectoryName(PythonToolsInstallPath.GetFile("VsPyProf.dll")); string dll = _arch == ProcessorArchitecture.Amd64 ? "VsPyProf.dll" : "VsPyProfX86.dll"; string arguments = "\"" + Path.Combine(pythonInstallDir, "proflaun.py") + "\" " + "\"" + Path.Combine(pythonInstallDir, dll) + "\" " + "\"" + dir + "\" " + _args; processInfo = new ProcessStartInfo(_exe, arguments); if (_pyService.DebuggerOptions.WaitOnNormalExit) { processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_NORMAL_EXIT"] = "1"; } if (_pyService.DebuggerOptions.WaitOnAbnormalExit) { processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_ABNORMAL_EXIT"] = "1"; } processInfo.CreateNoWindow = false; processInfo.UseShellExecute = false; processInfo.RedirectStandardOutput = false; processInfo.WorkingDirectory = _dir; if (envVars != null) { foreach (var keyValue in envVars) { processInfo.EnvironmentVariables[keyValue.Key] = keyValue.Value; } } _process = new Process(); _process.StartInfo = processInfo; }
public TemplateCompletionController( PythonToolsService pyService, ITextView textView, IList <ITextBuffer> subjectBuffers, ICompletionBroker completionBroker, IAsyncQuickInfoBroker quickInfoBroker, ISignatureHelpBroker signatureBroker) : base(textView, subjectBuffers, completionBroker, quickInfoBroker, signatureBroker) { _pyService = pyService; }
public PythonWebLauncher( IServiceProvider serviceProvider, LaunchConfiguration runConfig, LaunchConfiguration debugConfig, LaunchConfiguration defaultConfig ) { _serviceProvider = serviceProvider; _pyService = _serviceProvider.GetPythonToolsService(); _runConfig = runConfig; _debugConfig = debugConfig; _defaultConfig = defaultConfig; }
public PythonDebugReplEvaluator(IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; _pyService = serviceProvider.GetPythonToolsService(); AD7Engine.EngineAttached += new EventHandler<AD7EngineEventArgs>(OnEngineAttached); AD7Engine.EngineDetaching += new EventHandler<AD7EngineEventArgs>(OnEngineDetaching); var dte = _serviceProvider.GetDTE(); if (dte != null) { // running outside of VS, make this work for tests. _debuggerEvents = dte.Events.DebuggerEvents; _debuggerEvents.OnEnterBreakMode += new EnvDTE._dispDebuggerEvents_OnEnterBreakModeEventHandler(OnEnterBreakMode); } }
public ProfiledProcess(PythonToolsService pyService, string exe, string args, string dir, Dictionary<string, string> envVars) { var arch = NativeMethods.GetBinaryType(exe); if (arch != ProcessorArchitecture.X86 && arch != ProcessorArchitecture.Amd64) { throw new InvalidOperationException(String.Format("Unsupported architecture: {0}", arch)); } dir = PathUtils.TrimEndSeparator(dir); if (string.IsNullOrEmpty(dir)) { dir = "."; } _pyService = pyService; _exe = exe; _args = args; _dir = dir; _arch = arch; ProcessStartInfo processInfo; string pythonInstallDir = Path.GetDirectoryName(PythonToolsInstallPath.GetFile("VsPyProf.dll", typeof(ProfiledProcess).Assembly)); string dll = _arch == ProcessorArchitecture.Amd64 ? "VsPyProf.dll" : "VsPyProfX86.dll"; string arguments = string.Join(" ", ProcessOutput.QuoteSingleArgument(Path.Combine(pythonInstallDir, "proflaun.py")), ProcessOutput.QuoteSingleArgument(Path.Combine(pythonInstallDir, dll)), ProcessOutput.QuoteSingleArgument(dir), _args ); processInfo = new ProcessStartInfo(_exe, arguments); if (_pyService.DebuggerOptions.WaitOnNormalExit) { processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_NORMAL_EXIT"] = "1"; } if (_pyService.DebuggerOptions.WaitOnAbnormalExit) { processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_ABNORMAL_EXIT"] = "1"; } processInfo.CreateNoWindow = false; processInfo.UseShellExecute = false; processInfo.RedirectStandardOutput = false; processInfo.WorkingDirectory = _dir; if (envVars != null) { foreach (var keyValue in envVars) { processInfo.EnvironmentVariables[keyValue.Key] = keyValue.Value; } } _process = new Process(); _process.StartInfo = processInfo; }
public ProfiledProcess(PythonToolsService pyService, string exe, string args, string dir, Dictionary<string, string> envVars, ProcessorArchitecture arch) { if (arch != ProcessorArchitecture.X86 && arch != ProcessorArchitecture.Amd64) { throw new InvalidOperationException(String.Format("Unsupported architecture: {0}", arch)); } if (dir.EndsWith("\\")) { dir = dir.Substring(0, dir.Length - 1); } if (String.IsNullOrEmpty(dir)) { dir = "."; } _pyService = pyService; _exe = exe; _args = args; _dir = dir; _arch = arch; ProcessStartInfo processInfo; string pythonInstallDir = Path.GetDirectoryName(PythonToolsInstallPath.GetFile("VsPyProf.dll")); string dll = _arch == ProcessorArchitecture.Amd64 ? "VsPyProf.dll" : "VsPyProfX86.dll"; string arguments = "\"" + Path.Combine(pythonInstallDir, "proflaun.py") + "\" " + "\"" + Path.Combine(pythonInstallDir, dll) + "\" " + "\"" + dir + "\" " + _args; processInfo = new ProcessStartInfo(_exe, arguments); if (_pyService.DebuggerOptions.WaitOnNormalExit) { processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_NORMAL_EXIT"] = "1"; } if (_pyService.DebuggerOptions.WaitOnAbnormalExit) { processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_ABNORMAL_EXIT"] = "1"; } processInfo.CreateNoWindow = false; processInfo.UseShellExecute = false; processInfo.RedirectStandardOutput = false; processInfo.WorkingDirectory = _dir; if (envVars != null) { foreach (var keyValue in envVars) { processInfo.EnvironmentVariables[keyValue.Key] = keyValue.Value; } } _process = new Process(); _process.StartInfo = processInfo; }
public PythonWebLauncher(IServiceProvider serviceProvider, PythonToolsService pyService, IPythonProject project) { _pyService = pyService; _project = project; _serviceProvider = serviceProvider; var project2 = project as IPythonProject2; if (project2 != null) { // The provider may return its own object, but the web launcher only // supports instances of CustomCommand. _runServerCommand = project2.FindCommand(RunWebServerCommand); _debugServerCommand = project2.FindCommand(DebugWebServerCommand); } var portNumber = _project.GetProperty(PythonConstants.WebBrowserPortSetting); int portNum; if (Int32.TryParse(portNumber, out portNum)) { _testServerPort = portNum; } }
private static IEnumerable<string> GetGlobalDebuggerOptions( PythonToolsService pyService, bool allowPauseAtEnd = true, bool alwaysPauseAtEnd = false ) { var options = pyService.DebuggerOptions; if (alwaysPauseAtEnd || allowPauseAtEnd && options.WaitOnAbnormalExit) { yield return AD7Engine.WaitOnAbnormalExitSetting + "=True"; } if (alwaysPauseAtEnd || allowPauseAtEnd && options.WaitOnNormalExit) { yield return AD7Engine.WaitOnNormalExitSetting + "=True"; } if (options.TeeStandardOutput) { yield return AD7Engine.RedirectOutputSetting + "=True"; } if (options.BreakOnSystemExitZero) { yield return AD7Engine.BreakSystemExitZero + "=True"; } if (options.DebugStdLib) { yield return AD7Engine.DebugStdLib + "=True"; } }
private ReplEditFilter( IVsTextView vsTextView, ITextView textView, IEditorOperations editorOps, IServiceProvider serviceProvider, IOleCommandTarget next ) { _vsTextView = vsTextView; _textView = textView; _editorOps = editorOps; _serviceProvider = serviceProvider; _componentModel = _serviceProvider.GetComponentModel(); _pyService = _serviceProvider.GetPythonToolsService(); _interactive = _textView.TextBuffer.GetInteractiveWindow(); _next = next; if (_interactive != null) { _selectEval = _interactive.Evaluator as SelectableReplEvaluator; } if (_selectEval != null) { _selectEval.EvaluatorChanged += EvaluatorChanged; _selectEval.AvailableEvaluatorsChanged += AvailableEvaluatorsChanged; } var mse = _interactive?.Evaluator as IMultipleScopeEvaluator; if (mse != null) { _scopeListVisible = mse.EnableMultipleScopes; mse.AvailableScopesChanged += AvailableScopesChanged; mse.MultipleScopeSupportChanged += MultipleScopeSupportChanged; } if (_next == null && _interactive != null) { ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next)); } }
internal VsProjectAnalyzer( IServiceProvider serviceProvider, IPythonInterpreter interpreter, IPythonInterpreterFactory factory, IPythonInterpreterFactory[] allFactories, bool implicitProject = true ) { _errorProvider = (ErrorTaskProvider)serviceProvider.GetService(typeof(ErrorTaskProvider)); _commentTaskProvider = (CommentTaskProvider)serviceProvider.GetService(typeof(CommentTaskProvider)); _unresolvedSquiggles = new UnresolvedImportSquiggleProvider(serviceProvider, _errorProvider); _queue = new ParseQueue(this); _analysisQueue = new AnalysisQueue(this); _analysisQueue.AnalysisStarted += AnalysisQueue_AnalysisStarted; _allFactories = allFactories; _interpreterFactory = factory; _implicitProject = implicitProject; if (interpreter != null) { _pyAnalyzer = PythonAnalyzer.Create(factory, interpreter); ReloadTask = _pyAnalyzer.ReloadModulesAsync().HandleAllExceptions(SR.ProductName, GetType()); ReloadTask.ContinueWith(_ => ReloadTask = null); interpreter.ModuleNamesChanged += OnModulesChanged; } _projectFiles = new ConcurrentDictionary<string, IProjectEntry>(StringComparer.OrdinalIgnoreCase); _pyService = serviceProvider.GetPythonToolsService(); _serviceProvider = serviceProvider; if (_pyAnalyzer != null) { _pyAnalyzer.Limits.CrossModule = _pyService.GeneralOptions.CrossModuleAnalysisLimit; // TODO: Load other limits from options } _userCount = 1; }
internal PythonAutomation(IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; _pyService = serviceProvider.GetPythonToolsService(); Debug.Assert(_pyService != null, "Did not find PythonToolsService"); }
internal PythonInteractiveOptions(IServiceProvider serviceProvider, PythonToolsService pyService, string category, string id) : base(pyService, category, id) { _serviceProvider = serviceProvider; }
public IronPythonLauncher(IServiceProvider serviceProvider, PythonToolsService pyService, IPythonProject project) { _serviceProvider = serviceProvider; _pyService = pyService; _project = project; }
internal AdvancedEditorOptions(PythonToolsService service) { _service = service; Load(); }
public CodeWindowManager(IServiceProvider serviceProvider, IVsCodeWindow codeWindow) { _serviceProvider = serviceProvider; _window = codeWindow; _pyService = _serviceProvider.GetPythonToolsService(); }
public DefaultLauncherProvider([Import(typeof(SVsServiceProvider))]IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; _pyService = serviceProvider.GetPythonToolsService(); }