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

... / ...

Commit	Line	Data
	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"