Implements five new vimscript list functions:
- count(): counts occurrences of a value in a list/dict
- index(): finds first index of a value in a list
- min()/max(): finds minimum/maximum value in a list/dict
- range(): generates a list of numbers with optional stride
Includes error handling for edge cases like zero stride and invalid ranges.
Implement five commonly used vimscript functions:
- repeat(expr, count): Repeats strings or lists multiple times
- char2nr(char): Converts character to Unicode code point
- nr2char(number): Converts code point to character
- trim(text, [mask], [dir]): Trims whitespace or custom characters
- reverse(object): Reverses lists in-place or returns reversed string
All functions include comprehensive test coverage and follow vim's
official behavior including edge cases.
Now, the inputProcessor will be called after all closing is finished. This includes the mode that won't be CMD_LINE anymore, but the one that was used before entering CMD_LINE
- Emphasize using git show to see full commit content
- Note that test files contain good examples for changelog
- Encourage looking at actual code changes for better understanding
- Help find specific command examples from tests
- Emphasize reading PR comments from previous changelog updates
- Add gh command to view PR comments
- Note that review feedback may indicate what to avoid
- Help ensure special instructions from PR discussions are followed
- Clarify that CHANGES.md is a large file
- Instruct to focus on [To Be Released] section and recent versions
- Avoid reading the entire file unnecessarily
- Create separate section with detailed instructions for changeNotes
- Clarify that content should match CHANGES.md exactly (no summarizing)
- Provide HTML formatting guidelines and examples
- Emphasize not to create shorter or condensed versions
- Include example showing Markdown to HTML conversion
- Specify that PR descriptions should be taken directly from PR titles
- Don't regenerate or rewrite PR descriptions
- Maintain author's original wording for PR entries
- Clarify that PRs have different inclusion criteria than Features/Fixes
- Note that internal changes and refactoring PRs should be included
- Emphasize acknowledging community contributions regardless of visibility
- Make clear that "user-visible only" rule doesn't apply to PRs section
- Add "Fixed inlay offset calculations" as bad example
- Show better alternative with specific user-visible case
- Reinforce that technical internal fixes should either have clear user impact or be omitted
- Include bad example: "Fixed count validation in text objects" (too vague)
- Show better alternative: specific command that was fixed
- Emphasize: if unable to determine specific case, omit entry rather than be unclear
- Help ensure all changelog entries are meaningful to users
- Clarify that each change should appear in only ONE subsection
- Add note that features can also use YouTrack link format
- Emphasize no duplication between Features, Fixes, and other categories
- Update both Format Notes and Writing Style sections for clarity
- Change PR title format to "Update changelog: <super short summary>"
- Add example showing how to summarize key changes in title
- Update both GitHub workflow and changelog instructions for consistency
- Guide to search for and include official documentation links
- Add links to JetBrains features and Vim commands when relevant
- Include examples showing linked IntelliJ features (Next Edit Suggestion, multiple cursors)
- Help users find more information about mentioned features
- Add instruction to include examples of commands/operations in changelog entries
- Update example entries to demonstrate including specific commands
- Show how to describe what now works for both fixes and features
- Help users understand how to use new features or what was fixed
- Clarify that internal code changes should not be logged
- Emphasize that changelog is for users, not developers
- Strengthen user-focused writing style guidelines
- Exclude refactoring, code cleanup, and internal architecture changes
- Simplified CLAUDE.md to avoid redundancy with other docs
- Created .claude/changelog-instructions.md with detailed changelog maintenance guide
- Updated GitHub Action to reference the new changelog instructions doc
- Added instructions for updating changeNotes in build.gradle.kts
- Added notes about excluding API module changes (experimental status)
- Added step to check previous changelog PRs for special instructions
The append, prepend, and remove functions now correctly handle empty
option values. When an option is empty (""), we use an empty list
instead of splitting the empty string which would result in [""].
This fixes test failures in OptionScopeTest for operations on empty options.
This workflow runs daily at 5 AM UTC (or manually) and uses Claude to:
- Review commits and update CHANGES.md with meaningful changes
- Maintain the exact format used before the changelog gap
- Include YouTrack links for fixes (format: [VIM-XXXX](url))
- Reference merged PRs (excluding dependabot and Claude PRs)
- Handle the historical gap between versions 2.9.0 and 2.28.0
- Create PRs only when there are actual changes to document
Claude has access to git, GitHub CLI, and can fetch from YouTrack,
GitHub, and JetBrains plugin pages to gather accurate information.
This workflow runs three times a year (August 15, April 30, December 1)
and uses Claude to check if new IntelliJ versions need to be added to
TeamCity test configurations. Claude will automatically create a PR if
a new version is needed.
The workflow can also be triggered manually for testing.
Added prominent warning notice to all Plugin API documentation files:
- Plugin-API-reference.md
- Plugin-API-introduction.md
- Plugin-API-quick-start-guide.md
- Plugin-API-tutorial-replace-with-register.md
The warning clearly states that the API is experimental and not
recommended for production use, with potential breaking changes.
- Document that option() function now returns a value
- Add comprehensive documentation for list option methods (append, prepend, remove)
- Add utility methods documentation (toggle, split)
- Include practical usage examples and common use cases
- Update method signatures to reflect non-nullable returns
- Add Vim command equivalents for better understanding
This allows users to easily retrieve values from option scope:
val x = option { get<Int>("history") }
- Changed option() signature from Unit to generic T return type
- Updated VimApiImpl implementation to return the lambda result
- Added test demonstrating the new return value capability
The implementation always returns a value or throws an exception,
so the return type should be non-nullable to reflect this behavior.
Updated extension functions to remove unnecessary null checks.
- Convert OptionScope from abstract class to interface
- Extract inline functions with reified types as extension functions
- Make getOptionValue() and setOption() public interface methods
- Remove internal modifier layer functions
- Update OptionScopeImpl to implement new interface
- Add documentation recommending extension function usage
- Update test imports to use new extension functions
- append(): adds values to end of comma-separated list (like Vim's +=)
- prepend(): adds values to beginning of list (like Vim's ^=)
- remove(): removes values from list (like Vim's -=)
- All functions prevent duplicate values from being added
- Comprehensive test coverage for all scenarios
Adds a simple toggle() function that flips boolean option values.
Works with both full option names and abbreviations.
Example usage:
toggle("ignorecase") // true → false, false → true
toggle("ic") // works with abbreviations
Adds a concise String.split() extension function within OptionScope that splits
comma-separated option values into lists. This simplifies working with list-type
options like 'virtualedit', 'whichwrap', etc.
Example usage:
val values = get<String>("virtualedit")?.split() ?: emptyList()
// "block,all" → ["block", "all"]
Added extensive test coverage for the OptionScope API including:
- String list options with various formats (single, multiple, empty values)
- Error handling for invalid values, empty names, and type mismatches
- Boundary conditions for integer options
- Boolean/integer type conversions
- Global vs local option scoping
- Option abbreviations
- Edge cases like trailing/leading commas and very long strings
1) ExException is wrapped with the IllegalArgumentException. We cannot use the raw ExException as it's not defined in the API module. So, if any client will have an access only to the API module, they won't be able to handle this kind of the exception.
2) getOption throws IllegalArgumentException if the type classifier is null. I don't know when this might happen, but this looks more like a plugin developer error. Also, this allows to distinguish the wrong option name vs this type of problem
3) In setOption and getOption throw an exception if there is no such option. This clearly explains what is wrong with this call.
Note: there was a question of using exceptions vs some return values, even like `Result`. The decision falls into the using of exceptions as using the wrong arguments in the plugin is a programming error from the user point of view.
This means, if there is a plugin that checks some option that in reality doesn't exist, it's not a fail of the end user and the end user cannot do anything about that.
Also, using the `Result` will force the plugin developer to handle all possible failure branches, what is quite unnecessary when accessing a well-defined option.
The way we split plugin.xml was outdated. Also, it started to show errors in highlighting, even there were no errors.
It's better to keep everything in a single file
This function is not provided by vim and by using it from the plugins we may drop the digraphs created by other plugins.
It'd be better to provide a just remove function. However, let's skip it for now. Also, maybe we should use an approach with the owners
The suspending operations must not be performed under the read or write actions as this will lead to performance issues or freezes.
Also, the current implementation of launching coroutine under the write action is simply incorrect. The coroutine will escape the write action into another thread.
The current representation of Mode with `returnTo` is quite complicated and we're not even sure it'll remain like that.
At the same time, `mode()` function in Vim has quite a reach specification and there is a small chance it'll be changed. With this approach, we use values from Vim, yet in a form of enum.
`ReadImpl` didn't use anything from `VimScopeImpl`. This would make sense if `Read` inherited `VimScope`, but it doesn't.
Also, we'll always be able to bring back the dependency if we figure out it's necessary.
Alex Plate