Add 'wrap' and other IDE-backed options

build.gradle.kts

@@ -310,7 +310,7 @@ tasks {
 
   patchPluginXml {
     // Don't forget to update plugin.xml
-    sinceBuild.set("233.11799.67")
+    sinceBuild.set("233.11799.241")
 
     changeNotes.set(
       """<a href="https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20Fix%20versions:%20${version.get()}">Changelog</a>"""

src/main/java/com/maddyhome/idea/vim/VimPlugin.java

@@ -282,7 +282,13 @@ private void registerIdeavimrc(VimEditor editor) {
     ideavimrcRegistered = true;
 
     if (!ApplicationManager.getApplication().isUnitTestMode()) {
-      executeIdeaVimRc(editor);
+      try {
+        VimInjectorKt.injector.getOptionGroup().startInitVimRc();
+        executeIdeaVimRc(editor);
+      }
+      finally {
+        VimInjectorKt.injector.getOptionGroup().endInitVimRc();
+      }
     }
   }
 

src/main/java/com/maddyhome/idea/vim/group/EditorGroup.java

@@ -42,8 +42,8 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static com.intellij.openapi.editor.EditorSettings.*;
 import static com.maddyhome.idea.vim.api.VimInjectorKt.injector;
-import static com.maddyhome.idea.vim.api.VimInjectorKt.options;
 import static com.maddyhome.idea.vim.newapi.IjVimInjectorKt.ijOptions;
 
 /**
@@ -55,12 +55,31 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
 
   private Boolean isKeyRepeat = null;
 
+  // TODO: Get rid of this custom line converter once we support soft wraps properly
+  // The builtin relative line converter looks like it's using Vim's logical lines for counting, where a Vim logical
+  // line is a buffer line, or a single line representing a fold of several buffer lines. This converter is counting
+  // screen lines (but badly - if you're on the second line of a wrapped line, it still counts like you're on the first.
+  // We really want to use Vim logical lines, but we don't currently support them for movement - we move by screen line.
+
   private final CaretListener myLineNumbersCaretListener = new CaretListener() {
     @Override
     public void caretPositionChanged(@NotNull CaretEvent e) {
-      final boolean requiresRepaint = e.getNewPosition().line != e.getOldPosition().line;
-      if (requiresRepaint && options(injector, new IjVimEditor(e.getEditor())).getRelativenumber()) {
-        repaintRelativeLineNumbers(e.getEditor());
+      // We don't get notified when the IDE's settings change, so make sure we're up-to-date when the caret moves
+      final Editor editor = e.getEditor();
+      boolean relativenumber = ijOptions(injector, new IjVimEditor(editor)).getRelativenumber();
+      if (relativenumber) {
+        if (!hasRelativeLineNumbersInstalled(editor)) {
+          installRelativeLineNumbers(editor);
+        }
+        else {
+          // We must repaint on each caret move, so we update when caret's visual line doesn't match logical line
+          repaintRelativeLineNumbers(editor);
+        }
+      }
+      else {
+        if (hasRelativeLineNumbersInstalled(editor)) {
+          removeRelativeLineNumbers(editor);
+        }
       }
     }
   };
@@ -73,11 +92,10 @@ private void initLineNumbers(final @NotNull Editor editor) {
     editor.getCaretModel().addCaretListener(myLineNumbersCaretListener);
     UserDataManager.setVimEditorGroup(editor, true);
 
-    UserDataManager.setVimLineNumbersInitialState(editor, editor.getSettings().isLineNumbersShown());
     updateLineNumbers(editor);
   }
 
-  private void deinitLineNumbers(@NotNull Editor editor, boolean isReleasing) {
+  private void deinitLineNumbers(@NotNull Editor editor) {
     if (isProjectDisposed(editor) || !supportsVimLineNumbers(editor) || !UserDataManager.getVimEditorGroup(editor)) {
       return;
     }
@@ -86,14 +104,6 @@ private void deinitLineNumbers(@NotNull Editor editor, boolean isReleasing) {
     UserDataManager.setVimEditorGroup(editor, false);
 
     removeRelativeLineNumbers(editor);
-
-    // Don't reset the built in line numbers if we're releasing the editor. If we do, EditorSettings.setLineNumbersShown
-    // can cause the editor to refresh settings and can call into FileManagerImpl.getCachedPsiFile AFTER FileManagerImpl
-    // has been disposed (Closing the project with a Find Usages result showing a preview panel is a good repro case).
-    // See IDEA-184351 and VIM-1671
-    if (!isReleasing) {
-      setBuiltinLineNumbers(editor, UserDataManager.getVimLineNumbersInitialState(editor));
-    }
   }
 
   private static boolean supportsVimLineNumbers(final @NotNull Editor editor) {
@@ -107,41 +117,22 @@ private static boolean isProjectDisposed(final @NotNull Editor editor) {
   }
 
   private static void updateLineNumbers(final @NotNull Editor editor) {
-    final EffectiveOptions options = options(injector, new IjVimEditor(editor));
-    final boolean relativeNumber = options.getRelativenumber();
-    final boolean number = options.getNumber();
-
-    final boolean showBuiltinEditorLineNumbers = shouldShowBuiltinLineNumbers(editor, number, relativeNumber);
-
-    final EditorSettings settings = editor.getSettings();
-    if (settings.isLineNumbersShown() ^ showBuiltinEditorLineNumbers) {
-      // Update line numbers later since it may be called from a caret listener
-      // on the caret move and it may move the caret internally
-      ApplicationManager.getApplication().invokeLater(() -> {
-        if (editor.isDisposed()) return;
-        setBuiltinLineNumbers(editor, showBuiltinEditorLineNumbers);
-      });
+    final boolean isLineNumbersShown = editor.getSettings().isLineNumbersShown();
+    if (!isLineNumbersShown) {
+      return;
     }
 
-    if (relativeNumber) {
+    final LineNumerationType lineNumerationType = editor.getSettings().getLineNumerationType();
+    if (lineNumerationType == LineNumerationType.RELATIVE || lineNumerationType == LineNumerationType.HYBRID) {
       if (!hasRelativeLineNumbersInstalled(editor)) {
         installRelativeLineNumbers(editor);
       }
     }
-    else if (hasRelativeLineNumbersInstalled(editor)) {
+    else {
       removeRelativeLineNumbers(editor);
     }
   }
 
-  private static boolean shouldShowBuiltinLineNumbers(final @NotNull Editor editor, boolean number, boolean relativeNumber) {
-    final boolean initialState = UserDataManager.getVimLineNumbersInitialState(editor);
-    return initialState || number || relativeNumber;
-  }
-
-  private static void setBuiltinLineNumbers(final @NotNull Editor editor, boolean show) {
-    editor.getSettings().setLineNumbersShown(show);
-  }
-
   private static boolean hasRelativeLineNumbersInstalled(final @NotNull Editor editor) {
     return UserDataManager.getVimHasRelativeLineNumbersInstalled(editor);
   }
@@ -256,8 +247,8 @@ public void editorCreated(@NotNull Editor editor) {
     updateCaretsVisualAttributes(new IjVimEditor(editor));
   }
 
-  public void editorDeinit(@NotNull Editor editor, boolean isReleased) {
-    deinitLineNumbers(editor, isReleased);
+  public void editorDeinit(@NotNull Editor editor) {
+    deinitLineNumbers(editor);
     UserDataManager.unInitializeEditor(editor);
     VimPlugin.getKey().unregisterShortcutKeys(new IjVimEditor(editor));
     CaretVisualAttributesHelperKt.removeCaretsVisualAttributes(editor);
@@ -322,17 +313,18 @@ public void onEffectiveValueChanged(@NotNull VimEditor editor) {
   private static class RelativeLineNumberConverter implements LineNumberConverter {
     @Override
     public Integer convert(@NotNull Editor editor, int lineNumber) {
-      final boolean number = options(injector, new IjVimEditor(editor)).getNumber();
+      final IjVimEditor ijVimEditor = new IjVimEditor(editor);
+      final boolean number = ijOptions(injector, ijVimEditor).getNumber();
       final int caretLine = editor.getCaretModel().getLogicalPosition().line;
 
       // lineNumber is 1 based
-      if (number && (lineNumber - 1) == caretLine) {
-        return lineNumber;
+      if ((lineNumber - 1) == caretLine) {
+        return number ? lineNumber : 0;
       }
       else {
-        final int visualLine = new IjVimEditor(editor).bufferLineToVisualLine(lineNumber - 1);
-        final int currentVisualLine = new IjVimEditor(editor).bufferLineToVisualLine(caretLine);
-        return Math.abs(currentVisualLine - visualLine);
+        final int visualLine = ijVimEditor.bufferLineToVisualLine(lineNumber - 1);
+        final int caretVisualLine = editor.getCaretModel().getVisualPosition().line;
+        return Math.abs(caretVisualLine - visualLine);
       }
     }
 

src/main/java/com/maddyhome/idea/vim/group/IjOptionProperties.kt

@@ -45,6 +45,18 @@ public open class GlobalIjOptions(scope: OptionAccessScope) : OptionsPropertiesB
  * As a convenience, this class also provides access to the IntelliJ specific global options, via inheritance.
  */
 public class EffectiveIjOptions(scope: OptionAccessScope.EFFECTIVE): GlobalIjOptions(scope) {
+  // Vim options that are implemented purely by existing IntelliJ features and not used by vim-engine
+  public var breakindent: Boolean by optionProperty(IjOptions.breakindent)
+  public val colorcolumn: StringListOptionValue by optionProperty(IjOptions.colorcolumn)
+  public var cursorline: Boolean by optionProperty(IjOptions.cursorline)
+  public var fileformat: String by optionProperty(IjOptions.fileformat)
+  public var list: Boolean by optionProperty(IjOptions.list)
+  public var number: Boolean by optionProperty(IjOptions.number)
+  public var relativenumber: Boolean by optionProperty(IjOptions.relativenumber)
+  public var textwidth: Int by optionProperty(IjOptions.textwidth)
+  public var wrap: Boolean by optionProperty(IjOptions.wrap)
+
+  // IntelliJ specific options
   public var ideacopypreprocess: Boolean by optionProperty(IjOptions.ideacopypreprocess)
   public var ideajoin: Boolean by optionProperty(IjOptions.ideajoin)
   public var idearefactormode: String by optionProperty(IjOptions.idearefactormode)

src/main/java/com/maddyhome/idea/vim/group/IjOptions.kt

@@ -10,9 +10,14 @@ package com.maddyhome.idea.vim.group
 
 import com.intellij.openapi.application.ApplicationNamesInfo
 import com.maddyhome.idea.vim.api.Options
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.ex.exExceptionMessage
+import com.maddyhome.idea.vim.options.NumberOption
 import com.maddyhome.idea.vim.options.Option
 import com.maddyhome.idea.vim.options.OptionDeclaredScope.GLOBAL
 import com.maddyhome.idea.vim.options.OptionDeclaredScope.GLOBAL_OR_LOCAL_TO_BUFFER
+import com.maddyhome.idea.vim.options.OptionDeclaredScope.LOCAL_TO_BUFFER
+import com.maddyhome.idea.vim.options.OptionDeclaredScope.LOCAL_TO_WINDOW
 import com.maddyhome.idea.vim.options.StringListOption
 import com.maddyhome.idea.vim.options.StringOption
 import com.maddyhome.idea.vim.options.ToggleOption
@@ -33,6 +38,56 @@ public object IjOptions {
     Options.overrideDefaultValue(Options.clipboard, VimString("ideaput,autoselect,exclude:cons\\|linux"))
   }
 
+  // Vim options that are implemented purely by existing IntelliJ features and not used by vim-engine
+  public val breakindent: ToggleOption = addOption(ToggleOption("breakindent", LOCAL_TO_WINDOW, "bri", false))
+  public val colorcolumn: StringListOption = addOption(object : StringListOption("colorcolumn", LOCAL_TO_WINDOW, "cc", "") {
+    override fun checkIfValueValid(value: VimDataType, token: String) {
+      super.checkIfValueValid(value, token)
+      if (value != VimString.EMPTY) {
+        // Each element in the comma-separated string list needs to be a number. No spaces. Vim supports numbers
+        // beginning "+" or "-" to draw a highlight column relative to the 'textwidth' value. We don't fully support
+        // that, but we do automatically add "+0" because IntelliJ always displays the right margin
+        split((value as VimString).asString()).forEach {
+          if (!it.matches(Regex("[+-]?[0-9]+"))) {
+            throw exExceptionMessage("E474", token)
+          }
+        }
+      }
+    }
+  })
+  public val cursorline: ToggleOption = addOption(ToggleOption("cursorline", LOCAL_TO_WINDOW, "cul", false))
+  public val list: ToggleOption = addOption(ToggleOption("list", LOCAL_TO_WINDOW, "list", false))
+  public val number: ToggleOption = addOption(ToggleOption("number", LOCAL_TO_WINDOW, "nu", false))
+  public val relativenumber: ToggleOption = addOption(ToggleOption("relativenumber", LOCAL_TO_WINDOW, "rnu", false))
+  public val textwidth: NumberOption = addOption(UnsignedNumberOption("textwidth", LOCAL_TO_BUFFER, "tw", 0))
+  public val wrap: ToggleOption = addOption(ToggleOption("wrap", LOCAL_TO_WINDOW, "wrap", true))
+
+  // These options are not explicitly listed as local-noglobal in Vim's help, but are set when a new buffer is edited,
+  // based on the value of 'fileformats' or 'fileencodings'. To prevent unexpected file cnversion, we treat them as
+  // local-noglobal. See `:help local-noglobal`, `:help 'fileformats'` and `:help 'fileencodings'`
+  public val bomb: ToggleOption =
+    addOption(ToggleOption("bomb", LOCAL_TO_BUFFER, "bomb", false, isLocalNoGlobal = true))
+  public val fileencoding: StringOption = addOption(
+    StringOption(
+      "fileencoding",
+      LOCAL_TO_BUFFER,
+      "fenc",
+      VimString.EMPTY,
+      isLocalNoGlobal = true
+    )
+  )
+  public val fileformat: StringOption = addOption(
+    StringOption(
+      "fileformat",
+      LOCAL_TO_BUFFER,
+      "ff",
+      if (injector.systemInfoService.isWindows) "dos" else "unix",
+      boundedValues = setOf("dos", "unix", "mac"),
+      isLocalNoGlobal = true
+    )
+  )
+
+  // IntelliJ specific functionality - custom options
   public val ide: StringOption = addOption(
     StringOption("ide", GLOBAL, "ide", ApplicationNamesInfo.getInstance().fullProductNameWithEdition)
   )