Major AceJump refactoring!

See acejump#348 for information on what's changed and what more needs to be done.

.editorconfig

@@ -1,7 +1,7 @@
 [*]
-charset=utf-8
-end_of_line=lf
-insert_final_newline=false
-indent_style=space
-indent_size=2
-max_line_length=80
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+max_line_length = 140

build.gradle.kts

@@ -1,37 +1,20 @@
 import org.jetbrains.changelog.closure
-import org.jetbrains.intellij.tasks.*
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.intellij.tasks.PatchPluginXmlTask
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
   idea apply true
   kotlin("jvm") version "1.3.72"
-  id("org.jetbrains.intellij") version "0.6.4"
+  id("org.jetbrains.intellij") version "0.6.5"
   id("org.jetbrains.changelog") version "0.6.2"
-  id("com.github.ben-manes.versions") version "0.36.0"
 }
 
 tasks {
   withType<KotlinCompile> {
     kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()
     kotlinOptions.freeCompilerArgs += "-progressive"
   }
-
-  named<Zip>("buildPlugin") {
-    dependsOn("test")
-    archiveFileName.set("AceJump.zip")
-  }
-
-  withType<RunIdeTask> {
-    dependsOn("test")
-    findProperty("luginDev")?.let { args = listOf(projectDir.absolutePath) }
-  }
-
-  withType<PublishTask> {
-    val intellijPublishToken: String? by project
-    token(intellijPublishToken)
-  }
-
+
   withType<PatchPluginXmlTask> {
     sinceBuild("201.6668.0")
     changeNotes({ changelog.getLatest().toHTML() })
@@ -44,10 +27,7 @@ changelog {
 }
 
 dependencies {
-  // gradle-intellij-plugin doesn't attach sources properly for Kotlin :(
   compileOnly(kotlin("stdlib-jdk8"))
-  // https://github.com/promeG/TinyPinyin
-  implementation("com.github.promeg:tinypinyin:2.0.3")
 }
 
 repositories {
@@ -62,5 +42,11 @@ intellij {
   setPlugins("java")
 }
 
+idea {
+  module {
+    excludeDirs.add(buildDir)
+  }
+}
+
 group = "org.acejump"
-version = "3.6.4"
+version = "4.0"

src/main/kotlin/org/acejump/AceUtil.kt

@@ -0,0 +1,82 @@
+package org.acejump
+
+import com.intellij.openapi.editor.Editor
+
+annotation class ExternalUsage
+
+/**
+ * Returns an immutable version of the currently edited document.
+ */
+val Editor.immutableText
+  get() = this.document.immutableCharSequence
+
+/**
+ * Returns true if [this] contains [otherText] at the specified offset.
+ */
+fun CharSequence.matchesAt(selfOffset: Int, otherText: String, ignoreCase: Boolean): Boolean {
+  return this.regionMatches(selfOffset, otherText, 0, otherText.length, ignoreCase)
+}
+
+/**
+ * Calculates the length of a common prefix in [this] starting at index [selfOffset], and [otherText] starting at index 0.
+ */
+fun CharSequence.countMatchingCharacters(selfOffset: Int, otherText: String): Int {
+  var i = 0
+  var o = selfOffset + i
+
+  while (i < otherText.length && o < this.length && otherText[i].equals(this[o], ignoreCase = true)) {
+    i++
+    o++
+  }
+
+  return i
+}
+
+/**
+ * Determines which characters form a "word" for the purposes of functions below.
+ */
+val Char.isWordPart
+  get() = this.isJavaIdentifierPart()
+
+/**
+ * Finds index of the first character in a word.
+ */
+inline fun CharSequence.wordStart(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int {
+  var start = pos
+
+  while (start > 0 && isPartOfWord(this[start - 1])) {
+    --start
+  }
+
+  return start
+}
+
+/**
+ * Finds index of the last character in a word.
+ */
+inline fun CharSequence.wordEnd(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int {
+  var end = pos
+
+  while (end < length - 1 && isPartOfWord(this[end + 1])) {
+    ++end
+  }
+
+  return end
+}
+
+/**
+ * Finds index of the first word character following a sequence of non-word characters following the end of a word.
+ */
+inline fun CharSequence.wordEndPlus(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int {
+  var end = this.wordEnd(pos, isPartOfWord)
+
+  while (end < length - 1 && !isPartOfWord(this[end + 1])) {
+    ++end
+  }
+
+  if (end < length - 1 && isPartOfWord(this[end + 1])) {
+    ++end
+  }
+
+  return end
+}

src/main/kotlin/org/acejump/action/AceAction.kt

@@ -0,0 +1,61 @@
+package org.acejump.action
+
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.CommonDataKeys.EDITOR
+import com.intellij.openapi.project.DumbAwareAction
+import org.acejump.boundaries.Boundaries
+import org.acejump.boundaries.StandardBoundaries
+import org.acejump.input.JumpMode
+import org.acejump.search.Pattern
+import org.acejump.session.Session
+import org.acejump.session.SessionManager
+
+/**
+ * Base class for keyboard-activated actions that create or update an AceJump [Session].
+ */
+sealed class AceAction : DumbAwareAction() {
+  final override fun update(action: AnActionEvent) {
+    action.presentation.isEnabled = action.getData(EDITOR) != null
+  }
+
+  final override fun actionPerformed(e: AnActionEvent) {
+    invoke(SessionManager.start(e.getData(EDITOR) ?: return))
+  }
+
+  abstract operator fun invoke(session: Session)
+
+  /**
+   * Generic action type that toggles a specific [JumpMode].
+   */
+  abstract class BaseToggleJumpModeAction(private val mode: JumpMode) : AceAction() {
+    final override fun invoke(session: Session) = session.toggleJumpMode(mode)
+  }
+
+  /**
+   * Generic action type that starts a regex search.
+   */
+  abstract class BaseRegexSearchAction(private val pattern: Pattern, private val boundaries: Boundaries) : AceAction() {
+    override fun invoke(session: Session) = session.startRegexSearch(pattern, boundaries)
+  }
+
+  /**
+   * Initiates an AceJump session in the first [JumpMode], or cycles to the next [JumpMode] as defined in configuration.
+   */
+  object ActivateOrCycleMode : AceAction() {
+    override fun invoke(session: Session) = session.cycleJumpMode()
+  }
+
+  // @formatter:off
+
+  object ToggleJumpMode        : BaseToggleJumpModeAction(JumpMode.JUMP)
+  object ToggleJumpEndMode     : BaseToggleJumpModeAction(JumpMode.JUMP_END)
+  object ToggleTargetMode      : BaseToggleJumpModeAction(JumpMode.TARGET)
+  object ToggleDeclarationMode : BaseToggleJumpModeAction(JumpMode.DEFINE)
+
+  object ToggleAllLinesMode          : BaseRegexSearchAction(Pattern.LINE_MARK, StandardBoundaries.WHOLE_FILE)
+  object ToggleAllWordsMode          : BaseRegexSearchAction(Pattern.ALL_WORDS, StandardBoundaries.WHOLE_FILE)
+  object ToggleAllWordsBackwardsMode : BaseRegexSearchAction(Pattern.ALL_WORDS, StandardBoundaries.BEFORE_CARET)
+  object ToggleAllWordsForwardMode   : BaseRegexSearchAction(Pattern.ALL_WORDS, StandardBoundaries.AFTER_CARET)
+
+  // @formatter:on
+}

src/main/kotlin/org/acejump/action/AceEditorAction.kt

@@ -0,0 +1,62 @@
+package org.acejump.action
+
+import com.intellij.openapi.actionSystem.DataContext
+import com.intellij.openapi.editor.Caret
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.actionSystem.EditorActionHandler
+import org.acejump.boundaries.StandardBoundaries
+import org.acejump.search.Pattern
+import org.acejump.session.Session
+import org.acejump.session.SessionManager
+
+/**
+ * Base class for keyboard-activated overrides of existing editor actions, that have a different meaning during an AceJump [Session].
+ */
+sealed class AceEditorAction(private val originalHandler: EditorActionHandler) : EditorActionHandler() {
+  final override fun isEnabledForCaret(editor: Editor, caret: Caret, dataContext: DataContext?): Boolean {
+    return SessionManager[editor] != null || originalHandler.isEnabled(editor, caret, dataContext)
+  }
+
+  final override fun doExecute(editor: Editor, caret: Caret?, dataContext: DataContext?) {
+    val session = SessionManager[editor]
+
+    if (session != null) {
+      run(session)
+    }
+    else if (originalHandler.isEnabled(editor, caret, dataContext)) {
+      originalHandler.execute(editor, caret, dataContext)
+    }
+  }
+
+  protected abstract fun run(session: Session)
+
+  // Actions
+
+  class Reset(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.end()
+  }
+
+  class ClearSearch(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.restart()
+  }
+
+  class SelectBackward(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.visitPreviousTag()
+  }
+
+  class SelectForward(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.visitNextTag()
+  }
+
+  class SearchCodeIndents(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.startRegexSearch(Pattern.CODE_INDENTS, StandardBoundaries.WHOLE_FILE)
+  }
+
+  class SearchLineStarts(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.startRegexSearch(Pattern.START_OF_LINE, StandardBoundaries.WHOLE_FILE)
+  }
+
+  class SearchLineEnds(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) {
+    override fun run(session: Session) = session.startRegexSearch(Pattern.END_OF_LINE, StandardBoundaries.WHOLE_FILE)
+  }
+}

src/main/kotlin/org/acejump/action/TagJumper.kt

@@ -0,0 +1,108 @@
+package org.acejump.action
+
+import com.intellij.codeInsight.navigation.actions.GotoDeclarationAction
+import com.intellij.codeInsight.navigation.actions.GotoTypeDeclarationAction
+import com.intellij.openapi.actionSystem.ActionManager
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.command.CommandProcessor
+import com.intellij.openapi.command.UndoConfirmationPolicy
+import com.intellij.openapi.editor.Document
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.actionSystem.DocCommandGroupId
+import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.ui.playback.commands.ActionCommand
+import org.acejump.*
+import org.acejump.input.JumpMode
+import org.acejump.input.JumpMode.*
+import org.acejump.search.SearchProcessor
+
+/**
+ * Performs [JumpMode] navigation and actions.
+ */
+internal class TagJumper(private val editor: Editor, private val mode: JumpMode, private val searchProcessor: SearchProcessor?) {
+  /**
+   * Moves caret to a specific offset in the editor according to the positioning and selection rules of the current [JumpMode].
+   */
+  fun visit(offset: Int) {
+    if (mode === JUMP_END || mode === TARGET) {
+      val chars = editor.immutableText
+      val matchingChars = searchProcessor?.let { chars.countMatchingCharacters(offset, it.query.rawText) } ?: 0
+      val targetOffset = offset + matchingChars
+      val isInsideWord = matchingChars > 0 && chars[targetOffset - 1].isWordPart && chars[targetOffset].isWordPart
+      val finalTargetOffset = if (isInsideWord) chars.wordEnd(targetOffset) + 1 else targetOffset
+
+      if (mode === JUMP_END) {
+        moveCaretTo(editor, finalTargetOffset)
+      }
+      else if (mode === TARGET) {
+        if (isInsideWord) {
+          selectRange(editor, chars.wordStart(targetOffset), finalTargetOffset)
+        }
+        else {
+          selectRange(editor, offset, finalTargetOffset)
+        }
+      }
+    }
+    else {
+      moveCaretTo(editor, offset)
+    }
+  }
+
+  /**
+   * Updates caret and selection by [visit]ing a specific offset in the editor, and applying session-finalizing [JumpMode] actions such as
+   * using the Go To Declaration action, or selecting text between caret and target offset/word if Shift was held during the jump.
+   */
+  fun jump(offset: Int, shiftMode: Boolean) {
+    val oldOffset = editor.caretModel.offset
+
+    visit(offset)
+
+    if (mode === DEFINE) {
+      performAction(if (shiftMode) GotoTypeDeclarationAction() else GotoDeclarationAction())
+      return
+    }
+
+    if (shiftMode) {
+      val newOffset = editor.caretModel.offset
+
+      if (mode === TARGET) {
+        selectRange(editor, oldOffset, when {
+          newOffset < oldOffset -> editor.selectionModel.selectionStart
+          else                  -> editor.selectionModel.selectionEnd
+        })
+      }
+      else {
+        selectRange(editor, oldOffset, newOffset)
+      }
+    }
+  }
+
+  private companion object {
+    private fun moveCaretTo(editor: Editor, offset: Int) = with(editor) {
+      project?.let { addCurrentPositionToHistory(it, document) }
+      selectionModel.removeSelection(true)
+      caretModel.moveToOffset(offset)
+    }
+
+    private fun selectRange(editor: Editor, fromOffset: Int, toOffset: Int) = with(editor) {
+      selectionModel.removeSelection(true)
+      selectionModel.setSelection(fromOffset, toOffset)
+      caretModel.moveToOffset(toOffset)
+    }
+
+    private fun addCurrentPositionToHistory(project: Project, document: Document) {
+      CommandProcessor.getInstance().executeCommand(project, {
+        with(IdeDocumentHistory.getInstance(project)) {
+          setCurrentCommandHasMoves()
+          includeCurrentCommandAsNavigation()
+          includeCurrentPlaceAsChangePlace()
+        }
+      }, "AceJumpHistoryAppender", DocCommandGroupId.noneGroupId(document), UndoConfirmationPolicy.DO_NOT_REQUEST_CONFIRMATION, document)
+    }
+
+    private fun performAction(action: AnAction) {
+      ActionManager.getInstance().tryToExecute(action, ActionCommand.getInputEvent(null), null, null, true)
+    }
+  }
+}