chylex/IntelliJ-IdeaVim
1
0
Fork 0
mirror of https://github.com/chylex/IntelliJ-IdeaVim.git synced 2025-03-03 18:32:54 +01:00
Code

Deleted VimContext from commands

Browse Source
This commit is contained in:
lippfi 2021-09-16 21:21:38 +03:00
parent c300fdbfb1
commit 4e3ee024ac
76 changed files with 105 additions and 182 deletions

3
src/com/maddyhome/idea/vim/vimscript/model/commands/ActionCommand.kt
View File

@ -29,7 +29,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.helper.runAfterGotFocus
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* @author smartbomb
@ -38,7 +37,7 @@ data class ActionCommand(val ranges: Ranges, val argument: String) : Command.Sin
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY, Flag.SAVE_VISUAL)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val actionName = argument.trim()
val action = ActionManager.getInstance().getAction(actionName) ?: throw ExException(MessageHelper.message("action.not.found.0", actionName))
val application = ApplicationManager.getApplication()

3
src/com/maddyhome/idea/vim/vimscript/model/commands/ActionListCommand.kt
View File

@ -27,7 +27,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.helper.StringHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* @author smartbomb
@ -35,7 +34,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class ActionListCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val lineSeparator = "\n"
val searchPattern = argument.trim().toLowerCase().split("*")
val actionManager = ActionManager.getInstance()

3
src/com/maddyhome/idea/vim/vimscript/model/commands/AsciiCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :ascii"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class AsciiCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getDigraph().displayAsciiInfo(editor)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/BufferCloseCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :bdelete"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class BufferCloseCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val arg = argument.trim()
val bufNum = arg.toIntOrNull()
if (bufNum != null) {

3
src/com/maddyhome/idea/vim/vimscript/model/commands/BufferCommand.kt
View File

@ -27,7 +27,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.EditorHelper
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* Handles buffer, buf, bu, b.
@ -37,7 +36,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class BufferCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val arg = argument.trim()
val overrideModified = arg.startsWith('!')
val buffer = if (overrideModified) arg.replace(Regex("^!\\s*"), "") else arg

3
src/com/maddyhome/idea/vim/vimscript/model/commands/BufferListCommand.kt
View File

@ -31,7 +31,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.EditorHelper
import com.maddyhome.idea.vim.helper.vimLine
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import org.jetbrains.annotations.NonNls
/**
@ -47,7 +46,7 @@ data class BufferListCommand(val ranges: Ranges, val argument: String) : Command
val SUPPORTED_FILTERS = setOf('+', '=', 'a', '%', '#')
}
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val arg = argument.trim()
val filter = pruneUnsupportedFilters(arg)
val bufferList = getBufferList(context, filter)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/CmdClearCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :comclear"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class CmdClearCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getCommand().resetAliases()
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/CmdCommand.kt
View File

@ -27,7 +27,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.group.CommandGroup.Companion.BLACKLISTED_ALIASES
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import org.jetbrains.annotations.NonNls
/**
@ -49,7 +48,7 @@ data class CmdCommand(val ranges: Ranges, val argument: String) : Command.Single
const val zeroOrOneArguments = "?"
const val moreThanZeroArguments = "+"
}
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val result: Boolean = if (argument.trim().isEmpty()) {
this.listAlias(editor, "")
} else {

3
src/com/maddyhome/idea/vim/vimscript/model/commands/CmdFilterCommand.kt
View File

@ -30,7 +30,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.EditorHelper
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :!"
@ -38,7 +37,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class CmdFilterCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.SELF_SYNCHRONIZED)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
logger.debug("execute")
val command = buildString {
var inBackslash = false

17
src/com/maddyhome/idea/vim/vimscript/model/commands/Command.kt
View File

@ -23,25 +23,24 @@ import com.maddyhome.idea.vim.helper.inVisualMode
import com.maddyhome.idea.vim.helper.noneOfEnum
import com.maddyhome.idea.vim.vimscript.model.Executable
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import java.util.*
sealed class Command(var commandRanges: Ranges, val commandArgument: String) : Executable {
sealed class Command(var commandRanges: Ranges, val commandArgument: String) : Executable() {
abstract val argFlags: CommandHandlerFlags
protected open val optFlags: EnumSet<CommandFlags> = noneOfEnum()
private val logger = logger<Command>()
abstract class ForEachCaret(ranges: Ranges, argument: String = "") : Command(ranges, argument) {
abstract fun processCommand(editor: Editor, caret: Caret, context: DataContext, vimContext: VimContext): ExecutionResult
abstract fun processCommand(editor: Editor, caret: Caret, context: DataContext): ExecutionResult
}
abstract class SingleExecution(ranges: Ranges, argument: String = "") : Command(ranges, argument) {
abstract fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult
abstract fun processCommand(editor: Editor, context: DataContext): ExecutionResult
}
@Throws(ExException::class)
override fun execute(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun execute(editor: Editor, context: DataContext): ExecutionResult {
checkRanges()
checkArgument()
if (editor.inVisualMode && Flag.SAVE_VISUAL !in argFlags.flags) {
@ -52,7 +51,7 @@ sealed class Command(var commandRanges: Ranges, val commandArgument: String) : E
return ExecutionResult.Error
}
val runCommand = ThrowableComputable<ExecutionResult, ExException> { runCommand(editor, context, vimContext) }
val runCommand = ThrowableComputable<ExecutionResult, ExException> { runCommand(editor, context) }
return when (argFlags.access) {
Access.WRITABLE -> ApplicationManager.getApplication().runWriteAction(runCommand)
Access.READ_ONLY -> ApplicationManager.getApplication().runReadAction(runCommand)
@ -60,20 +59,20 @@ sealed class Command(var commandRanges: Ranges, val commandArgument: String) : E
}
}
private fun runCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
private fun runCommand(editor: Editor, context: DataContext): ExecutionResult {
var result: ExecutionResult = ExecutionResult.Success
when (this) {
is ForEachCaret -> {
editor.caretModel.runForEachCaret(
{ caret ->
if (result is ExecutionResult.Success) {
result = processCommand(editor, caret, context, vimContext)
result = processCommand(editor, caret, context)
}
},
true
)
}
is SingleExecution -> result = processCommand(editor, context, vimContext)
is SingleExecution -> result = processCommand(editor, context)
}
return result
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/CopyTextCommand.kt
View File

@ -27,7 +27,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.group.copy.PutData
import com.maddyhome.idea.vim.helper.EditorHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.parser.VimscriptParser
/**
@ -36,7 +35,7 @@ import com.maddyhome.idea.vim.vimscript.parser.VimscriptParser
data class CopyTextCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_REQUIRED, Access.WRITABLE)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val carets = EditorHelper.getOrderedCaretsList(editor)
for (caret in carets) {
val range = getTextRange(editor, caret, false)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/DelCmdCommand.kt
View File

@ -24,14 +24,13 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :delcommand"
*/
data class DelCmdCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_REQUIRED, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
if (!VimPlugin.getCommand().hasAlias(argument)) {
VimPlugin.showMessage(MessageHelper.message("e184.no.such.user.defined.command.0", argument))
return ExecutionResult.Error

3
src/com/maddyhome/idea/vim/vimscript/model/commands/DeleteLinesCommand.kt
View File

@ -25,7 +25,6 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.command.SelectionType
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :delete"
@ -33,7 +32,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class DeleteLinesCommand(val ranges: Ranges, var argument: String) : Command.ForEachCaret(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.WRITABLE)
override fun processCommand(editor: Editor, caret: Caret, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, caret: Caret, context: DataContext): ExecutionResult {
val argument = this.argument
val register = if (argument.isNotEmpty() && !argument[0].isDigit()) {
this.argument = argument.substring(1)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/DeleteMarksCommand.kt
View File

@ -30,7 +30,6 @@ import com.maddyhome.idea.vim.group.MarkGroup.WR_REGULAR_FILE_MARKS
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.helper.Msg
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
private val VIML_COMMENT = Regex("(?<!\\\\)\".*")
private val TRAILING_SPACES = Regex("\\s*$")
@ -46,7 +45,7 @@ private const val UNESCAPED_QUOTE = "\""
data class DeleteMarksCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_REQUIRED, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val processedArg = argument
.replace(VIML_COMMENT, "")
.replace(ESCAPED_QUOTE, UNESCAPED_QUOTE)

7
src/com/maddyhome/idea/vim/vimscript/model/commands/DelfunctionCommand.kt
View File

@ -5,7 +5,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ExException
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.model.expressions.Scope
import com.maddyhome.idea.vim.vimscript.services.FunctionStorage
@ -21,10 +20,10 @@ data class DelfunctionCommand(
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
if (ignoreIfMissing) {
try {
FunctionStorage.deleteFunction(name, vimContext, scope)
FunctionStorage.deleteFunction(name, scope, this)
} catch (e: ExException) {
if (e.message != null && e.message!!.startsWith("E130")) {
// "ignoreIfMissing" flag handles the "E130: Unknown function" exception
@ -33,7 +32,7 @@ data class DelfunctionCommand(
}
}
} else {
FunctionStorage.deleteFunction(name, vimContext, scope)
FunctionStorage.deleteFunction(name, scope, this)
}
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/DigraphCommand.kt
View File

@ -25,7 +25,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :digraphs"
@ -33,7 +32,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class DigraphCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val arg = argument
logger.debug { "arg=$arg" }

3
src/com/maddyhome/idea/vim/vimscript/model/commands/DumpLineCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :dumpline"
*/
data class DumpLineCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
if (!logger.isDebugEnabled) return ExecutionResult.Error
val range = getLineRange(editor)

8
src/com/maddyhome/idea/vim/vimscript/model/commands/EchoCommand.kt
View File

@ -5,20 +5,18 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ExOutputModel
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.model.expressions.Expression
/**
* see "h :echo"
*/
data class EchoCommand(val ranges: Ranges, val args: List<Expression>) :
Command.SingleExecution(ranges) {
data class EchoCommand(val ranges: Ranges, val args: List<Expression>) : Command.SingleExecution(ranges) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult.Success {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult.Success {
val text = args.joinToString(separator = " ", postfix = "\n") {
it.evaluate(editor, context, vimContext).toString()
it.evaluate(editor, context, this).toString()
}
ExOutputModel.getInstance(editor).output(text)
return ExecutionResult.Success

3
src/com/maddyhome/idea/vim/vimscript/model/commands/EditFileCommand.kt
View File

@ -26,14 +26,13 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.EditorDataContext
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :edit"
*/
data class EditFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val arg = argument
if (arg == "#") {
VimPlugin.getMark().saveJumpLocation(editor)

5
src/com/maddyhome/idea/vim/vimscript/model/commands/ExecuteCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.Executor
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.model.expressions.Expression
/**
@ -32,8 +31,8 @@ import com.maddyhome.idea.vim.vimscript.model.expressions.Expression
class ExecuteCommand(val ranges: Ranges, val expressions: List<Expression>) : Command.SingleExecution(ranges) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.SELF_SYNCHRONIZED)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
val command = expressions.joinToString(separator = " ") { it.evaluate(editor, context, vimContext).asString() }
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val command = expressions.joinToString(separator = " ") { it.evaluate(editor, context, this).asString() }
return Executor.execute(command, editor, context, skipHistory = true, indicateErrors = true)
}
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/ExitCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :quitall"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class ExitCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getWindow().closeAll(context)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/FileCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :file"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class FileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_IS_COUNT, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val count = getCount(editor, 0, false)
VimPlugin.getFile().displayFileInfo(editor, count > 0)
return ExecutionResult.Success

3
src/com/maddyhome/idea/vim/vimscript/model/commands/FindClassCommand.kt
View File

@ -25,14 +25,13 @@ import com.maddyhome.idea.vim.KeyHandler
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :class"
*/
data class FindClassCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val arg = argument
if (arg.isNotEmpty()) {
val res = VimPlugin.getFile().openFile("$arg.java", context)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/FindFileCommand.kt
View File

@ -25,14 +25,13 @@ import com.maddyhome.idea.vim.KeyHandler
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :file"
*/
data class FindFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val arg = argument
if (arg.isNotEmpty()) {
val res = VimPlugin.getFile().openFile(arg, context)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/FindSymbolCommand.kt
View File

@ -24,14 +24,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.KeyHandler
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :symbol"
*/
data class FindSymbolCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
// TODO: Check the command argument and jump to a specific symbol
ApplicationManager.getApplication().invokeLater { KeyHandler.executeAction("GotoSymbol", context) }
return ExecutionResult.Success

3
src/com/maddyhome/idea/vim/vimscript/model/commands/GlobalCommand.kt
View File

@ -35,7 +35,6 @@ import com.maddyhome.idea.vim.regexp.CharPointer
import com.maddyhome.idea.vim.regexp.RegExp
import com.maddyhome.idea.vim.vimscript.Executor
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :global" / "h :vglobal"
@ -43,7 +42,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class GlobalCommand(val ranges: Ranges, val argument: String, val invert: Boolean) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.SELF_SYNCHRONIZED)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
var result: ExecutionResult = ExecutionResult.Success
editor.caretModel.removeSecondaryCarets()
val caret = editor.caretModel.currentCaret

2
src/com/maddyhome/idea/vim/vimscript/model/commands/GoToLineCommand.kt
View File

@ -8,7 +8,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.group.MotionGroup
import com.maddyhome.idea.vim.helper.EditorHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import java.lang.Integer.min
/**
@ -23,7 +22,6 @@ data class GoToLineCommand(val ranges: Ranges) :
editor: Editor,
caret: Caret,
context: DataContext,
vimContext: VimContext,
): ExecutionResult {
val line = min(this.getLine(editor, caret), EditorHelper.getLineCount(editor) - 1)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/GotoCharacterCommand.kt
View File

@ -25,7 +25,6 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.group.MotionGroup
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :goto"
@ -33,7 +32,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class GotoCharacterCommand(val ranges: Ranges, val argument: String) : Command.ForEachCaret(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_IS_COUNT, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, caret: Caret, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, caret: Caret, context: DataContext): ExecutionResult {
val count = getCount(editor, caret, 1, true)
if (count <= 0) return ExecutionResult.Error

3
src/com/maddyhome/idea/vim/vimscript/model/commands/HelpCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.actionSystem.DataContext
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import org.jetbrains.annotations.NonNls
import java.io.UnsupportedEncodingException
import java.net.URLEncoder
@ -34,7 +33,7 @@ import java.net.URLEncoder
*/
data class HelpCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
BrowserUtil.browse(helpTopicUrl(argument))
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/HistoryCommand.kt
View File

@ -30,14 +30,13 @@ import com.maddyhome.idea.vim.group.HistoryGroup.EXPRESSION
import com.maddyhome.idea.vim.group.HistoryGroup.INPUT
import com.maddyhome.idea.vim.group.HistoryGroup.SEARCH
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :history"
*/
data class HistoryCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
logger.debug("execute")
var arg = argument.trim().ifEmpty { "cmd" }

3
src/com/maddyhome/idea/vim/vimscript/model/commands/JoinLinesCommand.kt
View File

@ -25,7 +25,6 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.common.TextRange
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :join"
@ -33,7 +32,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class JoinLinesCommand(val ranges: Ranges, val argument: String) : Command.ForEachCaret(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.WRITABLE)
override fun processCommand(editor: Editor, caret: Caret, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, caret: Caret, context: DataContext): ExecutionResult {
val arg = argument
val spaces = arg.isEmpty() || arg[0] != '!'

3
src/com/maddyhome/idea/vim/vimscript/model/commands/JumpsCommand.kt
View File

@ -27,7 +27,6 @@ import com.maddyhome.idea.vim.helper.EditorHelper
import com.maddyhome.idea.vim.helper.StringHelper.stringToKeys
import com.maddyhome.idea.vim.helper.StringHelper.toPrintableCharacters
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import kotlin.math.absoluteValue
/**
@ -35,7 +34,7 @@ import kotlin.math.absoluteValue
*/
data class JumpsCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val jumps = VimPlugin.getMark().jumps
val spot = VimPlugin.getMark().jumpSpot

29
src/com/maddyhome/idea/vim/vimscript/model/commands/LetCommand.kt
View File

@ -10,7 +10,6 @@ import com.maddyhome.idea.vim.option.OptionsManager
import com.maddyhome.idea.vim.option.StringOption
import com.maddyhome.idea.vim.option.ToggleOption
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.model.datatypes.VimBlob
import com.maddyhome.idea.vim.vimscript.model.datatypes.VimDictionary
import com.maddyhome.idea.vim.vimscript.model.datatypes.VimInt
@ -41,21 +40,21 @@ data class LetCommand(
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
@Throws(ExException::class)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
when (variable) {
is Variable -> {
VariableService.storeVariable(
variable, operator.getNewValue(variable, expression, editor, context, vimContext),
editor, context, vimContext
variable, operator.getNewValue(variable, expression, editor, context, this),
editor, context, this
)
}
is OneElementSublistExpression -> {
if (variable.expression is Variable) {
val variableValue = VariableService.getNonNullVariableValue(variable.expression, editor, context, vimContext)
val variableValue = VariableService.getNonNullVariableValue(variable.expression, editor, context, this)
when (variableValue) {
is VimDictionary -> {
val dictKey = VimString(variable.index.evaluate(editor, context, vimContext).asString())
val dictKey = VimString(variable.index.evaluate(editor, context, this).asString())
if (operator != AssignmentOperator.ASSIGNMENT && !variableValue.dictionary.containsKey(dictKey)) {
throw ExException("E716: Key not present in Dictionary: $dictKey")
}
@ -63,21 +62,21 @@ data class LetCommand(
variableValue.dictionary[dictKey] =
operator.getNewValue(
SimpleExpression(variableValue.dictionary[dictKey]!!), expression, editor,
context, vimContext
context, this
)
} else {
variableValue.dictionary[dictKey] = expression.evaluate(editor, context, vimContext)
variableValue.dictionary[dictKey] = expression.evaluate(editor, context, this)
}
}
is VimList -> {
// we use Integer.parseInt(........asString()) because in case if index's type is Float, List, Dictionary etc
// vim throws the same error as the asString() method
val index = Integer.parseInt(variable.index.evaluate(editor, context, vimContext).asString())
val index = Integer.parseInt(variable.index.evaluate(editor, context, this).asString())
if (index > variableValue.values.size - 1) {
throw ExException("E684: list index out of range: $index")
}
variableValue.values[index] = operator.getNewValue(
SimpleExpression(variableValue.values[index]), expression, editor, context, vimContext
SimpleExpression(variableValue.values[index]), expression, editor, context, this
)
}
is VimBlob -> TODO()
@ -90,17 +89,17 @@ data class LetCommand(
is SublistExpression -> {
if (variable.expression is Variable) {
val variableValue = VariableService.getNonNullVariableValue(variable.expression, editor, context, vimContext)
val variableValue = VariableService.getNonNullVariableValue(variable.expression, editor, context, this)
if (variableValue is VimList) {
// we use Integer.parseInt(........asString()) because in case if index's type is Float, List, Dictionary etc
// vim throws the same error as the asString() method
val from = Integer.parseInt(variable.from?.evaluate(editor, context, vimContext)?.toString() ?: "0")
val from = Integer.parseInt(variable.from?.evaluate(editor, context, this)?.toString() ?: "0")
val to = Integer.parseInt(
variable.to?.evaluate(editor, context, vimContext)?.toString()
variable.to?.evaluate(editor, context, this)?.toString()
?: (variableValue.values.size - 1).toString()
)
val expressionValue = expression.evaluate(editor, context, vimContext)
val expressionValue = expression.evaluate(editor, context, this)
if (expressionValue !is VimList && expressionValue !is VimBlob) {
throw ExException("E709: [:] requires a List or Blob value")
} else if (expressionValue is VimList) {
@ -142,7 +141,7 @@ data class LetCommand(
if (operator == AssignmentOperator.ASSIGNMENT || operator == AssignmentOperator.CONCATENATION ||
operator == AssignmentOperator.ADDITION || operator == AssignmentOperator.SUBTRACTION
) {
val newValue = operator.getNewValue(SimpleExpression(optionValue), expression, editor, context, vimContext)
val newValue = operator.getNewValue(SimpleExpression(optionValue), expression, editor, context, this)
when (option) {
is ToggleOption -> {
if (newValue.asBoolean()) {

3
src/com/maddyhome/idea/vim/vimscript/model/commands/MarkCommand.kt
View File

@ -26,7 +26,6 @@ import com.maddyhome.idea.vim.helper.EditorHelper
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.helper.Msg
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :mark"
@ -34,7 +33,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class MarkCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_REQUIRED, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val mark = argument[0]
val line = getLine(editor)
val offset = EditorHelper.getLineStartOffset(editor, line)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/MarksCommand.kt
View File

@ -27,7 +27,6 @@ import com.maddyhome.idea.vim.helper.EditorHelper
import com.maddyhome.idea.vim.helper.StringHelper.stringToKeys
import com.maddyhome.idea.vim.helper.StringHelper.toPrintableCharacters
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :marks"
@ -35,7 +34,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class MarksCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
// Yeah, lower case. Vim uses lower case here, but Title Case in :registers. Go figure.
val res = VimPlugin.getMark().getMarks(editor)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/MoveTextCommand.kt
View File

@ -34,7 +34,6 @@ import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.helper.Msg
import com.maddyhome.idea.vim.helper.fileSize
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.parser.VimscriptParser
import kotlin.math.min
@ -45,7 +44,7 @@ data class MoveTextCommand(val ranges: Ranges, val argument: String) : Command.S
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_REQUIRED, Access.WRITABLE)
@Throws(ExException::class)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val carets = EditorHelper.getOrderedCaretsList(editor)
val caretModel = editor.caretModel
val caretCount = caretModel.caretCount

3
src/com/maddyhome/idea/vim/vimscript/model/commands/NextFileCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :next" / "h :bnext"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class NextFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_IS_COUNT, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val count = getCount(editor, 1, true)
VimPlugin.getMark().saveJumpLocation(editor)
VimPlugin.getFile().selectNextFile(count, context)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/NextTabCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :tabnext"
*/
data class NextTabCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getMotion().moveCaretGotoNextTab(editor, context, argument.toIntOrNull() ?: 0)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/NoHLSearchCommand.kt
View File

@ -22,14 +22,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :nohlsearch"
*/
data class NoHLSearchCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getSearch().clearSearchHighlight()
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/OnlyCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :only"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class OnlyCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getWindow().closeAllExceptCurrent(context)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/PlugCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.extension.VimExtensionRegistrar
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* This handler is created to support `Plug` command from vim-plug and `Plugin` command from vundle.
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class PlugCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_REQUIRED, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val argument = argument
val firstChar = argument[0]
if (firstChar != '"' && firstChar != '\'') return ExecutionResult.Error

3
src/com/maddyhome/idea/vim/vimscript/model/commands/PreviousFileCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :previous" / "h :bprevious"
*/
data class PreviousFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_IS_COUNT, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val count = getCount(editor, 1, true)
VimPlugin.getMark().saveJumpLocation(editor)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/PreviousTabCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :tabprevious"
*/
data class PreviousTabCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getMotion().moveCaretGotoPreviousTab(editor, context, argument.toIntOrNull() ?: 0)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/PrintCommand.kt
View File

@ -24,7 +24,6 @@ import com.intellij.openapi.util.TextRange
import com.maddyhome.idea.vim.ex.ExOutputModel
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :print"
@ -32,7 +31,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class PrintCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
editor.caretModel.removeSecondaryCarets()
val caret = editor.caretModel.currentCaret
val textRange = getTextRange(editor, caret, checkCount = true)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/PromptFindCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.KeyHandler
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :promptfind"
*/
data class PromptFindCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (KeyHandler.executeAction("Find", context)) ExecutionResult.Success else ExecutionResult.Error
}
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/PromptReplaceCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.KeyHandler
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :promptrepl"
*/
data class PromptReplaceCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (KeyHandler.executeAction("Replace", context)) ExecutionResult.Success else ExecutionResult.Error
}
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/PutLinesCommand.kt
View File

@ -26,7 +26,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.group.copy.PutData
import com.maddyhome.idea.vim.helper.StringHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :put"
@ -34,7 +33,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class PutLinesCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
if (editor.isOneLineMode) return ExecutionResult.Error
val registerGroup = VimPlugin.getRegister()

3
src/com/maddyhome/idea/vim/vimscript/model/commands/QuitCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :quit" / "h :close" / "h :quit"
*/
data class QuitCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getFile().closeFile(editor, context)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/RedoCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.UndoRedoHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :redo"
*/
data class RedoCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.WRITABLE)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (UndoRedoHelper.redo(context)) ExecutionResult.Success else ExecutionResult.Error
}
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/RegistersCommand.kt
View File

@ -27,14 +27,13 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.StringHelper
import com.maddyhome.idea.vim.helper.StringHelper.parseKeys
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :registers" / "h :display"
*/
data class RegistersCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val registerGroup = VimPlugin.getRegister()
val regs = registerGroup.registers

3
src/com/maddyhome/idea/vim/vimscript/model/commands/RepeatCommand.kt
View File

@ -27,7 +27,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.group.MotionGroup
import com.maddyhome.idea.vim.vimscript.Executor
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :@"
@ -38,7 +37,7 @@ data class RepeatCommand(val ranges: Ranges, val argument: String) : Command.For
private var lastArg = ':'
@Throws(ExException::class)
override fun processCommand(editor: Editor, caret: Caret, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, caret: Caret, context: DataContext): ExecutionResult {
var arg = argument[0]
if (arg == '@') arg = lastArg
lastArg = arg

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SelectFileCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :argument"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class SelectFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_IS_COUNT, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val count = getCount(editor, 0, true)
if (count > 0) {

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SelectFirstFileCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :first"
*/
data class SelectFirstFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val res = VimPlugin.getFile().selectFile(0, context)
if (res) {
VimPlugin.getMark().saveJumpLocation(editor)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SelectLastFileCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :last"
*/
data class SelectLastFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val res = VimPlugin.getFile().selectFile(999, context)
if (res) {
VimPlugin.getMark().saveJumpLocation(editor)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SetCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.option.OptionsManager
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :set"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class SetCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (parseOptionLine(editor, true)) ExecutionResult.Success else ExecutionResult.Error
}
private fun parseOptionLine(editor: Editor?, failOnBad: Boolean) =

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SetHandlerCommand.kt
View File

@ -26,12 +26,11 @@ import com.maddyhome.idea.vim.helper.StringHelper.parseKeys
import com.maddyhome.idea.vim.key.ShortcutOwner
import com.maddyhome.idea.vim.key.ShortcutOwnerInfo
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
data class SetHandlerCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (doCommand()) ExecutionResult.Success else ExecutionResult.Error
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/ShellCommand.kt
View File

@ -22,7 +22,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.KeyHandler
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* @author John Grib
@ -30,7 +29,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
*/
data class ShellCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (KeyHandler.executeAction("ActivateTerminalToolWindow", context)) ExecutionResult.Success else ExecutionResult.Error
}
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/ShiftLeftCommand.kt
View File

@ -25,7 +25,6 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.common.TextRange
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :<"
@ -33,7 +32,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class ShiftLeftCommand(val ranges: Ranges, val argument: String, val length: Int) : Command.ForEachCaret(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.WRITABLE)
override fun processCommand(editor: Editor, caret: Caret, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, caret: Caret, context: DataContext): ExecutionResult {
val range = getTextRange(editor, caret, true)
val endOffsets = range.endOffsets.map { it - 1 }.toIntArray()
VimPlugin.getChange().indentRange(

3
src/com/maddyhome/idea/vim/vimscript/model/commands/ShiftRightCommand.kt
View File

@ -25,7 +25,6 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.common.TextRange
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :>"
@ -33,7 +32,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class ShiftRightCommand(val ranges: Ranges, val argument: String, val length: Int) : Command.ForEachCaret(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.WRITABLE)
override fun processCommand(editor: Editor, caret: Caret, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, caret: Caret, context: DataContext): ExecutionResult {
val range = getTextRange(editor, caret, true)
val endOffsets = range.endOffsets.map { it - 1 }.toIntArray()
VimPlugin.getChange().indentRange(

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SortCommand.kt
View File

@ -29,7 +29,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.inBlockSubMode
import com.maddyhome.idea.vim.helper.moveToInlayAwareOffset
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* @author Alex Selesse
@ -39,7 +38,7 @@ data class SortCommand(val ranges: Ranges, val argument: String) : Command.Singl
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.WRITABLE)
@Throws(ExException::class)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val arg = argument
val nonEmptyArg = arg.trim().isNotEmpty()

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SourceCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.Executor
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import java.io.File
/**
@ -32,7 +31,7 @@ import java.io.File
*/
data class SourceCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_REQUIRED, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val path = expandUser(argument.trim())
Executor.executeFile(File(path))
return ExecutionResult.Success

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SplitCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :split" / "h :vsplit"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class SplitCommand(val ranges: Ranges, val argument: String, val splitType: SplitType) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
if (splitType == SplitType.VERTICAL) {
VimPlugin.getWindow().splitWindowVertical(context, argument)
} else {

3
src/com/maddyhome/idea/vim/vimscript/model/commands/SubstituteCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :substitute"
*/
data class SubstituteCommand(val ranges: Ranges, val argument: String, val command: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.SELF_SYNCHRONIZED)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
var result = true
for (caret in editor.caretModel.allCarets) {
val lineRange = getLineRange(editor, caret)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/TabCloseCommand.kt
View File

@ -26,7 +26,6 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* @author Rieon Ke
@ -36,7 +35,7 @@ data class TabCloseCommand(val ranges: Ranges, val argument: String) : Command.S
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val project = PlatformDataKeys.PROJECT.getData(context) ?: return ExecutionResult.Error
val fileEditorManager = FileEditorManagerEx.getInstanceEx(project)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/TabOnlyCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :tabonly"
*/
data class TabOnlyCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_IS_COUNT, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getWindow().closeAllExceptCurrentTab(context)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/UndoCommand.kt
View File

@ -23,7 +23,6 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.UndoRedoHelper
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :undo"
@ -31,7 +30,7 @@ import com.maddyhome.idea.vim.vimscript.model.VimContext
data class UndoCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.WRITABLE)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (UndoRedoHelper.undo(context)) ExecutionResult.Success else ExecutionResult.Error
}
}

12
src/com/maddyhome/idea/vim/vimscript/model/commands/UnknownCommand.kt
View File

@ -28,7 +28,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.MessageHelper
import com.maddyhome.idea.vim.helper.Msg
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.model.commands.UnknownCommand.Constants.MAX_RECURSION
import com.maddyhome.idea.vim.vimscript.parser.VimscriptParser
@ -43,11 +42,11 @@ data class UnknownCommand(val ranges: Ranges, val name: String, val argument: St
const val MAX_RECURSION = 100
}
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
return processPossiblyAliasCommand("$name $argument", editor, context, vimContext, MAX_RECURSION)
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return processPossiblyAliasCommand("$name $argument", editor, context, MAX_RECURSION)
}
private fun processPossiblyAliasCommand(name: String, editor: Editor, context: DataContext, vimContext: VimContext, aliasCountdown: Int): ExecutionResult {
private fun processPossiblyAliasCommand(name: String, editor: Editor, context: DataContext, aliasCountdown: Int): ExecutionResult {
if (VimPlugin.getCommand().isAlias(name)) {
if (aliasCountdown > 0) {
val commandAlias = VimPlugin.getCommand().getAliasCommand(name, 1)
@ -59,9 +58,10 @@ data class UnknownCommand(val ranges: Ranges, val name: String, val argument: St
}
val parsedCommand = VimscriptParser.parseCommand(commandAlias.command) ?: throw ExException("E492: Not an editor command: ${commandAlias.command}")
return if (parsedCommand is UnknownCommand) {
processPossiblyAliasCommand(commandAlias.command, editor, context, vimContext, aliasCountdown - 1)
processPossiblyAliasCommand(commandAlias.command, editor, context, aliasCountdown - 1)
} else {
parsedCommand.execute(editor, context, vimContext)
parsedCommand.parent = this.parent
parsedCommand.execute(editor, context)
ExecutionResult.Success
}
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/WriteAllCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :wall"
*/
data class WriteAllCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getFile().saveFiles(context)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/WriteCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :write"
*/
data class WriteCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getFile().saveFile(context)
return ExecutionResult.Success
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/WriteNextFileCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :wnext"
*/
data class WriteNextFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_IS_COUNT, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val count = getCount(editor, 1, true)
VimPlugin.getFile().saveFile(context)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/WritePreviousFileCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :wprevious"
*/
data class WritePreviousFileCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val count = getCount(editor, 1, true)
VimPlugin.getFile().saveFile(context)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/WriteQuitCommand.kt
View File

@ -23,14 +23,13 @@ import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :exit"
*/
data class WriteQuitCommand(val ranges: Ranges, val argument: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
VimPlugin.getFile().saveFile(context)
VimPlugin.getFile().closeFile(editor, context)

3
src/com/maddyhome/idea/vim/vimscript/model/commands/YankLinesCommand.kt
View File

@ -26,7 +26,6 @@ import com.maddyhome.idea.vim.common.TextRange
import com.maddyhome.idea.vim.ex.ExException
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
/**
* see "h :yank"
@ -35,7 +34,7 @@ data class YankLinesCommand(val ranges: Ranges, var argument: String) : Command.
override val argFlags = flags(RangeFlag.RANGE_OPTIONAL, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
@Throws(ExException::class)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
val argument = this.argument
val registerGroup = VimPlugin.getRegister()
val register = if (argument.isNotEmpty() && !argument[0].isDigit()) {

3
src/com/maddyhome/idea/vim/vimscript/model/commands/mapping/MapClearCommand.kt
View File

@ -24,13 +24,12 @@ import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.command.MappingMode
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.model.commands.Command
data class MapClearCommand(val ranges: Ranges, val argument: String, val cmd: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_FORBIDDEN, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (executeCommand()) ExecutionResult.Success else ExecutionResult.Error
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/mapping/MapCommand.kt
View File

@ -27,7 +27,6 @@ import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.StringHelper.parseKeys
import com.maddyhome.idea.vim.key.MappingOwner
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.model.commands.Command
import com.maddyhome.idea.vim.vimscript.model.commands.mapping.MapCommand.SpecialArgument.EXPR
import com.maddyhome.idea.vim.vimscript.model.commands.mapping.MapCommand.SpecialArgument.SCRIPT
@ -46,7 +45,7 @@ data class MapCommand(val ranges: Ranges, val argument: String, val cmd: String)
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_OPTIONAL, Access.READ_ONLY)
@Throws(ExException::class)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (executeCommand(editor)) ExecutionResult.Success else ExecutionResult.Error
}

3
src/com/maddyhome/idea/vim/vimscript/model/commands/mapping/UnMapCommand.kt
View File

@ -25,13 +25,12 @@ import com.maddyhome.idea.vim.command.MappingMode
import com.maddyhome.idea.vim.ex.ranges.Ranges
import com.maddyhome.idea.vim.helper.StringHelper.parseKeys
import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
import com.maddyhome.idea.vim.vimscript.model.VimContext
import com.maddyhome.idea.vim.vimscript.model.commands.Command
data class UnMapCommand(val ranges: Ranges, val argument: String, val cmd: String) : Command.SingleExecution(ranges, argument) {
override val argFlags = flags(RangeFlag.RANGE_FORBIDDEN, ArgumentFlag.ARGUMENT_REQUIRED, Access.READ_ONLY)
override fun processCommand(editor: Editor, context: DataContext, vimContext: VimContext): ExecutionResult {
override fun processCommand(editor: Editor, context: DataContext): ExecutionResult {
return if (executeCommand()) ExecutionResult.Success else ExecutionResult.Error
}