public static async Task <ImmutableArray <Diagnostic> > AnalyzeSpellingAsync(
Project project,
SpellingData spellingData,
SpellingFixerOptions options = null,
CancellationToken cancellationToken = default)
{
ISpellingService service = MefWorkspaceServices.Default.GetService <ISpellingService>(project.Language);
if (service == null)
{
return(ImmutableArray <Diagnostic> .Empty);
}
ImmutableArray <Diagnostic> .Builder diagnostics = ImmutableArray.CreateBuilder <Diagnostic>();
foreach (Document document in project.Documents)
{
if (!document.SupportsSyntaxTree)
{
continue;
}
ImmutableArray <Diagnostic> diagnostics2 = await AnalyzeSpellingAsync(
service,
document,
spellingData,
options,
cancellationToken)
.ConfigureAwait(false);
diagnostics.AddRange(diagnostics2);
}
return(diagnostics.ToImmutableArray());
}
private void OnStartup(object sender, StartupEventArgs ea)
{
InitializeSettings();
if (UserSettings == null || AlreadyEditingFile())
{
Shutdown();
return;
}
Activated += OnActivated;
_spellingService = new SpellingService();
var spellCheckProvider = new SpellCheckProvider(_spellingService);
var snippetManager = new SnippetManager();
var mainWindow = new MainWindow(spellCheckProvider, snippetManager);
var windowPlacementSettings = mainWindow.GetWindowPlacementSettings();
if (windowPlacementSettings.UpgradeSettings)
{
windowPlacementSettings.Upgrade();
windowPlacementSettings.UpgradeSettings = false;
windowPlacementSettings.Save();
}
MainWindow = mainWindow;
MainWindow.Show();
}
public DocumentView()
{
InitializeComponent();
Loaded += DocumentViewLoaded;
wb.Loaded += WbLoaded;
wb.OpenExternalLink += WebControl_LinkClicked;
SizeChanged += new SizeChangedEventHandler(DocumentViewSizeChanged);
Editor.TextArea.SelectionChanged += SelectionChanged;
Editor.PreviewMouseLeftButtonUp += HandleMouseUp;
hunspell = IoC.Get <ISpellingService>();
spellCheckRenderer = new SpellCheckBackgroundRenderer();
Editor.TextArea.TextView.BackgroundRenderers.Add(spellCheckRenderer);
Editor.TextArea.TextView.VisualLinesChanged += TextView_VisualLinesChanged;
CommandBindings.Add(new CommandBinding(FormattingCommands.ToggleBold, (x, y) => ToggleBold(), CanEditDocument));
CommandBindings.Add(new CommandBinding(FormattingCommands.ToggleItalic, (x, y) => ToggleItalic(), CanEditDocument));
CommandBindings.Add(new CommandBinding(FormattingCommands.ToggleCode, (x, y) => ToggleCode(), CanEditDocument));
CommandBindings.Add(new CommandBinding(FormattingCommands.ToggleCodeBlock, (x, y) => ToggleCodeBlock(), CanEditDocument));
CommandBindings.Add(new CommandBinding(FormattingCommands.SetHyperlink, (x, y) => SetHyperlink(), CanEditDocument));
}
private void OnStartup(object sender, StartupEventArgs ea)
{
InitializeSettings();
if (UserSettings == null || AlreadyEditingFile())
{
Shutdown();
return;
}
Activated += OnActivated;
_spellingService = new SpellingService();
var spellCheckProvider = new SpellCheckProvider(_spellingService);
var snippetManager = new SnippetManager();
var mainWindow = new MainWindow(spellCheckProvider, snippetManager);
var windowPlacementSettings = mainWindow.GetWindowPlacementSettings();
if (windowPlacementSettings.UpgradeSettings)
{
windowPlacementSettings.Upgrade();
windowPlacementSettings.UpgradeSettings = false;
windowPlacementSettings.Save();
}
MainWindow = mainWindow;
MainWindow.Show();
}
public SpellCheckProvider(ISpellingService spellingService, DocumentView view)
{
_spellingService = spellingService;
_spellCheckRenderer = new SpellCheckBackgroundRenderer();
this.View = view;
this.View.Editor.TextArea.TextView.BackgroundRenderers.Add(_spellCheckRenderer);
this.View.Editor.TextArea.TextView.VisualLinesChanged += TextView_VisualLinesChanged;
}
public SpellCheckProvider(ISpellingService spellingService, IDocumentView view)
{
this.spellingService = spellingService;
spellCheckRenderer = new SpellCheckBackgroundRenderer();
View = view;
View.TextView.BackgroundRenderers.Add(spellCheckRenderer);
View.TextView.VisualLinesChanged += TextViewVisualLinesChanged;
}
public SpellCheckProvider(ISpellingService spellingService, DocumentView view)
{
this.spellingService = spellingService;
spellCheckRenderer = new SpellCheckBackgroundRenderer();
this.view = view;
this.view.Editor.TextArea.TextView.BackgroundRenderers.Add(spellCheckRenderer);
this.view.Editor.TextArea.TextView.VisualLinesChanged += TextViewVisualLinesChanged;
}
public SpellCheckPlugin(
IPluginSettingsProvider settingsProvider,
ISpellingService spellingService,
ISpellCheckProviderFactory spellCheckProviderFactory)
{
_settingsProvider = settingsProvider;
_spellingService = spellingService;
_spellCheckProviderFactory = spellCheckProviderFactory;
_settings = _settingsProvider.GetSettings<SpellCheckPluginSettings>();
_spellingService.SetLanguage(_settings.Language);
}
public SpellCheckPlugin(
IPluginSettingsProvider settingsProvider,
ISpellingService spellingService,
ISpellCheckProviderFactory spellCheckProviderFactory)
{
_settingsProvider = settingsProvider;
_spellingService = spellingService;
_spellCheckProviderFactory = spellCheckProviderFactory;
_settings = _settingsProvider.GetSettings <SpellCheckPluginSettings>();
_spellingService.SetLanguage(_settings.Language);
}
public SettingsViewModel(
ISettingsProvider settingsService,
IEventAggregator eventAggregator,
Func <IPlugin, PluginViewModel> pluginViewModelCreator,
ISpellingService spellingService,
IEnumerable <IPlugin> plugins,
IBlogService blogService)
{
this.settingsService = settingsService;
this.eventAggregator = eventAggregator;
this.pluginViewModelCreator = pluginViewModelCreator;
this.spellingService = spellingService;
this.blogService = blogService;
this.plugins = plugins.ToList();
}
public SettingsViewModel(
ISettingsProvider settingsService,
IEventAggregator eventAggregator,
Func<IPlugin, PluginViewModel> pluginViewModelCreator,
ISpellingService spellingService,
IEnumerable<IPlugin> plugins,
IBlogService blogService)
{
this.settingsService = settingsService;
this.eventAggregator = eventAggregator;
this.pluginViewModelCreator = pluginViewModelCreator;
this.spellingService = spellingService;
this.blogService = blogService;
this.plugins = plugins.ToList();
}
public SettingsViewModel(
ISettingsProvider settingsService,
IWindowManager windowManager,
IEventAggregator eventAggregator,
Func<BlogSettingsViewModel> blogSettingsCreator,
IPluginManager pluginManager,
Func<IPlugin, PluginViewModel> pluginViewModelCreator,
ISpellingService spellingService)
{
this.settingsService = settingsService;
this.windowManager = windowManager;
this.eventAggregator = eventAggregator;
this.blogSettingsCreator = blogSettingsCreator;
this.pluginManager = pluginManager;
this.pluginViewModelCreator = pluginViewModelCreator;
this.spellingService = spellingService;
this.pluginManager.Container.ComposeParts(this);
}
public SettingsViewModel(
ISettingsProvider settingsService,
IWindowManager windowManager,
IEventAggregator eventAggregator,
Func <BlogSettingsViewModel> blogSettingsCreator,
IPluginManager pluginManager,
Func <IPlugin, PluginViewModel> pluginViewModelCreator,
ISpellingService spellingService)
{
this.settingsService = settingsService;
this.windowManager = windowManager;
this.eventAggregator = eventAggregator;
this.blogSettingsCreator = blogSettingsCreator;
this.pluginManager = pluginManager;
this.pluginViewModelCreator = pluginViewModelCreator;
this.spellingService = spellingService;
this.pluginManager.Container.ComposeParts(this);
}
private void OnStartup(object sender, StartupEventArgs ea)
{
InitializeSettings();
Activated += OnActivated;
var markdownConverter = new CommonMarkConverter();
_spellingService = new SpellingService();
var spellCheckProvider = new SpellCheckProvider(_spellingService);
var snippetManager = new SnippetManager();
var mainWindow = new MainWindow(markdownConverter, spellCheckProvider, snippetManager);
var windowPlacementSettings = mainWindow.GetWindowPlacementSettings();
if (windowPlacementSettings.UpgradeSettings)
{
windowPlacementSettings.Upgrade();
windowPlacementSettings.UpgradeSettings = false;
windowPlacementSettings.Save();
}
MainWindow = mainWindow;
MainWindow.Show();
}
public static async Task <ImmutableArray <Diagnostic> > AnalyzeSpellingAsync(
ISpellingService service,
Document document,
SpellingData spellingData,
SpellingFixerOptions options = null,
CancellationToken cancellationToken = default)
{
SyntaxTree tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (tree == null)
{
return(ImmutableArray <Diagnostic> .Empty);
}
if (!options.IncludeGeneratedCode &&
GeneratedCodeUtility.IsGeneratedCode(tree, f => service.SyntaxFacts.IsComment(f), cancellationToken))
{
return(ImmutableArray <Diagnostic> .Empty);
}
SyntaxNode root = await tree.GetRootAsync(cancellationToken).ConfigureAwait(false);
return(service.AnalyzeSpelling(root, spellingData, options, cancellationToken));
}
private void OnStartup(object sender, StartupEventArgs ea)
{
InitializeSettings();
Activated += OnActivated;
var commonmarkConverter = new CommonMarkConverter();
var githubMarkdownConverter = new GitHubMarkdownConverter();
_spellingService = new SpellingService();
var spellCheckProvider = new SpellCheckProvider(_spellingService);
var snippetManager = new SnippetManager();
var mainWindow = new MainWindow(commonmarkConverter, githubMarkdownConverter, spellCheckProvider, snippetManager);
var windowPlacementSettings = mainWindow.GetWindowPlacementSettings();
if (windowPlacementSettings.UpgradeSettings)
{
windowPlacementSettings.Upgrade();
windowPlacementSettings.UpgradeSettings = false;
windowPlacementSettings.Save();
}
MainWindow = mainWindow;
MainWindow.Show();
}
public async Task <ImmutableArray <SpellingFixResult> > FixProjectAsync(
Project project,
CancellationToken cancellationToken = default)
{
project = CurrentSolution.GetProject(project.Id);
ISpellingService service = MefWorkspaceServices.Default.GetService <ISpellingService>(project.Language);
if (service == null)
{
return(ImmutableArray <SpellingFixResult> .Empty);
}
ImmutableArray <Diagnostic> previousDiagnostics = ImmutableArray <Diagnostic> .Empty;
ImmutableArray <Diagnostic> previousPreviousDiagnostics = ImmutableArray <Diagnostic> .Empty;
ImmutableArray <SpellingFixResult> .Builder results = ImmutableArray.CreateBuilder <SpellingFixResult>();
bool nonSymbolsFixed = (Options.ScopeFilter & (SpellingScopeFilter.NonSymbol)) == 0;
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
var compilationWithAnalyzersOptions = new CompilationWithAnalyzersOptions(
options: default(AnalyzerOptions),
onAnalyzerException: default(Action <Exception, DiagnosticAnalyzer, Diagnostic>),
concurrentAnalysis: true,
logAnalyzerExecutionTime: false,
reportSuppressedDiagnostics: false);
Compilation compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
DiagnosticAnalyzer analyzer = service.CreateAnalyzer(SpellingData, Options);
var compilationWithAnalyzers = new CompilationWithAnalyzers(
compilation,
ImmutableArray.Create(analyzer),
compilationWithAnalyzersOptions);
ImmutableArray <Diagnostic> diagnostics = await compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync(cancellationToken).ConfigureAwait(false);
#if DEBUG
foreach (IGrouping <Diagnostic, Diagnostic> grouping in diagnostics
.GroupBy(f => f, DiagnosticDeepEqualityComparer.Instance))
{
using (IEnumerator <Diagnostic> en = grouping.GetEnumerator())
{
if (en.MoveNext() &&
en.MoveNext())
{
Debug.Fail(DiagnosticFormatter.FormatDiagnostic(en.Current));
}
}
}
#endif
int length = diagnostics.Length;
if (length == 0)
{
break;
}
if (length == previousDiagnostics.Length &&
!diagnostics.Except(previousDiagnostics, DiagnosticDeepEqualityComparer.Instance).Any())
{
break;
}
if (length == previousPreviousDiagnostics.Length &&
!diagnostics.Except(previousPreviousDiagnostics, DiagnosticDeepEqualityComparer.Instance).Any())
{
LogHelpers.WriteInfiniteLoopSummary(diagnostics, previousDiagnostics, project, FormatProvider);
break;
}
var spellingDiagnostics = new List <SpellingDiagnostic>();
foreach (Diagnostic diagnostic in diagnostics)
{
Debug.Assert(diagnostic.Id == CommonDiagnosticIdentifiers.PossibleMisspellingOrTypo, diagnostic.Id);
if (diagnostic.Id != CommonDiagnosticIdentifiers.PossibleMisspellingOrTypo)
{
if (diagnostic.IsAnalyzerExceptionDiagnostic())
{
LogHelpers.WriteDiagnostic(diagnostic, baseDirectoryPath: Path.GetDirectoryName(project.FilePath), formatProvider: FormatProvider, indentation: " ", verbosity: Verbosity.Detailed);
}
continue;
}
SpellingDiagnostic spellingDiagnostic = service.CreateSpellingDiagnostic(diagnostic);
spellingDiagnostics.Add(spellingDiagnostic);
}
if (!nonSymbolsFixed)
{
List <SpellingFixResult> commentResults = await FixCommentsAsync(project, spellingDiagnostics, cancellationToken).ConfigureAwait(false);
results.AddRange(commentResults);
nonSymbolsFixed = true;
}
if ((Options.ScopeFilter & SpellingScopeFilter.Symbol) == 0)
{
break;
}
(List <SpellingFixResult> symbolResults, bool allIgnored) = await FixSymbolsAsync(
project,
spellingDiagnostics,
service.SyntaxFacts,
cancellationToken)
.ConfigureAwait(false);
results.AddRange(symbolResults);
if (allIgnored)
{
break;
}
if (Options.DryRun)
{
break;
}
project = CurrentSolution.GetProject(project.Id);
previousPreviousDiagnostics = previousDiagnostics;
previousDiagnostics = diagnostics;
}
return(results.ToImmutableArray());
}
public SpellCheckProvider(ISpellingService spellingService)
{
_spellingService = spellingService;
_spellCheckRenderer = new SpellCheckBackgroundRenderer();
}
public ActionResult Post([FromBody] SpellingRequest request, [FromQuery] string machineLearning, [FromServices] ISpellingService spellingService)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
if (machineLearning != null)
{
#region Machine Learning Service configuration
var machineLearningConfigurationSection = _configuration.GetSection("MachineLearningEndpointSettings");
try
{
this._machineLearningService.AddEndpoint(
new Uri(machineLearningConfigurationSection.GetSection(machineLearning).GetValue <string>("Url")),
machineLearningConfigurationSection.GetSection(machineLearning).GetValue <string>("apiKey"));
}
catch (Exception ex)
{
_logger.LogError($"Machine Learning configuration with name '{machineLearning}' not found");
return(BadRequest(new ArgumentOutOfRangeException("machineLearning")));
}
#endregion
}
var result = spellingService.SuggestCorrectionWithMachineLearning(request.Dictionary, request.Words.ToList(), machineLearning);
result.Wait();
return(new OkObjectResult(result.Result));
}
public ISpellCheckProvider GetProvider(ISpellingService spellingService, IDocumentView view)
{
return new SpellCheckProvider(spellingService, view);
}
public EchoBot(ISpellingService spellingService, IHttpContextAccessor httpContextAccessor)
{
_spellingService = spellingService;
_httpContextAccessor = httpContextAccessor;
}
public SpellCheckExtension(ISpellingService spellingService)
{
this.spellingService = spellingService;
}
public SpellCheckProvider(ISpellingService spellingService)
{
_spellingService = spellingService;
_spellCheckRenderer = new SpellCheckBackgroundRenderer();
}
public ISpellCheckProvider GetProvider(ISpellingService spellingService, IDocumentView view)
{
return(new SpellCheckProvider(spellingService, (DocumentView)view));
}
