feat: support adding words to dictionary with a callback#95
feat: support adding words to dictionary with a callback#95andrew-bekhiet-solid wants to merge 16 commits into
Conversation
![gemini-code-assist[bot]](https://avatars.githubusercontent.com/in/956858?s=60&v=4){kind=small}
There was a problem hiding this comment.
Summary of Changes
Hello @andrew-bekhiet-solid, I'm Gemini Code Assist1! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!
This pull request significantly enhances the spell-checking capabilities by allowing users to maintain a personal dictionary. This feature enables the system to learn and ignore specific words, such as proper nouns or domain-specific terminology, thereby improving the precision and user experience of the spell checker. The changes involve new service implementations, controller updates, and UI adjustments to support this functionality.
Highlights
- Custom Dictionary Support: Introduced the ability to add words to a custom dictionary directly from the mistake popup, enhancing spell-checking accuracy and reducing false positives.
- In-Memory Dictionary Service: Implemented a new
InMemoryDictionaryLanguageCheckServicethat filters spell-check suggestions based on a user-defined, dynamic dictionary. - Text Re-evaluation: Added a
recheckTextmethod toLanguageToolControllerto explicitly re-evaluate the text for mistakes, useful after dictionary updates or configuration changes. - Mistake Popup Enhancements: Improved the
LanguageToolMistakePopupby adding an 'add to dictionary' action and refining its visual layout with adjusted icon sizes and padding. - Example Application Update: The example application now includes a UI for managing the in-memory dictionary, demonstrating the new functionality.
Using Gemini Code Assist
The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.
Invoking Gemini
You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.
| Feature | Command | Description |
|---|---|---|
| Code Review | /gemini review |
Performs a code review for the current pull request in its current state. |
| Pull Request Summary | /gemini summary |
Provides a summary of the current pull request in its current state. |
| Comment | @gemini-code-assist | Responds in comments when explicitly tagged, both in issue comments and review comments. |
| Help | /gemini help |
Displays a list of available commands. |
Customization
To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.
Limitations & Feedback
Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.
You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.
Footnotes
-
Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩
There was a problem hiding this comment.
Code Review
This pull request introduces a great new feature for adding words to a custom dictionary, which will be very useful. The implementation is solid, with a new InMemoryDictionaryLanguageCheckService and UI hooks in the mistake popup. I've provided a few suggestions to improve robustness and flexibility, mainly around error handling for the dictionary callback and making the new service more composable. The example app has also been updated well to showcase the feature, though I have a minor suggestion to prevent potential UI overflows.
|
Thanks @andrew-bekhiet-solid - could you please also add a screenshot? I'm assuming that should be some UI button with it. |
|
Sure here they are:
|
solid-maxim
left a comment
solid-maxim
left a comment
There was a problem hiding this comment.
Hey, @andrew-bekhiet-solid. I've added small suggestions, take a look please.
|
@solid-maxim can you please fix suggestions yourself as well? |
style: move all constants to class static members
ui: use default icon button padding export result to allow custom language check service implementations
refactor: move getDictionary call to be inside success result
andrew-bekhiet-solid
force-pushed
the
feat-support-adding-words-to-dictionary
branch
from
f8bd4de to
587d5dc
Compare
refactor: decouple in memory dictionary from throttling services refactor: move invalid mistakes offset check to ThrottlingLanguageCheckService
|
/gemini review |
There was a problem hiding this comment.
Code Review
This pull request adds support for adding words to a dictionary via an addWordToDictionary callback in LanguageToolMistakePopup, introduces an InMemoryDictionaryLanguageCheckService to post-filter mistakes, and exposes a recheckText method on LanguageToolController. Feedback on these changes identifies a potential race condition in _addWordToDictionaryAndFix that could lead to crashes, and an issue where throttled requests can return stale mistakes, causing incorrect highlights. Additionally, the reviewer suggested calling recheckText() in the example app when adding a word to clear other highlights, and correcting a misleading docstring in InMemoryDictionaryLanguageCheckService.
Important
The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.
| Future<Result<List<Mistake>>?> findMistakes(String text) async { | ||
| return await _throttling | ||
| final result = await _throttling | ||
| .throttle(() => _languageCheckService.findMistakes(text)); | ||
|
|
||
| return result?.map( | ||
| (mistakes) => mistakes.where( | ||
| (mistake) { | ||
| final mistakeHasInvalidOffset = mistake.offset < 0 || | ||
| mistake.offset >= text.length || | ||
| mistake.endOffset < 0 || | ||
| mistake.endOffset > text.length; | ||
|
|
||
| return !mistakeHasInvalidOffset; | ||
| }, | ||
| ).toList(growable: false), | ||
| ); | ||
| } |
There was a problem hiding this comment.
When Throttling.throttle throttles a call, it returns the result of the previous execution (which was for an older version of the text).
While the added bounds check prevents crashes (by filtering out mistakes that are physically out of bounds of the new text), it does not prevent incorrect highlights if the old mistake's offsets happen to be within the bounds of the new text. For example, if the user changes the text from 'helo' to 'them', the old mistake for 'helo' (at offset 0-4) is still within the bounds of 'them' (length 4), so 'them' will be incorrectly highlighted as a mistake with the suggestion 'hello'.
To fix this, we should keep track of the text for which the mistakes were actually retrieved, and return null if the current text does not match.
Here is an example of how this can be implemented by adding a _lastCheckedText field to the class:
String? _lastCheckedText;
@override
Future<Result<List<Mistake>>?> findMistakes(String text) async {
final result = await _throttling.throttle(() async {
_lastCheckedText = text;
return _languageCheckService.findMistakes(text);
});
if (_lastCheckedText != text) {
return null;
}
return result?.map(...);
}There was a problem hiding this comment.
The whole point here is to keep the stale highlights while api fetch is in progress
If we keep checking the latest text, mistakes highlights will keep flashing while the user is typing, so I guess this is a good compromise
| final mistakeStillExists = | ||
| controller.text.substring(mistake.offset, mistake.endOffset) == word; | ||
| if (mistakeStillExists) { | ||
| _fixTheMistake(mistake, word); |
There was a problem hiding this comment.
why do we need to fix it there? Is it just to clear the error while text won't change? If yes - let's add a comment about that because it's not obvious
| LanguageToolController? _spellCheckController; | ||
|
|
||
| LanguageToolController _nonNullController() { | ||
| return _spellCheckController ??= LanguageToolController( | ||
| languageCheckService: InMemoryDictionaryLanguageCheckService( | ||
| languageCheckService: ThrottlingLanguageCheckService( | ||
| LanguageToolService(LanguageToolClient()), | ||
| const Duration(milliseconds: 250), | ||
| ), | ||
| shouldIgnoreMistake: (mistake, text) { | ||
| final word = text.substring(mistake.offset, mistake.endOffset); | ||
|
|
||
| return _dictionary.contains(word); | ||
| }, | ||
| ), | ||
| ); | ||
| } | ||
|
|
||
| @override | ||
| Widget build(BuildContext context) { | ||
| final spellCheckController = _nonNullController(); |
There was a problem hiding this comment.
why not initialise it right away?
| /// This class does not throttle or debounce requests. Wrap it in | ||
| /// [ThrottlingLanguageCheckService] or [DebounceLanguageCheckService] when | ||
| /// needed. | ||
| class InMemoryDictionaryLanguageCheckService extends LanguageCheckService { |
There was a problem hiding this comment.
FilteredLanguageCheckService is probably more correct naming now
5 participants
No description provided.