git.r.bdr.sh - rbdr/dotfiles/blob - atom/packages/vim-mode/spec/operators-spec.coffee

   1 helpers = require './spec-helper'
   2 settings = require '../lib/settings'
   3
   4 describe "Operators", ->
   5   [editor, editorElement, vimState] = []
   6
   7   beforeEach ->
   8     vimMode = atom.packages.loadPackage('vim-mode')
   9     vimMode.activateResources()
  10
  11     helpers.getEditorElement (element) ->
  12       editorElement = element
  13       editor = editorElement.getModel()
  14       vimState = editorElement.vimState
  15       vimState.activateNormalMode()
  16       vimState.resetNormalMode()
  17
  18   keydown = (key, options={}) ->
  19     options.element ?= editorElement
  20     helpers.keydown(key, options)
  21
  22   normalModeInputKeydown = (key, opts = {}) ->
  23     editor.normalModeInputView.editorElement.getModel().setText(key)
  24
  25   describe "cancelling operations", ->
  26     it "throws an error when no operation is pending", ->
  27       # cancel operation pushes an empty input operation
  28       # doing this without a pending operation would throw an exception
  29       expect(-> vimState.pushOperations(new Input(''))).toThrow()
  30
  31     it "cancels and cleans up properly", ->
  32       # make sure normalModeInputView is created
  33       keydown('/')
  34       expect(vimState.isOperatorPending()).toBe true
  35       editor.normalModeInputView.viewModel.cancel()
  36
  37       expect(vimState.isOperatorPending()).toBe false
  38       expect(editor.normalModeInputView).toBe undefined
  39
  40   describe "the x keybinding", ->
  41     describe "on a line with content", ->
  42       describe "without vim-mode.wrapLeftRightMotion", ->
  43         beforeEach ->
  44           editor.setText("abc\n012345\n\nxyz")
  45           editor.setCursorScreenPosition([1, 4])
  46
  47         it "deletes a character", ->
  48           keydown('x')
  49           expect(editor.getText()).toBe 'abc\n01235\n\nxyz'
  50           expect(editor.getCursorScreenPosition()).toEqual [1, 4]
  51           expect(vimState.getRegister('"').text).toBe '4'
  52
  53           keydown('x')
  54           expect(editor.getText()).toBe 'abc\n0123\n\nxyz'
  55           expect(editor.getCursorScreenPosition()).toEqual [1, 3]
  56           expect(vimState.getRegister('"').text).toBe '5'
  57
  58           keydown('x')
  59           expect(editor.getText()).toBe 'abc\n012\n\nxyz'
  60           expect(editor.getCursorScreenPosition()).toEqual [1, 2]
  61           expect(vimState.getRegister('"').text).toBe '3'
  62
  63           keydown('x')
  64           expect(editor.getText()).toBe 'abc\n01\n\nxyz'
  65           expect(editor.getCursorScreenPosition()).toEqual [1, 1]
  66           expect(vimState.getRegister('"').text).toBe '2'
  67
  68           keydown('x')
  69           expect(editor.getText()).toBe 'abc\n0\n\nxyz'
  70           expect(editor.getCursorScreenPosition()).toEqual [1, 0]
  71           expect(vimState.getRegister('"').text).toBe '1'
  72
  73           keydown('x')
  74           expect(editor.getText()).toBe 'abc\n\n\nxyz'
  75           expect(editor.getCursorScreenPosition()).toEqual [1, 0]
  76           expect(vimState.getRegister('"').text).toBe '0'
  77
  78         it "deletes multiple characters with a count", ->
  79           keydown('2')
  80           keydown('x')
  81           expect(editor.getText()).toBe 'abc\n0123\n\nxyz'
  82           expect(editor.getCursorScreenPosition()).toEqual [1, 3]
  83           expect(vimState.getRegister('"').text).toBe '45'
  84
  85           editor.setCursorScreenPosition([0, 1])
  86           keydown('3')
  87           keydown('x')
  88           expect(editor.getText()).toBe 'a\n0123\n\nxyz'
  89           expect(editor.getCursorScreenPosition()).toEqual [0, 0]
  90           expect(vimState.getRegister('"').text).toBe 'bc'
  91
  92       describe "with multiple cursors", ->
  93         beforeEach ->
  94           editor.setText "abc\n012345\n\nxyz"
  95           editor.setCursorScreenPosition [1, 4]
  96           editor.addCursorAtBufferPosition [0, 1]
  97
  98         it "is undone as one operation", ->
  99           keydown('x')
 100           expect(editor.getText()).toBe "ac\n01235\n\nxyz"
 101           keydown('u')
 102           expect(editor.getText()).toBe "abc\n012345\n\nxyz"
 103
 104       describe "with vim-mode.wrapLeftRightMotion", ->
 105         beforeEach ->
 106           editor.setText("abc\n012345\n\nxyz")
 107           editor.setCursorScreenPosition([1, 4])
 108           atom.config.set('vim-mode.wrapLeftRightMotion', true)
 109
 110         it "deletes a character", ->
 111           # copy of the earlier test because wrapLeftRightMotion should not affect it
 112           keydown('x')
 113           expect(editor.getText()).toBe 'abc\n01235\n\nxyz'
 114           expect(editor.getCursorScreenPosition()).toEqual [1, 4]
 115           expect(vimState.getRegister('"').text).toBe '4'
 116
 117           keydown('x')
 118           expect(editor.getText()).toBe 'abc\n0123\n\nxyz'
 119           expect(editor.getCursorScreenPosition()).toEqual [1, 3]
 120           expect(vimState.getRegister('"').text).toBe '5'
 121
 122           keydown('x')
 123           expect(editor.getText()).toBe 'abc\n012\n\nxyz'
 124           expect(editor.getCursorScreenPosition()).toEqual [1, 2]
 125           expect(vimState.getRegister('"').text).toBe '3'
 126
 127           keydown('x')
 128           expect(editor.getText()).toBe 'abc\n01\n\nxyz'
 129           expect(editor.getCursorScreenPosition()).toEqual [1, 1]
 130           expect(vimState.getRegister('"').text).toBe '2'
 131
 132           keydown('x')
 133           expect(editor.getText()).toBe 'abc\n0\n\nxyz'
 134           expect(editor.getCursorScreenPosition()).toEqual [1, 0]
 135           expect(vimState.getRegister('"').text).toBe '1'
 136
 137           keydown('x')
 138           expect(editor.getText()).toBe 'abc\n\n\nxyz'
 139           expect(editor.getCursorScreenPosition()).toEqual [1, 0]
 140           expect(vimState.getRegister('"').text).toBe '0'
 141
 142         it "deletes multiple characters and newlines with a count", ->
 143           atom.config.set('vim-mode.wrapLeftRightMotion', true)
 144           keydown('2')
 145           keydown('x')
 146           expect(editor.getText()).toBe 'abc\n0123\n\nxyz'
 147           expect(editor.getCursorScreenPosition()).toEqual [1, 3]
 148           expect(vimState.getRegister('"').text).toBe '45'
 149
 150           editor.setCursorScreenPosition([0, 1])
 151           keydown('3')
 152           keydown('x')
 153           expect(editor.getText()).toBe 'a0123\n\nxyz'
 154           expect(editor.getCursorScreenPosition()).toEqual [0, 1]
 155           expect(vimState.getRegister('"').text).toBe 'bc\n'
 156
 157           keydown('7')
 158           keydown('x')
 159           expect(editor.getText()).toBe 'ayz'
 160           expect(editor.getCursorScreenPosition()).toEqual [0, 1]
 161           expect(vimState.getRegister('"').text).toBe '0123\n\nx'
 162
 163     describe "on an empty line", ->
 164       beforeEach ->
 165         editor.setText("abc\n012345\n\nxyz")
 166         editor.setCursorScreenPosition([2, 0])
 167
 168       it "deletes nothing on an empty line when vim-mode.wrapLeftRightMotion is false", ->
 169         atom.config.set('vim-mode.wrapLeftRightMotion', false)
 170         keydown('x')
 171         expect(editor.getText()).toBe "abc\n012345\n\nxyz"
 172         expect(editor.getCursorScreenPosition()).toEqual [2, 0]
 173
 174       it "deletes an empty line when vim-mode.wrapLeftRightMotion is true", ->
 175         atom.config.set('vim-mode.wrapLeftRightMotion', true)
 176         keydown('x')
 177         expect(editor.getText()).toBe "abc\n012345\nxyz"
 178         expect(editor.getCursorScreenPosition()).toEqual [2, 0]
 179
 180   describe "the X keybinding", ->
 181     describe "on a line with content", ->
 182       beforeEach ->
 183         editor.setText("ab\n012345")
 184         editor.setCursorScreenPosition([1, 2])
 185
 186       it "deletes a character", ->
 187         keydown('X', shift: true)
 188         expect(editor.getText()).toBe 'ab\n02345'
 189         expect(editor.getCursorScreenPosition()).toEqual [1, 1]
 190         expect(vimState.getRegister('"').text).toBe '1'
 191
 192         keydown('X', shift: true)
 193         expect(editor.getText()).toBe 'ab\n2345'
 194         expect(editor.getCursorScreenPosition()).toEqual [1, 0]
 195         expect(vimState.getRegister('"').text).toBe '0'
 196
 197         keydown('X', shift: true)
 198         expect(editor.getText()).toBe 'ab\n2345'
 199         expect(editor.getCursorScreenPosition()).toEqual [1, 0]
 200         expect(vimState.getRegister('"').text).toBe '0'
 201
 202         atom.config.set('vim-mode.wrapLeftRightMotion', true)
 203         keydown('X', shift: true)
 204         expect(editor.getText()).toBe 'ab2345'
 205         expect(editor.getCursorScreenPosition()).toEqual [0, 2]
 206         expect(vimState.getRegister('"').text).toBe '\n'
 207
 208     describe "on an empty line", ->
 209       beforeEach ->
 210         editor.setText("012345\n\nabcdef")
 211         editor.setCursorScreenPosition([1, 0])
 212
 213       it "deletes nothing when vim-mode.wrapLeftRightMotion is false", ->
 214         atom.config.set('vim-mode.wrapLeftRightMotion', false)
 215         keydown('X', shift: true)
 216         expect(editor.getText()).toBe "012345\n\nabcdef"
 217         expect(editor.getCursorScreenPosition()).toEqual [1, 0]
 218
 219       it "deletes the newline when wrapLeftRightMotion is true", ->
 220         atom.config.set('vim-mode.wrapLeftRightMotion', true)
 221         keydown('X', shift: true)
 222         expect(editor.getText()).toBe "012345\nabcdef"
 223         expect(editor.getCursorScreenPosition()).toEqual [0, 5]
 224
 225   describe "the s keybinding", ->
 226     beforeEach ->
 227       editor.setText('012345')
 228       editor.setCursorScreenPosition([0, 1])
 229
 230     it "deletes the character to the right and enters insert mode", ->
 231       keydown('s')
 232       expect(editorElement.classList.contains('insert-mode')).toBe(true)
 233       expect(editor.getText()).toBe '02345'
 234       expect(editor.getCursorScreenPosition()).toEqual [0, 1]
 235       expect(vimState.getRegister('"').text).toBe '1'
 236
 237     it "is repeatable", ->
 238       editor.setCursorScreenPosition([0, 0])
 239       keydown('3')
 240       keydown('s')
 241       editor.insertText("ab")
 242       keydown('escape')
 243       expect(editor.getText()).toBe 'ab345'
 244       editor.setCursorScreenPosition([0, 2])
 245       keydown('.')
 246       expect(editor.getText()).toBe 'abab'
 247
 248     it "is undoable", ->
 249       editor.setCursorScreenPosition([0, 0])
 250       keydown('3')
 251       keydown('s')
 252       editor.insertText("ab")
 253       keydown('escape')
 254       expect(editor.getText()).toBe 'ab345'
 255       keydown('u')
 256       expect(editor.getText()).toBe '012345'
 257       expect(editor.getSelectedText()).toBe ''
 258
 259     describe "in visual mode", ->
 260       beforeEach ->
 261         keydown('v')
 262         editor.selectRight()
 263         keydown('s')
 264
 265       it "deletes the selected characters and enters insert mode", ->
 266         expect(editorElement.classList.contains('insert-mode')).toBe(true)
 267         expect(editor.getText()).toBe '0345'
 268         expect(editor.getCursorScreenPosition()).toEqual [0, 1]
 269         expect(vimState.getRegister('"').text).toBe '12'
 270
 271   describe "the S keybinding", ->
 272     beforeEach ->
 273       editor.setText("12345\nabcde\nABCDE")
 274       editor.setCursorScreenPosition([1, 3])
 275
 276     it "deletes the entire line and enters insert mode", ->
 277       keydown('S', shift: true)
 278       expect(editorElement.classList.contains('insert-mode')).toBe(true)
 279       expect(editor.getText()).toBe "12345\n\nABCDE"
 280       expect(editor.getCursorScreenPosition()).toEqual [1, 0]
 281       expect(vimState.getRegister('"').text).toBe "abcde\n"
 282       expect(vimState.getRegister('"').type).toBe 'linewise'
 283
 284     it "is repeatable", ->
 285       keydown('S', shift: true)
 286       editor.insertText("abc")
 287       keydown 'escape'
 288       expect(editor.getText()).toBe "12345\nabc\nABCDE"
 289       editor.setCursorScreenPosition([2, 3])
 290       keydown '.'
 291       expect(editor.getText()).toBe "12345\nabc\nabc\n"
 292
 293     it "is undoable", ->
 294       keydown('S', shift: true)
 295       editor.insertText("abc")
 296       keydown 'escape'
 297       expect(editor.getText()).toBe "12345\nabc\nABCDE"
 298       keydown 'u'
 299       expect(editor.getText()).toBe "12345\nabcde\nABCDE"
 300       expect(editor.getSelectedText()).toBe ''
 301
 302     it "works when the cursor's goal column is greater than its current column", ->
 303       editor.setText("\n12345")
 304       editor.setCursorBufferPosition([1, Infinity])
 305       editor.moveUp()
 306       keydown("S", shift: true)
 307       expect(editor.getText()).toBe("\n12345")
 308
 309     # Can't be tested without setting grammar of test buffer
 310     xit "respects indentation", ->
 311
 312   describe "the d keybinding", ->
 313     it "enters operator-pending mode", ->
 314       keydown('d')
 315       expect(editorElement.classList.contains('operator-pending-mode')).toBe(true)
 316       expect(editorElement.classList.contains('normal-mode')).toBe(false)
 317
 318     describe "when followed by a d", ->
 319       it "deletes the current line and exits operator-pending mode", ->
 320         editor.setText("12345\nabcde\n\nABCDE")
 321         editor.setCursorScreenPosition([1, 1])
 322
 323         keydown('d')
 324         keydown('d')
 325
 326         expect(editor.getText()).toBe "12345\n\nABCDE"
 327         expect(editor.getCursorScreenPosition()).toEqual [1, 0]
 328         expect(vimState.getRegister('"').text).toBe "abcde\n"
 329         expect(editorElement.classList.contains('operator-pending-mode')).toBe(false)
 330         expect(editorElement.classList.contains('normal-mode')).toBe(true)
 331
 332       it "deletes the last line", ->
 333         editor.setText("12345\nabcde\nABCDE")
 334         editor.setCursorScreenPosition([2, 1])
 335
 336         keydown('d')
 337         keydown('d')
 338
 339         expect(editor.getText()).toBe "12345\nabcde\n"
 340         expect(editor.getCursorScreenPosition()).toEqual [2, 0]
 341
 342       it "leaves the cursor on the first nonblank character", ->
 343         editor.setText("12345\n  abcde\n")
 344         editor.setCursorScreenPosition([0, 4])
 345
 346         keydown('d')
 347         keydown('d')
 348
 349         expect(editor.getText()).toBe "  abcde\n"
 350         expect(editor.getCursorScreenPosition()).toEqual [0, 2]
 351
 352     describe "undo behavior", ->
 353       beforeEach ->
 354         editor.setText("12345\nabcde\nABCDE\nQWERT")
 355         editor.setCursorScreenPosition([1, 1])
 356
 357       it "undoes both lines", ->
 358         keydown('d')
 359         keydown('2')
 360         keydown('d')
 361
 362         keydown('u')
 363
 364         expect(editor.getText()).toBe "12345\nabcde\nABCDE\nQWERT"
 365         expect(editor.getSelectedText()).toBe ''
 366
 367       describe "with multiple cursors", ->
 368         beforeEach ->
 369           editor.setCursorBufferPosition([1, 1])
 370           editor.addCursorAtBufferPosition([0, 0])
 371
 372         it "is undone as one operation", ->
 373           keydown('d')
 374           keydown('l')
 375
 376           keydown('u')
 377
 378           expect(editor.getText()).toBe "12345\nabcde\nABCDE\nQWERT"
 379           expect(editor.getSelectedText()).toBe ''
 380
 381     describe "when followed by a w", ->
 382       it "deletes the next word until the end of the line and exits operator-pending mode", ->
 383         editor.setText("abcd efg\nabc")
 384         editor.setCursorScreenPosition([0, 5])
 385
 386         keydown('d')
 387         keydown('w')
 388
 389         # Incompatibility with VIM. In vim, `w` behaves differently as an
 390         # operator than as a motion; it stops at the end of a line.expect(editor.getText()).toBe "abcd abc"
 391         expect(editor.getText()).toBe "abcd abc"
 392         expect(editor.getCursorScreenPosition()).toEqual [0, 5]
 393
 394         expect(editorElement.classList.contains('operator-pending-mode')).toBe(false)
 395         expect(editorElement.classList.contains('normal-mode')).toBe(true)
 396
 397       it "deletes to the beginning of the next word", ->
 398         editor.setText('abcd efg')
 399         editor.setCursorScreenPosition([0, 2])
 400
 401         keydown('d')
 402         keydown('w')
 403
 404         expect(editor.getText()).toBe 'abefg'
 405         expect(editor.getCursorScreenPosition()).toEqual [0, 2]
 406
 407         editor.setText('one two three four')
 408         editor.setCursorScreenPosition([0, 0])
 409
 410         keydown('d')
 411         keydown('3')
 412         keydown('w')
 413
 414         expect(editor.getText()).toBe 'four'
 415         expect(editor.getCursorScreenPosition()).toEqual [0, 0]
 416
 417     describe "when followed by an iw", ->
 418       it "deletes the containing word", ->
 419         editor.setText("12345 abcde ABCDE")
 420         editor.setCursorScreenPosition([0, 9])
 421
 422         keydown('d')
 423         expect(editorElement.classList.contains('operator-pending-mode')).toBe(true)
 424         keydown('i')
 425         keydown('w')
 426
 427         expect(editor.getText()).toBe "12345  ABCDE"
 428         expect(editor.getCursorScreenPosition()).toEqual [0, 6]
 429         expect(vimState.getRegister('"').text).toBe "abcde"
 430         expect(editorElement.classList.contains('operator-pending-mode')).toBe(false)
 431         expect(editorElement.classList.contains('normal-mode')).toBe(true)
 432
 433     describe "when followed by a j", ->
 434       originalText = "12345\nabcde\nABCDE\n"
 435
 436       beforeEach ->
 437         editor.setText(originalText)
 438
 439       describe "on the beginning of the file", ->
 440         it "deletes the next two lines", ->
 441           editor.setCursorScreenPosition([0, 0])
 442           keydown('d')
 443           keydown('j')
 444           expect(editor.getText()).toBe("ABCDE\n")
 445
 446       describe "on the end of the file", ->
 447         it "deletes nothing", ->
 448           editor.setCursorScreenPosition([4, 0])
 449           keydown('d')
 450           keydown('j')
 451           expect(editor.getText()).toBe(originalText)
 452
 453       describe "on the middle of second line", ->
 454         it "deletes the last two lines", ->
 455           editor.setCursorScreenPosition([1, 2])
 456           keydown('d')
 457           keydown('j')
 458           expect(editor.getText()).toBe("12345\n")
 459
 460     describe "when followed by an k", ->
 461       originalText = "12345\nabcde\nABCDE"
 462
 463       beforeEach ->
 464         editor.setText(originalText)
 465
 466       describe "on the end of the file", ->
 467         it "deletes the bottom two lines", ->
 468           editor.setCursorScreenPosition([2, 4])
 469           keydown('d')
 470           keydown('k')
 471           expect(editor.getText()).toBe("12345\n")
 472
 473       describe "on the beginning of the file", ->
 474         xit "deletes nothing", ->
 475           editor.setCursorScreenPosition([0, 0])
 476           keydown('d')
 477           keydown('k')
 478           expect(editor.getText()).toBe(originalText)
 479
 480       describe "when on the middle of second line", ->
 481         it "deletes the first two lines", ->
 482           editor.setCursorScreenPosition([1, 2])
 483           keydown('d')
 484           keydown('k')
 485           expect(editor.getText()).toBe("ABCDE")
 486
 487     describe "when followed by a G", ->
 488       beforeEach ->
 489         originalText = "12345\nabcde\nABCDE"
 490         editor.setText(originalText)
 491
 492       describe "on the beginning of the second line", ->
 493         it "deletes the bottom two lines", ->
 494           editor.setCursorScreenPosition([1, 0])
 495           keydown('d')
 496           keydown('G', shift: true)
 497           expect(editor.getText()).toBe("12345\n")
 498
 499       describe "on the middle of the second line", ->
 500         it "deletes the bottom two lines", ->
 501           editor.setCursorScreenPosition([1, 2])
 502           keydown('d')
 503           keydown('G', shift: true)
 504           expect(editor.getText()).toBe("12345\n")
 505
 506     describe "when followed by a goto line G", ->
 507       beforeEach ->
 508         originalText = "12345\nabcde\nABCDE"
 509         editor.setText(originalText)
 510
 511       describe "on the beginning of the second line", ->
 512         it "deletes the bottom two lines", ->
 513           editor.setCursorScreenPosition([1, 0])
 514           keydown('d')
 515           keydown('2')
 516           keydown('G', shift: true)
 517           expect(editor.getText()).toBe("12345\nABCDE")
 518
 519       describe "on the middle of the second line", ->
 520         it "deletes the bottom two lines", ->
 521           editor.setCursorScreenPosition([1, 2])
 522           keydown('d')
 523           keydown('2')
 524           keydown('G', shift: true)
 525           expect(editor.getText()).toBe("12345\nABCDE")
 526
 527     describe "when followed by a t)", ->
 528       describe "with the entire line yanked before", ->
 529         beforeEach ->
 530           editor.setText("test (xyz)")
 531           editor.setCursorScreenPosition([0, 6])
 532
 533         it "deletes until the closing parenthesis", ->
 534           keydown('y')
 535           keydown('y')
 536           keydown('d')
 537           keydown('t')
 538           normalModeInputKeydown(')')
 539           expect(editor.getText()).toBe("test ()")
 540           expect(editor.getCursorScreenPosition()).toEqual [0, 6]
 541
 542     describe "with multiple cursors", ->
 543       it "deletes each selection", ->
 544         editor.setText("abcd\n1234\nABCD\n")
 545         editor.setCursorBufferPosition([0, 1])
 546         editor.addCursorAtBufferPosition([1, 2])
 547         editor.addCursorAtBufferPosition([2, 3])
 548
 549         keydown('d')
 550         keydown('e')
 551
 552         expect(editor.getText()).toBe "a\n12\nABC"
 553         expect(editor.getCursorBufferPositions()).toEqual [
 554           [0, 0],
 555           [1, 1],
 556           [2, 2],
 557         ]
 558
 559       it "doesn't delete empty selections", ->
 560         editor.setText("abcd\nabc\nabd")
 561         editor.setCursorBufferPosition([0, 0])
 562         editor.addCursorAtBufferPosition([1, 0])
 563         editor.addCursorAtBufferPosition([2, 0])
 564
 565         keydown('d')
 566         keydown('t')
 567         normalModeInputKeydown('d')
 568
 569         expect(editor.getText()).toBe "d\nabc\nd"
 570         expect(editor.getCursorBufferPositions()).toEqual [
 571           [0, 0],
 572           [1, 0],
 573           [2, 0],
 574         ]
 575
 576   describe "the D keybinding", ->
 577     beforeEach ->
 578       editor.getBuffer().setText("012\n")
 579       editor.setCursorScreenPosition([0, 1])
 580       keydown('D', shift: true)
 581
 582     it "deletes the contents until the end of the line", ->
 583       expect(editor.getText()).toBe "0\n"
 584
 585   describe "the c keybinding", ->
 586     beforeEach ->
 587       editor.setText("12345\nabcde\nABCDE")
 588
 589     describe "when followed by a c", ->
 590       describe "with autoindent", ->
 591         beforeEach ->
 592           editor.setText("12345\n  abcde\nABCDE")
 593           editor.setCursorScreenPosition([1, 1])
 594           spyOn(editor, 'shouldAutoIndent').andReturn(true)
 595           spyOn(editor, 'autoIndentBufferRow').andCallFake (line) ->
 596             editor.indent()
 597           spyOn(editor.languageMode, 'suggestedIndentForLineAtBufferRow').andCallFake -> 1
 598
 599         it "deletes the current line and enters insert mode", ->
 600           editor.setCursorScreenPosition([1, 1])
 601
 602           keydown('c')
 603           keydown('c')
 604
 605           expect(editor.getText()).toBe "12345\n  \nABCDE"
 606           expect(editor.getCursorScreenPosition()).toEqual [1, 2]
 607           expect(editorElement.classList.contains('normal-mode')).toBe(false)
 608           expect(editorElement.classList.contains('insert-mode')).toBe(true)
 609
 610         it "is repeatable", ->
 611           keydown('c')
 612           keydown('c')
 613           editor.insertText("abc")
 614           keydown 'escape'
 615           expect(editor.getText()).toBe "12345\n  abc\nABCDE"
 616           editor.setCursorScreenPosition([2, 3])
 617           keydown '.'
 618           expect(editor.getText()).toBe "12345\n  abc\n  abc\n"
 619
 620         it "is undoable", ->
 621           keydown('c')
 622           keydown('c')
 623           editor.insertText("abc")
 624           keydown 'escape'
 625           expect(editor.getText()).toBe "12345\n  abc\nABCDE"
 626           keydown 'u'
 627           expect(editor.getText()).toBe "12345\n  abcde\nABCDE"
 628           expect(editor.getSelectedText()).toBe ''
 629
 630       describe "when the cursor is on the last line", ->
 631         it "deletes the line's content and enters insert mode on the last line", ->
 632           editor.setCursorScreenPosition([2, 1])
 633
 634           keydown('c')
 635           keydown('c')
 636
 637           expect(editor.getText()).toBe "12345\nabcde\n\n"
 638           expect(editor.getCursorScreenPosition()).toEqual [2, 0]
 639           expect(editorElement.classList.contains('normal-mode')).toBe(false)
 640           expect(editorElement.classList.contains('insert-mode')).toBe(true)
 641
 642       describe "when the cursor is on the only line", ->
 643         it "deletes the line's content and enters insert mode", ->
 644           editor.setText("12345")
 645           editor.setCursorScreenPosition([0, 2])
 646
 647           keydown('c')
 648           keydown('c')
 649
 650           expect(editor.getText()).toBe ""
 651           expect(editor.getCursorScreenPosition()).toEqual [0, 0]
 652           expect(editorElement.classList.contains('normal-mode')).toBe(false)
 653           expect(editorElement.classList.contains('insert-mode')).toBe(true)
 654
 655     describe "when followed by i w", ->
 656       it "undo's and redo's completely", ->
 657         editor.setCursorScreenPosition([1, 1])
 658
 659         keydown('c')
 660         keydown('i')
 661         keydown('w')
 662         expect(editor.getText()).toBe "12345\n\nABCDE"
 663         expect(editor.getCursorScreenPosition()).toEqual [1, 0]
 664         expect(editorElement.classList.contains('insert-mode')).toBe(true)
 665
 666         # Just cannot get "typing" to work correctly in test.
 667         editor.setText("12345\nfg\nABCDE")
 668         keydown('escape')
 669         expect(editorElement.classList.contains('normal-mode')).toBe(true)
 670         expect(editor.getText()).toBe "12345\nfg\nABCDE"
 671
 672         keydown('u')
 673         expect(editor.getText()).toBe "12345\nabcde\nABCDE"
 674         keydown('r', ctrl: true)
 675         expect(editor.getText()).toBe "12345\nfg\nABCDE"
 676
 677     describe "when followed by a w", ->
 678       it "changes the word", ->
 679         editor.setText("word1 word2 word3")
 680         editor.setCursorBufferPosition([0, "word1 w".length])
 681
 682         keydown("c")
 683         keydown("w")
 684         keydown("escape")
 685
 686         expect(editor.getText()).toBe "word1 w word3"
 687
 688     describe "when followed by a G", ->
 689       beforeEach ->
 690         originalText = "12345\nabcde\nABCDE"
 691         editor.setText(originalText)
 692
 693       describe "on the beginning of the second line", ->
 694         it "deletes the bottom two lines", ->
 695           editor.setCursorScreenPosition([1, 0])
 696           keydown('c')
 697           keydown('G', shift: true)
 698           keydown('escape')
 699           expect(editor.getText()).toBe("12345\n\n")
 700
 701       describe "on the middle of the second line", ->
 702         it "deletes the bottom two lines", ->
 703           editor.setCursorScreenPosition([1, 2])
 704           keydown('c')
 705           keydown('G', shift: true)
 706           keydown('escape')
 707           expect(editor.getText()).toBe("12345\n\n")
 708
 709     describe "when followed by a %", ->
 710       beforeEach ->
 711         editor.setText("12345(67)8\nabc(d)e\nA()BCDE")
 712
 713       describe "before brackets or on the first one", ->
 714         beforeEach ->
 715           editor.setCursorScreenPosition([0, 1])
 716           editor.addCursorAtScreenPosition([1, 1])
 717           editor.addCursorAtScreenPosition([2, 1])
 718           keydown('c')
 719           keydown('%')
 720           editor.insertText('x')
 721
 722         it "replaces inclusively until matching bracket", ->
 723           expect(editor.getText()).toBe("1x8\naxe\nAxBCDE")
 724           expect(vimState.mode).toBe "insert"
 725
 726         it "undoes correctly with u", ->
 727           keydown('escape')
 728           expect(vimState.mode).toBe "normal"
 729           keydown 'u'
 730           expect(editor.getText()).toBe("12345(67)8\nabc(d)e\nA()BCDE")
 731
 732       describe "inside brackets or on the ending one", ->
 733         it "replaces inclusively backwards until matching bracket", ->
 734           editor.setCursorScreenPosition([0, 6])
 735           editor.addCursorAtScreenPosition([1, 5])
 736           editor.addCursorAtScreenPosition([2, 2])
 737           keydown('c')
 738           keydown('%')
 739           editor.insertText('x')
 740           expect(editor.getText()).toBe("12345x7)8\nabcxe\nAxBCDE")
 741           expect(vimState.mode).toBe "insert"
 742
 743       describe "after or without brackets", ->
 744         it "deletes nothing", ->
 745           editor.setText("12345(67)8\nabc(d)e\nABCDE")
 746           editor.setCursorScreenPosition([0, 9])
 747           editor.addCursorAtScreenPosition([2, 2])
 748           keydown('c')
 749           keydown('%')
 750           expect(editor.getText()).toBe("12345(67)8\nabc(d)e\nABCDE")
 751           expect(vimState.mode).toBe "normal"
 752
 753       describe "repetition with .", ->
 754         beforeEach ->
 755           editor.setCursorScreenPosition([0, 1])
 756           keydown('c')
 757           keydown('%')
 758           editor.insertText('x')
 759           keydown('escape')
 760
 761         it "repeats correctly before a bracket", ->
 762           editor.setCursorScreenPosition([1, 0])
 763           keydown('.')
 764           expect(editor.getText()).toBe("1x8\nxe\nA()BCDE")
 765           expect(vimState.mode).toBe "normal"
 766
 767         it "repeats correctly on the opening bracket", ->
 768           editor.setCursorScreenPosition([1, 3])
 769           keydown('.')
 770           expect(editor.getText()).toBe("1x8\nabcxe\nA()BCDE")
 771           expect(vimState.mode).toBe "normal"
 772
 773         it "repeats correctly inside brackets", ->
 774           editor.setCursorScreenPosition([1, 4])
 775           keydown('.')
 776           expect(editor.getText()).toBe("1x8\nabcx)e\nA()BCDE")
 777           expect(vimState.mode).toBe "normal"
 778
 779         it "repeats correctly on the closing bracket", ->
 780           editor.setCursorScreenPosition([1, 5])
 781           keydown('.')
 782           expect(editor.getText()).toBe("1x8\nabcxe\nA()BCDE")
 783           expect(vimState.mode).toBe "normal"
 784
 785         it "does nothing when repeated after a bracket", ->
 786           editor.setCursorScreenPosition([2, 3])
 787           keydown('.')
 788           expect(editor.getText()).toBe("1x8\nabc(d)e\nA()BCDE")
 789           expect(vimState.mode).toBe "normal"
 790
 791     describe "when followed by a goto line G", ->
 792       beforeEach ->
 793         editor.setText "12345\nabcde\nABCDE"
 794
 795       describe "on the beginning of the second line", ->
 796         it "deletes all the text on the line", ->
 797           editor.setCursorScreenPosition([1, 0])
 798           keydown('c')
 799           keydown('2')
 800           keydown('G', shift: true)
 801           keydown('escape')
 802           expect(editor.getText()).toBe("12345\n\nABCDE")
 803
 804       describe "on the middle of the second line", ->
 805         it "deletes all the text on the line", ->
 806           editor.setCursorScreenPosition([1, 2])
 807           keydown('c')
 808           keydown('2')
 809           keydown('G', shift: true)
 810           keydown('escape')
 811           expect(editor.getText()).toBe("12345\n\nABCDE")
 812
 813     describe "in visual mode", ->
 814       beforeEach ->
 815         editor.setText "123456789\nabcde\nfghijklmnopq\nuvwxyz"
 816         editor.setCursorScreenPosition [1, 1]
 817
 818       describe "with characterwise selection on a single line", ->
 819         it "repeats with .", ->
 820           keydown 'v'
 821           keydown '2'
 822           keydown 'l'
 823           keydown 'c'
 824           editor.insertText "ab"
 825           keydown 'escape'
 826           expect(editor.getText()).toBe "123456789\naabe\nfghijklmnopq\nuvwxyz"
 827
 828           editor.setCursorScreenPosition [0, 1]
 829           keydown '.'
 830           expect(editor.getText()).toBe "1ab56789\naabe\nfghijklmnopq\nuvwxyz"
 831
 832         it "repeats shortened with . near the end of the line", ->
 833           editor.setCursorScreenPosition [0, 2]
 834           keydown 'v'
 835           keydown '4'
 836           keydown 'l'
 837           keydown 'c'
 838           editor.insertText "ab"
 839           keydown 'escape'
 840           expect(editor.getText()).toBe "12ab89\nabcde\nfghijklmnopq\nuvwxyz"
 841
 842           editor.setCursorScreenPosition [1, 3]
 843           keydown '.'
 844           expect(editor.getText()).toBe "12ab89\nabcab\nfghijklmnopq\nuvwxyz"
 845
 846         it "repeats shortened with . near the end of the line regardless of whether motion wrapping is enabled", ->
 847           atom.config.set('vim-mode.wrapLeftRightMotion', true)
 848           editor.setCursorScreenPosition [0, 2]
 849           keydown 'v'
 850           keydown '4'
 851           keydown 'l'
 852           keydown 'c'
 853           editor.insertText "ab"
 854           keydown 'escape'
 855           expect(editor.getText()).toBe "12ab89\nabcde\nfghijklmnopq\nuvwxyz"
 856
 857           editor.setCursorScreenPosition [1, 3]
 858           keydown '.'
 859           # this differs from VIM, which would eat the \n before fghij...
 860           expect(editor.getText()).toBe "12ab89\nabcab\nfghijklmnopq\nuvwxyz"
 861
 862       describe "is repeatable with characterwise selection over multiple lines", ->
 863         it "repeats with .", ->
 864           keydown 'v'
 865           keydown 'j'
 866           keydown '3'
 867           keydown 'l'
 868           keydown 'c'
 869           editor.insertText "x"
 870           keydown 'escape'
 871           expect(editor.getText()).toBe "123456789\naxklmnopq\nuvwxyz"
 872
 873           editor.setCursorScreenPosition [0, 1]
 874           keydown '.'
 875           expect(editor.getText()).toBe "1xnopq\nuvwxyz"
 876
 877         it "repeats shortened with . near the end of the line", ->
 878           # this behaviour is unlike VIM, see #737
 879           keydown 'v'
 880           keydown 'j'
 881           keydown '6'
 882           keydown 'l'
 883           keydown 'c'
 884           editor.insertText "x"
 885           keydown 'escape'
 886           expect(editor.getText()).toBe "123456789\naxnopq\nuvwxyz"
 887
 888           editor.setCursorScreenPosition [0, 1]
 889           keydown '.'
 890           expect(editor.getText()).toBe "1x\nuvwxyz"
 891
 892       describe "is repeatable with linewise selection", ->
 893         describe "with one line selected", ->
 894           it "repeats with .", ->
 895             keydown 'V', shift: true
 896             keydown 'c'
 897             editor.insertText "x"
 898             keydown 'escape'
 899             expect(editor.getText()).toBe "123456789\nx\nfghijklmnopq\nuvwxyz"
 900
 901             editor.setCursorScreenPosition [0, 7]
 902             keydown '.'
 903             expect(editor.getText()).toBe "x\nx\nfghijklmnopq\nuvwxyz"
 904
 905             editor.setCursorScreenPosition [2, 0]
 906             keydown '.'
 907             expect(editor.getText()).toBe "x\nx\nx\nuvwxyz"
 908
 909         describe "with multiple lines selected", ->
 910           it "repeats with .", ->
 911             keydown 'V', shift: true
 912             keydown 'j'
 913             keydown 'c'
 914             editor.insertText "x"
 915             keydown 'escape'
 916             expect(editor.getText()).toBe "123456789\nx\nuvwxyz"
 917
 918             editor.setCursorScreenPosition [0, 7]
 919             keydown '.'
 920             expect(editor.getText()).toBe "x\nuvwxyz"
 921
 922           it "repeats shortened with . near the end of the file", ->
 923             keydown 'V', shift: true
 924             keydown 'j'
 925             keydown 'c'
 926             editor.insertText "x"
 927             keydown 'escape'
 928             expect(editor.getText()).toBe "123456789\nx\nuvwxyz"
 929
 930             editor.setCursorScreenPosition [1, 7]
 931             keydown '.'
 932             expect(editor.getText()).toBe "123456789\nx\n"
 933
 934       xdescribe "is repeatable with block selection", ->
 935         # there is no block selection yet
 936
 937   describe "the C keybinding", ->
 938     beforeEach ->
 939       editor.getBuffer().setText("012\n")
 940       editor.setCursorScreenPosition([0, 1])
 941       keydown('C', shift: true)
 942
 943     it "deletes the contents until the end of the line and enters insert mode", ->
 944       expect(editor.getText()).toBe "0\n"
 945       expect(editor.getCursorScreenPosition()).toEqual [0, 1]
 946       expect(editorElement.classList.contains('normal-mode')).toBe(false)
 947       expect(editorElement.classList.contains('insert-mode')).toBe(true)
 948
 949   describe "the y keybinding", ->
 950     beforeEach ->
 951       editor.getBuffer().setText("012 345\nabc\ndefg\n")
 952       editor.setCursorScreenPosition([0, 4])
 953       vimState.setRegister('"', text: '345')
 954
 955     describe "when selected lines in visual linewise mode", ->
 956       beforeEach ->
 957         keydown('V', shift: true)
 958         keydown('j')
 959         keydown('y')
 960
 961       it "is in linewise motion", ->
 962         expect(vimState.getRegister('"').type).toEqual "linewise"
 963
 964       it "saves the lines to the default register", ->
 965         expect(vimState.getRegister('"').text).toBe "012 345\nabc\n"
 966
 967       it "places the cursor at the beginning of the selection", ->
 968         expect(editor.getCursorBufferPositions()).toEqual([[0, 0]])
 969
 970     describe "when followed by a second y ", ->
 971       beforeEach ->
 972         keydown('y')
 973         keydown('y')
 974
 975       it "saves the line to the default register", ->
 976         expect(vimState.getRegister('"').text).toBe "012 345\n"
 977
 978       it "leaves the cursor at the starting position", ->
 979         expect(editor.getCursorScreenPosition()).toEqual [0, 4]
 980
 981     describe "when useClipboardAsDefaultRegister enabled", ->
 982       it "writes to clipboard", ->
 983         atom.config.set 'vim-mode.useClipboardAsDefaultRegister', true
 984         keydown('y')
 985         keydown('y')
 986         expect(atom.clipboard.read()).toBe '012 345\n'
 987
 988     describe "when followed with a repeated y", ->
 989       beforeEach ->
 990         keydown('y')
 991         keydown('2')
 992         keydown('y')
 993
 994       it "copies n lines, starting from the current", ->
 995         expect(vimState.getRegister('"').text).toBe "012 345\nabc\n"
 996
 997       it "leaves the cursor at the starting position", ->
 998         expect(editor.getCursorScreenPosition()).toEqual [0, 4]
 999
1000     describe "with a register", ->
1001       beforeEach ->
1002         keydown('"')
1003         keydown('a')
1004         keydown('y')
1005         keydown('y')
1006
1007       it "saves the line to the a register", ->
1008         expect(vimState.getRegister('a').text).toBe "012 345\n"
1009
1010       it "appends the line to the A register", ->
1011         keydown('"')
1012         keydown('A', shift: true)
1013         keydown('y')
1014         keydown('y')
1015         expect(vimState.getRegister('a').text).toBe "012 345\n012 345\n"
1016
1017     describe "with a forward motion", ->
1018       beforeEach ->
1019         keydown('y')
1020         keydown('e')
1021
1022       it "saves the selected text to the default register", ->
1023         expect(vimState.getRegister('"').text).toBe '345'
1024
1025       it "leaves the cursor at the starting position", ->
1026         expect(editor.getCursorScreenPosition()).toEqual [0, 4]
1027
1028       it "does not yank when motion fails", ->
1029         keydown('y')
1030         keydown('t')
1031         normalModeInputKeydown('x')
1032         expect(vimState.getRegister('"').text).toBe '345'
1033
1034     describe "with a text object", ->
1035       it "moves the cursor to the beginning of the text object", ->
1036         editor.setCursorBufferPosition([0, 5])
1037         keydown("y")
1038         keydown("i")
1039         keydown("w")
1040         expect(editor.getCursorBufferPositions()).toEqual([[0, 4]])
1041
1042     describe "with a left motion", ->
1043       beforeEach ->
1044         keydown('y')
1045         keydown('h')
1046
1047       it "saves the left letter to the default register", ->
1048         expect(vimState.getRegister('"').text).toBe " "
1049
1050       it "moves the cursor position to the left", ->
1051         expect(editor.getCursorScreenPosition()).toEqual [0, 3]
1052
1053     describe "with a down motion", ->
1054       beforeEach ->
1055         keydown 'y'
1056         keydown 'j'
1057
1058       it "saves both full lines to the default register", ->
1059         expect(vimState.getRegister('"').text).toBe "012 345\nabc\n"
1060
1061       it "leaves the cursor at the starting position", ->
1062         expect(editor.getCursorScreenPosition()).toEqual [0, 4]
1063
1064     describe "with an up motion", ->
1065       beforeEach ->
1066         editor.setCursorScreenPosition([2, 2])
1067         keydown 'y'
1068         keydown 'k'
1069
1070       it "saves both full lines to the default register", ->
1071         expect(vimState.getRegister('"').text).toBe "abc\ndefg\n"
1072
1073       it "puts the cursor on the first line and the original column", ->
1074         expect(editor.getCursorScreenPosition()).toEqual [1, 2]
1075
1076     describe "when followed by a G", ->
1077       beforeEach ->
1078         originalText = "12345\nabcde\nABCDE"
1079         editor.setText(originalText)
1080
1081       describe "on the beginning of the second line", ->
1082         it "deletes the bottom two lines", ->
1083           editor.setCursorScreenPosition([1, 0])
1084           keydown('y')
1085           keydown('G', shift: true)
1086           keydown('P', shift: true)
1087           expect(editor.getText()).toBe("12345\nabcde\nABCDE\nabcde\nABCDE")
1088
1089       describe "on the middle of the second line", ->
1090         it "deletes the bottom two lines", ->
1091           editor.setCursorScreenPosition([1, 2])
1092           keydown('y')
1093           keydown('G', shift: true)
1094           keydown('P', shift: true)
1095           expect(editor.getText()).toBe("12345\nabcde\nABCDE\nabcde\nABCDE")
1096
1097     describe "when followed by a goto line G", ->
1098       beforeEach ->
1099         originalText = "12345\nabcde\nABCDE"
1100         editor.setText(originalText)
1101
1102       describe "on the beginning of the second line", ->
1103         it "deletes the bottom two lines", ->
1104           editor.setCursorScreenPosition([1, 0])
1105           keydown('y')
1106           keydown('2')
1107           keydown('G', shift: true)
1108           keydown('P', shift: true)
1109           expect(editor.getText()).toBe("12345\nabcde\nabcde\nABCDE")
1110
1111       describe "on the middle of the second line", ->
1112         it "deletes the bottom two lines", ->
1113           editor.setCursorScreenPosition([1, 2])
1114           keydown('y')
1115           keydown('2')
1116           keydown('G', shift: true)
1117           keydown('P', shift: true)
1118           expect(editor.getText()).toBe("12345\nabcde\nabcde\nABCDE")
1119
1120     describe "with multiple cursors", ->
1121       it "moves each cursor and copies the last selection's text", ->
1122         editor.setText "  abcd\n  1234"
1123         editor.setCursorBufferPosition([0, 0])
1124         editor.addCursorAtBufferPosition([1, 5])
1125
1126         keydown("y")
1127         keydown("^")
1128
1129         expect(vimState.getRegister('"').text).toBe '123'
1130         expect(editor.getCursorBufferPositions()).toEqual [[0, 0], [1, 2]]
1131
1132     describe "in a long file", ->
1133       beforeEach ->
1134         editor.setHeight(400)
1135         editor.setLineHeightInPixels(10)
1136         editor.setDefaultCharWidth(10)
1137         text = ""
1138         for i in [1..200]
1139           text += "#{i}\n"
1140         editor.setText(text)
1141
1142       describe "yanking many lines forward", ->
1143         it "does not scroll the window", ->
1144           editor.setCursorBufferPosition [40, 1]
1145           previousScrollTop = editor.getScrollTop()
1146
1147           # yank many lines
1148           keydown('y')
1149           keydown('1')
1150           keydown('6')
1151           keydown('0')
1152           keydown('G', shift: true)
1153
1154           expect(editor.getScrollTop()).toEqual(previousScrollTop)
1155           expect(editor.getCursorBufferPosition()).toEqual [40, 1]
1156           expect(vimState.getRegister('"').text.split('\n').length).toBe 121
1157
1158       describe "yanking many lines backwards", ->
1159         it "scrolls the window", ->
1160           editor.setCursorBufferPosition [140, 1]
1161           previousScrollTop = editor.getScrollTop()
1162
1163           # yank many lines
1164           keydown('y')
1165           keydown('6')
1166           keydown('0')
1167           keydown('G', shift: true)
1168
1169           expect(editor.getScrollTop()).toNotEqual previousScrollTop
1170           expect(editor.getCursorBufferPosition()).toEqual [59, 1]
1171           expect(vimState.getRegister('"').text.split('\n').length).toBe 83
1172
1173   describe "the yy keybinding", ->
1174     describe "on a single line file", ->
1175       beforeEach ->
1176         editor.getBuffer().setText "exclamation!\n"
1177         editor.setCursorScreenPosition [0, 0]
1178
1179       it "copies the entire line and pastes it correctly", ->
1180         keydown('y')
1181         keydown('y')
1182         keydown('p')
1183
1184         expect(vimState.getRegister('"').text).toBe "exclamation!\n"
1185         expect(editor.getText()).toBe "exclamation!\nexclamation!\n"
1186
1187     describe "on a single line file with no newline", ->
1188       beforeEach ->
1189         editor.getBuffer().setText "no newline!"
1190         editor.setCursorScreenPosition [0, 0]
1191
1192       it "copies the entire line and pastes it correctly", ->
1193         keydown('y')
1194         keydown('y')
1195         keydown('p')
1196
1197         expect(vimState.getRegister('"').text).toBe "no newline!\n"
1198         expect(editor.getText()).toBe "no newline!\nno newline!"
1199
1200       it "copies the entire line and pastes it respecting count and new lines", ->
1201         keydown('y')
1202         keydown('y')
1203         keydown('2')
1204         keydown('p')
1205
1206         expect(vimState.getRegister('"').text).toBe "no newline!\n"
1207         expect(editor.getText()).toBe "no newline!\nno newline!\nno newline!"
1208
1209   describe "the Y keybinding", ->
1210     beforeEach ->
1211       editor.getBuffer().setText "012 345\nabc\n"
1212       editor.setCursorScreenPosition [0, 4]
1213
1214     it "saves the line to the default register", ->
1215       keydown('Y', shift: true)
1216
1217       expect(vimState.getRegister('"').text).toBe "012 345\n"
1218       expect(editor.getCursorScreenPosition()).toEqual [0, 4]
1219
1220   describe "the p keybinding", ->
1221     describe "with character contents", ->
1222       beforeEach ->
1223         editor.getBuffer().setText "012\n"
1224         editor.setCursorScreenPosition [0, 0]
1225         vimState.setRegister('"', text: '345')
1226         vimState.setRegister('a', text: 'a')
1227         atom.clipboard.write "clip"
1228
1229       describe "from the default register", ->
1230         beforeEach -> keydown('p')
1231
1232         it "inserts the contents", ->
1233           expect(editor.getText()).toBe "034512\n"
1234           expect(editor.getCursorScreenPosition()).toEqual [0, 3]
1235
1236       describe "at the end of a line", ->
1237         beforeEach ->
1238           editor.setCursorScreenPosition [0, 2]
1239           keydown('p')
1240
1241         it "positions cursor correctly", ->
1242           expect(editor.getText()).toBe "012345\n"
1243           expect(editor.getCursorScreenPosition()).toEqual [0, 5]
1244
1245       describe "when useClipboardAsDefaultRegister enabled", ->
1246         it "inserts contents from clipboard", ->
1247           atom.config.set 'vim-mode.useClipboardAsDefaultRegister', true
1248           keydown('p')
1249           expect(editor.getText()).toBe "0clip12\n"
1250
1251       describe "from a specified register", ->
1252         beforeEach ->
1253           keydown('"')
1254           keydown('a')
1255           keydown('p')
1256
1257         it "inserts the contents of the 'a' register", ->
1258           expect(editor.getText()).toBe "0a12\n"
1259           expect(editor.getCursorScreenPosition()).toEqual [0, 1]
1260
1261       describe "at the end of a line", ->
1262         it "inserts before the current line's newline", ->
1263           editor.setText("abcde\none two three")
1264           editor.setCursorScreenPosition([1, 4])
1265
1266           keydown 'd'
1267           keydown '$'
1268           keydown 'k'
1269           keydown '$'
1270           keydown 'p'
1271
1272           expect(editor.getText()).toBe "abcdetwo three\none "
1273
1274       describe "with a selection", ->
1275         beforeEach ->
1276           editor.selectRight()
1277           keydown('p')
1278
1279         it "replaces the current selection", ->
1280           expect(editor.getText()).toBe "34512\n"
1281           expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1282
1283     describe "with linewise contents", ->
1284       describe "on a single line", ->
1285         beforeEach ->
1286           editor.getBuffer().setText("012")
1287           editor.setCursorScreenPosition([0, 1])
1288           vimState.setRegister('"', text: " 345\n", type: 'linewise')
1289
1290         it "inserts the contents of the default register", ->
1291           keydown('p')
1292
1293           expect(editor.getText()).toBe "012\n 345"
1294           expect(editor.getCursorScreenPosition()).toEqual [1, 1]
1295
1296         it "replaces the current selection", ->
1297           editor.selectRight()
1298           keydown('p')
1299
1300           expect(editor.getText()).toBe "0 345\n2"
1301           expect(editor.getCursorScreenPosition()).toEqual [1, 0]
1302
1303       describe "on multiple lines", ->
1304         beforeEach ->
1305           editor.getBuffer().setText("012\n 345")
1306           vimState.setRegister('"', text: " 456\n", type: 'linewise')
1307
1308         it "inserts the contents of the default register at middle line", ->
1309           editor.setCursorScreenPosition([0, 1])
1310           keydown('p')
1311
1312           expect(editor.getText()).toBe "012\n 456\n 345"
1313           expect(editor.getCursorScreenPosition()).toEqual [1, 1]
1314
1315         it "inserts the contents of the default register at end of line", ->
1316           editor.setCursorScreenPosition([1, 1])
1317           keydown('p')
1318
1319           expect(editor.getText()).toBe "012\n 345\n 456"
1320           expect(editor.getCursorScreenPosition()).toEqual [2, 1]
1321
1322     describe "with multiple linewise contents", ->
1323       beforeEach ->
1324         editor.getBuffer().setText("012\nabc")
1325         editor.setCursorScreenPosition([1, 0])
1326         vimState.setRegister('"', text: " 345\n 678\n", type: 'linewise')
1327         keydown('p')
1328
1329       it "inserts the contents of the default register", ->
1330         expect(editor.getText()).toBe "012\nabc\n 345\n 678"
1331         expect(editor.getCursorScreenPosition()).toEqual [2, 1]
1332
1333     describe "pasting twice", ->
1334       beforeEach ->
1335         editor.setText("12345\nabcde\nABCDE\nQWERT")
1336         editor.setCursorScreenPosition([1, 1])
1337         vimState.setRegister('"', text: '123')
1338         keydown('2')
1339         keydown('p')
1340
1341       it "inserts the same line twice", ->
1342         expect(editor.getText()).toBe "12345\nab123123cde\nABCDE\nQWERT"
1343
1344       describe "when undone", ->
1345         beforeEach ->
1346           keydown('u')
1347
1348         it "removes both lines", ->
1349           expect(editor.getText()).toBe "12345\nabcde\nABCDE\nQWERT"
1350
1351   describe "the P keybinding", ->
1352     describe "with character contents", ->
1353       beforeEach ->
1354         editor.getBuffer().setText("012\n")
1355         editor.setCursorScreenPosition([0, 0])
1356         vimState.setRegister('"', text: '345')
1357         vimState.setRegister('a', text: 'a')
1358         keydown('P', shift: true)
1359
1360       it "inserts the contents of the default register above", ->
1361         expect(editor.getText()).toBe "345012\n"
1362         expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1363
1364   describe "the O keybinding", ->
1365     beforeEach ->
1366       spyOn(editor, 'shouldAutoIndent').andReturn(true)
1367       spyOn(editor, 'autoIndentBufferRow').andCallFake (line) ->
1368         editor.indent()
1369
1370       editor.getBuffer().setText("  abc\n  012\n")
1371       editor.setCursorScreenPosition([1, 1])
1372
1373     it "switches to insert and adds a newline above the current one", ->
1374       keydown('O', shift: true)
1375       expect(editor.getText()).toBe "  abc\n  \n  012\n"
1376       expect(editor.getCursorScreenPosition()).toEqual [1, 2]
1377       expect(editorElement.classList.contains('insert-mode')).toBe(true)
1378
1379     it "is repeatable", ->
1380       editor.getBuffer().setText("  abc\n  012\n    4spaces\n")
1381       editor.setCursorScreenPosition([1, 1])
1382       keydown('O', shift: true)
1383       editor.insertText "def"
1384       keydown 'escape'
1385       expect(editor.getText()).toBe "  abc\n  def\n  012\n    4spaces\n"
1386       editor.setCursorScreenPosition([1, 1])
1387       keydown '.'
1388       expect(editor.getText()).toBe "  abc\n  def\n  def\n  012\n    4spaces\n"
1389       editor.setCursorScreenPosition([4, 1])
1390       keydown '.'
1391       expect(editor.getText()).toBe "  abc\n  def\n  def\n  012\n    def\n    4spaces\n"
1392
1393     it "is undoable", ->
1394       keydown('O', shift: true)
1395       editor.insertText "def"
1396       keydown 'escape'
1397       expect(editor.getText()).toBe "  abc\n  def\n  012\n"
1398       keydown 'u'
1399       expect(editor.getText()).toBe "  abc\n  012\n"
1400
1401   describe "the o keybinding", ->
1402     beforeEach ->
1403       spyOn(editor, 'shouldAutoIndent').andReturn(true)
1404       spyOn(editor, 'autoIndentBufferRow').andCallFake (line) ->
1405         editor.indent()
1406
1407       editor.getBuffer().setText("abc\n  012\n")
1408       editor.setCursorScreenPosition([1, 2])
1409
1410     it "switches to insert and adds a newline above the current one", ->
1411       keydown('o')
1412       expect(editor.getText()).toBe "abc\n  012\n  \n"
1413       expect(editorElement.classList.contains('insert-mode')).toBe(true)
1414       expect(editor.getCursorScreenPosition()).toEqual [2, 2]
1415
1416     # This works in practice, but the editor doesn't respect the indentation
1417     # rules without a syntax grammar. Need to set the editor's grammar
1418     # to fix it.
1419     xit "is repeatable", ->
1420       editor.getBuffer().setText("  abc\n  012\n    4spaces\n")
1421       editor.setCursorScreenPosition([1, 1])
1422       keydown('o')
1423       editor.insertText "def"
1424       keydown 'escape'
1425       expect(editor.getText()).toBe "  abc\n  012\n  def\n    4spaces\n"
1426       keydown '.'
1427       expect(editor.getText()).toBe "  abc\n  012\n  def\n  def\n    4spaces\n"
1428       editor.setCursorScreenPosition([4, 1])
1429       keydown '.'
1430       expect(editor.getText()).toBe "  abc\n  def\n  def\n  012\n    4spaces\n    def\n"
1431
1432     it "is undoable", ->
1433       keydown('o')
1434       editor.insertText "def"
1435       keydown 'escape'
1436       expect(editor.getText()).toBe "abc\n  012\n  def\n"
1437       keydown 'u'
1438       expect(editor.getText()).toBe "abc\n  012\n"
1439
1440   describe "the a keybinding", ->
1441     beforeEach ->
1442       editor.getBuffer().setText("012\n")
1443
1444     describe "at the beginning of the line", ->
1445       beforeEach ->
1446         editor.setCursorScreenPosition([0, 0])
1447         keydown('a')
1448
1449       it "switches to insert mode and shifts to the right", ->
1450         expect(editor.getCursorScreenPosition()).toEqual [0, 1]
1451         expect(editorElement.classList.contains('insert-mode')).toBe(true)
1452
1453     describe "at the end of the line", ->
1454       beforeEach ->
1455         editor.setCursorScreenPosition([0, 3])
1456         keydown('a')
1457
1458       it "doesn't linewrap", ->
1459         expect(editor.getCursorScreenPosition()).toEqual [0, 3]
1460
1461   describe "the A keybinding", ->
1462     beforeEach ->
1463       editor.getBuffer().setText("11\n22\n")
1464
1465     describe "at the beginning of a line", ->
1466       it "switches to insert mode at the end of the line", ->
1467         editor.setCursorScreenPosition([0, 0])
1468         keydown('A', shift: true)
1469
1470         expect(editorElement.classList.contains('insert-mode')).toBe(true)
1471         expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1472
1473       it "repeats always as insert at the end of the line", ->
1474         editor.setCursorScreenPosition([0, 0])
1475         keydown('A', shift: true)
1476         editor.insertText("abc")
1477         keydown 'escape'
1478         editor.setCursorScreenPosition([1, 0])
1479         keydown '.'
1480
1481         expect(editor.getText()).toBe "11abc\n22abc\n"
1482         expect(editorElement.classList.contains('insert-mode')).toBe(false)
1483         expect(editor.getCursorScreenPosition()).toEqual [1, 4]
1484
1485   describe "the I keybinding", ->
1486     beforeEach ->
1487       editor.getBuffer().setText("11\n  22\n")
1488
1489     describe "at the end of a line", ->
1490       it "switches to insert mode at the beginning of the line", ->
1491         editor.setCursorScreenPosition([0, 2])
1492         keydown('I', shift: true)
1493
1494         expect(editorElement.classList.contains('insert-mode')).toBe(true)
1495         expect(editor.getCursorScreenPosition()).toEqual [0, 0]
1496
1497       it "switches to insert mode after leading whitespace", ->
1498         editor.setCursorScreenPosition([1, 4])
1499         keydown('I', shift: true)
1500
1501         expect(editorElement.classList.contains('insert-mode')).toBe(true)
1502         expect(editor.getCursorScreenPosition()).toEqual [1, 2]
1503
1504       it "repeats always as insert at the first character of the line", ->
1505         editor.setCursorScreenPosition([0, 2])
1506         keydown('I', shift: true)
1507         editor.insertText("abc")
1508         keydown 'escape'
1509         expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1510         editor.setCursorScreenPosition([1, 4])
1511         keydown '.'
1512
1513         expect(editor.getText()).toBe "abc11\n  abc22\n"
1514         expect(editorElement.classList.contains('insert-mode')).toBe(false)
1515         expect(editor.getCursorScreenPosition()).toEqual [1, 4]
1516
1517   describe "the J keybinding", ->
1518     beforeEach ->
1519       editor.getBuffer().setText("012\n    456\n")
1520       editor.setCursorScreenPosition([0, 1])
1521
1522     describe "without repeating", ->
1523       beforeEach -> keydown('J', shift: true)
1524
1525       it "joins the contents of the current line with the one below it", ->
1526         expect(editor.getText()).toBe "012 456\n"
1527
1528     describe "with repeating", ->
1529       beforeEach ->
1530         editor.setText("12345\nabcde\nABCDE\nQWERT")
1531         editor.setCursorScreenPosition([1, 1])
1532         keydown('2')
1533         keydown('J', shift: true)
1534
1535       describe "undo behavior", ->
1536         beforeEach -> keydown('u')
1537
1538         it "handles repeats", ->
1539           expect(editor.getText()).toBe "12345\nabcde\nABCDE\nQWERT"
1540
1541   describe "the > keybinding", ->
1542     beforeEach ->
1543       editor.setText("12345\nabcde\nABCDE")
1544
1545     describe "on the last line", ->
1546       beforeEach ->
1547         editor.setCursorScreenPosition([2, 0])
1548
1549       describe "when followed by a >", ->
1550         beforeEach ->
1551           keydown('>')
1552           keydown('>')
1553
1554         it "indents the current line", ->
1555           expect(editor.getText()).toBe "12345\nabcde\n  ABCDE"
1556           expect(editor.getCursorScreenPosition()).toEqual [2, 2]
1557
1558     describe "on the first line", ->
1559       beforeEach ->
1560         editor.setCursorScreenPosition([0, 0])
1561
1562       describe "when followed by a >", ->
1563         beforeEach ->
1564           keydown('>')
1565           keydown('>')
1566
1567         it "indents the current line", ->
1568           expect(editor.getText()).toBe "  12345\nabcde\nABCDE"
1569           expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1570
1571       describe "when followed by a repeating >", ->
1572         beforeEach ->
1573           keydown('3')
1574           keydown('>')
1575           keydown('>')
1576
1577         it "indents multiple lines at once", ->
1578           expect(editor.getText()).toBe "  12345\n  abcde\n  ABCDE"
1579           expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1580
1581         describe "undo behavior", ->
1582           beforeEach -> keydown('u')
1583
1584           it "outdents all three lines", ->
1585             expect(editor.getText()).toBe "12345\nabcde\nABCDE"
1586
1587     describe "in visual mode linewise", ->
1588       beforeEach ->
1589         editor.setCursorScreenPosition([0, 0])
1590         keydown('v', shift: true)
1591         keydown('j')
1592
1593       describe "single indent multiple lines", ->
1594         beforeEach ->
1595           keydown('>')
1596
1597         it "indents both lines once and exits visual mode", ->
1598           expect(editorElement.classList.contains('normal-mode')).toBe(true)
1599           expect(editor.getText()).toBe "  12345\n  abcde\nABCDE"
1600           expect(editor.getSelectedBufferRanges()).toEqual [ [[0, 2], [0, 2]] ]
1601
1602         it "allows repeating the operation", ->
1603           keydown('.')
1604           expect(editor.getText()).toBe "    12345\n    abcde\nABCDE"
1605
1606       describe "multiple indent multiple lines", ->
1607         beforeEach ->
1608           keydown('2')
1609           keydown('>')
1610
1611         it "indents both lines twice and exits visual mode", ->
1612           expect(editorElement.classList.contains('normal-mode')).toBe(true)
1613           expect(editor.getText()).toBe "    12345\n    abcde\nABCDE"
1614           expect(editor.getSelectedBufferRanges()).toEqual [ [[0, 4], [0, 4]] ]
1615
1616     describe "with multiple selections", ->
1617       beforeEach ->
1618         editor.setCursorScreenPosition([1, 3])
1619         keydown('v')
1620         keydown('j')
1621         editor.addCursorAtScreenPosition([0, 0])
1622
1623       it "indents the lines and keeps the cursors", ->
1624         keydown('>')
1625         expect(editor.getText()).toBe "  12345\n  abcde\n  ABCDE"
1626         expect(editor.getCursorScreenPositions()).toEqual [[1, 2], [0, 2]]
1627
1628   describe "the < keybinding", ->
1629     beforeEach ->
1630       editor.setText("    12345\n    abcde\nABCDE")
1631       editor.setCursorScreenPosition([0, 0])
1632
1633     describe "when followed by a <", ->
1634       beforeEach ->
1635         keydown('<')
1636         keydown('<')
1637
1638       it "outdents the current line", ->
1639         expect(editor.getText()).toBe "  12345\n    abcde\nABCDE"
1640         expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1641
1642     describe "when followed by a repeating <", ->
1643       beforeEach ->
1644         keydown('2')
1645         keydown('<')
1646         keydown('<')
1647
1648       it "outdents multiple lines at once", ->
1649         expect(editor.getText()).toBe "  12345\n  abcde\nABCDE"
1650         expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1651
1652       describe "undo behavior", ->
1653         beforeEach -> keydown('u')
1654
1655         it "indents both lines", ->
1656           expect(editor.getText()).toBe "    12345\n    abcde\nABCDE"
1657
1658     describe "in visual mode linewise", ->
1659       beforeEach ->
1660         keydown('v', shift: true)
1661         keydown('j')
1662
1663       describe "single outdent multiple lines", ->
1664         beforeEach ->
1665           keydown('<')
1666
1667         it "outdents the current line and exits visual mode", ->
1668           expect(editorElement.classList.contains('normal-mode')).toBe(true)
1669           expect(editor.getText()).toBe "  12345\n  abcde\nABCDE"
1670           expect(editor.getSelectedBufferRanges()).toEqual [ [[0, 2], [0, 2]] ]
1671
1672         it "allows repeating the operation", ->
1673           keydown('.')
1674           expect(editor.getText()).toBe "12345\nabcde\nABCDE"
1675
1676       describe "multiple outdent multiple lines", ->
1677         beforeEach ->
1678           keydown('2')
1679           keydown('<')
1680
1681         it "outdents both lines twice and exits visual mode", ->
1682           expect(editorElement.classList.contains('normal-mode')).toBe(true)
1683           expect(editor.getText()).toBe "12345\nabcde\nABCDE"
1684           expect(editor.getSelectedBufferRanges()).toEqual [ [[0, 0], [0, 0]] ]
1685
1686   describe "the = keybinding", ->
1687     oldGrammar = []
1688
1689     beforeEach ->
1690       waitsForPromise ->
1691         atom.packages.activatePackage('language-javascript')
1692
1693       oldGrammar = editor.getGrammar()
1694       editor.setText("foo\n  bar\n  baz")
1695       editor.setCursorScreenPosition([1, 0])
1696
1697     describe "when used in a scope that supports auto-indent", ->
1698       beforeEach ->
1699         jsGrammar = atom.grammars.grammarForScopeName('source.js')
1700         editor.setGrammar(jsGrammar)
1701
1702       afterEach ->
1703         editor.setGrammar(oldGrammar)
1704
1705       describe "when followed by a =", ->
1706         beforeEach ->
1707           keydown('=')
1708           keydown('=')
1709
1710         it "indents the current line", ->
1711           expect(editor.indentationForBufferRow(1)).toBe 0
1712
1713       describe "when followed by a G", ->
1714         beforeEach ->
1715           editor.setCursorScreenPosition([0, 0])
1716           keydown('=')
1717           keydown('G', shift: true)
1718
1719         it "uses the default count", ->
1720           expect(editor.indentationForBufferRow(1)).toBe 0
1721           expect(editor.indentationForBufferRow(2)).toBe 0
1722
1723       describe "when followed by a repeating =", ->
1724         beforeEach ->
1725           keydown('2')
1726           keydown('=')
1727           keydown('=')
1728
1729         it "autoindents multiple lines at once", ->
1730           expect(editor.getText()).toBe "foo\nbar\nbaz"
1731           expect(editor.getCursorScreenPosition()).toEqual [1, 0]
1732
1733         describe "undo behavior", ->
1734           beforeEach -> keydown('u')
1735
1736           it "indents both lines", ->
1737             expect(editor.getText()).toBe "foo\n  bar\n  baz"
1738
1739   describe "the . keybinding", ->
1740     beforeEach ->
1741       editor.setText("12\n34\n56\n78")
1742       editor.setCursorScreenPosition([0, 0])
1743
1744     it "repeats the last operation", ->
1745       keydown '2'
1746       keydown 'd'
1747       keydown 'd'
1748       keydown '.'
1749
1750       expect(editor.getText()).toBe ""
1751
1752     it "composes with motions", ->
1753       keydown 'd'
1754       keydown 'd'
1755       keydown '2'
1756       keydown '.'
1757
1758       expect(editor.getText()).toBe "78"
1759
1760   describe "the r keybinding", ->
1761     beforeEach ->
1762       editor.setText("12\n34\n\n")
1763       editor.setCursorBufferPosition([0, 0])
1764       editor.addCursorAtBufferPosition([1, 0])
1765
1766     it "replaces a single character", ->
1767       keydown('r')
1768       normalModeInputKeydown('x')
1769       expect(editor.getText()).toBe 'x2\nx4\n\n'
1770
1771     it "does nothing when cancelled", ->
1772       keydown('r')
1773       expect(editorElement.classList.contains('operator-pending-mode')).toBe(true)
1774       keydown('escape')
1775       expect(editor.getText()).toBe '12\n34\n\n'
1776       expect(editorElement.classList.contains('normal-mode')).toBe(true)
1777
1778     it "replaces a single character with a line break", ->
1779       keydown('r')
1780       atom.commands.dispatch(editor.normalModeInputView.editorElement, 'core:confirm')
1781       expect(editor.getText()).toBe '\n2\n\n4\n\n'
1782       expect(editor.getCursorBufferPositions()).toEqual [[1, 0], [3, 0]]
1783
1784     it "composes properly with motions", ->
1785       keydown('2')
1786       keydown('r')
1787       normalModeInputKeydown('x')
1788       expect(editor.getText()).toBe 'xx\nxx\n\n'
1789
1790     it "does nothing on an empty line", ->
1791       editor.setCursorBufferPosition([2, 0])
1792       keydown('r')
1793       normalModeInputKeydown('x')
1794       expect(editor.getText()).toBe '12\n34\n\n'
1795
1796     it "does nothing if asked to replace more characters than there are on a line", ->
1797       keydown('3')
1798       keydown('r')
1799       normalModeInputKeydown('x')
1800       expect(editor.getText()).toBe '12\n34\n\n'
1801
1802     describe "when in visual mode", ->
1803       beforeEach ->
1804         keydown('v')
1805         keydown('e')
1806
1807       it "replaces the entire selection with the given character", ->
1808         keydown('r')
1809         normalModeInputKeydown('x')
1810         expect(editor.getText()).toBe 'xx\nxx\n\n'
1811
1812       it "leaves the cursor at the beginning of the selection", ->
1813         keydown('r')
1814         normalModeInputKeydown('x')
1815         expect(editor.getCursorBufferPositions()).toEqual [[0, 0], [1, 0]]
1816
1817     describe 'with accented characters', ->
1818       buildIMECompositionEvent = (event, {data, target}={}) ->
1819         event = new Event(event)
1820         event.data = data
1821         Object.defineProperty(event, 'target', get: -> target)
1822         event
1823
1824       buildTextInputEvent = ({data, target}) ->
1825         event = new Event('textInput')
1826         event.data = data
1827         Object.defineProperty(event, 'target', get: -> target)
1828         event
1829
1830       it 'works with IME composition', ->
1831         keydown('r')
1832         normalModeEditor = editor.normalModeInputView.editorElement
1833         jasmine.attachToDOM(normalModeEditor)
1834         domNode = normalModeEditor.component.domNode
1835         inputNode = domNode.querySelector('.hidden-input')
1836         domNode.dispatchEvent(buildIMECompositionEvent('compositionstart', target: inputNode))
1837         domNode.dispatchEvent(buildIMECompositionEvent('compositionupdate', data: 's', target: inputNode))
1838         expect(normalModeEditor.getModel().getText()).toEqual 's'
1839         domNode.dispatchEvent(buildIMECompositionEvent('compositionupdate', data: 'sd', target: inputNode))
1840         expect(normalModeEditor.getModel().getText()).toEqual 'sd'
1841         domNode.dispatchEvent(buildIMECompositionEvent('compositionend', target: inputNode))
1842         domNode.dispatchEvent(buildTextInputEvent(data: '速度', target: inputNode))
1843         expect(editor.getText()).toBe '速度2\n速度4\n\n'
1844
1845   describe 'the m keybinding', ->
1846     beforeEach ->
1847       editor.setText('12\n34\n56\n')
1848       editor.setCursorBufferPosition([0, 1])
1849
1850     it 'marks a position', ->
1851       keydown('m')
1852       normalModeInputKeydown('a')
1853       expect(vimState.getMark('a')).toEqual [0, 1]
1854
1855   describe 'the ~ keybinding', ->
1856     beforeEach ->
1857       editor.setText('aBc\nXyZ')
1858       editor.setCursorBufferPosition([0, 0])
1859       editor.addCursorAtBufferPosition([1, 0])
1860
1861     it 'toggles the case and moves right', ->
1862       keydown('~')
1863       expect(editor.getText()).toBe 'ABc\nxyZ'
1864       expect(editor.getCursorScreenPositions()).toEqual [[0, 1], [1, 1]]
1865
1866       keydown('~')
1867       expect(editor.getText()).toBe 'Abc\nxYZ'
1868       expect(editor.getCursorScreenPositions()).toEqual [[0, 2], [1, 2]]
1869
1870       keydown('~')
1871       expect(editor.getText()).toBe 'AbC\nxYz'
1872       expect(editor.getCursorScreenPositions()).toEqual [[0, 2], [1, 2]]
1873
1874     it 'takes a count', ->
1875       keydown('4')
1876       keydown('~')
1877
1878       expect(editor.getText()).toBe 'AbC\nxYz'
1879       expect(editor.getCursorScreenPositions()).toEqual [[0, 2], [1, 2]]
1880
1881     describe "in visual mode", ->
1882       it "toggles the case of the selected text", ->
1883         editor.setCursorBufferPosition([0, 0])
1884         keydown("V", shift: true)
1885         keydown("~")
1886         expect(editor.getText()).toBe 'AbC\nXyZ'
1887
1888     describe "with g and motion", ->
1889       it "toggles the case of text", ->
1890         editor.setCursorBufferPosition([0, 0])
1891         keydown("g")
1892         keydown("~")
1893         keydown("2")
1894         keydown("l")
1895         expect(editor.getText()).toBe 'Abc\nXyZ'
1896
1897       it "uses default count", ->
1898         editor.setCursorBufferPosition([0, 0])
1899         keydown("g")
1900         keydown("~")
1901         keydown("G", shift: true)
1902         expect(editor.getText()).toBe 'AbC\nxYz'
1903
1904   describe 'the U keybinding', ->
1905     beforeEach ->
1906       editor.setText('aBc\nXyZ')
1907       editor.setCursorBufferPosition([0, 0])
1908
1909     it "makes text uppercase with g and motion", ->
1910       keydown("g")
1911       keydown("U", shift: true)
1912       keydown("l")
1913       expect(editor.getText()).toBe 'ABc\nXyZ'
1914
1915       keydown("g")
1916       keydown("U", shift: true)
1917       keydown("e")
1918       expect(editor.getText()).toBe 'ABC\nXyZ'
1919
1920       editor.setCursorBufferPosition([1, 0])
1921       keydown("g")
1922       keydown("U", shift: true)
1923       keydown("$")
1924       expect(editor.getText()).toBe 'ABC\nXYZ'
1925       expect(editor.getCursorScreenPosition()).toEqual [1, 2]
1926
1927     it "uses default count", ->
1928       editor.setCursorBufferPosition([0, 0])
1929       keydown("g")
1930       keydown("U", shift: true)
1931       keydown("G", shift: true)
1932       expect(editor.getText()).toBe 'ABC\nXYZ'
1933
1934     it "makes the selected text uppercase in visual mode", ->
1935       keydown("V", shift: true)
1936       keydown("U", shift: true)
1937       expect(editor.getText()).toBe 'ABC\nXyZ'
1938
1939   describe 'the u keybinding', ->
1940     beforeEach ->
1941       editor.setText('aBc\nXyZ')
1942       editor.setCursorBufferPosition([0, 0])
1943
1944     it "makes text lowercase with g and motion", ->
1945       keydown("g")
1946       keydown("u")
1947       keydown("$")
1948       expect(editor.getText()).toBe 'abc\nXyZ'
1949       expect(editor.getCursorScreenPosition()).toEqual [0, 2]
1950
1951     it "uses default count", ->
1952       editor.setCursorBufferPosition([0, 0])
1953       keydown("g")
1954       keydown("u")
1955       keydown("G", shift: true)
1956       expect(editor.getText()).toBe 'abc\nxyz'
1957
1958     it "makes the selected text lowercase in visual mode", ->
1959       keydown("V", shift: true)
1960       keydown("u")
1961       expect(editor.getText()).toBe 'abc\nXyZ'
1962
1963   describe "the i keybinding", ->
1964     beforeEach ->
1965       editor.setText('123\n4567')
1966       editor.setCursorBufferPosition([0, 0])
1967       editor.addCursorAtBufferPosition([1, 0])
1968
1969     it "allows undoing an entire batch of typing", ->
1970       keydown 'i'
1971       editor.insertText("abcXX")
1972       editor.backspace()
1973       editor.backspace()
1974       keydown 'escape'
1975       expect(editor.getText()).toBe "abc123\nabc4567"
1976
1977       keydown 'i'
1978       editor.insertText "d"
1979       editor.insertText "e"
1980       editor.insertText "f"
1981       keydown 'escape'
1982       expect(editor.getText()).toBe "abdefc123\nabdefc4567"
1983
1984       keydown 'u'
1985       expect(editor.getText()).toBe "abc123\nabc4567"
1986
1987       keydown 'u'
1988       expect(editor.getText()).toBe "123\n4567"
1989
1990     it "allows repeating typing", ->
1991       keydown 'i'
1992       editor.insertText("abcXX")
1993       editor.backspace()
1994       editor.backspace()
1995       keydown 'escape'
1996       expect(editor.getText()).toBe "abc123\nabc4567"
1997
1998       keydown '.'
1999       expect(editor.getText()).toBe "ababcc123\nababcc4567"
2000
2001       keydown '.'
2002       expect(editor.getText()).toBe "abababccc123\nabababccc4567"
2003
2004     describe 'with nonlinear input', ->
2005       beforeEach ->
2006         editor.setText ''
2007         editor.setCursorBufferPosition [0, 0]
2008
2009       it 'deals with auto-matched brackets', ->
2010         keydown 'i'
2011         # this sequence simulates what the bracket-matcher package does
2012         # when the user types (a)b<enter>
2013         editor.insertText '()'
2014         editor.moveLeft()
2015         editor.insertText 'a'
2016         editor.moveRight()
2017         editor.insertText 'b\n'
2018         keydown 'escape'
2019         expect(editor.getCursorScreenPosition()).toEqual [1,  0]
2020
2021         keydown '.'
2022         expect(editor.getText()).toBe '(a)b\n(a)b\n'
2023         expect(editor.getCursorScreenPosition()).toEqual [2,  0]
2024
2025       it 'deals with autocomplete', ->
2026         keydown 'i'
2027         # this sequence simulates autocompletion of 'add' to 'addFoo'
2028         editor.insertText 'a'
2029         editor.insertText 'd'
2030         editor.insertText 'd'
2031         editor.setTextInBufferRange [[0, 0], [0, 3]], 'addFoo'
2032         keydown 'escape'
2033         expect(editor.getCursorScreenPosition()).toEqual [0,  5]
2034         expect(editor.getText()).toBe 'addFoo'
2035
2036         keydown '.'
2037         expect(editor.getText()).toBe 'addFoaddFooo'
2038         expect(editor.getCursorScreenPosition()).toEqual [0,  10]
2039
2040   describe 'the a keybinding', ->
2041     beforeEach ->
2042       editor.setText('')
2043       editor.setCursorBufferPosition([0, 0])
2044
2045     it "can be undone in one go", ->
2046       keydown 'a'
2047       editor.insertText("abc")
2048       keydown 'escape'
2049       expect(editor.getText()).toBe "abc"
2050       keydown 'u'
2051       expect(editor.getText()).toBe ""
2052
2053     it "repeats correctly", ->
2054       keydown 'a'
2055       editor.insertText("abc")
2056       keydown 'escape'
2057       expect(editor.getText()).toBe "abc"
2058       expect(editor.getCursorScreenPosition()).toEqual [0, 2]
2059       keydown '.'
2060       expect(editor.getText()).toBe "abcabc"
2061       expect(editor.getCursorScreenPosition()).toEqual [0, 5]
2062
2063   describe "the ctrl-a/ctrl-x keybindings", ->
2064     beforeEach ->
2065       atom.config.set 'vim-mode.numberRegex', settings.config.numberRegex.default
2066       editor.setText('123\nab45\ncd-67ef\nab-5\na-bcdef')
2067       editor.setCursorBufferPosition [0, 0]
2068       editor.addCursorAtBufferPosition [1, 0]
2069       editor.addCursorAtBufferPosition [2, 0]
2070       editor.addCursorAtBufferPosition [3, 3]
2071       editor.addCursorAtBufferPosition [4, 0]
2072
2073     describe "increasing numbers", ->
2074       it "increases the next number", ->
2075         keydown('a', ctrl: true)
2076         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 3], [2, 4], [3, 3], [4, 0]]
2077         expect(editor.getText()).toBe '124\nab46\ncd-66ef\nab-4\na-bcdef'
2078         expect(atom.beep).not.toHaveBeenCalled()
2079
2080       it "repeats with .", ->
2081         keydown 'a', ctrl: true
2082         keydown '.'
2083         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 3], [2, 4], [3, 3], [4, 0]]
2084         expect(editor.getText()).toBe '125\nab47\ncd-65ef\nab-3\na-bcdef'
2085         expect(atom.beep).not.toHaveBeenCalled()
2086
2087       it "can have a count", ->
2088         keydown '5'
2089         keydown 'a', ctrl: true
2090         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 3], [2, 4], [3, 2], [4, 0]]
2091         expect(editor.getText()).toBe '128\nab50\ncd-62ef\nab0\na-bcdef'
2092         expect(atom.beep).not.toHaveBeenCalled()
2093
2094       it "can make a negative number positive, change number of digits", ->
2095         keydown '9'
2096         keydown '9'
2097         keydown 'a', ctrl: true
2098         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 4], [2, 3], [3, 3], [4, 0]]
2099         expect(editor.getText()).toBe '222\nab144\ncd32ef\nab94\na-bcdef'
2100         expect(atom.beep).not.toHaveBeenCalled()
2101
2102       it "does nothing when cursor is after the number", ->
2103         editor.setCursorBufferPosition [2, 5]
2104         keydown 'a', ctrl: true
2105         expect(editor.getCursorBufferPositions()).toEqual [[2, 5]]
2106         expect(editor.getText()).toBe '123\nab45\ncd-67ef\nab-5\na-bcdef'
2107         expect(atom.beep).toHaveBeenCalled()
2108
2109       it "does nothing on an empty line", ->
2110         editor.setText('\n')
2111         editor.setCursorBufferPosition [0, 0]
2112         editor.addCursorAtBufferPosition [1, 0]
2113         keydown 'a', ctrl: true
2114         expect(editor.getCursorBufferPositions()).toEqual [[0, 0], [1, 0]]
2115         expect(editor.getText()).toBe '\n'
2116         expect(atom.beep).toHaveBeenCalled()
2117
2118       it "honours the vim-mode:numberRegex setting", ->
2119         editor.setText('123\nab45\ncd -67ef\nab-5\na-bcdef')
2120         editor.setCursorBufferPosition [0, 0]
2121         editor.addCursorAtBufferPosition [1, 0]
2122         editor.addCursorAtBufferPosition [2, 0]
2123         editor.addCursorAtBufferPosition [3, 3]
2124         editor.addCursorAtBufferPosition [4, 0]
2125         atom.config.set('vim-mode.numberRegex', '(?:\\B-)?[0-9]+')
2126         keydown('a', ctrl: true)
2127         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 3], [2, 5], [3, 3], [4, 0]]
2128         expect(editor.getText()).toBe '124\nab46\ncd -66ef\nab-6\na-bcdef'
2129         expect(atom.beep).not.toHaveBeenCalled()
2130
2131     describe "decreasing numbers", ->
2132       it "decreases the next number", ->
2133         keydown('x', ctrl: true)
2134         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 3], [2, 4], [3, 3], [4, 0]]
2135         expect(editor.getText()).toBe '122\nab44\ncd-68ef\nab-6\na-bcdef'
2136         expect(atom.beep).not.toHaveBeenCalled()
2137
2138       it "repeats with .", ->
2139         keydown 'x', ctrl: true
2140         keydown '.'
2141         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 3], [2, 4], [3, 3], [4, 0]]
2142         expect(editor.getText()).toBe '121\nab43\ncd-69ef\nab-7\na-bcdef'
2143         expect(atom.beep).not.toHaveBeenCalled()
2144
2145       it "can have a count", ->
2146         keydown '5'
2147         keydown 'x', ctrl: true
2148         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 3], [2, 4], [3, 4], [4, 0]]
2149         expect(editor.getText()).toBe '118\nab40\ncd-72ef\nab-10\na-bcdef'
2150         expect(atom.beep).not.toHaveBeenCalled()
2151
2152       it "can make a positive number negative, change number of digits", ->
2153         keydown '9'
2154         keydown '9'
2155         keydown 'x', ctrl: true
2156         expect(editor.getCursorBufferPositions()).toEqual [[0, 1], [1, 4], [2, 5], [3, 5], [4, 0]]
2157         expect(editor.getText()).toBe '24\nab-54\ncd-166ef\nab-104\na-bcdef'
2158         expect(atom.beep).not.toHaveBeenCalled()
2159
2160       it "does nothing when cursor is after the number", ->
2161         editor.setCursorBufferPosition [2, 5]
2162         keydown 'x', ctrl: true
2163         expect(editor.getCursorBufferPositions()).toEqual [[2, 5]]
2164         expect(editor.getText()).toBe '123\nab45\ncd-67ef\nab-5\na-bcdef'
2165         expect(atom.beep).toHaveBeenCalled()
2166
2167       it "does nothing on an empty line", ->
2168         editor.setText('\n')
2169         editor.setCursorBufferPosition [0, 0]
2170         editor.addCursorAtBufferPosition [1, 0]
2171         keydown 'x', ctrl: true
2172         expect(editor.getCursorBufferPositions()).toEqual [[0, 0], [1, 0]]
2173         expect(editor.getText()).toBe '\n'
2174         expect(atom.beep).toHaveBeenCalled()
2175
2176       it "honours the vim-mode:numberRegex setting", ->
2177         editor.setText('123\nab45\ncd -67ef\nab-5\na-bcdef')
2178         editor.setCursorBufferPosition [0, 0]
2179         editor.addCursorAtBufferPosition [1, 0]
2180         editor.addCursorAtBufferPosition [2, 0]
2181         editor.addCursorAtBufferPosition [3, 3]
2182         editor.addCursorAtBufferPosition [4, 0]
2183         atom.config.set('vim-mode.numberRegex', '(?:\\B-)?[0-9]+')
2184         keydown('x', ctrl: true)
2185         expect(editor.getCursorBufferPositions()).toEqual [[0, 2], [1, 3], [2, 5], [3, 3], [4, 0]]
2186         expect(editor.getText()).toBe '122\nab44\ncd -68ef\nab-4\na-bcdef'
2187         expect(atom.beep).not.toHaveBeenCalled()
2188
2189   describe 'the R keybinding', ->
2190     beforeEach ->
2191       editor.setText('12345\n67890')
2192       editor.setCursorBufferPosition([0, 2])
2193
2194     it "enters replace mode and replaces characters", ->
2195       keydown "R", shift: true
2196       expect(editorElement.classList.contains('insert-mode')).toBe true
2197       expect(editorElement.classList.contains('replace-mode')).toBe true
2198
2199       editor.insertText "ab"
2200       keydown 'escape'
2201
2202       expect(editor.getText()).toBe "12ab5\n67890"
2203       expect(editor.getCursorScreenPosition()).toEqual [0, 3]
2204       expect(editorElement.classList.contains('insert-mode')).toBe false
2205       expect(editorElement.classList.contains('replace-mode')).toBe false
2206       expect(editorElement.classList.contains('normal-mode')).toBe true
2207
2208     it "continues beyond end of line as insert", ->
2209       keydown "R", shift: true
2210       expect(editorElement.classList.contains('insert-mode')).toBe true
2211       expect(editorElement.classList.contains('replace-mode')).toBe true
2212
2213       editor.insertText "abcde"
2214       keydown 'escape'
2215
2216       expect(editor.getText()).toBe "12abcde\n67890"
2217
2218     it "treats backspace as undo", ->
2219       editor.insertText "foo"
2220       keydown "R", shift: true
2221
2222       editor.insertText "a"
2223       editor.insertText "b"
2224       expect(editor.getText()).toBe "12fooab5\n67890"
2225
2226       keydown 'backspace', raw: true
2227       expect(editor.getText()).toBe "12fooa45\n67890"
2228
2229       editor.insertText "c"
2230
2231       expect(editor.getText()).toBe "12fooac5\n67890"
2232
2233       keydown 'backspace', raw: true
2234       keydown 'backspace', raw: true
2235
2236       expect(editor.getText()).toBe "12foo345\n67890"
2237       expect(editor.getSelectedText()).toBe ""
2238
2239       keydown 'backspace', raw: true
2240       expect(editor.getText()).toBe "12foo345\n67890"
2241       expect(editor.getSelectedText()).toBe ""
2242
2243     it "can be repeated", ->
2244       keydown "R", shift: true
2245       editor.insertText "ab"
2246       keydown 'escape'
2247       editor.setCursorBufferPosition([1, 2])
2248       keydown '.'
2249       expect(editor.getText()).toBe "12ab5\n67ab0"
2250       expect(editor.getCursorScreenPosition()).toEqual [1, 3]
2251
2252       editor.setCursorBufferPosition([0, 4])
2253       keydown '.'
2254       expect(editor.getText()).toBe "12abab\n67ab0"
2255       expect(editor.getCursorScreenPosition()).toEqual [0, 5]
2256
2257     it "can be interrupted by arrow keys and behave as insert for repeat", ->
2258       # FIXME don't know how to test this (also, depends on PR #568)
2259
2260     it "repeats correctly when backspace was used in the text", ->
2261       keydown "R", shift: true
2262       editor.insertText "a"
2263       keydown 'backspace', raw: true
2264       editor.insertText "b"
2265       keydown 'escape'
2266       editor.setCursorBufferPosition([1, 2])
2267       keydown '.'
2268       expect(editor.getText()).toBe "12b45\n67b90"
2269       expect(editor.getCursorScreenPosition()).toEqual [1, 2]
2270
2271       editor.setCursorBufferPosition([0, 4])
2272       keydown '.'
2273       expect(editor.getText()).toBe "12b4b\n67b90"
2274       expect(editor.getCursorScreenPosition()).toEqual [0, 4]
2275
2276     it "doesn't replace a character if newline is entered", ->
2277       keydown "R", shift: true
2278       expect(editorElement.classList.contains('insert-mode')).toBe true
2279       expect(editorElement.classList.contains('replace-mode')).toBe true
2280
2281       editor.insertText "\n"
2282       keydown 'escape'
2283
2284       expect(editor.getText()).toBe "12\n345\n67890"