mirror of
https://github.com/atom/atom.git
synced 2026-04-28 03:01:47 -04:00
1084 lines
58 KiB
CoffeeScript
1084 lines
58 KiB
CoffeeScript
TextBuffer = require 'text-buffer'
|
|
TextEditor = require '../src/text-editor'
|
|
TextEditorPresenter = require '../src/text-editor-presenter'
|
|
|
|
describe "TextEditorPresenter", ->
|
|
[buffer, editor] = []
|
|
|
|
beforeEach ->
|
|
# These *should* be mocked in the spec helper, but changing that now would break packages :-(
|
|
spyOn(window, "setInterval").andCallFake window.fakeSetInterval
|
|
spyOn(window, "clearInterval").andCallFake window.fakeClearInterval
|
|
|
|
buffer = new TextBuffer(filePath: require.resolve('./fixtures/sample.js'))
|
|
editor = new TextEditor({buffer})
|
|
waitsForPromise -> buffer.load()
|
|
|
|
afterEach ->
|
|
editor.destroy()
|
|
buffer.destroy()
|
|
|
|
expectValues = (actual, expected) ->
|
|
for key, value of expected
|
|
expect(actual[key]).toEqual value
|
|
|
|
expectStateUpdate = (presenter, fn) ->
|
|
updatedState = false
|
|
disposable = presenter.onDidUpdateState ->
|
|
updatedState = true
|
|
disposable.dispose()
|
|
fn()
|
|
expect(updatedState).toBe true
|
|
|
|
# These `describe` and `it` blocks mirror the structure of the ::state object.
|
|
# Please maintain this structure when adding specs for new state fields.
|
|
describe "::state", ->
|
|
describe ".scrollHeight", ->
|
|
it "is initialized based on the lineHeight, the number of lines, and the clientHeight", ->
|
|
presenter = new TextEditorPresenter(model: editor, scrollTop: 0, lineHeight: 10)
|
|
expect(presenter.state.scrollHeight).toBe editor.getScreenLineCount() * 10
|
|
|
|
presenter = new TextEditorPresenter(model: editor, scrollTop: 0, lineHeight: 10, clientHeight: 500)
|
|
expect(presenter.state.scrollHeight).toBe 500
|
|
|
|
it "updates when the ::lineHeight changes", ->
|
|
presenter = new TextEditorPresenter(model: editor, scrollTop: 0, lineHeight: 10)
|
|
expectStateUpdate presenter, -> presenter.setLineHeight(20)
|
|
expect(presenter.state.scrollHeight).toBe editor.getScreenLineCount() * 20
|
|
|
|
it "updates when the line count changes", ->
|
|
presenter = new TextEditorPresenter(model: editor, scrollTop: 0, lineHeight: 10)
|
|
expectStateUpdate presenter, -> editor.getBuffer().append("\n\n\n")
|
|
expect(presenter.state.scrollHeight).toBe editor.getScreenLineCount() * 10
|
|
|
|
describe ".scrollTop", ->
|
|
it "tracks the value of ::scrollTop", ->
|
|
presenter = new TextEditorPresenter(model: editor, scrollTop: 10, lineHeight: 10)
|
|
expect(presenter.state.scrollTop).toBe 10
|
|
expectStateUpdate presenter, -> presenter.setScrollTop(50)
|
|
expect(presenter.state.scrollTop).toBe 50
|
|
|
|
describe ".content", ->
|
|
describe ".scrollWidth", ->
|
|
it "is initialized as the max of the clientWidth and the width of the longest line", ->
|
|
maxLineLength = editor.getMaxScreenLineLength()
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientWidth: 50, baseCharacterWidth: 10)
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 1
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientWidth: 10 * maxLineLength + 20, baseCharacterWidth: 10)
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 20
|
|
|
|
it "updates when the ::clientWidth changes", ->
|
|
maxLineLength = editor.getMaxScreenLineLength()
|
|
presenter = new TextEditorPresenter(model: editor, clientWidth: 50, baseCharacterWidth: 10)
|
|
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 1
|
|
expectStateUpdate presenter, -> presenter.setClientWidth(10 * maxLineLength + 20)
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 20
|
|
|
|
it "updates when the ::baseCharacterWidth changes", ->
|
|
maxLineLength = editor.getMaxScreenLineLength()
|
|
presenter = new TextEditorPresenter(model: editor, clientWidth: 50, baseCharacterWidth: 10)
|
|
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 1
|
|
expectStateUpdate presenter, -> presenter.setBaseCharacterWidth(15)
|
|
expect(presenter.state.content.scrollWidth).toBe 15 * maxLineLength + 1
|
|
|
|
it "updates when the scoped character widths change", ->
|
|
waitsForPromise -> atom.packages.activatePackage('language-javascript')
|
|
|
|
runs ->
|
|
maxLineLength = editor.getMaxScreenLineLength()
|
|
presenter = new TextEditorPresenter(model: editor, clientWidth: 50, baseCharacterWidth: 10)
|
|
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 1
|
|
expectStateUpdate presenter, -> presenter.setScopedCharWidth(['source.js', 'support.function.js'], 'p', 20)
|
|
expect(presenter.state.content.scrollWidth).toBe (10 * (maxLineLength - 2)) + (20 * 2) + 1 # 2 of the characters are 20px wide now instead of 10px wide
|
|
|
|
it "updates when ::softWrapped changes on the editor", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientWidth: 50, baseCharacterWidth: 10)
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1
|
|
expectStateUpdate presenter, -> editor.setSoftWrapped(true)
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength()
|
|
expectStateUpdate presenter, -> editor.setSoftWrapped(false)
|
|
expect(presenter.state.content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1
|
|
|
|
describe ".scrollLeft", ->
|
|
it "tracks the value of ::scrollLeft", ->
|
|
presenter = new TextEditorPresenter(model: editor, scrollLeft: 10, lineHeight: 10, lineOverdrawMargin: 1)
|
|
expect(presenter.state.content.scrollLeft).toBe 10
|
|
expectStateUpdate presenter, -> presenter.setScrollLeft(50)
|
|
expect(presenter.state.content.scrollLeft).toBe 50
|
|
|
|
describe ".indentGuidesVisible", ->
|
|
it "is initialized based on the editor.showIndentGuide config setting", ->
|
|
presenter = new TextEditorPresenter(model: editor)
|
|
expect(presenter.state.content.indentGuidesVisible).toBe false
|
|
|
|
atom.config.set('editor.showIndentGuide', true)
|
|
presenter = new TextEditorPresenter(model: editor)
|
|
expect(presenter.state.content.indentGuidesVisible).toBe true
|
|
|
|
it "updates when the editor.showIndentGuide config setting changes", ->
|
|
presenter = new TextEditorPresenter(model: editor)
|
|
expect(presenter.state.content.indentGuidesVisible).toBe false
|
|
|
|
expectStateUpdate presenter, -> atom.config.set('editor.showIndentGuide', true)
|
|
expect(presenter.state.content.indentGuidesVisible).toBe true
|
|
|
|
expectStateUpdate presenter, -> atom.config.set('editor.showIndentGuide', false)
|
|
expect(presenter.state.content.indentGuidesVisible).toBe false
|
|
|
|
it "updates when the editor's grammar changes", ->
|
|
atom.config.set('editor.showIndentGuide', true, scopeSelector: ".source.js")
|
|
|
|
presenter = new TextEditorPresenter(model: editor)
|
|
expect(presenter.state.content.indentGuidesVisible).toBe false
|
|
|
|
stateUpdated = false
|
|
presenter.onDidUpdateState -> stateUpdated = true
|
|
|
|
waitsForPromise -> atom.packages.activatePackage('language-javascript')
|
|
|
|
runs ->
|
|
expect(stateUpdated).toBe true
|
|
expect(presenter.state.content.indentGuidesVisible).toBe true
|
|
|
|
expectStateUpdate presenter, -> editor.setGrammar(atom.grammars.selectGrammar('.txt'))
|
|
expect(presenter.state.content.indentGuidesVisible).toBe false
|
|
|
|
describe ".lines", ->
|
|
lineStateForScreenRow = (presenter, screenRow) ->
|
|
presenter.state.content.lines[presenter.model.tokenizedLineForScreenRow(screenRow).id]
|
|
|
|
it "contains states for lines that are visible on screen, plus and minus the overdraw margin", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 15, scrollTop: 50, lineHeight: 10, lineOverdrawMargin: 1)
|
|
|
|
expect(lineStateForScreenRow(presenter, 3)).toBeUndefined()
|
|
|
|
line4 = editor.tokenizedLineForScreenRow(4)
|
|
expectValues lineStateForScreenRow(presenter, 4), {
|
|
screenRow: 4
|
|
text: line4.text
|
|
tokens: line4.tokens
|
|
top: 10 * 4
|
|
}
|
|
|
|
line5 = editor.tokenizedLineForScreenRow(5)
|
|
expectValues lineStateForScreenRow(presenter, 5), {
|
|
screenRow: 5
|
|
text: line5.text
|
|
tokens: line5.tokens
|
|
top: 10 * 5
|
|
}
|
|
|
|
line6 = editor.tokenizedLineForScreenRow(6)
|
|
expectValues lineStateForScreenRow(presenter, 6), {
|
|
screenRow: 6
|
|
text: line6.text
|
|
tokens: line6.tokens
|
|
top: 10 * 6
|
|
}
|
|
|
|
line7 = editor.tokenizedLineForScreenRow(7)
|
|
expectValues lineStateForScreenRow(presenter, 7), {
|
|
screenRow: 7
|
|
text: line7.text
|
|
tokens: line7.tokens
|
|
top: 10 * 7
|
|
}
|
|
|
|
line8 = editor.tokenizedLineForScreenRow(8)
|
|
expectValues lineStateForScreenRow(presenter, 8), {
|
|
screenRow: 8
|
|
text: line8.text
|
|
tokens: line8.tokens
|
|
top: 10 * 8
|
|
}
|
|
|
|
expect(lineStateForScreenRow(presenter, 9)).toBeUndefined()
|
|
|
|
it "does not overdraw above the first row", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 15, scrollTop: 10, lineHeight: 10, lineOverdrawMargin: 2)
|
|
expect(lineStateForScreenRow(presenter, 0)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 1)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 2)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 3)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 4)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 5)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 6)).toBeUndefined()
|
|
|
|
it "does not overdraw below the last row", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 105, lineHeight: 10, lineOverdrawMargin: 2)
|
|
expect(lineStateForScreenRow(presenter, 7)).toBeUndefined()
|
|
expect(lineStateForScreenRow(presenter, 8)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 9)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 10)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 11)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 12)).toBeDefined()
|
|
|
|
it "includes state for all lines if no external ::clientHeight is assigned", ->
|
|
presenter = new TextEditorPresenter(model: editor, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 1)
|
|
expect(lineStateForScreenRow(presenter, 0)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 12)).toBeDefined()
|
|
|
|
it "updates when ::scrollTop changes", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 1)
|
|
|
|
expect(lineStateForScreenRow(presenter, 0)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 4)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 5)).toBeUndefined()
|
|
|
|
expectStateUpdate presenter, -> presenter.setScrollTop(25)
|
|
|
|
expect(lineStateForScreenRow(presenter, 0)).toBeUndefined()
|
|
expect(lineStateForScreenRow(presenter, 1)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 6)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 7)).toBeUndefined()
|
|
|
|
it "updates when ::clientHeight changes", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 15, scrollTop: 15, lineHeight: 10, lineOverdrawMargin: 1)
|
|
|
|
line5 = editor.tokenizedLineForScreenRow(5)
|
|
|
|
expect(lineStateForScreenRow(presenter, 4)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 5)).toBeUndefined()
|
|
|
|
expectStateUpdate presenter, -> presenter.setClientHeight(35)
|
|
|
|
expect(lineStateForScreenRow(presenter, 5)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 6)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 7)).toBeUndefined()
|
|
|
|
it "updates when ::lineHeight changes", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 15, scrollTop: 10, lineHeight: 10, lineOverdrawMargin: 0)
|
|
|
|
expect(lineStateForScreenRow(presenter, 0)).toBeUndefined()
|
|
expect(lineStateForScreenRow(presenter, 1)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 2)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 4)).toBeUndefined()
|
|
|
|
expectStateUpdate presenter, -> presenter.setLineHeight(5)
|
|
|
|
expect(lineStateForScreenRow(presenter, 0)).toBeUndefined()
|
|
expect(lineStateForScreenRow(presenter, 1)).toBeUndefined()
|
|
expect(lineStateForScreenRow(presenter, 2)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 5)).toBeDefined()
|
|
expect(lineStateForScreenRow(presenter, 6)).toBeUndefined()
|
|
|
|
it "updates when the editor's content changes", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 10, lineHeight: 10, lineOverdrawMargin: 0)
|
|
|
|
expectStateUpdate presenter, -> buffer.insert([2, 0], "hello\nworld\n")
|
|
|
|
line1 = editor.tokenizedLineForScreenRow(1)
|
|
expectValues lineStateForScreenRow(presenter, 1), {
|
|
text: line1.text
|
|
tokens: line1.tokens
|
|
}
|
|
|
|
line2 = editor.tokenizedLineForScreenRow(2)
|
|
expectValues lineStateForScreenRow(presenter, 2), {
|
|
text: line2.text
|
|
tokens: line2.tokens
|
|
}
|
|
|
|
line3 = editor.tokenizedLineForScreenRow(3)
|
|
expectValues lineStateForScreenRow(presenter, 3), {
|
|
text: line3.text
|
|
tokens: line3.tokens
|
|
}
|
|
|
|
describe "[lineId]", -> # line state objects
|
|
it "includes the .endOfLineInvisibles if the editor.showInvisibles config option is true", ->
|
|
editor.setText("hello\nworld\r\n")
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
expect(lineStateForScreenRow(presenter, 0).endOfLineInvisibles).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 1).endOfLineInvisibles).toBeNull()
|
|
|
|
atom.config.set('editor.showInvisibles', true)
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
expect(lineStateForScreenRow(presenter, 0).endOfLineInvisibles).toEqual [atom.config.get('editor.invisibles.eol')]
|
|
expect(lineStateForScreenRow(presenter, 1).endOfLineInvisibles).toEqual [atom.config.get('editor.invisibles.cr'), atom.config.get('editor.invisibles.eol')]
|
|
|
|
describe ".decorationClasses", ->
|
|
it "adds decoration classes to the relevant line state objects, both initially and when decorations change", ->
|
|
marker1 = editor.markBufferRange([[4, 0], [6, 2]], invalidate: 'touch')
|
|
decoration1 = editor.decorateMarker(marker1, type: 'line', class: 'a')
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker2 = editor.markBufferRange([[4, 0], [6, 2]], invalidate: 'touch')
|
|
decoration2 = editor.decorateMarker(marker2, type: 'line', class: 'b')
|
|
|
|
expect(lineStateForScreenRow(presenter, 3).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> editor.getBuffer().insert([5, 0], 'x')
|
|
expect(marker1.isValid()).toBe false
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> editor.undo()
|
|
expect(lineStateForScreenRow(presenter, 3).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> marker1.setBufferRange([[2, 0], [4, 2]])
|
|
expect(lineStateForScreenRow(presenter, 1).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 2).decorationClasses).toEqual ['a']
|
|
expect(lineStateForScreenRow(presenter, 3).decorationClasses).toEqual ['a']
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toEqual ['b']
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toEqual ['b']
|
|
expect(lineStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> decoration1.destroy()
|
|
expect(lineStateForScreenRow(presenter, 2).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 3).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toEqual ['b']
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toEqual ['b']
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toEqual ['b']
|
|
expect(lineStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> marker2.destroy()
|
|
expect(lineStateForScreenRow(presenter, 2).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 3).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
it "honors the 'onlyEmpty' option on line decorations", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker = editor.markBufferRange([[4, 0], [6, 1]])
|
|
decoration = editor.decorateMarker(marker, type: 'line', class: 'a', onlyEmpty: true)
|
|
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> marker.clearTail()
|
|
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toBeNull()
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toEqual ['a']
|
|
|
|
it "honors the 'onlyNonEmpty' option on line decorations", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker = editor.markBufferRange([[4, 0], [6, 2]])
|
|
decoration = editor.decorateMarker(marker, type: 'line', class: 'a', onlyNonEmpty: true)
|
|
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a']
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toEqual ['a']
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toEqual ['a']
|
|
|
|
expectStateUpdate presenter, -> marker.clearTail()
|
|
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
|
|
it "does not decorate the last line of a non-empty line decoration range if it ends at column 0", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker = editor.markBufferRange([[4, 0], [6, 0]])
|
|
decoration = editor.decorateMarker(marker, type: 'line', class: 'a')
|
|
|
|
expect(lineStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a']
|
|
expect(lineStateForScreenRow(presenter, 5).decorationClasses).toEqual ['a']
|
|
expect(lineStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
|
|
it "does not apply line decorations to mini editors", ->
|
|
editor.setMini(true)
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 10, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker = editor.markBufferRange([[0, 0], [0, 0]])
|
|
decoration = editor.decorateMarker(marker, type: 'line', class: 'a')
|
|
expect(lineStateForScreenRow(presenter, 0).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> editor.setMini(false)
|
|
expect(lineStateForScreenRow(presenter, 0).decorationClasses).toEqual ['cursor-line', 'a']
|
|
|
|
expectStateUpdate presenter, -> editor.setMini(true)
|
|
expect(lineStateForScreenRow(presenter, 0).decorationClasses).toBeNull()
|
|
|
|
describe ".cursors", ->
|
|
stateForCursor = (presenter, cursorIndex) ->
|
|
presenter.state.content.cursors[presenter.model.getCursors()[cursorIndex].id]
|
|
|
|
it "contains pixelRects for empty selections that are visible on screen", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[1, 2], [1, 2]],
|
|
[[2, 4], [2, 4]],
|
|
[[3, 4], [3, 5]]
|
|
[[5, 12], [5, 12]],
|
|
[[8, 4], [8, 4]]
|
|
])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 30, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expect(stateForCursor(presenter, 0)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 1)).toEqual {top: 2 * 10, left: 4 * 10, width: 10, height: 10}
|
|
expect(stateForCursor(presenter, 2)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 3)).toEqual {top: 5 * 10, left: 12 * 10, width: 10, height: 10}
|
|
expect(stateForCursor(presenter, 4)).toBeUndefined()
|
|
|
|
it "updates when ::scrollTop changes", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[1, 2], [1, 2]],
|
|
[[2, 4], [2, 4]],
|
|
[[3, 4], [3, 5]]
|
|
[[5, 12], [5, 12]],
|
|
[[8, 4], [8, 4]]
|
|
])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 30, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectStateUpdate presenter, -> presenter.setScrollTop(5 * 10)
|
|
expect(stateForCursor(presenter, 0)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 1)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 2)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 3)).toEqual {top: 5 * 10, left: 12 * 10, width: 10, height: 10}
|
|
expect(stateForCursor(presenter, 4)).toEqual {top: 8 * 10, left: 4 * 10, width: 10, height: 10}
|
|
|
|
it "updates when ::clientHeight changes", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[1, 2], [1, 2]],
|
|
[[2, 4], [2, 4]],
|
|
[[3, 4], [3, 5]]
|
|
[[5, 12], [5, 12]],
|
|
[[8, 4], [8, 4]]
|
|
])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectStateUpdate presenter, -> presenter.setClientHeight(30)
|
|
expect(stateForCursor(presenter, 0)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 1)).toEqual {top: 2 * 10, left: 4 * 10, width: 10, height: 10}
|
|
expect(stateForCursor(presenter, 2)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 3)).toEqual {top: 5 * 10, left: 12 * 10, width: 10, height: 10}
|
|
expect(stateForCursor(presenter, 4)).toBeUndefined()
|
|
|
|
it "updates when ::lineHeight changes", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[1, 2], [1, 2]],
|
|
[[2, 4], [2, 4]],
|
|
[[3, 4], [3, 5]]
|
|
[[5, 12], [5, 12]],
|
|
[[8, 4], [8, 4]]
|
|
])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectStateUpdate presenter, -> presenter.setLineHeight(5)
|
|
expect(stateForCursor(presenter, 0)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 1)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 2)).toBeUndefined()
|
|
expect(stateForCursor(presenter, 3)).toEqual {top: 5 * 5, left: 12 * 10, width: 10, height: 5}
|
|
expect(stateForCursor(presenter, 4)).toEqual {top: 8 * 5, left: 4 * 10, width: 10, height: 5}
|
|
|
|
it "updates when ::baseCharacterWidth changes", ->
|
|
editor.setCursorBufferPosition([2, 4])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectStateUpdate presenter, -> presenter.setBaseCharacterWidth(20)
|
|
expect(stateForCursor(presenter, 0)).toEqual {top: 2 * 10, left: 4 * 20, width: 20, height: 10}
|
|
|
|
it "updates when scoped character widths change", ->
|
|
waitsForPromise ->
|
|
atom.packages.activatePackage('language-javascript')
|
|
|
|
runs ->
|
|
editor.setCursorBufferPosition([1, 4])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectStateUpdate presenter, -> presenter.setScopedCharWidth(['source.js', 'storage.modifier.js'], 'v', 20)
|
|
expect(stateForCursor(presenter, 0)).toEqual {top: 1 * 10, left: (3 * 10) + 20, width: 10, height: 10}
|
|
|
|
expectStateUpdate presenter, -> presenter.setScopedCharWidth(['source.js', 'storage.modifier.js'], 'r', 20)
|
|
expect(stateForCursor(presenter, 0)).toEqual {top: 1 * 10, left: (3 * 10) + 20, width: 20, height: 10}
|
|
|
|
it "updates when cursors are added, moved, hidden, shown, or destroyed", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[1, 2], [1, 2]],
|
|
[[3, 4], [3, 5]]
|
|
])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
# moving into view
|
|
expect(stateForCursor(presenter, 0)).toBeUndefined()
|
|
editor.getCursors()[0].setBufferPosition([2, 4])
|
|
expect(stateForCursor(presenter, 0)).toEqual {top: 2 * 10, left: 4 * 10, width: 10, height: 10}
|
|
|
|
# showing
|
|
expectStateUpdate presenter, -> editor.getSelections()[1].clear()
|
|
expect(stateForCursor(presenter, 1)).toEqual {top: 3 * 10, left: 5 * 10, width: 10, height: 10}
|
|
|
|
# hiding
|
|
expectStateUpdate presenter, -> editor.getSelections()[1].setBufferRange([[3, 4], [3, 5]])
|
|
expect(stateForCursor(presenter, 1)).toBeUndefined()
|
|
|
|
# moving out of view
|
|
expectStateUpdate presenter, -> editor.getCursors()[0].setBufferPosition([10, 4])
|
|
expect(stateForCursor(presenter, 0)).toBeUndefined()
|
|
|
|
# adding
|
|
expectStateUpdate presenter, -> editor.addCursorAtBufferPosition([4, 4])
|
|
expect(stateForCursor(presenter, 2)).toEqual {top: 4 * 10, left: 4 * 10, width: 10, height: 10}
|
|
|
|
# moving added cursor
|
|
expectStateUpdate presenter, -> editor.getCursors()[2].setBufferPosition([4, 6])
|
|
expect(stateForCursor(presenter, 2)).toEqual {top: 4 * 10, left: 6 * 10, width: 10, height: 10}
|
|
|
|
# destroying
|
|
destroyedCursor = editor.getCursors()[2]
|
|
expectStateUpdate presenter, -> destroyedCursor.destroy()
|
|
expect(presenter.state.content.cursors[destroyedCursor.id]).toBeUndefined()
|
|
|
|
it "makes cursors as wide as the ::baseCharacterWidth if they're at the end of a line", ->
|
|
editor.setCursorBufferPosition([1, Infinity])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
expect(stateForCursor(presenter, 0).width).toBe 10
|
|
|
|
describe ".blinkCursorsOff", ->
|
|
it "alternates between true and false twice per ::cursorBlinkPeriod", ->
|
|
cursorBlinkPeriod = 100
|
|
cursorBlinkResumeDelay = 200
|
|
presenter = new TextEditorPresenter({model: editor, cursorBlinkPeriod, cursorBlinkResumeDelay})
|
|
|
|
expect(presenter.state.content.blinkCursorsOff).toBe false
|
|
expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2)
|
|
expect(presenter.state.content.blinkCursorsOff).toBe true
|
|
expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2)
|
|
expect(presenter.state.content.blinkCursorsOff).toBe false
|
|
expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2)
|
|
expect(presenter.state.content.blinkCursorsOff).toBe true
|
|
|
|
it "stops alternating for ::cursorBlinkResumeDelay when a cursor moves or a cursor is added", ->
|
|
cursorBlinkPeriod = 100
|
|
cursorBlinkResumeDelay = 200
|
|
presenter = new TextEditorPresenter({model: editor, cursorBlinkPeriod, cursorBlinkResumeDelay})
|
|
|
|
expect(presenter.state.content.blinkCursorsOff).toBe false
|
|
expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2)
|
|
expect(presenter.state.content.blinkCursorsOff).toBe true
|
|
|
|
expectStateUpdate presenter, -> editor.moveRight()
|
|
expect(presenter.state.content.blinkCursorsOff).toBe false
|
|
|
|
expectStateUpdate presenter, ->
|
|
advanceClock(cursorBlinkResumeDelay)
|
|
advanceClock(cursorBlinkPeriod / 2)
|
|
|
|
expect(presenter.state.content.blinkCursorsOff).toBe true
|
|
expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2)
|
|
expect(presenter.state.content.blinkCursorsOff).toBe false
|
|
expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2)
|
|
expect(presenter.state.content.blinkCursorsOff).toBe true
|
|
|
|
expectStateUpdate presenter, -> editor.addCursorAtBufferPosition([1, 0])
|
|
expect(presenter.state.content.blinkCursorsOff).toBe false
|
|
|
|
expectStateUpdate presenter, ->
|
|
advanceClock(cursorBlinkResumeDelay)
|
|
advanceClock(cursorBlinkPeriod / 2)
|
|
expect(presenter.state.content.blinkCursorsOff).toBe true
|
|
|
|
describe ".highlights", ->
|
|
stateForHighlight = (presenter, decoration) ->
|
|
presenter.state.content.highlights[decoration.id]
|
|
|
|
stateForSelection = (presenter, selectionIndex) ->
|
|
selection = presenter.model.getSelections()[selectionIndex]
|
|
stateForHighlight(presenter, selection.decoration)
|
|
|
|
it "contains states for highlights that are visible on screen", ->
|
|
# off-screen above
|
|
marker1 = editor.markBufferRange([[0, 0], [1, 0]])
|
|
highlight1 = editor.decorateMarker(marker1, type: 'highlight', class: 'a')
|
|
|
|
# partially off-screen above, 1 of 2 regions on screen
|
|
marker2 = editor.markBufferRange([[1, 6], [2, 6]])
|
|
highlight2 = editor.decorateMarker(marker2, type: 'highlight', class: 'b')
|
|
|
|
# partially off-screen above, 2 of 3 regions on screen
|
|
marker3 = editor.markBufferRange([[0, 6], [3, 6]])
|
|
highlight3 = editor.decorateMarker(marker3, type: 'highlight', class: 'c')
|
|
|
|
# on-screen
|
|
marker4 = editor.markBufferRange([[2, 6], [4, 6]])
|
|
highlight4 = editor.decorateMarker(marker4, type: 'highlight', class: 'd')
|
|
|
|
# partially off-screen below, 2 of 3 regions on screen
|
|
marker5 = editor.markBufferRange([[3, 6], [6, 6]])
|
|
highlight5 = editor.decorateMarker(marker5, type: 'highlight', class: 'e')
|
|
|
|
# partially off-screen below, 1 of 3 regions on screen
|
|
marker6 = editor.markBufferRange([[5, 6], [7, 6]])
|
|
highlight6 = editor.decorateMarker(marker6, type: 'highlight', class: 'f')
|
|
|
|
# off-screen below
|
|
marker7 = editor.markBufferRange([[6, 6], [7, 6]])
|
|
highlight7 = editor.decorateMarker(marker7, type: 'highlight', class: 'g')
|
|
|
|
# on-screen, empty
|
|
marker8 = editor.markBufferRange([[2, 2], [2, 2]])
|
|
highlight8 = editor.decorateMarker(marker8, type: 'highlight', class: 'h')
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 30, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expect(stateForHighlight(presenter, highlight1)).toBeUndefined()
|
|
|
|
expectValues stateForHighlight(presenter, highlight2), {
|
|
class: 'b'
|
|
regions: [
|
|
{top: 2 * 10, left: 0 * 10, width: 6 * 10, height: 1 * 10}
|
|
]
|
|
}
|
|
|
|
expectValues stateForHighlight(presenter, highlight3), {
|
|
class: 'c'
|
|
regions: [
|
|
{top: 2 * 10, left: 0 * 10, right: 0, height: 1 * 10}
|
|
{top: 3 * 10, left: 0 * 10, width: 6 * 10, height: 1 * 10}
|
|
]
|
|
}
|
|
|
|
expectValues stateForHighlight(presenter, highlight4), {
|
|
class: 'd'
|
|
regions: [
|
|
{top: 2 * 10, left: 6 * 10, right: 0, height: 1 * 10}
|
|
{top: 3 * 10, left: 0, right: 0, height: 1 * 10}
|
|
{top: 4 * 10, left: 0, width: 6 * 10, height: 1 * 10}
|
|
]
|
|
}
|
|
|
|
expectValues stateForHighlight(presenter, highlight5), {
|
|
class: 'e'
|
|
regions: [
|
|
{top: 3 * 10, left: 6 * 10, right: 0, height: 1 * 10}
|
|
{top: 4 * 10, left: 0 * 10, right: 0, height: 2 * 10}
|
|
]
|
|
}
|
|
|
|
expectValues stateForHighlight(presenter, highlight6), {
|
|
class: 'f'
|
|
regions: [
|
|
{top: 5 * 10, left: 6 * 10, right: 0, height: 1 * 10}
|
|
]
|
|
}
|
|
|
|
expect(stateForHighlight(presenter, highlight7)).toBeUndefined()
|
|
expect(stateForHighlight(presenter, highlight8)).toBeUndefined()
|
|
|
|
it "does not include highlights for invalid markers", ->
|
|
marker = editor.markBufferRange([[2, 2], [2, 4]], invalidate: 'touch')
|
|
highlight = editor.decorateMarker(marker, type: 'highlight', class: 'h')
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 30, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expect(stateForHighlight(presenter, highlight)).toBeDefined()
|
|
expectStateUpdate presenter, -> editor.getBuffer().insert([2, 2], "stuff")
|
|
expect(stateForHighlight(presenter, highlight)).toBeUndefined()
|
|
|
|
it "updates when ::scrollTop changes", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[6, 2], [6, 4]],
|
|
])
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 30, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expect(stateForSelection(presenter, 0)).toBeUndefined()
|
|
expectStateUpdate presenter, -> presenter.setScrollTop(5 * 10)
|
|
expect(stateForSelection(presenter, 0)).toBeDefined()
|
|
expectStateUpdate presenter, -> presenter.setScrollTop(2 * 10)
|
|
expect(stateForSelection(presenter, 0)).toBeUndefined()
|
|
|
|
it "updates when ::clientHeight changes", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[6, 2], [6, 4]],
|
|
])
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expect(stateForSelection(presenter, 0)).toBeUndefined()
|
|
expectStateUpdate presenter, -> presenter.setClientHeight(60)
|
|
expect(stateForSelection(presenter, 0)).toBeDefined()
|
|
expectStateUpdate presenter, -> presenter.setClientHeight(20)
|
|
expect(stateForSelection(presenter, 0)).toBeUndefined()
|
|
|
|
it "updates when ::lineHeight changes", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[2, 2], [2, 4]],
|
|
[[3, 4], [3, 6]],
|
|
])
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectValues stateForSelection(presenter, 0), {
|
|
regions: [
|
|
{top: 2 * 10, left: 2 * 10, width: 2 * 10, height: 10}
|
|
]
|
|
}
|
|
expect(stateForSelection(presenter, 1)).toBeUndefined()
|
|
|
|
expectStateUpdate presenter, -> presenter.setLineHeight(5)
|
|
|
|
expectValues stateForSelection(presenter, 0), {
|
|
regions: [
|
|
{top: 2 * 5, left: 2 * 10, width: 2 * 10, height: 5}
|
|
]
|
|
}
|
|
|
|
expectValues stateForSelection(presenter, 1), {
|
|
regions: [
|
|
{top: 3 * 5, left: 4 * 10, width: 2 * 10, height: 5}
|
|
]
|
|
}
|
|
|
|
it "updates when ::baseCharacterWidth changes", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[2, 2], [2, 4]],
|
|
])
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectValues stateForSelection(presenter, 0), {
|
|
regions: [{top: 2 * 10, left: 2 * 10, width: 2 * 10, height: 10}]
|
|
}
|
|
expectStateUpdate presenter, -> presenter.setBaseCharacterWidth(20)
|
|
expectValues stateForSelection(presenter, 0), {
|
|
regions: [{top: 2 * 10, left: 2 * 20, width: 2 * 20, height: 10}]
|
|
}
|
|
|
|
it "updates when scoped character widths change", ->
|
|
waitsForPromise ->
|
|
atom.packages.activatePackage('language-javascript')
|
|
|
|
runs ->
|
|
editor.setSelectedBufferRanges([
|
|
[[2, 4], [2, 6]],
|
|
])
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectValues stateForSelection(presenter, 0), {
|
|
regions: [{top: 2 * 10, left: 4 * 10, width: 2 * 10, height: 10}]
|
|
}
|
|
expectStateUpdate presenter, -> presenter.setScopedCharWidth(['source.js', 'keyword.control.js'], 'i', 20)
|
|
expectValues stateForSelection(presenter, 0), {
|
|
regions: [{top: 2 * 10, left: 4 * 10, width: 20 + 10, height: 10}]
|
|
}
|
|
|
|
it "updates when highlight decorations are added, moved, hidden, shown, or destroyed", ->
|
|
editor.setSelectedBufferRanges([
|
|
[[1, 2], [1, 4]],
|
|
[[3, 4], [3, 6]]
|
|
])
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 20, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectValues stateForSelection(presenter, 0), {
|
|
regions: [{top: 1 * 10, left: 2 * 10, width: 2 * 10, height: 10}]
|
|
}
|
|
expect(stateForSelection(presenter, 1)).toBeUndefined()
|
|
|
|
# moving into view
|
|
expectStateUpdate presenter, -> editor.getSelections()[1].setBufferRange([[2, 4], [2, 6]])
|
|
expectValues stateForSelection(presenter, 1), {
|
|
regions: [{top: 2 * 10, left: 4 * 10, width: 2 * 10, height: 10}]
|
|
}
|
|
|
|
# becoming empty
|
|
expectStateUpdate presenter, -> editor.getSelections()[1].clear()
|
|
expect(stateForSelection(presenter, 1)).toBeUndefined()
|
|
|
|
# becoming non-empty
|
|
expectStateUpdate presenter, -> editor.getSelections()[1].setBufferRange([[2, 4], [2, 6]])
|
|
expectValues stateForSelection(presenter, 1), {
|
|
regions: [{top: 2 * 10, left: 4 * 10, width: 2 * 10, height: 10}]
|
|
}
|
|
|
|
# moving out of view
|
|
expectStateUpdate presenter, -> editor.getSelections()[1].setBufferRange([[3, 4], [3, 6]])
|
|
expect(stateForSelection(presenter, 1)).toBeUndefined()
|
|
|
|
# adding
|
|
expectStateUpdate presenter, -> editor.addSelectionForBufferRange([[1, 4], [1, 6]])
|
|
expectValues stateForSelection(presenter, 2), {
|
|
regions: [{top: 1 * 10, left: 4 * 10, width: 2 * 10, height: 10}]
|
|
}
|
|
|
|
# moving added selection
|
|
expectStateUpdate presenter, -> editor.getSelections()[2].setBufferRange([[1, 4], [1, 8]])
|
|
expectValues stateForSelection(presenter, 2), {
|
|
regions: [{top: 1 * 10, left: 4 * 10, width: 4 * 10, height: 10}]
|
|
}
|
|
|
|
# destroying
|
|
destroyedSelection = editor.getSelections()[2]
|
|
expectStateUpdate presenter, -> destroyedSelection.destroy()
|
|
expect(stateForHighlight(presenter, destroyedSelection.decoration)).toBeUndefined()
|
|
|
|
it "updates when highlight decorations' properties are updated", ->
|
|
marker = editor.markBufferRange([[2, 2], [2, 4]])
|
|
highlight = editor.decorateMarker(marker, type: 'highlight', class: 'a')
|
|
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 30, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
expectValues stateForHighlight(presenter, highlight), {class: 'a'}
|
|
expectStateUpdate presenter, -> highlight.setProperties(class: 'b', type: 'highlight')
|
|
expectValues stateForHighlight(presenter, highlight), {class: 'b'}
|
|
|
|
it "increments the .flashCount and sets the .flashClass and .flashDuration when the highlight model flashes", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 30, scrollTop: 20, lineHeight: 10, lineOverdrawMargin: 0, baseCharacterWidth: 10)
|
|
|
|
marker = editor.markBufferRange([[2, 2], [2, 4]])
|
|
highlight = editor.decorateMarker(marker, type: 'highlight', class: 'a')
|
|
expectStateUpdate presenter, -> highlight.flash('b', 500)
|
|
|
|
expectValues stateForHighlight(presenter, highlight), {
|
|
flashClass: 'b'
|
|
flashDuration: 500
|
|
flashCount: 1
|
|
}
|
|
|
|
expectStateUpdate presenter, -> highlight.flash('c', 600)
|
|
|
|
expectValues stateForHighlight(presenter, highlight), {
|
|
flashClass: 'c'
|
|
flashDuration: 600
|
|
flashCount: 2
|
|
}
|
|
|
|
describe ".lineNumbers", ->
|
|
lineNumberStateForScreenRow = (presenter, screenRow) ->
|
|
presenter.state.lineNumbers[screenRow - presenter.getStartRow()]
|
|
|
|
it "contains states for line numbers that are visible on screen, plus and minus the overdraw margin", ->
|
|
editor.foldBufferRow(4)
|
|
editor.setSoftWrapped(true)
|
|
editor.setEditorWidthInChars(50)
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 30, lineHeight: 10, lineOverdrawMargin: 1)
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 1)).toBeUndefined()
|
|
expectValues lineNumberStateForScreenRow(presenter, 2), {bufferRow: 2, softWrapped: false, top: 2 * 10}
|
|
expectValues lineNumberStateForScreenRow(presenter, 3), {bufferRow: 3, softWrapped: false, top: 3 * 10}
|
|
expectValues lineNumberStateForScreenRow(presenter, 4), {bufferRow: 3, softWrapped: true, top: 4 * 10}
|
|
expectValues lineNumberStateForScreenRow(presenter, 5), {bufferRow: 4, softWrapped: false, top: 5 * 10}
|
|
expectValues lineNumberStateForScreenRow(presenter, 6), {bufferRow: 7, softWrapped: false, top: 6 * 10}
|
|
expectValues lineNumberStateForScreenRow(presenter, 7), {bufferRow: 8, softWrapped: false, top: 7 * 10}
|
|
expect(lineNumberStateForScreenRow(presenter, 8)).toBeUndefined()
|
|
|
|
it "includes states for all line numbers if no external client height is assigned", ->
|
|
presenter = new TextEditorPresenter(model: editor, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 1)
|
|
expect(lineNumberStateForScreenRow(presenter, 0)).toBeDefined()
|
|
expect(lineNumberStateForScreenRow(presenter, 12)).toBeDefined()
|
|
|
|
it "updates when ::scrollTop changes", ->
|
|
editor.foldBufferRow(4)
|
|
editor.setSoftWrapped(true)
|
|
editor.setEditorWidthInChars(50)
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 30, lineHeight: 10, lineOverdrawMargin: 1)
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 1)).toBeUndefined()
|
|
expectValues lineNumberStateForScreenRow(presenter, 2), {bufferRow: 2}
|
|
expectValues lineNumberStateForScreenRow(presenter, 7), {bufferRow: 8}
|
|
expect(lineNumberStateForScreenRow(presenter, 8)).toBeUndefined()
|
|
|
|
expectStateUpdate presenter, -> presenter.setScrollTop(20)
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 0)).toBeUndefined()
|
|
expectValues lineNumberStateForScreenRow(presenter, 1), {bufferRow: 1}
|
|
expectValues lineNumberStateForScreenRow(presenter, 6), {bufferRow: 7}
|
|
expect(lineNumberStateForScreenRow(presenter, 7)).toBeUndefined()
|
|
|
|
it "updates when ::clientHeight changes", ->
|
|
editor.foldBufferRow(4)
|
|
editor.setSoftWrapped(true)
|
|
editor.setEditorWidthInChars(50)
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 30, lineHeight: 10, lineOverdrawMargin: 1)
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 1)).toBeUndefined()
|
|
expectValues lineNumberStateForScreenRow(presenter, 2), {bufferRow: 2}
|
|
expectValues lineNumberStateForScreenRow(presenter, 7), {bufferRow: 8}
|
|
expect(lineNumberStateForScreenRow(presenter, 8)).toBeUndefined()
|
|
|
|
expectStateUpdate presenter, -> presenter.setClientHeight(35)
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 0)).toBeUndefined()
|
|
expectValues lineNumberStateForScreenRow(presenter, 2), {bufferRow: 2}
|
|
expectValues lineNumberStateForScreenRow(presenter, 8), {bufferRow: 8}
|
|
expect(lineNumberStateForScreenRow(presenter, 9)).toBeUndefined()
|
|
|
|
it "updates when ::lineHeight changes", ->
|
|
editor.foldBufferRow(4)
|
|
editor.setSoftWrapped(true)
|
|
editor.setEditorWidthInChars(50)
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 25, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
|
|
expectValues lineNumberStateForScreenRow(presenter, 0), {bufferRow: 0}
|
|
expectValues lineNumberStateForScreenRow(presenter, 3), {bufferRow: 3}
|
|
expect(lineNumberStateForScreenRow(presenter, 4)).toBeUndefined()
|
|
|
|
expectStateUpdate presenter, -> presenter.setLineHeight(5)
|
|
|
|
expectValues lineNumberStateForScreenRow(presenter, 0), {bufferRow: 0}
|
|
expectValues lineNumberStateForScreenRow(presenter, 5), {bufferRow: 4}
|
|
expect(lineNumberStateForScreenRow(presenter, 6)).toBeUndefined()
|
|
|
|
it "updates when the editor's content changes", ->
|
|
editor.foldBufferRow(4)
|
|
editor.setSoftWrapped(true)
|
|
editor.setEditorWidthInChars(50)
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 35, scrollTop: 30, lineHeight: 10, lineOverdrawMargin: 0)
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 2)).toBeUndefined()
|
|
expectValues lineNumberStateForScreenRow(presenter, 3), {bufferRow: 3}
|
|
expectValues lineNumberStateForScreenRow(presenter, 4), {bufferRow: 3}
|
|
expectValues lineNumberStateForScreenRow(presenter, 5), {bufferRow: 4}
|
|
expectValues lineNumberStateForScreenRow(presenter, 6), {bufferRow: 7}
|
|
expectValues lineNumberStateForScreenRow(presenter, 7), {bufferRow: 8}
|
|
expect(lineNumberStateForScreenRow(presenter, 8)).toBeUndefined()
|
|
|
|
expectStateUpdate presenter, ->
|
|
editor.getBuffer().insert([3, Infinity], new Array(25).join("x "))
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 2)).toBeUndefined()
|
|
expectValues lineNumberStateForScreenRow(presenter, 3), {bufferRow: 3}
|
|
expectValues lineNumberStateForScreenRow(presenter, 4), {bufferRow: 3}
|
|
expectValues lineNumberStateForScreenRow(presenter, 5), {bufferRow: 3}
|
|
expectValues lineNumberStateForScreenRow(presenter, 6), {bufferRow: 4}
|
|
expectValues lineNumberStateForScreenRow(presenter, 7), {bufferRow: 7}
|
|
expect(lineNumberStateForScreenRow(presenter, 8)).toBeUndefined()
|
|
|
|
describe ".decorationClasses", ->
|
|
it "adds decoration classes to the relevant line number state objects, both initially and when decorations change", ->
|
|
marker1 = editor.markBufferRange([[4, 0], [6, 2]], invalidate: 'touch')
|
|
decoration1 = editor.decorateMarker(marker1, type: 'line-number', class: 'a')
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker2 = editor.markBufferRange([[4, 0], [6, 2]], invalidate: 'touch')
|
|
decoration2 = editor.decorateMarker(marker2, type: 'line-number', class: 'b')
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 3).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineNumberStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> editor.getBuffer().insert([5, 0], 'x')
|
|
expect(marker1.isValid()).toBe false
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> editor.undo()
|
|
expect(lineNumberStateForScreenRow(presenter, 3).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineNumberStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> marker1.setBufferRange([[2, 0], [4, 2]])
|
|
expect(lineNumberStateForScreenRow(presenter, 1).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 2).decorationClasses).toEqual ['a']
|
|
expect(lineNumberStateForScreenRow(presenter, 3).decorationClasses).toEqual ['a']
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a', 'b']
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toEqual ['b']
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toEqual ['b']
|
|
expect(lineNumberStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> decoration1.destroy()
|
|
expect(lineNumberStateForScreenRow(presenter, 2).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 3).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toEqual ['b']
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toEqual ['b']
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toEqual ['b']
|
|
expect(lineNumberStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> marker2.destroy()
|
|
expect(lineNumberStateForScreenRow(presenter, 2).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 3).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 7).decorationClasses).toBeNull()
|
|
|
|
it "honors the 'onlyEmpty' option on line decorations", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker = editor.markBufferRange([[4, 0], [6, 1]])
|
|
decoration = editor.decorateMarker(marker, type: 'line-number', class: 'a', onlyEmpty: true)
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> marker.clearTail()
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toBeNull()
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toEqual ['a']
|
|
|
|
it "honors the 'onlyNonEmpty' option on line decorations", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker = editor.markBufferRange([[4, 0], [6, 2]])
|
|
decoration = editor.decorateMarker(marker, type: 'line-number', class: 'a', onlyNonEmpty: true)
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a']
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toEqual ['a']
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toEqual ['a']
|
|
|
|
expectStateUpdate presenter, -> marker.clearTail()
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
|
|
it "does not decorate the last line of a non-empty line decoration range if it ends at column 0", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker = editor.markBufferRange([[4, 0], [6, 0]])
|
|
decoration = editor.decorateMarker(marker, type: 'line-number', class: 'a')
|
|
|
|
expect(lineNumberStateForScreenRow(presenter, 4).decorationClasses).toEqual ['a']
|
|
expect(lineNumberStateForScreenRow(presenter, 5).decorationClasses).toEqual ['a']
|
|
expect(lineNumberStateForScreenRow(presenter, 6).decorationClasses).toBeNull()
|
|
|
|
it "does not apply line decorations to mini editors", ->
|
|
editor.setMini(true)
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 10, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
marker = editor.markBufferRange([[0, 0], [0, 0]])
|
|
decoration = editor.decorateMarker(marker, type: 'line-number', class: 'a')
|
|
expect(lineNumberStateForScreenRow(presenter, 0).decorationClasses).toBeNull()
|
|
|
|
expectStateUpdate presenter, -> editor.setMini(false)
|
|
expect(lineNumberStateForScreenRow(presenter, 0).decorationClasses).toEqual ['cursor-line', 'cursor-line-no-selection', 'a']
|
|
|
|
expectStateUpdate presenter, -> editor.setMini(true)
|
|
expect(lineNumberStateForScreenRow(presenter, 0).decorationClasses).toBeNull()
|
|
|
|
describe ".foldable", ->
|
|
it "marks line numbers at the start of a foldable region as foldable", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
expect(lineNumberStateForScreenRow(presenter, 0).foldable).toBe true
|
|
expect(lineNumberStateForScreenRow(presenter, 1).foldable).toBe true
|
|
expect(lineNumberStateForScreenRow(presenter, 2).foldable).toBe false
|
|
expect(lineNumberStateForScreenRow(presenter, 3).foldable).toBe false
|
|
expect(lineNumberStateForScreenRow(presenter, 4).foldable).toBe true
|
|
expect(lineNumberStateForScreenRow(presenter, 5).foldable).toBe false
|
|
|
|
it "updates the foldable class on the correct line numbers when the foldable positions change", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
editor.getBuffer().insert([0, 0], '\n')
|
|
expect(lineNumberStateForScreenRow(presenter, 0).foldable).toBe false
|
|
expect(lineNumberStateForScreenRow(presenter, 1).foldable).toBe true
|
|
expect(lineNumberStateForScreenRow(presenter, 2).foldable).toBe true
|
|
expect(lineNumberStateForScreenRow(presenter, 3).foldable).toBe false
|
|
expect(lineNumberStateForScreenRow(presenter, 4).foldable).toBe false
|
|
expect(lineNumberStateForScreenRow(presenter, 5).foldable).toBe true
|
|
expect(lineNumberStateForScreenRow(presenter, 6).foldable).toBe false
|
|
|
|
it "updates the foldable class on a line number that becomes foldable", ->
|
|
presenter = new TextEditorPresenter(model: editor, clientHeight: 130, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 0)
|
|
expect(lineNumberStateForScreenRow(presenter, 11).foldable).toBe false
|
|
|
|
editor.getBuffer().insert([11, 44], '\n fold me')
|
|
expect(lineNumberStateForScreenRow(presenter, 11).foldable).toBe true
|
|
|
|
editor.undo()
|
|
expect(lineNumberStateForScreenRow(presenter, 11).foldable).toBe false
|