",
+ scopes: ['text.html.ruby']
+ })
+
+ await atom.packages.activatePackage('language-html')
+ fullyTokenize(tokenizedBuffer)
+ expect(tokenizedBuffer.tokenizedLines[0].tokens[0]).toEqual({
+ value: '<',
+ scopes: ['text.html.ruby', 'meta.tag.block.div.html', 'punctuation.definition.tag.begin.html']
+ })
+ })
+ })
+
+ describe('when the buffer is configured with the null grammar', () => {
+ it('does not actually tokenize using the grammar', () => {
+ spyOn(NullGrammar, 'tokenizeLine').andCallThrough()
+ buffer = atom.project.bufferForPathSync('sample.will-use-the-null-grammar')
+ buffer.setText('a\nb\nc')
+ tokenizedBuffer = new TokenizedBuffer({buffer, tabLength: 2})
+ const tokenizeCallback = jasmine.createSpy('onDidTokenize')
+ tokenizedBuffer.onDidTokenize(tokenizeCallback)
+
+ expect(tokenizedBuffer.tokenizedLines[0]).toBeUndefined()
+ expect(tokenizedBuffer.tokenizedLines[1]).toBeUndefined()
+ expect(tokenizedBuffer.tokenizedLines[2]).toBeUndefined()
+ expect(tokenizeCallback.callCount).toBe(0)
+ expect(NullGrammar.tokenizeLine).not.toHaveBeenCalled()
+
+ fullyTokenize(tokenizedBuffer)
+ expect(tokenizedBuffer.tokenizedLines[0]).toBeUndefined()
+ expect(tokenizedBuffer.tokenizedLines[1]).toBeUndefined()
+ expect(tokenizedBuffer.tokenizedLines[2]).toBeUndefined()
+ expect(tokenizeCallback.callCount).toBe(0)
+ expect(NullGrammar.tokenizeLine).not.toHaveBeenCalled()
+ })
+ })
+ })
+
+ describe('.tokenForPosition(position)', () => {
+ afterEach(() => {
+ tokenizedBuffer.destroy()
+ buffer.release()
+ })
+
+ it('returns the correct token (regression)', () => {
+ buffer = atom.project.bufferForPathSync('sample.js')
+ tokenizedBuffer = new TokenizedBuffer({buffer, grammar: atom.grammars.grammarForScopeName('source.js'), tabLength: 2})
+ fullyTokenize(tokenizedBuffer)
+ expect(tokenizedBuffer.tokenForPosition([1, 0]).scopes).toEqual(['source.js'])
+ expect(tokenizedBuffer.tokenForPosition([1, 1]).scopes).toEqual(['source.js'])
+ expect(tokenizedBuffer.tokenForPosition([1, 2]).scopes).toEqual(['source.js', 'storage.type.var.js'])
+ })
+ })
+
+ describe('.bufferRangeForScopeAtPosition(selector, position)', () => {
+ beforeEach(() => {
+ buffer = atom.project.bufferForPathSync('sample.js')
+ tokenizedBuffer = new TokenizedBuffer({buffer, grammar: atom.grammars.grammarForScopeName('source.js'), tabLength: 2})
+ fullyTokenize(tokenizedBuffer)
+ })
+
+ describe('when the selector does not match the token at the position', () =>
+ it('returns a falsy value', () => expect(tokenizedBuffer.bufferRangeForScopeAtPosition('.bogus', [0, 1])).toBeUndefined())
+ )
+
+ describe('when the selector matches a single token at the position', () => {
+ it('returns the range covered by the token', () => {
+ expect(tokenizedBuffer.bufferRangeForScopeAtPosition('.storage.type.var.js', [0, 1])).toEqual([[0, 0], [0, 3]])
+ expect(tokenizedBuffer.bufferRangeForScopeAtPosition('.storage.type.var.js', [0, 3])).toEqual([[0, 0], [0, 3]])
+ })
+ })
+
+ describe('when the selector matches a run of multiple tokens at the position', () => {
+ it('returns the range covered by all contiguous tokens (within a single line)', () => {
+ expect(tokenizedBuffer.bufferRangeForScopeAtPosition('.function', [1, 18])).toEqual([[1, 6], [1, 28]])
+ })
+ })
+ })
+
+ describe('.tokenizedLineForRow(row)', () => {
+ it("returns the tokenized line for a row, or a placeholder line if it hasn't been tokenized yet", () => {
+ buffer = atom.project.bufferForPathSync('sample.js')
+ const grammar = atom.grammars.grammarForScopeName('source.js')
+ tokenizedBuffer = new TokenizedBuffer({buffer, grammar, tabLength: 2})
+ const line0 = buffer.lineForRow(0)
+
+ const jsScopeStartId = grammar.startIdForScope(grammar.scopeName)
+ const jsScopeEndId = grammar.endIdForScope(grammar.scopeName)
+ startTokenizing(tokenizedBuffer)
+ expect(tokenizedBuffer.tokenizedLines[0]).toBeUndefined()
+ expect(tokenizedBuffer.tokenizedLineForRow(0).text).toBe(line0)
+ expect(tokenizedBuffer.tokenizedLineForRow(0).tags).toEqual([jsScopeStartId, line0.length, jsScopeEndId])
+ advanceClock(1)
+ expect(tokenizedBuffer.tokenizedLines[0]).not.toBeUndefined()
+ expect(tokenizedBuffer.tokenizedLineForRow(0).text).toBe(line0)
+ expect(tokenizedBuffer.tokenizedLineForRow(0).tags).not.toEqual([jsScopeStartId, line0.length, jsScopeEndId])
+
+ const nullScopeStartId = NullGrammar.startIdForScope(NullGrammar.scopeName)
+ const nullScopeEndId = NullGrammar.endIdForScope(NullGrammar.scopeName)
+ tokenizedBuffer.setGrammar(NullGrammar)
+ startTokenizing(tokenizedBuffer)
+ expect(tokenizedBuffer.tokenizedLines[0]).toBeUndefined()
+ expect(tokenizedBuffer.tokenizedLineForRow(0).text).toBe(line0)
+ expect(tokenizedBuffer.tokenizedLineForRow(0).tags).toEqual([nullScopeStartId, line0.length, nullScopeEndId])
+ advanceClock(1)
+ expect(tokenizedBuffer.tokenizedLineForRow(0).text).toBe(line0)
+ expect(tokenizedBuffer.tokenizedLineForRow(0).tags).toEqual([nullScopeStartId, line0.length, nullScopeEndId])
+ })
+
+ it('returns undefined if the requested row is outside the buffer range', () => {
+ buffer = atom.project.bufferForPathSync('sample.js')
+ const grammar = atom.grammars.grammarForScopeName('source.js')
+ tokenizedBuffer = new TokenizedBuffer({buffer, grammar, tabLength: 2})
+ fullyTokenize(tokenizedBuffer)
+ expect(tokenizedBuffer.tokenizedLineForRow(999)).toBeUndefined()
+ })
+ })
+
+ describe('text decoration layer API', () => {
+ describe('iterator', () => {
+ it('iterates over the syntactic scope boundaries', () => {
+ buffer = new TextBuffer({text: 'var foo = 1 /*\nhello*/var bar = 2\n'})
+ tokenizedBuffer = new TokenizedBuffer({buffer, grammar: atom.grammars.grammarForScopeName('source.js'), tabLength: 2})
+ fullyTokenize(tokenizedBuffer)
+
+ const iterator = tokenizedBuffer.buildIterator()
+ iterator.seek(Point(0, 0))
+
+ const expectedBoundaries = [
+ {position: Point(0, 0), closeTags: [], openTags: ['syntax--source syntax--js', 'syntax--storage syntax--type syntax--var syntax--js']},
+ {position: Point(0, 3), closeTags: ['syntax--storage syntax--type syntax--var syntax--js'], openTags: []},
+ {position: Point(0, 8), closeTags: [], openTags: ['syntax--keyword syntax--operator syntax--assignment syntax--js']},
+ {position: Point(0, 9), closeTags: ['syntax--keyword syntax--operator syntax--assignment syntax--js'], openTags: []},
+ {position: Point(0, 10), closeTags: [], openTags: ['syntax--constant syntax--numeric syntax--decimal syntax--js']},
+ {position: Point(0, 11), closeTags: ['syntax--constant syntax--numeric syntax--decimal syntax--js'], openTags: []},
+ {position: Point(0, 12), closeTags: [], openTags: ['syntax--comment syntax--block syntax--js', 'syntax--punctuation syntax--definition syntax--comment syntax--begin syntax--js']},
+ {position: Point(0, 14), closeTags: ['syntax--punctuation syntax--definition syntax--comment syntax--begin syntax--js'], openTags: []},
+ {position: Point(1, 5), closeTags: [], openTags: ['syntax--punctuation syntax--definition syntax--comment syntax--end syntax--js']},
+ {position: Point(1, 7), closeTags: ['syntax--punctuation syntax--definition syntax--comment syntax--end syntax--js', 'syntax--comment syntax--block syntax--js'], openTags: ['syntax--storage syntax--type syntax--var syntax--js']},
+ {position: Point(1, 10), closeTags: ['syntax--storage syntax--type syntax--var syntax--js'], openTags: []},
+ {position: Point(1, 15), closeTags: [], openTags: ['syntax--keyword syntax--operator syntax--assignment syntax--js']},
+ {position: Point(1, 16), closeTags: ['syntax--keyword syntax--operator syntax--assignment syntax--js'], openTags: []},
+ {position: Point(1, 17), closeTags: [], openTags: ['syntax--constant syntax--numeric syntax--decimal syntax--js']},
+ {position: Point(1, 18), closeTags: ['syntax--constant syntax--numeric syntax--decimal syntax--js'], openTags: []}
+ ]
+
+ while (true) {
+ const boundary = {
+ position: iterator.getPosition(),
+ closeTags: iterator.getCloseScopeIds().map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId)),
+ openTags: iterator.getOpenScopeIds().map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId))
+ }
+
+ expect(boundary).toEqual(expectedBoundaries.shift())
+ if (!iterator.moveToSuccessor()) { break }
+ }
+
+ expect(iterator.seek(Point(0, 1)).map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId))).toEqual([
+ 'syntax--source syntax--js',
+ 'syntax--storage syntax--type syntax--var syntax--js'
+ ])
+ expect(iterator.getPosition()).toEqual(Point(0, 3))
+ expect(iterator.seek(Point(0, 8)).map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId))).toEqual([
+ 'syntax--source syntax--js'
+ ])
+ expect(iterator.getPosition()).toEqual(Point(0, 8))
+ expect(iterator.seek(Point(1, 0)).map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId))).toEqual([
+ 'syntax--source syntax--js',
+ 'syntax--comment syntax--block syntax--js'
+ ])
+ expect(iterator.getPosition()).toEqual(Point(1, 0))
+ expect(iterator.seek(Point(1, 18)).map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId))).toEqual([
+ 'syntax--source syntax--js',
+ 'syntax--constant syntax--numeric syntax--decimal syntax--js'
+ ])
+ expect(iterator.getPosition()).toEqual(Point(1, 18))
+
+ expect(iterator.seek(Point(2, 0)).map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId))).toEqual([
+ 'syntax--source syntax--js'
+ ])
+ iterator.moveToSuccessor()
+ }) // ensure we don't infinitely loop (regression test)
+
+ it('does not report columns beyond the length of the line', async () => {
+ await atom.packages.activatePackage('language-coffee-script')
+
+ buffer = new TextBuffer({text: '# hello\n# world'})
+ tokenizedBuffer = new TokenizedBuffer({buffer, grammar: atom.grammars.grammarForScopeName('source.coffee'), tabLength: 2})
+ fullyTokenize(tokenizedBuffer)
+
+ const iterator = tokenizedBuffer.buildIterator()
+ iterator.seek(Point(0, 0))
+ iterator.moveToSuccessor()
+ iterator.moveToSuccessor()
+ expect(iterator.getPosition().column).toBe(7)
+
+ iterator.moveToSuccessor()
+ expect(iterator.getPosition().column).toBe(0)
+
+ iterator.seek(Point(0, 7))
+ expect(iterator.getPosition().column).toBe(7)
+
+ iterator.seek(Point(0, 8))
+ expect(iterator.getPosition().column).toBe(7)
+ })
+
+ it('correctly terminates scopes at the beginning of the line (regression)', () => {
+ const grammar = atom.grammars.createGrammar('test', {
+ 'scopeName': 'text.broken',
+ 'name': 'Broken grammar',
+ 'patterns': [
+ {'begin': 'start', 'end': '(?=end)', 'name': 'blue.broken'},
+ {'match': '.', 'name': 'yellow.broken'}
+ ]
+ })
+
+ buffer = new TextBuffer({text: 'start x\nend x\nx'})
+ tokenizedBuffer = new TokenizedBuffer({buffer, grammar, tabLength: 2})
+ fullyTokenize(tokenizedBuffer)
+
+ const iterator = tokenizedBuffer.buildIterator()
+ iterator.seek(Point(1, 0))
+
+ expect(iterator.getPosition()).toEqual([1, 0])
+ expect(iterator.getCloseScopeIds().map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId))).toEqual(['syntax--blue syntax--broken'])
+ expect(iterator.getOpenScopeIds().map(scopeId => tokenizedBuffer.classNameForScopeId(scopeId))).toEqual(['syntax--yellow syntax--broken'])
+ })
+ })
+ })
+
+ describe('.suggestedIndentForBufferRow', () => {
+ let editor
+
+ describe('javascript', () => {
+ beforeEach(async () => {
+ editor = await atom.workspace.open('sample.js', {autoIndent: false})
+ await atom.packages.activatePackage('language-javascript')
+ })
+
+ it('bases indentation off of the previous non-blank line', () => {
+ expect(editor.suggestedIndentForBufferRow(0)).toBe(0)
+ expect(editor.suggestedIndentForBufferRow(1)).toBe(1)
+ expect(editor.suggestedIndentForBufferRow(2)).toBe(2)
+ expect(editor.suggestedIndentForBufferRow(5)).toBe(3)
+ expect(editor.suggestedIndentForBufferRow(7)).toBe(2)
+ expect(editor.suggestedIndentForBufferRow(9)).toBe(1)
+ expect(editor.suggestedIndentForBufferRow(11)).toBe(1)
+ })
+
+ it('does not take invisibles into account', () => {
+ editor.update({showInvisibles: true})
+ expect(editor.suggestedIndentForBufferRow(0)).toBe(0)
+ expect(editor.suggestedIndentForBufferRow(1)).toBe(1)
+ expect(editor.suggestedIndentForBufferRow(2)).toBe(2)
+ expect(editor.suggestedIndentForBufferRow(5)).toBe(3)
+ expect(editor.suggestedIndentForBufferRow(7)).toBe(2)
+ expect(editor.suggestedIndentForBufferRow(9)).toBe(1)
+ expect(editor.suggestedIndentForBufferRow(11)).toBe(1)
+ })
+ })
+
+ describe('css', () => {
+ beforeEach(async () => {
+ editor = await atom.workspace.open('css.css', {autoIndent: true})
+ await atom.packages.activatePackage('language-source')
+ await atom.packages.activatePackage('language-css')
+ })
+
+ it('does not return negative values (regression)', () => {
+ editor.setText('.test {\npadding: 0;\n}')
+ expect(editor.suggestedIndentForBufferRow(2)).toBe(0)
+ })
+ })
+ })
+
+ describe('.isFoldableAtRow(row)', () => {
+ beforeEach(() => {
+ buffer = atom.project.bufferForPathSync('sample.js')
+ buffer.insert([10, 0], ' // multi-line\n // comment\n // block\n')
+ buffer.insert([0, 0], '// multi-line\n// comment\n// block\n')
+ tokenizedBuffer = new TokenizedBuffer({buffer, grammar: atom.grammars.grammarForScopeName('source.js'), tabLength: 2})
+ fullyTokenize(tokenizedBuffer)
+ })
+
+ it('includes the first line of multi-line comments', () => {
+ expect(tokenizedBuffer.isFoldableAtRow(0)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(1)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(2)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(3)).toBe(true) // because of indent
+ expect(tokenizedBuffer.isFoldableAtRow(13)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(14)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(15)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(16)).toBe(false)
+
+ buffer.insert([0, Infinity], '\n')
+
+ expect(tokenizedBuffer.isFoldableAtRow(0)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(1)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(2)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(3)).toBe(false)
+
+ buffer.undo()
+
+ expect(tokenizedBuffer.isFoldableAtRow(0)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(1)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(2)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(3)).toBe(true)
+ }) // because of indent
+
+ it('includes non-comment lines that precede an increase in indentation', () => {
+ buffer.insert([2, 0], ' ') // commented lines preceding an indent aren't foldable
+
+ expect(tokenizedBuffer.isFoldableAtRow(1)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(2)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(3)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(4)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(5)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(6)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(7)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(8)).toBe(false)
+
+ buffer.insert([7, 0], ' ')
+
+ expect(tokenizedBuffer.isFoldableAtRow(6)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(7)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(8)).toBe(false)
+
+ buffer.undo()
+
+ expect(tokenizedBuffer.isFoldableAtRow(6)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(7)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(8)).toBe(false)
+
+ buffer.insert([7, 0], ' \n x\n')
+
+ expect(tokenizedBuffer.isFoldableAtRow(6)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(7)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(8)).toBe(false)
+
+ buffer.insert([9, 0], ' ')
+
+ expect(tokenizedBuffer.isFoldableAtRow(6)).toBe(true)
+ expect(tokenizedBuffer.isFoldableAtRow(7)).toBe(false)
+ expect(tokenizedBuffer.isFoldableAtRow(8)).toBe(false)
+ })
+ })
+
+ describe('.getFoldableRangesAtIndentLevel', () => {
+ it('returns the ranges that can be folded at the given indent level', () => {
+ buffer = new TextBuffer(dedent `
+ if (a) {
+ b();
+ if (c) {
+ d()
+ if (e) {
+ f()
+ }
+ g()
+ }
+ h()
+ }
+ i()
+ if (j) {
+ k()
+ }
+ `)
+
+ tokenizedBuffer = new TokenizedBuffer({buffer})
+
+ expect(simulateFold(tokenizedBuffer.getFoldableRangesAtIndentLevel(0, 2))).toBe(dedent `
+ if (a) {⋯
+ }
+ i()
+ if (j) {⋯
+ }
+ `)
+
+ expect(simulateFold(tokenizedBuffer.getFoldableRangesAtIndentLevel(1, 2))).toBe(dedent `
+ if (a) {
+ b();
+ if (c) {⋯
+ }
+ h()
+ }
+ i()
+ if (j) {
+ k()
+ }
+ `)
+
+ expect(simulateFold(tokenizedBuffer.getFoldableRangesAtIndentLevel(2, 2))).toBe(dedent `
+ if (a) {
+ b();
+ if (c) {
+ d()
+ if (e) {⋯
+ }
+ g()
+ }
+ h()
+ }
+ i()
+ if (j) {
+ k()
+ }
+ `)
+ })
+ })
+
+ describe('.getFoldableRanges', () => {
+ it('returns the ranges that can be folded', () => {
+ buffer = new TextBuffer(dedent `
+ if (a) {
+ b();
+ if (c) {
+ d()
+ if (e) {
+ f()
+ }
+ g()
+ }
+ h()
+ }
+ i()
+ if (j) {
+ k()
+ }
+ `)
+
+ tokenizedBuffer = new TokenizedBuffer({buffer})
+
+ expect(tokenizedBuffer.getFoldableRanges(2).map(r => r.toString())).toEqual([
+ ...tokenizedBuffer.getFoldableRangesAtIndentLevel(0, 2),
+ ...tokenizedBuffer.getFoldableRangesAtIndentLevel(1, 2),
+ ...tokenizedBuffer.getFoldableRangesAtIndentLevel(2, 2),
+ ].sort((a, b) => (a.start.row - b.start.row) || (a.end.row - b.end.row)).map(r => r.toString()))
+ })
+ })
+
+ describe('.getFoldableRangeContainingPoint', () => {
+ it('returns the range for the smallest fold that contains the given range', () => {
+ buffer = new TextBuffer(dedent `
+ if (a) {
+ b();
+ if (c) {
+ d()
+ if (e) {
+ f()
+ }
+ g()
+ }
+ h()
+ }
+ i()
+ if (j) {
+ k()
+ }
+ `)
+
+ tokenizedBuffer = new TokenizedBuffer({buffer})
+
+ expect(tokenizedBuffer.getFoldableRangeContainingPoint(Point(0, 5), 2)).toBeNull()
+
+ let range = tokenizedBuffer.getFoldableRangeContainingPoint(Point(0, 10), 2)
+ expect(simulateFold([range])).toBe(dedent `
+ if (a) {⋯
+ }
+ i()
+ if (j) {
+ k()
+ }
+ `)
+
+ range = tokenizedBuffer.getFoldableRangeContainingPoint(Point(1, Infinity), 2)
+ expect(simulateFold([range])).toBe(dedent `
+ if (a) {⋯
+ }
+ i()
+ if (j) {
+ k()
+ }
+ `)
+
+ range = tokenizedBuffer.getFoldableRangeContainingPoint(Point(2, 20), 2)
+ expect(simulateFold([range])).toBe(dedent `
+ if (a) {
+ b();
+ if (c) {⋯
+ }
+ h()
+ }
+ i()
+ if (j) {
+ k()
+ }
+ `)
+ })
+
+ it('works for coffee-script', async () => {
+ const editor = await atom.workspace.open('coffee.coffee')
+ await atom.packages.activatePackage('language-coffee-script')
+ buffer = editor.buffer
+ tokenizedBuffer = editor.tokenizedBuffer
+
+ expect(tokenizedBuffer.getFoldableRangeContainingPoint(Point(0, Infinity))).toEqual([[0, Infinity], [20, Infinity]])
+ expect(tokenizedBuffer.getFoldableRangeContainingPoint(Point(1, Infinity))).toEqual([[1, Infinity], [17, Infinity]])
+ expect(tokenizedBuffer.getFoldableRangeContainingPoint(Point(2, Infinity))).toEqual([[1, Infinity], [17, Infinity]])
+ expect(tokenizedBuffer.getFoldableRangeContainingPoint(Point(19, Infinity))).toEqual([[19, Infinity], [20, Infinity]])
+ })
+
+ it('works for javascript', async () => {
+ const editor = await atom.workspace.open('sample.js')
+ await atom.packages.activatePackage('language-javascript')
+ buffer = editor.buffer
+ tokenizedBuffer = editor.tokenizedBuffer
+
+ expect(editor.tokenizedBuffer.getFoldableRangeContainingPoint(Point(0, Infinity))).toEqual([[0, Infinity], [12, Infinity]])
+ expect(editor.tokenizedBuffer.getFoldableRangeContainingPoint(Point(1, Infinity))).toEqual([[1, Infinity], [9, Infinity]])
+ expect(editor.tokenizedBuffer.getFoldableRangeContainingPoint(Point(2, Infinity))).toEqual([[1, Infinity], [9, Infinity]])
+ expect(editor.tokenizedBuffer.getFoldableRangeContainingPoint(Point(4, Infinity))).toEqual([[4, Infinity], [7, Infinity]])
+ })
+ })
+
+ function simulateFold (ranges) {
+ buffer.transact(() => {
+ for (const range of ranges.reverse()) {
+ buffer.setTextInRange(range, '⋯')
+ }
+ })
+ let text = buffer.getText()
+ buffer.undo()
+ return text
+ }
+})
diff --git a/spec/tooltip-manager-spec.coffee b/spec/tooltip-manager-spec.coffee
index 35e563dae..95182853e 100644
--- a/spec/tooltip-manager-spec.coffee
+++ b/spec/tooltip-manager-spec.coffee
@@ -204,7 +204,7 @@ describe "TooltipManager", ->
disposable2.dispose()
expect(manager.findTooltips(element).length).toBe(0)
- it "lets us hide tooltips programatically", ->
+ it "lets us hide tooltips programmatically", ->
disposable = manager.add element, title: "Title"
hover element, ->
expect(document.body.querySelector(".tooltip")).not.toBeNull()
diff --git a/spec/uri-handler-registry-spec.js b/spec/uri-handler-registry-spec.js
new file mode 100644
index 000000000..d2da93087
--- /dev/null
+++ b/spec/uri-handler-registry-spec.js
@@ -0,0 +1,75 @@
+/** @babel */
+
+import url from 'url'
+
+import {it} from './async-spec-helpers'
+
+import URIHandlerRegistry from '../src/uri-handler-registry'
+
+describe('URIHandlerRegistry', () => {
+ let registry
+
+ beforeEach(() => {
+ registry = new URIHandlerRegistry(5)
+ })
+
+ it('handles URIs on a per-host basis', () => {
+ const testPackageSpy = jasmine.createSpy()
+ const otherPackageSpy = jasmine.createSpy()
+ registry.registerHostHandler('test-package', testPackageSpy)
+ registry.registerHostHandler('other-package', otherPackageSpy)
+
+ registry.handleURI('atom://yet-another-package/path')
+ expect(testPackageSpy).not.toHaveBeenCalled()
+ expect(otherPackageSpy).not.toHaveBeenCalled()
+
+ registry.handleURI('atom://test-package/path')
+ expect(testPackageSpy).toHaveBeenCalledWith(url.parse('atom://test-package/path', true), 'atom://test-package/path')
+ expect(otherPackageSpy).not.toHaveBeenCalled()
+
+ registry.handleURI('atom://other-package/path')
+ expect(otherPackageSpy).toHaveBeenCalledWith(url.parse('atom://other-package/path', true), 'atom://other-package/path')
+ })
+
+ it('keeps track of the most recent URIs', () => {
+ const spy1 = jasmine.createSpy()
+ const spy2 = jasmine.createSpy()
+ const changeSpy = jasmine.createSpy()
+ registry.registerHostHandler('one', spy1)
+ registry.registerHostHandler('two', spy2)
+ registry.onHistoryChange(changeSpy)
+
+ const uris = [
+ 'atom://one/something?asdf=1',
+ 'atom://fake/nothing',
+ 'atom://two/other/stuff',
+ 'atom://one/more/thing',
+ 'atom://two/more/stuff'
+ ]
+
+ uris.forEach(u => registry.handleURI(u))
+
+ expect(changeSpy.callCount).toBe(5)
+ expect(registry.getRecentlyHandledURIs()).toEqual(uris.map((u, idx) => {
+ return {id: idx + 1, uri: u, handled: !u.match(/fake/), host: url.parse(u).host}
+ }).reverse())
+
+ registry.handleURI('atom://another/url')
+ expect(changeSpy.callCount).toBe(6)
+ const history = registry.getRecentlyHandledURIs()
+ expect(history.length).toBe(5)
+ expect(history[0].uri).toBe('atom://another/url')
+ expect(history[4].uri).toBe(uris[1])
+ })
+
+ it('refuses to handle bad URLs', () => {
+ [
+ 'atom:package/path',
+ 'atom:8080://package/path',
+ 'user:pass@atom://package/path',
+ 'smth://package/path'
+ ].forEach(uri => {
+ expect(() => registry.handleURI(uri)).toThrow()
+ })
+ })
+})
diff --git a/spec/view-registry-spec.coffee b/spec/view-registry-spec.coffee
deleted file mode 100644
index 4bae1d811..000000000
--- a/spec/view-registry-spec.coffee
+++ /dev/null
@@ -1,163 +0,0 @@
-ViewRegistry = require '../src/view-registry'
-
-describe "ViewRegistry", ->
- registry = null
-
- beforeEach ->
- registry = new ViewRegistry
-
- afterEach ->
- registry.clearDocumentRequests()
-
- describe "::getView(object)", ->
- describe "when passed a DOM node", ->
- it "returns the given DOM node", ->
- node = document.createElement('div')
- expect(registry.getView(node)).toBe node
-
- describe "when passed an object with an element property", ->
- it "returns the element property if it's an instance of HTMLElement", ->
- class TestComponent
- constructor: -> @element = document.createElement('div')
-
- component = new TestComponent
- expect(registry.getView(component)).toBe component.element
-
- describe "when passed an object with a getElement function", ->
- it "returns the return value of getElement if it's an instance of HTMLElement", ->
- class TestComponent
- getElement: ->
- @myElement ?= document.createElement('div')
-
- component = new TestComponent
- expect(registry.getView(component)).toBe component.myElement
-
- describe "when passed a model object", ->
- describe "when a view provider is registered matching the object's constructor", ->
- it "constructs a view element and assigns the model on it", ->
- class TestModel
-
- class TestModelSubclass extends TestModel
-
- class TestView
- initialize: (@model) -> this
-
- model = new TestModel
-
- registry.addViewProvider TestModel, (model) ->
- new TestView().initialize(model)
-
- view = registry.getView(model)
- expect(view instanceof TestView).toBe true
- expect(view.model).toBe model
-
- subclassModel = new TestModelSubclass
- view2 = registry.getView(subclassModel)
- expect(view2 instanceof TestView).toBe true
- expect(view2.model).toBe subclassModel
-
- describe "when a view provider is registered generically, and works with the object", ->
- it "constructs a view element and assigns the model on it", ->
- model = {a: 'b'}
-
- registry.addViewProvider (model) ->
- if model.a is 'b'
- element = document.createElement('div')
- element.className = 'test-element'
- element
-
- view = registry.getView({a: 'b'})
- expect(view.className).toBe 'test-element'
-
- expect(-> registry.getView({a: 'c'})).toThrow()
-
- describe "when no view provider is registered for the object's constructor", ->
- it "throws an exception", ->
- expect(-> registry.getView(new Object)).toThrow()
-
- describe "::addViewProvider(providerSpec)", ->
- it "returns a disposable that can be used to remove the provider", ->
- class TestModel
- class TestView
- initialize: (@model) -> this
-
- disposable = registry.addViewProvider TestModel, (model) ->
- new TestView().initialize(model)
-
- expect(registry.getView(new TestModel) instanceof TestView).toBe true
- disposable.dispose()
- expect(-> registry.getView(new TestModel)).toThrow()
-
- describe "::updateDocument(fn) and ::readDocument(fn)", ->
- frameRequests = null
-
- beforeEach ->
- frameRequests = []
- spyOn(window, 'requestAnimationFrame').andCallFake (fn) -> frameRequests.push(fn)
-
- it "performs all pending writes before all pending reads on the next animation frame", ->
- events = []
-
- registry.updateDocument -> events.push('write 1')
- registry.readDocument -> events.push('read 1')
- registry.readDocument -> events.push('read 2')
- registry.updateDocument -> events.push('write 2')
-
- expect(events).toEqual []
-
- expect(frameRequests.length).toBe 1
- frameRequests[0]()
- expect(events).toEqual ['write 1', 'write 2', 'read 1', 'read 2']
-
- frameRequests = []
- events = []
- disposable = registry.updateDocument -> events.push('write 3')
- registry.updateDocument -> events.push('write 4')
- registry.readDocument -> events.push('read 3')
-
- disposable.dispose()
-
- expect(frameRequests.length).toBe 1
- frameRequests[0]()
- expect(events).toEqual ['write 4', 'read 3']
-
- it "performs writes requested from read callbacks in the same animation frame", ->
- spyOn(window, 'setInterval').andCallFake(fakeSetInterval)
- spyOn(window, 'clearInterval').andCallFake(fakeClearInterval)
- events = []
-
- registry.updateDocument -> events.push('write 1')
- registry.readDocument ->
- registry.updateDocument -> events.push('write from read 1')
- events.push('read 1')
- registry.readDocument ->
- registry.updateDocument -> events.push('write from read 2')
- events.push('read 2')
- registry.updateDocument -> events.push('write 2')
-
- expect(frameRequests.length).toBe 1
- frameRequests[0]()
- expect(frameRequests.length).toBe 1
-
- expect(events).toEqual [
- 'write 1'
- 'write 2'
- 'read 1'
- 'read 2'
- 'write from read 1'
- 'write from read 2'
- ]
-
- describe "::getNextUpdatePromise()", ->
- it "returns a promise that resolves at the end of the next update cycle", ->
- updateCalled = false
- readCalled = false
-
- waitsFor 'getNextUpdatePromise to resolve', (done) ->
- registry.getNextUpdatePromise().then ->
- expect(updateCalled).toBe true
- expect(readCalled).toBe true
- done()
-
- registry.updateDocument -> updateCalled = true
- registry.readDocument -> readCalled = true
diff --git a/spec/view-registry-spec.js b/spec/view-registry-spec.js
new file mode 100644
index 000000000..db8b077f1
--- /dev/null
+++ b/spec/view-registry-spec.js
@@ -0,0 +1,216 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+const ViewRegistry = require('../src/view-registry')
+
+describe('ViewRegistry', () => {
+ let registry = null
+
+ beforeEach(() => {
+ registry = new ViewRegistry()
+ })
+
+ afterEach(() => {
+ registry.clearDocumentRequests()
+ })
+
+ describe('::getView(object)', () => {
+ describe('when passed a DOM node', () =>
+ it('returns the given DOM node', () => {
+ const node = document.createElement('div')
+ expect(registry.getView(node)).toBe(node)
+ })
+ )
+
+ describe('when passed an object with an element property', () =>
+ it("returns the element property if it's an instance of HTMLElement", () => {
+ class TestComponent {
+ constructor () {
+ this.element = document.createElement('div')
+ }
+ }
+
+ const component = new TestComponent()
+ expect(registry.getView(component)).toBe(component.element)
+ })
+ )
+
+ describe('when passed an object with a getElement function', () =>
+ it("returns the return value of getElement if it's an instance of HTMLElement", () => {
+ class TestComponent {
+ getElement () {
+ if (this.myElement == null) {
+ this.myElement = document.createElement('div')
+ }
+ return this.myElement
+ }
+ }
+
+ const component = new TestComponent()
+ expect(registry.getView(component)).toBe(component.myElement)
+ })
+ )
+
+ describe('when passed a model object', () => {
+ describe("when a view provider is registered matching the object's constructor", () =>
+ it('constructs a view element and assigns the model on it', () => {
+ class TestModel {}
+
+ class TestModelSubclass extends TestModel {}
+
+ class TestView {
+ initialize (model) {
+ this.model = model
+ return this
+ }
+ }
+
+ const model = new TestModel()
+
+ registry.addViewProvider(TestModel, (model) =>
+ new TestView().initialize(model)
+ )
+
+ const view = registry.getView(model)
+ expect(view instanceof TestView).toBe(true)
+ expect(view.model).toBe(model)
+
+ const subclassModel = new TestModelSubclass()
+ const view2 = registry.getView(subclassModel)
+ expect(view2 instanceof TestView).toBe(true)
+ expect(view2.model).toBe(subclassModel)
+ })
+ )
+
+ describe('when a view provider is registered generically, and works with the object', () =>
+ it('constructs a view element and assigns the model on it', () => {
+ registry.addViewProvider((model) => {
+ if (model.a === 'b') {
+ const element = document.createElement('div')
+ element.className = 'test-element'
+ return element
+ }
+ })
+
+ const view = registry.getView({a: 'b'})
+ expect(view.className).toBe('test-element')
+
+ expect(() => registry.getView({a: 'c'})).toThrow()
+ })
+ )
+
+ describe("when no view provider is registered for the object's constructor", () =>
+ it('throws an exception', () => {
+ expect(() => registry.getView({})).toThrow()
+ })
+ )
+ })
+ })
+
+ describe('::addViewProvider(providerSpec)', () =>
+ it('returns a disposable that can be used to remove the provider', () => {
+ class TestModel {}
+ class TestView {
+ initialize (model) {
+ this.model = model
+ return this
+ }
+ }
+
+ const disposable = registry.addViewProvider(TestModel, (model) =>
+ new TestView().initialize(model)
+ )
+
+ expect(registry.getView(new TestModel()) instanceof TestView).toBe(true)
+ disposable.dispose()
+ expect(() => registry.getView(new TestModel())).toThrow()
+ })
+ )
+
+ describe('::updateDocument(fn) and ::readDocument(fn)', () => {
+ let frameRequests = null
+
+ beforeEach(() => {
+ frameRequests = []
+ spyOn(window, 'requestAnimationFrame').andCallFake(fn => frameRequests.push(fn))
+ })
+
+ it('performs all pending writes before all pending reads on the next animation frame', () => {
+ let events = []
+
+ registry.updateDocument(() => events.push('write 1'))
+ registry.readDocument(() => events.push('read 1'))
+ registry.readDocument(() => events.push('read 2'))
+ registry.updateDocument(() => events.push('write 2'))
+
+ expect(events).toEqual([])
+
+ expect(frameRequests.length).toBe(1)
+ frameRequests[0]()
+ expect(events).toEqual(['write 1', 'write 2', 'read 1', 'read 2'])
+
+ frameRequests = []
+ events = []
+ const disposable = registry.updateDocument(() => events.push('write 3'))
+ registry.updateDocument(() => events.push('write 4'))
+ registry.readDocument(() => events.push('read 3'))
+
+ disposable.dispose()
+
+ expect(frameRequests.length).toBe(1)
+ frameRequests[0]()
+ expect(events).toEqual(['write 4', 'read 3'])
+ })
+
+ it('performs writes requested from read callbacks in the same animation frame', () => {
+ spyOn(window, 'setInterval').andCallFake(fakeSetInterval)
+ spyOn(window, 'clearInterval').andCallFake(fakeClearInterval)
+ const events = []
+
+ registry.updateDocument(() => events.push('write 1'))
+ registry.readDocument(() => {
+ registry.updateDocument(() => events.push('write from read 1'))
+ events.push('read 1')
+ })
+ registry.readDocument(() => {
+ registry.updateDocument(() => events.push('write from read 2'))
+ events.push('read 2')
+ })
+ registry.updateDocument(() => events.push('write 2'))
+
+ expect(frameRequests.length).toBe(1)
+ frameRequests[0]()
+ expect(frameRequests.length).toBe(1)
+
+ expect(events).toEqual([
+ 'write 1',
+ 'write 2',
+ 'read 1',
+ 'read 2',
+ 'write from read 1',
+ 'write from read 2'
+ ])
+ })
+ })
+
+ describe('::getNextUpdatePromise()', () =>
+ it('returns a promise that resolves at the end of the next update cycle', () => {
+ let updateCalled = false
+ let readCalled = false
+
+ waitsFor('getNextUpdatePromise to resolve', (done) => {
+ registry.getNextUpdatePromise().then(() => {
+ expect(updateCalled).toBe(true)
+ expect(readCalled).toBe(true)
+ done()
+ })
+
+ registry.updateDocument(() => { updateCalled = true })
+ registry.readDocument(() => { readCalled = true })
+ })
+ })
+ )
+})
diff --git a/spec/window-event-handler-spec.coffee b/spec/window-event-handler-spec.coffee
deleted file mode 100644
index 9c9f4a098..000000000
--- a/spec/window-event-handler-spec.coffee
+++ /dev/null
@@ -1,209 +0,0 @@
-KeymapManager = require 'atom-keymap'
-TextEditor = require '../src/text-editor'
-WindowEventHandler = require '../src/window-event-handler'
-{ipcRenderer} = require 'electron'
-
-describe "WindowEventHandler", ->
- [windowEventHandler] = []
-
- beforeEach ->
- atom.uninstallWindowEventHandler()
- spyOn(atom, 'hide')
- initialPath = atom.project.getPaths()[0]
- spyOn(atom, 'getLoadSettings').andCallFake ->
- loadSettings = atom.getLoadSettings.originalValue.call(atom)
- loadSettings.initialPath = initialPath
- loadSettings
- atom.project.destroy()
- windowEventHandler = new WindowEventHandler({atomEnvironment: atom, applicationDelegate: atom.applicationDelegate})
- windowEventHandler.initialize(window, document)
-
- afterEach ->
- windowEventHandler.unsubscribe()
- atom.installWindowEventHandler()
-
- describe "when the window is loaded", ->
- it "doesn't have .is-blurred on the body tag", ->
- return if process.platform is 'win32' #Win32TestFailures - can not steal focus
- expect(document.body.className).not.toMatch("is-blurred")
-
- describe "when the window is blurred", ->
- beforeEach ->
- window.dispatchEvent(new CustomEvent('blur'))
-
- afterEach ->
- document.body.classList.remove('is-blurred')
-
- it "adds the .is-blurred class on the body", ->
- expect(document.body.className).toMatch("is-blurred")
-
- describe "when the window is focused again", ->
- it "removes the .is-blurred class from the body", ->
- window.dispatchEvent(new CustomEvent('focus'))
- expect(document.body.className).not.toMatch("is-blurred")
-
- describe "window:close event", ->
- it "closes the window", ->
- spyOn(atom, 'close')
- window.dispatchEvent(new CustomEvent('window:close'))
- expect(atom.close).toHaveBeenCalled()
-
- describe "when a link is clicked", ->
- it "opens the http/https links in an external application", ->
- {shell} = require 'electron'
- spyOn(shell, 'openExternal')
-
- link = document.createElement('a')
- linkChild = document.createElement('span')
- link.appendChild(linkChild)
- link.href = 'http://github.com'
- jasmine.attachToDOM(link)
- fakeEvent = {target: linkChild, currentTarget: link, preventDefault: (->)}
-
- windowEventHandler.handleLinkClick(fakeEvent)
- expect(shell.openExternal).toHaveBeenCalled()
- expect(shell.openExternal.argsForCall[0][0]).toBe "http://github.com"
- shell.openExternal.reset()
-
- link.href = 'https://github.com'
- windowEventHandler.handleLinkClick(fakeEvent)
- expect(shell.openExternal).toHaveBeenCalled()
- expect(shell.openExternal.argsForCall[0][0]).toBe "https://github.com"
- shell.openExternal.reset()
-
- link.href = ''
- windowEventHandler.handleLinkClick(fakeEvent)
- expect(shell.openExternal).not.toHaveBeenCalled()
- shell.openExternal.reset()
-
- link.href = '#scroll-me'
- windowEventHandler.handleLinkClick(fakeEvent)
- expect(shell.openExternal).not.toHaveBeenCalled()
-
- describe "when a form is submitted", ->
- it "prevents the default so that the window's URL isn't changed", ->
- form = document.createElement('form')
- jasmine.attachToDOM(form)
-
- defaultPrevented = false
- event = new CustomEvent('submit', bubbles: true)
- event.preventDefault = -> defaultPrevented = true
- form.dispatchEvent(event)
- expect(defaultPrevented).toBe(true)
-
- describe "core:focus-next and core:focus-previous", ->
- describe "when there is no currently focused element", ->
- it "focuses the element with the lowest/highest tabindex", ->
- wrapperDiv = document.createElement('div')
- wrapperDiv.innerHTML = """
-
-
-
-
- """
- elements = wrapperDiv.firstChild
- jasmine.attachToDOM(elements)
-
- elements.dispatchEvent(new CustomEvent("core:focus-next", bubbles: true))
- expect(document.activeElement.tabIndex).toBe 1
-
- document.body.focus()
- elements.dispatchEvent(new CustomEvent("core:focus-previous", bubbles: true))
- expect(document.activeElement.tabIndex).toBe 2
-
- describe "when a tabindex is set on the currently focused element", ->
- it "focuses the element with the next highest/lowest tabindex, skipping disabled elements", ->
- wrapperDiv = document.createElement('div')
- wrapperDiv.innerHTML = """
-
+ `.trim()
+ const elements = wrapperDiv.firstChild
+ jasmine.attachToDOM(elements)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-next', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(1)
+
+ document.body.focus()
+ elements.dispatchEvent(new CustomEvent('core:focus-previous', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(2)
+ })
+ )
+
+ describe('when a tabindex is set on the currently focused element', () =>
+ it('focuses the element with the next highest/lowest tabindex, skipping disabled elements', () => {
+ const wrapperDiv = document.createElement('div')
+ wrapperDiv.innerHTML = `
+
+
+
+
+
+
+
+
+
+ `.trim()
+ const elements = wrapperDiv.firstChild
+ jasmine.attachToDOM(elements)
+
+ elements.querySelector('[tabindex="1"]').focus()
+
+ elements.dispatchEvent(new CustomEvent('core:focus-next', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(2)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-next', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(3)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-next', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(5)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-next', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(7)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-next', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(1)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-previous', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(7)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-previous', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(5)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-previous', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(3)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-previous', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(2)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-previous', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(1)
+
+ elements.dispatchEvent(new CustomEvent('core:focus-previous', {bubbles: true}))
+ expect(document.activeElement.tabIndex).toBe(7)
+ })
+ )
+ })
+
+ describe('when keydown events occur on the document', () =>
+ it('dispatches the event via the KeymapManager and CommandRegistry', () => {
+ const dispatchedCommands = []
+ atom.commands.onWillDispatch(command => dispatchedCommands.push(command))
+ atom.commands.add('*', {'foo-command': () => {}})
+ atom.keymaps.add('source-name', {'*': {'x': 'foo-command'}})
+
+ const event = KeymapManager.buildKeydownEvent('x', {target: document.createElement('div')})
+ document.dispatchEvent(event)
+
+ expect(dispatchedCommands.length).toBe(1)
+ expect(dispatchedCommands[0].type).toBe('foo-command')
+ })
+ )
+
+ describe('native key bindings', () =>
+ it("correctly dispatches them to active elements with the '.native-key-bindings' class", () => {
+ const webContentsSpy = jasmine.createSpyObj('webContents', ['copy', 'paste'])
+ spyOn(atom.applicationDelegate, 'getCurrentWindow').andReturn({
+ webContents: webContentsSpy,
+ on: () => {}
+ })
+
+ const nativeKeyBindingsInput = document.createElement('input')
+ nativeKeyBindingsInput.classList.add('native-key-bindings')
+ jasmine.attachToDOM(nativeKeyBindingsInput)
+ nativeKeyBindingsInput.focus()
+
+ atom.dispatchApplicationMenuCommand('core:copy')
+ atom.dispatchApplicationMenuCommand('core:paste')
+
+ expect(webContentsSpy.copy).toHaveBeenCalled()
+ expect(webContentsSpy.paste).toHaveBeenCalled()
+
+ webContentsSpy.copy.reset()
+ webContentsSpy.paste.reset()
+
+ const normalInput = document.createElement('input')
+ jasmine.attachToDOM(normalInput)
+ normalInput.focus()
+
+ atom.dispatchApplicationMenuCommand('core:copy')
+ atom.dispatchApplicationMenuCommand('core:paste')
+
+ expect(webContentsSpy.copy).not.toHaveBeenCalled()
+ expect(webContentsSpy.paste).not.toHaveBeenCalled()
+ })
+ )
+})
diff --git a/spec/workspace-spec.js b/spec/workspace-spec.js
index 476a4ba5b..1bde0e6fe 100644
--- a/spec/workspace-spec.js
+++ b/spec/workspace-spec.js
@@ -1585,15 +1585,15 @@ i = /test/; #FIXME\
atom2.project.deserialize(atom.project.serialize())
atom2.workspace.deserialize(atom.workspace.serialize(), atom2.deserializers)
- expect(atom2.grammars.getGrammars().map(grammar => grammar.name).sort()).toEqual([
- 'CoffeeScript',
- 'CoffeeScript (Literate)',
- 'JSDoc',
- 'JavaScript',
- 'Null Grammar',
- 'Regular Expression Replacement (JavaScript)',
- 'Regular Expressions (JavaScript)',
- 'TODO'
+ expect(atom2.grammars.getGrammars().map(grammar => grammar.scopeName).sort()).toEqual([
+ 'source.coffee',
+ 'source.js',
+ 'source.js.regexp',
+ 'source.js.regexp.replacement',
+ 'source.jsdoc',
+ 'source.litcoffee',
+ 'text.plain.null-grammar',
+ 'text.todo'
])
atom2.destroy()
@@ -2773,7 +2773,7 @@ i = /test/; #FIXME\
})
})
- describe('when the core.allowPendingPaneItems option is falsey', () => {
+ describe('when the core.allowPendingPaneItems option is falsy', () => {
it('does not open item with `pending: true` option as pending', () => {
let pane = null
atom.config.set('core.allowPendingPaneItems', false)
diff --git a/src/application-delegate.coffee b/src/application-delegate.coffee
index 78ea42087..55c27eb61 100644
--- a/src/application-delegate.coffee
+++ b/src/application-delegate.coffee
@@ -233,6 +233,14 @@ class ApplicationDelegate
new Disposable ->
ipcRenderer.removeListener('context-command', outerCallback)
+ onURIMessage: (callback) ->
+ outerCallback = (event, args...) ->
+ callback(args...)
+
+ ipcRenderer.on('uri-message', outerCallback)
+ new Disposable ->
+ ipcRenderer.removeListener('uri-message', outerCallback)
+
onDidRequestUnload: (callback) ->
outerCallback = (event, message) ->
callback(event).then (shouldUnload) ->
diff --git a/src/atom-environment.coffee b/src/atom-environment.coffee
index d777ecc3e..af61ffb36 100644
--- a/src/atom-environment.coffee
+++ b/src/atom-environment.coffee
@@ -22,6 +22,7 @@ Config = require './config'
KeymapManager = require './keymap-extensions'
TooltipManager = require './tooltip-manager'
CommandRegistry = require './command-registry'
+URIHandlerRegistry = require './uri-handler-registry'
GrammarRegistry = require './grammar-registry'
{HistoryManager, HistoryProject} = require './history-manager'
ReopenProjectMenuManager = require './reopen-project-menu-manager'
@@ -31,6 +32,7 @@ ThemeManager = require './theme-manager'
MenuManager = require './menu-manager'
ContextMenuManager = require './context-menu-manager'
CommandInstaller = require './command-installer'
+ProtocolHandlerInstaller = require './protocol-handler-installer'
Project = require './project'
TitleBar = require './title-bar'
Workspace = require './workspace'
@@ -146,12 +148,14 @@ class AtomEnvironment extends Model
@keymaps = new KeymapManager({notificationManager: @notifications})
@tooltips = new TooltipManager(keymapManager: @keymaps, viewRegistry: @views)
@commands = new CommandRegistry
+ @uriHandlerRegistry = new URIHandlerRegistry
@grammars = new GrammarRegistry({@config})
@styles = new StyleManager()
@packages = new PackageManager({
@config, styleManager: @styles,
commandRegistry: @commands, keymapManager: @keymaps, notificationManager: @notifications,
- grammarRegistry: @grammars, deserializerManager: @deserializers, viewRegistry: @views
+ grammarRegistry: @grammars, deserializerManager: @deserializers, viewRegistry: @views,
+ uriHandlerRegistry: @uriHandlerRegistry
})
@themes = new ThemeManager({
packageManager: @packages, @config, styleManager: @styles,
@@ -165,6 +169,7 @@ class AtomEnvironment extends Model
@project = new Project({notificationManager: @notifications, packageManager: @packages, @config, @applicationDelegate})
@commandInstaller = new CommandInstaller(@applicationDelegate)
+ @protocolHandlerInstaller = new ProtocolHandlerInstaller()
@textEditors = new TextEditorRegistry({
@config, grammarRegistry: @grammars, assert: @assert.bind(this),
@@ -231,6 +236,7 @@ class AtomEnvironment extends Model
@themes.initialize({@configDirPath, resourcePath, safeMode, devMode})
@commandInstaller.initialize(@getVersion())
+ @protocolHandlerInstaller.initialize(@config, @notifications)
@autoUpdater.initialize()
@config.load()
@@ -327,20 +333,14 @@ class AtomEnvironment extends Model
@contextMenu.clear()
- @packages.reset()
-
- @workspace.reset(@packages)
- @registerDefaultOpeners()
-
- @project.reset(@packages)
-
- @workspace.subscribeToEvents()
-
- @grammars.clear()
-
- @textEditors.clear()
-
- @views.clear()
+ @packages.reset().then =>
+ @workspace.reset(@packages)
+ @registerDefaultOpeners()
+ @project.reset(@packages)
+ @workspace.subscribeToEvents()
+ @grammars.clear()
+ @textEditors.clear()
+ @views.clear()
destroy: ->
return if not @project
@@ -355,6 +355,7 @@ class AtomEnvironment extends Model
@stylesElement.remove()
@config.unobserveUserConfig()
@autoUpdater.destroy()
+ @uriHandlerRegistry.destroy()
@uninstallWindowEventHandler()
@@ -444,7 +445,9 @@ class AtomEnvironment extends Model
getVersion: ->
@appVersion ?= @getLoadSettings().appVersion
- # Returns the release channel as a {String}. Will return one of `'dev', 'beta', 'stable'`
+ # Public: Gets the release channel of the Atom application.
+ #
+ # Returns the release channel as a {String}. Will return one of `dev`, `beta`, or `stable`.
getReleaseChannel: ->
version = @getVersion()
if version.indexOf('beta') > -1
@@ -693,6 +696,7 @@ class AtomEnvironment extends Model
@disposables.add(@applicationDelegate.onDidOpenLocations(@openLocations.bind(this)))
@disposables.add(@applicationDelegate.onApplicationMenuCommand(@dispatchApplicationMenuCommand.bind(this)))
@disposables.add(@applicationDelegate.onContextMenuCommand(@dispatchContextMenuCommand.bind(this)))
+ @disposables.add(@applicationDelegate.onURIMessage(@dispatchURIMessage.bind(this)))
@disposables.add @applicationDelegate.onDidRequestUnload =>
@saveState({isUnloading: true})
.catch(console.error)
@@ -701,6 +705,11 @@ class AtomEnvironment extends Model
windowCloseRequested: true,
projectHasPaths: @project.getPaths().length > 0
})
+ .then (closing) =>
+ if closing
+ @packages.deactivatePackages().then -> closing
+ else
+ closing
@listenForUpdates()
@@ -757,7 +766,6 @@ class AtomEnvironment extends Model
return if not @project
@storeWindowBackground()
- @packages.deactivatePackages()
@saveBlobStoreSync()
@unloaded = true
@@ -826,6 +834,9 @@ class AtomEnvironment extends Model
# Essential: A flexible way to open a dialog akin to an alert dialog.
#
+ # If the dialog is closed (via `Esc` key or `X` in the top corner) without selecting a button
+ # the first button will be clicked unless a "Cancel" or "No" button is provided.
+ #
# ## Examples
#
# ```coffee
@@ -843,7 +854,7 @@ class AtomEnvironment extends Model
# * `buttons` (optional) Either an array of strings or an object where keys are
# button names and the values are callbacks to invoke when clicked.
#
- # Returns the chosen button index {Number} if the buttons option was an array.
+ # Returns the chosen button index {Number} if the buttons option is an array or the return value of the callback if the buttons option is an object.
confirm: (params={}) ->
@applicationDelegate.confirm(params)
@@ -997,11 +1008,18 @@ class AtomEnvironment extends Model
@setFullScreen(state.fullScreen)
+ missingProjectPaths = []
+
@packages.packageStates = state.packageStates ? {}
startTime = Date.now()
if state.project?
projectPromise = @project.deserialize(state.project, @deserializers)
+ .catch (err) =>
+ if err.missingProjectPaths?
+ missingProjectPaths.push(err.missingProjectPaths...)
+ else
+ @notifications.addError "Unable to deserialize project", description: err.message, stack: err.stack
else
projectPromise = Promise.resolve()
@@ -1014,6 +1032,19 @@ class AtomEnvironment extends Model
@workspace.deserialize(state.workspace, @deserializers) if state.workspace?
@deserializeTimings.workspace = Date.now() - startTime
+ if missingProjectPaths.length > 0
+ count = if missingProjectPaths.length is 1 then '' else missingProjectPaths.length + ' '
+ noun = if missingProjectPaths.length is 1 then 'directory' else 'directories'
+ toBe = if missingProjectPaths.length is 1 then 'is' else 'are'
+ escaped = missingProjectPaths.map (projectPath) -> "`#{projectPath}`"
+ group = switch escaped.length
+ when 1 then escaped[0]
+ when 2 then "#{escaped[0]} and #{escaped[1]}"
+ else escaped[..-2].join(", ") + ", and #{escaped[escaped.length - 1]}"
+
+ @notifications.addError "Unable to open #{count}project #{noun}",
+ description: "Project #{noun} #{group} #{toBe} no longer on disk."
+
getStateKey: (paths) ->
if paths?.length > 0
sha1 = crypto.createHash('sha1').update(paths.slice().sort().join("\n")).digest('hex')
@@ -1068,6 +1099,14 @@ class AtomEnvironment extends Model
dispatchContextMenuCommand: (command, args...) ->
@commands.dispatch(@contextMenu.activeElement, command, args)
+ dispatchURIMessage: (uri) ->
+ if @packages.hasLoadedInitialPackages()
+ @uriHandlerRegistry.handleURI(uri)
+ else
+ sub = @packages.onDidLoadInitialPackages ->
+ sub.dispose()
+ @uriHandlerRegistry.handleURI(uri)
+
openLocations: (locations) ->
needsProjectPaths = @project?.getPaths().length is 0
diff --git a/src/color.js b/src/color.js
index 6208d6837..2f2947e16 100644
--- a/src/color.js
+++ b/src/color.js
@@ -112,27 +112,15 @@ export default class Color {
function parseColor (colorString) {
const color = parseInt(colorString, 10)
- if (isNaN(color)) {
- return 0
- } else {
- return Math.min(Math.max(color, 0), 255)
- }
+ return isNaN(color) ? 0 : Math.min(Math.max(color, 0), 255)
}
function parseAlpha (alphaString) {
const alpha = parseFloat(alphaString)
- if (isNaN(alpha)) {
- return 1
- } else {
- return Math.min(Math.max(alpha, 0), 1)
- }
+ return isNaN(alpha) ? 1 : Math.min(Math.max(alpha, 0), 1)
}
function numberToHexString (number) {
const hex = number.toString(16)
- if (number < 16) {
- return `0${hex}`
- } else {
- return hex
- }
+ return number < 16 ? `0${hex}` : hex
}
diff --git a/src/compile-cache.js b/src/compile-cache.js
index 4209b30ab..a4f9ded1e 100644
--- a/src/compile-cache.js
+++ b/src/compile-cache.js
@@ -84,20 +84,20 @@ function compileFileAtPath (compiler, filePath, extension) {
var sourceCode = fs.readFileSync(filePath, 'utf8')
if (compiler.shouldCompile(sourceCode, filePath)) {
var cachePath = compiler.getCachePath(sourceCode, filePath)
- var compiledCode = readCachedJavascript(cachePath)
+ var compiledCode = readCachedJavaScript(cachePath)
if (compiledCode != null) {
cacheStats[extension].hits++
} else {
cacheStats[extension].misses++
compiledCode = compiler.compile(sourceCode, filePath)
- writeCachedJavascript(cachePath, compiledCode)
+ writeCachedJavaScript(cachePath, compiledCode)
}
return compiledCode
}
return sourceCode
}
-function readCachedJavascript (relativeCachePath) {
+function readCachedJavaScript (relativeCachePath) {
var cachePath = path.join(cacheDirectory, relativeCachePath)
if (fs.isFileSync(cachePath)) {
try {
@@ -107,7 +107,7 @@ function readCachedJavascript (relativeCachePath) {
return null
}
-function writeCachedJavascript (relativeCachePath, code) {
+function writeCachedJavaScript (relativeCachePath, code) {
var cachePath = path.join(cacheDirectory, relativeCachePath)
fs.writeFileSync(cachePath, code, 'utf8')
}
@@ -153,7 +153,7 @@ exports.install = function (resourcesPath, nodeRequire) {
if (!compiler) compiler = COMPILERS['.js']
try {
- var fileData = readCachedJavascript(compiler.getCachePath(sourceCode, filePath))
+ var fileData = readCachedJavaScript(compiler.getCachePath(sourceCode, filePath))
} catch (error) {
console.warn('Error reading compiled file', error.stack)
return null
diff --git a/src/config-schema.js b/src/config-schema.js
index fb0164766..2ff68be86 100644
--- a/src/config-schema.js
+++ b/src/config-schema.js
@@ -17,7 +17,7 @@ const configSchema = {
type: 'boolean',
default: true,
title: 'Exclude VCS Ignored Paths',
- description: 'Files and directories ignored by the current project\'s VCS system will be ignored by some packages, such as the fuzzy finder and find and replace. For example, projects using Git have these paths defined in the .gitignore file. Individual packages might have additional config settings for ignoring VCS ignored files and folders.'
+ description: 'Files and directories ignored by the current project\'s VCS will be ignored by some packages, such as the fuzzy finder and find and replace. For example, projects using Git have these paths defined in the .gitignore file. Individual packages might have additional config settings for ignoring VCS ignored files and folders.'
},
followSymlinks: {
type: 'boolean',
@@ -55,6 +55,25 @@ const configSchema = {
}
}
},
+ uriHandlerRegistration: {
+ type: 'string',
+ default: 'prompt',
+ description: 'When should Atom register itself as the default handler for atom:// URIs',
+ enum: [
+ {
+ value: 'prompt',
+ description: 'Prompt to register Atom as the default atom:// URI handler'
+ },
+ {
+ value: 'always',
+ description: 'Always become the default atom:// URI handler automatically'
+ },
+ {
+ value: 'never',
+ description: 'Never become the default atom:// URI handler'
+ }
+ ]
+ },
themes: {
type: 'array',
default: ['one-dark-ui', 'one-dark-syntax'],
@@ -409,6 +428,12 @@ const configSchema = {
minimum: 1,
description: 'Identifies the length of a line which is used when wrapping text with the `Soft Wrap At Preferred Line Length` setting enabled, in number of characters.'
},
+ maxScreenLineLength: {
+ type: 'integer',
+ default: 500,
+ minimum: 500,
+ description: 'Defines the maximum width of the editor window before soft wrapping is enforced, in number of characters.'
+ },
tabLength: {
type: 'integer',
default: 2,
diff --git a/src/config.coffee b/src/config.coffee
index f0628ffee..b8bf8a76f 100644
--- a/src/config.coffee
+++ b/src/config.coffee
@@ -4,7 +4,7 @@ fs = require 'fs-plus'
CSON = require 'season'
path = require 'path'
async = require 'async'
-pathWatcher = require 'pathwatcher'
+{watchPath} = require './path-watcher'
{
getValueAtKeyPath, setValueAtKeyPath, deleteValueAtKeyPath,
pushKeyPath, splitKeyPath,
@@ -221,7 +221,7 @@ ScopeDescriptor = require './scope-descriptor'
# #### object / Grouping other types
#
# A config setting with the type `object` allows grouping a set of config
-# settings. The group will be visualy separated and has its own group headline.
+# settings. The group will be visually separated and has its own group headline.
# The sub options must be listed under a `properties` key.
#
# ```coffee
@@ -417,17 +417,24 @@ class Config
@defaultSettings = {}
@settings = {}
@scopedSettingsStore = new ScopedPropertyStore
+
+ @settingsLoaded = false
+ @savePending = false
@configFileHasErrors = false
@transactDepth = 0
- @savePending = false
- @requestLoad = _.debounce(@loadUserConfig, 100)
- @requestSave = =>
- @savePending = true
- debouncedSave.call(this)
- save = =>
+ @pendingOperations = []
+
+ @requestLoad = _.debounce =>
+ @loadUserConfig()
+ , 100
+
+ debouncedSave = _.debounce =>
@savePending = false
@save()
- debouncedSave = _.debounce(save, 100)
+ , 100
+ @requestSave = =>
+ @savePending = true
+ debouncedSave()
shouldNotAccessFileSystem: -> not @enablePersistence
@@ -647,6 +654,10 @@ class Config
# * `false` if the value was not able to be coerced to the type specified in the setting's schema.
set: ->
[keyPath, value, options] = arguments
+
+ unless @settingsLoaded
+ @pendingOperations.push => @set.call(this, keyPath, value, options)
+
scopeSelector = options?.scopeSelector
source = options?.source
shouldSave = options?.save ? true
@@ -667,7 +678,8 @@ class Config
else
@setRawValue(keyPath, value)
- @requestSave() if source is @getUserConfigPath() and shouldSave and not @configFileHasErrors
+ if source is @getUserConfigPath() and shouldSave and not @configFileHasErrors and @settingsLoaded
+ @requestSave()
true
# Essential: Restore the setting at `keyPath` to its default value.
@@ -677,6 +689,9 @@ class Config
# * `scopeSelector` (optional) {String}. See {::set}
# * `source` (optional) {String}. See {::set}
unset: (keyPath, options) ->
+ unless @settingsLoaded
+ @pendingOperations.push => @unset.call(this, keyPath, options)
+
{scopeSelector, source} = options ? {}
source ?= @getUserConfigPath()
@@ -688,7 +703,8 @@ class Config
setValueAtKeyPath(settings, keyPath, undefined)
settings = withoutEmptyObjects(settings)
@set(null, settings, {scopeSelector, source, priority: @priorityForSource(source)}) if settings?
- @requestSave()
+ if source is @getUserConfigPath() and not @configFileHasErrors and @settingsLoaded
+ @requestSave()
else
@scopedSettingsStore.removePropertiesForSourceAndSelector(source, scopeSelector)
@emitChangeEvent()
@@ -848,21 +864,27 @@ class Config
loadUserConfig: ->
return if @shouldNotAccessFileSystem()
+ return if @savePending
try
unless fs.existsSync(@configFilePath)
fs.makeTreeSync(path.dirname(@configFilePath))
- CSON.writeFileSync(@configFilePath, {})
+ CSON.writeFileSync(@configFilePath, {}, {flag: 'wx'}) # fails if file exists
catch error
- @configFileHasErrors = true
- @notifyFailure("Failed to initialize `#{path.basename(@configFilePath)}`", error.stack)
- return
+ if error.code isnt 'EEXIST'
+ @configFileHasErrors = true
+ @notifyFailure("Failed to initialize `#{path.basename(@configFilePath)}`", error.stack)
+ return
try
- unless @savePending
- userConfig = CSON.readFileSync(@configFilePath)
- @resetUserSettings(userConfig)
- @configFileHasErrors = false
+ userConfig = CSON.readFileSync(@configFilePath)
+ userConfig = {} if userConfig is null
+
+ unless isPlainObject(userConfig)
+ throw new Error("`#{path.basename(@configFilePath)}` must contain valid JSON or CSON")
+
+ @resetUserSettings(userConfig)
+ @configFileHasErrors = false
catch error
@configFileHasErrors = true
message = "Failed to load `#{path.basename(@configFilePath)}`"
@@ -880,8 +902,10 @@ class Config
return if @shouldNotAccessFileSystem()
try
- @watchSubscription ?= pathWatcher.watch @configFilePath, (eventType) =>
- @requestLoad() if eventType is 'change' and @watchSubscription?
+ @watchSubscriptionPromise ?= watchPath @configFilePath, {}, (events) =>
+ for {action} in events
+ if action in ['created', 'modified', 'renamed'] and @watchSubscriptionPromise?
+ @requestLoad()
catch error
@notifyFailure """
Unable to watch path: `#{path.basename(@configFilePath)}`. Make sure you have permissions to
@@ -890,9 +914,11 @@ class Config
[watches]:https://github.com/atom/atom/blob/master/docs/build-instructions/linux.md#typeerror-unable-to-watch-path
"""
+ @watchSubscriptionPromise
+
unobserveUserConfig: ->
- @watchSubscription?.close()
- @watchSubscription = null
+ @watchSubscriptionPromise?.then (watcher) -> watcher?.dispose()
+ @watchSubscriptionPromise = null
notifyFailure: (errorMessage, detail) ->
@notificationManager?.addError(errorMessage, {detail, dismissable: true})
@@ -915,11 +941,6 @@ class Config
###
resetUserSettings: (newSettings) ->
- unless isPlainObject(newSettings)
- @settings = {}
- @emitChangeEvent()
- return
-
if newSettings.global?
newSettings['*'] = newSettings.global
delete newSettings.global
@@ -932,8 +953,11 @@ class Config
@transact =>
@settings = {}
+ @settingsLoaded = true
@set(key, value, save: false) for key, value of newSettings
- return
+ if @pendingOperations.length
+ op() for op in @pendingOperations
+ @pendingOperations = []
getRawValue: (keyPath, options) ->
unless options?.excludeSources?.indexOf(@getUserConfigPath()) >= 0
diff --git a/src/cursor.coffee b/src/cursor.coffee
deleted file mode 100644
index 128fe7ff5..000000000
--- a/src/cursor.coffee
+++ /dev/null
@@ -1,659 +0,0 @@
-{Point, Range} = require 'text-buffer'
-{Emitter} = require 'event-kit'
-_ = require 'underscore-plus'
-Model = require './model'
-
-EmptyLineRegExp = /(\r\n[\t ]*\r\n)|(\n[\t ]*\n)/g
-
-# Extended: The `Cursor` class represents the little blinking line identifying
-# where text can be inserted.
-#
-# Cursors belong to {TextEditor}s and have some metadata attached in the form
-# of a {DisplayMarker}.
-module.exports =
-class Cursor extends Model
- screenPosition: null
- bufferPosition: null
- goalColumn: null
-
- # Instantiated by a {TextEditor}
- constructor: ({@editor, @marker, id}) ->
- @emitter = new Emitter
- @assignId(id)
-
- destroy: ->
- @marker.destroy()
-
- ###
- Section: Event Subscription
- ###
-
- # Public: Calls your `callback` when the cursor has been moved.
- #
- # * `callback` {Function}
- # * `event` {Object}
- # * `oldBufferPosition` {Point}
- # * `oldScreenPosition` {Point}
- # * `newBufferPosition` {Point}
- # * `newScreenPosition` {Point}
- # * `textChanged` {Boolean}
- # * `Cursor` {Cursor} that triggered the event
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidChangePosition: (callback) ->
- @emitter.on 'did-change-position', callback
-
- # Public: Calls your `callback` when the cursor is destroyed
- #
- # * `callback` {Function}
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidDestroy: (callback) ->
- @emitter.once 'did-destroy', callback
-
- ###
- Section: Managing Cursor Position
- ###
-
- # Public: Moves a cursor to a given screen position.
- #
- # * `screenPosition` {Array} of two numbers: the screen row, and the screen column.
- # * `options` (optional) {Object} with the following keys:
- # * `autoscroll` A Boolean which, if `true`, scrolls the {TextEditor} to wherever
- # the cursor moves to.
- setScreenPosition: (screenPosition, options={}) ->
- @changePosition options, =>
- @marker.setHeadScreenPosition(screenPosition, options)
-
- # Public: Returns the screen position of the cursor as a {Point}.
- getScreenPosition: ->
- @marker.getHeadScreenPosition()
-
- # Public: Moves a cursor to a given buffer position.
- #
- # * `bufferPosition` {Array} of two numbers: the buffer row, and the buffer column.
- # * `options` (optional) {Object} with the following keys:
- # * `autoscroll` {Boolean} indicating whether to autoscroll to the new
- # position. Defaults to `true` if this is the most recently added cursor,
- # `false` otherwise.
- setBufferPosition: (bufferPosition, options={}) ->
- @changePosition options, =>
- @marker.setHeadBufferPosition(bufferPosition, options)
-
- # Public: Returns the current buffer position as an Array.
- getBufferPosition: ->
- @marker.getHeadBufferPosition()
-
- # Public: Returns the cursor's current screen row.
- getScreenRow: ->
- @getScreenPosition().row
-
- # Public: Returns the cursor's current screen column.
- getScreenColumn: ->
- @getScreenPosition().column
-
- # Public: Retrieves the cursor's current buffer row.
- getBufferRow: ->
- @getBufferPosition().row
-
- # Public: Returns the cursor's current buffer column.
- getBufferColumn: ->
- @getBufferPosition().column
-
- # Public: Returns the cursor's current buffer row of text excluding its line
- # ending.
- getCurrentBufferLine: ->
- @editor.lineTextForBufferRow(@getBufferRow())
-
- # Public: Returns whether the cursor is at the start of a line.
- isAtBeginningOfLine: ->
- @getBufferPosition().column is 0
-
- # Public: Returns whether the cursor is on the line return character.
- isAtEndOfLine: ->
- @getBufferPosition().isEqual(@getCurrentLineBufferRange().end)
-
- ###
- Section: Cursor Position Details
- ###
-
- # Public: Returns the underlying {DisplayMarker} for the cursor.
- # Useful with overlay {Decoration}s.
- getMarker: -> @marker
-
- # Public: Identifies if the cursor is surrounded by whitespace.
- #
- # "Surrounded" here means that the character directly before and after the
- # cursor are both whitespace.
- #
- # Returns a {Boolean}.
- isSurroundedByWhitespace: ->
- {row, column} = @getBufferPosition()
- range = [[row, column - 1], [row, column + 1]]
- /^\s+$/.test @editor.getTextInBufferRange(range)
-
- # Public: Returns whether the cursor is currently between a word and non-word
- # character. The non-word characters are defined by the
- # `editor.nonWordCharacters` config value.
- #
- # This method returns false if the character before or after the cursor is
- # whitespace.
- #
- # Returns a Boolean.
- isBetweenWordAndNonWord: ->
- return false if @isAtBeginningOfLine() or @isAtEndOfLine()
-
- {row, column} = @getBufferPosition()
- range = [[row, column - 1], [row, column + 1]]
- [before, after] = @editor.getTextInBufferRange(range)
- return false if /\s/.test(before) or /\s/.test(after)
-
- nonWordCharacters = @getNonWordCharacters()
- nonWordCharacters.includes(before) isnt nonWordCharacters.includes(after)
-
- # Public: Returns whether this cursor is between a word's start and end.
- #
- # * `options` (optional) {Object}
- # * `wordRegex` A {RegExp} indicating what constitutes a "word"
- # (default: {::wordRegExp}).
- #
- # Returns a {Boolean}
- isInsideWord: (options) ->
- {row, column} = @getBufferPosition()
- range = [[row, column], [row, Infinity]]
- @editor.getTextInBufferRange(range).search(options?.wordRegex ? @wordRegExp()) is 0
-
- # Public: Returns the indentation level of the current line.
- getIndentLevel: ->
- if @editor.getSoftTabs()
- @getBufferColumn() / @editor.getTabLength()
- else
- @getBufferColumn()
-
- # Public: Retrieves the scope descriptor for the cursor's current position.
- #
- # Returns a {ScopeDescriptor}
- getScopeDescriptor: ->
- @editor.scopeDescriptorForBufferPosition(@getBufferPosition())
-
- # Public: Returns true if this cursor has no non-whitespace characters before
- # its current position.
- hasPrecedingCharactersOnLine: ->
- bufferPosition = @getBufferPosition()
- line = @editor.lineTextForBufferRow(bufferPosition.row)
- firstCharacterColumn = line.search(/\S/)
-
- if firstCharacterColumn is -1
- false
- else
- bufferPosition.column > firstCharacterColumn
-
- # Public: Identifies if this cursor is the last in the {TextEditor}.
- #
- # "Last" is defined as the most recently added cursor.
- #
- # Returns a {Boolean}.
- isLastCursor: ->
- this is @editor.getLastCursor()
-
- ###
- Section: Moving the Cursor
- ###
-
- # Public: Moves the cursor up one screen row.
- #
- # * `rowCount` (optional) {Number} number of rows to move (default: 1)
- # * `options` (optional) {Object} with the following keys:
- # * `moveToEndOfSelection` if true, move to the left of the selection if a
- # selection exists.
- moveUp: (rowCount=1, {moveToEndOfSelection}={}) ->
- range = @marker.getScreenRange()
- if moveToEndOfSelection and not range.isEmpty()
- {row, column} = range.start
- else
- {row, column} = @getScreenPosition()
-
- column = @goalColumn if @goalColumn?
- @setScreenPosition({row: row - rowCount, column: column}, skipSoftWrapIndentation: true)
- @goalColumn = column
-
- # Public: Moves the cursor down one screen row.
- #
- # * `rowCount` (optional) {Number} number of rows to move (default: 1)
- # * `options` (optional) {Object} with the following keys:
- # * `moveToEndOfSelection` if true, move to the left of the selection if a
- # selection exists.
- moveDown: (rowCount=1, {moveToEndOfSelection}={}) ->
- range = @marker.getScreenRange()
- if moveToEndOfSelection and not range.isEmpty()
- {row, column} = range.end
- else
- {row, column} = @getScreenPosition()
-
- column = @goalColumn if @goalColumn?
- @setScreenPosition({row: row + rowCount, column: column}, skipSoftWrapIndentation: true)
- @goalColumn = column
-
- # Public: Moves the cursor left one screen column.
- #
- # * `columnCount` (optional) {Number} number of columns to move (default: 1)
- # * `options` (optional) {Object} with the following keys:
- # * `moveToEndOfSelection` if true, move to the left of the selection if a
- # selection exists.
- moveLeft: (columnCount=1, {moveToEndOfSelection}={}) ->
- range = @marker.getScreenRange()
- if moveToEndOfSelection and not range.isEmpty()
- @setScreenPosition(range.start)
- else
- {row, column} = @getScreenPosition()
-
- while columnCount > column and row > 0
- columnCount -= column
- column = @editor.lineLengthForScreenRow(--row)
- columnCount-- # subtract 1 for the row move
-
- column = column - columnCount
- @setScreenPosition({row, column}, clipDirection: 'backward')
-
- # Public: Moves the cursor right one screen column.
- #
- # * `columnCount` (optional) {Number} number of columns to move (default: 1)
- # * `options` (optional) {Object} with the following keys:
- # * `moveToEndOfSelection` if true, move to the right of the selection if a
- # selection exists.
- moveRight: (columnCount=1, {moveToEndOfSelection}={}) ->
- range = @marker.getScreenRange()
- if moveToEndOfSelection and not range.isEmpty()
- @setScreenPosition(range.end)
- else
- {row, column} = @getScreenPosition()
- maxLines = @editor.getScreenLineCount()
- rowLength = @editor.lineLengthForScreenRow(row)
- columnsRemainingInLine = rowLength - column
-
- while columnCount > columnsRemainingInLine and row < maxLines - 1
- columnCount -= columnsRemainingInLine
- columnCount-- # subtract 1 for the row move
-
- column = 0
- rowLength = @editor.lineLengthForScreenRow(++row)
- columnsRemainingInLine = rowLength
-
- column = column + columnCount
- @setScreenPosition({row, column}, clipDirection: 'forward')
-
- # Public: Moves the cursor to the top of the buffer.
- moveToTop: ->
- @setBufferPosition([0, 0])
-
- # Public: Moves the cursor to the bottom of the buffer.
- moveToBottom: ->
- @setBufferPosition(@editor.getEofBufferPosition())
-
- # Public: Moves the cursor to the beginning of the line.
- moveToBeginningOfScreenLine: ->
- @setScreenPosition([@getScreenRow(), 0])
-
- # Public: Moves the cursor to the beginning of the buffer line.
- moveToBeginningOfLine: ->
- @setBufferPosition([@getBufferRow(), 0])
-
- # Public: Moves the cursor to the beginning of the first character in the
- # line.
- moveToFirstCharacterOfLine: ->
- screenRow = @getScreenRow()
- screenLineStart = @editor.clipScreenPosition([screenRow, 0], skipSoftWrapIndentation: true)
- screenLineEnd = [screenRow, Infinity]
- screenLineBufferRange = @editor.bufferRangeForScreenRange([screenLineStart, screenLineEnd])
-
- firstCharacterColumn = null
- @editor.scanInBufferRange /\S/, screenLineBufferRange, ({range, stop}) ->
- firstCharacterColumn = range.start.column
- stop()
-
- if firstCharacterColumn? and firstCharacterColumn isnt @getBufferColumn()
- targetBufferColumn = firstCharacterColumn
- else
- targetBufferColumn = screenLineBufferRange.start.column
-
- @setBufferPosition([screenLineBufferRange.start.row, targetBufferColumn])
-
- # Public: Moves the cursor to the end of the line.
- moveToEndOfScreenLine: ->
- @setScreenPosition([@getScreenRow(), Infinity])
-
- # Public: Moves the cursor to the end of the buffer line.
- moveToEndOfLine: ->
- @setBufferPosition([@getBufferRow(), Infinity])
-
- # Public: Moves the cursor to the beginning of the word.
- moveToBeginningOfWord: ->
- @setBufferPosition(@getBeginningOfCurrentWordBufferPosition())
-
- # Public: Moves the cursor to the end of the word.
- moveToEndOfWord: ->
- if position = @getEndOfCurrentWordBufferPosition()
- @setBufferPosition(position)
-
- # Public: Moves the cursor to the beginning of the next word.
- moveToBeginningOfNextWord: ->
- if position = @getBeginningOfNextWordBufferPosition()
- @setBufferPosition(position)
-
- # Public: Moves the cursor to the previous word boundary.
- moveToPreviousWordBoundary: ->
- if position = @getPreviousWordBoundaryBufferPosition()
- @setBufferPosition(position)
-
- # Public: Moves the cursor to the next word boundary.
- moveToNextWordBoundary: ->
- if position = @getNextWordBoundaryBufferPosition()
- @setBufferPosition(position)
-
- # Public: Moves the cursor to the previous subword boundary.
- moveToPreviousSubwordBoundary: ->
- options = {wordRegex: @subwordRegExp(backwards: true)}
- if position = @getPreviousWordBoundaryBufferPosition(options)
- @setBufferPosition(position)
-
- # Public: Moves the cursor to the next subword boundary.
- moveToNextSubwordBoundary: ->
- options = {wordRegex: @subwordRegExp()}
- if position = @getNextWordBoundaryBufferPosition(options)
- @setBufferPosition(position)
-
- # Public: Moves the cursor to the beginning of the buffer line, skipping all
- # whitespace.
- skipLeadingWhitespace: ->
- position = @getBufferPosition()
- scanRange = @getCurrentLineBufferRange()
- endOfLeadingWhitespace = null
- @editor.scanInBufferRange /^[ \t]*/, scanRange, ({range}) ->
- endOfLeadingWhitespace = range.end
-
- @setBufferPosition(endOfLeadingWhitespace) if endOfLeadingWhitespace.isGreaterThan(position)
-
- # Public: Moves the cursor to the beginning of the next paragraph
- moveToBeginningOfNextParagraph: ->
- if position = @getBeginningOfNextParagraphBufferPosition()
- @setBufferPosition(position)
-
- # Public: Moves the cursor to the beginning of the previous paragraph
- moveToBeginningOfPreviousParagraph: ->
- if position = @getBeginningOfPreviousParagraphBufferPosition()
- @setBufferPosition(position)
-
- ###
- Section: Local Positions and Ranges
- ###
-
- # Public: Returns buffer position of previous word boundary. It might be on
- # the current word, or the previous word.
- #
- # * `options` (optional) {Object} with the following keys:
- # * `wordRegex` A {RegExp} indicating what constitutes a "word"
- # (default: {::wordRegExp})
- getPreviousWordBoundaryBufferPosition: (options = {}) ->
- currentBufferPosition = @getBufferPosition()
- previousNonBlankRow = @editor.buffer.previousNonBlankRow(currentBufferPosition.row)
- scanRange = [[previousNonBlankRow ? 0, 0], currentBufferPosition]
-
- beginningOfWordPosition = null
- @editor.backwardsScanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) ->
- if range.start.row < currentBufferPosition.row and currentBufferPosition.column > 0
- # force it to stop at the beginning of each line
- beginningOfWordPosition = new Point(currentBufferPosition.row, 0)
- else if range.end.isLessThan(currentBufferPosition)
- beginningOfWordPosition = range.end
- else
- beginningOfWordPosition = range.start
-
- if not beginningOfWordPosition?.isEqual(currentBufferPosition)
- stop()
-
- beginningOfWordPosition or currentBufferPosition
-
- # Public: Returns buffer position of the next word boundary. It might be on
- # the current word, or the previous word.
- #
- # * `options` (optional) {Object} with the following keys:
- # * `wordRegex` A {RegExp} indicating what constitutes a "word"
- # (default: {::wordRegExp})
- getNextWordBoundaryBufferPosition: (options = {}) ->
- currentBufferPosition = @getBufferPosition()
- scanRange = [currentBufferPosition, @editor.getEofBufferPosition()]
-
- endOfWordPosition = null
- @editor.scanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) ->
- if range.start.row > currentBufferPosition.row
- # force it to stop at the beginning of each line
- endOfWordPosition = new Point(range.start.row, 0)
- else if range.start.isGreaterThan(currentBufferPosition)
- endOfWordPosition = range.start
- else
- endOfWordPosition = range.end
-
- if not endOfWordPosition?.isEqual(currentBufferPosition)
- stop()
-
- endOfWordPosition or currentBufferPosition
-
- # Public: Retrieves the buffer position of where the current word starts.
- #
- # * `options` (optional) An {Object} with the following keys:
- # * `wordRegex` A {RegExp} indicating what constitutes a "word"
- # (default: {::wordRegExp}).
- # * `includeNonWordCharacters` A {Boolean} indicating whether to include
- # non-word characters in the default word regex.
- # Has no effect if wordRegex is set.
- # * `allowPrevious` A {Boolean} indicating whether the beginning of the
- # previous word can be returned.
- #
- # Returns a {Range}.
- getBeginningOfCurrentWordBufferPosition: (options = {}) ->
- allowPrevious = options.allowPrevious ? true
- currentBufferPosition = @getBufferPosition()
- previousNonBlankRow = @editor.buffer.previousNonBlankRow(currentBufferPosition.row) ? 0
- scanRange = [[previousNonBlankRow, 0], currentBufferPosition]
-
- beginningOfWordPosition = null
- @editor.backwardsScanInBufferRange (options.wordRegex ? @wordRegExp(options)), scanRange, ({range, matchText, stop}) ->
- # Ignore 'empty line' matches between '\r' and '\n'
- return if matchText is '' and range.start.column isnt 0
-
- if range.start.isLessThan(currentBufferPosition)
- if range.end.isGreaterThanOrEqual(currentBufferPosition) or allowPrevious
- beginningOfWordPosition = range.start
- stop()
-
- if beginningOfWordPosition?
- beginningOfWordPosition
- else if allowPrevious
- new Point(0, 0)
- else
- currentBufferPosition
-
- # Public: Retrieves the buffer position of where the current word ends.
- #
- # * `options` (optional) {Object} with the following keys:
- # * `wordRegex` A {RegExp} indicating what constitutes a "word"
- # (default: {::wordRegExp})
- # * `includeNonWordCharacters` A Boolean indicating whether to include
- # non-word characters in the default word regex. Has no effect if
- # wordRegex is set.
- #
- # Returns a {Range}.
- getEndOfCurrentWordBufferPosition: (options = {}) ->
- allowNext = options.allowNext ? true
- currentBufferPosition = @getBufferPosition()
- scanRange = [currentBufferPosition, @editor.getEofBufferPosition()]
-
- endOfWordPosition = null
- @editor.scanInBufferRange (options.wordRegex ? @wordRegExp(options)), scanRange, ({range, matchText, stop}) ->
- # Ignore 'empty line' matches between '\r' and '\n'
- return if matchText is '' and range.start.column isnt 0
-
- if range.end.isGreaterThan(currentBufferPosition)
- if allowNext or range.start.isLessThanOrEqual(currentBufferPosition)
- endOfWordPosition = range.end
- stop()
-
- endOfWordPosition ? currentBufferPosition
-
- # Public: Retrieves the buffer position of where the next word starts.
- #
- # * `options` (optional) {Object}
- # * `wordRegex` A {RegExp} indicating what constitutes a "word"
- # (default: {::wordRegExp}).
- #
- # Returns a {Range}
- getBeginningOfNextWordBufferPosition: (options = {}) ->
- currentBufferPosition = @getBufferPosition()
- start = if @isInsideWord(options) then @getEndOfCurrentWordBufferPosition(options) else currentBufferPosition
- scanRange = [start, @editor.getEofBufferPosition()]
-
- beginningOfNextWordPosition = null
- @editor.scanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) ->
- beginningOfNextWordPosition = range.start
- stop()
-
- beginningOfNextWordPosition or currentBufferPosition
-
- # Public: Returns the buffer Range occupied by the word located under the cursor.
- #
- # * `options` (optional) {Object}
- # * `wordRegex` A {RegExp} indicating what constitutes a "word"
- # (default: {::wordRegExp}).
- getCurrentWordBufferRange: (options={}) ->
- startOptions = Object.assign(_.clone(options), allowPrevious: false)
- endOptions = Object.assign(_.clone(options), allowNext: false)
- new Range(@getBeginningOfCurrentWordBufferPosition(startOptions), @getEndOfCurrentWordBufferPosition(endOptions))
-
- # Public: Returns the buffer Range for the current line.
- #
- # * `options` (optional) {Object}
- # * `includeNewline` A {Boolean} which controls whether the Range should
- # include the newline.
- getCurrentLineBufferRange: (options) ->
- @editor.bufferRangeForBufferRow(@getBufferRow(), options)
-
- # Public: Retrieves the range for the current paragraph.
- #
- # A paragraph is defined as a block of text surrounded by empty lines or comments.
- #
- # Returns a {Range}.
- getCurrentParagraphBufferRange: ->
- @editor.languageMode.rowRangeForParagraphAtBufferRow(@getBufferRow())
-
- # Public: Returns the characters preceding the cursor in the current word.
- getCurrentWordPrefix: ->
- @editor.getTextInBufferRange([@getBeginningOfCurrentWordBufferPosition(), @getBufferPosition()])
-
- ###
- Section: Visibility
- ###
-
- ###
- Section: Comparing to another cursor
- ###
-
- # Public: Compare this cursor's buffer position to another cursor's buffer position.
- #
- # See {Point::compare} for more details.
- #
- # * `otherCursor`{Cursor} to compare against
- compare: (otherCursor) ->
- @getBufferPosition().compare(otherCursor.getBufferPosition())
-
- ###
- Section: Utilities
- ###
-
- # Public: Deselects the current selection.
- clearSelection: (options) ->
- @selection?.clear(options)
-
- # Public: Get the RegExp used by the cursor to determine what a "word" is.
- #
- # * `options` (optional) {Object} with the following keys:
- # * `includeNonWordCharacters` A {Boolean} indicating whether to include
- # non-word characters in the regex. (default: true)
- #
- # Returns a {RegExp}.
- wordRegExp: (options) ->
- nonWordCharacters = _.escapeRegExp(@getNonWordCharacters())
- source = "^[\t ]*$|[^\\s#{nonWordCharacters}]+"
- if options?.includeNonWordCharacters ? true
- source += "|" + "[#{nonWordCharacters}]+"
- new RegExp(source, "g")
-
- # Public: Get the RegExp used by the cursor to determine what a "subword" is.
- #
- # * `options` (optional) {Object} with the following keys:
- # * `backwards` A {Boolean} indicating whether to look forwards or backwards
- # for the next subword. (default: false)
- #
- # Returns a {RegExp}.
- subwordRegExp: (options={}) ->
- nonWordCharacters = @getNonWordCharacters()
- lowercaseLetters = 'a-z\\u00DF-\\u00F6\\u00F8-\\u00FF'
- uppercaseLetters = 'A-Z\\u00C0-\\u00D6\\u00D8-\\u00DE'
- snakeCamelSegment = "[#{uppercaseLetters}]?[#{lowercaseLetters}]+"
- segments = [
- "^[\t ]+",
- "[\t ]+$",
- "[#{uppercaseLetters}]+(?![#{lowercaseLetters}])",
- "\\d+"
- ]
- if options.backwards
- segments.push("#{snakeCamelSegment}_*")
- segments.push("[#{_.escapeRegExp(nonWordCharacters)}]+\\s*")
- else
- segments.push("_*#{snakeCamelSegment}")
- segments.push("\\s*[#{_.escapeRegExp(nonWordCharacters)}]+")
- segments.push("_+")
- new RegExp(segments.join("|"), "g")
-
- ###
- Section: Private
- ###
-
- getNonWordCharacters: ->
- @editor.getNonWordCharacters(@getScopeDescriptor().getScopesArray())
-
- changePosition: (options, fn) ->
- @clearSelection(autoscroll: false)
- fn()
- @autoscroll() if options.autoscroll ? @isLastCursor()
-
- getScreenRange: ->
- {row, column} = @getScreenPosition()
- new Range(new Point(row, column), new Point(row, column + 1))
-
- autoscroll: (options = {}) ->
- options.clip = false
- @editor.scrollToScreenRange(@getScreenRange(), options)
-
- getBeginningOfNextParagraphBufferPosition: ->
- start = @getBufferPosition()
- eof = @editor.getEofBufferPosition()
- scanRange = [start, eof]
-
- {row, column} = eof
- position = new Point(row, column - 1)
-
- @editor.scanInBufferRange EmptyLineRegExp, scanRange, ({range, stop}) ->
- position = range.start.traverse(Point(1, 0))
- stop() unless position.isEqual(start)
- position
-
- getBeginningOfPreviousParagraphBufferPosition: ->
- start = @getBufferPosition()
-
- {row, column} = start
- scanRange = [[row-1, column], [0, 0]]
- position = new Point(0, 0)
- @editor.backwardsScanInBufferRange EmptyLineRegExp, scanRange, ({range, stop}) ->
- position = range.start.traverse(Point(1, 0))
- stop() unless position.isEqual(start)
- position
diff --git a/src/cursor.js b/src/cursor.js
new file mode 100644
index 000000000..6cd0cc623
--- /dev/null
+++ b/src/cursor.js
@@ -0,0 +1,754 @@
+const {Point, Range} = require('text-buffer')
+const {Emitter} = require('event-kit')
+const _ = require('underscore-plus')
+const Model = require('./model')
+
+const EmptyLineRegExp = /(\r\n[\t ]*\r\n)|(\n[\t ]*\n)/g
+
+// Extended: The `Cursor` class represents the little blinking line identifying
+// where text can be inserted.
+//
+// Cursors belong to {TextEditor}s and have some metadata attached in the form
+// of a {DisplayMarker}.
+module.exports =
+class Cursor extends Model {
+ // Instantiated by a {TextEditor}
+ constructor (params) {
+ super(params)
+ this.editor = params.editor
+ this.marker = params.marker
+ this.emitter = new Emitter()
+ }
+
+ destroy () {
+ this.marker.destroy()
+ }
+
+ /*
+ Section: Event Subscription
+ */
+
+ // Public: Calls your `callback` when the cursor has been moved.
+ //
+ // * `callback` {Function}
+ // * `event` {Object}
+ // * `oldBufferPosition` {Point}
+ // * `oldScreenPosition` {Point}
+ // * `newBufferPosition` {Point}
+ // * `newScreenPosition` {Point}
+ // * `textChanged` {Boolean}
+ // * `cursor` {Cursor} that triggered the event
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidChangePosition (callback) {
+ return this.emitter.on('did-change-position', callback)
+ }
+
+ // Public: Calls your `callback` when the cursor is destroyed
+ //
+ // * `callback` {Function}
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidDestroy (callback) {
+ return this.emitter.once('did-destroy', callback)
+ }
+
+ /*
+ Section: Managing Cursor Position
+ */
+
+ // Public: Moves a cursor to a given screen position.
+ //
+ // * `screenPosition` {Array} of two numbers: the screen row, and the screen column.
+ // * `options` (optional) {Object} with the following keys:
+ // * `autoscroll` A Boolean which, if `true`, scrolls the {TextEditor} to wherever
+ // the cursor moves to.
+ setScreenPosition (screenPosition, options = {}) {
+ this.changePosition(options, () => {
+ this.marker.setHeadScreenPosition(screenPosition, options)
+ })
+ }
+
+ // Public: Returns the screen position of the cursor as a {Point}.
+ getScreenPosition () {
+ return this.marker.getHeadScreenPosition()
+ }
+
+ // Public: Moves a cursor to a given buffer position.
+ //
+ // * `bufferPosition` {Array} of two numbers: the buffer row, and the buffer column.
+ // * `options` (optional) {Object} with the following keys:
+ // * `autoscroll` {Boolean} indicating whether to autoscroll to the new
+ // position. Defaults to `true` if this is the most recently added cursor,
+ // `false` otherwise.
+ setBufferPosition (bufferPosition, options = {}) {
+ this.changePosition(options, () => {
+ this.marker.setHeadBufferPosition(bufferPosition, options)
+ })
+ }
+
+ // Public: Returns the current buffer position as an Array.
+ getBufferPosition () {
+ return this.marker.getHeadBufferPosition()
+ }
+
+ // Public: Returns the cursor's current screen row.
+ getScreenRow () {
+ return this.getScreenPosition().row
+ }
+
+ // Public: Returns the cursor's current screen column.
+ getScreenColumn () {
+ return this.getScreenPosition().column
+ }
+
+ // Public: Retrieves the cursor's current buffer row.
+ getBufferRow () {
+ return this.getBufferPosition().row
+ }
+
+ // Public: Returns the cursor's current buffer column.
+ getBufferColumn () {
+ return this.getBufferPosition().column
+ }
+
+ // Public: Returns the cursor's current buffer row of text excluding its line
+ // ending.
+ getCurrentBufferLine () {
+ return this.editor.lineTextForBufferRow(this.getBufferRow())
+ }
+
+ // Public: Returns whether the cursor is at the start of a line.
+ isAtBeginningOfLine () {
+ return this.getBufferPosition().column === 0
+ }
+
+ // Public: Returns whether the cursor is on the line return character.
+ isAtEndOfLine () {
+ return this.getBufferPosition().isEqual(this.getCurrentLineBufferRange().end)
+ }
+
+ /*
+ Section: Cursor Position Details
+ */
+
+ // Public: Returns the underlying {DisplayMarker} for the cursor.
+ // Useful with overlay {Decoration}s.
+ getMarker () { return this.marker }
+
+ // Public: Identifies if the cursor is surrounded by whitespace.
+ //
+ // "Surrounded" here means that the character directly before and after the
+ // cursor are both whitespace.
+ //
+ // Returns a {Boolean}.
+ isSurroundedByWhitespace () {
+ const {row, column} = this.getBufferPosition()
+ const range = [[row, column - 1], [row, column + 1]]
+ return /^\s+$/.test(this.editor.getTextInBufferRange(range))
+ }
+
+ // Public: Returns whether the cursor is currently between a word and non-word
+ // character. The non-word characters are defined by the
+ // `editor.nonWordCharacters` config value.
+ //
+ // This method returns false if the character before or after the cursor is
+ // whitespace.
+ //
+ // Returns a Boolean.
+ isBetweenWordAndNonWord () {
+ if (this.isAtBeginningOfLine() || this.isAtEndOfLine()) return false
+
+ const {row, column} = this.getBufferPosition()
+ const range = [[row, column - 1], [row, column + 1]]
+ const text = this.editor.getTextInBufferRange(range)
+ if (/\s/.test(text[0]) || /\s/.test(text[1])) return false
+
+ const nonWordCharacters = this.getNonWordCharacters()
+ return nonWordCharacters.includes(text[0]) !== nonWordCharacters.includes(text[1])
+ }
+
+ // Public: Returns whether this cursor is between a word's start and end.
+ //
+ // * `options` (optional) {Object}
+ // * `wordRegex` A {RegExp} indicating what constitutes a "word"
+ // (default: {::wordRegExp}).
+ //
+ // Returns a {Boolean}
+ isInsideWord (options) {
+ const {row, column} = this.getBufferPosition()
+ const range = [[row, column], [row, Infinity]]
+ const text = this.editor.getTextInBufferRange(range)
+ return text.search((options && options.wordRegex) || this.wordRegExp()) === 0
+ }
+
+ // Public: Returns the indentation level of the current line.
+ getIndentLevel () {
+ if (this.editor.getSoftTabs()) {
+ return this.getBufferColumn() / this.editor.getTabLength()
+ } else {
+ return this.getBufferColumn()
+ }
+ }
+
+ // Public: Retrieves the scope descriptor for the cursor's current position.
+ //
+ // Returns a {ScopeDescriptor}
+ getScopeDescriptor () {
+ return this.editor.scopeDescriptorForBufferPosition(this.getBufferPosition())
+ }
+
+ // Public: Returns true if this cursor has no non-whitespace characters before
+ // its current position.
+ hasPrecedingCharactersOnLine () {
+ const bufferPosition = this.getBufferPosition()
+ const line = this.editor.lineTextForBufferRow(bufferPosition.row)
+ const firstCharacterColumn = line.search(/\S/)
+
+ if (firstCharacterColumn === -1) {
+ return false
+ } else {
+ return bufferPosition.column > firstCharacterColumn
+ }
+ }
+
+ // Public: Identifies if this cursor is the last in the {TextEditor}.
+ //
+ // "Last" is defined as the most recently added cursor.
+ //
+ // Returns a {Boolean}.
+ isLastCursor () {
+ return this === this.editor.getLastCursor()
+ }
+
+ /*
+ Section: Moving the Cursor
+ */
+
+ // Public: Moves the cursor up one screen row.
+ //
+ // * `rowCount` (optional) {Number} number of rows to move (default: 1)
+ // * `options` (optional) {Object} with the following keys:
+ // * `moveToEndOfSelection` if true, move to the left of the selection if a
+ // selection exists.
+ moveUp (rowCount = 1, {moveToEndOfSelection} = {}) {
+ let row, column
+ const range = this.marker.getScreenRange()
+ if (moveToEndOfSelection && !range.isEmpty()) {
+ ({row, column} = range.start)
+ } else {
+ ({row, column} = this.getScreenPosition())
+ }
+
+ if (this.goalColumn != null) column = this.goalColumn
+ this.setScreenPosition({row: row - rowCount, column}, {skipSoftWrapIndentation: true})
+ this.goalColumn = column
+ }
+
+ // Public: Moves the cursor down one screen row.
+ //
+ // * `rowCount` (optional) {Number} number of rows to move (default: 1)
+ // * `options` (optional) {Object} with the following keys:
+ // * `moveToEndOfSelection` if true, move to the left of the selection if a
+ // selection exists.
+ moveDown (rowCount = 1, {moveToEndOfSelection} = {}) {
+ let row, column
+ const range = this.marker.getScreenRange()
+ if (moveToEndOfSelection && !range.isEmpty()) {
+ ({row, column} = range.end)
+ } else {
+ ({row, column} = this.getScreenPosition())
+ }
+
+ if (this.goalColumn != null) column = this.goalColumn
+ this.setScreenPosition({row: row + rowCount, column}, {skipSoftWrapIndentation: true})
+ this.goalColumn = column
+ }
+
+ // Public: Moves the cursor left one screen column.
+ //
+ // * `columnCount` (optional) {Number} number of columns to move (default: 1)
+ // * `options` (optional) {Object} with the following keys:
+ // * `moveToEndOfSelection` if true, move to the left of the selection if a
+ // selection exists.
+ moveLeft (columnCount = 1, {moveToEndOfSelection} = {}) {
+ const range = this.marker.getScreenRange()
+ if (moveToEndOfSelection && !range.isEmpty()) {
+ this.setScreenPosition(range.start)
+ } else {
+ let {row, column} = this.getScreenPosition()
+
+ while (columnCount > column && row > 0) {
+ columnCount -= column
+ column = this.editor.lineLengthForScreenRow(--row)
+ columnCount-- // subtract 1 for the row move
+ }
+
+ column = column - columnCount
+ this.setScreenPosition({row, column}, {clipDirection: 'backward'})
+ }
+ }
+
+ // Public: Moves the cursor right one screen column.
+ //
+ // * `columnCount` (optional) {Number} number of columns to move (default: 1)
+ // * `options` (optional) {Object} with the following keys:
+ // * `moveToEndOfSelection` if true, move to the right of the selection if a
+ // selection exists.
+ moveRight (columnCount = 1, {moveToEndOfSelection} = {}) {
+ const range = this.marker.getScreenRange()
+ if (moveToEndOfSelection && !range.isEmpty()) {
+ this.setScreenPosition(range.end)
+ } else {
+ let {row, column} = this.getScreenPosition()
+ const maxLines = this.editor.getScreenLineCount()
+ let rowLength = this.editor.lineLengthForScreenRow(row)
+ let columnsRemainingInLine = rowLength - column
+
+ while (columnCount > columnsRemainingInLine && row < maxLines - 1) {
+ columnCount -= columnsRemainingInLine
+ columnCount-- // subtract 1 for the row move
+
+ column = 0
+ rowLength = this.editor.lineLengthForScreenRow(++row)
+ columnsRemainingInLine = rowLength
+ }
+
+ column = column + columnCount
+ this.setScreenPosition({row, column}, {clipDirection: 'forward'})
+ }
+ }
+
+ // Public: Moves the cursor to the top of the buffer.
+ moveToTop () {
+ this.setBufferPosition([0, 0])
+ }
+
+ // Public: Moves the cursor to the bottom of the buffer.
+ moveToBottom () {
+ this.setBufferPosition(this.editor.getEofBufferPosition())
+ }
+
+ // Public: Moves the cursor to the beginning of the line.
+ moveToBeginningOfScreenLine () {
+ this.setScreenPosition([this.getScreenRow(), 0])
+ }
+
+ // Public: Moves the cursor to the beginning of the buffer line.
+ moveToBeginningOfLine () {
+ this.setBufferPosition([this.getBufferRow(), 0])
+ }
+
+ // Public: Moves the cursor to the beginning of the first character in the
+ // line.
+ moveToFirstCharacterOfLine () {
+ let targetBufferColumn
+ const screenRow = this.getScreenRow()
+ const screenLineStart = this.editor.clipScreenPosition([screenRow, 0], {skipSoftWrapIndentation: true})
+ const screenLineEnd = [screenRow, Infinity]
+ const screenLineBufferRange = this.editor.bufferRangeForScreenRange([screenLineStart, screenLineEnd])
+
+ let firstCharacterColumn = null
+ this.editor.scanInBufferRange(/\S/, screenLineBufferRange, ({range, stop}) => {
+ firstCharacterColumn = range.start.column
+ stop()
+ })
+
+ if (firstCharacterColumn != null && firstCharacterColumn !== this.getBufferColumn()) {
+ targetBufferColumn = firstCharacterColumn
+ } else {
+ targetBufferColumn = screenLineBufferRange.start.column
+ }
+
+ this.setBufferPosition([screenLineBufferRange.start.row, targetBufferColumn])
+ }
+
+ // Public: Moves the cursor to the end of the line.
+ moveToEndOfScreenLine () {
+ this.setScreenPosition([this.getScreenRow(), Infinity])
+ }
+
+ // Public: Moves the cursor to the end of the buffer line.
+ moveToEndOfLine () {
+ this.setBufferPosition([this.getBufferRow(), Infinity])
+ }
+
+ // Public: Moves the cursor to the beginning of the word.
+ moveToBeginningOfWord () {
+ this.setBufferPosition(this.getBeginningOfCurrentWordBufferPosition())
+ }
+
+ // Public: Moves the cursor to the end of the word.
+ moveToEndOfWord () {
+ const position = this.getEndOfCurrentWordBufferPosition()
+ if (position) this.setBufferPosition(position)
+ }
+
+ // Public: Moves the cursor to the beginning of the next word.
+ moveToBeginningOfNextWord () {
+ const position = this.getBeginningOfNextWordBufferPosition()
+ if (position) this.setBufferPosition(position)
+ }
+
+ // Public: Moves the cursor to the previous word boundary.
+ moveToPreviousWordBoundary () {
+ const position = this.getPreviousWordBoundaryBufferPosition()
+ if (position) this.setBufferPosition(position)
+ }
+
+ // Public: Moves the cursor to the next word boundary.
+ moveToNextWordBoundary () {
+ const position = this.getNextWordBoundaryBufferPosition()
+ if (position) this.setBufferPosition(position)
+ }
+
+ // Public: Moves the cursor to the previous subword boundary.
+ moveToPreviousSubwordBoundary () {
+ const options = {wordRegex: this.subwordRegExp({backwards: true})}
+ const position = this.getPreviousWordBoundaryBufferPosition(options)
+ if (position) this.setBufferPosition(position)
+ }
+
+ // Public: Moves the cursor to the next subword boundary.
+ moveToNextSubwordBoundary () {
+ const options = {wordRegex: this.subwordRegExp()}
+ const position = this.getNextWordBoundaryBufferPosition(options)
+ if (position) this.setBufferPosition(position)
+ }
+
+ // Public: Moves the cursor to the beginning of the buffer line, skipping all
+ // whitespace.
+ skipLeadingWhitespace () {
+ const position = this.getBufferPosition()
+ const scanRange = this.getCurrentLineBufferRange()
+ let endOfLeadingWhitespace = null
+ this.editor.scanInBufferRange(/^[ \t]*/, scanRange, ({range}) => {
+ endOfLeadingWhitespace = range.end
+ })
+
+ if (endOfLeadingWhitespace.isGreaterThan(position)) this.setBufferPosition(endOfLeadingWhitespace)
+ }
+
+ // Public: Moves the cursor to the beginning of the next paragraph
+ moveToBeginningOfNextParagraph () {
+ const position = this.getBeginningOfNextParagraphBufferPosition()
+ if (position) this.setBufferPosition(position)
+ }
+
+ // Public: Moves the cursor to the beginning of the previous paragraph
+ moveToBeginningOfPreviousParagraph () {
+ const position = this.getBeginningOfPreviousParagraphBufferPosition()
+ if (position) this.setBufferPosition(position)
+ }
+
+ /*
+ Section: Local Positions and Ranges
+ */
+
+ // Public: Returns buffer position of previous word boundary. It might be on
+ // the current word, or the previous word.
+ //
+ // * `options` (optional) {Object} with the following keys:
+ // * `wordRegex` A {RegExp} indicating what constitutes a "word"
+ // (default: {::wordRegExp})
+ getPreviousWordBoundaryBufferPosition (options = {}) {
+ const currentBufferPosition = this.getBufferPosition()
+ const previousNonBlankRow = this.editor.buffer.previousNonBlankRow(currentBufferPosition.row)
+ const scanRange = [[previousNonBlankRow || 0, 0], currentBufferPosition]
+
+ let beginningOfWordPosition
+ this.editor.backwardsScanInBufferRange(options.wordRegex || this.wordRegExp(), scanRange, ({range, stop}) => {
+ if (range.start.row < currentBufferPosition.row && currentBufferPosition.column > 0) {
+ // force it to stop at the beginning of each line
+ beginningOfWordPosition = new Point(currentBufferPosition.row, 0)
+ } else if (range.end.isLessThan(currentBufferPosition)) {
+ beginningOfWordPosition = range.end
+ } else {
+ beginningOfWordPosition = range.start
+ }
+
+ if (!beginningOfWordPosition.isEqual(currentBufferPosition)) stop()
+ })
+
+ return beginningOfWordPosition || currentBufferPosition
+ }
+
+ // Public: Returns buffer position of the next word boundary. It might be on
+ // the current word, or the previous word.
+ //
+ // * `options` (optional) {Object} with the following keys:
+ // * `wordRegex` A {RegExp} indicating what constitutes a "word"
+ // (default: {::wordRegExp})
+ getNextWordBoundaryBufferPosition (options = {}) {
+ const currentBufferPosition = this.getBufferPosition()
+ const scanRange = [currentBufferPosition, this.editor.getEofBufferPosition()]
+
+ let endOfWordPosition
+ this.editor.scanInBufferRange((options.wordRegex != null ? options.wordRegex : this.wordRegExp()), scanRange, function ({range, stop}) {
+ if (range.start.row > currentBufferPosition.row) {
+ // force it to stop at the beginning of each line
+ endOfWordPosition = new Point(range.start.row, 0)
+ } else if (range.start.isGreaterThan(currentBufferPosition)) {
+ endOfWordPosition = range.start
+ } else {
+ endOfWordPosition = range.end
+ }
+
+ if (!endOfWordPosition.isEqual(currentBufferPosition)) stop()
+ })
+
+ return endOfWordPosition || currentBufferPosition
+ }
+
+ // Public: Retrieves the buffer position of where the current word starts.
+ //
+ // * `options` (optional) An {Object} with the following keys:
+ // * `wordRegex` A {RegExp} indicating what constitutes a "word"
+ // (default: {::wordRegExp}).
+ // * `includeNonWordCharacters` A {Boolean} indicating whether to include
+ // non-word characters in the default word regex.
+ // Has no effect if wordRegex is set.
+ // * `allowPrevious` A {Boolean} indicating whether the beginning of the
+ // previous word can be returned.
+ //
+ // Returns a {Range}.
+ getBeginningOfCurrentWordBufferPosition (options = {}) {
+ const allowPrevious = options.allowPrevious !== false
+ const position = this.getBufferPosition()
+
+ const scanRange = allowPrevious
+ ? new Range(new Point(position.row - 1, 0), position)
+ : new Range(new Point(position.row, 0), position)
+
+ const ranges = this.editor.buffer.findAllInRangeSync(
+ options.wordRegex || this.wordRegExp(),
+ scanRange
+ )
+
+ let result
+ for (let range of ranges) {
+ if (position.isLessThanOrEqual(range.start)) break
+ if (allowPrevious || position.isLessThanOrEqual(range.end)) result = Point.fromObject(range.start)
+ }
+
+ return result || (allowPrevious ? new Point(0, 0) : position)
+ }
+
+ // Public: Retrieves the buffer position of where the current word ends.
+ //
+ // * `options` (optional) {Object} with the following keys:
+ // * `wordRegex` A {RegExp} indicating what constitutes a "word"
+ // (default: {::wordRegExp})
+ // * `includeNonWordCharacters` A Boolean indicating whether to include
+ // non-word characters in the default word regex. Has no effect if
+ // wordRegex is set.
+ //
+ // Returns a {Range}.
+ getEndOfCurrentWordBufferPosition (options = {}) {
+ const allowNext = options.allowNext !== false
+ const position = this.getBufferPosition()
+
+ const scanRange = allowNext
+ ? new Range(position, new Point(position.row + 2, 0))
+ : new Range(position, new Point(position.row, Infinity))
+
+ const ranges = this.editor.buffer.findAllInRangeSync(
+ options.wordRegex || this.wordRegExp(),
+ scanRange
+ )
+
+ for (let range of ranges) {
+ if (position.isLessThan(range.start) && !allowNext) break
+ if (position.isLessThan(range.end)) return Point.fromObject(range.end)
+ }
+
+ return allowNext ? this.editor.getEofBufferPosition() : position
+ }
+
+ // Public: Retrieves the buffer position of where the next word starts.
+ //
+ // * `options` (optional) {Object}
+ // * `wordRegex` A {RegExp} indicating what constitutes a "word"
+ // (default: {::wordRegExp}).
+ //
+ // Returns a {Range}
+ getBeginningOfNextWordBufferPosition (options = {}) {
+ const currentBufferPosition = this.getBufferPosition()
+ const start = this.isInsideWord(options) ? this.getEndOfCurrentWordBufferPosition(options) : currentBufferPosition
+ const scanRange = [start, this.editor.getEofBufferPosition()]
+
+ let beginningOfNextWordPosition
+ this.editor.scanInBufferRange(options.wordRegex || this.wordRegExp(), scanRange, ({range, stop}) => {
+ beginningOfNextWordPosition = range.start
+ stop()
+ })
+
+ return beginningOfNextWordPosition || currentBufferPosition
+ }
+
+ // Public: Returns the buffer Range occupied by the word located under the cursor.
+ //
+ // * `options` (optional) {Object}
+ // * `wordRegex` A {RegExp} indicating what constitutes a "word"
+ // (default: {::wordRegExp}).
+ getCurrentWordBufferRange (options = {}) {
+ const position = this.getBufferPosition()
+ const ranges = this.editor.buffer.findAllInRangeSync(
+ options.wordRegex || this.wordRegExp(),
+ new Range(new Point(position.row, 0), new Point(position.row, Infinity))
+ )
+ const range = ranges.find(range =>
+ range.end.column >= position.column && range.start.column <= position.column
+ )
+ return range ? Range.fromObject(range) : new Range(position, position)
+ }
+
+ // Public: Returns the buffer Range for the current line.
+ //
+ // * `options` (optional) {Object}
+ // * `includeNewline` A {Boolean} which controls whether the Range should
+ // include the newline.
+ getCurrentLineBufferRange (options) {
+ return this.editor.bufferRangeForBufferRow(this.getBufferRow(), options)
+ }
+
+ // Public: Retrieves the range for the current paragraph.
+ //
+ // A paragraph is defined as a block of text surrounded by empty lines or comments.
+ //
+ // Returns a {Range}.
+ getCurrentParagraphBufferRange () {
+ return this.editor.rowRangeForParagraphAtBufferRow(this.getBufferRow())
+ }
+
+ // Public: Returns the characters preceding the cursor in the current word.
+ getCurrentWordPrefix () {
+ return this.editor.getTextInBufferRange([this.getBeginningOfCurrentWordBufferPosition(), this.getBufferPosition()])
+ }
+
+ /*
+ Section: Visibility
+ */
+
+ /*
+ Section: Comparing to another cursor
+ */
+
+ // Public: Compare this cursor's buffer position to another cursor's buffer position.
+ //
+ // See {Point::compare} for more details.
+ //
+ // * `otherCursor`{Cursor} to compare against
+ compare (otherCursor) {
+ return this.getBufferPosition().compare(otherCursor.getBufferPosition())
+ }
+
+ /*
+ Section: Utilities
+ */
+
+ // Public: Deselects the current selection.
+ clearSelection (options) {
+ if (this.selection) this.selection.clear(options)
+ }
+
+ // Public: Get the RegExp used by the cursor to determine what a "word" is.
+ //
+ // * `options` (optional) {Object} with the following keys:
+ // * `includeNonWordCharacters` A {Boolean} indicating whether to include
+ // non-word characters in the regex. (default: true)
+ //
+ // Returns a {RegExp}.
+ wordRegExp (options) {
+ const nonWordCharacters = _.escapeRegExp(this.getNonWordCharacters())
+ let source = `^[\t\r ]*$|[^\\s${nonWordCharacters}]+`
+ if (!options || options.includeNonWordCharacters !== false) {
+ source += `|${`[${nonWordCharacters}]+`}`
+ }
+ return new RegExp(source, 'g')
+ }
+
+ // Public: Get the RegExp used by the cursor to determine what a "subword" is.
+ //
+ // * `options` (optional) {Object} with the following keys:
+ // * `backwards` A {Boolean} indicating whether to look forwards or backwards
+ // for the next subword. (default: false)
+ //
+ // Returns a {RegExp}.
+ subwordRegExp (options = {}) {
+ const nonWordCharacters = this.getNonWordCharacters()
+ const lowercaseLetters = 'a-z\\u00DF-\\u00F6\\u00F8-\\u00FF'
+ const uppercaseLetters = 'A-Z\\u00C0-\\u00D6\\u00D8-\\u00DE'
+ const snakeCamelSegment = `[${uppercaseLetters}]?[${lowercaseLetters}]+`
+ const segments = [
+ '^[\t ]+',
+ '[\t ]+$',
+ `[${uppercaseLetters}]+(?![${lowercaseLetters}])`,
+ '\\d+'
+ ]
+ if (options.backwards) {
+ segments.push(`${snakeCamelSegment}_*`)
+ segments.push(`[${_.escapeRegExp(nonWordCharacters)}]+\\s*`)
+ } else {
+ segments.push(`_*${snakeCamelSegment}`)
+ segments.push(`\\s*[${_.escapeRegExp(nonWordCharacters)}]+`)
+ }
+ segments.push('_+')
+ return new RegExp(segments.join('|'), 'g')
+ }
+
+ /*
+ Section: Private
+ */
+
+ getNonWordCharacters () {
+ return this.editor.getNonWordCharacters(this.getScopeDescriptor().getScopesArray())
+ }
+
+ changePosition (options, fn) {
+ this.clearSelection({autoscroll: false})
+ fn()
+ const autoscroll = (options && options.autoscroll != null)
+ ? options.autoscroll
+ : this.isLastCursor()
+ if (autoscroll) this.autoscroll()
+ }
+
+ getScreenRange () {
+ const {row, column} = this.getScreenPosition()
+ return new Range(new Point(row, column), new Point(row, column + 1))
+ }
+
+ autoscroll (options = {}) {
+ options.clip = false
+ this.editor.scrollToScreenRange(this.getScreenRange(), options)
+ }
+
+ getBeginningOfNextParagraphBufferPosition () {
+ const start = this.getBufferPosition()
+ const eof = this.editor.getEofBufferPosition()
+ const scanRange = [start, eof]
+
+ const {row, column} = eof
+ let position = new Point(row, column - 1)
+
+ this.editor.scanInBufferRange(EmptyLineRegExp, scanRange, ({range, stop}) => {
+ position = range.start.traverse(Point(1, 0))
+ if (!position.isEqual(start)) stop()
+ })
+ return position
+ }
+
+ getBeginningOfPreviousParagraphBufferPosition () {
+ const start = this.getBufferPosition()
+
+ const {row, column} = start
+ const scanRange = [[row - 1, column], [0, 0]]
+ let position = new Point(0, 0)
+ this.editor.backwardsScanInBufferRange(EmptyLineRegExp, scanRange, ({range, stop}) => {
+ position = range.start.traverse(Point(1, 0))
+ if (!position.isEqual(start)) stop()
+ })
+ return position
+ }
+}
diff --git a/src/decoration.coffee b/src/decoration.coffee
deleted file mode 100644
index f18733f6e..000000000
--- a/src/decoration.coffee
+++ /dev/null
@@ -1,178 +0,0 @@
-_ = require 'underscore-plus'
-{Emitter} = require 'event-kit'
-
-idCounter = 0
-nextId = -> idCounter++
-
-# Applies changes to a decorationsParam {Object} to make it possible to
-# differentiate decorations on custom gutters versus the line-number gutter.
-translateDecorationParamsOldToNew = (decorationParams) ->
- if decorationParams.type is 'line-number'
- decorationParams.gutterName = 'line-number'
- decorationParams
-
-# Essential: Represents a decoration that follows a {DisplayMarker}. A decoration is
-# basically a visual representation of a marker. It allows you to add CSS
-# classes to line numbers in the gutter, lines, and add selection-line regions
-# around marked ranges of text.
-#
-# {Decoration} objects are not meant to be created directly, but created with
-# {TextEditor::decorateMarker}. eg.
-#
-# ```coffee
-# range = editor.getSelectedBufferRange() # any range you like
-# marker = editor.markBufferRange(range)
-# decoration = editor.decorateMarker(marker, {type: 'line', class: 'my-line-class'})
-# ```
-#
-# Best practice for destroying the decoration is by destroying the {DisplayMarker}.
-#
-# ```coffee
-# marker.destroy()
-# ```
-#
-# You should only use {Decoration::destroy} when you still need or do not own
-# the marker.
-module.exports =
-class Decoration
- # Private: Check if the `decorationProperties.type` matches `type`
- #
- # * `decorationProperties` {Object} eg. `{type: 'line-number', class: 'my-new-class'}`
- # * `type` {String} type like `'line-number'`, `'line'`, etc. `type` can also
- # be an {Array} of {String}s, where it will return true if the decoration's
- # type matches any in the array.
- #
- # Returns {Boolean}
- # Note: 'line-number' is a special subtype of the 'gutter' type. I.e., a
- # 'line-number' is a 'gutter', but a 'gutter' is not a 'line-number'.
- @isType: (decorationProperties, type) ->
- # 'line-number' is a special case of 'gutter'.
- if _.isArray(decorationProperties.type)
- return true if type in decorationProperties.type
- if type is 'gutter'
- return true if 'line-number' in decorationProperties.type
- return false
- else
- if type is 'gutter'
- return true if decorationProperties.type in ['gutter', 'line-number']
- else
- type is decorationProperties.type
-
- ###
- Section: Construction and Destruction
- ###
-
- constructor: (@marker, @decorationManager, properties) ->
- @emitter = new Emitter
- @id = nextId()
- @setProperties properties
- @destroyed = false
- @markerDestroyDisposable = @marker.onDidDestroy => @destroy()
-
- # Essential: Destroy this marker decoration.
- #
- # You can also destroy the marker if you own it, which will destroy this
- # decoration.
- destroy: ->
- return if @destroyed
- @markerDestroyDisposable.dispose()
- @markerDestroyDisposable = null
- @destroyed = true
- @decorationManager.didDestroyMarkerDecoration(this)
- @emitter.emit 'did-destroy'
- @emitter.dispose()
-
- isDestroyed: -> @destroyed
-
- ###
- Section: Event Subscription
- ###
-
- # Essential: When the {Decoration} is updated via {Decoration::update}.
- #
- # * `callback` {Function}
- # * `event` {Object}
- # * `oldProperties` {Object} the old parameters the decoration used to have
- # * `newProperties` {Object} the new parameters the decoration now has
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidChangeProperties: (callback) ->
- @emitter.on 'did-change-properties', callback
-
- # Essential: Invoke the given callback when the {Decoration} is destroyed
- #
- # * `callback` {Function}
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidDestroy: (callback) ->
- @emitter.once 'did-destroy', callback
-
- ###
- Section: Decoration Details
- ###
-
- # Essential: An id unique across all {Decoration} objects
- getId: -> @id
-
- # Essential: Returns the marker associated with this {Decoration}
- getMarker: -> @marker
-
- # Public: Check if this decoration is of type `type`
- #
- # * `type` {String} type like `'line-number'`, `'line'`, etc. `type` can also
- # be an {Array} of {String}s, where it will return true if the decoration's
- # type matches any in the array.
- #
- # Returns {Boolean}
- isType: (type) ->
- Decoration.isType(@properties, type)
-
- ###
- Section: Properties
- ###
-
- # Essential: Returns the {Decoration}'s properties.
- getProperties: ->
- @properties
-
- # Essential: Update the marker with new Properties. Allows you to change the decoration's class.
- #
- # ## Examples
- #
- # ```coffee
- # decoration.update({type: 'line-number', class: 'my-new-class'})
- # ```
- #
- # * `newProperties` {Object} eg. `{type: 'line-number', class: 'my-new-class'}`
- setProperties: (newProperties) ->
- return if @destroyed
- oldProperties = @properties
- @properties = translateDecorationParamsOldToNew(newProperties)
- if newProperties.type?
- @decorationManager.decorationDidChangeType(this)
- @decorationManager.emitDidUpdateDecorations()
- @emitter.emit 'did-change-properties', {oldProperties, newProperties}
-
- ###
- Section: Utility
- ###
-
- inspect: ->
- ""
-
- ###
- Section: Private methods
- ###
-
- matchesPattern: (decorationPattern) ->
- return false unless decorationPattern?
- for key, value of decorationPattern
- return false if @properties[key] isnt value
- true
-
- flash: (klass, duration=500) ->
- @properties.flashRequested = true
- @properties.flashClass = klass
- @properties.flashDuration = duration
- @decorationManager.emitDidUpdateDecorations()
- @emitter.emit 'did-flash'
diff --git a/src/decoration.js b/src/decoration.js
new file mode 100644
index 000000000..731935506
--- /dev/null
+++ b/src/decoration.js
@@ -0,0 +1,205 @@
+const _ = require('underscore-plus')
+const {Emitter} = require('event-kit')
+
+let idCounter = 0
+const nextId = () => idCounter++
+
+// Applies changes to a decorationsParam {Object} to make it possible to
+// differentiate decorations on custom gutters versus the line-number gutter.
+const translateDecorationParamsOldToNew = function (decorationParams) {
+ if (decorationParams.type === 'line-number') {
+ decorationParams.gutterName = 'line-number'
+ }
+ return decorationParams
+}
+
+// Essential: Represents a decoration that follows a {DisplayMarker}. A decoration is
+// basically a visual representation of a marker. It allows you to add CSS
+// classes to line numbers in the gutter, lines, and add selection-line regions
+// around marked ranges of text.
+//
+// {Decoration} objects are not meant to be created directly, but created with
+// {TextEditor::decorateMarker}. eg.
+//
+// ```coffee
+// range = editor.getSelectedBufferRange() # any range you like
+// marker = editor.markBufferRange(range)
+// decoration = editor.decorateMarker(marker, {type: 'line', class: 'my-line-class'})
+// ```
+//
+// Best practice for destroying the decoration is by destroying the {DisplayMarker}.
+//
+// ```coffee
+// marker.destroy()
+// ```
+//
+// You should only use {Decoration::destroy} when you still need or do not own
+// the marker.
+module.exports =
+class Decoration {
+ // Private: Check if the `decorationProperties.type` matches `type`
+ //
+ // * `decorationProperties` {Object} eg. `{type: 'line-number', class: 'my-new-class'}`
+ // * `type` {String} type like `'line-number'`, `'line'`, etc. `type` can also
+ // be an {Array} of {String}s, where it will return true if the decoration's
+ // type matches any in the array.
+ //
+ // Returns {Boolean}
+ // Note: 'line-number' is a special subtype of the 'gutter' type. I.e., a
+ // 'line-number' is a 'gutter', but a 'gutter' is not a 'line-number'.
+ static isType (decorationProperties, type) {
+ // 'line-number' is a special case of 'gutter'.
+ if (_.isArray(decorationProperties.type)) {
+ if (decorationProperties.type.includes(type)) {
+ return true
+ }
+
+ if (type === 'gutter' && decorationProperties.type.includes('line-number')) {
+ return true
+ }
+
+ return false
+ } else {
+ if (type === 'gutter') {
+ return ['gutter', 'line-number'].includes(decorationProperties.type)
+ } else {
+ return type === decorationProperties.type
+ }
+ }
+ }
+
+ /*
+ Section: Construction and Destruction
+ */
+
+ constructor (marker, decorationManager, properties) {
+ this.marker = marker
+ this.decorationManager = decorationManager
+ this.emitter = new Emitter()
+ this.id = nextId()
+ this.setProperties(properties)
+ this.destroyed = false
+ this.markerDestroyDisposable = this.marker.onDidDestroy(() => this.destroy())
+ }
+
+ // Essential: Destroy this marker decoration.
+ //
+ // You can also destroy the marker if you own it, which will destroy this
+ // decoration.
+ destroy () {
+ if (this.destroyed) { return }
+ this.markerDestroyDisposable.dispose()
+ this.markerDestroyDisposable = null
+ this.destroyed = true
+ this.decorationManager.didDestroyMarkerDecoration(this)
+ this.emitter.emit('did-destroy')
+ return this.emitter.dispose()
+ }
+
+ isDestroyed () { return this.destroyed }
+
+ /*
+ Section: Event Subscription
+ */
+
+ // Essential: When the {Decoration} is updated via {Decoration::update}.
+ //
+ // * `callback` {Function}
+ // * `event` {Object}
+ // * `oldProperties` {Object} the old parameters the decoration used to have
+ // * `newProperties` {Object} the new parameters the decoration now has
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidChangeProperties (callback) {
+ return this.emitter.on('did-change-properties', callback)
+ }
+
+ // Essential: Invoke the given callback when the {Decoration} is destroyed
+ //
+ // * `callback` {Function}
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidDestroy (callback) {
+ return this.emitter.once('did-destroy', callback)
+ }
+
+ /*
+ Section: Decoration Details
+ */
+
+ // Essential: An id unique across all {Decoration} objects
+ getId () { return this.id }
+
+ // Essential: Returns the marker associated with this {Decoration}
+ getMarker () { return this.marker }
+
+ // Public: Check if this decoration is of type `type`
+ //
+ // * `type` {String} type like `'line-number'`, `'line'`, etc. `type` can also
+ // be an {Array} of {String}s, where it will return true if the decoration's
+ // type matches any in the array.
+ //
+ // Returns {Boolean}
+ isType (type) {
+ return Decoration.isType(this.properties, type)
+ }
+
+ /*
+ Section: Properties
+ */
+
+ // Essential: Returns the {Decoration}'s properties.
+ getProperties () {
+ return this.properties
+ }
+
+ // Essential: Update the marker with new Properties. Allows you to change the decoration's class.
+ //
+ // ## Examples
+ //
+ // ```coffee
+ // decoration.update({type: 'line-number', class: 'my-new-class'})
+ // ```
+ //
+ // * `newProperties` {Object} eg. `{type: 'line-number', class: 'my-new-class'}`
+ setProperties (newProperties) {
+ if (this.destroyed) { return }
+ const oldProperties = this.properties
+ this.properties = translateDecorationParamsOldToNew(newProperties)
+ if (newProperties.type != null) {
+ this.decorationManager.decorationDidChangeType(this)
+ }
+ this.decorationManager.emitDidUpdateDecorations()
+ return this.emitter.emit('did-change-properties', {oldProperties, newProperties})
+ }
+
+ /*
+ Section: Utility
+ */
+
+ inspect () {
+ return ``
+ }
+
+ /*
+ Section: Private methods
+ */
+
+ matchesPattern (decorationPattern) {
+ if (decorationPattern == null) { return false }
+ for (let key in decorationPattern) {
+ const value = decorationPattern[key]
+ if (this.properties[key] !== value) { return false }
+ }
+ return true
+ }
+
+ flash (klass, duration) {
+ if (duration == null) { duration = 500 }
+ this.properties.flashRequested = true
+ this.properties.flashClass = klass
+ this.properties.flashDuration = duration
+ this.decorationManager.emitDidUpdateDecorations()
+ return this.emitter.emit('did-flash')
+ }
+}
diff --git a/src/default-directory-provider.coffee b/src/default-directory-provider.coffee
index 44d5298dd..e55379092 100644
--- a/src/default-directory-provider.coffee
+++ b/src/default-directory-provider.coffee
@@ -13,7 +13,7 @@ class DefaultDirectoryProvider
#
# Returns:
# * {Directory} if the given URI is compatible with this provider.
- # * `null` if the given URI is not compatibile with this provider.
+ # * `null` if the given URI is not compatible with this provider.
directoryForURISync: (uri) ->
normalizedPath = @normalizePath(uri)
{host} = url.parse(uri)
@@ -39,7 +39,7 @@ class DefaultDirectoryProvider
#
# Returns a {Promise} that resolves to:
# * {Directory} if the given URI is compatible with this provider.
- # * `null` if the given URI is not compatibile with this provider.
+ # * `null` if the given URI is not compatible with this provider.
directoryForURI: (uri) ->
Promise.resolve(@directoryForURISync(uri))
diff --git a/src/dock.js b/src/dock.js
index 30284f884..7f2856800 100644
--- a/src/dock.js
+++ b/src/dock.js
@@ -119,7 +119,7 @@ module.exports = class Dock {
this.setState({visible: false})
}
- // Extended: Toggle the dock's visiblity without changing the {Workspace}'s
+ // Extended: Toggle the dock's visibility without changing the {Workspace}'s
// active pane container.
toggle () {
const state = {visible: !this.state.visible}
@@ -143,7 +143,7 @@ module.exports = class Dock {
// frame to ensure the property is animated (or not) appropriately, however we luck out in this
// case because the drag start always happens before the item is dragged into the toggle button.
if (nextState.visible !== prevState.visible) {
- // Never animate toggling visiblity...
+ // Never animate toggling visibility...
nextState.shouldAnimate = false
} else if (!nextState.visible && nextState.draggingItem && !prevState.draggingItem) {
// ...but do animate if you start dragging while the panel is hidden.
diff --git a/src/git-repository.coffee b/src/git-repository.coffee
deleted file mode 100644
index c7105baef..000000000
--- a/src/git-repository.coffee
+++ /dev/null
@@ -1,496 +0,0 @@
-{join} = require 'path'
-
-_ = require 'underscore-plus'
-{Emitter, Disposable, CompositeDisposable} = require 'event-kit'
-fs = require 'fs-plus'
-path = require 'path'
-GitUtils = require 'git-utils'
-
-Task = require './task'
-
-# Extended: Represents the underlying git operations performed by Atom.
-#
-# This class shouldn't be instantiated directly but instead by accessing the
-# `atom.project` global and calling `getRepositories()`. Note that this will
-# only be available when the project is backed by a Git repository.
-#
-# This class handles submodules automatically by taking a `path` argument to many
-# of the methods. This `path` argument will determine which underlying
-# repository is used.
-#
-# For a repository with submodules this would have the following outcome:
-#
-# ```coffee
-# repo = atom.project.getRepositories()[0]
-# repo.getShortHead() # 'master'
-# repo.getShortHead('vendor/path/to/a/submodule') # 'dead1234'
-# ```
-#
-# ## Examples
-#
-# ### Logging the URL of the origin remote
-#
-# ```coffee
-# git = atom.project.getRepositories()[0]
-# console.log git.getOriginURL()
-# ```
-#
-# ### Requiring in packages
-#
-# ```coffee
-# {GitRepository} = require 'atom'
-# ```
-module.exports =
-class GitRepository
- @exists: (path) ->
- if git = @open(path)
- git.destroy()
- true
- else
- false
-
- ###
- Section: Construction and Destruction
- ###
-
- # Public: Creates a new GitRepository instance.
- #
- # * `path` The {String} path to the Git repository to open.
- # * `options` An optional {Object} with the following keys:
- # * `refreshOnWindowFocus` A {Boolean}, `true` to refresh the index and
- # statuses when the window is focused.
- #
- # Returns a {GitRepository} instance or `null` if the repository could not be opened.
- @open: (path, options) ->
- return null unless path
- try
- new GitRepository(path, options)
- catch
- null
-
- constructor: (path, options={}) ->
- @emitter = new Emitter
- @subscriptions = new CompositeDisposable
-
- @repo = GitUtils.open(path)
- unless @repo?
- throw new Error("No Git repository found searching path: #{path}")
-
- @statuses = {}
- @upstream = {ahead: 0, behind: 0}
- for submodulePath, submoduleRepo of @repo.submodules
- submoduleRepo.upstream = {ahead: 0, behind: 0}
-
- {@project, @config, refreshOnWindowFocus} = options
-
- refreshOnWindowFocus ?= true
- if refreshOnWindowFocus
- onWindowFocus = =>
- @refreshIndex()
- @refreshStatus()
-
- window.addEventListener 'focus', onWindowFocus
- @subscriptions.add new Disposable(-> window.removeEventListener 'focus', onWindowFocus)
-
- if @project?
- @project.getBuffers().forEach (buffer) => @subscribeToBuffer(buffer)
- @subscriptions.add @project.onDidAddBuffer (buffer) => @subscribeToBuffer(buffer)
-
- # Public: Destroy this {GitRepository} object.
- #
- # This destroys any tasks and subscriptions and releases the underlying
- # libgit2 repository handle. This method is idempotent.
- destroy: ->
- if @emitter?
- @emitter.emit 'did-destroy'
- @emitter.dispose()
- @emitter = null
-
- if @statusTask?
- @statusTask.terminate()
- @statusTask = null
-
- if @repo?
- @repo.release()
- @repo = null
-
- if @subscriptions?
- @subscriptions.dispose()
- @subscriptions = null
-
- # Public: Returns a {Boolean} indicating if this repository has been destroyed.
- isDestroyed: ->
- not @repo?
-
- # Public: Invoke the given callback when this GitRepository's destroy() method
- # is invoked.
- #
- # * `callback` {Function}
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidDestroy: (callback) ->
- @emitter.once 'did-destroy', callback
-
- ###
- Section: Event Subscription
- ###
-
- # Public: Invoke the given callback when a specific file's status has
- # changed. When a file is updated, reloaded, etc, and the status changes, this
- # will be fired.
- #
- # * `callback` {Function}
- # * `event` {Object}
- # * `path` {String} the old parameters the decoration used to have
- # * `pathStatus` {Number} representing the status. This value can be passed to
- # {::isStatusModified} or {::isStatusNew} to get more information.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidChangeStatus: (callback) ->
- @emitter.on 'did-change-status', callback
-
- # Public: Invoke the given callback when a multiple files' statuses have
- # changed. For example, on window focus, the status of all the paths in the
- # repo is checked. If any of them have changed, this will be fired. Call
- # {::getPathStatus(path)} to get the status for your path of choice.
- #
- # * `callback` {Function}
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidChangeStatuses: (callback) ->
- @emitter.on 'did-change-statuses', callback
-
- ###
- Section: Repository Details
- ###
-
- # Public: A {String} indicating the type of version control system used by
- # this repository.
- #
- # Returns `"git"`.
- getType: -> 'git'
-
- # Public: Returns the {String} path of the repository.
- getPath: ->
- @path ?= fs.absolute(@getRepo().getPath())
-
- # Public: Returns the {String} working directory path of the repository.
- getWorkingDirectory: -> @getRepo().getWorkingDirectory()
-
- # Public: Returns true if at the root, false if in a subfolder of the
- # repository.
- isProjectAtRoot: ->
- @projectAtRoot ?= @project?.relativize(@getWorkingDirectory()) is ''
-
- # Public: Makes a path relative to the repository's working directory.
- relativize: (path) -> @getRepo().relativize(path)
-
- # Public: Returns true if the given branch exists.
- hasBranch: (branch) -> @getReferenceTarget("refs/heads/#{branch}")?
-
- # Public: Retrieves a shortened version of the HEAD reference value.
- #
- # This removes the leading segments of `refs/heads`, `refs/tags`, or
- # `refs/remotes`. It also shortens the SHA-1 of a detached `HEAD` to 7
- # characters.
- #
- # * `path` An optional {String} path in the repository to get this information
- # for, only needed if the repository contains submodules.
- #
- # Returns a {String}.
- getShortHead: (path) -> @getRepo(path).getShortHead()
-
- # Public: Is the given path a submodule in the repository?
- #
- # * `path` The {String} path to check.
- #
- # Returns a {Boolean}.
- isSubmodule: (path) ->
- return false unless path
-
- repo = @getRepo(path)
- if repo.isSubmodule(repo.relativize(path))
- true
- else
- # Check if the path is a working directory in a repo that isn't the root.
- repo isnt @getRepo() and repo.relativize(join(path, 'dir')) is 'dir'
-
- # Public: Returns the number of commits behind the current branch is from the
- # its upstream remote branch.
- #
- # * `reference` The {String} branch reference name.
- # * `path` The {String} path in the repository to get this information for,
- # only needed if the repository contains submodules.
- getAheadBehindCount: (reference, path) ->
- @getRepo(path).getAheadBehindCount(reference)
-
- # Public: Get the cached ahead/behind commit counts for the current branch's
- # upstream branch.
- #
- # * `path` An optional {String} path in the repository to get this information
- # for, only needed if the repository has submodules.
- #
- # Returns an {Object} with the following keys:
- # * `ahead` The {Number} of commits ahead.
- # * `behind` The {Number} of commits behind.
- getCachedUpstreamAheadBehindCount: (path) ->
- @getRepo(path).upstream ? @upstream
-
- # Public: Returns the git configuration value specified by the key.
- #
- # * `key` The {String} key for the configuration to lookup.
- # * `path` An optional {String} path in the repository to get this information
- # for, only needed if the repository has submodules.
- getConfigValue: (key, path) -> @getRepo(path).getConfigValue(key)
-
- # Public: Returns the origin url of the repository.
- #
- # * `path` (optional) {String} path in the repository to get this information
- # for, only needed if the repository has submodules.
- getOriginURL: (path) -> @getConfigValue('remote.origin.url', path)
-
- # Public: Returns the upstream branch for the current HEAD, or null if there
- # is no upstream branch for the current HEAD.
- #
- # * `path` An optional {String} path in the repo to get this information for,
- # only needed if the repository contains submodules.
- #
- # Returns a {String} branch name such as `refs/remotes/origin/master`.
- getUpstreamBranch: (path) -> @getRepo(path).getUpstreamBranch()
-
- # Public: Gets all the local and remote references.
- #
- # * `path` An optional {String} path in the repository to get this information
- # for, only needed if the repository has submodules.
- #
- # Returns an {Object} with the following keys:
- # * `heads` An {Array} of head reference names.
- # * `remotes` An {Array} of remote reference names.
- # * `tags` An {Array} of tag reference names.
- getReferences: (path) -> @getRepo(path).getReferences()
-
- # Public: Returns the current {String} SHA for the given reference.
- #
- # * `reference` The {String} reference to get the target of.
- # * `path` An optional {String} path in the repo to get the reference target
- # for. Only needed if the repository contains submodules.
- getReferenceTarget: (reference, path) ->
- @getRepo(path).getReferenceTarget(reference)
-
- ###
- Section: Reading Status
- ###
-
- # Public: Returns true if the given path is modified.
- #
- # * `path` The {String} path to check.
- #
- # Returns a {Boolean} that's true if the `path` is modified.
- isPathModified: (path) -> @isStatusModified(@getPathStatus(path))
-
- # Public: Returns true if the given path is new.
- #
- # * `path` The {String} path to check.
- #
- # Returns a {Boolean} that's true if the `path` is new.
- isPathNew: (path) -> @isStatusNew(@getPathStatus(path))
-
- # Public: Is the given path ignored?
- #
- # * `path` The {String} path to check.
- #
- # Returns a {Boolean} that's true if the `path` is ignored.
- isPathIgnored: (path) -> @getRepo().isIgnored(@relativize(path))
-
- # Public: Get the status of a directory in the repository's working directory.
- #
- # * `path` The {String} path to check.
- #
- # Returns a {Number} representing the status. This value can be passed to
- # {::isStatusModified} or {::isStatusNew} to get more information.
- getDirectoryStatus: (directoryPath) ->
- directoryPath = "#{@relativize(directoryPath)}/"
- directoryStatus = 0
- for statusPath, status of @statuses
- directoryStatus |= status if statusPath.indexOf(directoryPath) is 0
- directoryStatus
-
- # Public: Get the status of a single path in the repository.
- #
- # * `path` A {String} repository-relative path.
- #
- # Returns a {Number} representing the status. This value can be passed to
- # {::isStatusModified} or {::isStatusNew} to get more information.
- getPathStatus: (path) ->
- repo = @getRepo(path)
- relativePath = @relativize(path)
- currentPathStatus = @statuses[relativePath] ? 0
- pathStatus = repo.getStatus(repo.relativize(path)) ? 0
- pathStatus = 0 if repo.isStatusIgnored(pathStatus)
- if pathStatus > 0
- @statuses[relativePath] = pathStatus
- else
- delete @statuses[relativePath]
- if currentPathStatus isnt pathStatus
- @emitter.emit 'did-change-status', {path, pathStatus}
-
- pathStatus
-
- # Public: Get the cached status for the given path.
- #
- # * `path` A {String} path in the repository, relative or absolute.
- #
- # Returns a status {Number} or null if the path is not in the cache.
- getCachedPathStatus: (path) ->
- @statuses[@relativize(path)]
-
- # Public: Returns true if the given status indicates modification.
- #
- # * `status` A {Number} representing the status.
- #
- # Returns a {Boolean} that's true if the `status` indicates modification.
- isStatusModified: (status) -> @getRepo().isStatusModified(status)
-
- # Public: Returns true if the given status indicates a new path.
- #
- # * `status` A {Number} representing the status.
- #
- # Returns a {Boolean} that's true if the `status` indicates a new path.
- isStatusNew: (status) -> @getRepo().isStatusNew(status)
-
- ###
- Section: Retrieving Diffs
- ###
-
- # Public: Retrieves the number of lines added and removed to a path.
- #
- # This compares the working directory contents of the path to the `HEAD`
- # version.
- #
- # * `path` The {String} path to check.
- #
- # Returns an {Object} with the following keys:
- # * `added` The {Number} of added lines.
- # * `deleted` The {Number} of deleted lines.
- getDiffStats: (path) ->
- repo = @getRepo(path)
- repo.getDiffStats(repo.relativize(path))
-
- # Public: Retrieves the line diffs comparing the `HEAD` version of the given
- # path and the given text.
- #
- # * `path` The {String} path relative to the repository.
- # * `text` The {String} to compare against the `HEAD` contents
- #
- # Returns an {Array} of hunk {Object}s with the following keys:
- # * `oldStart` The line {Number} of the old hunk.
- # * `newStart` The line {Number} of the new hunk.
- # * `oldLines` The {Number} of lines in the old hunk.
- # * `newLines` The {Number} of lines in the new hunk
- getLineDiffs: (path, text) ->
- # Ignore eol of line differences on windows so that files checked in as
- # LF don't report every line modified when the text contains CRLF endings.
- options = ignoreEolWhitespace: process.platform is 'win32'
- repo = @getRepo(path)
- repo.getLineDiffs(repo.relativize(path), text, options)
-
- ###
- Section: Checking Out
- ###
-
- # Public: Restore the contents of a path in the working directory and index
- # to the version at `HEAD`.
- #
- # This is essentially the same as running:
- #
- # ```sh
- # git reset HEAD --
- # git checkout HEAD --
- # ```
- #
- # * `path` The {String} path to checkout.
- #
- # Returns a {Boolean} that's true if the method was successful.
- checkoutHead: (path) ->
- repo = @getRepo(path)
- headCheckedOut = repo.checkoutHead(repo.relativize(path))
- @getPathStatus(path) if headCheckedOut
- headCheckedOut
-
- # Public: Checks out a branch in your repository.
- #
- # * `reference` The {String} reference to checkout.
- # * `create` A {Boolean} value which, if true creates the new reference if
- # it doesn't exist.
- #
- # Returns a Boolean that's true if the method was successful.
- checkoutReference: (reference, create) ->
- @getRepo().checkoutReference(reference, create)
-
- ###
- Section: Private
- ###
-
- # Subscribes to buffer events.
- subscribeToBuffer: (buffer) ->
- getBufferPathStatus = =>
- if bufferPath = buffer.getPath()
- @getPathStatus(bufferPath)
-
- getBufferPathStatus()
- bufferSubscriptions = new CompositeDisposable
- bufferSubscriptions.add buffer.onDidSave(getBufferPathStatus)
- bufferSubscriptions.add buffer.onDidReload(getBufferPathStatus)
- bufferSubscriptions.add buffer.onDidChangePath(getBufferPathStatus)
- bufferSubscriptions.add buffer.onDidDestroy =>
- bufferSubscriptions.dispose()
- @subscriptions.remove(bufferSubscriptions)
- @subscriptions.add(bufferSubscriptions)
- return
-
- # Subscribes to editor view event.
- checkoutHeadForEditor: (editor) ->
- buffer = editor.getBuffer()
- if filePath = buffer.getPath()
- @checkoutHead(filePath)
- buffer.reload()
-
- # Returns the corresponding {Repository}
- getRepo: (path) ->
- if @repo?
- @repo.submoduleForPath(path) ? @repo
- else
- throw new Error("Repository has been destroyed")
-
- # Reread the index to update any values that have changed since the
- # last time the index was read.
- refreshIndex: -> @getRepo().refreshIndex()
-
- # Refreshes the current git status in an outside process and asynchronously
- # updates the relevant properties.
- refreshStatus: ->
- @handlerPath ?= require.resolve('./repository-status-handler')
-
- relativeProjectPaths = @project?.getPaths()
- .map (projectPath) => @relativize(projectPath)
- .filter (projectPath) -> projectPath.length > 0 and not path.isAbsolute(projectPath)
-
- @statusTask?.terminate()
- new Promise (resolve) =>
- @statusTask = Task.once @handlerPath, @getPath(), relativeProjectPaths, ({statuses, upstream, branch, submodules}) =>
- statusesUnchanged = _.isEqual(statuses, @statuses) and
- _.isEqual(upstream, @upstream) and
- _.isEqual(branch, @branch) and
- _.isEqual(submodules, @submodules)
-
- @statuses = statuses
- @upstream = upstream
- @branch = branch
- @submodules = submodules
-
- for submodulePath, submoduleRepo of @getRepo().submodules
- submoduleRepo.upstream = submodules[submodulePath]?.upstream ? {ahead: 0, behind: 0}
-
- unless statusesUnchanged
- @emitter.emit 'did-change-statuses'
- resolve()
diff --git a/src/git-repository.js b/src/git-repository.js
new file mode 100644
index 000000000..057c5fcb7
--- /dev/null
+++ b/src/git-repository.js
@@ -0,0 +1,603 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS104: Avoid inline assignments
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+const {join} = require('path')
+const _ = require('underscore-plus')
+const {Emitter, Disposable, CompositeDisposable} = require('event-kit')
+const fs = require('fs-plus')
+const path = require('path')
+const GitUtils = require('git-utils')
+
+let nextId = 0
+
+// Extended: Represents the underlying git operations performed by Atom.
+//
+// This class shouldn't be instantiated directly but instead by accessing the
+// `atom.project` global and calling `getRepositories()`. Note that this will
+// only be available when the project is backed by a Git repository.
+//
+// This class handles submodules automatically by taking a `path` argument to many
+// of the methods. This `path` argument will determine which underlying
+// repository is used.
+//
+// For a repository with submodules this would have the following outcome:
+//
+// ```coffee
+// repo = atom.project.getRepositories()[0]
+// repo.getShortHead() # 'master'
+// repo.getShortHead('vendor/path/to/a/submodule') # 'dead1234'
+// ```
+//
+// ## Examples
+//
+// ### Logging the URL of the origin remote
+//
+// ```coffee
+// git = atom.project.getRepositories()[0]
+// console.log git.getOriginURL()
+// ```
+//
+// ### Requiring in packages
+//
+// ```coffee
+// {GitRepository} = require 'atom'
+// ```
+module.exports =
+class GitRepository {
+ static exists (path) {
+ const git = this.open(path)
+ if (git) {
+ git.destroy()
+ return true
+ } else {
+ return false
+ }
+ }
+
+ /*
+ Section: Construction and Destruction
+ */
+
+ // Public: Creates a new GitRepository instance.
+ //
+ // * `path` The {String} path to the Git repository to open.
+ // * `options` An optional {Object} with the following keys:
+ // * `refreshOnWindowFocus` A {Boolean}, `true` to refresh the index and
+ // statuses when the window is focused.
+ //
+ // Returns a {GitRepository} instance or `null` if the repository could not be opened.
+ static open (path, options) {
+ if (!path) { return null }
+ try {
+ return new GitRepository(path, options)
+ } catch (error) {
+ return null
+ }
+ }
+
+ constructor (path, options = {}) {
+ this.id = nextId++
+ this.emitter = new Emitter()
+ this.subscriptions = new CompositeDisposable()
+ this.repo = GitUtils.open(path)
+ if (this.repo == null) {
+ throw new Error(`No Git repository found searching path: ${path}`)
+ }
+
+ this.statusRefreshCount = 0
+ this.statuses = {}
+ this.upstream = {ahead: 0, behind: 0}
+ for (let submodulePath in this.repo.submodules) {
+ const submoduleRepo = this.repo.submodules[submodulePath]
+ submoduleRepo.upstream = {ahead: 0, behind: 0}
+ }
+
+ this.project = options.project
+ this.config = options.config
+
+ if (options.refreshOnWindowFocus || options.refreshOnWindowFocus == null) {
+ const onWindowFocus = () => {
+ this.refreshIndex()
+ this.refreshStatus()
+ }
+
+ window.addEventListener('focus', onWindowFocus)
+ this.subscriptions.add(new Disposable(() => window.removeEventListener('focus', onWindowFocus)))
+ }
+
+ if (this.project != null) {
+ this.project.getBuffers().forEach(buffer => this.subscribeToBuffer(buffer))
+ this.subscriptions.add(this.project.onDidAddBuffer(buffer => this.subscribeToBuffer(buffer)))
+ }
+ }
+
+ // Public: Destroy this {GitRepository} object.
+ //
+ // This destroys any tasks and subscriptions and releases the underlying
+ // libgit2 repository handle. This method is idempotent.
+ destroy () {
+ this.repo = null
+
+ if (this.emitter) {
+ this.emitter.emit('did-destroy')
+ this.emitter.dispose()
+ this.emitter = null
+ }
+
+ if (this.subscriptions) {
+ this.subscriptions.dispose()
+ this.subscriptions = null
+ }
+ }
+
+ // Public: Returns a {Boolean} indicating if this repository has been destroyed.
+ isDestroyed () {
+ return this.repo == null
+ }
+
+ // Public: Invoke the given callback when this GitRepository's destroy() method
+ // is invoked.
+ //
+ // * `callback` {Function}
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidDestroy (callback) {
+ return this.emitter.once('did-destroy', callback)
+ }
+
+ /*
+ Section: Event Subscription
+ */
+
+ // Public: Invoke the given callback when a specific file's status has
+ // changed. When a file is updated, reloaded, etc, and the status changes, this
+ // will be fired.
+ //
+ // * `callback` {Function}
+ // * `event` {Object}
+ // * `path` {String} the old parameters the decoration used to have
+ // * `pathStatus` {Number} representing the status. This value can be passed to
+ // {::isStatusModified} or {::isStatusNew} to get more information.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidChangeStatus (callback) {
+ return this.emitter.on('did-change-status', callback)
+ }
+
+ // Public: Invoke the given callback when a multiple files' statuses have
+ // changed. For example, on window focus, the status of all the paths in the
+ // repo is checked. If any of them have changed, this will be fired. Call
+ // {::getPathStatus(path)} to get the status for your path of choice.
+ //
+ // * `callback` {Function}
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidChangeStatuses (callback) {
+ return this.emitter.on('did-change-statuses', callback)
+ }
+
+ /*
+ Section: Repository Details
+ */
+
+ // Public: A {String} indicating the type of version control system used by
+ // this repository.
+ //
+ // Returns `"git"`.
+ getType () { return 'git' }
+
+ // Public: Returns the {String} path of the repository.
+ getPath () {
+ if (this.path == null) {
+ this.path = fs.absolute(this.getRepo().getPath())
+ }
+ return this.path
+ }
+
+ // Public: Returns the {String} working directory path of the repository.
+ getWorkingDirectory () {
+ return this.getRepo().getWorkingDirectory()
+ }
+
+ // Public: Returns true if at the root, false if in a subfolder of the
+ // repository.
+ isProjectAtRoot () {
+ if (this.projectAtRoot == null) {
+ this.projectAtRoot = this.project && this.project.relativize(this.getWorkingDirectory()) === ''
+ }
+ return this.projectAtRoot
+ }
+
+ // Public: Makes a path relative to the repository's working directory.
+ relativize (path) {
+ return this.getRepo().relativize(path)
+ }
+
+ // Public: Returns true if the given branch exists.
+ hasBranch (branch) {
+ return this.getReferenceTarget(`refs/heads/${branch}`) != null
+ }
+
+ // Public: Retrieves a shortened version of the HEAD reference value.
+ //
+ // This removes the leading segments of `refs/heads`, `refs/tags`, or
+ // `refs/remotes`. It also shortens the SHA-1 of a detached `HEAD` to 7
+ // characters.
+ //
+ // * `path` An optional {String} path in the repository to get this information
+ // for, only needed if the repository contains submodules.
+ //
+ // Returns a {String}.
+ getShortHead (path) {
+ return this.getRepo(path).getShortHead()
+ }
+
+ // Public: Is the given path a submodule in the repository?
+ //
+ // * `path` The {String} path to check.
+ //
+ // Returns a {Boolean}.
+ isSubmodule (path) {
+ if (!path) return false
+
+ const repo = this.getRepo(path)
+ if (repo.isSubmodule(repo.relativize(path))) {
+ return true
+ } else {
+ // Check if the path is a working directory in a repo that isn't the root.
+ return repo !== this.getRepo() && repo.relativize(join(path, 'dir')) === 'dir'
+ }
+ }
+
+ // Public: Returns the number of commits behind the current branch is from the
+ // its upstream remote branch.
+ //
+ // * `reference` The {String} branch reference name.
+ // * `path` The {String} path in the repository to get this information for,
+ // only needed if the repository contains submodules.
+ getAheadBehindCount (reference, path) {
+ return this.getRepo(path).getAheadBehindCount(reference)
+ }
+
+ // Public: Get the cached ahead/behind commit counts for the current branch's
+ // upstream branch.
+ //
+ // * `path` An optional {String} path in the repository to get this information
+ // for, only needed if the repository has submodules.
+ //
+ // Returns an {Object} with the following keys:
+ // * `ahead` The {Number} of commits ahead.
+ // * `behind` The {Number} of commits behind.
+ getCachedUpstreamAheadBehindCount (path) {
+ return this.getRepo(path).upstream || this.upstream
+ }
+
+ // Public: Returns the git configuration value specified by the key.
+ //
+ // * `key` The {String} key for the configuration to lookup.
+ // * `path` An optional {String} path in the repository to get this information
+ // for, only needed if the repository has submodules.
+ getConfigValue (key, path) {
+ return this.getRepo(path).getConfigValue(key)
+ }
+
+ // Public: Returns the origin url of the repository.
+ //
+ // * `path` (optional) {String} path in the repository to get this information
+ // for, only needed if the repository has submodules.
+ getOriginURL (path) {
+ return this.getConfigValue('remote.origin.url', path)
+ }
+
+ // Public: Returns the upstream branch for the current HEAD, or null if there
+ // is no upstream branch for the current HEAD.
+ //
+ // * `path` An optional {String} path in the repo to get this information for,
+ // only needed if the repository contains submodules.
+ //
+ // Returns a {String} branch name such as `refs/remotes/origin/master`.
+ getUpstreamBranch (path) {
+ return this.getRepo(path).getUpstreamBranch()
+ }
+
+ // Public: Gets all the local and remote references.
+ //
+ // * `path` An optional {String} path in the repository to get this information
+ // for, only needed if the repository has submodules.
+ //
+ // Returns an {Object} with the following keys:
+ // * `heads` An {Array} of head reference names.
+ // * `remotes` An {Array} of remote reference names.
+ // * `tags` An {Array} of tag reference names.
+ getReferences (path) {
+ return this.getRepo(path).getReferences()
+ }
+
+ // Public: Returns the current {String} SHA for the given reference.
+ //
+ // * `reference` The {String} reference to get the target of.
+ // * `path` An optional {String} path in the repo to get the reference target
+ // for. Only needed if the repository contains submodules.
+ getReferenceTarget (reference, path) {
+ return this.getRepo(path).getReferenceTarget(reference)
+ }
+
+ /*
+ Section: Reading Status
+ */
+
+ // Public: Returns true if the given path is modified.
+ //
+ // * `path` The {String} path to check.
+ //
+ // Returns a {Boolean} that's true if the `path` is modified.
+ isPathModified (path) {
+ return this.isStatusModified(this.getPathStatus(path))
+ }
+
+ // Public: Returns true if the given path is new.
+ //
+ // * `path` The {String} path to check.
+ //
+ // Returns a {Boolean} that's true if the `path` is new.
+ isPathNew (path) {
+ return this.isStatusNew(this.getPathStatus(path))
+ }
+
+ // Public: Is the given path ignored?
+ //
+ // * `path` The {String} path to check.
+ //
+ // Returns a {Boolean} that's true if the `path` is ignored.
+ isPathIgnored (path) {
+ return this.getRepo().isIgnored(this.relativize(path))
+ }
+
+ // Public: Get the status of a directory in the repository's working directory.
+ //
+ // * `path` The {String} path to check.
+ //
+ // Returns a {Number} representing the status. This value can be passed to
+ // {::isStatusModified} or {::isStatusNew} to get more information.
+ getDirectoryStatus (directoryPath) {
+ directoryPath = `${this.relativize(directoryPath)}/`
+ let directoryStatus = 0
+ for (let statusPath in this.statuses) {
+ const status = this.statuses[statusPath]
+ if (statusPath.startsWith(directoryPath)) directoryStatus |= status
+ }
+ return directoryStatus
+ }
+
+ // Public: Get the status of a single path in the repository.
+ //
+ // * `path` A {String} repository-relative path.
+ //
+ // Returns a {Number} representing the status. This value can be passed to
+ // {::isStatusModified} or {::isStatusNew} to get more information.
+ getPathStatus (path) {
+ const repo = this.getRepo(path)
+ const relativePath = this.relativize(path)
+ const currentPathStatus = this.statuses[relativePath] || 0
+ let pathStatus = repo.getStatus(repo.relativize(path)) || 0
+ if (repo.isStatusIgnored(pathStatus)) pathStatus = 0
+ if (pathStatus > 0) {
+ this.statuses[relativePath] = pathStatus
+ } else {
+ delete this.statuses[relativePath]
+ }
+ if (currentPathStatus !== pathStatus) {
+ this.emitter.emit('did-change-status', {path, pathStatus})
+ }
+
+ return pathStatus
+ }
+
+ // Public: Get the cached status for the given path.
+ //
+ // * `path` A {String} path in the repository, relative or absolute.
+ //
+ // Returns a status {Number} or null if the path is not in the cache.
+ getCachedPathStatus (path) {
+ return this.statuses[this.relativize(path)]
+ }
+
+ // Public: Returns true if the given status indicates modification.
+ //
+ // * `status` A {Number} representing the status.
+ //
+ // Returns a {Boolean} that's true if the `status` indicates modification.
+ isStatusModified (status) { return this.getRepo().isStatusModified(status) }
+
+ // Public: Returns true if the given status indicates a new path.
+ //
+ // * `status` A {Number} representing the status.
+ //
+ // Returns a {Boolean} that's true if the `status` indicates a new path.
+ isStatusNew (status) {
+ return this.getRepo().isStatusNew(status)
+ }
+
+ /*
+ Section: Retrieving Diffs
+ */
+
+ // Public: Retrieves the number of lines added and removed to a path.
+ //
+ // This compares the working directory contents of the path to the `HEAD`
+ // version.
+ //
+ // * `path` The {String} path to check.
+ //
+ // Returns an {Object} with the following keys:
+ // * `added` The {Number} of added lines.
+ // * `deleted` The {Number} of deleted lines.
+ getDiffStats (path) {
+ const repo = this.getRepo(path)
+ return repo.getDiffStats(repo.relativize(path))
+ }
+
+ // Public: Retrieves the line diffs comparing the `HEAD` version of the given
+ // path and the given text.
+ //
+ // * `path` The {String} path relative to the repository.
+ // * `text` The {String} to compare against the `HEAD` contents
+ //
+ // Returns an {Array} of hunk {Object}s with the following keys:
+ // * `oldStart` The line {Number} of the old hunk.
+ // * `newStart` The line {Number} of the new hunk.
+ // * `oldLines` The {Number} of lines in the old hunk.
+ // * `newLines` The {Number} of lines in the new hunk
+ getLineDiffs (path, text) {
+ // Ignore eol of line differences on windows so that files checked in as
+ // LF don't report every line modified when the text contains CRLF endings.
+ const options = {ignoreEolWhitespace: process.platform === 'win32'}
+ const repo = this.getRepo(path)
+ return repo.getLineDiffs(repo.relativize(path), text, options)
+ }
+
+ /*
+ Section: Checking Out
+ */
+
+ // Public: Restore the contents of a path in the working directory and index
+ // to the version at `HEAD`.
+ //
+ // This is essentially the same as running:
+ //
+ // ```sh
+ // git reset HEAD --
+ // git checkout HEAD --
+ // ```
+ //
+ // * `path` The {String} path to checkout.
+ //
+ // Returns a {Boolean} that's true if the method was successful.
+ checkoutHead (path) {
+ const repo = this.getRepo(path)
+ const headCheckedOut = repo.checkoutHead(repo.relativize(path))
+ if (headCheckedOut) this.getPathStatus(path)
+ return headCheckedOut
+ }
+
+ // Public: Checks out a branch in your repository.
+ //
+ // * `reference` The {String} reference to checkout.
+ // * `create` A {Boolean} value which, if true creates the new reference if
+ // it doesn't exist.
+ //
+ // Returns a Boolean that's true if the method was successful.
+ checkoutReference (reference, create) {
+ return this.getRepo().checkoutReference(reference, create)
+ }
+
+ /*
+ Section: Private
+ */
+
+ // Subscribes to buffer events.
+ subscribeToBuffer (buffer) {
+ const getBufferPathStatus = () => {
+ const bufferPath = buffer.getPath()
+ if (bufferPath) this.getPathStatus(bufferPath)
+ }
+
+ getBufferPathStatus()
+ const bufferSubscriptions = new CompositeDisposable()
+ bufferSubscriptions.add(buffer.onDidSave(getBufferPathStatus))
+ bufferSubscriptions.add(buffer.onDidReload(getBufferPathStatus))
+ bufferSubscriptions.add(buffer.onDidChangePath(getBufferPathStatus))
+ bufferSubscriptions.add(buffer.onDidDestroy(() => {
+ bufferSubscriptions.dispose()
+ return this.subscriptions.remove(bufferSubscriptions)
+ }))
+ this.subscriptions.add(bufferSubscriptions)
+ }
+
+ // Subscribes to editor view event.
+ checkoutHeadForEditor (editor) {
+ const buffer = editor.getBuffer()
+ const bufferPath = buffer.getPath()
+ if (bufferPath) {
+ this.checkoutHead(bufferPath)
+ return buffer.reload()
+ }
+ }
+
+ // Returns the corresponding {Repository}
+ getRepo (path) {
+ if (this.repo) {
+ return this.repo.submoduleForPath(path) || this.repo
+ } else {
+ throw new Error('Repository has been destroyed')
+ }
+ }
+
+ // Reread the index to update any values that have changed since the
+ // last time the index was read.
+ refreshIndex () {
+ return this.getRepo().refreshIndex()
+ }
+
+ // Refreshes the current git status in an outside process and asynchronously
+ // updates the relevant properties.
+ async refreshStatus () {
+ const statusRefreshCount = ++this.statusRefreshCount
+ const repo = this.getRepo()
+
+ const relativeProjectPaths = this.project && this.project.getPaths()
+ .map(projectPath => this.relativize(projectPath))
+ .filter(projectPath => (projectPath.length > 0) && !path.isAbsolute(projectPath))
+
+ const branch = await repo.getHeadAsync()
+ const upstream = await repo.getAheadBehindCountAsync()
+
+ const statuses = {}
+ const repoStatus = relativeProjectPaths.length > 0
+ ? await repo.getStatusAsync(relativeProjectPaths)
+ : await repo.getStatusAsync()
+ for (let filePath in repoStatus) {
+ statuses[filePath] = repoStatus[filePath]
+ }
+
+ const submodules = {}
+ for (let submodulePath in repo.submodules) {
+ const submoduleRepo = repo.submodules[submodulePath]
+ submodules[submodulePath] = {
+ branch: await submoduleRepo.getHeadAsync(),
+ upstream: await submoduleRepo.getAheadBehindCountAsync()
+ }
+
+ const workingDirectoryPath = submoduleRepo.getWorkingDirectory()
+ const submoduleStatus = await submoduleRepo.getStatusAsync()
+ for (let filePath in submoduleStatus) {
+ const absolutePath = path.join(workingDirectoryPath, filePath)
+ const relativizePath = repo.relativize(absolutePath)
+ statuses[relativizePath] = submoduleStatus[filePath]
+ }
+ }
+
+ if (this.statusRefreshCount !== statusRefreshCount || this.isDestroyed()) return
+
+ const statusesUnchanged =
+ _.isEqual(branch, this.branch) &&
+ _.isEqual(statuses, this.statuses) &&
+ _.isEqual(upstream, this.upstream) &&
+ _.isEqual(submodules, this.submodules)
+
+ this.branch = branch
+ this.statuses = statuses
+ this.upstream = upstream
+ this.submodules = submodules
+
+ for (let submodulePath in repo.submodules) {
+ repo.submodules[submodulePath].upstream = submodules[submodulePath].upstream
+ }
+
+ if (!statusesUnchanged) this.emitter.emit('did-change-statuses')
+ }
+}
diff --git a/src/grammar-registry.coffee b/src/grammar-registry.coffee
deleted file mode 100644
index a2341c967..000000000
--- a/src/grammar-registry.coffee
+++ /dev/null
@@ -1,130 +0,0 @@
-_ = require 'underscore-plus'
-FirstMate = require 'first-mate'
-Token = require './token'
-fs = require 'fs-plus'
-Grim = require 'grim'
-
-PathSplitRegex = new RegExp("[/.]")
-
-# Extended: Syntax class holding the grammars used for tokenizing.
-#
-# An instance of this class is always available as the `atom.grammars` global.
-#
-# The Syntax class also contains properties for things such as the
-# language-specific comment regexes. See {::getProperty} for more details.
-module.exports =
-class GrammarRegistry extends FirstMate.GrammarRegistry
- constructor: ({@config}={}) ->
- super(maxTokensPerLine: 100, maxLineLength: 1000)
-
- createToken: (value, scopes) -> new Token({value, scopes})
-
- # Extended: Select a grammar for the given file path and file contents.
- #
- # This picks the best match by checking the file path and contents against
- # each grammar.
- #
- # * `filePath` A {String} file path.
- # * `fileContents` A {String} of text for the file path.
- #
- # Returns a {Grammar}, never null.
- selectGrammar: (filePath, fileContents) ->
- @selectGrammarWithScore(filePath, fileContents).grammar
-
- selectGrammarWithScore: (filePath, fileContents) ->
- bestMatch = null
- highestScore = -Infinity
- for grammar in @grammars
- score = @getGrammarScore(grammar, filePath, fileContents)
- if score > highestScore or not bestMatch?
- bestMatch = grammar
- highestScore = score
- {grammar: bestMatch, score: highestScore}
-
- # Extended: Returns a {Number} representing how well the grammar matches the
- # `filePath` and `contents`.
- getGrammarScore: (grammar, filePath, contents) ->
- contents = fs.readFileSync(filePath, 'utf8') if not contents? and fs.isFileSync(filePath)
-
- score = @getGrammarPathScore(grammar, filePath)
- if score > 0 and not grammar.bundledPackage
- score += 0.25
- if @grammarMatchesContents(grammar, contents)
- score += 0.125
- score
-
- getGrammarPathScore: (grammar, filePath) ->
- return -1 unless filePath
- filePath = filePath.replace(/\\/g, '/') if process.platform is 'win32'
-
- pathComponents = filePath.toLowerCase().split(PathSplitRegex)
- pathScore = -1
-
- fileTypes = grammar.fileTypes
- if customFileTypes = @config.get('core.customFileTypes')?[grammar.scopeName]
- fileTypes = fileTypes.concat(customFileTypes)
-
- for fileType, i in fileTypes
- fileTypeComponents = fileType.toLowerCase().split(PathSplitRegex)
- pathSuffix = pathComponents[-fileTypeComponents.length..-1]
- if _.isEqual(pathSuffix, fileTypeComponents)
- pathScore = Math.max(pathScore, fileType.length)
- if i >= grammar.fileTypes.length
- pathScore += 0.5
-
- pathScore
-
- grammarMatchesContents: (grammar, contents) ->
- return false unless contents? and grammar.firstLineRegex?
-
- escaped = false
- numberOfNewlinesInRegex = 0
- for character in grammar.firstLineRegex.source
- switch character
- when '\\'
- escaped = not escaped
- when 'n'
- numberOfNewlinesInRegex++ if escaped
- escaped = false
- else
- escaped = false
- lines = contents.split('\n')
- grammar.firstLineRegex.testSync(lines[0..numberOfNewlinesInRegex].join('\n'))
-
- # Deprecated: Get the grammar override for the given file path.
- #
- # * `filePath` A {String} file path.
- #
- # Returns a {String} such as `"source.js"`.
- grammarOverrideForPath: (filePath) ->
- Grim.deprecate 'Use atom.textEditors.getGrammarOverride(editor) instead'
- if editor = getEditorForPath(filePath)
- atom.textEditors.getGrammarOverride(editor)
-
- # Deprecated: Set the grammar override for the given file path.
- #
- # * `filePath` A non-empty {String} file path.
- # * `scopeName` A {String} such as `"source.js"`.
- #
- # Returns undefined
- setGrammarOverrideForPath: (filePath, scopeName) ->
- Grim.deprecate 'Use atom.textEditors.setGrammarOverride(editor, scopeName) instead'
- if editor = getEditorForPath(filePath)
- atom.textEditors.setGrammarOverride(editor, scopeName)
- return
-
- # Deprecated: Remove the grammar override for the given file path.
- #
- # * `filePath` A {String} file path.
- #
- # Returns undefined.
- clearGrammarOverrideForPath: (filePath) ->
- Grim.deprecate 'Use atom.textEditors.clearGrammarOverride(editor) instead'
- if editor = getEditorForPath(filePath)
- atom.textEditors.clearGrammarOverride(editor)
- return
-
-getEditorForPath = (filePath) ->
- if filePath?
- atom.workspace.getTextEditors().find (editor) ->
- editor.getPath() is filePath
diff --git a/src/grammar-registry.js b/src/grammar-registry.js
new file mode 100644
index 000000000..f2994acf1
--- /dev/null
+++ b/src/grammar-registry.js
@@ -0,0 +1,171 @@
+const _ = require('underscore-plus')
+const FirstMate = require('first-mate')
+const Token = require('./token')
+const fs = require('fs-plus')
+const Grim = require('grim')
+
+const PathSplitRegex = new RegExp('[/.]')
+
+// Extended: Syntax class holding the grammars used for tokenizing.
+//
+// An instance of this class is always available as the `atom.grammars` global.
+//
+// The Syntax class also contains properties for things such as the
+// language-specific comment regexes. See {::getProperty} for more details.
+module.exports =
+class GrammarRegistry extends FirstMate.GrammarRegistry {
+ constructor ({config} = {}) {
+ super({maxTokensPerLine: 100, maxLineLength: 1000})
+ this.config = config
+ }
+
+ createToken (value, scopes) {
+ return new Token({value, scopes})
+ }
+
+ // Extended: Select a grammar for the given file path and file contents.
+ //
+ // This picks the best match by checking the file path and contents against
+ // each grammar.
+ //
+ // * `filePath` A {String} file path.
+ // * `fileContents` A {String} of text for the file path.
+ //
+ // Returns a {Grammar}, never null.
+ selectGrammar (filePath, fileContents) {
+ return this.selectGrammarWithScore(filePath, fileContents).grammar
+ }
+
+ selectGrammarWithScore (filePath, fileContents) {
+ let bestMatch = null
+ let highestScore = -Infinity
+ for (let grammar of this.grammars) {
+ const score = this.getGrammarScore(grammar, filePath, fileContents)
+ if ((score > highestScore) || (bestMatch == null)) {
+ bestMatch = grammar
+ highestScore = score
+ }
+ }
+ return {grammar: bestMatch, score: highestScore}
+ }
+
+ // Extended: Returns a {Number} representing how well the grammar matches the
+ // `filePath` and `contents`.
+ getGrammarScore (grammar, filePath, contents) {
+ if ((contents == null) && fs.isFileSync(filePath)) {
+ contents = fs.readFileSync(filePath, 'utf8')
+ }
+
+ let score = this.getGrammarPathScore(grammar, filePath)
+ if ((score > 0) && !grammar.bundledPackage) {
+ score += 0.125
+ }
+ if (this.grammarMatchesContents(grammar, contents)) {
+ score += 0.25
+ }
+ return score
+ }
+
+ getGrammarPathScore (grammar, filePath) {
+ if (!filePath) { return -1 }
+ if (process.platform === 'win32') { filePath = filePath.replace(/\\/g, '/') }
+
+ const pathComponents = filePath.toLowerCase().split(PathSplitRegex)
+ let pathScore = -1
+
+ let customFileTypes
+ if (this.config.get('core.customFileTypes')) {
+ customFileTypes = this.config.get('core.customFileTypes')[grammar.scopeName]
+ }
+
+ let { fileTypes } = grammar
+ if (customFileTypes) {
+ fileTypes = fileTypes.concat(customFileTypes)
+ }
+
+ for (let i = 0; i < fileTypes.length; i++) {
+ const fileType = fileTypes[i]
+ const fileTypeComponents = fileType.toLowerCase().split(PathSplitRegex)
+ const pathSuffix = pathComponents.slice(-fileTypeComponents.length)
+ if (_.isEqual(pathSuffix, fileTypeComponents)) {
+ pathScore = Math.max(pathScore, fileType.length)
+ if (i >= grammar.fileTypes.length) {
+ pathScore += 0.5
+ }
+ }
+ }
+
+ return pathScore
+ }
+
+ grammarMatchesContents (grammar, contents) {
+ if ((contents == null) || (grammar.firstLineRegex == null)) { return false }
+
+ let escaped = false
+ let numberOfNewlinesInRegex = 0
+ for (let character of grammar.firstLineRegex.source) {
+ switch (character) {
+ case '\\':
+ escaped = !escaped
+ break
+ case 'n':
+ if (escaped) { numberOfNewlinesInRegex++ }
+ escaped = false
+ break
+ default:
+ escaped = false
+ }
+ }
+ const lines = contents.split('\n')
+ return grammar.firstLineRegex.testSync(lines.slice(0, numberOfNewlinesInRegex + 1).join('\n'))
+ }
+
+ // Deprecated: Get the grammar override for the given file path.
+ //
+ // * `filePath` A {String} file path.
+ //
+ // Returns a {String} such as `"source.js"`.
+ grammarOverrideForPath (filePath) {
+ Grim.deprecate('Use atom.textEditors.getGrammarOverride(editor) instead')
+
+ const editor = getEditorForPath(filePath)
+ if (editor) {
+ return atom.textEditors.getGrammarOverride(editor)
+ }
+ }
+
+ // Deprecated: Set the grammar override for the given file path.
+ //
+ // * `filePath` A non-empty {String} file path.
+ // * `scopeName` A {String} such as `"source.js"`.
+ //
+ // Returns undefined.
+ setGrammarOverrideForPath (filePath, scopeName) {
+ Grim.deprecate('Use atom.textEditors.setGrammarOverride(editor, scopeName) instead')
+
+ const editor = getEditorForPath(filePath)
+ if (editor) {
+ atom.textEditors.setGrammarOverride(editor, scopeName)
+ }
+ }
+
+ // Deprecated: Remove the grammar override for the given file path.
+ //
+ // * `filePath` A {String} file path.
+ //
+ // Returns undefined.
+ clearGrammarOverrideForPath (filePath) {
+ Grim.deprecate('Use atom.textEditors.clearGrammarOverride(editor) instead')
+
+ const editor = getEditorForPath(filePath)
+ if (editor) {
+ atom.textEditors.clearGrammarOverride(editor)
+ }
+ }
+}
+
+function getEditorForPath (filePath) {
+ if (filePath != null) {
+ return atom.workspace.getTextEditors().find(editor => editor.getPath() === filePath)
+ }
+}
diff --git a/src/gutter-container.coffee b/src/gutter-container.coffee
deleted file mode 100644
index 677fa4521..000000000
--- a/src/gutter-container.coffee
+++ /dev/null
@@ -1,87 +0,0 @@
-{Emitter} = require 'event-kit'
-Gutter = require './gutter'
-
-module.exports =
-class GutterContainer
- constructor: (textEditor) ->
- @gutters = []
- @textEditor = textEditor
- @emitter = new Emitter
-
- scheduleComponentUpdate: ->
- @textEditor.scheduleComponentUpdate()
-
- destroy: ->
- # Create a copy, because `Gutter::destroy` removes the gutter from
- # GutterContainer's @gutters.
- guttersToDestroy = @gutters.slice(0)
- for gutter in guttersToDestroy
- gutter.destroy() if gutter.name isnt 'line-number'
- @gutters = []
- @emitter.dispose()
-
- addGutter: (options) ->
- options = options ? {}
- gutterName = options.name
- if gutterName is null
- throw new Error('A name is required to create a gutter.')
- if @gutterWithName(gutterName)
- throw new Error('Tried to create a gutter with a name that is already in use.')
- newGutter = new Gutter(this, options)
-
- inserted = false
- # Insert the gutter into the gutters array, sorted in ascending order by 'priority'.
- # This could be optimized, but there are unlikely to be many gutters.
- for i in [0...@gutters.length]
- if @gutters[i].priority >= newGutter.priority
- @gutters.splice(i, 0, newGutter)
- inserted = true
- break
- if not inserted
- @gutters.push newGutter
- @scheduleComponentUpdate()
- @emitter.emit 'did-add-gutter', newGutter
- return newGutter
-
- getGutters: ->
- @gutters.slice()
-
- gutterWithName: (name) ->
- for gutter in @gutters
- if gutter.name is name then return gutter
- null
-
- observeGutters: (callback) ->
- callback(gutter) for gutter in @getGutters()
- @onDidAddGutter callback
-
- onDidAddGutter: (callback) ->
- @emitter.on 'did-add-gutter', callback
-
- onDidRemoveGutter: (callback) ->
- @emitter.on 'did-remove-gutter', callback
-
- ###
- Section: Private Methods
- ###
-
- # Processes the destruction of the gutter. Throws an error if this gutter is
- # not within this gutterContainer.
- removeGutter: (gutter) ->
- index = @gutters.indexOf(gutter)
- if index > -1
- @gutters.splice(index, 1)
- @scheduleComponentUpdate()
- @emitter.emit 'did-remove-gutter', gutter.name
- else
- throw new Error 'The given gutter cannot be removed because it is not ' +
- 'within this GutterContainer.'
-
- # The public interface is Gutter::decorateMarker or TextEditor::decorateMarker.
- addGutterDecoration: (gutter, marker, options) ->
- if gutter.name is 'line-number'
- options.type = 'line-number'
- else
- options.type = 'gutter'
- options.gutterName = gutter.name
- @textEditor.decorateMarker(marker, options)
diff --git a/src/gutter-container.js b/src/gutter-container.js
new file mode 100644
index 000000000..3faece073
--- /dev/null
+++ b/src/gutter-container.js
@@ -0,0 +1,108 @@
+const {Emitter} = require('event-kit')
+const Gutter = require('./gutter')
+
+module.exports = class GutterContainer {
+ constructor (textEditor) {
+ this.gutters = []
+ this.textEditor = textEditor
+ this.emitter = new Emitter()
+ }
+
+ scheduleComponentUpdate () {
+ this.textEditor.scheduleComponentUpdate()
+ }
+
+ destroy () {
+ // Create a copy, because `Gutter::destroy` removes the gutter from
+ // GutterContainer's @gutters.
+ const guttersToDestroy = this.gutters.slice(0)
+ for (let gutter of guttersToDestroy) {
+ if (gutter.name !== 'line-number') { gutter.destroy() }
+ }
+ this.gutters = []
+ this.emitter.dispose()
+ }
+
+ addGutter (options) {
+ options = options || {}
+ const gutterName = options.name
+ if (gutterName === null) {
+ throw new Error('A name is required to create a gutter.')
+ }
+ if (this.gutterWithName(gutterName)) {
+ throw new Error('Tried to create a gutter with a name that is already in use.')
+ }
+ const newGutter = new Gutter(this, options)
+
+ let inserted = false
+ // Insert the gutter into the gutters array, sorted in ascending order by 'priority'.
+ // This could be optimized, but there are unlikely to be many gutters.
+ for (let i = 0; i < this.gutters.length; i++) {
+ if (this.gutters[i].priority >= newGutter.priority) {
+ this.gutters.splice(i, 0, newGutter)
+ inserted = true
+ break
+ }
+ }
+ if (!inserted) {
+ this.gutters.push(newGutter)
+ }
+ this.scheduleComponentUpdate()
+ this.emitter.emit('did-add-gutter', newGutter)
+ return newGutter
+ }
+
+ getGutters () {
+ return this.gutters.slice()
+ }
+
+ gutterWithName (name) {
+ for (let gutter of this.gutters) {
+ if (gutter.name === name) { return gutter }
+ }
+ return null
+ }
+
+ observeGutters (callback) {
+ for (let gutter of this.getGutters()) { callback(gutter) }
+ return this.onDidAddGutter(callback)
+ }
+
+ onDidAddGutter (callback) {
+ return this.emitter.on('did-add-gutter', callback)
+ }
+
+ onDidRemoveGutter (callback) {
+ return this.emitter.on('did-remove-gutter', callback)
+ }
+
+ /*
+ Section: Private Methods
+ */
+
+ // Processes the destruction of the gutter. Throws an error if this gutter is
+ // not within this gutterContainer.
+ removeGutter (gutter) {
+ const index = this.gutters.indexOf(gutter)
+ if (index > -1) {
+ this.gutters.splice(index, 1)
+ this.scheduleComponentUpdate()
+ this.emitter.emit('did-remove-gutter', gutter.name)
+ } else {
+ throw new Error('The given gutter cannot be removed because it is not ' +
+ 'within this GutterContainer.'
+ )
+ }
+ }
+
+ // The public interface is Gutter::decorateMarker or TextEditor::decorateMarker.
+ addGutterDecoration (gutter, marker, options) {
+ if (gutter.name === 'line-number') {
+ options.type = 'line-number'
+ } else {
+ options.type = 'gutter'
+ }
+ options.gutterName = gutter.name
+ return this.textEditor.decorateMarker(marker, options)
+ }
+}
diff --git a/src/gutter.coffee b/src/gutter.coffee
deleted file mode 100644
index 4521eeeb2..000000000
--- a/src/gutter.coffee
+++ /dev/null
@@ -1,95 +0,0 @@
-{Emitter} = require 'event-kit'
-CustomGutterComponent = null
-
-DefaultPriority = -100
-
-# Extended: Represents a gutter within a {TextEditor}.
-#
-# See {TextEditor::addGutter} for information on creating a gutter.
-module.exports =
-class Gutter
- constructor: (gutterContainer, options) ->
- @gutterContainer = gutterContainer
- @name = options?.name
- @priority = options?.priority ? DefaultPriority
- @visible = options?.visible ? true
-
- @emitter = new Emitter
-
- ###
- Section: Gutter Destruction
- ###
-
- # Essential: Destroys the gutter.
- destroy: ->
- if @name is 'line-number'
- throw new Error('The line-number gutter cannot be destroyed.')
- else
- @gutterContainer.removeGutter(this)
- @emitter.emit 'did-destroy'
- @emitter.dispose()
-
- ###
- Section: Event Subscription
- ###
-
- # Essential: Calls your `callback` when the gutter's visibility changes.
- #
- # * `callback` {Function}
- # * `gutter` The gutter whose visibility changed.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidChangeVisible: (callback) ->
- @emitter.on 'did-change-visible', callback
-
- # Essential: Calls your `callback` when the gutter is destroyed.
- #
- # * `callback` {Function}
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidDestroy: (callback) ->
- @emitter.once 'did-destroy', callback
-
- ###
- Section: Visibility
- ###
-
- # Essential: Hide the gutter.
- hide: ->
- if @visible
- @visible = false
- @gutterContainer.scheduleComponentUpdate()
- @emitter.emit 'did-change-visible', this
-
- # Essential: Show the gutter.
- show: ->
- if not @visible
- @visible = true
- @gutterContainer.scheduleComponentUpdate()
- @emitter.emit 'did-change-visible', this
-
- # Essential: Determine whether the gutter is visible.
- #
- # Returns a {Boolean}.
- isVisible: ->
- @visible
-
- # Essential: Add a decoration that tracks a {DisplayMarker}. When the marker moves,
- # is invalidated, or is destroyed, the decoration will be updated to reflect
- # the marker's state.
- #
- # ## Arguments
- #
- # * `marker` A {DisplayMarker} you want this decoration to follow.
- # * `decorationParams` An {Object} representing the decoration. It is passed
- # to {TextEditor::decorateMarker} as its `decorationParams` and so supports
- # all options documented there.
- # * `type` __Caveat__: set to `'line-number'` if this is the line-number
- # gutter, `'gutter'` otherwise. This cannot be overridden.
- #
- # Returns a {Decoration} object
- decorateMarker: (marker, options) ->
- @gutterContainer.addGutterDecoration(this, marker, options)
-
- getElement: ->
- @element ?= document.createElement('div')
diff --git a/src/gutter.js b/src/gutter.js
new file mode 100644
index 000000000..3bf7a72ea
--- /dev/null
+++ b/src/gutter.js
@@ -0,0 +1,107 @@
+const {Emitter} = require('event-kit')
+
+const DefaultPriority = -100
+
+// Extended: Represents a gutter within a {TextEditor}.
+//
+// See {TextEditor::addGutter} for information on creating a gutter.
+module.exports = class Gutter {
+ constructor (gutterContainer, options) {
+ this.gutterContainer = gutterContainer
+ this.name = options && options.name
+ this.priority = (options && options.priority != null) ? options.priority : DefaultPriority
+ this.visible = (options && options.visible != null) ? options.visible : true
+
+ this.emitter = new Emitter()
+ }
+
+ /*
+ Section: Gutter Destruction
+ */
+
+ // Essential: Destroys the gutter.
+ destroy () {
+ if (this.name === 'line-number') {
+ throw new Error('The line-number gutter cannot be destroyed.')
+ } else {
+ this.gutterContainer.removeGutter(this)
+ this.emitter.emit('did-destroy')
+ this.emitter.dispose()
+ }
+ }
+
+ /*
+ Section: Event Subscription
+ */
+
+ // Essential: Calls your `callback` when the gutter's visibility changes.
+ //
+ // * `callback` {Function}
+ // * `gutter` The gutter whose visibility changed.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidChangeVisible (callback) {
+ return this.emitter.on('did-change-visible', callback)
+ }
+
+ // Essential: Calls your `callback` when the gutter is destroyed.
+ //
+ // * `callback` {Function}
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidDestroy (callback) {
+ return this.emitter.once('did-destroy', callback)
+ }
+
+ /*
+ Section: Visibility
+ */
+
+ // Essential: Hide the gutter.
+ hide () {
+ if (this.visible) {
+ this.visible = false
+ this.gutterContainer.scheduleComponentUpdate()
+ this.emitter.emit('did-change-visible', this)
+ }
+ }
+
+ // Essential: Show the gutter.
+ show () {
+ if (!this.visible) {
+ this.visible = true
+ this.gutterContainer.scheduleComponentUpdate()
+ this.emitter.emit('did-change-visible', this)
+ }
+ }
+
+ // Essential: Determine whether the gutter is visible.
+ //
+ // Returns a {Boolean}.
+ isVisible () {
+ return this.visible
+ }
+
+ // Essential: Add a decoration that tracks a {DisplayMarker}. When the marker moves,
+ // is invalidated, or is destroyed, the decoration will be updated to reflect
+ // the marker's state.
+ //
+ // ## Arguments
+ //
+ // * `marker` A {DisplayMarker} you want this decoration to follow.
+ // * `decorationParams` An {Object} representing the decoration. It is passed
+ // to {TextEditor::decorateMarker} as its `decorationParams` and so supports
+ // all options documented there.
+ // * `type` __Caveat__: set to `'line-number'` if this is the line-number
+ // gutter, `'gutter'` otherwise. This cannot be overridden.
+ //
+ // Returns a {Decoration} object
+ decorateMarker (marker, options) {
+ return this.gutterContainer.addGutterDecoration(this, marker, options)
+ }
+
+ getElement () {
+ if (this.element == null) this.element = document.createElement('div')
+ return this.element
+ }
+}
diff --git a/src/language-mode.coffee b/src/language-mode.coffee
deleted file mode 100644
index 1839f1c59..000000000
--- a/src/language-mode.coffee
+++ /dev/null
@@ -1,350 +0,0 @@
-{Range} = require 'text-buffer'
-_ = require 'underscore-plus'
-{OnigRegExp} = require 'oniguruma'
-ScopeDescriptor = require './scope-descriptor'
-NullGrammar = require './null-grammar'
-
-module.exports =
-class LanguageMode
- # Sets up a `LanguageMode` for the given {TextEditor}.
- #
- # editor - The {TextEditor} to associate with
- constructor: (@editor) ->
- {@buffer} = @editor
- @regexesByPattern = {}
-
- destroy: ->
-
- toggleLineCommentForBufferRow: (row) ->
- @toggleLineCommentsForBufferRows(row, row)
-
- # Wraps the lines between two rows in comments.
- #
- # If the language doesn't have comment, nothing happens.
- #
- # startRow - The row {Number} to start at
- # endRow - The row {Number} to end at
- toggleLineCommentsForBufferRows: (start, end) ->
- scope = @editor.scopeDescriptorForBufferPosition([start, 0])
- commentStrings = @editor.getCommentStrings(scope)
- return unless commentStrings?.commentStartString
- {commentStartString, commentEndString} = commentStrings
-
- buffer = @editor.buffer
- commentStartRegexString = _.escapeRegExp(commentStartString).replace(/(\s+)$/, '(?:$1)?')
- commentStartRegex = new OnigRegExp("^(\\s*)(#{commentStartRegexString})")
-
- if commentEndString
- shouldUncomment = commentStartRegex.testSync(buffer.lineForRow(start))
- if shouldUncomment
- commentEndRegexString = _.escapeRegExp(commentEndString).replace(/^(\s+)/, '(?:$1)?')
- commentEndRegex = new OnigRegExp("(#{commentEndRegexString})(\\s*)$")
- startMatch = commentStartRegex.searchSync(buffer.lineForRow(start))
- endMatch = commentEndRegex.searchSync(buffer.lineForRow(end))
- if startMatch and endMatch
- buffer.transact ->
- columnStart = startMatch[1].length
- columnEnd = columnStart + startMatch[2].length
- buffer.setTextInRange([[start, columnStart], [start, columnEnd]], "")
-
- endLength = buffer.lineLengthForRow(end) - endMatch[2].length
- endColumn = endLength - endMatch[1].length
- buffer.setTextInRange([[end, endColumn], [end, endLength]], "")
- else
- buffer.transact ->
- indentLength = buffer.lineForRow(start).match(/^\s*/)?[0].length ? 0
- buffer.insert([start, indentLength], commentStartString)
- buffer.insert([end, buffer.lineLengthForRow(end)], commentEndString)
- else
- allBlank = true
- allBlankOrCommented = true
-
- for row in [start..end] by 1
- line = buffer.lineForRow(row)
- blank = line?.match(/^\s*$/)
-
- allBlank = false unless blank
- allBlankOrCommented = false unless blank or commentStartRegex.testSync(line)
-
- shouldUncomment = allBlankOrCommented and not allBlank
-
- if shouldUncomment
- for row in [start..end] by 1
- if match = commentStartRegex.searchSync(buffer.lineForRow(row))
- columnStart = match[1].length
- columnEnd = columnStart + match[2].length
- buffer.setTextInRange([[row, columnStart], [row, columnEnd]], "")
- else
- if start is end
- indent = @editor.indentationForBufferRow(start)
- else
- indent = @minIndentLevelForRowRange(start, end)
- indentString = @editor.buildIndentString(indent)
- tabLength = @editor.getTabLength()
- indentRegex = new RegExp("(\t|[ ]{#{tabLength}}){#{Math.floor(indent)}}")
- for row in [start..end] by 1
- line = buffer.lineForRow(row)
- if indentLength = line.match(indentRegex)?[0].length
- buffer.insert([row, indentLength], commentStartString)
- else
- buffer.setTextInRange([[row, 0], [row, indentString.length]], indentString + commentStartString)
- return
-
- # Folds all the foldable lines in the buffer.
- foldAll: ->
- @unfoldAll()
- foldedRowRanges = {}
- for currentRow in [0..@buffer.getLastRow()] by 1
- rowRange = [startRow, endRow] = @rowRangeForFoldAtBufferRow(currentRow) ? []
- continue unless startRow?
- continue if foldedRowRanges[rowRange]
-
- @editor.foldBufferRowRange(startRow, endRow)
- foldedRowRanges[rowRange] = true
- return
-
- # Unfolds all the foldable lines in the buffer.
- unfoldAll: ->
- @editor.displayLayer.destroyAllFolds()
-
- # Fold all comment and code blocks at a given indentLevel
- #
- # indentLevel - A {Number} indicating indentLevel; 0 based.
- foldAllAtIndentLevel: (indentLevel) ->
- @unfoldAll()
- foldedRowRanges = {}
- for currentRow in [0..@buffer.getLastRow()] by 1
- rowRange = [startRow, endRow] = @rowRangeForFoldAtBufferRow(currentRow) ? []
- continue unless startRow?
- continue if foldedRowRanges[rowRange]
-
- # assumption: startRow will always be the min indent level for the entire range
- if @editor.indentationForBufferRow(startRow) is indentLevel
- @editor.foldBufferRowRange(startRow, endRow)
- foldedRowRanges[rowRange] = true
- return
-
- # Given a buffer row, creates a fold at it.
- #
- # bufferRow - A {Number} indicating the buffer row
- #
- # Returns the new {Fold}.
- foldBufferRow: (bufferRow) ->
- for currentRow in [bufferRow..0] by -1
- [startRow, endRow] = @rowRangeForFoldAtBufferRow(currentRow) ? []
- continue unless startRow? and startRow <= bufferRow <= endRow
- unless @editor.isFoldedAtBufferRow(startRow)
- return @editor.foldBufferRowRange(startRow, endRow)
-
- # Find the row range for a fold at a given bufferRow. Will handle comments
- # and code.
- #
- # bufferRow - A {Number} indicating the buffer row
- #
- # Returns an {Array} of the [startRow, endRow]. Returns null if no range.
- rowRangeForFoldAtBufferRow: (bufferRow) ->
- rowRange = @rowRangeForCommentAtBufferRow(bufferRow)
- rowRange ?= @rowRangeForCodeFoldAtBufferRow(bufferRow)
- rowRange
-
- rowRangeForCommentAtBufferRow: (bufferRow) ->
- return unless @editor.tokenizedBuffer.tokenizedLines[bufferRow]?.isComment()
-
- startRow = bufferRow
- endRow = bufferRow
-
- if bufferRow > 0
- for currentRow in [bufferRow-1..0] by -1
- break unless @editor.tokenizedBuffer.tokenizedLines[currentRow]?.isComment()
- startRow = currentRow
-
- if bufferRow < @buffer.getLastRow()
- for currentRow in [bufferRow+1..@buffer.getLastRow()] by 1
- break unless @editor.tokenizedBuffer.tokenizedLines[currentRow]?.isComment()
- endRow = currentRow
-
- return [startRow, endRow] if startRow isnt endRow
-
- rowRangeForCodeFoldAtBufferRow: (bufferRow) ->
- return null unless @isFoldableAtBufferRow(bufferRow)
-
- startIndentLevel = @editor.indentationForBufferRow(bufferRow)
- scopeDescriptor = @editor.scopeDescriptorForBufferPosition([bufferRow, 0])
- for row in [(bufferRow + 1)..@editor.getLastBufferRow()] by 1
- continue if @editor.isBufferRowBlank(row)
- indentation = @editor.indentationForBufferRow(row)
- if indentation <= startIndentLevel
- includeRowInFold = indentation is startIndentLevel and @foldEndRegexForScopeDescriptor(scopeDescriptor)?.searchSync(@editor.lineTextForBufferRow(row))
- foldEndRow = row if includeRowInFold
- break
-
- foldEndRow = row
-
- [bufferRow, foldEndRow]
-
- isFoldableAtBufferRow: (bufferRow) ->
- @editor.tokenizedBuffer.isFoldableAtRow(bufferRow)
-
- # Returns a {Boolean} indicating whether the line at the given buffer
- # row is a comment.
- isLineCommentedAtBufferRow: (bufferRow) ->
- return false unless 0 <= bufferRow <= @editor.getLastBufferRow()
- @editor.tokenizedBuffer.tokenizedLines[bufferRow]?.isComment() ? false
-
- # Find a row range for a 'paragraph' around specified bufferRow. A paragraph
- # is a block of text bounded by and empty line or a block of text that is not
- # the same type (comments next to source code).
- rowRangeForParagraphAtBufferRow: (bufferRow) ->
- scope = @editor.scopeDescriptorForBufferPosition([bufferRow, 0])
- commentStrings = @editor.getCommentStrings(scope)
- commentStartRegex = null
- if commentStrings?.commentStartString? and not commentStrings.commentEndString?
- commentStartRegexString = _.escapeRegExp(commentStrings.commentStartString).replace(/(\s+)$/, '(?:$1)?')
- commentStartRegex = new OnigRegExp("^(\\s*)(#{commentStartRegexString})")
-
- filterCommentStart = (line) ->
- if commentStartRegex?
- matches = commentStartRegex.searchSync(line)
- line = line.substring(matches[0].end) if matches?.length
- line
-
- return unless /\S/.test(filterCommentStart(@editor.lineTextForBufferRow(bufferRow)))
-
- if @isLineCommentedAtBufferRow(bufferRow)
- isOriginalRowComment = true
- range = @rowRangeForCommentAtBufferRow(bufferRow)
- [firstRow, lastRow] = range or [bufferRow, bufferRow]
- else
- isOriginalRowComment = false
- [firstRow, lastRow] = [0, @editor.getLastBufferRow()-1]
-
- startRow = bufferRow
- while startRow > firstRow
- break if @isLineCommentedAtBufferRow(startRow - 1) isnt isOriginalRowComment
- break unless /\S/.test(filterCommentStart(@editor.lineTextForBufferRow(startRow - 1)))
- startRow--
-
- endRow = bufferRow
- lastRow = @editor.getLastBufferRow()
- while endRow < lastRow
- break if @isLineCommentedAtBufferRow(endRow + 1) isnt isOriginalRowComment
- break unless /\S/.test(filterCommentStart(@editor.lineTextForBufferRow(endRow + 1)))
- endRow++
-
- new Range([startRow, 0], [endRow, @editor.lineTextForBufferRow(endRow).length])
-
- # Given a buffer row, this returns a suggested indentation level.
- #
- # The indentation level provided is based on the current {LanguageMode}.
- #
- # bufferRow - A {Number} indicating the buffer row
- #
- # Returns a {Number}.
- suggestedIndentForBufferRow: (bufferRow, options) ->
- line = @buffer.lineForRow(bufferRow)
- tokenizedLine = @editor.tokenizedBuffer.tokenizedLineForRow(bufferRow)
- @suggestedIndentForTokenizedLineAtBufferRow(bufferRow, line, tokenizedLine, options)
-
- suggestedIndentForLineAtBufferRow: (bufferRow, line, options) ->
- tokenizedLine = @editor.tokenizedBuffer.buildTokenizedLineForRowWithText(bufferRow, line)
- @suggestedIndentForTokenizedLineAtBufferRow(bufferRow, line, tokenizedLine, options)
-
- suggestedIndentForTokenizedLineAtBufferRow: (bufferRow, line, tokenizedLine, options) ->
- iterator = tokenizedLine.getTokenIterator()
- iterator.next()
- scopeDescriptor = new ScopeDescriptor(scopes: iterator.getScopes())
-
- increaseIndentRegex = @increaseIndentRegexForScopeDescriptor(scopeDescriptor)
- decreaseIndentRegex = @decreaseIndentRegexForScopeDescriptor(scopeDescriptor)
- decreaseNextIndentRegex = @decreaseNextIndentRegexForScopeDescriptor(scopeDescriptor)
-
- if options?.skipBlankLines ? true
- precedingRow = @buffer.previousNonBlankRow(bufferRow)
- return 0 unless precedingRow?
- else
- precedingRow = bufferRow - 1
- return 0 if precedingRow < 0
-
- desiredIndentLevel = @editor.indentationForBufferRow(precedingRow)
- return desiredIndentLevel unless increaseIndentRegex
-
- unless @editor.isBufferRowCommented(precedingRow)
- precedingLine = @buffer.lineForRow(precedingRow)
- desiredIndentLevel += 1 if increaseIndentRegex?.testSync(precedingLine)
- desiredIndentLevel -= 1 if decreaseNextIndentRegex?.testSync(precedingLine)
-
- unless @buffer.isRowBlank(precedingRow)
- desiredIndentLevel -= 1 if decreaseIndentRegex?.testSync(line)
-
- Math.max(desiredIndentLevel, 0)
-
- # Calculate a minimum indent level for a range of lines excluding empty lines.
- #
- # startRow - The row {Number} to start at
- # endRow - The row {Number} to end at
- #
- # Returns a {Number} of the indent level of the block of lines.
- minIndentLevelForRowRange: (startRow, endRow) ->
- indents = (@editor.indentationForBufferRow(row) for row in [startRow..endRow] by 1 when not @editor.isBufferRowBlank(row))
- indents = [0] unless indents.length
- Math.min(indents...)
-
- # Indents all the rows between two buffer row numbers.
- #
- # startRow - The row {Number} to start at
- # endRow - The row {Number} to end at
- autoIndentBufferRows: (startRow, endRow) ->
- @autoIndentBufferRow(row) for row in [startRow..endRow] by 1
- return
-
- # Given a buffer row, this indents it.
- #
- # bufferRow - The row {Number}.
- # options - An options {Object} to pass through to {TextEditor::setIndentationForBufferRow}.
- autoIndentBufferRow: (bufferRow, options) ->
- indentLevel = @suggestedIndentForBufferRow(bufferRow, options)
- @editor.setIndentationForBufferRow(bufferRow, indentLevel, options)
-
- # Given a buffer row, this decreases the indentation.
- #
- # bufferRow - The row {Number}
- autoDecreaseIndentForBufferRow: (bufferRow) ->
- scopeDescriptor = @editor.scopeDescriptorForBufferPosition([bufferRow, 0])
- return unless decreaseIndentRegex = @decreaseIndentRegexForScopeDescriptor(scopeDescriptor)
-
- line = @buffer.lineForRow(bufferRow)
- return unless decreaseIndentRegex.testSync(line)
-
- currentIndentLevel = @editor.indentationForBufferRow(bufferRow)
- return if currentIndentLevel is 0
-
- precedingRow = @buffer.previousNonBlankRow(bufferRow)
- return unless precedingRow?
-
- precedingLine = @buffer.lineForRow(precedingRow)
- desiredIndentLevel = @editor.indentationForBufferRow(precedingRow)
-
- if increaseIndentRegex = @increaseIndentRegexForScopeDescriptor(scopeDescriptor)
- desiredIndentLevel -= 1 unless increaseIndentRegex.testSync(precedingLine)
-
- if decreaseNextIndentRegex = @decreaseNextIndentRegexForScopeDescriptor(scopeDescriptor)
- desiredIndentLevel -= 1 if decreaseNextIndentRegex.testSync(precedingLine)
-
- if desiredIndentLevel >= 0 and desiredIndentLevel < currentIndentLevel
- @editor.setIndentationForBufferRow(bufferRow, desiredIndentLevel)
-
- cacheRegex: (pattern) ->
- if pattern
- @regexesByPattern[pattern] ?= new OnigRegExp(pattern)
-
- increaseIndentRegexForScopeDescriptor: (scopeDescriptor) ->
- @cacheRegex(@editor.getIncreaseIndentPattern(scopeDescriptor))
-
- decreaseIndentRegexForScopeDescriptor: (scopeDescriptor) ->
- @cacheRegex(@editor.getDecreaseIndentPattern(scopeDescriptor))
-
- decreaseNextIndentRegexForScopeDescriptor: (scopeDescriptor) ->
- @cacheRegex(@editor.getDecreaseNextIndentPattern(scopeDescriptor))
-
- foldEndRegexForScopeDescriptor: (scopeDescriptor) ->
- @cacheRegex(@editor.getFoldEndPattern(scopeDescriptor))
diff --git a/src/main-process/atom-application.coffee b/src/main-process/atom-application.coffee
index dcc7c6513..0c587020e 100644
--- a/src/main-process/atom-application.coffee
+++ b/src/main-process/atom-application.coffee
@@ -648,6 +648,41 @@ class AtomApplication
# :devMode - Boolean to control the opened window's dev mode.
# :safeMode - Boolean to control the opened window's safe mode.
openUrl: ({urlToOpen, devMode, safeMode, env}) ->
+ parsedUrl = url.parse(urlToOpen)
+ return unless parsedUrl.protocol is "atom:"
+
+ pack = @findPackageWithName(parsedUrl.host, devMode)
+ if pack?.urlMain
+ @openPackageUrlMain(parsedUrl.host, pack.urlMain, urlToOpen, devMode, safeMode, env)
+ else
+ @openPackageUriHandler(urlToOpen, devMode, safeMode, env)
+
+ openPackageUriHandler: (url, devMode, safeMode, env) ->
+ resourcePath = @resourcePath
+ if devMode
+ try
+ windowInitializationScript = require.resolve(path.join(@devResourcePath, 'src', 'initialize-application-window'))
+ resourcePath = @devResourcePath
+
+ windowInitializationScript ?= require.resolve('../initialize-application-window')
+ if @lastFocusedWindow?
+ @lastFocusedWindow.sendURIMessage url
+ else
+ windowDimensions = @getDimensionsForNewWindow()
+ @lastFocusedWindow = new AtomWindow(this, @fileRecoveryService, {resourcePath, windowInitializationScript, devMode, safeMode, windowDimensions, env})
+ @lastFocusedWindow.on 'window:loaded', =>
+ @lastFocusedWindow.sendURIMessage url
+
+ findPackageWithName: (packageName, devMode) ->
+ _.find @getPackageManager(devMode).getAvailablePackageMetadata(), ({name}) -> name is packageName
+
+ openPackageUrlMain: (packageName, packageUrlMain, urlToOpen, devMode, safeMode, env) ->
+ packagePath = @getPackageManager(devMode).resolvePackagePath(packageName)
+ windowInitializationScript = path.resolve(packagePath, packageUrlMain)
+ windowDimensions = @getDimensionsForNewWindow()
+ new AtomWindow(this, @fileRecoveryService, {windowInitializationScript, @resourcePath, devMode, safeMode, urlToOpen, windowDimensions, env})
+
+ getPackageManager: (devMode) ->
unless @packages?
PackageManager = require '../package-manager'
@packages = new PackageManager({})
@@ -656,18 +691,8 @@ class AtomApplication
devMode: devMode
resourcePath: @resourcePath
- packageName = url.parse(urlToOpen).host
- pack = _.find @packages.getAvailablePackageMetadata(), ({name}) -> name is packageName
- if pack?
- if pack.urlMain
- packagePath = @packages.resolvePackagePath(packageName)
- windowInitializationScript = path.resolve(packagePath, pack.urlMain)
- windowDimensions = @getDimensionsForNewWindow()
- new AtomWindow(this, @fileRecoveryService, {windowInitializationScript, @resourcePath, devMode, safeMode, urlToOpen, windowDimensions, env})
- else
- console.log "Package '#{pack.name}' does not have a url main: #{urlToOpen}"
- else
- console.log "Opening unknown url: #{urlToOpen}"
+ @packages
+
# Opens up a new {AtomWindow} to run specs within.
#
diff --git a/src/main-process/atom-window.coffee b/src/main-process/atom-window.coffee
index 9bbdcfc25..ca3995c05 100644
--- a/src/main-process/atom-window.coffee
+++ b/src/main-process/atom-window.coffee
@@ -232,6 +232,9 @@ class AtomWindow
unless @atomApplication.sendCommandToFirstResponder(command)
@sendCommandToBrowserWindow(command, args...)
+ sendURIMessage: (uri) ->
+ @browserWindow.webContents.send 'uri-message', uri
+
sendCommandToBrowserWindow: (command, args...) ->
action = if args[0]?.contextCommand then 'context-command' else 'command'
@browserWindow.webContents.send action, command, args...
diff --git a/src/main-process/parse-command-line.js b/src/main-process/parse-command-line.js
index 7531e609b..3b0654962 100644
--- a/src/main-process/parse-command-line.js
+++ b/src/main-process/parse-command-line.js
@@ -19,6 +19,8 @@ module.exports = function parseCommandLine (processArgs) {
will be opened in that window. Otherwise, they will be opened in a new
window.
+ Paths that start with \`atom://\` will be interpreted as URLs.
+
Environment Variables:
ATOM_DEV_RESOURCE_PATH The path from which Atom loads source code in dev mode.
@@ -56,8 +58,18 @@ module.exports = function parseCommandLine (processArgs) {
options.string('user-data-dir')
options.boolean('clear-window-state').describe('clear-window-state', 'Delete all Atom environment state.')
options.boolean('enable-electron-logging').describe('enable-electron-logging', 'Enable low-level logging messages from Electron.')
+ options.boolean('uri-handler')
- const args = options.argv
+ let args = options.argv
+
+ // If --uri-handler is set, then we parse NOTHING else
+ if (args.uriHandler) {
+ args = {
+ uriHandler: true,
+ 'uri-handler': true,
+ _: args._.filter(str => str.startsWith('atom://')).slice(0, 1)
+ }
+ }
if (args.help) {
process.stdout.write(options.help())
@@ -76,7 +88,6 @@ module.exports = function parseCommandLine (processArgs) {
const addToLastWindow = args['add']
const safeMode = args['safe']
- const pathsToOpen = args._
const benchmark = args['benchmark']
const benchmarkTest = args['benchmark-test']
const test = args['test']
@@ -100,11 +111,20 @@ module.exports = function parseCommandLine (processArgs) {
const userDataDir = args['user-data-dir']
const profileStartup = args['profile-startup']
const clearWindowState = args['clear-window-state']
- const urlsToOpen = []
+ let pathsToOpen = []
+ let urlsToOpen = []
let devMode = args['dev']
let devResourcePath = process.env.ATOM_DEV_RESOURCE_PATH || path.join(app.getPath('home'), 'github', 'atom')
let resourcePath = null
+ for (const path of args._) {
+ if (path.startsWith('atom://')) {
+ urlsToOpen.push(path)
+ } else {
+ pathsToOpen.push(path)
+ }
+ }
+
if (args['resource-path']) {
devMode = true
devResourcePath = args['resource-path']
diff --git a/src/native-watcher-registry.js b/src/native-watcher-registry.js
index 798ff0619..e63ac6cda 100644
--- a/src/native-watcher-registry.js
+++ b/src/native-watcher-registry.js
@@ -239,7 +239,7 @@ class RegistryWatcherNode {
this.childPaths.add(path.join(...childPathSegments))
}
- // Private: Stop assuming responsbility for a previously assigned child path. If this node is
+ // Private: Stop assuming responsibility for a previously assigned child path. If this node is
// removed, the named child path will no longer be allocated a {RegistryWatcherNode}.
//
// * `childPathSegments` the {Array} of path segments between this node's directory and the no longer
@@ -323,13 +323,13 @@ class RegistryWatcherNode {
}
}
-// Private: A {RegisteryNode} traversal result that's returned when neither a directory, its children, nor its parents
+// Private: A {RegistryNode} traversal result that's returned when neither a directory, its children, nor its parents
// are present in the tree.
class MissingResult {
// Private: Instantiate a new {MissingResult}.
//
- // * `lastParent` the final succesfully traversed {RegistryNode}.
+ // * `lastParent` the final successfully traversed {RegistryNode}.
constructor (lastParent) {
this.lastParent = lastParent
}
diff --git a/src/notification-manager.coffee b/src/notification-manager.coffee
deleted file mode 100644
index 4beab82b9..000000000
--- a/src/notification-manager.coffee
+++ /dev/null
@@ -1,183 +0,0 @@
-{Emitter} = require 'event-kit'
-Notification = require '../src/notification'
-
-# Public: A notification manager used to create {Notification}s to be shown
-# to the user.
-#
-# An instance of this class is always available as the `atom.notifications`
-# global.
-module.exports =
-class NotificationManager
- constructor: ->
- @notifications = []
- @emitter = new Emitter
-
- ###
- Section: Events
- ###
-
- # Public: Invoke the given callback after a notification has been added.
- #
- # * `callback` {Function} to be called after the notification is added.
- # * `notification` The {Notification} that was added.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidAddNotification: (callback) ->
- @emitter.on 'did-add-notification', callback
-
- ###
- Section: Adding Notifications
- ###
-
- # Public: Add a success notification.
- #
- # * `message` A {String} message
- # * `options` (optional) An options {Object} with the following keys:
- # * `buttons` (optional) An {Array} of {Object} where each {Object} has the
- # following options:
- # * `className` (optional) {String} a class name to add to the button's
- # default class name (`btn btn-success`).
- # * `onDidClick` (optional) {Function} callback to call when the button
- # has been clicked. The context will be set to the
- # {NotificationElement} instance.
- # * `text` {String} inner text for the button
- # * `description` (optional) A Markdown {String} containing a longer
- # description about the notification. By default, this **will not**
- # preserve newlines and whitespace when it is rendered.
- # * `detail` (optional) A plain-text {String} containing additional details
- # about the notification. By default, this **will** preserve newlines
- # and whitespace when it is rendered.
- # * `dismissable` (optional) A {Boolean} indicating whether this
- # notification can be dismissed by the user. Defaults to `false`.
- # * `icon` (optional) A {String} name of an icon from Octicons to display
- # in the notification header. Defaults to `'check'`.
- addSuccess: (message, options) ->
- @addNotification(new Notification('success', message, options))
-
- # Public: Add an informational notification.
- #
- # * `message` A {String} message
- # * `options` (optional) An options {Object} with the following keys:
- # * `buttons` (optional) An {Array} of {Object} where each {Object} has the
- # following options:
- # * `className` (optional) {String} a class name to add to the button's
- # default class name (`btn btn-info`).
- # * `onDidClick` (optional) {Function} callback to call when the button
- # has been clicked. The context will be set to the
- # {NotificationElement} instance.
- # * `text` {String} inner text for the button
- # * `description` (optional) A Markdown {String} containing a longer
- # description about the notification. By default, this **will not**
- # preserve newlines and whitespace when it is rendered.
- # * `detail` (optional) A plain-text {String} containing additional details
- # about the notification. By default, this **will** preserve newlines
- # and whitespace when it is rendered.
- # * `dismissable` (optional) A {Boolean} indicating whether this
- # notification can be dismissed by the user. Defaults to `false`.
- # * `icon` (optional) A {String} name of an icon from Octicons to display
- # in the notification header. Defaults to `'info'`.
- addInfo: (message, options) ->
- @addNotification(new Notification('info', message, options))
-
- # Public: Add a warning notification.
- #
- # * `message` A {String} message
- # * `options` (optional) An options {Object} with the following keys:
- # * `buttons` (optional) An {Array} of {Object} where each {Object} has the
- # following options:
- # * `className` (optional) {String} a class name to add to the button's
- # default class name (`btn btn-warning`).
- # * `onDidClick` (optional) {Function} callback to call when the button
- # has been clicked. The context will be set to the
- # {NotificationElement} instance.
- # * `text` {String} inner text for the button
- # * `description` (optional) A Markdown {String} containing a longer
- # description about the notification. By default, this **will not**
- # preserve newlines and whitespace when it is rendered.
- # * `detail` (optional) A plain-text {String} containing additional details
- # about the notification. By default, this **will** preserve newlines
- # and whitespace when it is rendered.
- # * `dismissable` (optional) A {Boolean} indicating whether this
- # notification can be dismissed by the user. Defaults to `false`.
- # * `icon` (optional) A {String} name of an icon from Octicons to display
- # in the notification header. Defaults to `'alert'`.
- addWarning: (message, options) ->
- @addNotification(new Notification('warning', message, options))
-
- # Public: Add an error notification.
- #
- # * `message` A {String} message
- # * `options` (optional) An options {Object} with the following keys:
- # * `buttons` (optional) An {Array} of {Object} where each {Object} has the
- # following options:
- # * `className` (optional) {String} a class name to add to the button's
- # default class name (`btn btn-error`).
- # * `onDidClick` (optional) {Function} callback to call when the button
- # has been clicked. The context will be set to the
- # {NotificationElement} instance.
- # * `text` {String} inner text for the button
- # * `description` (optional) A Markdown {String} containing a longer
- # description about the notification. By default, this **will not**
- # preserve newlines and whitespace when it is rendered.
- # * `detail` (optional) A plain-text {String} containing additional details
- # about the notification. By default, this **will** preserve newlines
- # and whitespace when it is rendered.
- # * `dismissable` (optional) A {Boolean} indicating whether this
- # notification can be dismissed by the user. Defaults to `false`.
- # * `icon` (optional) A {String} name of an icon from Octicons to display
- # in the notification header. Defaults to `'flame'`.
- # * `stack` (optional) A preformatted {String} with stack trace information
- # describing the location of the error.
- addError: (message, options) ->
- @addNotification(new Notification('error', message, options))
-
- # Public: Add a fatal error notification.
- #
- # * `message` A {String} message
- # * `options` (optional) An options {Object} with the following keys:
- # * `buttons` (optional) An {Array} of {Object} where each {Object} has the
- # following options:
- # * `className` (optional) {String} a class name to add to the button's
- # default class name (`btn btn-error`).
- # * `onDidClick` (optional) {Function} callback to call when the button
- # has been clicked. The context will be set to the
- # {NotificationElement} instance.
- # * `text` {String} inner text for the button
- # * `description` (optional) A Markdown {String} containing a longer
- # description about the notification. By default, this **will not**
- # preserve newlines and whitespace when it is rendered.
- # * `detail` (optional) A plain-text {String} containing additional details
- # about the notification. By default, this **will** preserve newlines
- # and whitespace when it is rendered.
- # * `dismissable` (optional) A {Boolean} indicating whether this
- # notification can be dismissed by the user. Defaults to `false`.
- # * `icon` (optional) A {String} name of an icon from Octicons to display
- # in the notification header. Defaults to `'bug'`.
- # * `stack` (optional) A preformatted {String} with stack trace information
- # describing the location of the error.
- addFatalError: (message, options) ->
- @addNotification(new Notification('fatal', message, options))
-
- add: (type, message, options) ->
- @addNotification(new Notification(type, message, options))
-
- addNotification: (notification) ->
- @notifications.push(notification)
- @emitter.emit('did-add-notification', notification)
- notification
-
- ###
- Section: Getting Notifications
- ###
-
- # Public: Get all the notifications.
- #
- # Returns an {Array} of {Notification}s.
- getNotifications: -> @notifications.slice()
-
- ###
- Section: Managing Notifications
- ###
-
- clear: ->
- @notifications = []
diff --git a/src/notification-manager.js b/src/notification-manager.js
new file mode 100644
index 000000000..df5e5fb42
--- /dev/null
+++ b/src/notification-manager.js
@@ -0,0 +1,206 @@
+const {Emitter} = require('event-kit')
+const Notification = require('../src/notification')
+
+// Public: A notification manager used to create {Notification}s to be shown
+// to the user.
+//
+// An instance of this class is always available as the `atom.notifications`
+// global.
+module.exports =
+class NotificationManager {
+ constructor () {
+ this.notifications = []
+ this.emitter = new Emitter()
+ }
+
+ /*
+ Section: Events
+ */
+
+ // Public: Invoke the given callback after a notification has been added.
+ //
+ // * `callback` {Function} to be called after the notification is added.
+ // * `notification` The {Notification} that was added.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidAddNotification (callback) {
+ return this.emitter.on('did-add-notification', callback)
+ }
+
+ /*
+ Section: Adding Notifications
+ */
+
+ // Public: Add a success notification.
+ //
+ // * `message` A {String} message
+ // * `options` (optional) An options {Object} with the following keys:
+ // * `buttons` (optional) An {Array} of {Object} where each {Object} has
+ // the following options:
+ // * `className` (optional) {String} a class name to add to the button's
+ // default class name (`btn btn-success`).
+ // * `onDidClick` (optional) {Function} callback to call when the button
+ // has been clicked. The context will be set to the
+ // {NotificationElement} instance.
+ // * `text` {String} inner text for the button
+ // * `description` (optional) A Markdown {String} containing a longer
+ // description about the notification. By default, this **will not**
+ // preserve newlines and whitespace when it is rendered.
+ // * `detail` (optional) A plain-text {String} containing additional
+ // details about the notification. By default, this **will** preserve
+ // newlines and whitespace when it is rendered.
+ // * `dismissable` (optional) A {Boolean} indicating whether this
+ // notification can be dismissed by the user. Defaults to `false`.
+ // * `icon` (optional) A {String} name of an icon from Octicons to display
+ // in the notification header. Defaults to `'check'`.
+ //
+ // Returns the {Notification} that was added.
+ addSuccess (message, options) {
+ return this.addNotification(new Notification('success', message, options))
+ }
+
+ // Public: Add an informational notification.
+ //
+ // * `message` A {String} message
+ // * `options` (optional) An options {Object} with the following keys:
+ // * `buttons` (optional) An {Array} of {Object} where each {Object} has
+ // the following options:
+ // * `className` (optional) {String} a class name to add to the button's
+ // default class name (`btn btn-info`).
+ // * `onDidClick` (optional) {Function} callback to call when the button
+ // has been clicked. The context will be set to the
+ // {NotificationElement} instance.
+ // * `text` {String} inner text for the button
+ // * `description` (optional) A Markdown {String} containing a longer
+ // description about the notification. By default, this **will not**
+ // preserve newlines and whitespace when it is rendered.
+ // * `detail` (optional) A plain-text {String} containing additional
+ // details about the notification. By default, this **will** preserve
+ // newlines and whitespace when it is rendered.
+ // * `dismissable` (optional) A {Boolean} indicating whether this
+ // notification can be dismissed by the user. Defaults to `false`.
+ // * `icon` (optional) A {String} name of an icon from Octicons to display
+ // in the notification header. Defaults to `'info'`.
+ //
+ // Returns the {Notification} that was added.
+ addInfo (message, options) {
+ return this.addNotification(new Notification('info', message, options))
+ }
+
+ // Public: Add a warning notification.
+ //
+ // * `message` A {String} message
+ // * `options` (optional) An options {Object} with the following keys:
+ // * `buttons` (optional) An {Array} of {Object} where each {Object} has
+ // the following options:
+ // * `className` (optional) {String} a class name to add to the button's
+ // default class name (`btn btn-warning`).
+ // * `onDidClick` (optional) {Function} callback to call when the button
+ // has been clicked. The context will be set to the
+ // {NotificationElement} instance.
+ // * `text` {String} inner text for the button
+ // * `description` (optional) A Markdown {String} containing a longer
+ // description about the notification. By default, this **will not**
+ // preserve newlines and whitespace when it is rendered.
+ // * `detail` (optional) A plain-text {String} containing additional
+ // details about the notification. By default, this **will** preserve
+ // newlines and whitespace when it is rendered.
+ // * `dismissable` (optional) A {Boolean} indicating whether this
+ // notification can be dismissed by the user. Defaults to `false`.
+ // * `icon` (optional) A {String} name of an icon from Octicons to display
+ // in the notification header. Defaults to `'alert'`.
+ //
+ // Returns the {Notification} that was added.
+ addWarning (message, options) {
+ return this.addNotification(new Notification('warning', message, options))
+ }
+
+ // Public: Add an error notification.
+ //
+ // * `message` A {String} message
+ // * `options` (optional) An options {Object} with the following keys:
+ // * `buttons` (optional) An {Array} of {Object} where each {Object} has
+ // the following options:
+ // * `className` (optional) {String} a class name to add to the button's
+ // default class name (`btn btn-error`).
+ // * `onDidClick` (optional) {Function} callback to call when the button
+ // has been clicked. The context will be set to the
+ // {NotificationElement} instance.
+ // * `text` {String} inner text for the button
+ // * `description` (optional) A Markdown {String} containing a longer
+ // description about the notification. By default, this **will not**
+ // preserve newlines and whitespace when it is rendered.
+ // * `detail` (optional) A plain-text {String} containing additional
+ // details about the notification. By default, this **will** preserve
+ // newlines and whitespace when it is rendered.
+ // * `dismissable` (optional) A {Boolean} indicating whether this
+ // notification can be dismissed by the user. Defaults to `false`.
+ // * `icon` (optional) A {String} name of an icon from Octicons to display
+ // in the notification header. Defaults to `'flame'`.
+ // * `stack` (optional) A preformatted {String} with stack trace
+ // information describing the location of the error.
+ //
+ // Returns the {Notification} that was added.
+ addError (message, options) {
+ return this.addNotification(new Notification('error', message, options))
+ }
+
+ // Public: Add a fatal error notification.
+ //
+ // * `message` A {String} message
+ // * `options` (optional) An options {Object} with the following keys:
+ // * `buttons` (optional) An {Array} of {Object} where each {Object} has
+ // the following options:
+ // * `className` (optional) {String} a class name to add to the button's
+ // default class name (`btn btn-error`).
+ // * `onDidClick` (optional) {Function} callback to call when the button
+ // has been clicked. The context will be set to the
+ // {NotificationElement} instance.
+ // * `text` {String} inner text for the button
+ // * `description` (optional) A Markdown {String} containing a longer
+ // description about the notification. By default, this **will not**
+ // preserve newlines and whitespace when it is rendered.
+ // * `detail` (optional) A plain-text {String} containing additional
+ // details about the notification. By default, this **will** preserve
+ // newlines and whitespace when it is rendered.
+ // * `dismissable` (optional) A {Boolean} indicating whether this
+ // notification can be dismissed by the user. Defaults to `false`.
+ // * `icon` (optional) A {String} name of an icon from Octicons to display
+ // in the notification header. Defaults to `'bug'`.
+ // * `stack` (optional) A preformatted {String} with stack trace
+ // information describing the location of the error.
+ //
+ // Returns the {Notification} that was added.
+ addFatalError (message, options) {
+ return this.addNotification(new Notification('fatal', message, options))
+ }
+
+ add (type, message, options) {
+ return this.addNotification(new Notification(type, message, options))
+ }
+
+ addNotification (notification) {
+ this.notifications.push(notification)
+ this.emitter.emit('did-add-notification', notification)
+ return notification
+ }
+
+ /*
+ Section: Getting Notifications
+ */
+
+ // Public: Get all the notifications.
+ //
+ // Returns an {Array} of {Notification}s.
+ getNotifications () {
+ return this.notifications.slice()
+ }
+
+ /*
+ Section: Managing Notifications
+ */
+
+ clear () {
+ this.notifications = []
+ }
+}
diff --git a/src/notification.coffee b/src/notification.coffee
deleted file mode 100644
index d28bb88e8..000000000
--- a/src/notification.coffee
+++ /dev/null
@@ -1,86 +0,0 @@
-{Emitter} = require 'event-kit'
-_ = require 'underscore-plus'
-
-# Public: A notification to the user containing a message and type.
-module.exports =
-class Notification
- constructor: (@type, @message, @options={}) ->
- @emitter = new Emitter
- @timestamp = new Date()
- @dismissed = true
- @dismissed = false if @isDismissable()
- @displayed = false
- @validate()
-
- validate: ->
- if typeof @message isnt 'string'
- throw new Error("Notification must be created with string message: #{@message}")
-
- unless _.isObject(@options) and not _.isArray(@options)
- throw new Error("Notification must be created with an options object: #{@options}")
-
- ###
- Section: Event Subscription
- ###
-
- # Public: Invoke the given callback when the notification is dismissed.
- #
- # * `callback` {Function} to be called when the notification is dismissed.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidDismiss: (callback) ->
- @emitter.on 'did-dismiss', callback
-
- # Public: Invoke the given callback when the notification is displayed.
- #
- # * `callback` {Function} to be called when the notification is displayed.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidDisplay: (callback) ->
- @emitter.on 'did-display', callback
-
- getOptions: -> @options
-
- ###
- Section: Methods
- ###
-
- # Public: Returns the {String} type.
- getType: -> @type
-
- # Public: Returns the {String} message.
- getMessage: -> @message
-
- getTimestamp: -> @timestamp
-
- getDetail: -> @options.detail
-
- isEqual: (other) ->
- @getMessage() is other.getMessage() \
- and @getType() is other.getType() \
- and @getDetail() is other.getDetail()
-
- # Extended: Dismisses the notification, removing it from the UI. Calling this programmatically
- # will call all callbacks added via `onDidDismiss`.
- dismiss: ->
- return unless @isDismissable() and not @isDismissed()
- @dismissed = true
- @emitter.emit 'did-dismiss', this
-
- isDismissed: -> @dismissed
-
- isDismissable: -> !!@options.dismissable
-
- wasDisplayed: -> @displayed
-
- setDisplayed: (@displayed) ->
- @emitter.emit 'did-display', this
-
- getIcon: ->
- return @options.icon if @options.icon?
- switch @type
- when 'fatal' then 'bug'
- when 'error' then 'flame'
- when 'warning' then 'alert'
- when 'info' then 'info'
- when 'success' then 'check'
diff --git a/src/notification.js b/src/notification.js
new file mode 100644
index 000000000..320866d6b
--- /dev/null
+++ b/src/notification.js
@@ -0,0 +1,118 @@
+const {Emitter} = require('event-kit')
+const _ = require('underscore-plus')
+
+// Public: A notification to the user containing a message and type.
+module.exports =
+class Notification {
+ constructor (type, message, options = {}) {
+ this.type = type
+ this.message = message
+ this.options = options
+ this.emitter = new Emitter()
+ this.timestamp = new Date()
+ this.dismissed = true
+ if (this.isDismissable()) this.dismissed = false
+ this.displayed = false
+ this.validate()
+ }
+
+ validate () {
+ if (typeof this.message !== 'string') {
+ throw new Error(`Notification must be created with string message: ${this.message}`)
+ }
+
+ if (!_.isObject(this.options) || _.isArray(this.options)) {
+ throw new Error(`Notification must be created with an options object: ${this.options}`)
+ }
+ }
+
+ /*
+ Section: Event Subscription
+ */
+
+ // Public: Invoke the given callback when the notification is dismissed.
+ //
+ // * `callback` {Function} to be called when the notification is dismissed.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidDismiss (callback) {
+ return this.emitter.on('did-dismiss', callback)
+ }
+
+ // Public: Invoke the given callback when the notification is displayed.
+ //
+ // * `callback` {Function} to be called when the notification is displayed.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidDisplay (callback) {
+ return this.emitter.on('did-display', callback)
+ }
+
+ getOptions () {
+ return this.options
+ }
+
+ /*
+ Section: Methods
+ */
+
+ // Public: Returns the {String} type.
+ getType () {
+ return this.type
+ }
+
+ // Public: Returns the {String} message.
+ getMessage () {
+ return this.message
+ }
+
+ getTimestamp () {
+ return this.timestamp
+ }
+
+ getDetail () {
+ return this.options.detail
+ }
+
+ isEqual (other) {
+ return (this.getMessage() === other.getMessage()) &&
+ (this.getType() === other.getType()) &&
+ (this.getDetail() === other.getDetail())
+ }
+
+ // Extended: Dismisses the notification, removing it from the UI. Calling this
+ // programmatically will call all callbacks added via `onDidDismiss`.
+ dismiss () {
+ if (!this.isDismissable() || this.isDismissed()) return
+ this.dismissed = true
+ this.emitter.emit('did-dismiss', this)
+ }
+
+ isDismissed () {
+ return this.dismissed
+ }
+
+ isDismissable () {
+ return !!this.options.dismissable
+ }
+
+ wasDisplayed () {
+ return this.displayed
+ }
+
+ setDisplayed (displayed) {
+ this.displayed = displayed
+ this.emitter.emit('did-display', this)
+ }
+
+ getIcon () {
+ if (this.options.icon != null) return this.options.icon
+ switch (this.type) {
+ case 'fatal': return 'bug'
+ case 'error': return 'flame'
+ case 'warning': return 'alert'
+ case 'info': return 'info'
+ case 'success': return 'check'
+ }
+ }
+}
diff --git a/src/package-manager.js b/src/package-manager.js
index 73855ae37..17a5f2214 100644
--- a/src/package-manager.js
+++ b/src/package-manager.js
@@ -31,7 +31,8 @@ module.exports = class PackageManager {
constructor (params) {
({
config: this.config, styleManager: this.styleManager, notificationManager: this.notificationManager, keymapManager: this.keymapManager,
- commandRegistry: this.commandRegistry, grammarRegistry: this.grammarRegistry, deserializerManager: this.deserializerManager, viewRegistry: this.viewRegistry
+ commandRegistry: this.commandRegistry, grammarRegistry: this.grammarRegistry, deserializerManager: this.deserializerManager, viewRegistry: this.viewRegistry,
+ uriHandlerRegistry: this.uriHandlerRegistry
} = params)
this.emitter = new Emitter()
@@ -77,9 +78,9 @@ module.exports = class PackageManager {
this.themeManager = themeManager
}
- reset () {
+ async reset () {
this.serviceHub.clear()
- this.deactivatePackages()
+ await this.deactivatePackages()
this.loadedPackages = {}
this.preloadedPackages = {}
this.packageStates = {}
@@ -647,6 +648,10 @@ module.exports = class PackageManager {
})
}
+ registerURIHandlerForPackage (packageName, handler) {
+ return this.uriHandlerRegistry.registerHostHandler(packageName, handler)
+ }
+
// another type of package manager can handle other package types.
// See ThemeManager
registerPackageActivator (activator, types) {
@@ -744,21 +749,30 @@ module.exports = class PackageManager {
}
// Deactivate all packages
- deactivatePackages () {
- this.config.transact(() => {
- this.getLoadedPackages().forEach(pack => this.deactivatePackage(pack.name, true))
- })
+ async deactivatePackages () {
+ await this.config.transactAsync(() =>
+ Promise.all(this.getLoadedPackages().map(pack => this.deactivatePackage(pack.name, true)))
+ )
this.unobserveDisabledPackages()
this.unobservePackagesWithKeymapsDisabled()
}
// Deactivate the package with the given name
- deactivatePackage (name, suppressSerialization) {
+ async deactivatePackage (name, suppressSerialization) {
const pack = this.getLoadedPackage(name)
+ if (pack == null) {
+ return
+ }
+
if (!suppressSerialization && this.isPackageActive(pack.name)) {
this.serializePackage(pack)
}
- pack.deactivate()
+
+ const deactivationResult = pack.deactivate()
+ if (deactivationResult && typeof deactivationResult.then === 'function') {
+ await deactivationResult
+ }
+
delete this.activePackages[pack.name]
delete this.activatingPackages[pack.name]
this.emitter.emit('did-deactivate-package', pack)
diff --git a/src/package.coffee b/src/package.coffee
index 039ccf9d3..1635c75dc 100644
--- a/src/package.coffee
+++ b/src/package.coffee
@@ -84,6 +84,7 @@ class Package
@loadMenus()
@registerDeserializerMethods()
@activateCoreStartupServices()
+ @registerURIHandler()
@configSchemaRegisteredOnLoad = @registerConfigSchemaFromMetadata()
@requireMainModule()
@settingsPromise = @loadSettings()
@@ -114,6 +115,7 @@ class Package
@loadStylesheets()
@registerDeserializerMethods()
@activateCoreStartupServices()
+ @registerURIHandler()
@registerTranspilerConfig()
@configSchemaRegisteredOnLoad = @registerConfigSchemaFromMetadata()
@settingsPromise = @loadSettings()
@@ -318,6 +320,19 @@ class Package
@activationDisposables.add @packageManager.serviceHub.consume(name, version, @mainModule[methodName].bind(@mainModule))
return
+ registerURIHandler: ->
+ handlerConfig = @getURIHandler()
+ if methodName = handlerConfig?.method
+ @uriHandlerSubscription = @packageManager.registerURIHandlerForPackage @name, (args...) =>
+ @handleURI(methodName, args)
+
+ unregisterURIHandler: ->
+ @uriHandlerSubscription?.dispose()
+
+ handleURI: (methodName, args) ->
+ @activate().then => @mainModule[methodName]?.apply(@mainModule, args)
+ @activateNow() unless @mainActivated
+
registerTranspilerConfig: ->
if @metadata.atomTranspilers
CompileCache.addTranspilerConfigForPath(@path, @name, @metadata, @metadata.atomTranspilers)
@@ -504,16 +519,32 @@ class Package
@activationCommandSubscriptions?.dispose()
@activationHookSubscriptions?.dispose()
@configSchemaRegisteredOnActivate = false
+ @unregisterURIHandler()
@deactivateResources()
@deactivateKeymaps()
- if @mainActivated
- try
- @mainModule?.deactivate?()
- @mainModule?.deactivateConfig?()
- @mainActivated = false
- @mainInitialized = false
- catch e
- console.error "Error deactivating package '#{@name}'", e.stack
+
+ unless @mainActivated
+ @emitter.emit 'did-deactivate'
+ return
+
+ try
+ deactivationResult = @mainModule?.deactivate?()
+ catch e
+ console.error "Error deactivating package '#{@name}'", e.stack
+
+ # We support then-able async promises as well as sync ones from deactivate
+ if typeof deactivationResult?.then is 'function'
+ deactivationResult.then => @afterDeactivation()
+ else
+ @afterDeactivation()
+
+ afterDeactivation: ->
+ try
+ @mainModule?.deactivateConfig?()
+ catch e
+ console.error "Error deactivating package '#{@name}'", e.stack
+ @mainActivated = false
+ @mainInitialized = false
@emitter.emit 'did-deactivate'
deactivateResources: ->
@@ -580,7 +611,7 @@ class Package
@mainModulePath = fs.resolveExtension(mainModulePath, ["", CompileCache.supportedExtensions...])
activationShouldBeDeferred: ->
- @hasActivationCommands() or @hasActivationHooks()
+ @hasActivationCommands() or @hasActivationHooks() or @hasDeferredURIHandler()
hasActivationHooks: ->
@getActivationHooks()?.length > 0
@@ -590,6 +621,9 @@ class Package
return true if commands.length > 0
false
+ hasDeferredURIHandler: ->
+ @getURIHandler() and @getURIHandler().deferActivation isnt false
+
subscribeToDeferredActivation: ->
@subscribeToActivationCommands()
@subscribeToActivationHooks()
@@ -658,6 +692,9 @@ class Package
@activationHooks = _.uniq(@activationHooks)
+ getURIHandler: ->
+ @metadata?.uriHandler
+
# Does the given module path contain native code?
isNativeModule: (modulePath) ->
try
diff --git a/src/pane-container.js b/src/pane-container.js
index d907aea65..25e57acc8 100644
--- a/src/pane-container.js
+++ b/src/pane-container.js
@@ -267,7 +267,7 @@ class PaneContainer {
}
willDestroyPaneItem (event) {
- this.emitter.emit('will-destroy-pane-item', event)
+ return this.emitter.emitAsync('will-destroy-pane-item', event)
}
didDestroyPaneItem (event) {
diff --git a/src/pane-element.coffee b/src/pane-element.coffee
index c4866816a..d68b3b834 100644
--- a/src/pane-element.coffee
+++ b/src/pane-element.coffee
@@ -79,6 +79,7 @@ class PaneElement extends HTMLElement
activeItemChanged: (item) ->
delete @dataset.activeItemName
delete @dataset.activeItemPath
+ @changePathDisposable?.dispose()
return unless item?
@@ -89,6 +90,12 @@ class PaneElement extends HTMLElement
@dataset.activeItemName = path.basename(itemPath)
@dataset.activeItemPath = itemPath
+ if item.onDidChangePath?
+ @changePathDisposable = item.onDidChangePath =>
+ itemPath = item.getPath()
+ @dataset.activeItemName = path.basename(itemPath)
+ @dataset.activeItemPath = itemPath
+
unless @itemViews.contains(itemView)
@itemViews.appendChild(itemView)
@@ -119,6 +126,7 @@ class PaneElement extends HTMLElement
paneDestroyed: ->
@subscriptions.dispose()
+ @changePathDisposable?.dispose()
flexScaleChanged: (flexScale) ->
@style.flexGrow = flexScale
diff --git a/src/pane.coffee b/src/pane.coffee
deleted file mode 100644
index 6ac3ef359..000000000
--- a/src/pane.coffee
+++ /dev/null
@@ -1,996 +0,0 @@
-Grim = require 'grim'
-{find, compact, extend, last} = require 'underscore-plus'
-{CompositeDisposable, Emitter} = require 'event-kit'
-PaneAxis = require './pane-axis'
-TextEditor = require './text-editor'
-PaneElement = require './pane-element'
-
-nextInstanceId = 1
-
-class SaveCancelledError extends Error
- constructor: -> super
-
-# Extended: A container for presenting content in the center of the workspace.
-# Panes can contain multiple items, one of which is *active* at a given time.
-# The view corresponding to the active item is displayed in the interface. In
-# the default configuration, tabs are also displayed for each item.
-#
-# Each pane may also contain one *pending* item. When a pending item is added
-# to a pane, it will replace the currently pending item, if any, instead of
-# simply being added. In the default configuration, the text in the tab for
-# pending items is shown in italics.
-module.exports =
-class Pane
- inspect: -> "Pane #{@id}"
-
- @deserialize: (state, {deserializers, applicationDelegate, config, notifications, views}) ->
- {items, activeItemIndex, activeItemURI, activeItemUri} = state
- activeItemURI ?= activeItemUri
- items = items.map (itemState) -> deserializers.deserialize(itemState)
- state.activeItem = items[activeItemIndex]
- state.items = compact(items)
- if activeItemURI?
- state.activeItem ?= find state.items, (item) ->
- if typeof item.getURI is 'function'
- itemURI = item.getURI()
- itemURI is activeItemURI
- new Pane(extend(state, {
- deserializerManager: deserializers,
- notificationManager: notifications,
- viewRegistry: views,
- config, applicationDelegate
- }))
-
- constructor: (params) ->
- {
- @id, @activeItem, @focused, @applicationDelegate, @notificationManager, @config,
- @deserializerManager, @viewRegistry
- } = params
-
- if @id?
- nextInstanceId = Math.max(nextInstanceId, @id + 1)
- else
- @id = nextInstanceId++
- @emitter = new Emitter
- @alive = true
- @subscriptionsPerItem = new WeakMap
- @items = []
- @itemStack = []
- @container = null
- @activeItem ?= undefined
- @focused ?= false
-
- @addItems(compact(params?.items ? []))
- @setActiveItem(@items[0]) unless @getActiveItem()?
- @addItemsToStack(params?.itemStackIndices ? [])
- @setFlexScale(params?.flexScale ? 1)
-
- getElement: ->
- @element ?= new PaneElement().initialize(this, {views: @viewRegistry, @applicationDelegate})
-
- serialize: ->
- itemsToBeSerialized = compact(@items.map((item) -> item if typeof item.serialize is 'function'))
- itemStackIndices = (itemsToBeSerialized.indexOf(item) for item in @itemStack when typeof item.serialize is 'function')
- activeItemIndex = itemsToBeSerialized.indexOf(@activeItem)
-
- {
- deserializer: 'Pane',
- id: @id,
- items: itemsToBeSerialized.map((item) -> item.serialize())
- itemStackIndices: itemStackIndices
- activeItemIndex: activeItemIndex
- focused: @focused
- flexScale: @flexScale
- }
-
- getParent: -> @parent
-
- setParent: (@parent) -> @parent
-
- getContainer: -> @container
-
- setContainer: (container) ->
- if container and container isnt @container
- @container = container
- container.didAddPane({pane: this})
-
- # Private: Determine whether the given item is allowed to exist in this pane.
- #
- # * `item` the Item
- #
- # Returns a {Boolean}.
- isItemAllowed: (item) ->
- if (typeof item.getAllowedLocations isnt 'function')
- true
- else
- item.getAllowedLocations().includes(@getContainer().getLocation())
-
- setFlexScale: (@flexScale) ->
- @emitter.emit 'did-change-flex-scale', @flexScale
- @flexScale
-
- getFlexScale: -> @flexScale
-
- increaseSize: -> @setFlexScale(@getFlexScale() * 1.1)
-
- decreaseSize: -> @setFlexScale(@getFlexScale() / 1.1)
-
- ###
- Section: Event Subscription
- ###
-
- # Public: Invoke the given callback when the pane resizes
- #
- # The callback will be invoked when pane's flexScale property changes.
- # Use {::getFlexScale} to get the current value.
- #
- # * `callback` {Function} to be called when the pane is resized
- # * `flexScale` {Number} representing the panes `flex-grow`; ability for a
- # flex item to grow if necessary.
- #
- # Returns a {Disposable} on which '.dispose()' can be called to unsubscribe.
- onDidChangeFlexScale: (callback) ->
- @emitter.on 'did-change-flex-scale', callback
-
- # Public: Invoke the given callback with the current and future values of
- # {::getFlexScale}.
- #
- # * `callback` {Function} to be called with the current and future values of
- # the {::getFlexScale} property.
- # * `flexScale` {Number} representing the panes `flex-grow`; ability for a
- # flex item to grow if necessary.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- observeFlexScale: (callback) ->
- callback(@flexScale)
- @onDidChangeFlexScale(callback)
-
- # Public: Invoke the given callback when the pane is activated.
- #
- # The given callback will be invoked whenever {::activate} is called on the
- # pane, even if it is already active at the time.
- #
- # * `callback` {Function} to be called when the pane is activated.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidActivate: (callback) ->
- @emitter.on 'did-activate', callback
-
- # Public: Invoke the given callback before the pane is destroyed.
- #
- # * `callback` {Function} to be called before the pane is destroyed.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onWillDestroy: (callback) ->
- @emitter.on 'will-destroy', callback
-
- # Public: Invoke the given callback when the pane is destroyed.
- #
- # * `callback` {Function} to be called when the pane is destroyed.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidDestroy: (callback) ->
- @emitter.once 'did-destroy', callback
-
- # Public: Invoke the given callback when the value of the {::isActive}
- # property changes.
- #
- # * `callback` {Function} to be called when the value of the {::isActive}
- # property changes.
- # * `active` {Boolean} indicating whether the pane is active.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidChangeActive: (callback) ->
- @container.onDidChangeActivePane (activePane) =>
- callback(this is activePane)
-
- # Public: Invoke the given callback with the current and future values of the
- # {::isActive} property.
- #
- # * `callback` {Function} to be called with the current and future values of
- # the {::isActive} property.
- # * `active` {Boolean} indicating whether the pane is active.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- observeActive: (callback) ->
- callback(@isActive())
- @onDidChangeActive(callback)
-
- # Public: Invoke the given callback when an item is added to the pane.
- #
- # * `callback` {Function} to be called with when items are added.
- # * `event` {Object} with the following keys:
- # * `item` The added pane item.
- # * `index` {Number} indicating where the item is located.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidAddItem: (callback) ->
- @emitter.on 'did-add-item', callback
-
- # Public: Invoke the given callback when an item is removed from the pane.
- #
- # * `callback` {Function} to be called with when items are removed.
- # * `event` {Object} with the following keys:
- # * `item` The removed pane item.
- # * `index` {Number} indicating where the item was located.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidRemoveItem: (callback) ->
- @emitter.on 'did-remove-item', callback
-
- # Public: Invoke the given callback before an item is removed from the pane.
- #
- # * `callback` {Function} to be called with when items are removed.
- # * `event` {Object} with the following keys:
- # * `item` The pane item to be removed.
- # * `index` {Number} indicating where the item is located.
- onWillRemoveItem: (callback) ->
- @emitter.on 'will-remove-item', callback
-
- # Public: Invoke the given callback when an item is moved within the pane.
- #
- # * `callback` {Function} to be called with when items are moved.
- # * `event` {Object} with the following keys:
- # * `item` The removed pane item.
- # * `oldIndex` {Number} indicating where the item was located.
- # * `newIndex` {Number} indicating where the item is now located.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidMoveItem: (callback) ->
- @emitter.on 'did-move-item', callback
-
- # Public: Invoke the given callback with all current and future items.
- #
- # * `callback` {Function} to be called with current and future items.
- # * `item` An item that is present in {::getItems} at the time of
- # subscription or that is added at some later time.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- observeItems: (callback) ->
- callback(item) for item in @getItems()
- @onDidAddItem ({item}) -> callback(item)
-
- # Public: Invoke the given callback when the value of {::getActiveItem}
- # changes.
- #
- # * `callback` {Function} to be called with when the active item changes.
- # * `activeItem` The current active item.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidChangeActiveItem: (callback) ->
- @emitter.on 'did-change-active-item', callback
-
- # Public: Invoke the given callback when {::activateNextRecentlyUsedItem}
- # has been called, either initiating or continuing a forward MRU traversal of
- # pane items.
- #
- # * `callback` {Function} to be called with when the active item changes.
- # * `nextRecentlyUsedItem` The next MRU item, now being set active
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onChooseNextMRUItem: (callback) ->
- @emitter.on 'choose-next-mru-item', callback
-
- # Public: Invoke the given callback when {::activatePreviousRecentlyUsedItem}
- # has been called, either initiating or continuing a reverse MRU traversal of
- # pane items.
- #
- # * `callback` {Function} to be called with when the active item changes.
- # * `previousRecentlyUsedItem` The previous MRU item, now being set active
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onChooseLastMRUItem: (callback) ->
- @emitter.on 'choose-last-mru-item', callback
-
- # Public: Invoke the given callback when {::moveActiveItemToTopOfStack}
- # has been called, terminating an MRU traversal of pane items and moving the
- # current active item to the top of the stack. Typically bound to a modifier
- # (e.g. CTRL) key up event.
- #
- # * `callback` {Function} to be called with when the MRU traversal is done.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDoneChoosingMRUItem: (callback) ->
- @emitter.on 'done-choosing-mru-item', callback
-
- # Public: Invoke the given callback with the current and future values of
- # {::getActiveItem}.
- #
- # * `callback` {Function} to be called with the current and future active
- # items.
- # * `activeItem` The current active item.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- observeActiveItem: (callback) ->
- callback(@getActiveItem())
- @onDidChangeActiveItem(callback)
-
- # Public: Invoke the given callback before items are destroyed.
- #
- # * `callback` {Function} to be called before items are destroyed.
- # * `event` {Object} with the following keys:
- # * `item` The item that will be destroyed.
- # * `index` The location of the item.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to
- # unsubscribe.
- onWillDestroyItem: (callback) ->
- @emitter.on 'will-destroy-item', callback
-
- # Called by the view layer to indicate that the pane has gained focus.
- focus: ->
- @focused = true
- @activate()
-
- # Called by the view layer to indicate that the pane has lost focus.
- blur: ->
- @focused = false
- true # if this is called from an event handler, don't cancel it
-
- isFocused: -> @focused
-
- getPanes: -> [this]
-
- unsubscribeFromItem: (item) ->
- @subscriptionsPerItem.get(item)?.dispose()
- @subscriptionsPerItem.delete(item)
-
- ###
- Section: Items
- ###
-
- # Public: Get the items in this pane.
- #
- # Returns an {Array} of items.
- getItems: ->
- @items.slice()
-
- # Public: Get the active pane item in this pane.
- #
- # Returns a pane item.
- getActiveItem: -> @activeItem
-
- setActiveItem: (activeItem, options) ->
- {modifyStack} = options if options?
- unless activeItem is @activeItem
- @addItemToStack(activeItem) unless modifyStack is false
- @activeItem = activeItem
- @emitter.emit 'did-change-active-item', @activeItem
- @container?.didChangeActiveItemOnPane(this, @activeItem)
- @activeItem
-
- # Build the itemStack after deserializing
- addItemsToStack: (itemStackIndices) ->
- if @items.length > 0
- if itemStackIndices.length is 0 or itemStackIndices.length isnt @items.length or itemStackIndices.indexOf(-1) >= 0
- itemStackIndices = (i for i in [0..@items.length-1])
- for itemIndex in itemStackIndices
- @addItemToStack(@items[itemIndex])
- return
-
- # Add item (or move item) to the end of the itemStack
- addItemToStack: (newItem) ->
- return unless newItem?
- index = @itemStack.indexOf(newItem)
- @itemStack.splice(index, 1) unless index is -1
- @itemStack.push(newItem)
-
- # Return an {TextEditor} if the pane item is an {TextEditor}, or null otherwise.
- getActiveEditor: ->
- @activeItem if @activeItem instanceof TextEditor
-
- # Public: Return the item at the given index.
- #
- # * `index` {Number}
- #
- # Returns an item or `null` if no item exists at the given index.
- itemAtIndex: (index) ->
- @items[index]
-
- # Makes the next item in the itemStack active.
- activateNextRecentlyUsedItem: ->
- if @items.length > 1
- @itemStackIndex = @itemStack.length - 1 unless @itemStackIndex?
- @itemStackIndex = @itemStack.length if @itemStackIndex is 0
- @itemStackIndex = @itemStackIndex - 1
- nextRecentlyUsedItem = @itemStack[@itemStackIndex]
- @emitter.emit 'choose-next-mru-item', nextRecentlyUsedItem
- @setActiveItem(nextRecentlyUsedItem, modifyStack: false)
-
- # Makes the previous item in the itemStack active.
- activatePreviousRecentlyUsedItem: ->
- if @items.length > 1
- if @itemStackIndex + 1 is @itemStack.length or not @itemStackIndex?
- @itemStackIndex = -1
- @itemStackIndex = @itemStackIndex + 1
- previousRecentlyUsedItem = @itemStack[@itemStackIndex]
- @emitter.emit 'choose-last-mru-item', previousRecentlyUsedItem
- @setActiveItem(previousRecentlyUsedItem, modifyStack: false)
-
- # Moves the active item to the end of the itemStack once the ctrl key is lifted
- moveActiveItemToTopOfStack: ->
- delete @itemStackIndex
- @addItemToStack(@activeItem)
- @emitter.emit 'done-choosing-mru-item'
-
- # Public: Makes the next item active.
- activateNextItem: ->
- index = @getActiveItemIndex()
- if index < @items.length - 1
- @activateItemAtIndex(index + 1)
- else
- @activateItemAtIndex(0)
-
- # Public: Makes the previous item active.
- activatePreviousItem: ->
- index = @getActiveItemIndex()
- if index > 0
- @activateItemAtIndex(index - 1)
- else
- @activateItemAtIndex(@items.length - 1)
-
- activateLastItem: ->
- @activateItemAtIndex(@items.length - 1)
-
- # Public: Move the active tab to the right.
- moveItemRight: ->
- index = @getActiveItemIndex()
- rightItemIndex = index + 1
- @moveItem(@getActiveItem(), rightItemIndex) unless rightItemIndex > @items.length - 1
-
- # Public: Move the active tab to the left
- moveItemLeft: ->
- index = @getActiveItemIndex()
- leftItemIndex = index - 1
- @moveItem(@getActiveItem(), leftItemIndex) unless leftItemIndex < 0
-
- # Public: Get the index of the active item.
- #
- # Returns a {Number}.
- getActiveItemIndex: ->
- @items.indexOf(@activeItem)
-
- # Public: Activate the item at the given index.
- #
- # * `index` {Number}
- activateItemAtIndex: (index) ->
- item = @itemAtIndex(index) or @getActiveItem()
- @setActiveItem(item)
-
- # Public: Make the given item *active*, causing it to be displayed by
- # the pane's view.
- #
- # * `item` The item to activate
- # * `options` (optional) {Object}
- # * `pending` (optional) {Boolean} indicating that the item should be added
- # in a pending state if it does not yet exist in the pane. Existing pending
- # items in a pane are replaced with new pending items when they are opened.
- activateItem: (item, options={}) ->
- if item?
- if @getPendingItem() is @activeItem
- index = @getActiveItemIndex()
- else
- index = @getActiveItemIndex() + 1
- @addItem(item, extend({}, options, {index: index}))
- @setActiveItem(item)
-
- # Public: Add the given item to the pane.
- #
- # * `item` The item to add. It can be a model with an associated view or a
- # view.
- # * `options` (optional) {Object}
- # * `index` (optional) {Number} indicating the index at which to add the item.
- # If omitted, the item is added after the current active item.
- # * `pending` (optional) {Boolean} indicating that the item should be
- # added in a pending state. Existing pending items in a pane are replaced with
- # new pending items when they are opened.
- #
- # Returns the added item.
- addItem: (item, options={}) ->
- # Backward compat with old API:
- # addItem(item, index=@getActiveItemIndex() + 1)
- if typeof options is "number"
- Grim.deprecate("Pane::addItem(item, #{options}) is deprecated in favor of Pane::addItem(item, {index: #{options}})")
- options = index: options
-
- index = options.index ? @getActiveItemIndex() + 1
- moved = options.moved ? false
- pending = options.pending ? false
-
- throw new Error("Pane items must be objects. Attempted to add item #{item}.") unless item? and typeof item is 'object'
- throw new Error("Adding a pane item with URI '#{item.getURI?()}' that has already been destroyed") if item.isDestroyed?()
-
- return if item in @items
-
- if typeof item.onDidDestroy is 'function'
- itemSubscriptions = new CompositeDisposable
- itemSubscriptions.add item.onDidDestroy => @removeItem(item, false)
- if typeof item.onDidTerminatePendingState is "function"
- itemSubscriptions.add item.onDidTerminatePendingState =>
- @clearPendingItem() if @getPendingItem() is item
- @subscriptionsPerItem.set item, itemSubscriptions
-
- @items.splice(index, 0, item)
- lastPendingItem = @getPendingItem()
- replacingPendingItem = lastPendingItem? and not moved
- @pendingItem = null if replacingPendingItem
- @setPendingItem(item) if pending
-
- @emitter.emit 'did-add-item', {item, index, moved}
- @container?.didAddPaneItem(item, this, index) unless moved
-
- @destroyItem(lastPendingItem) if replacingPendingItem
- @setActiveItem(item) unless @getActiveItem()?
- item
-
- setPendingItem: (item) =>
- if @pendingItem isnt item
- mostRecentPendingItem = @pendingItem
- @pendingItem = item
- if mostRecentPendingItem?
- @emitter.emit 'item-did-terminate-pending-state', mostRecentPendingItem
-
- getPendingItem: =>
- @pendingItem or null
-
- clearPendingItem: =>
- @setPendingItem(null)
-
- onItemDidTerminatePendingState: (callback) =>
- @emitter.on 'item-did-terminate-pending-state', callback
-
- # Public: Add the given items to the pane.
- #
- # * `items` An {Array} of items to add. Items can be views or models with
- # associated views. Any objects that are already present in the pane's
- # current items will not be added again.
- # * `index` (optional) {Number} index at which to add the items. If omitted,
- # the item is # added after the current active item.
- #
- # Returns an {Array} of added items.
- addItems: (items, index=@getActiveItemIndex() + 1) ->
- items = items.filter (item) => not (item in @items)
- @addItem(item, {index: index + i}) for item, i in items
- items
-
- removeItem: (item, moved) ->
- index = @items.indexOf(item)
- return if index is -1
- @pendingItem = null if @getPendingItem() is item
- @removeItemFromStack(item)
- @emitter.emit 'will-remove-item', {item, index, destroyed: not moved, moved}
- @unsubscribeFromItem(item)
-
- if item is @activeItem
- if @items.length is 1
- @setActiveItem(undefined)
- else if index is 0
- @activateNextItem()
- else
- @activatePreviousItem()
- @items.splice(index, 1)
- @emitter.emit 'did-remove-item', {item, index, destroyed: not moved, moved}
- @container?.didDestroyPaneItem({item, index, pane: this}) unless moved
- @destroy() if @items.length is 0 and @config.get('core.destroyEmptyPanes')
-
- # Remove the given item from the itemStack.
- #
- # * `item` The item to remove.
- # * `index` {Number} indicating the index to which to remove the item from the itemStack.
- removeItemFromStack: (item) ->
- index = @itemStack.indexOf(item)
- @itemStack.splice(index, 1) unless index is -1
-
- # Public: Move the given item to the given index.
- #
- # * `item` The item to move.
- # * `index` {Number} indicating the index to which to move the item.
- moveItem: (item, newIndex) ->
- oldIndex = @items.indexOf(item)
- @items.splice(oldIndex, 1)
- @items.splice(newIndex, 0, item)
- @emitter.emit 'did-move-item', {item, oldIndex, newIndex}
-
- # Public: Move the given item to the given index on another pane.
- #
- # * `item` The item to move.
- # * `pane` {Pane} to which to move the item.
- # * `index` {Number} indicating the index to which to move the item in the
- # given pane.
- moveItemToPane: (item, pane, index) ->
- @removeItem(item, true)
- pane.addItem(item, {index: index, moved: true})
-
- # Public: Destroy the active item and activate the next item.
- destroyActiveItem: ->
- @destroyItem(@activeItem)
- false
-
- # Public: Destroy the given item.
- #
- # If the item is active, the next item will be activated. If the item is the
- # last item, the pane will be destroyed if the `core.destroyEmptyPanes` config
- # setting is `true`.
- #
- # * `item` Item to destroy
- # * `force` (optional) {Boolean} Destroy the item without prompting to save
- # it, even if the item's `isPermanentDockItem` method returns true.
- #
- # Returns a {Promise} that resolves with a {Boolean} indicating whether or not
- # the item was destroyed.
- destroyItem: (item, force) ->
- index = @items.indexOf(item)
- if index isnt -1
- if not force and @getContainer()?.getLocation() isnt 'center' and item.isPermanentDockItem?()
- return Promise.resolve(false)
-
- @emitter.emit 'will-destroy-item', {item, index}
- @container?.willDestroyPaneItem({item, index, pane: this})
- if force or not item?.shouldPromptToSave?()
- @removeItem(item, false)
- item.destroy?()
- Promise.resolve(true)
- else
- @promptToSaveItem(item).then (result) =>
- if result
- @removeItem(item, false)
- item.destroy?()
- result
-
- # Public: Destroy all items.
- destroyItems: ->
- Promise.all(
- @getItems().map((item) => @destroyItem(item))
- )
-
- # Public: Destroy all items except for the active item.
- destroyInactiveItems: ->
- Promise.all(
- @getItems()
- .filter((item) => item isnt @activeItem)
- .map((item) => @destroyItem(item))
- )
-
- promptToSaveItem: (item, options={}) ->
- return Promise.resolve(true) unless item.shouldPromptToSave?(options)
-
- if typeof item.getURI is 'function'
- uri = item.getURI()
- else if typeof item.getUri is 'function'
- uri = item.getUri()
- else
- return Promise.resolve(true)
-
- saveDialog = (saveButtonText, saveFn, message) =>
- chosen = @applicationDelegate.confirm
- message: message
- detailedMessage: "Your changes will be lost if you close this item without saving."
- buttons: [saveButtonText, "Cancel", "&Don't Save"]
- switch chosen
- when 0
- new Promise (resolve) ->
- saveFn item, (error) ->
- if error instanceof SaveCancelledError
- resolve(false)
- else
- saveError(error).then(resolve)
- when 1
- Promise.resolve(false)
- when 2
- Promise.resolve(true)
-
- saveError = (error) =>
- if error
- saveDialog("Save as", @saveItemAs, "'#{item.getTitle?() ? uri}' could not be saved.\nError: #{@getMessageForErrorCode(error.code)}")
- else
- Promise.resolve(true)
-
- saveDialog("Save", @saveItem, "'#{item.getTitle?() ? uri}' has changes, do you want to save them?")
-
- # Public: Save the active item.
- saveActiveItem: (nextAction) ->
- @saveItem(@getActiveItem(), nextAction)
-
- # Public: Prompt the user for a location and save the active item with the
- # path they select.
- #
- # * `nextAction` (optional) {Function} which will be called after the item is
- # successfully saved.
- #
- # Returns a {Promise} that resolves when the save is complete
- saveActiveItemAs: (nextAction) ->
- @saveItemAs(@getActiveItem(), nextAction)
-
- # Public: Save the given item.
- #
- # * `item` The item to save.
- # * `nextAction` (optional) {Function} which will be called with no argument
- # after the item is successfully saved, or with the error if it failed.
- # The return value will be that of `nextAction` or `undefined` if it was not
- # provided
- #
- # Returns a {Promise} that resolves when the save is complete
- saveItem: (item, nextAction) =>
- if typeof item?.getURI is 'function'
- itemURI = item.getURI()
- else if typeof item?.getUri is 'function'
- itemURI = item.getUri()
-
- if itemURI?
- if item.save?
- promisify -> item.save()
- .then -> nextAction?()
- .catch (error) =>
- if nextAction
- nextAction(error)
- else
- @handleSaveError(error, item)
- else
- nextAction?()
- else
- @saveItemAs(item, nextAction)
-
- # Public: Prompt the user for a location and save the active item with the
- # path they select.
- #
- # * `item` The item to save.
- # * `nextAction` (optional) {Function} which will be called with no argument
- # after the item is successfully saved, or with the error if it failed.
- # The return value will be that of `nextAction` or `undefined` if it was not
- # provided
- saveItemAs: (item, nextAction) =>
- return unless item?.saveAs?
-
- saveOptions = item.getSaveDialogOptions?() ? {}
- itemPath = item.getPath()
- saveOptions.defaultPath ?= itemPath if itemPath
- newItemPath = @applicationDelegate.showSaveDialog(saveOptions)
- if newItemPath
- promisify -> item.saveAs(newItemPath)
- .then -> nextAction?()
- .catch (error) =>
- if nextAction?
- nextAction(error)
- else
- @handleSaveError(error, item)
- else if nextAction?
- nextAction(new SaveCancelledError('Save Cancelled'))
-
- # Public: Save all items.
- saveItems: ->
- for item in @getItems()
- @saveItem(item) if item.isModified?()
- return
-
- # Public: Return the first item that matches the given URI or undefined if
- # none exists.
- #
- # * `uri` {String} containing a URI.
- itemForURI: (uri) ->
- find @items, (item) ->
- if typeof item.getURI is 'function'
- itemUri = item.getURI()
- else if typeof item.getUri is 'function'
- itemUri = item.getUri()
-
- itemUri is uri
-
- # Public: Activate the first item that matches the given URI.
- #
- # * `uri` {String} containing a URI.
- #
- # Returns a {Boolean} indicating whether an item matching the URI was found.
- activateItemForURI: (uri) ->
- if item = @itemForURI(uri)
- @activateItem(item)
- true
- else
- false
-
- copyActiveItem: ->
- @activeItem?.copy?()
-
- ###
- Section: Lifecycle
- ###
-
- # Public: Determine whether the pane is active.
- #
- # Returns a {Boolean}.
- isActive: ->
- @container?.getActivePane() is this
-
- # Public: Makes this pane the *active* pane, causing it to gain focus.
- activate: ->
- throw new Error("Pane has been destroyed") if @isDestroyed()
- @container?.didActivatePane(this)
- @emitter.emit 'did-activate'
-
- # Public: Close the pane and destroy all its items.
- #
- # If this is the last pane, all the items will be destroyed but the pane
- # itself will not be destroyed.
- destroy: ->
- if @container?.isAlive() and @container.getPanes().length is 1
- @destroyItems()
- else
- @emitter.emit 'will-destroy'
- @alive = false
- @container?.willDestroyPane(pane: this)
- @container.activateNextPane() if @isActive()
- @emitter.emit 'did-destroy'
- @emitter.dispose()
- item.destroy?() for item in @items.slice()
- @container?.didDestroyPane(pane: this)
-
- isAlive: -> @alive
-
- # Public: Determine whether this pane has been destroyed.
- #
- # Returns a {Boolean}.
- isDestroyed: -> not @isAlive()
-
- ###
- Section: Splitting
- ###
-
- # Public: Create a new pane to the left of this pane.
- #
- # * `params` (optional) {Object} with the following keys:
- # * `items` (optional) {Array} of items to add to the new pane.
- # * `copyActiveItem` (optional) {Boolean} true will copy the active item into the new split pane
- #
- # Returns the new {Pane}.
- splitLeft: (params) ->
- @split('horizontal', 'before', params)
-
- # Public: Create a new pane to the right of this pane.
- #
- # * `params` (optional) {Object} with the following keys:
- # * `items` (optional) {Array} of items to add to the new pane.
- # * `copyActiveItem` (optional) {Boolean} true will copy the active item into the new split pane
- #
- # Returns the new {Pane}.
- splitRight: (params) ->
- @split('horizontal', 'after', params)
-
- # Public: Creates a new pane above the receiver.
- #
- # * `params` (optional) {Object} with the following keys:
- # * `items` (optional) {Array} of items to add to the new pane.
- # * `copyActiveItem` (optional) {Boolean} true will copy the active item into the new split pane
- #
- # Returns the new {Pane}.
- splitUp: (params) ->
- @split('vertical', 'before', params)
-
- # Public: Creates a new pane below the receiver.
- #
- # * `params` (optional) {Object} with the following keys:
- # * `items` (optional) {Array} of items to add to the new pane.
- # * `copyActiveItem` (optional) {Boolean} true will copy the active item into the new split pane
- #
- # Returns the new {Pane}.
- splitDown: (params) ->
- @split('vertical', 'after', params)
-
- split: (orientation, side, params) ->
- if params?.copyActiveItem
- params.items ?= []
- params.items.push(@copyActiveItem())
-
- if @parent.orientation isnt orientation
- @parent.replaceChild(this, new PaneAxis({@container, orientation, children: [this], @flexScale}, @viewRegistry))
- @setFlexScale(1)
-
- newPane = new Pane(extend({@applicationDelegate, @notificationManager, @deserializerManager, @config, @viewRegistry}, params))
- switch side
- when 'before' then @parent.insertChildBefore(this, newPane)
- when 'after' then @parent.insertChildAfter(this, newPane)
-
- @moveItemToPane(@activeItem, newPane) if params?.moveActiveItem and @activeItem
-
- newPane.activate()
- newPane
-
- # If the parent is a horizontal axis, returns its first child if it is a pane;
- # otherwise returns this pane.
- findLeftmostSibling: ->
- if @parent.orientation is 'horizontal'
- [leftmostSibling] = @parent.children
- if leftmostSibling instanceof PaneAxis
- this
- else
- leftmostSibling
- else
- this
-
- findRightmostSibling: ->
- if @parent.orientation is 'horizontal'
- rightmostSibling = last(@parent.children)
- if rightmostSibling instanceof PaneAxis
- this
- else
- rightmostSibling
- else
- this
-
- # If the parent is a horizontal axis, returns its last child if it is a pane;
- # otherwise returns a new pane created by splitting this pane rightward.
- findOrCreateRightmostSibling: ->
- rightmostSibling = @findRightmostSibling()
- if rightmostSibling is this then @splitRight() else rightmostSibling
-
- # If the parent is a vertical axis, returns its first child if it is a pane;
- # otherwise returns this pane.
- findTopmostSibling: ->
- if @parent.orientation is 'vertical'
- [topmostSibling] = @parent.children
- if topmostSibling instanceof PaneAxis
- this
- else
- topmostSibling
- else
- this
-
- findBottommostSibling: ->
- if @parent.orientation is 'vertical'
- bottommostSibling = last(@parent.children)
- if bottommostSibling instanceof PaneAxis
- this
- else
- bottommostSibling
- else
- this
-
- # If the parent is a vertical axis, returns its last child if it is a pane;
- # otherwise returns a new pane created by splitting this pane bottomward.
- findOrCreateBottommostSibling: ->
- bottommostSibling = @findBottommostSibling()
- if bottommostSibling is this then @splitDown() else bottommostSibling
-
- # Private: Close the pane unless the user cancels the action via a dialog.
- #
- # Returns a {Promise} that resolves once the pane is either closed, or the
- # closing has been cancelled.
- close: ->
- Promise.all(@getItems().map((item) => @promptToSaveItem(item))).then (results) =>
- @destroy() unless results.includes(false)
-
- handleSaveError: (error, item) ->
- itemPath = error.path ? item?.getPath?()
- addWarningWithPath = (message, options) =>
- message = "#{message} '#{itemPath}'" if itemPath
- @notificationManager.addWarning(message, options)
-
- customMessage = @getMessageForErrorCode(error.code)
- if customMessage?
- addWarningWithPath("Unable to save file: #{customMessage}")
- else if error.code is 'EISDIR' or error.message?.endsWith?('is a directory')
- @notificationManager.addWarning("Unable to save file: #{error.message}")
- else if error.code in ['EPERM', 'EBUSY', 'UNKNOWN', 'EEXIST', 'ELOOP', 'EAGAIN']
- addWarningWithPath('Unable to save file', detail: error.message)
- else if errorMatch = /ENOTDIR, not a directory '([^']+)'/.exec(error.message)
- fileName = errorMatch[1]
- @notificationManager.addWarning("Unable to save file: A directory in the path '#{fileName}' could not be written to")
- else
- throw error
-
- getMessageForErrorCode: (errorCode) ->
- switch errorCode
- when 'EACCES' then 'Permission denied'
- when 'ECONNRESET' then 'Connection reset'
- when 'EINTR' then 'Interrupted system call'
- when 'EIO' then 'I/O error writing file'
- when 'ENOSPC' then 'No space left on device'
- when 'ENOTSUP' then 'Operation not supported on socket'
- when 'ENXIO' then 'No such device or address'
- when 'EROFS' then 'Read-only file system'
- when 'ESPIPE' then 'Invalid seek'
- when 'ETIMEDOUT' then 'Connection timed out'
-
-promisify = (callback) ->
- try
- Promise.resolve(callback())
- catch error
- Promise.reject(error)
diff --git a/src/pane.js b/src/pane.js
new file mode 100644
index 000000000..0305b39dd
--- /dev/null
+++ b/src/pane.js
@@ -0,0 +1,1252 @@
+const Grim = require('grim')
+const {CompositeDisposable, Emitter} = require('event-kit')
+const PaneAxis = require('./pane-axis')
+const TextEditor = require('./text-editor')
+const PaneElement = require('./pane-element')
+
+let nextInstanceId = 1
+
+class SaveCancelledError extends Error {}
+
+// Extended: A container for presenting content in the center of the workspace.
+// Panes can contain multiple items, one of which is *active* at a given time.
+// The view corresponding to the active item is displayed in the interface. In
+// the default configuration, tabs are also displayed for each item.
+//
+// Each pane may also contain one *pending* item. When a pending item is added
+// to a pane, it will replace the currently pending item, if any, instead of
+// simply being added. In the default configuration, the text in the tab for
+// pending items is shown in italics.
+module.exports =
+class Pane {
+ inspect () {
+ return `Pane ${this.id}`
+ }
+
+ static deserialize (state, {deserializers, applicationDelegate, config, notifications, views}) {
+ const {activeItemIndex} = state
+ const activeItemURI = state.activeItemURI || state.activeItemUri
+
+ const items = []
+ for (const itemState of state.items) {
+ const item = deserializers.deserialize(itemState)
+ if (item) items.push(item)
+ }
+ state.items = items
+
+ state.activeItem = items[activeItemIndex]
+ if (!state.activeItem && activeItemURI) {
+ state.activeItem = state.items.find((item) =>
+ typeof item.getURI === 'function' && item.getURI() === activeItemURI
+ )
+ }
+
+ return new Pane(Object.assign(state, {
+ deserializerManager: deserializers,
+ notificationManager: notifications,
+ viewRegistry: views,
+ config,
+ applicationDelegate
+ }))
+ }
+
+ constructor (params = {}) {
+ this.setPendingItem = this.setPendingItem.bind(this)
+ this.getPendingItem = this.getPendingItem.bind(this)
+ this.clearPendingItem = this.clearPendingItem.bind(this)
+ this.onItemDidTerminatePendingState = this.onItemDidTerminatePendingState.bind(this)
+ this.saveItem = this.saveItem.bind(this)
+ this.saveItemAs = this.saveItemAs.bind(this)
+
+ this.id = params.id
+ if (this.id != null) {
+ nextInstanceId = Math.max(nextInstanceId, this.id + 1)
+ } else {
+ this.id = nextInstanceId++
+ }
+
+ this.activeItem = params.activeItem
+ this.focused = params.focused != null ? params.focused : false
+ this.applicationDelegate = params.applicationDelegate
+ this.notificationManager = params.notificationManager
+ this.config = params.config
+ this.deserializerManager = params.deserializerManager
+ this.viewRegistry = params.viewRegistry
+
+ this.emitter = new Emitter()
+ this.alive = true
+ this.subscriptionsPerItem = new WeakMap()
+ this.items = []
+ this.itemStack = []
+ this.container = null
+
+ this.addItems((params.items || []).filter(item => item))
+ if (!this.getActiveItem()) this.setActiveItem(this.items[0])
+ this.addItemsToStack(params.itemStackIndices || [])
+ this.setFlexScale(params.flexScale || 1)
+ }
+
+ getElement () {
+ if (!this.element) {
+ this.element = new PaneElement().initialize(
+ this,
+ {views: this.viewRegistry, applicationDelegate: this.applicationDelegate}
+ )
+ }
+ return this.element
+ }
+
+ serialize () {
+ const itemsToBeSerialized = this.items.filter(item => item && typeof item.serialize === 'function')
+
+ const itemStackIndices = []
+ for (const item of this.itemStack) {
+ if (typeof item.serialize === 'function') {
+ itemStackIndices.push(itemsToBeSerialized.indexOf(item))
+ }
+ }
+
+ const activeItemIndex = itemsToBeSerialized.indexOf(this.activeItem)
+
+ return {
+ deserializer: 'Pane',
+ id: this.id,
+ items: itemsToBeSerialized.map(item => item.serialize()),
+ itemStackIndices,
+ activeItemIndex,
+ focused: this.focused,
+ flexScale: this.flexScale
+ }
+ }
+
+ getParent () { return this.parent }
+
+ setParent (parent) {
+ this.parent = parent
+ }
+
+ getContainer () { return this.container }
+
+ setContainer (container) {
+ if (container && container !== this.container) {
+ this.container = container
+ container.didAddPane({pane: this})
+ }
+ }
+
+ // Private: Determine whether the given item is allowed to exist in this pane.
+ //
+ // * `item` the Item
+ //
+ // Returns a {Boolean}.
+ isItemAllowed (item) {
+ if (typeof item.getAllowedLocations !== 'function') {
+ return true
+ } else {
+ return item.getAllowedLocations().includes(this.getContainer().getLocation())
+ }
+ }
+
+ setFlexScale (flexScale) {
+ this.flexScale = flexScale
+ this.emitter.emit('did-change-flex-scale', this.flexScale)
+ return this.flexScale
+ }
+
+ getFlexScale () { return this.flexScale }
+
+ increaseSize () { this.setFlexScale(this.getFlexScale() * 1.1) }
+
+ decreaseSize () { this.setFlexScale(this.getFlexScale() / 1.1) }
+
+ /*
+ Section: Event Subscription
+ */
+
+ // Public: Invoke the given callback when the pane resizes
+ //
+ // The callback will be invoked when pane's flexScale property changes.
+ // Use {::getFlexScale} to get the current value.
+ //
+ // * `callback` {Function} to be called when the pane is resized
+ // * `flexScale` {Number} representing the panes `flex-grow`; ability for a
+ // flex item to grow if necessary.
+ //
+ // Returns a {Disposable} on which '.dispose()' can be called to unsubscribe.
+ onDidChangeFlexScale (callback) {
+ return this.emitter.on('did-change-flex-scale', callback)
+ }
+
+ // Public: Invoke the given callback with the current and future values of
+ // {::getFlexScale}.
+ //
+ // * `callback` {Function} to be called with the current and future values of
+ // the {::getFlexScale} property.
+ // * `flexScale` {Number} representing the panes `flex-grow`; ability for a
+ // flex item to grow if necessary.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ observeFlexScale (callback) {
+ callback(this.flexScale)
+ return this.onDidChangeFlexScale(callback)
+ }
+
+ // Public: Invoke the given callback when the pane is activated.
+ //
+ // The given callback will be invoked whenever {::activate} is called on the
+ // pane, even if it is already active at the time.
+ //
+ // * `callback` {Function} to be called when the pane is activated.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidActivate (callback) {
+ return this.emitter.on('did-activate', callback)
+ }
+
+ // Public: Invoke the given callback before the pane is destroyed.
+ //
+ // * `callback` {Function} to be called before the pane is destroyed.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onWillDestroy (callback) {
+ return this.emitter.on('will-destroy', callback)
+ }
+
+ // Public: Invoke the given callback when the pane is destroyed.
+ //
+ // * `callback` {Function} to be called when the pane is destroyed.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidDestroy (callback) {
+ return this.emitter.once('did-destroy', callback)
+ }
+
+ // Public: Invoke the given callback when the value of the {::isActive}
+ // property changes.
+ //
+ // * `callback` {Function} to be called when the value of the {::isActive}
+ // property changes.
+ // * `active` {Boolean} indicating whether the pane is active.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidChangeActive (callback) {
+ return this.container.onDidChangeActivePane(activePane => {
+ const isActive = this === activePane
+ callback(isActive)
+ })
+ }
+
+ // Public: Invoke the given callback with the current and future values of the
+ // {::isActive} property.
+ //
+ // * `callback` {Function} to be called with the current and future values of
+ // the {::isActive} property.
+ // * `active` {Boolean} indicating whether the pane is active.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ observeActive (callback) {
+ callback(this.isActive())
+ return this.onDidChangeActive(callback)
+ }
+
+ // Public: Invoke the given callback when an item is added to the pane.
+ //
+ // * `callback` {Function} to be called with when items are added.
+ // * `event` {Object} with the following keys:
+ // * `item` The added pane item.
+ // * `index` {Number} indicating where the item is located.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidAddItem (callback) {
+ return this.emitter.on('did-add-item', callback)
+ }
+
+ // Public: Invoke the given callback when an item is removed from the pane.
+ //
+ // * `callback` {Function} to be called with when items are removed.
+ // * `event` {Object} with the following keys:
+ // * `item` The removed pane item.
+ // * `index` {Number} indicating where the item was located.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidRemoveItem (callback) {
+ return this.emitter.on('did-remove-item', callback)
+ }
+
+ // Public: Invoke the given callback before an item is removed from the pane.
+ //
+ // * `callback` {Function} to be called with when items are removed.
+ // * `event` {Object} with the following keys:
+ // * `item` The pane item to be removed.
+ // * `index` {Number} indicating where the item is located.
+ onWillRemoveItem (callback) {
+ return this.emitter.on('will-remove-item', callback)
+ }
+
+ // Public: Invoke the given callback when an item is moved within the pane.
+ //
+ // * `callback` {Function} to be called with when items are moved.
+ // * `event` {Object} with the following keys:
+ // * `item` The removed pane item.
+ // * `oldIndex` {Number} indicating where the item was located.
+ // * `newIndex` {Number} indicating where the item is now located.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidMoveItem (callback) {
+ return this.emitter.on('did-move-item', callback)
+ }
+
+ // Public: Invoke the given callback with all current and future items.
+ //
+ // * `callback` {Function} to be called with current and future items.
+ // * `item` An item that is present in {::getItems} at the time of
+ // subscription or that is added at some later time.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ observeItems (callback) {
+ for (let item of this.getItems()) {
+ callback(item)
+ }
+ return this.onDidAddItem(({item}) => callback(item))
+ }
+
+ // Public: Invoke the given callback when the value of {::getActiveItem}
+ // changes.
+ //
+ // * `callback` {Function} to be called with when the active item changes.
+ // * `activeItem` The current active item.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidChangeActiveItem (callback) {
+ return this.emitter.on('did-change-active-item', callback)
+ }
+
+ // Public: Invoke the given callback when {::activateNextRecentlyUsedItem}
+ // has been called, either initiating or continuing a forward MRU traversal of
+ // pane items.
+ //
+ // * `callback` {Function} to be called with when the active item changes.
+ // * `nextRecentlyUsedItem` The next MRU item, now being set active
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onChooseNextMRUItem (callback) {
+ return this.emitter.on('choose-next-mru-item', callback)
+ }
+
+ // Public: Invoke the given callback when {::activatePreviousRecentlyUsedItem}
+ // has been called, either initiating or continuing a reverse MRU traversal of
+ // pane items.
+ //
+ // * `callback` {Function} to be called with when the active item changes.
+ // * `previousRecentlyUsedItem` The previous MRU item, now being set active
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onChooseLastMRUItem (callback) {
+ return this.emitter.on('choose-last-mru-item', callback)
+ }
+
+ // Public: Invoke the given callback when {::moveActiveItemToTopOfStack}
+ // has been called, terminating an MRU traversal of pane items and moving the
+ // current active item to the top of the stack. Typically bound to a modifier
+ // (e.g. CTRL) key up event.
+ //
+ // * `callback` {Function} to be called with when the MRU traversal is done.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDoneChoosingMRUItem (callback) {
+ return this.emitter.on('done-choosing-mru-item', callback)
+ }
+
+ // Public: Invoke the given callback with the current and future values of
+ // {::getActiveItem}.
+ //
+ // * `callback` {Function} to be called with the current and future active
+ // items.
+ // * `activeItem` The current active item.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ observeActiveItem (callback) {
+ callback(this.getActiveItem())
+ return this.onDidChangeActiveItem(callback)
+ }
+
+ // Public: Invoke the given callback before items are destroyed.
+ //
+ // * `callback` {Function} to be called before items are destroyed.
+ // * `event` {Object} with the following keys:
+ // * `item` The item that will be destroyed.
+ // * `index` The location of the item.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to
+ // unsubscribe.
+ onWillDestroyItem (callback) {
+ return this.emitter.on('will-destroy-item', callback)
+ }
+
+ // Called by the view layer to indicate that the pane has gained focus.
+ focus () {
+ this.focused = true
+ return this.activate()
+ }
+
+ // Called by the view layer to indicate that the pane has lost focus.
+ blur () {
+ this.focused = false
+ return true // if this is called from an event handler, don't cancel it
+ }
+
+ isFocused () { return this.focused }
+
+ getPanes () { return [this] }
+
+ unsubscribeFromItem (item) {
+ const subscription = this.subscriptionsPerItem.get(item)
+ if (subscription) {
+ subscription.dispose()
+ this.subscriptionsPerItem.delete(item)
+ }
+ }
+
+ /*
+ Section: Items
+ */
+
+ // Public: Get the items in this pane.
+ //
+ // Returns an {Array} of items.
+ getItems () {
+ return this.items.slice()
+ }
+
+ // Public: Get the active pane item in this pane.
+ //
+ // Returns a pane item.
+ getActiveItem () { return this.activeItem }
+
+ setActiveItem (activeItem, options) {
+ const modifyStack = options && options.modifyStack
+ if (activeItem !== this.activeItem) {
+ if (modifyStack !== false) this.addItemToStack(activeItem)
+ this.activeItem = activeItem
+ this.emitter.emit('did-change-active-item', this.activeItem)
+ if (this.container) this.container.didChangeActiveItemOnPane(this, this.activeItem)
+ }
+ return this.activeItem
+ }
+
+ // Build the itemStack after deserializing
+ addItemsToStack (itemStackIndices) {
+ if (this.items.length > 0) {
+ if (itemStackIndices.length !== this.items.length || itemStackIndices.includes(-1)) {
+ itemStackIndices = this.items.map((item, i) => i)
+ }
+
+ for (let itemIndex of itemStackIndices) {
+ this.addItemToStack(this.items[itemIndex])
+ }
+ }
+ }
+
+ // Add item (or move item) to the end of the itemStack
+ addItemToStack (newItem) {
+ if (newItem == null) { return }
+ const index = this.itemStack.indexOf(newItem)
+ if (index !== -1) this.itemStack.splice(index, 1)
+ return this.itemStack.push(newItem)
+ }
+
+ // Return an {TextEditor} if the pane item is an {TextEditor}, or null otherwise.
+ getActiveEditor () {
+ if (this.activeItem instanceof TextEditor) return this.activeItem
+ }
+
+ // Public: Return the item at the given index.
+ //
+ // * `index` {Number}
+ //
+ // Returns an item or `null` if no item exists at the given index.
+ itemAtIndex (index) {
+ return this.items[index]
+ }
+
+ // Makes the next item in the itemStack active.
+ activateNextRecentlyUsedItem () {
+ if (this.items.length > 1) {
+ if (this.itemStackIndex == null) this.itemStackIndex = this.itemStack.length - 1
+ if (this.itemStackIndex === 0) this.itemStackIndex = this.itemStack.length
+ this.itemStackIndex--
+ const nextRecentlyUsedItem = this.itemStack[this.itemStackIndex]
+ this.emitter.emit('choose-next-mru-item', nextRecentlyUsedItem)
+ this.setActiveItem(nextRecentlyUsedItem, {modifyStack: false})
+ }
+ }
+
+ // Makes the previous item in the itemStack active.
+ activatePreviousRecentlyUsedItem () {
+ if (this.items.length > 1) {
+ if (this.itemStackIndex + 1 === this.itemStack.length || this.itemStackIndex == null) {
+ this.itemStackIndex = -1
+ }
+ this.itemStackIndex++
+ const previousRecentlyUsedItem = this.itemStack[this.itemStackIndex]
+ this.emitter.emit('choose-last-mru-item', previousRecentlyUsedItem)
+ this.setActiveItem(previousRecentlyUsedItem, {modifyStack: false})
+ }
+ }
+
+ // Moves the active item to the end of the itemStack once the ctrl key is lifted
+ moveActiveItemToTopOfStack () {
+ delete this.itemStackIndex
+ this.addItemToStack(this.activeItem)
+ this.emitter.emit('done-choosing-mru-item')
+ }
+
+ // Public: Makes the next item active.
+ activateNextItem () {
+ const index = this.getActiveItemIndex()
+ if (index < (this.items.length - 1)) {
+ this.activateItemAtIndex(index + 1)
+ } else {
+ this.activateItemAtIndex(0)
+ }
+ }
+
+ // Public: Makes the previous item active.
+ activatePreviousItem () {
+ const index = this.getActiveItemIndex()
+ if (index > 0) {
+ this.activateItemAtIndex(index - 1)
+ } else {
+ this.activateItemAtIndex(this.items.length - 1)
+ }
+ }
+
+ activateLastItem () {
+ this.activateItemAtIndex(this.items.length - 1)
+ }
+
+ // Public: Move the active tab to the right.
+ moveItemRight () {
+ const index = this.getActiveItemIndex()
+ const rightItemIndex = index + 1
+ if (rightItemIndex <= this.items.length - 1) this.moveItem(this.getActiveItem(), rightItemIndex)
+ }
+
+ // Public: Move the active tab to the left
+ moveItemLeft () {
+ const index = this.getActiveItemIndex()
+ const leftItemIndex = index - 1
+ if (leftItemIndex >= 0) return this.moveItem(this.getActiveItem(), leftItemIndex)
+ }
+
+ // Public: Get the index of the active item.
+ //
+ // Returns a {Number}.
+ getActiveItemIndex () {
+ return this.items.indexOf(this.activeItem)
+ }
+
+ // Public: Activate the item at the given index.
+ //
+ // * `index` {Number}
+ activateItemAtIndex (index) {
+ const item = this.itemAtIndex(index) || this.getActiveItem()
+ return this.setActiveItem(item)
+ }
+
+ // Public: Make the given item *active*, causing it to be displayed by
+ // the pane's view.
+ //
+ // * `item` The item to activate
+ // * `options` (optional) {Object}
+ // * `pending` (optional) {Boolean} indicating that the item should be added
+ // in a pending state if it does not yet exist in the pane. Existing pending
+ // items in a pane are replaced with new pending items when they are opened.
+ activateItem (item, options = {}) {
+ if (item) {
+ const index = (this.getPendingItem() === this.activeItem)
+ ? this.getActiveItemIndex()
+ : this.getActiveItemIndex() + 1
+ this.addItem(item, Object.assign({}, options, {index}))
+ this.setActiveItem(item)
+ }
+ }
+
+ // Public: Add the given item to the pane.
+ //
+ // * `item` The item to add. It can be a model with an associated view or a
+ // view.
+ // * `options` (optional) {Object}
+ // * `index` (optional) {Number} indicating the index at which to add the item.
+ // If omitted, the item is added after the current active item.
+ // * `pending` (optional) {Boolean} indicating that the item should be
+ // added in a pending state. Existing pending items in a pane are replaced with
+ // new pending items when they are opened.
+ //
+ // Returns the added item.
+ addItem (item, options = {}) {
+ // Backward compat with old API:
+ // addItem(item, index=@getActiveItemIndex() + 1)
+ if (typeof options === 'number') {
+ Grim.deprecate(`Pane::addItem(item, ${options}) is deprecated in favor of Pane::addItem(item, {index: ${options}})`)
+ options = {index: options}
+ }
+
+ const index = options.index != null ? options.index : this.getActiveItemIndex() + 1
+ const moved = options.moved != null ? options.moved : false
+ const pending = options.pending != null ? options.pending : false
+
+ if (!item || typeof item !== 'object') {
+ throw new Error(`Pane items must be objects. Attempted to add item ${item}.`)
+ }
+
+ if (typeof item.isDestroyed === 'function' && item.isDestroyed()) {
+ throw new Error(`Adding a pane item with URI '${typeof item.getURI === 'function' && item.getURI()}' that has already been destroyed`)
+ }
+
+ if (this.items.includes(item)) return
+
+ if (typeof item.onDidDestroy === 'function') {
+ const itemSubscriptions = new CompositeDisposable()
+ itemSubscriptions.add(item.onDidDestroy(() => this.removeItem(item, false)))
+ if (typeof item.onDidTerminatePendingState === 'function') {
+ itemSubscriptions.add(item.onDidTerminatePendingState(() => {
+ if (this.getPendingItem() === item) this.clearPendingItem()
+ }))
+ }
+ this.subscriptionsPerItem.set(item, itemSubscriptions)
+ }
+
+ this.items.splice(index, 0, item)
+ const lastPendingItem = this.getPendingItem()
+ const replacingPendingItem = lastPendingItem != null && !moved
+ if (replacingPendingItem) this.pendingItem = null
+ if (pending) this.setPendingItem(item)
+
+ this.emitter.emit('did-add-item', {item, index, moved})
+ if (!moved) {
+ if (this.container) this.container.didAddPaneItem(item, this, index)
+ }
+
+ if (replacingPendingItem) this.destroyItem(lastPendingItem)
+ if (!this.getActiveItem()) this.setActiveItem(item)
+ return item
+ }
+
+ setPendingItem (item) {
+ if (this.pendingItem !== item) {
+ const mostRecentPendingItem = this.pendingItem
+ this.pendingItem = item
+ if (mostRecentPendingItem) {
+ this.emitter.emit('item-did-terminate-pending-state', mostRecentPendingItem)
+ }
+ }
+ }
+
+ getPendingItem () {
+ return this.pendingItem || null
+ }
+
+ clearPendingItem () {
+ this.setPendingItem(null)
+ }
+
+ onItemDidTerminatePendingState (callback) {
+ return this.emitter.on('item-did-terminate-pending-state', callback)
+ }
+
+ // Public: Add the given items to the pane.
+ //
+ // * `items` An {Array} of items to add. Items can be views or models with
+ // associated views. Any objects that are already present in the pane's
+ // current items will not be added again.
+ // * `index` (optional) {Number} index at which to add the items. If omitted,
+ // the item is # added after the current active item.
+ //
+ // Returns an {Array} of added items.
+ addItems (items, index = this.getActiveItemIndex() + 1) {
+ items = items.filter(item => !this.items.includes(item))
+ for (let i = 0; i < items.length; i++) {
+ const item = items[i]
+ this.addItem(item, {index: index + i})
+ }
+ return items
+ }
+
+ removeItem (item, moved) {
+ const index = this.items.indexOf(item)
+ if (index === -1) return
+ if (this.getPendingItem() === item) this.pendingItem = null
+ this.removeItemFromStack(item)
+ this.emitter.emit('will-remove-item', {item, index, destroyed: !moved, moved})
+ this.unsubscribeFromItem(item)
+
+ if (item === this.activeItem) {
+ if (this.items.length === 1) {
+ this.setActiveItem(undefined)
+ } else if (index === 0) {
+ this.activateNextItem()
+ } else {
+ this.activatePreviousItem()
+ }
+ }
+ this.items.splice(index, 1)
+ this.emitter.emit('did-remove-item', {item, index, destroyed: !moved, moved})
+ if (!moved && this.container) this.container.didDestroyPaneItem({item, index, pane: this})
+ if (this.items.length === 0 && this.config.get('core.destroyEmptyPanes')) this.destroy()
+ }
+
+ // Remove the given item from the itemStack.
+ //
+ // * `item` The item to remove.
+ // * `index` {Number} indicating the index to which to remove the item from the itemStack.
+ removeItemFromStack (item) {
+ const index = this.itemStack.indexOf(item)
+ if (index !== -1) this.itemStack.splice(index, 1)
+ }
+
+ // Public: Move the given item to the given index.
+ //
+ // * `item` The item to move.
+ // * `index` {Number} indicating the index to which to move the item.
+ moveItem (item, newIndex) {
+ const oldIndex = this.items.indexOf(item)
+ this.items.splice(oldIndex, 1)
+ this.items.splice(newIndex, 0, item)
+ this.emitter.emit('did-move-item', {item, oldIndex, newIndex})
+ }
+
+ // Public: Move the given item to the given index on another pane.
+ //
+ // * `item` The item to move.
+ // * `pane` {Pane} to which to move the item.
+ // * `index` {Number} indicating the index to which to move the item in the
+ // given pane.
+ moveItemToPane (item, pane, index) {
+ this.removeItem(item, true)
+ return pane.addItem(item, {index, moved: true})
+ }
+
+ // Public: Destroy the active item and activate the next item.
+ //
+ // Returns a {Promise} that resolves when the item is destroyed.
+ destroyActiveItem () {
+ return this.destroyItem(this.activeItem)
+ }
+
+ // Public: Destroy the given item.
+ //
+ // If the item is active, the next item will be activated. If the item is the
+ // last item, the pane will be destroyed if the `core.destroyEmptyPanes` config
+ // setting is `true`.
+ //
+ // * `item` Item to destroy
+ // * `force` (optional) {Boolean} Destroy the item without prompting to save
+ // it, even if the item's `isPermanentDockItem` method returns true.
+ //
+ // Returns a {Promise} that resolves with a {Boolean} indicating whether or not
+ // the item was destroyed.
+ async destroyItem (item, force) {
+ const index = this.items.indexOf(item)
+ if (index === -1) return false
+
+ if (!force &&
+ typeof item.isPermanentDockItem === 'function' && item.isPermanentDockItem() &&
+ (!this.container || this.container.getLocation() !== 'center')) {
+ return false
+ }
+
+ // In the case where there are no `onWillDestroyPaneItem` listeners, preserve the old behavior
+ // where `Pane.destroyItem` and callers such as `Pane.close` take effect synchronously.
+ if (this.emitter.listenerCountForEventName('will-destroy-item') > 0) {
+ await this.emitter.emitAsync('will-destroy-item', {item, index})
+ }
+ if (this.container && this.container.emitter.listenerCountForEventName('will-destroy-pane-item') > 0) {
+ await this.container.willDestroyPaneItem({item, index, pane: this})
+ }
+
+ if (!force && typeof item.shouldPromptToSave === 'function' && item.shouldPromptToSave()) {
+ if (!await this.promptToSaveItem(item)) return false
+ }
+ this.removeItem(item, false)
+ if (typeof item.destroy === 'function') item.destroy()
+ return true
+ }
+
+ // Public: Destroy all items.
+ destroyItems () {
+ return Promise.all(
+ this.getItems().map(item => this.destroyItem(item))
+ )
+ }
+
+ // Public: Destroy all items except for the active item.
+ destroyInactiveItems () {
+ return Promise.all(
+ this.getItems()
+ .filter(item => item !== this.activeItem)
+ .map(item => this.destroyItem(item))
+ )
+ }
+
+ promptToSaveItem (item, options = {}) {
+ if (typeof item.shouldPromptToSave !== 'function' || !item.shouldPromptToSave(options)) {
+ return Promise.resolve(true)
+ }
+
+ let uri
+ if (typeof item.getURI === 'function') {
+ uri = item.getURI()
+ } else if (typeof item.getUri === 'function') {
+ uri = item.getUri()
+ } else {
+ return Promise.resolve(true)
+ }
+
+ const title = (typeof item.getTitle === 'function' && item.getTitle()) || uri
+
+ const saveDialog = (saveButtonText, saveFn, message) => {
+ const chosen = this.applicationDelegate.confirm({
+ message,
+ detailedMessage: 'Your changes will be lost if you close this item without saving.',
+ buttons: [saveButtonText, 'Cancel', "&Don't Save"]}
+ )
+
+ switch (chosen) {
+ case 0:
+ return new Promise(resolve => {
+ return saveFn(item, error => {
+ if (error instanceof SaveCancelledError) {
+ resolve(false)
+ } else if (error) {
+ saveDialog(
+ 'Save as',
+ this.saveItemAs,
+ `'${title}' could not be saved.\nError: ${this.getMessageForErrorCode(error.code)}`
+ ).then(resolve)
+ } else {
+ resolve(true)
+ }
+ })
+ })
+ case 1:
+ return Promise.resolve(false)
+ case 2:
+ return Promise.resolve(true)
+ }
+ }
+
+ return saveDialog(
+ 'Save',
+ this.saveItem,
+ `'${title}' has changes, do you want to save them?`
+ )
+ }
+
+ // Public: Save the active item.
+ saveActiveItem (nextAction) {
+ return this.saveItem(this.getActiveItem(), nextAction)
+ }
+
+ // Public: Prompt the user for a location and save the active item with the
+ // path they select.
+ //
+ // * `nextAction` (optional) {Function} which will be called after the item is
+ // successfully saved.
+ //
+ // Returns a {Promise} that resolves when the save is complete
+ saveActiveItemAs (nextAction) {
+ return this.saveItemAs(this.getActiveItem(), nextAction)
+ }
+
+ // Public: Save the given item.
+ //
+ // * `item` The item to save.
+ // * `nextAction` (optional) {Function} which will be called with no argument
+ // after the item is successfully saved, or with the error if it failed.
+ // The return value will be that of `nextAction` or `undefined` if it was not
+ // provided
+ //
+ // Returns a {Promise} that resolves when the save is complete
+ saveItem (item, nextAction) {
+ if (!item) return Promise.resolve()
+
+ let itemURI
+ if (typeof item.getURI === 'function') {
+ itemURI = item.getURI()
+ } else if (typeof item.getUri === 'function') {
+ itemURI = item.getUri()
+ }
+
+ if (itemURI != null) {
+ if (typeof item.save === 'function') {
+ return promisify(() => item.save())
+ .then(() => {
+ if (nextAction) nextAction()
+ })
+ .catch(error => {
+ if (nextAction) {
+ nextAction(error)
+ } else {
+ this.handleSaveError(error, item)
+ }
+ })
+ } else if (nextAction) {
+ nextAction()
+ return Promise.resolve()
+ }
+ } else {
+ return this.saveItemAs(item, nextAction)
+ }
+ }
+
+ // Public: Prompt the user for a location and save the active item with the
+ // path they select.
+ //
+ // * `item` The item to save.
+ // * `nextAction` (optional) {Function} which will be called with no argument
+ // after the item is successfully saved, or with the error if it failed.
+ // The return value will be that of `nextAction` or `undefined` if it was not
+ // provided
+ saveItemAs (item, nextAction) {
+ if (!item) return
+ if (typeof item.saveAs !== 'function') return
+
+ const saveOptions = typeof item.getSaveDialogOptions === 'function'
+ ? item.getSaveDialogOptions()
+ : {}
+
+ const itemPath = item.getPath()
+ if (itemPath && !saveOptions.defaultPath) saveOptions.defaultPath = itemPath
+
+ const newItemPath = this.applicationDelegate.showSaveDialog(saveOptions)
+ if (newItemPath) {
+ return promisify(() => item.saveAs(newItemPath))
+ .then(() => {
+ if (nextAction) nextAction()
+ })
+ .catch(error => {
+ if (nextAction) {
+ nextAction(error)
+ } else {
+ this.handleSaveError(error, item)
+ }
+ })
+ } else if (nextAction) {
+ return nextAction(new SaveCancelledError('Save Cancelled'))
+ }
+ }
+
+ // Public: Save all items.
+ saveItems () {
+ for (let item of this.getItems()) {
+ if (typeof item.isModified === 'function' && item.isModified()) {
+ this.saveItem(item)
+ }
+ }
+ }
+
+ // Public: Return the first item that matches the given URI or undefined if
+ // none exists.
+ //
+ // * `uri` {String} containing a URI.
+ itemForURI (uri) {
+ return this.items.find(item => {
+ if (typeof item.getURI === 'function') {
+ return item.getURI() === uri
+ } else if (typeof item.getUri === 'function') {
+ return item.getUri() === uri
+ }
+ })
+ }
+
+ // Public: Activate the first item that matches the given URI.
+ //
+ // * `uri` {String} containing a URI.
+ //
+ // Returns a {Boolean} indicating whether an item matching the URI was found.
+ activateItemForURI (uri) {
+ const item = this.itemForURI(uri)
+ if (item) {
+ this.activateItem(item)
+ return true
+ } else {
+ return false
+ }
+ }
+
+ copyActiveItem () {
+ if (this.activeItem && typeof this.activeItem.copy === 'function') {
+ return this.activeItem.copy()
+ }
+ }
+
+ /*
+ Section: Lifecycle
+ */
+
+ // Public: Determine whether the pane is active.
+ //
+ // Returns a {Boolean}.
+ isActive () {
+ return this.container && this.container.getActivePane() === this
+ }
+
+ // Public: Makes this pane the *active* pane, causing it to gain focus.
+ activate () {
+ if (this.isDestroyed()) throw new Error('Pane has been destroyed')
+ if (this.container) this.container.didActivatePane(this)
+ this.emitter.emit('did-activate')
+ }
+
+ // Public: Close the pane and destroy all its items.
+ //
+ // If this is the last pane, all the items will be destroyed but the pane
+ // itself will not be destroyed.
+ destroy () {
+ if (this.container && this.container.isAlive() && this.container.getPanes().length === 1) {
+ return this.destroyItems()
+ }
+
+ this.emitter.emit('will-destroy')
+ this.alive = false
+ if (this.container) {
+ this.container.willDestroyPane({pane: this})
+ if (this.isActive()) this.container.activateNextPane()
+ }
+ this.emitter.emit('did-destroy')
+ this.emitter.dispose()
+ for (let item of this.items.slice()) {
+ if (typeof item.destroy === 'function') item.destroy()
+ }
+ if (this.container) this.container.didDestroyPane({pane: this})
+ }
+
+ isAlive () { return this.alive }
+
+ // Public: Determine whether this pane has been destroyed.
+ //
+ // Returns a {Boolean}.
+ isDestroyed () { return !this.isAlive() }
+
+ /*
+ Section: Splitting
+ */
+
+ // Public: Create a new pane to the left of this pane.
+ //
+ // * `params` (optional) {Object} with the following keys:
+ // * `items` (optional) {Array} of items to add to the new pane.
+ // * `copyActiveItem` (optional) {Boolean} true will copy the active item into the new split pane
+ //
+ // Returns the new {Pane}.
+ splitLeft (params) {
+ return this.split('horizontal', 'before', params)
+ }
+
+ // Public: Create a new pane to the right of this pane.
+ //
+ // * `params` (optional) {Object} with the following keys:
+ // * `items` (optional) {Array} of items to add to the new pane.
+ // * `copyActiveItem` (optional) {Boolean} true will copy the active item into the new split pane
+ //
+ // Returns the new {Pane}.
+ splitRight (params) {
+ return this.split('horizontal', 'after', params)
+ }
+
+ // Public: Creates a new pane above the receiver.
+ //
+ // * `params` (optional) {Object} with the following keys:
+ // * `items` (optional) {Array} of items to add to the new pane.
+ // * `copyActiveItem` (optional) {Boolean} true will copy the active item into the new split pane
+ //
+ // Returns the new {Pane}.
+ splitUp (params) {
+ return this.split('vertical', 'before', params)
+ }
+
+ // Public: Creates a new pane below the receiver.
+ //
+ // * `params` (optional) {Object} with the following keys:
+ // * `items` (optional) {Array} of items to add to the new pane.
+ // * `copyActiveItem` (optional) {Boolean} true will copy the active item into the new split pane
+ //
+ // Returns the new {Pane}.
+ splitDown (params) {
+ return this.split('vertical', 'after', params)
+ }
+
+ split (orientation, side, params) {
+ if (params && params.copyActiveItem) {
+ if (!params.items) params.items = []
+ params.items.push(this.copyActiveItem())
+ }
+
+ if (this.parent.orientation !== orientation) {
+ this.parent.replaceChild(this, new PaneAxis({
+ container: this.container,
+ orientation,
+ children: [this],
+ flexScale: this.flexScale},
+ this.viewRegistry
+ ))
+ this.setFlexScale(1)
+ }
+
+ const newPane = new Pane(Object.assign({
+ applicationDelegate: this.applicationDelegate,
+ notificationManager: this.notificationManager,
+ deserializerManager: this.deserializerManager,
+ config: this.config,
+ viewRegistry: this.viewRegistry
+ }, params))
+
+ switch (side) {
+ case 'before': this.parent.insertChildBefore(this, newPane); break
+ case 'after': this.parent.insertChildAfter(this, newPane); break
+ }
+
+ if (params && params.moveActiveItem && this.activeItem) this.moveItemToPane(this.activeItem, newPane)
+
+ newPane.activate()
+ return newPane
+ }
+
+ // If the parent is a horizontal axis, returns its first child if it is a pane;
+ // otherwise returns this pane.
+ findLeftmostSibling () {
+ if (this.parent.orientation === 'horizontal') {
+ const [leftmostSibling] = this.parent.children
+ if (leftmostSibling instanceof PaneAxis) {
+ return this
+ } else {
+ return leftmostSibling
+ }
+ } else {
+ return this
+ }
+ }
+
+ findRightmostSibling () {
+ if (this.parent.orientation === 'horizontal') {
+ const rightmostSibling = this.parent.children[this.parent.children.length - 1]
+ if (rightmostSibling instanceof PaneAxis) {
+ return this
+ } else {
+ return rightmostSibling
+ }
+ } else {
+ return this
+ }
+ }
+
+ // If the parent is a horizontal axis, returns its last child if it is a pane;
+ // otherwise returns a new pane created by splitting this pane rightward.
+ findOrCreateRightmostSibling () {
+ const rightmostSibling = this.findRightmostSibling()
+ if (rightmostSibling === this) {
+ return this.splitRight()
+ } else {
+ return rightmostSibling
+ }
+ }
+
+ // If the parent is a vertical axis, returns its first child if it is a pane;
+ // otherwise returns this pane.
+ findTopmostSibling () {
+ if (this.parent.orientation === 'vertical') {
+ const [topmostSibling] = this.parent.children
+ if (topmostSibling instanceof PaneAxis) {
+ return this
+ } else {
+ return topmostSibling
+ }
+ } else {
+ return this
+ }
+ }
+
+ findBottommostSibling () {
+ if (this.parent.orientation === 'vertical') {
+ const bottommostSibling = this.parent.children[this.parent.children.length - 1]
+ if (bottommostSibling instanceof PaneAxis) {
+ return this
+ } else {
+ return bottommostSibling
+ }
+ } else {
+ return this
+ }
+ }
+
+ // If the parent is a vertical axis, returns its last child if it is a pane;
+ // otherwise returns a new pane created by splitting this pane bottomward.
+ findOrCreateBottommostSibling () {
+ const bottommostSibling = this.findBottommostSibling()
+ if (bottommostSibling === this) {
+ return this.splitDown()
+ } else {
+ return bottommostSibling
+ }
+ }
+
+ // Private: Close the pane unless the user cancels the action via a dialog.
+ //
+ // Returns a {Promise} that resolves once the pane is either closed, or the
+ // closing has been cancelled.
+ close () {
+ return Promise.all(this.getItems().map(item => this.promptToSaveItem(item)))
+ .then(results => {
+ if (!results.includes(false)) return this.destroy()
+ })
+ }
+
+ handleSaveError (error, item) {
+ const itemPath = error.path || (typeof item.getPath === 'function' && item.getPath())
+ const addWarningWithPath = (message, options) => {
+ if (itemPath) message = `${message} '${itemPath}'`
+ this.notificationManager.addWarning(message, options)
+ }
+
+ const customMessage = this.getMessageForErrorCode(error.code)
+ if (customMessage != null) {
+ addWarningWithPath(`Unable to save file: ${customMessage}`)
+ } else if (error.code === 'EISDIR' || (error.message && error.message.endsWith('is a directory'))) {
+ return this.notificationManager.addWarning(`Unable to save file: ${error.message}`)
+ } else if (['EPERM', 'EBUSY', 'UNKNOWN', 'EEXIST', 'ELOOP', 'EAGAIN'].includes(error.code)) {
+ addWarningWithPath('Unable to save file', {detail: error.message})
+ } else {
+ const errorMatch = /ENOTDIR, not a directory '([^']+)'/.exec(error.message)
+ if (errorMatch) {
+ const fileName = errorMatch[1]
+ this.notificationManager.addWarning(`Unable to save file: A directory in the path '${fileName}' could not be written to`)
+ } else {
+ throw error
+ }
+ }
+ }
+
+ getMessageForErrorCode (errorCode) {
+ switch (errorCode) {
+ case 'EACCES': return 'Permission denied'
+ case 'ECONNRESET': return 'Connection reset'
+ case 'EINTR': return 'Interrupted system call'
+ case 'EIO': return 'I/O error writing file'
+ case 'ENOSPC': return 'No space left on device'
+ case 'ENOTSUP': return 'Operation not supported on socket'
+ case 'ENXIO': return 'No such device or address'
+ case 'EROFS': return 'Read-only file system'
+ case 'ESPIPE': return 'Invalid seek'
+ case 'ETIMEDOUT': return 'Connection timed out'
+ }
+ }
+}
+
+function promisify (callback) {
+ try {
+ return Promise.resolve(callback())
+ } catch (error) {
+ return Promise.reject(error)
+ }
+}
diff --git a/src/path-watcher.js b/src/path-watcher.js
index 69bf36da0..2dfece46e 100644
--- a/src/path-watcher.js
+++ b/src/path-watcher.js
@@ -437,7 +437,7 @@ class PathWatcher {
// await watcher.getStartPromise()
// fs.writeFile(FILE, 'contents\n', err => {
// // The watcher is listening and the event should be
- // // received asyncronously
+ // // received asynchronously
// }
// })
// })
diff --git a/src/project.coffee b/src/project.coffee
deleted file mode 100644
index cad5f03ac..000000000
--- a/src/project.coffee
+++ /dev/null
@@ -1,517 +0,0 @@
-path = require 'path'
-
-_ = require 'underscore-plus'
-fs = require 'fs-plus'
-{Emitter, Disposable} = require 'event-kit'
-TextBuffer = require 'text-buffer'
-{watchPath} = require('./path-watcher')
-
-DefaultDirectoryProvider = require './default-directory-provider'
-Model = require './model'
-GitRepositoryProvider = require './git-repository-provider'
-
-# Extended: Represents a project that's opened in Atom.
-#
-# An instance of this class is always available as the `atom.project` global.
-module.exports =
-class Project extends Model
- ###
- Section: Construction and Destruction
- ###
-
- constructor: ({@notificationManager, packageManager, config, @applicationDelegate}) ->
- @emitter = new Emitter
- @buffers = []
- @rootDirectories = []
- @repositories = []
- @directoryProviders = []
- @defaultDirectoryProvider = new DefaultDirectoryProvider()
- @repositoryPromisesByPath = new Map()
- @repositoryProviders = [new GitRepositoryProvider(this, config)]
- @loadPromisesByPath = {}
- @watcherPromisesByPath = {}
- @consumeServices(packageManager)
-
- destroyed: ->
- buffer.destroy() for buffer in @buffers.slice()
- repository?.destroy() for repository in @repositories.slice()
- watcher.dispose() for _, watcher in @watcherPromisesByPath
- @rootDirectories = []
- @repositories = []
-
- reset: (packageManager) ->
- @emitter.dispose()
- @emitter = new Emitter
-
- buffer?.destroy() for buffer in @buffers
- @buffers = []
- @setPaths([])
- @loadPromisesByPath = {}
- @consumeServices(packageManager)
-
- destroyUnretainedBuffers: ->
- buffer.destroy() for buffer in @getBuffers() when not buffer.isRetained()
- return
-
- ###
- Section: Serialization
- ###
-
- deserialize: (state) ->
- bufferPromises = []
- for bufferState in state.buffers
- continue if fs.isDirectorySync(bufferState.filePath)
- if bufferState.filePath
- try
- fs.closeSync(fs.openSync(bufferState.filePath, 'r'))
- catch error
- continue unless error.code is 'ENOENT'
- unless bufferState.shouldDestroyOnFileDelete?
- bufferState.shouldDestroyOnFileDelete = ->
- atom.config.get('core.closeDeletedFileTabs')
- bufferPromises.push(TextBuffer.deserialize(bufferState))
- Promise.all(bufferPromises).then (@buffers) =>
- @subscribeToBuffer(buffer) for buffer in @buffers
- @setPaths(state.paths)
-
- serialize: (options={}) ->
- deserializer: 'Project'
- paths: @getPaths()
- buffers: _.compact(@buffers.map (buffer) ->
- if buffer.isRetained()
- isUnloading = options.isUnloading is true
- buffer.serialize({markerLayers: isUnloading, history: isUnloading})
- )
-
- ###
- Section: Event Subscription
- ###
-
- # Public: Invoke the given callback when the project paths change.
- #
- # * `callback` {Function} to be called after the project paths change.
- # * `projectPaths` An {Array} of {String} project paths.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidChangePaths: (callback) ->
- @emitter.on 'did-change-paths', callback
-
- # Public: Invoke the given callback when a text buffer is added to the
- # project.
- #
- # * `callback` {Function} to be called when a text buffer is added.
- # * `buffer` A {TextBuffer} item.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- onDidAddBuffer: (callback) ->
- @emitter.on 'did-add-buffer', callback
-
- # Public: Invoke the given callback with all current and future text
- # buffers in the project.
- #
- # * `callback` {Function} to be called with current and future text buffers.
- # * `buffer` A {TextBuffer} item.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
- observeBuffers: (callback) ->
- callback(buffer) for buffer in @getBuffers()
- @onDidAddBuffer callback
-
- # Extended: Invoke a callback when a filesystem change occurs within any open
- # project path.
- #
- # ```js
- # const disposable = atom.project.onDidChangeFiles(events => {
- # for (const event of events) {
- # // "created", "modified", "deleted", or "renamed"
- # console.log(`Event action: ${event.type}`)
- #
- # // absolute path to the filesystem entry that was touched
- # console.log(`Event path: ${event.path}`)
- #
- # if (event.type === 'renamed') {
- # console.log(`.. renamed from: ${event.oldPath}`)
- # }
- # }
- # }
- #
- # disposable.dispose()
- # ```
- #
- # To watch paths outside of open projects, use the `watchPaths` function instead; see {PathWatcher}.
- #
- # When writing tests against functionality that uses this method, be sure to wait for the
- # {Promise} returned by {getWatcherPromise()} before manipulating the filesystem to ensure that
- # the watcher is receiving events.
- #
- # * `callback` {Function} to be called with batches of filesystem events reported by
- # the operating system.
- # * `events` An {Array} of objects that describe a batch of filesystem events.
- # * `action` {String} describing the filesystem action that occurred. One of `"created"`,
- # `"modified"`, `"deleted"`, or `"renamed"`.
- # * `path` {String} containing the absolute path to the filesystem entry
- # that was acted upon.
- # * `oldPath` For rename events, {String} containing the filesystem entry's
- # former absolute path.
- #
- # Returns a {Disposable} to manage this event subscription.
- onDidChangeFiles: (callback) ->
- @emitter.on 'did-change-files', callback
-
- ###
- Section: Accessing the git repository
- ###
-
- # Public: Get an {Array} of {GitRepository}s associated with the project's
- # directories.
- #
- # This method will be removed in 2.0 because it does synchronous I/O.
- # Prefer the following, which evaluates to a {Promise} that resolves to an
- # {Array} of {Repository} objects:
- # ```
- # Promise.all(atom.project.getDirectories().map(
- # atom.project.repositoryForDirectory.bind(atom.project)))
- # ```
- getRepositories: -> @repositories
-
- # Public: Get the repository for a given directory asynchronously.
- #
- # * `directory` {Directory} for which to get a {Repository}.
- #
- # Returns a {Promise} that resolves with either:
- # * {Repository} if a repository can be created for the given directory
- # * `null` if no repository can be created for the given directory.
- repositoryForDirectory: (directory) ->
- pathForDirectory = directory.getRealPathSync()
- promise = @repositoryPromisesByPath.get(pathForDirectory)
- unless promise
- promises = @repositoryProviders.map (provider) ->
- provider.repositoryForDirectory(directory)
- promise = Promise.all(promises).then (repositories) =>
- repo = _.find(repositories, (repo) -> repo?) ? null
-
- # If no repository is found, remove the entry in for the directory in
- # @repositoryPromisesByPath in case some other RepositoryProvider is
- # registered in the future that could supply a Repository for the
- # directory.
- @repositoryPromisesByPath.delete(pathForDirectory) unless repo?
- repo?.onDidDestroy?(=> @repositoryPromisesByPath.delete(pathForDirectory))
- repo
- @repositoryPromisesByPath.set(pathForDirectory, promise)
- promise
-
- ###
- Section: Managing Paths
- ###
-
- # Public: Get an {Array} of {String}s containing the paths of the project's
- # directories.
- getPaths: -> rootDirectory.getPath() for rootDirectory in @rootDirectories
-
- # Public: Set the paths of the project's directories.
- #
- # * `projectPaths` {Array} of {String} paths.
- setPaths: (projectPaths) ->
- repository?.destroy() for repository in @repositories
- @rootDirectories = []
- @repositories = []
-
- watcher.then((w) -> w.dispose()) for _, watcher in @watcherPromisesByPath
- @watcherPromisesByPath = {}
-
- @addPath(projectPath, emitEvent: false) for projectPath in projectPaths
-
- @emitter.emit 'did-change-paths', projectPaths
-
- # Public: Add a path to the project's list of root paths
- #
- # * `projectPath` {String} The path to the directory to add.
- addPath: (projectPath, options) ->
- directory = @getDirectoryForProjectPath(projectPath)
- return unless directory.existsSync()
- for existingDirectory in @getDirectories()
- return if existingDirectory.getPath() is directory.getPath()
-
- @rootDirectories.push(directory)
- @watcherPromisesByPath[directory.getPath()] = watchPath directory.getPath(), {}, (events) =>
- # Stop event delivery immediately on removal of a rootDirectory, even if its watcher
- # promise has yet to resolve at the time of removal
- if @rootDirectories.includes directory
- @emitter.emit 'did-change-files', events
-
- for root, watcherPromise in @watcherPromisesByPath
- unless @rootDirectories.includes root
- watcherPromise.then (watcher) -> watcher.dispose()
-
- repo = null
- for provider in @repositoryProviders
- break if repo = provider.repositoryForDirectorySync?(directory)
- @repositories.push(repo ? null)
-
- unless options?.emitEvent is false
- @emitter.emit 'did-change-paths', @getPaths()
-
- getDirectoryForProjectPath: (projectPath) ->
- directory = null
- for provider in @directoryProviders
- break if directory = provider.directoryForURISync?(projectPath)
- directory ?= @defaultDirectoryProvider.directoryForURISync(projectPath)
- directory
-
- # Extended: Access a {Promise} that resolves when the filesystem watcher associated with a project
- # root directory is ready to begin receiving events.
- #
- # This is especially useful in test cases, where it's important to know that the watcher is
- # ready before manipulating the filesystem to produce events.
- #
- # * `projectPath` {String} One of the project's root directories.
- #
- # Returns a {Promise} that resolves with the {PathWatcher} associated with this project root
- # once it has initialized and is ready to start sending events. The Promise will reject with
- # an error instead if `projectPath` is not currently a root directory.
- getWatcherPromise: (projectPath) ->
- @watcherPromisesByPath[projectPath] or
- Promise.reject(new Error("#{projectPath} is not a project root"))
-
- # Public: remove a path from the project's list of root paths.
- #
- # * `projectPath` {String} The path to remove.
- removePath: (projectPath) ->
- # The projectPath may be a URI, in which case it should not be normalized.
- unless projectPath in @getPaths()
- projectPath = @defaultDirectoryProvider.normalizePath(projectPath)
-
- indexToRemove = null
- for directory, i in @rootDirectories
- if directory.getPath() is projectPath
- indexToRemove = i
- break
-
- if indexToRemove?
- [removedDirectory] = @rootDirectories.splice(indexToRemove, 1)
- [removedRepository] = @repositories.splice(indexToRemove, 1)
- removedRepository?.destroy() unless removedRepository in @repositories
- @watcherPromisesByPath[projectPath]?.then (w) -> w.dispose()
- delete @watcherPromisesByPath[projectPath]
- @emitter.emit "did-change-paths", @getPaths()
- true
- else
- false
-
- # Public: Get an {Array} of {Directory}s associated with this project.
- getDirectories: ->
- @rootDirectories
-
- resolvePath: (uri) ->
- return unless uri
-
- if uri?.match(/[A-Za-z0-9+-.]+:\/\//) # leave path alone if it has a scheme
- uri
- else
- if fs.isAbsolute(uri)
- @defaultDirectoryProvider.normalizePath(fs.resolveHome(uri))
- # TODO: what should we do here when there are multiple directories?
- else if projectPath = @getPaths()[0]
- @defaultDirectoryProvider.normalizePath(fs.resolveHome(path.join(projectPath, uri)))
- else
- undefined
-
- relativize: (fullPath) ->
- @relativizePath(fullPath)[1]
-
- # Public: Get the path to the project directory that contains the given path,
- # and the relative path from that project directory to the given path.
- #
- # * `fullPath` {String} An absolute path.
- #
- # Returns an {Array} with two elements:
- # * `projectPath` The {String} path to the project directory that contains the
- # given path, or `null` if none is found.
- # * `relativePath` {String} The relative path from the project directory to
- # the given path.
- relativizePath: (fullPath) ->
- result = [null, fullPath]
- if fullPath?
- for rootDirectory in @rootDirectories
- relativePath = rootDirectory.relativize(fullPath)
- if relativePath?.length < result[1].length
- result = [rootDirectory.getPath(), relativePath]
- result
-
- # Public: Determines whether the given path (real or symbolic) is inside the
- # project's directory.
- #
- # This method does not actually check if the path exists, it just checks their
- # locations relative to each other.
- #
- # ## Examples
- #
- # Basic operation
- #
- # ```coffee
- # # Project's root directory is /foo/bar
- # project.contains('/foo/bar/baz') # => true
- # project.contains('/usr/lib/baz') # => false
- # ```
- #
- # Existence of the path is not required
- #
- # ```coffee
- # # Project's root directory is /foo/bar
- # fs.existsSync('/foo/bar/baz') # => false
- # project.contains('/foo/bar/baz') # => true
- # ```
- #
- # * `pathToCheck` {String} path
- #
- # Returns whether the path is inside the project's root directory.
- contains: (pathToCheck) ->
- @rootDirectories.some (dir) -> dir.contains(pathToCheck)
-
- ###
- Section: Private
- ###
-
- consumeServices: ({serviceHub}) ->
- serviceHub.consume(
- 'atom.directory-provider',
- '^0.1.0',
- (provider) =>
- @directoryProviders.unshift(provider)
- new Disposable =>
- @directoryProviders.splice(@directoryProviders.indexOf(provider), 1)
- )
-
- serviceHub.consume(
- 'atom.repository-provider',
- '^0.1.0',
- (provider) =>
- @repositoryProviders.unshift(provider)
- @setPaths(@getPaths()) if null in @repositories
- new Disposable =>
- @repositoryProviders.splice(@repositoryProviders.indexOf(provider), 1)
- )
-
- # Retrieves all the {TextBuffer}s in the project; that is, the
- # buffers for all open files.
- #
- # Returns an {Array} of {TextBuffer}s.
- getBuffers: ->
- @buffers.slice()
-
- # Is the buffer for the given path modified?
- isPathModified: (filePath) ->
- @findBufferForPath(@resolvePath(filePath))?.isModified()
-
- findBufferForPath: (filePath) ->
- _.find @buffers, (buffer) -> buffer.getPath() is filePath
-
- findBufferForId: (id) ->
- _.find @buffers, (buffer) -> buffer.getId() is id
-
- # Only to be used in specs
- bufferForPathSync: (filePath) ->
- absoluteFilePath = @resolvePath(filePath)
- existingBuffer = @findBufferForPath(absoluteFilePath) if filePath
- existingBuffer ? @buildBufferSync(absoluteFilePath)
-
- # Only to be used when deserializing
- bufferForIdSync: (id) ->
- existingBuffer = @findBufferForId(id) if id
- existingBuffer ? @buildBufferSync()
-
- # Given a file path, this retrieves or creates a new {TextBuffer}.
- #
- # If the `filePath` already has a `buffer`, that value is used instead. Otherwise,
- # `text` is used as the contents of the new buffer.
- #
- # * `filePath` A {String} representing a path. If `null`, an "Untitled" buffer is created.
- #
- # Returns a {Promise} that resolves to the {TextBuffer}.
- bufferForPath: (absoluteFilePath) ->
- existingBuffer = @findBufferForPath(absoluteFilePath) if absoluteFilePath?
- if existingBuffer
- Promise.resolve(existingBuffer)
- else
- @buildBuffer(absoluteFilePath)
-
- shouldDestroyBufferOnFileDelete: ->
- atom.config.get('core.closeDeletedFileTabs')
-
- # Still needed when deserializing a tokenized buffer
- buildBufferSync: (absoluteFilePath) ->
- params = {shouldDestroyOnFileDelete: @shouldDestroyBufferOnFileDelete}
- if absoluteFilePath?
- buffer = TextBuffer.loadSync(absoluteFilePath, params)
- else
- buffer = new TextBuffer(params)
- @addBuffer(buffer)
- buffer
-
- # Given a file path, this sets its {TextBuffer}.
- #
- # * `absoluteFilePath` A {String} representing a path.
- # * `text` The {String} text to use as a buffer.
- #
- # Returns a {Promise} that resolves to the {TextBuffer}.
- buildBuffer: (absoluteFilePath) ->
- params = {shouldDestroyOnFileDelete: @shouldDestroyBufferOnFileDelete}
- if absoluteFilePath?
- promise =
- @loadPromisesByPath[absoluteFilePath] ?=
- TextBuffer.load(absoluteFilePath, params).catch (error) =>
- delete @loadPromisesByPath[absoluteFilePath]
- throw error
- else
- promise = Promise.resolve(new TextBuffer(params))
- promise.then (buffer) =>
- delete @loadPromisesByPath[absoluteFilePath]
- @addBuffer(buffer)
- buffer
-
-
- addBuffer: (buffer, options={}) ->
- @addBufferAtIndex(buffer, @buffers.length, options)
-
- addBufferAtIndex: (buffer, index, options={}) ->
- @buffers.splice(index, 0, buffer)
- @subscribeToBuffer(buffer)
- @emitter.emit 'did-add-buffer', buffer
- buffer
-
- # Removes a {TextBuffer} association from the project.
- #
- # Returns the removed {TextBuffer}.
- removeBuffer: (buffer) ->
- index = @buffers.indexOf(buffer)
- @removeBufferAtIndex(index) unless index is -1
-
- removeBufferAtIndex: (index, options={}) ->
- [buffer] = @buffers.splice(index, 1)
- buffer?.destroy()
-
- eachBuffer: (args...) ->
- subscriber = args.shift() if args.length > 1
- callback = args.shift()
-
- callback(buffer) for buffer in @getBuffers()
- if subscriber
- subscriber.subscribe this, 'buffer-created', (buffer) -> callback(buffer)
- else
- @on 'buffer-created', (buffer) -> callback(buffer)
-
- subscribeToBuffer: (buffer) ->
- buffer.onWillSave ({path}) => @applicationDelegate.emitWillSavePath(path)
- buffer.onDidSave ({path}) => @applicationDelegate.emitDidSavePath(path)
- buffer.onDidDestroy => @removeBuffer(buffer)
- buffer.onDidChangePath =>
- unless @getPaths().length > 0
- @setPaths([path.dirname(buffer.getPath())])
- buffer.onWillThrowWatchError ({error, handle}) =>
- handle()
- @notificationManager.addWarning """
- Unable to read file after file `#{error.eventType}` event.
- Make sure you have permission to access `#{buffer.getPath()}`.
- """,
- detail: error.message
- dismissable: true
diff --git a/src/project.js b/src/project.js
new file mode 100644
index 000000000..48541c395
--- /dev/null
+++ b/src/project.js
@@ -0,0 +1,705 @@
+const path = require('path')
+
+const _ = require('underscore-plus')
+const fs = require('fs-plus')
+const {Emitter, Disposable} = require('event-kit')
+const TextBuffer = require('text-buffer')
+const {watchPath} = require('./path-watcher')
+
+const DefaultDirectoryProvider = require('./default-directory-provider')
+const Model = require('./model')
+const GitRepositoryProvider = require('./git-repository-provider')
+
+// Extended: Represents a project that's opened in Atom.
+//
+// An instance of this class is always available as the `atom.project` global.
+module.exports =
+class Project extends Model {
+ /*
+ Section: Construction and Destruction
+ */
+
+ constructor ({notificationManager, packageManager, config, applicationDelegate}) {
+ super()
+ this.notificationManager = notificationManager
+ this.applicationDelegate = applicationDelegate
+ this.emitter = new Emitter()
+ this.buffers = []
+ this.rootDirectories = []
+ this.repositories = []
+ this.directoryProviders = []
+ this.defaultDirectoryProvider = new DefaultDirectoryProvider()
+ this.repositoryPromisesByPath = new Map()
+ this.repositoryProviders = [new GitRepositoryProvider(this, config)]
+ this.loadPromisesByPath = {}
+ this.watcherPromisesByPath = {}
+ this.retiredBufferIDs = new Set()
+ this.retiredBufferPaths = new Set()
+ this.consumeServices(packageManager)
+ }
+
+ destroyed () {
+ for (let buffer of this.buffers.slice()) { buffer.destroy() }
+ for (let repository of this.repositories.slice()) {
+ if (repository != null) repository.destroy()
+ }
+ for (let path in this.watcherPromisesByPath) {
+ this.watcherPromisesByPath[path].then(watcher => { watcher.dispose() })
+ }
+ this.rootDirectories = []
+ this.repositories = []
+ }
+
+ reset (packageManager) {
+ this.emitter.dispose()
+ this.emitter = new Emitter()
+
+ for (let buffer of this.buffers) {
+ if (buffer != null) buffer.destroy()
+ }
+ this.buffers = []
+ this.setPaths([])
+ this.loadPromisesByPath = {}
+ this.retiredBufferIDs = new Set()
+ this.retiredBufferPaths = new Set()
+ this.consumeServices(packageManager)
+ }
+
+ destroyUnretainedBuffers () {
+ for (let buffer of this.getBuffers()) {
+ if (!buffer.isRetained()) buffer.destroy()
+ }
+ }
+
+ /*
+ Section: Serialization
+ */
+
+ deserialize (state) {
+ this.retiredBufferIDs = new Set()
+ this.retiredBufferPaths = new Set()
+
+ const handleBufferState = (bufferState) => {
+ if (bufferState.shouldDestroyOnFileDelete == null) {
+ bufferState.shouldDestroyOnFileDelete = () => atom.config.get('core.closeDeletedFileTabs')
+ }
+
+ // Use a little guilty knowledge of the way TextBuffers are serialized.
+ // This allows TextBuffers that have never been saved (but have filePaths) to be deserialized, but prevents
+ // TextBuffers backed by files that have been deleted from being saved.
+ bufferState.mustExist = bufferState.digestWhenLastPersisted !== false
+
+ return TextBuffer.deserialize(bufferState).catch((_) => {
+ this.retiredBufferIDs.add(bufferState.id)
+ this.retiredBufferPaths.add(bufferState.filePath)
+ return null
+ })
+ }
+
+ const bufferPromises = []
+ for (let bufferState of state.buffers) {
+ bufferPromises.push(handleBufferState(bufferState))
+ }
+
+ return Promise.all(bufferPromises).then(buffers => {
+ this.buffers = buffers.filter(Boolean)
+ for (let buffer of this.buffers) {
+ this.subscribeToBuffer(buffer)
+ }
+ this.setPaths(state.paths || [], {mustExist: true, exact: true})
+ })
+ }
+
+ serialize (options = {}) {
+ return {
+ deserializer: 'Project',
+ paths: this.getPaths(),
+ buffers: _.compact(this.buffers.map(function (buffer) {
+ if (buffer.isRetained()) {
+ const isUnloading = options.isUnloading === true
+ return buffer.serialize({markerLayers: isUnloading, history: isUnloading})
+ }
+ }))
+ }
+ }
+
+ /*
+ Section: Event Subscription
+ */
+
+ // Public: Invoke the given callback when the project paths change.
+ //
+ // * `callback` {Function} to be called after the project paths change.
+ // * `projectPaths` An {Array} of {String} project paths.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidChangePaths (callback) {
+ return this.emitter.on('did-change-paths', callback)
+ }
+
+ // Public: Invoke the given callback when a text buffer is added to the
+ // project.
+ //
+ // * `callback` {Function} to be called when a text buffer is added.
+ // * `buffer` A {TextBuffer} item.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ onDidAddBuffer (callback) {
+ return this.emitter.on('did-add-buffer', callback)
+ }
+
+ // Public: Invoke the given callback with all current and future text
+ // buffers in the project.
+ //
+ // * `callback` {Function} to be called with current and future text buffers.
+ // * `buffer` A {TextBuffer} item.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+ observeBuffers (callback) {
+ for (let buffer of this.getBuffers()) { callback(buffer) }
+ return this.onDidAddBuffer(callback)
+ }
+
+ // Extended: Invoke a callback when a filesystem change occurs within any open
+ // project path.
+ //
+ // ```js
+ // const disposable = atom.project.onDidChangeFiles(events => {
+ // for (const event of events) {
+ // // "created", "modified", "deleted", or "renamed"
+ // console.log(`Event action: ${event.type}`)
+ //
+ // // absolute path to the filesystem entry that was touched
+ // console.log(`Event path: ${event.path}`)
+ //
+ // if (event.type === 'renamed') {
+ // console.log(`.. renamed from: ${event.oldPath}`)
+ // }
+ // }
+ // }
+ //
+ // disposable.dispose()
+ // ```
+ //
+ // To watch paths outside of open projects, use the `watchPaths` function instead; see {PathWatcher}.
+ //
+ // When writing tests against functionality that uses this method, be sure to wait for the
+ // {Promise} returned by {getWatcherPromise()} before manipulating the filesystem to ensure that
+ // the watcher is receiving events.
+ //
+ // * `callback` {Function} to be called with batches of filesystem events reported by
+ // the operating system.
+ // * `events` An {Array} of objects that describe a batch of filesystem events.
+ // * `action` {String} describing the filesystem action that occurred. One of `"created"`,
+ // `"modified"`, `"deleted"`, or `"renamed"`.
+ // * `path` {String} containing the absolute path to the filesystem entry
+ // that was acted upon.
+ // * `oldPath` For rename events, {String} containing the filesystem entry's
+ // former absolute path.
+ //
+ // Returns a {Disposable} to manage this event subscription.
+ onDidChangeFiles (callback) {
+ return this.emitter.on('did-change-files', callback)
+ }
+
+ /*
+ Section: Accessing the git repository
+ */
+
+ // Public: Get an {Array} of {GitRepository}s associated with the project's
+ // directories.
+ //
+ // This method will be removed in 2.0 because it does synchronous I/O.
+ // Prefer the following, which evaluates to a {Promise} that resolves to an
+ // {Array} of {Repository} objects:
+ // ```
+ // Promise.all(atom.project.getDirectories().map(
+ // atom.project.repositoryForDirectory.bind(atom.project)))
+ // ```
+ getRepositories () {
+ return this.repositories
+ }
+
+ // Public: Get the repository for a given directory asynchronously.
+ //
+ // * `directory` {Directory} for which to get a {Repository}.
+ //
+ // Returns a {Promise} that resolves with either:
+ // * {Repository} if a repository can be created for the given directory
+ // * `null` if no repository can be created for the given directory.
+ repositoryForDirectory (directory) {
+ const pathForDirectory = directory.getRealPathSync()
+ let promise = this.repositoryPromisesByPath.get(pathForDirectory)
+ if (!promise) {
+ const promises = this.repositoryProviders.map((provider) =>
+ provider.repositoryForDirectory(directory)
+ )
+ promise = Promise.all(promises).then((repositories) => {
+ const repo = repositories.find((repo) => repo != null) || null
+
+ // If no repository is found, remove the entry for the directory in
+ // @repositoryPromisesByPath in case some other RepositoryProvider is
+ // registered in the future that could supply a Repository for the
+ // directory.
+ if (repo == null) this.repositoryPromisesByPath.delete(pathForDirectory)
+
+ if (repo && repo.onDidDestroy) {
+ repo.onDidDestroy(() => this.repositoryPromisesByPath.delete(pathForDirectory))
+ }
+
+ return repo
+ })
+ this.repositoryPromisesByPath.set(pathForDirectory, promise)
+ }
+ return promise
+ }
+
+ /*
+ Section: Managing Paths
+ */
+
+ // Public: Get an {Array} of {String}s containing the paths of the project's
+ // directories.
+ getPaths () {
+ return this.rootDirectories.map((rootDirectory) => rootDirectory.getPath())
+ }
+
+ // Public: Set the paths of the project's directories.
+ //
+ // * `projectPaths` {Array} of {String} paths.
+ // * `options` An optional {Object} that may contain the following keys:
+ // * `mustExist` If `true`, throw an Error if any `projectPaths` do not exist. Any remaining `projectPaths` that
+ // do exist will still be added to the project. Default: `false`.
+ // * `exact` If `true`, only add a `projectPath` if it names an existing directory. If `false` and any `projectPath`
+ // is a file or does not exist, its parent directory will be added instead. Default: `false`.
+ setPaths (projectPaths, options = {}) {
+ for (let repository of this.repositories) {
+ if (repository != null) repository.destroy()
+ }
+ this.rootDirectories = []
+ this.repositories = []
+
+ for (let path in this.watcherPromisesByPath) {
+ this.watcherPromisesByPath[path].then(watcher => { watcher.dispose() })
+ }
+ this.watcherPromisesByPath = {}
+
+ const missingProjectPaths = []
+ for (let projectPath of projectPaths) {
+ try {
+ this.addPath(projectPath, {emitEvent: false, mustExist: true, exact: options.exact === true})
+ } catch (e) {
+ if (e.missingProjectPaths != null) {
+ missingProjectPaths.push(...e.missingProjectPaths)
+ } else {
+ throw e
+ }
+ }
+ }
+
+ this.emitter.emit('did-change-paths', projectPaths)
+
+ if ((options.mustExist === true) && (missingProjectPaths.length > 0)) {
+ const err = new Error('One or more project directories do not exist')
+ err.missingProjectPaths = missingProjectPaths
+ throw err
+ }
+ }
+
+ // Public: Add a path to the project's list of root paths
+ //
+ // * `projectPath` {String} The path to the directory to add.
+ // * `options` An optional {Object} that may contain the following keys:
+ // * `mustExist` If `true`, throw an Error if the `projectPath` does not exist. If `false`, a `projectPath` that does
+ // not exist is ignored. Default: `false`.
+ // * `exact` If `true`, only add `projectPath` if it names an existing directory. If `false`, if `projectPath` is a
+ // a file or does not exist, its parent directory will be added instead.
+ addPath (projectPath, options = {}) {
+ const directory = this.getDirectoryForProjectPath(projectPath)
+
+ let ok = true
+ if (options.exact === true) {
+ ok = (directory.getPath() === projectPath)
+ }
+ ok = ok && directory.existsSync()
+
+ if (!ok) {
+ if (options.mustExist === true) {
+ const err = new Error(`Project directory ${directory} does not exist`)
+ err.missingProjectPaths = [projectPath]
+ throw err
+ } else {
+ return
+ }
+ }
+
+ for (let existingDirectory of this.getDirectories()) {
+ if (existingDirectory.getPath() === directory.getPath()) { return }
+ }
+
+ this.rootDirectories.push(directory)
+ this.watcherPromisesByPath[directory.getPath()] = watchPath(directory.getPath(), {}, events => {
+ // Stop event delivery immediately on removal of a rootDirectory, even if its watcher
+ // promise has yet to resolve at the time of removal
+ if (this.rootDirectories.includes(directory)) {
+ this.emitter.emit('did-change-files', events)
+ }
+ })
+
+ for (let watchedPath in this.watcherPromisesByPath) {
+ if (!this.rootDirectories.find(dir => dir.getPath() === watchedPath)) {
+ this.watcherPromisesByPath[watchedPath].then(watcher => { watcher.dispose() })
+ }
+ }
+
+ let repo = null
+ for (let provider of this.repositoryProviders) {
+ if (provider.repositoryForDirectorySync) {
+ repo = provider.repositoryForDirectorySync(directory)
+ }
+ if (repo) { break }
+ }
+ this.repositories.push(repo != null ? repo : null)
+
+ if (options.emitEvent !== false) {
+ this.emitter.emit('did-change-paths', this.getPaths())
+ }
+ }
+
+ getDirectoryForProjectPath (projectPath) {
+ let directory = null
+ for (let provider of this.directoryProviders) {
+ if (typeof provider.directoryForURISync === 'function') {
+ directory = provider.directoryForURISync(projectPath)
+ if (directory) break
+ }
+ }
+ if (directory == null) {
+ directory = this.defaultDirectoryProvider.directoryForURISync(projectPath)
+ }
+ return directory
+ }
+
+ // Extended: Access a {Promise} that resolves when the filesystem watcher associated with a project
+ // root directory is ready to begin receiving events.
+ //
+ // This is especially useful in test cases, where it's important to know that the watcher is
+ // ready before manipulating the filesystem to produce events.
+ //
+ // * `projectPath` {String} One of the project's root directories.
+ //
+ // Returns a {Promise} that resolves with the {PathWatcher} associated with this project root
+ // once it has initialized and is ready to start sending events. The Promise will reject with
+ // an error instead if `projectPath` is not currently a root directory.
+ getWatcherPromise (projectPath) {
+ return this.watcherPromisesByPath[projectPath] ||
+ Promise.reject(new Error(`${projectPath} is not a project root`))
+ }
+
+ // Public: remove a path from the project's list of root paths.
+ //
+ // * `projectPath` {String} The path to remove.
+ removePath (projectPath) {
+ // The projectPath may be a URI, in which case it should not be normalized.
+ if (!this.getPaths().includes(projectPath)) {
+ projectPath = this.defaultDirectoryProvider.normalizePath(projectPath)
+ }
+
+ let indexToRemove = null
+ for (let i = 0; i < this.rootDirectories.length; i++) {
+ const directory = this.rootDirectories[i]
+ if (directory.getPath() === projectPath) {
+ indexToRemove = i
+ break
+ }
+ }
+
+ if (indexToRemove != null) {
+ this.rootDirectories.splice(indexToRemove, 1)
+ const [removedRepository] = this.repositories.splice(indexToRemove, 1)
+ if (!this.repositories.includes(removedRepository)) {
+ if (removedRepository) removedRepository.destroy()
+ }
+ if (this.watcherPromisesByPath[projectPath] != null) {
+ this.watcherPromisesByPath[projectPath].then(w => w.dispose())
+ }
+ delete this.watcherPromisesByPath[projectPath]
+ this.emitter.emit('did-change-paths', this.getPaths())
+ return true
+ } else {
+ return false
+ }
+ }
+
+ // Public: Get an {Array} of {Directory}s associated with this project.
+ getDirectories () {
+ return this.rootDirectories
+ }
+
+ resolvePath (uri) {
+ if (!uri) { return }
+
+ if (uri.match(/[A-Za-z0-9+-.]+:\/\//)) { // leave path alone if it has a scheme
+ return uri
+ } else {
+ let projectPath
+ if (fs.isAbsolute(uri)) {
+ return this.defaultDirectoryProvider.normalizePath(fs.resolveHome(uri))
+ // TODO: what should we do here when there are multiple directories?
+ } else if ((projectPath = this.getPaths()[0])) {
+ return this.defaultDirectoryProvider.normalizePath(fs.resolveHome(path.join(projectPath, uri)))
+ } else {
+ return undefined
+ }
+ }
+ }
+
+ relativize (fullPath) {
+ return this.relativizePath(fullPath)[1]
+ }
+
+ // Public: Get the path to the project directory that contains the given path,
+ // and the relative path from that project directory to the given path.
+ //
+ // * `fullPath` {String} An absolute path.
+ //
+ // Returns an {Array} with two elements:
+ // * `projectPath` The {String} path to the project directory that contains the
+ // given path, or `null` if none is found.
+ // * `relativePath` {String} The relative path from the project directory to
+ // the given path.
+ relativizePath (fullPath) {
+ let result = [null, fullPath]
+ if (fullPath != null) {
+ for (let rootDirectory of this.rootDirectories) {
+ const relativePath = rootDirectory.relativize(fullPath)
+ if ((relativePath != null) && (relativePath.length < result[1].length)) {
+ result = [rootDirectory.getPath(), relativePath]
+ }
+ }
+ }
+ return result
+ }
+
+ // Public: Determines whether the given path (real or symbolic) is inside the
+ // project's directory.
+ //
+ // This method does not actually check if the path exists, it just checks their
+ // locations relative to each other.
+ //
+ // ## Examples
+ //
+ // Basic operation
+ //
+ // ```coffee
+ // # Project's root directory is /foo/bar
+ // project.contains('/foo/bar/baz') # => true
+ // project.contains('/usr/lib/baz') # => false
+ // ```
+ //
+ // Existence of the path is not required
+ //
+ // ```coffee
+ // # Project's root directory is /foo/bar
+ // fs.existsSync('/foo/bar/baz') # => false
+ // project.contains('/foo/bar/baz') # => true
+ // ```
+ //
+ // * `pathToCheck` {String} path
+ //
+ // Returns whether the path is inside the project's root directory.
+ contains (pathToCheck) {
+ return this.rootDirectories.some(dir => dir.contains(pathToCheck))
+ }
+
+ /*
+ Section: Private
+ */
+
+ consumeServices ({serviceHub}) {
+ serviceHub.consume(
+ 'atom.directory-provider',
+ '^0.1.0',
+ provider => {
+ this.directoryProviders.unshift(provider)
+ return new Disposable(() => {
+ return this.directoryProviders.splice(this.directoryProviders.indexOf(provider), 1)
+ })
+ })
+
+ return serviceHub.consume(
+ 'atom.repository-provider',
+ '^0.1.0',
+ provider => {
+ this.repositoryProviders.unshift(provider)
+ if (this.repositories.includes(null)) { this.setPaths(this.getPaths()) }
+ return new Disposable(() => {
+ return this.repositoryProviders.splice(this.repositoryProviders.indexOf(provider), 1)
+ })
+ })
+ }
+
+ // Retrieves all the {TextBuffer}s in the project; that is, the
+ // buffers for all open files.
+ //
+ // Returns an {Array} of {TextBuffer}s.
+ getBuffers () {
+ return this.buffers.slice()
+ }
+
+ // Is the buffer for the given path modified?
+ isPathModified (filePath) {
+ const bufferForPath = this.findBufferForPath(this.resolvePath(filePath))
+ return bufferForPath && bufferForPath.isModified()
+ }
+
+ findBufferForPath (filePath) {
+ return _.find(this.buffers, buffer => buffer.getPath() === filePath)
+ }
+
+ findBufferForId (id) {
+ return _.find(this.buffers, buffer => buffer.getId() === id)
+ }
+
+ // Only to be used in specs
+ bufferForPathSync (filePath) {
+ const absoluteFilePath = this.resolvePath(filePath)
+ if (this.retiredBufferPaths.has(absoluteFilePath)) { return null }
+
+ let existingBuffer
+ if (filePath) { existingBuffer = this.findBufferForPath(absoluteFilePath) }
+ return existingBuffer != null ? existingBuffer : this.buildBufferSync(absoluteFilePath)
+ }
+
+ // Only to be used when deserializing
+ bufferForIdSync (id) {
+ if (this.retiredBufferIDs.has(id)) { return null }
+
+ let existingBuffer
+ if (id) { existingBuffer = this.findBufferForId(id) }
+ return existingBuffer != null ? existingBuffer : this.buildBufferSync()
+ }
+
+ // Given a file path, this retrieves or creates a new {TextBuffer}.
+ //
+ // If the `filePath` already has a `buffer`, that value is used instead. Otherwise,
+ // `text` is used as the contents of the new buffer.
+ //
+ // * `filePath` A {String} representing a path. If `null`, an "Untitled" buffer is created.
+ //
+ // Returns a {Promise} that resolves to the {TextBuffer}.
+ bufferForPath (absoluteFilePath) {
+ let existingBuffer
+ if (absoluteFilePath != null) { existingBuffer = this.findBufferForPath(absoluteFilePath) }
+ if (existingBuffer) {
+ return Promise.resolve(existingBuffer)
+ } else {
+ return this.buildBuffer(absoluteFilePath)
+ }
+ }
+
+ shouldDestroyBufferOnFileDelete () {
+ return atom.config.get('core.closeDeletedFileTabs')
+ }
+
+ // Still needed when deserializing a tokenized buffer
+ buildBufferSync (absoluteFilePath) {
+ const params = {shouldDestroyOnFileDelete: this.shouldDestroyBufferOnFileDelete}
+
+ let buffer
+ if (absoluteFilePath != null) {
+ buffer = TextBuffer.loadSync(absoluteFilePath, params)
+ } else {
+ buffer = new TextBuffer(params)
+ }
+ this.addBuffer(buffer)
+ return buffer
+ }
+
+ // Given a file path, this sets its {TextBuffer}.
+ //
+ // * `absoluteFilePath` A {String} representing a path.
+ // * `text` The {String} text to use as a buffer.
+ //
+ // Returns a {Promise} that resolves to the {TextBuffer}.
+ buildBuffer (absoluteFilePath) {
+ const params = {shouldDestroyOnFileDelete: this.shouldDestroyBufferOnFileDelete}
+
+ let promise
+ if (absoluteFilePath != null) {
+ if (this.loadPromisesByPath[absoluteFilePath] == null) {
+ this.loadPromisesByPath[absoluteFilePath] =
+ TextBuffer.load(absoluteFilePath, params).catch(error => {
+ delete this.loadPromisesByPath[absoluteFilePath]
+ throw error
+ })
+ }
+ promise = this.loadPromisesByPath[absoluteFilePath]
+ } else {
+ promise = Promise.resolve(new TextBuffer(params))
+ }
+ return promise.then(buffer => {
+ delete this.loadPromisesByPath[absoluteFilePath]
+ this.addBuffer(buffer)
+ return buffer
+ })
+ }
+
+ addBuffer (buffer, options = {}) {
+ return this.addBufferAtIndex(buffer, this.buffers.length, options)
+ }
+
+ addBufferAtIndex (buffer, index, options = {}) {
+ this.buffers.splice(index, 0, buffer)
+ this.subscribeToBuffer(buffer)
+ this.emitter.emit('did-add-buffer', buffer)
+ return buffer
+ }
+
+ // Removes a {TextBuffer} association from the project.
+ //
+ // Returns the removed {TextBuffer}.
+ removeBuffer (buffer) {
+ const index = this.buffers.indexOf(buffer)
+ if (index !== -1) { return this.removeBufferAtIndex(index) }
+ }
+
+ removeBufferAtIndex (index, options = {}) {
+ const [buffer] = this.buffers.splice(index, 1)
+ return (buffer != null ? buffer.destroy() : undefined)
+ }
+
+ eachBuffer (...args) {
+ let subscriber
+ if (args.length > 1) { subscriber = args.shift() }
+ const callback = args.shift()
+
+ for (let buffer of this.getBuffers()) { callback(buffer) }
+ if (subscriber) {
+ return subscriber.subscribe(this, 'buffer-created', buffer => callback(buffer))
+ } else {
+ return this.on('buffer-created', buffer => callback(buffer))
+ }
+ }
+
+ subscribeToBuffer (buffer) {
+ buffer.onWillSave(({path}) => this.applicationDelegate.emitWillSavePath(path))
+ buffer.onDidSave(({path}) => this.applicationDelegate.emitDidSavePath(path))
+ buffer.onDidDestroy(() => this.removeBuffer(buffer))
+ buffer.onDidChangePath(() => {
+ if (!(this.getPaths().length > 0)) {
+ this.setPaths([path.dirname(buffer.getPath())])
+ }
+ })
+ buffer.onWillThrowWatchError(({error, handle}) => {
+ handle()
+ const message =
+ `Unable to read file after file \`${error.eventType}\` event.` +
+ `Make sure you have permission to access \`${buffer.getPath()}\`.`
+ this.notificationManager.addWarning(message, {
+ detail: error.message,
+ dismissable: true
+ })
+ })
+ }
+}
diff --git a/src/protocol-handler-installer.js b/src/protocol-handler-installer.js
new file mode 100644
index 000000000..0a55bff41
--- /dev/null
+++ b/src/protocol-handler-installer.js
@@ -0,0 +1,92 @@
+const {remote} = require('electron')
+
+const SETTING = 'core.uriHandlerRegistration'
+const PROMPT = 'prompt'
+const ALWAYS = 'always'
+const NEVER = 'never'
+
+module.exports =
+class ProtocolHandlerInstaller {
+ isSupported () {
+ return ['win32', 'darwin'].includes(process.platform)
+ }
+
+ isDefaultProtocolClient () {
+ return remote.app.isDefaultProtocolClient('atom', process.execPath, ['--uri-handler'])
+ }
+
+ setAsDefaultProtocolClient () {
+ // This Electron API is only available on Windows and macOS. There might be some
+ // hacks to make it work on Linux; see https://github.com/electron/electron/issues/6440
+ return this.isSupported() && remote.app.setAsDefaultProtocolClient('atom', process.execPath, ['--uri-handler'])
+ }
+
+ initialize (config, notifications) {
+ if (!this.isSupported()) {
+ return
+ }
+
+ if (!this.isDefaultProtocolClient()) {
+ const behaviorWhenNotProtocolClient = config.get(SETTING)
+ switch (behaviorWhenNotProtocolClient) {
+ case PROMPT:
+ this.promptToBecomeProtocolClient(config, notifications)
+ break
+ case ALWAYS:
+ this.setAsDefaultProtocolClient()
+ break
+ case NEVER:
+ default:
+ // Do nothing
+ }
+ }
+ }
+
+ promptToBecomeProtocolClient (config, notifications) {
+ let notification
+
+ const withSetting = (value, fn) => {
+ return function () {
+ config.set(SETTING, value)
+ fn()
+ }
+ }
+
+ const accept = () => {
+ notification.dismiss()
+ this.setAsDefaultProtocolClient()
+ }
+ const decline = () => {
+ notification.dismiss()
+ }
+
+ notification = notifications.addInfo('Register as default atom:// URI handler?', {
+ dismissable: true,
+ icon: 'link',
+ description: 'Atom is not currently set as the defaut handler for atom:// URIs. Would you like Atom to handle ' +
+ 'atom:// URIs?',
+ buttons: [
+ {
+ text: 'Yes',
+ className: 'btn btn-info btn-primary',
+ onDidClick: accept
+ },
+ {
+ text: 'Yes, Always',
+ className: 'btn btn-info',
+ onDidClick: withSetting(ALWAYS, accept)
+ },
+ {
+ text: 'No',
+ className: 'btn btn-info',
+ onDidClick: decline
+ },
+ {
+ text: 'No, Never',
+ className: 'btn btn-info',
+ onDidClick: withSetting(NEVER, decline)
+ }
+ ]
+ })
+ }
+}
diff --git a/src/register-default-commands.coffee b/src/register-default-commands.coffee
index d5b741c40..7dc0d3298 100644
--- a/src/register-default-commands.coffee
+++ b/src/register-default-commands.coffee
@@ -174,6 +174,11 @@ module.exports = ({commandRegistry, commandInstaller, config, notificationManage
'core:cut': -> @cutSelectedText()
'core:copy': -> @copySelectedText()
'core:paste': -> @pasteText()
+ 'editor:paste-without-reformatting': -> @pasteText({
+ normalizeLineEndings: false,
+ autoIndent: false,
+ preserveTrailingLineIndentation: true
+ })
'editor:delete-to-previous-word-boundary': -> @deleteToPreviousWordBoundary()
'editor:delete-to-next-word-boundary': -> @deleteToNextWordBoundary()
'editor:delete-to-beginning-of-word': -> @deleteToBeginningOfWord()
diff --git a/src/repository-status-handler.coffee b/src/repository-status-handler.coffee
deleted file mode 100644
index 2fda9a335..000000000
--- a/src/repository-status-handler.coffee
+++ /dev/null
@@ -1,36 +0,0 @@
-Git = require 'git-utils'
-path = require 'path'
-
-module.exports = (repoPath, paths = []) ->
- repo = Git.open(repoPath)
-
- upstream = {}
- statuses = {}
- submodules = {}
- branch = null
-
- if repo?
- # Statuses in main repo
- workingDirectoryPath = repo.getWorkingDirectory()
- repoStatus = (if paths.length > 0 then repo.getStatusForPaths(paths) else repo.getStatus())
- for filePath, status of repoStatus
- statuses[filePath] = status
-
- # Statuses in submodules
- for submodulePath, submoduleRepo of repo.submodules
- submodules[submodulePath] =
- branch: submoduleRepo.getHead()
- upstream: submoduleRepo.getAheadBehindCount()
-
- workingDirectoryPath = submoduleRepo.getWorkingDirectory()
- for filePath, status of submoduleRepo.getStatus()
- absolutePath = path.join(workingDirectoryPath, filePath)
- # Make path relative to parent repository
- relativePath = repo.relativize(absolutePath)
- statuses[relativePath] = status
-
- upstream = repo.getAheadBehindCount()
- branch = repo.getHead()
- repo.release()
-
- {statuses, upstream, branch, submodules}
diff --git a/src/scope-descriptor.coffee b/src/scope-descriptor.coffee
index ca97a2a43..95539cc69 100644
--- a/src/scope-descriptor.coffee
+++ b/src/scope-descriptor.coffee
@@ -10,8 +10,8 @@
#
# You should not need to create a `ScopeDescriptor` directly.
#
-# * {Editor::getRootScopeDescriptor} to get the language's descriptor.
-# * {Editor::scopeDescriptorForBufferPosition} to get the descriptor at a
+# * {TextEditor::getRootScopeDescriptor} to get the language's descriptor.
+# * {TextEditor::scopeDescriptorForBufferPosition} to get the descriptor at a
# specific position in the buffer.
# * {Cursor::getScopeDescriptor} to get a cursor's descriptor based on position.
#
diff --git a/src/selection.coffee b/src/selection.coffee
index e361d0b5c..6fcf8dd36 100644
--- a/src/selection.coffee
+++ b/src/selection.coffee
@@ -356,13 +356,19 @@ class Selection extends Model
#
# * `text` A {String} representing the text to add
# * `options` (optional) {Object} with keys:
- # * `select` if `true`, selects the newly added text.
- # * `autoIndent` if `true`, indents all inserted text appropriately.
- # * `autoIndentNewline` if `true`, indent newline appropriately.
- # * `autoDecreaseIndent` if `true`, decreases indent level appropriately
+ # * `select` If `true`, selects the newly added text.
+ # * `autoIndent` If `true`, indents all inserted text appropriately.
+ # * `autoIndentNewline` If `true`, indent newline appropriately.
+ # * `autoDecreaseIndent` If `true`, decreases indent level appropriately
# (for example, when a closing bracket is inserted).
+ # * `preserveTrailingLineIndentation` By default, when pasting multiple
+ # lines, Atom attempts to preserve the relative indent level between the
+ # first line and trailing lines, even if the indent level of the first
+ # line has changed from the copied text. If this option is `true`, this
+ # behavior is suppressed.
+ # level between the first lines and the trailing lines.
# * `normalizeLineEndings` (optional) {Boolean} (default: true)
- # * `undo` if `skip`, skips the undo stack for this operation.
+ # * `undo` If `skip`, skips the undo stack for this operation.
insertText: (text, options={}) ->
oldBufferRange = @getBufferRange()
wasReversed = @isReversed()
@@ -373,7 +379,7 @@ class Selection extends Model
remainingLines = text.split('\n')
firstInsertedLine = remainingLines.shift()
- if options.indentBasis?
+ if options.indentBasis? and not options.preserveTrailingLineIndentation
indentAdjustment = @editor.indentLevelForLine(precedingText) - options.indentBasis
@adjustIndent(remainingLines, indentAdjustment)
@@ -381,7 +387,7 @@ class Selection extends Model
if options.autoIndent and textIsAutoIndentable and not NonWhitespaceRegExp.test(precedingText) and remainingLines.length > 0
autoIndentFirstLine = true
firstLine = precedingText + firstInsertedLine
- desiredIndentLevel = @editor.languageMode.suggestedIndentForLineAtBufferRow(oldBufferRange.start.row, firstLine)
+ desiredIndentLevel = @editor.tokenizedBuffer.suggestedIndentForLineAtBufferRow(oldBufferRange.start.row, firstLine)
indentAdjustment = desiredIndentLevel - @editor.indentLevelForLine(firstLine)
@adjustIndent(remainingLines, indentAdjustment)
diff --git a/src/text-editor-component.js b/src/text-editor-component.js
index 61868228b..641cdad02 100644
--- a/src/text-editor-component.js
+++ b/src/text-editor-component.js
@@ -117,7 +117,7 @@ class TextEditorComponent {
this.linesToMeasure = new Map()
this.extraRenderedScreenLines = new Map()
this.horizontalPositionsToMeasure = new Map() // Keys are rows with positions we want to measure, values are arrays of columns to measure
- this.horizontalPixelPositionsByScreenLineId = new Map() // Values are maps from column to horiontal pixel positions
+ this.horizontalPixelPositionsByScreenLineId = new Map() // Values are maps from column to horizontal pixel positions
this.blockDecorationsToMeasure = new Set()
this.blockDecorationsByElement = new WeakMap()
this.blockDecorationSentinel = document.createElement('div')
@@ -362,7 +362,7 @@ class TextEditorComponent {
this.requestHorizontalMeasurement(screenRange.start.row, screenRange.start.column)
this.requestHorizontalMeasurement(screenRange.end.row, screenRange.end.column)
}
- this.populateVisibleRowRange()
+ this.populateVisibleRowRange(this.getRenderedStartRow())
this.populateVisibleTiles()
this.queryScreenLinesToRender()
this.queryLongestLine()
@@ -804,7 +804,15 @@ class TextEditorComponent {
key: overlayProps.element,
overlayComponents: this.overlayComponents,
measuredDimensions: this.overlayDimensionsByElement.get(overlayProps.element),
- didResize: () => { this.updateSync() }
+ didResize: (overlayComponent) => {
+ this.updateOverlayToRender(overlayProps)
+ overlayComponent.update(Object.assign(
+ {
+ measuredDimensions: this.overlayDimensionsByElement.get(overlayProps.element)
+ },
+ overlayProps
+ ))
+ }
},
overlayProps
))
@@ -1153,9 +1161,11 @@ class TextEditorComponent {
}
addBlockDecorationToRender (decoration, screenRange, reversed) {
- const screenPosition = reversed ? screenRange.start : screenRange.end
- const tileStartRow = this.tileStartRowForRow(screenPosition.row)
- const screenLine = this.renderedScreenLines[screenPosition.row - this.getRenderedStartRow()]
+ const {row} = reversed ? screenRange.start : screenRange.end
+ if (row < this.getRenderedStartRow() || row >= this.getRenderedEndRow()) return
+
+ const tileStartRow = this.tileStartRowForRow(row)
+ const screenLine = this.renderedScreenLines[row - this.getRenderedStartRow()]
let decorationsByScreenLine = this.decorationsToRender.blocks.get(tileStartRow)
if (!decorationsByScreenLine) {
@@ -1337,42 +1347,47 @@ class TextEditorComponent {
})
}
+ updateOverlayToRender (decoration) {
+ const windowInnerHeight = this.getWindowInnerHeight()
+ const windowInnerWidth = this.getWindowInnerWidth()
+ const contentClientRect = this.refs.content.getBoundingClientRect()
+
+ const {element, screenPosition, avoidOverflow} = decoration
+ const {row, column} = screenPosition
+ let wrapperTop = contentClientRect.top + this.pixelPositionAfterBlocksForRow(row) + this.getLineHeight()
+ let wrapperLeft = contentClientRect.left + this.pixelLeftForRowAndColumn(row, column)
+ const clientRect = element.getBoundingClientRect()
+ this.overlayDimensionsByElement.set(element, clientRect)
+
+ if (avoidOverflow !== false) {
+ const computedStyle = window.getComputedStyle(element)
+ const elementTop = wrapperTop + parseInt(computedStyle.marginTop)
+ const elementBottom = elementTop + clientRect.height
+ const flippedElementTop = wrapperTop - this.getLineHeight() - clientRect.height - parseInt(computedStyle.marginBottom)
+ const elementLeft = wrapperLeft + parseInt(computedStyle.marginLeft)
+ const elementRight = elementLeft + clientRect.width
+
+ if (elementBottom > windowInnerHeight && flippedElementTop >= 0) {
+ wrapperTop -= (elementTop - flippedElementTop)
+ }
+ if (elementLeft < 0) {
+ wrapperLeft -= elementLeft
+ } else if (elementRight > windowInnerWidth) {
+ wrapperLeft -= (elementRight - windowInnerWidth)
+ }
+ }
+
+ decoration.pixelTop = Math.round(wrapperTop)
+ decoration.pixelLeft = Math.round(wrapperLeft)
+ }
+
updateOverlaysToRender () {
const overlayCount = this.decorationsToRender.overlays.length
if (overlayCount === 0) return null
- const windowInnerHeight = this.getWindowInnerHeight()
- const windowInnerWidth = this.getWindowInnerWidth()
- const contentClientRect = this.refs.content.getBoundingClientRect()
for (let i = 0; i < overlayCount; i++) {
const decoration = this.decorationsToRender.overlays[i]
- const {element, screenPosition, avoidOverflow} = decoration
- const {row, column} = screenPosition
- let wrapperTop = contentClientRect.top + this.pixelPositionAfterBlocksForRow(row) + this.getLineHeight()
- let wrapperLeft = contentClientRect.left + this.pixelLeftForRowAndColumn(row, column)
- const clientRect = element.getBoundingClientRect()
- this.overlayDimensionsByElement.set(element, clientRect)
-
- if (avoidOverflow !== false) {
- const computedStyle = window.getComputedStyle(element)
- const elementTop = wrapperTop + parseInt(computedStyle.marginTop)
- const elementBottom = elementTop + clientRect.height
- const flippedElementTop = wrapperTop - this.getLineHeight() - clientRect.height - parseInt(computedStyle.marginBottom)
- const elementLeft = wrapperLeft + parseInt(computedStyle.marginLeft)
- const elementRight = elementLeft + clientRect.width
-
- if (elementBottom > windowInnerHeight && flippedElementTop >= 0) {
- wrapperTop -= (elementTop - flippedElementTop)
- }
- if (elementLeft < 0) {
- wrapperLeft -= elementLeft
- } else if (elementRight > windowInnerWidth) {
- wrapperLeft -= (elementRight - windowInnerWidth)
- }
- }
-
- decoration.pixelTop = Math.round(wrapperTop)
- decoration.pixelLeft = Math.round(wrapperLeft)
+ this.updateOverlayToRender(decoration)
}
}
@@ -1401,6 +1416,9 @@ class TextEditorComponent {
if (this.isVisible()) {
this.didShow()
+
+ if (this.refs.verticalScrollbar) this.refs.verticalScrollbar.flushScrollPosition()
+ if (this.refs.horizontalScrollbar) this.refs.horizontalScrollbar.flushScrollPosition()
} else {
this.didHide()
}
@@ -1590,30 +1608,30 @@ class TextEditorComponent {
}
didTextInput (event) {
- if (!this.isInputEnabled()) return
-
- event.stopPropagation()
-
- // WARNING: If we call preventDefault on the input of a space character,
- // then the browser interprets the spacebar keypress as a page-down command,
- // causing spaces to scroll elements containing editors. This is impossible
- // to test.
- if (event.data !== ' ') event.preventDefault()
-
if (this.compositionCheckpoint) {
this.props.model.revertToCheckpoint(this.compositionCheckpoint)
this.compositionCheckpoint = null
}
- // If the input event is fired while the accented character menu is open it
- // means that the user has chosen one of the accented alternatives. Thus, we
- // will replace the original non accented character with the selected
- // alternative.
- if (this.accentedCharacterMenuIsOpen) {
- this.props.model.selectLeft()
- }
+ if (this.isInputEnabled()) {
+ event.stopPropagation()
- this.props.model.insertText(event.data, {groupUndo: true})
+ // WARNING: If we call preventDefault on the input of a space character,
+ // then the browser interprets the spacebar keypress as a page-down command,
+ // causing spaces to scroll elements containing editors. This is impossible
+ // to test.
+ if (event.data !== ' ') event.preventDefault()
+
+ // If the input event is fired while the accented character menu is open it
+ // means that the user has chosen one of the accented alternatives. Thus, we
+ // will replace the original non accented character with the selected
+ // alternative.
+ if (this.accentedCharacterMenuIsOpen) {
+ this.props.model.selectLeft()
+ }
+
+ this.props.model.insertText(event.data, {groupUndo: true})
+ }
}
// We need to get clever to detect when the accented character menu is
@@ -1633,6 +1651,11 @@ class TextEditorComponent {
// keypress, meaning we're *holding* the _same_ key we intially pressed.
// Got that?
didKeydown (event) {
+ // Stop dragging when user interacts with the keyboard. This prevents
+ // unwanted selections in the case edits are performed while selecting text
+ // at the same time.
+ if (this.stopDragging) this.stopDragging()
+
if (this.lastKeydownBeforeKeypress != null) {
if (this.lastKeydownBeforeKeypress.code === event.code) {
this.accentedCharacterMenuIsOpen = true
@@ -1761,22 +1784,22 @@ class TextEditorComponent {
if (existingSelection) {
if (model.hasMultipleCursors()) existingSelection.destroy()
} else {
- model.addCursorAtScreenPosition(screenPosition)
+ model.addCursorAtScreenPosition(screenPosition, {autoscroll: false})
}
} else {
if (shiftKey) {
- model.selectToScreenPosition(screenPosition)
+ model.selectToScreenPosition(screenPosition, {autoscroll: false})
} else {
- model.setCursorScreenPosition(screenPosition)
+ model.setCursorScreenPosition(screenPosition, {autoscroll: false})
}
}
break
case 2:
- if (addOrRemoveSelection) model.addCursorAtScreenPosition(screenPosition)
+ if (addOrRemoveSelection) model.addCursorAtScreenPosition(screenPosition, {autoscroll: false})
model.getLastSelection().selectWord({autoscroll: false})
break
case 3:
- if (addOrRemoveSelection) model.addCursorAtScreenPosition(screenPosition)
+ if (addOrRemoveSelection) model.addCursorAtScreenPosition(screenPosition, {autoscroll: false})
model.getLastSelection().selectLine(null, {autoscroll: false})
break
}
@@ -1857,7 +1880,6 @@ class TextEditorComponent {
handleMouseDragUntilMouseUp ({didDrag, didStopDragging}) {
let dragging = false
let lastMousemoveEvent
- let bufferWillChangeDisposable
const animationFrameLoop = () => {
window.requestAnimationFrame(() => {
@@ -1877,9 +1899,9 @@ class TextEditorComponent {
}
function didMouseUp () {
+ this.stopDragging = null
window.removeEventListener('mousemove', didMouseMove)
- window.removeEventListener('mouseup', didMouseUp)
- bufferWillChangeDisposable.dispose()
+ window.removeEventListener('mouseup', didMouseUp, {capture: true})
if (dragging) {
dragging = false
didStopDragging()
@@ -1888,10 +1910,7 @@ class TextEditorComponent {
window.addEventListener('mousemove', didMouseMove)
window.addEventListener('mouseup', didMouseUp, {capture: true})
- // Simulate a mouse-up event if the buffer is about to change. This prevents
- // unwanted selections when users perform edits while holding the left mouse
- // button at the same time.
- bufferWillChangeDisposable = this.props.model.getBuffer().onWillChange(didMouseUp)
+ this.stopDragging = didMouseUp
}
autoscrollOnMouseDrag ({clientX, clientY}, verticalOnly = false) {
@@ -2091,14 +2110,30 @@ class TextEditorComponent {
return marginInBaseCharacters * this.getBaseCharacterWidth()
}
+ // This method is called at the beginning of a frame render to relay any
+ // potential changes in the editor's width into the model before proceeding.
updateModelSoftWrapColumn () {
const {model} = this.props
const newEditorWidthInChars = this.getScrollContainerClientWidthInBaseCharacters()
if (newEditorWidthInChars !== model.getEditorWidthInChars()) {
this.suppressUpdates = true
+
+ const renderedStartRow = this.getRenderedStartRow()
this.props.model.setEditorWidthInChars(newEditorWidthInChars)
- // Wrapping may cause a vertical scrollbar to appear, which will change the width again.
+
+ // Relaying a change in to the editor's client width may cause the
+ // vertical scrollbar to appear or disappear, which causes the editor's
+ // client width to change *again*. Make sure the display layer is fully
+ // populated for the visible area before recalculating the editor's
+ // width in characters. Then update the display layer *again* just in
+ // case a change in scrollbar visibility causes lines to wrap
+ // differently. We capture the renderedStartRow before resetting the
+ // display layer because once it has been reset, we can't compute the
+ // rendered start row accurately. 😥
+ this.populateVisibleRowRange(renderedStartRow)
this.props.model.setEditorWidthInChars(this.getScrollContainerClientWidthInBaseCharacters())
+ this.derivedDimensionsCache = {}
+
this.suppressUpdates = false
}
}
@@ -2501,7 +2536,8 @@ class TextEditorComponent {
didUpdateDisposable.dispose()
didDestroyDisposable.dispose()
- if (marker.isValid()) {
+ if (wasValid) {
+ wasValid = false
this.blockDecorationsToMeasure.delete(decoration)
this.heightsByBlockDecoration.delete(decoration)
this.blockDecorationsByElement.delete(element)
@@ -2745,7 +2781,7 @@ class TextEditorComponent {
// but keeping this calculation simple ensures the number of tiles remains
// fixed for a given editor height, which eliminates situations where a
// tile is repeatedly added and removed during scrolling in certain
- // comibinations of editor height and line height.
+ // combinations of editor height and line height.
getVisibleTileCount () {
if (this.derivedDimensionsCache.visibleTileCount == null) {
const editorHeightInTiles = this.getScrollContainerHeight() / this.getLineHeight() / this.getRowsPerTile()
@@ -2862,13 +2898,19 @@ class TextEditorComponent {
}
}
- // Ensure the spatial index is populated with rows that are currently
- // visible so we *at least* get the longest row in the visible range.
- populateVisibleRowRange () {
- const editorHeightInTiles = this.getScrollContainerHeight() / this.getLineHeight()
- const visibleTileCount = Math.ceil(editorHeightInTiles) + 1
- const lastRenderedRow = this.getRenderedStartRow() + (visibleTileCount * this.getRowsPerTile())
- this.props.model.displayLayer.populateSpatialIndexIfNeeded(Infinity, lastRenderedRow)
+ // Ensure the spatial index is populated with rows that are currently visible
+ populateVisibleRowRange (renderedStartRow) {
+ const {model} = this.props
+ const previousScreenLineCount = model.getApproximateScreenLineCount()
+
+ const renderedEndRow = renderedStartRow + (this.getVisibleTileCount() * this.getRowsPerTile())
+ this.props.model.displayLayer.populateSpatialIndexIfNeeded(Infinity, renderedEndRow)
+
+ // If the approximate screen line count changes, previously-cached derived
+ // dimensions could now be out of date.
+ if (model.getApproximateScreenLineCount() !== previousScreenLineCount) {
+ this.derivedDimensionsCache = {}
+ }
}
populateVisibleTiles () {
@@ -4173,8 +4215,8 @@ class OverlayComponent {
const {contentRect} = entries[0]
if (contentRect.width !== this.props.measuredDimensions.width || contentRect.height !== this.props.measuredDimensions.height) {
this.resizeObserver.disconnect()
- this.props.didResize()
- process.nextTick(() => { this.resizeObserver.observe(this.element) })
+ this.props.didResize(this)
+ process.nextTick(() => { this.resizeObserver.observe(this.props.element) })
}
})
this.didAttach()
@@ -4186,19 +4228,34 @@ class OverlayComponent {
this.didDetach()
}
+ getNextUpdatePromise () {
+ if (!this.nextUpdatePromise) {
+ this.nextUpdatePromise = new Promise((resolve) => {
+ this.resolveNextUpdatePromise = () => {
+ this.nextUpdatePromise = null
+ this.resolveNextUpdatePromise = null
+ resolve()
+ }
+ })
+ }
+ return this.nextUpdatePromise
+ }
+
update (newProps) {
const oldProps = this.props
- this.props = newProps
+ this.props = Object.assign({}, oldProps, newProps)
if (this.props.pixelTop != null) this.element.style.top = this.props.pixelTop + 'px'
if (this.props.pixelLeft != null) this.element.style.left = this.props.pixelLeft + 'px'
if (newProps.className !== oldProps.className) {
if (oldProps.className != null) this.element.classList.remove(oldProps.className)
if (newProps.className != null) this.element.classList.add(newProps.className)
}
+
+ if (this.resolveNextUpdatePromise) this.resolveNextUpdatePromise()
}
didAttach () {
- this.resizeObserver.observe(this.element)
+ this.resizeObserver.observe(this.props.element)
}
didDetach () {
@@ -4307,7 +4364,7 @@ class NodePool {
}
if (element) {
- element.className = className
+ element.className = className || ''
element.styleMap.forEach((value, key) => {
if (!style || style[key] == null) element.style[key] = ''
})
diff --git a/src/text-editor-registry.js b/src/text-editor-registry.js
index 72aa8b364..d891a5868 100644
--- a/src/text-editor-registry.js
+++ b/src/text-editor-registry.js
@@ -18,6 +18,7 @@ const EDITOR_PARAMS_BY_SETTING_KEY = [
['editor.softWrapHangingIndent', 'softWrapHangingIndentLength'],
['editor.softWrapAtPreferredLineLength', 'softWrapAtPreferredLineLength'],
['editor.preferredLineLength', 'preferredLineLength'],
+ ['editor.maxScreenLineLength', 'maxScreenLineLength'],
['editor.autoIndent', 'autoIndent'],
['editor.autoIndentOnPaste', 'autoIndentOnPaste'],
['editor.scrollPastEnd', 'scrollPastEnd'],
@@ -287,7 +288,7 @@ export default class TextEditorRegistry {
let currentScore = this.editorGrammarScores.get(editor)
if (currentScore == null || score > currentScore) {
- editor.setGrammar(grammar, score)
+ editor.setGrammar(grammar)
this.editorGrammarScores.set(editor, score)
}
}
@@ -428,3 +429,5 @@ class ScopedSettingsDelegate {
}
}
}
+
+TextEditorRegistry.ScopedSettingsDelegate = ScopedSettingsDelegate
diff --git a/src/text-editor-utils.js b/src/text-editor-utils.js
new file mode 100644
index 000000000..ab1104144
--- /dev/null
+++ b/src/text-editor-utils.js
@@ -0,0 +1,139 @@
+// This file is temporary. We should gradually convert methods in `text-editor.coffee`
+// from CoffeeScript to JavaScript and move them here, so that we can eventually convert
+// the entire class to JavaScript.
+
+const {Point, Range} = require('text-buffer')
+
+const NON_WHITESPACE_REGEX = /\S/
+
+module.exports = {
+ toggleLineCommentsForBufferRows (start, end) {
+ let {
+ commentStartString,
+ commentEndString
+ } = this.tokenizedBuffer.commentStringsForPosition(Point(start, 0))
+ if (!commentStartString) return
+ commentStartString = commentStartString.trim()
+
+ if (commentEndString) {
+ commentEndString = commentEndString.trim()
+ const startDelimiterColumnRange = columnRangeForStartDelimiter(
+ this.buffer.lineForRow(start),
+ commentStartString
+ )
+ if (startDelimiterColumnRange) {
+ const endDelimiterColumnRange = columnRangeForEndDelimiter(
+ this.buffer.lineForRow(end),
+ commentEndString
+ )
+ if (endDelimiterColumnRange) {
+ this.buffer.transact(() => {
+ this.buffer.delete([[end, endDelimiterColumnRange[0]], [end, endDelimiterColumnRange[1]]])
+ this.buffer.delete([[start, startDelimiterColumnRange[0]], [start, startDelimiterColumnRange[1]]])
+ })
+ }
+ } else {
+ this.buffer.transact(() => {
+ const indentLength = this.buffer.lineForRow(start).match(/^\s*/)[0].length
+ this.buffer.insert([start, indentLength], commentStartString + ' ')
+ this.buffer.insert([end, this.buffer.lineLengthForRow(end)], ' ' + commentEndString)
+ })
+ }
+ } else {
+ let hasCommentedLines = false
+ let hasUncommentedLines = false
+ for (let row = start; row <= end; row++) {
+ const line = this.buffer.lineForRow(row)
+ if (NON_WHITESPACE_REGEX.test(line)) {
+ if (columnRangeForStartDelimiter(line, commentStartString)) {
+ hasCommentedLines = true
+ } else {
+ hasUncommentedLines = true
+ }
+ }
+ }
+
+ const shouldUncomment = hasCommentedLines && !hasUncommentedLines
+
+ if (shouldUncomment) {
+ for (let row = start; row <= end; row++) {
+ const columnRange = columnRangeForStartDelimiter(
+ this.buffer.lineForRow(row),
+ commentStartString
+ )
+ if (columnRange) this.buffer.delete([[row, columnRange[0]], [row, columnRange[1]]])
+ }
+ } else {
+ let minIndentLevel = Infinity
+ let minBlankIndentLevel = Infinity
+ for (let row = start; row <= end; row++) {
+ const line = this.buffer.lineForRow(row)
+ const indentLevel = this.indentLevelForLine(line)
+ if (NON_WHITESPACE_REGEX.test(line)) {
+ if (indentLevel < minIndentLevel) minIndentLevel = indentLevel
+ } else {
+ if (indentLevel < minBlankIndentLevel) minBlankIndentLevel = indentLevel
+ }
+ }
+ minIndentLevel = Number.isFinite(minIndentLevel)
+ ? minIndentLevel
+ : Number.isFinite(minBlankIndentLevel)
+ ? minBlankIndentLevel
+ : 0
+
+ const tabLength = this.getTabLength()
+ const indentString = ' '.repeat(tabLength * minIndentLevel)
+ for (let row = start; row <= end; row++) {
+ const line = this.buffer.lineForRow(row)
+ if (NON_WHITESPACE_REGEX.test(line)) {
+ const indentColumn = columnForIndentLevel(line, minIndentLevel, this.getTabLength())
+ this.buffer.insert(Point(row, indentColumn), commentStartString + ' ')
+ } else {
+ this.buffer.setTextInRange(
+ new Range(new Point(row, 0), new Point(row, Infinity)),
+ indentString + commentStartString + ' '
+ )
+ }
+ }
+ }
+ }
+ }
+}
+
+function columnForIndentLevel (line, indentLevel, tabLength) {
+ let column = 0
+ let indentLength = 0
+ const goalIndentLength = indentLevel * tabLength
+ while (indentLength < goalIndentLength) {
+ const char = line[column]
+ if (char === '\t') {
+ indentLength += tabLength - (indentLength % tabLength)
+ } else if (char === ' ') {
+ indentLength++
+ } else {
+ break
+ }
+ column++
+ }
+ return column
+}
+
+function columnRangeForStartDelimiter (line, delimiter) {
+ const startColumn = line.search(NON_WHITESPACE_REGEX)
+ if (startColumn === -1) return null
+ if (!line.startsWith(delimiter, startColumn)) return null
+
+ let endColumn = startColumn + delimiter.length
+ if (line[endColumn] === ' ') endColumn++
+ return [startColumn, endColumn]
+}
+
+function columnRangeForEndDelimiter (line, delimiter) {
+ let startColumn = line.lastIndexOf(delimiter)
+ if (startColumn === -1) return null
+
+ const endColumn = startColumn + delimiter.length
+ if (NON_WHITESPACE_REGEX.test(line.slice(endColumn))) return null
+ if (line[startColumn - 1] === ' ') startColumn--
+ return [startColumn, endColumn]
+}
diff --git a/src/text-editor.coffee b/src/text-editor.coffee
index 54de91054..1e3f9930d 100644
--- a/src/text-editor.coffee
+++ b/src/text-editor.coffee
@@ -4,20 +4,21 @@ fs = require 'fs-plus'
Grim = require 'grim'
{CompositeDisposable, Disposable, Emitter} = require 'event-kit'
{Point, Range} = TextBuffer = require 'text-buffer'
-LanguageMode = require './language-mode'
DecorationManager = require './decoration-manager'
TokenizedBuffer = require './tokenized-buffer'
Cursor = require './cursor'
Model = require './model'
Selection = require './selection'
+TextEditorUtils = require './text-editor-utils'
+
TextMateScopeSelector = require('first-mate').ScopeSelector
GutterContainer = require './gutter-container'
TextEditorComponent = null
TextEditorElement = null
{isDoubleWidthCharacter, isHalfWidthCharacter, isKoreanCharacter, isWrapBoundary} = require './text-utils'
+NON_WHITESPACE_REGEXP = /\S/
ZERO_WIDTH_NBSP = '\ufeff'
-MAX_SCREEN_LINE_LENGTH = 500
# Essential: This class represents all essential editing state for a single
# {TextBuffer}, including cursor and selection positions, folds, and soft wraps.
@@ -79,7 +80,6 @@ class TextEditor extends Model
serializationVersion: 1
buffer: null
- languageMode: null
cursors: null
showCursorOnSelection: null
selections: null
@@ -123,13 +123,20 @@ class TextEditor extends Model
this
)
+ Object.defineProperty(@prototype, 'languageMode', get: -> @tokenizedBuffer)
+
+ Object.assign(@prototype, TextEditorUtils)
+
@deserialize: (state, atomEnvironment) ->
# TODO: Return null on version mismatch when 1.8.0 has been out for a while
if state.version isnt @prototype.serializationVersion and state.displayBuffer?
state.tokenizedBuffer = state.displayBuffer.tokenizedBuffer
try
- state.tokenizedBuffer = TokenizedBuffer.deserialize(state.tokenizedBuffer, atomEnvironment)
+ tokenizedBuffer = TokenizedBuffer.deserialize(state.tokenizedBuffer, atomEnvironment)
+ return null unless tokenizedBuffer?
+
+ state.tokenizedBuffer = tokenizedBuffer
state.tabLength = state.tokenizedBuffer.getTabLength()
catch error
if error.syscall is 'read'
@@ -153,12 +160,12 @@ class TextEditor extends Model
{
@softTabs, @initialScrollTopRow, @initialScrollLeftColumn, initialLine, initialColumn, tabLength,
- @softWrapped, @decorationManager, @selectionsMarkerLayer, @buffer, suppressCursorCreation,
+ @decorationManager, @selectionsMarkerLayer, @buffer, suppressCursorCreation,
@mini, @placeholderText, lineNumberGutterVisible, @showLineNumbers, @largeFileMode,
@assert, grammar, @showInvisibles, @autoHeight, @autoWidth, @scrollPastEnd, @scrollSensitivity, @editorWidthInChars,
@tokenizedBuffer, @displayLayer, @invisibles, @showIndentGuide,
@softWrapped, @softWrapAtPreferredLineLength, @preferredLineLength,
- @showCursorOnSelection
+ @showCursorOnSelection, @maxScreenLineLength
} = params
@assert ?= (condition) -> condition
@@ -183,6 +190,7 @@ class TextEditor extends Model
@softWrapped ?= false
@softWrapAtPreferredLineLength ?= false
@preferredLineLength ?= 80
+ @maxScreenLineLength ?= 500
@showLineNumbers ?= true
@buffer ?= new TextBuffer({
@@ -240,8 +248,6 @@ class TextEditor extends Model
initialColumn = Math.max(parseInt(initialColumn) or 0, 0)
@addCursorAtBufferPosition([initialLine, initialColumn])
- @languageMode = new LanguageMode(this)
-
@gutterContainer = new GutterContainer(this)
@lineNumberGutter = @gutterContainer.addGutter
name: 'line-number'
@@ -323,6 +329,11 @@ class TextEditor extends Model
@preferredLineLength = value
displayLayerParams.softWrapColumn = @getSoftWrapColumn()
+ when 'maxScreenLineLength'
+ if value isnt @maxScreenLineLength
+ @maxScreenLineLength = value
+ displayLayerParams.softWrapColumn = @getSoftWrapColumn()
+
when 'mini'
if value isnt @mini
@mini = value
@@ -433,7 +444,7 @@ class TextEditor extends Model
softWrapHangingIndentLength: @displayLayer.softWrapHangingIndent
@id, @softTabs, @softWrapped, @softWrapAtPreferredLineLength,
- @preferredLineLength, @mini, @editorWidthInChars, @width, @largeFileMode,
+ @preferredLineLength, @mini, @editorWidthInChars, @width, @largeFileMode, @maxScreenLineLength,
@registered, @invisibles, @showInvisibles, @showIndentGuide, @autoHeight, @autoWidth
}
@@ -474,7 +485,6 @@ class TextEditor extends Model
@tokenizedBuffer.destroy()
selection.destroy() for selection in @selections.slice()
@buffer.release()
- @languageMode.destroy()
@gutterContainer.destroy()
@emitter.emit 'did-destroy'
@emitter.clear()
@@ -955,7 +965,7 @@ class TextEditor extends Model
# this editor.
shouldPromptToSave: ({windowCloseRequested, projectHasPaths}={}) ->
if windowCloseRequested and projectHasPaths and atom.stateStore.isConnected()
- false
+ @buffer.isInConflict()
else
@isModified() and not @buffer.hasMultipleEditors()
@@ -1223,7 +1233,7 @@ class TextEditor extends Model
@autoIndentSelectedRows() if @shouldAutoIndent()
@scrollToBufferPosition([newSelectionRanges[0].start.row, 0])
- # Move lines intersecting the most recent selection or muiltiple selections
+ # Move lines intersecting the most recent selection or multiple selections
# down by one row in screen coordinates.
moveLineDown: ->
selections = @getSelectedBufferRanges()
@@ -2202,7 +2212,7 @@ class TextEditor extends Model
#
# Returns a {Cursor}.
addCursorAtBufferPosition: (bufferPosition, options) ->
- @selectionsMarkerLayer.markBufferPosition(bufferPosition, Object.assign({invalidate: 'never'}, options))
+ @selectionsMarkerLayer.markBufferPosition(bufferPosition, {invalidate: 'never'})
@getLastSelection().cursor.autoscroll() unless options?.autoscroll is false
@getLastSelection().cursor
@@ -2510,7 +2520,7 @@ class TextEditor extends Model
# Essential: Select from the current cursor position to the given position in
# buffer coordinates.
#
- # This method may merge selections that end up intesecting.
+ # This method may merge selections that end up intersecting.
#
# * `position` An instance of {Point}, with a given `row` and `column`.
selectToBufferPosition: (position) ->
@@ -2521,7 +2531,7 @@ class TextEditor extends Model
# Essential: Select from the current cursor position to the given position in
# screen coordinates.
#
- # This method may merge selections that end up intesecting.
+ # This method may merge selections that end up intersecting.
#
# * `position` An instance of {Point}, with a given `row` and `column`.
selectToScreenPosition: (position, options) ->
@@ -2535,7 +2545,7 @@ class TextEditor extends Model
#
# * `rowCount` (optional) {Number} number of rows to select (default: 1)
#
- # This method may merge selections that end up intesecting.
+ # This method may merge selections that end up intersecting.
selectUp: (rowCount) ->
@expandSelectionsBackward (selection) -> selection.selectUp(rowCount)
@@ -2544,7 +2554,7 @@ class TextEditor extends Model
#
# * `rowCount` (optional) {Number} number of rows to select (default: 1)
#
- # This method may merge selections that end up intesecting.
+ # This method may merge selections that end up intersecting.
selectDown: (rowCount) ->
@expandSelectionsForward (selection) -> selection.selectDown(rowCount)
@@ -2553,7 +2563,7 @@ class TextEditor extends Model
#
# * `columnCount` (optional) {Number} number of columns to select (default: 1)
#
- # This method may merge selections that end up intesecting.
+ # This method may merge selections that end up intersecting.
selectLeft: (columnCount) ->
@expandSelectionsBackward (selection) -> selection.selectLeft(columnCount)
@@ -2562,7 +2572,7 @@ class TextEditor extends Model
#
# * `columnCount` (optional) {Number} number of columns to select (default: 1)
#
- # This method may merge selections that end up intesecting.
+ # This method may merge selections that end up intersecting.
selectRight: (columnCount) ->
@expandSelectionsForward (selection) -> selection.selectRight(columnCount)
@@ -2589,7 +2599,7 @@ class TextEditor extends Model
# Essential: Move the cursor of each selection to the beginning of its line
# while preserving the selection's tail position.
#
- # This method may merge selections that end up intesecting.
+ # This method may merge selections that end up intersecting.
selectToBeginningOfLine: ->
@expandSelectionsBackward (selection) -> selection.selectToBeginningOfLine()
@@ -3039,7 +3049,7 @@ class TextEditor extends Model
else
@getEditorWidthInChars()
else
- MAX_SCREEN_LINE_LENGTH
+ @maxScreenLineLength
###
Section: Indentation
@@ -3241,12 +3251,13 @@ class TextEditor extends Model
# corresponding clipboard selection text.
#
# * `options` (optional) See {Selection::insertText}.
- pasteText: (options={}) ->
+ pasteText: (options) ->
+ options = Object.assign({}, options)
{text: clipboardText, metadata} = @constructor.clipboard.readWithMetadata()
return false unless @emitWillInsertTextEvent(clipboardText)
metadata ?= {}
- options.autoIndent = @shouldAutoIndentOnPaste()
+ options.autoIndent ?= @shouldAutoIndentOnPaste()
@mutateSelectedText (selection, index) =>
if metadata.selections?.length is @getSelections().length
@@ -3303,13 +3314,15 @@ class TextEditor extends Model
# indentation level up to the nearest following row with a lower indentation
# level.
foldCurrentRow: ->
- bufferRow = @bufferPositionForScreenPosition(@getCursorScreenPosition()).row
- @foldBufferRow(bufferRow)
+ {row} = @getCursorBufferPosition()
+ if range = @tokenizedBuffer.getFoldableRangeContainingPoint(Point(row, Infinity))
+ @displayLayer.foldBufferRange(range)
# Essential: Unfold the most recent cursor's row by one level.
unfoldCurrentRow: ->
- bufferRow = @bufferPositionForScreenPosition(@getCursorScreenPosition()).row
- @unfoldBufferRow(bufferRow)
+ {row} = @getCursorBufferPosition()
+ position = Point(row, Infinity)
+ @displayLayer.destroyFoldsIntersectingBufferRange(Range(position, position))
# Essential: Fold the given row in buffer coordinates based on its indentation
# level.
@@ -3319,13 +3332,26 @@ class TextEditor extends Model
#
# * `bufferRow` A {Number}.
foldBufferRow: (bufferRow) ->
- @languageMode.foldBufferRow(bufferRow)
+ position = Point(bufferRow, Infinity)
+ loop
+ foldableRange = @tokenizedBuffer.getFoldableRangeContainingPoint(position, @getTabLength())
+ if foldableRange
+ existingFolds = @displayLayer.foldsIntersectingBufferRange(Range(foldableRange.start, foldableRange.start))
+ if existingFolds.length is 0
+ @displayLayer.foldBufferRange(foldableRange)
+ else
+ firstExistingFoldRange = @displayLayer.bufferRangeForFold(existingFolds[0])
+ if firstExistingFoldRange.start.isLessThan(position)
+ position = Point(firstExistingFoldRange.start.row, 0)
+ continue
+ return
# Essential: Unfold all folds containing the given row in buffer coordinates.
#
# * `bufferRow` A {Number}
unfoldBufferRow: (bufferRow) ->
- @displayLayer.destroyFoldsIntersectingBufferRange(Range(Point(bufferRow, 0), Point(bufferRow, Infinity)))
+ position = Point(bufferRow, Infinity)
+ @displayLayer.destroyFoldsIntersectingBufferRange(Range(position, position))
# Extended: For each selection, fold the rows it intersects.
foldSelectedLines: ->
@@ -3334,18 +3360,25 @@ class TextEditor extends Model
# Extended: Fold all foldable lines.
foldAll: ->
- @languageMode.foldAll()
+ @displayLayer.destroyAllFolds()
+ for range in @tokenizedBuffer.getFoldableRanges(@getTabLength())
+ @displayLayer.foldBufferRange(range)
+ return
# Extended: Unfold all existing folds.
unfoldAll: ->
- @languageMode.unfoldAll()
+ result = @displayLayer.destroyAllFolds()
@scrollToCursorPosition()
+ result
# Extended: Fold all foldable lines at the given indent level.
#
# * `level` A {Number}.
foldAllAtIndentLevel: (level) ->
- @languageMode.foldAllAtIndentLevel(level)
+ @displayLayer.destroyAllFolds()
+ for range in @tokenizedBuffer.getFoldableRangesAtIndentLevel(level, @getTabLength())
+ @displayLayer.foldBufferRange(range)
+ return
# Extended: Determine whether the given row in buffer coordinates is foldable.
#
@@ -3539,6 +3572,7 @@ class TextEditor extends Model
# for specific syntactic scopes. See the `ScopedSettingsDelegate` in
# `text-editor-registry.js` for an example implementation.
setScopedSettingsDelegate: (@scopedSettingsDelegate) ->
+ @tokenizedBuffer.scopedSettingsDelegate = this.scopedSettingsDelegate
# Experimental: Retrieve the {Object} that provides the editor with settings
# for specific syntactic scopes.
@@ -3592,21 +3626,6 @@ class TextEditor extends Model
getNonWordCharacters: (scopes) ->
@scopedSettingsDelegate?.getNonWordCharacters?(scopes) ? @nonWordCharacters
- getCommentStrings: (scopes) ->
- @scopedSettingsDelegate?.getCommentStrings?(scopes)
-
- getIncreaseIndentPattern: (scopes) ->
- @scopedSettingsDelegate?.getIncreaseIndentPattern?(scopes)
-
- getDecreaseIndentPattern: (scopes) ->
- @scopedSettingsDelegate?.getDecreaseIndentPattern?(scopes)
-
- getDecreaseNextIndentPattern: (scopes) ->
- @scopedSettingsDelegate?.getDecreaseNextIndentPattern?(scopes)
-
- getFoldEndPattern: (scopes) ->
- @scopedSettingsDelegate?.getFoldEndPattern?(scopes)
-
###
Section: Event Handlers
###
@@ -3842,14 +3861,49 @@ class TextEditor extends Model
Section: Language Mode Delegated Methods
###
- suggestedIndentForBufferRow: (bufferRow, options) -> @languageMode.suggestedIndentForBufferRow(bufferRow, options)
+ suggestedIndentForBufferRow: (bufferRow, options) -> @tokenizedBuffer.suggestedIndentForBufferRow(bufferRow, options)
- autoIndentBufferRow: (bufferRow, options) -> @languageMode.autoIndentBufferRow(bufferRow, options)
+ # Given a buffer row, indent it.
+ #
+ # * bufferRow - The row {Number}.
+ # * options - An options {Object} to pass through to {TextEditor::setIndentationForBufferRow}.
+ autoIndentBufferRow: (bufferRow, options) ->
+ indentLevel = @suggestedIndentForBufferRow(bufferRow, options)
+ @setIndentationForBufferRow(bufferRow, indentLevel, options)
- autoIndentBufferRows: (startRow, endRow) -> @languageMode.autoIndentBufferRows(startRow, endRow)
+ # Indents all the rows between two buffer row numbers.
+ #
+ # * startRow - The row {Number} to start at
+ # * endRow - The row {Number} to end at
+ autoIndentBufferRows: (startRow, endRow) ->
+ row = startRow
+ while row <= endRow
+ @autoIndentBufferRow(row)
+ row++
+ return
- autoDecreaseIndentForBufferRow: (bufferRow) -> @languageMode.autoDecreaseIndentForBufferRow(bufferRow)
+ autoDecreaseIndentForBufferRow: (bufferRow) ->
+ indentLevel = @tokenizedBuffer.suggestedIndentForEditedBufferRow(bufferRow)
+ @setIndentationForBufferRow(bufferRow, indentLevel) if indentLevel?
- toggleLineCommentForBufferRow: (row) -> @languageMode.toggleLineCommentsForBufferRow(row)
+ toggleLineCommentForBufferRow: (row) -> @toggleLineCommentsForBufferRows(row, row)
- toggleLineCommentsForBufferRows: (start, end) -> @languageMode.toggleLineCommentsForBufferRows(start, end)
+ rowRangeForParagraphAtBufferRow: (bufferRow) ->
+ return unless NON_WHITESPACE_REGEXP.test(@lineTextForBufferRow(bufferRow))
+
+ isCommented = @tokenizedBuffer.isRowCommented(bufferRow)
+
+ startRow = bufferRow
+ while startRow > 0
+ break unless NON_WHITESPACE_REGEXP.test(@lineTextForBufferRow(startRow - 1))
+ break if @tokenizedBuffer.isRowCommented(startRow - 1) isnt isCommented
+ startRow--
+
+ endRow = bufferRow
+ rowCount = @getLineCount()
+ while endRow < rowCount
+ break unless NON_WHITESPACE_REGEXP.test(@lineTextForBufferRow(endRow + 1))
+ break if @tokenizedBuffer.isRowCommented(endRow + 1) isnt isCommented
+ endRow++
+
+ new Range(new Point(startRow, 0), new Point(endRow, @buffer.lineLengthForRow(endRow)))
diff --git a/src/theme-manager.coffee b/src/theme-manager.coffee
index 0f019dbf0..d5a2cb0d1 100644
--- a/src/theme-manager.coffee
+++ b/src/theme-manager.coffee
@@ -127,7 +127,7 @@ class ThemeManager
# Resolve and apply the stylesheet specified by the path.
#
- # This supports both CSS and Less stylsheets.
+ # This supports both CSS and Less stylesheets.
#
# * `stylesheetPath` A {String} path to the stylesheet that can be an absolute
# path or a relative path that will be resolved against the load path.
@@ -142,8 +142,8 @@ class ThemeManager
throw new Error("Could not find a file at path '#{stylesheetPath}'")
unwatchUserStylesheet: ->
- @userStylsheetSubscriptions?.dispose()
- @userStylsheetSubscriptions = null
+ @userStylesheetSubscriptions?.dispose()
+ @userStylesheetSubscriptions = null
@userStylesheetFile = null
@userStyleSheetDisposable?.dispose()
@userStyleSheetDisposable = null
@@ -156,11 +156,11 @@ class ThemeManager
try
@userStylesheetFile = new File(userStylesheetPath)
- @userStylsheetSubscriptions = new CompositeDisposable()
+ @userStylesheetSubscriptions = new CompositeDisposable()
reloadStylesheet = => @loadUserStylesheet()
- @userStylsheetSubscriptions.add(@userStylesheetFile.onDidChange(reloadStylesheet))
- @userStylsheetSubscriptions.add(@userStylesheetFile.onDidRename(reloadStylesheet))
- @userStylsheetSubscriptions.add(@userStylesheetFile.onDidDelete(reloadStylesheet))
+ @userStylesheetSubscriptions.add(@userStylesheetFile.onDidChange(reloadStylesheet))
+ @userStylesheetSubscriptions.add(@userStylesheetFile.onDidRename(reloadStylesheet))
+ @userStylesheetSubscriptions.add(@userStylesheetFile.onDidDelete(reloadStylesheet))
catch error
message = """
Unable to watch path: `#{path.basename(userStylesheetPath)}`. Make sure
@@ -262,33 +262,31 @@ class ThemeManager
new Promise (resolve) =>
# @config.observe runs the callback once, then on subsequent changes.
@config.observe 'core.themes', =>
- @deactivateThemes()
+ @deactivateThemes().then =>
+ @warnForNonExistentThemes()
+ @refreshLessCache() # Update cache for packages in core.themes config
- @warnForNonExistentThemes()
+ promises = []
+ for themeName in @getEnabledThemeNames()
+ if @packageManager.resolvePackagePath(themeName)
+ promises.push(@packageManager.activatePackage(themeName))
+ else
+ console.warn("Failed to activate theme '#{themeName}' because it isn't installed.")
- @refreshLessCache() # Update cache for packages in core.themes config
-
- promises = []
- for themeName in @getEnabledThemeNames()
- if @packageManager.resolvePackagePath(themeName)
- promises.push(@packageManager.activatePackage(themeName))
- else
- console.warn("Failed to activate theme '#{themeName}' because it isn't installed.")
-
- Promise.all(promises).then =>
- @addActiveThemeClasses()
- @refreshLessCache() # Update cache again now that @getActiveThemes() is populated
- @loadUserStylesheet()
- @reloadBaseStylesheets()
- @initialLoadComplete = true
- @emitter.emit 'did-change-active-themes'
- resolve()
+ Promise.all(promises).then =>
+ @addActiveThemeClasses()
+ @refreshLessCache() # Update cache again now that @getActiveThemes() is populated
+ @loadUserStylesheet()
+ @reloadBaseStylesheets()
+ @initialLoadComplete = true
+ @emitter.emit 'did-change-active-themes'
+ resolve()
deactivateThemes: ->
@removeActiveThemeClasses()
@unwatchUserStylesheet()
- @packageManager.deactivatePackage(pack.name) for pack in @getActiveThemes()
- null
+ results = @getActiveThemes().map((pack) => @packageManager.deactivatePackage(pack.name))
+ Promise.all(results.filter((r) -> typeof r?.then is 'function'))
isInitialLoadComplete: -> @initialLoadComplete
diff --git a/src/tokenized-buffer.coffee b/src/tokenized-buffer.coffee
deleted file mode 100644
index 8fca6c06b..000000000
--- a/src/tokenized-buffer.coffee
+++ /dev/null
@@ -1,451 +0,0 @@
-_ = require 'underscore-plus'
-{CompositeDisposable, Emitter} = require 'event-kit'
-{Point, Range} = require 'text-buffer'
-Model = require './model'
-TokenizedLine = require './tokenized-line'
-TokenIterator = require './token-iterator'
-ScopeDescriptor = require './scope-descriptor'
-TokenizedBufferIterator = require './tokenized-buffer-iterator'
-NullGrammar = require './null-grammar'
-{toFirstMateScopeId} = require './first-mate-helpers'
-
-prefixedScopes = new Map()
-
-module.exports =
-class TokenizedBuffer extends Model
- grammar: null
- buffer: null
- tabLength: null
- tokenizedLines: null
- chunkSize: 50
- invalidRows: null
- visible: false
- changeCount: 0
-
- @deserialize: (state, atomEnvironment) ->
- if state.bufferId
- state.buffer = atomEnvironment.project.bufferForIdSync(state.bufferId)
- else
- # TODO: remove this fallback after everyone transitions to the latest version.
- state.buffer = atomEnvironment.project.bufferForPathSync(state.bufferPath)
- state.assert = atomEnvironment.assert
- new this(state)
-
- constructor: (params) ->
- {grammar, @buffer, @tabLength, @largeFileMode, @assert} = params
-
- @emitter = new Emitter
- @disposables = new CompositeDisposable
- @tokenIterator = new TokenIterator(this)
-
- @disposables.add @buffer.registerTextDecorationLayer(this)
-
- @setGrammar(grammar ? NullGrammar)
-
- destroyed: ->
- @disposables.dispose()
- @tokenizedLines.length = 0
-
- buildIterator: ->
- new TokenizedBufferIterator(this)
-
- classNameForScopeId: (id) ->
- scope = @grammar.scopeForId(toFirstMateScopeId(id))
- if scope
- prefixedScope = prefixedScopes.get(scope)
- if prefixedScope
- prefixedScope
- else
- prefixedScope = "syntax--#{scope.replace(/\./g, ' syntax--')}"
- prefixedScopes.set(scope, prefixedScope)
- prefixedScope
- else
- null
-
- getInvalidatedRanges: ->
- []
-
- onDidInvalidateRange: (fn) ->
- @emitter.on 'did-invalidate-range', fn
-
- serialize: ->
- {
- deserializer: 'TokenizedBuffer'
- bufferPath: @buffer.getPath()
- bufferId: @buffer.getId()
- tabLength: @tabLength
- largeFileMode: @largeFileMode
- }
-
- observeGrammar: (callback) ->
- callback(@grammar)
- @onDidChangeGrammar(callback)
-
- onDidChangeGrammar: (callback) ->
- @emitter.on 'did-change-grammar', callback
-
- onDidTokenize: (callback) ->
- @emitter.on 'did-tokenize', callback
-
- setGrammar: (grammar) ->
- return unless grammar? and grammar isnt @grammar
-
- @grammar = grammar
- @rootScopeDescriptor = new ScopeDescriptor(scopes: [@grammar.scopeName])
-
- @grammarUpdateDisposable?.dispose()
- @grammarUpdateDisposable = @grammar.onDidUpdate => @retokenizeLines()
- @disposables.add(@grammarUpdateDisposable)
-
- @retokenizeLines()
-
- @emitter.emit 'did-change-grammar', grammar
-
- getGrammarSelectionContent: ->
- @buffer.getTextInRange([[0, 0], [10, 0]])
-
- hasTokenForSelector: (selector) ->
- for tokenizedLine in @tokenizedLines when tokenizedLine?
- for token in tokenizedLine.tokens
- return true if selector.matches(token.scopes)
- false
-
- retokenizeLines: ->
- return unless @alive
- @fullyTokenized = false
- @tokenizedLines = new Array(@buffer.getLineCount())
- @invalidRows = []
- if @largeFileMode or @grammar.name is 'Null Grammar'
- @markTokenizationComplete()
- else
- @invalidateRow(0)
-
- setVisible: (@visible) ->
- if @visible and @grammar.name isnt 'Null Grammar' and not @largeFileMode
- @tokenizeInBackground()
-
- getTabLength: -> @tabLength
-
- setTabLength: (@tabLength) ->
-
- tokenizeInBackground: ->
- return if not @visible or @pendingChunk or not @isAlive()
-
- @pendingChunk = true
- _.defer =>
- @pendingChunk = false
- @tokenizeNextChunk() if @isAlive() and @buffer.isAlive()
-
- tokenizeNextChunk: ->
- rowsRemaining = @chunkSize
-
- while @firstInvalidRow()? and rowsRemaining > 0
- startRow = @invalidRows.shift()
- lastRow = @getLastRow()
- continue if startRow > lastRow
-
- row = startRow
- loop
- previousStack = @stackForRow(row)
- @tokenizedLines[row] = @buildTokenizedLineForRow(row, @stackForRow(row - 1), @openScopesForRow(row))
- if --rowsRemaining is 0
- filledRegion = false
- endRow = row
- break
- if row is lastRow or _.isEqual(@stackForRow(row), previousStack)
- filledRegion = true
- endRow = row
- break
- row++
-
- @validateRow(endRow)
- @invalidateRow(endRow + 1) unless filledRegion
-
- @emitter.emit 'did-invalidate-range', Range(Point(startRow, 0), Point(endRow + 1, 0))
-
- if @firstInvalidRow()?
- @tokenizeInBackground()
- else
- @markTokenizationComplete()
-
- markTokenizationComplete: ->
- unless @fullyTokenized
- @emitter.emit 'did-tokenize'
- @fullyTokenized = true
-
- firstInvalidRow: ->
- @invalidRows[0]
-
- validateRow: (row) ->
- @invalidRows.shift() while @invalidRows[0] <= row
- return
-
- invalidateRow: (row) ->
- @invalidRows.push(row)
- @invalidRows.sort (a, b) -> a - b
- @tokenizeInBackground()
-
- updateInvalidRows: (start, end, delta) ->
- @invalidRows = @invalidRows.map (row) ->
- if row < start
- row
- else if start <= row <= end
- end + delta + 1
- else if row > end
- row + delta
-
- bufferDidChange: (e) ->
- @changeCount = @buffer.changeCount
-
- {oldRange, newRange} = e
- start = oldRange.start.row
- end = oldRange.end.row
- delta = newRange.end.row - oldRange.end.row
- oldLineCount = oldRange.end.row - oldRange.start.row + 1
- newLineCount = newRange.end.row - newRange.start.row + 1
-
- @updateInvalidRows(start, end, delta)
- previousEndStack = @stackForRow(end) # used in spill detection below
- if @largeFileMode or @grammar.name is 'Null Grammar'
- _.spliceWithArray(@tokenizedLines, start, oldLineCount, new Array(newLineCount))
- else
- newTokenizedLines = @buildTokenizedLinesForRows(start, end + delta, @stackForRow(start - 1), @openScopesForRow(start))
- _.spliceWithArray(@tokenizedLines, start, oldLineCount, newTokenizedLines)
- newEndStack = @stackForRow(end + delta)
- if newEndStack and not _.isEqual(newEndStack, previousEndStack)
- @invalidateRow(end + delta + 1)
-
- isFoldableAtRow: (row) ->
- @isFoldableCodeAtRow(row) or @isFoldableCommentAtRow(row)
-
- # Returns a {Boolean} indicating whether the given buffer row starts
- # a a foldable row range due to the code's indentation patterns.
- isFoldableCodeAtRow: (row) ->
- if 0 <= row <= @buffer.getLastRow()
- nextRow = @buffer.nextNonBlankRow(row)
- tokenizedLine = @tokenizedLines[row]
- if @buffer.isRowBlank(row) or tokenizedLine?.isComment() or not nextRow?
- false
- else
- @indentLevelForRow(nextRow) > @indentLevelForRow(row)
- else
- false
-
- isFoldableCommentAtRow: (row) ->
- previousRow = row - 1
- nextRow = row + 1
- if nextRow > @buffer.getLastRow()
- false
- else
- Boolean(
- not (@tokenizedLines[previousRow]?.isComment()) and
- @tokenizedLines[row]?.isComment() and
- @tokenizedLines[nextRow]?.isComment()
- )
-
- buildTokenizedLinesForRows: (startRow, endRow, startingStack, startingopenScopes) ->
- ruleStack = startingStack
- openScopes = startingopenScopes
- stopTokenizingAt = startRow + @chunkSize
- tokenizedLines = for row in [startRow..endRow] by 1
- if (ruleStack or row is 0) and row < stopTokenizingAt
- tokenizedLine = @buildTokenizedLineForRow(row, ruleStack, openScopes)
- ruleStack = tokenizedLine.ruleStack
- openScopes = @scopesFromTags(openScopes, tokenizedLine.tags)
- else
- tokenizedLine = undefined
- tokenizedLine
-
- if endRow >= stopTokenizingAt
- @invalidateRow(stopTokenizingAt)
- @tokenizeInBackground()
-
- tokenizedLines
-
- buildTokenizedLineForRow: (row, ruleStack, openScopes) ->
- @buildTokenizedLineForRowWithText(row, @buffer.lineForRow(row), ruleStack, openScopes)
-
- buildTokenizedLineForRowWithText: (row, text, ruleStack = @stackForRow(row - 1), openScopes = @openScopesForRow(row)) ->
- lineEnding = @buffer.lineEndingForRow(row)
- {tags, ruleStack} = @grammar.tokenizeLine(text, ruleStack, row is 0, false)
- new TokenizedLine({openScopes, text, tags, ruleStack, lineEnding, @tokenIterator, @grammar})
-
- tokenizedLineForRow: (bufferRow) ->
- if 0 <= bufferRow <= @buffer.getLastRow()
- if tokenizedLine = @tokenizedLines[bufferRow]
- tokenizedLine
- else
- text = @buffer.lineForRow(bufferRow)
- lineEnding = @buffer.lineEndingForRow(bufferRow)
- tags = [@grammar.startIdForScope(@grammar.scopeName), text.length, @grammar.endIdForScope(@grammar.scopeName)]
- @tokenizedLines[bufferRow] = new TokenizedLine({openScopes: [], text, tags, lineEnding, @tokenIterator, @grammar})
-
- tokenizedLinesForRows: (startRow, endRow) ->
- for row in [startRow..endRow] by 1
- @tokenizedLineForRow(row)
-
- stackForRow: (bufferRow) ->
- @tokenizedLines[bufferRow]?.ruleStack
-
- openScopesForRow: (bufferRow) ->
- if precedingLine = @tokenizedLines[bufferRow - 1]
- @scopesFromTags(precedingLine.openScopes, precedingLine.tags)
- else
- []
-
- scopesFromTags: (startingScopes, tags) ->
- scopes = startingScopes.slice()
- for tag in tags when tag < 0
- if (tag % 2) is -1
- scopes.push(tag)
- else
- matchingStartTag = tag + 1
- loop
- break if scopes.pop() is matchingStartTag
- if scopes.length is 0
- @assert false, "Encountered an unmatched scope end tag.", (error) =>
- error.metadata = {
- grammarScopeName: @grammar.scopeName
- unmatchedEndTag: @grammar.scopeForId(tag)
- }
- path = require 'path'
- error.privateMetadataDescription = "The contents of `#{path.basename(@buffer.getPath())}`"
- error.privateMetadata = {
- filePath: @buffer.getPath()
- fileContents: @buffer.getText()
- }
- break
- scopes
-
- indentLevelForRow: (bufferRow) ->
- line = @buffer.lineForRow(bufferRow)
- indentLevel = 0
-
- if line is ''
- nextRow = bufferRow + 1
- lineCount = @getLineCount()
- while nextRow < lineCount
- nextLine = @buffer.lineForRow(nextRow)
- unless nextLine is ''
- indentLevel = Math.ceil(@indentLevelForLine(nextLine))
- break
- nextRow++
-
- previousRow = bufferRow - 1
- while previousRow >= 0
- previousLine = @buffer.lineForRow(previousRow)
- unless previousLine is ''
- indentLevel = Math.max(Math.ceil(@indentLevelForLine(previousLine)), indentLevel)
- break
- previousRow--
-
- indentLevel
- else
- @indentLevelForLine(line)
-
- indentLevelForLine: (line) ->
- indentLength = 0
- for char in line
- if char is '\t'
- indentLength += @getTabLength() - (indentLength % @getTabLength())
- else if char is ' '
- indentLength++
- else
- break
-
- indentLength / @getTabLength()
-
- scopeDescriptorForPosition: (position) ->
- {row, column} = @buffer.clipPosition(Point.fromObject(position))
-
- iterator = @tokenizedLineForRow(row).getTokenIterator()
- while iterator.next()
- if iterator.getBufferEnd() > column
- scopes = iterator.getScopes()
- break
-
- # rebuild scope of last token if we iterated off the end
- unless scopes?
- scopes = iterator.getScopes()
- scopes.push(iterator.getScopeEnds().reverse()...)
-
- new ScopeDescriptor({scopes})
-
- tokenForPosition: (position) ->
- {row, column} = Point.fromObject(position)
- @tokenizedLineForRow(row).tokenAtBufferColumn(column)
-
- tokenStartPositionForPosition: (position) ->
- {row, column} = Point.fromObject(position)
- column = @tokenizedLineForRow(row).tokenStartColumnForBufferColumn(column)
- new Point(row, column)
-
- bufferRangeForScopeAtPosition: (selector, position) ->
- position = Point.fromObject(position)
-
- {openScopes, tags} = @tokenizedLineForRow(position.row)
- scopes = openScopes.map (tag) => @grammar.scopeForId(tag)
-
- startColumn = 0
- for tag, tokenIndex in tags
- if tag < 0
- if tag % 2 is -1
- scopes.push(@grammar.scopeForId(tag))
- else
- scopes.pop()
- else
- endColumn = startColumn + tag
- if endColumn >= position.column
- break
- else
- startColumn = endColumn
-
-
- return unless selectorMatchesAnyScope(selector, scopes)
-
- startScopes = scopes.slice()
- for startTokenIndex in [(tokenIndex - 1)..0] by -1
- tag = tags[startTokenIndex]
- if tag < 0
- if tag % 2 is -1
- startScopes.pop()
- else
- startScopes.push(@grammar.scopeForId(tag))
- else
- break unless selectorMatchesAnyScope(selector, startScopes)
- startColumn -= tag
-
- endScopes = scopes.slice()
- for endTokenIndex in [(tokenIndex + 1)...tags.length] by 1
- tag = tags[endTokenIndex]
- if tag < 0
- if tag % 2 is -1
- endScopes.push(@grammar.scopeForId(tag))
- else
- endScopes.pop()
- else
- break unless selectorMatchesAnyScope(selector, endScopes)
- endColumn += tag
-
- new Range(new Point(position.row, startColumn), new Point(position.row, endColumn))
-
- # Gets the row number of the last line.
- #
- # Returns a {Number}.
- getLastRow: ->
- @buffer.getLastRow()
-
- getLineCount: ->
- @buffer.getLineCount()
-
- logLines: (start=0, end=@buffer.getLastRow()) ->
- for row in [start..end]
- line = @tokenizedLines[row].text
- console.log row, line, line.length
- return
-
-selectorMatchesAnyScope = (selector, scopes) ->
- targetClasses = selector.replace(/^\./, '').split('.')
- _.any scopes, (scope) ->
- scopeClasses = scope.split('.')
- _.isSubset(targetClasses, scopeClasses)
diff --git a/src/tokenized-buffer.js b/src/tokenized-buffer.js
new file mode 100644
index 000000000..2a9446256
--- /dev/null
+++ b/src/tokenized-buffer.js
@@ -0,0 +1,764 @@
+const _ = require('underscore-plus')
+const {CompositeDisposable, Emitter} = require('event-kit')
+const {Point, Range} = require('text-buffer')
+const TokenizedLine = require('./tokenized-line')
+const TokenIterator = require('./token-iterator')
+const ScopeDescriptor = require('./scope-descriptor')
+const TokenizedBufferIterator = require('./tokenized-buffer-iterator')
+const NullGrammar = require('./null-grammar')
+const {OnigRegExp} = require('oniguruma')
+const {toFirstMateScopeId} = require('./first-mate-helpers')
+
+const NON_WHITESPACE_REGEX = /\S/
+
+let nextId = 0
+const prefixedScopes = new Map()
+
+module.exports =
+class TokenizedBuffer {
+ static deserialize (state, atomEnvironment) {
+ const buffer = atomEnvironment.project.bufferForIdSync(state.bufferId)
+ if (!buffer) return null
+
+ state.buffer = buffer
+ state.assert = atomEnvironment.assert
+ return new TokenizedBuffer(state)
+ }
+
+ constructor (params) {
+ this.emitter = new Emitter()
+ this.disposables = new CompositeDisposable()
+ this.tokenIterator = new TokenIterator(this)
+ this.regexesByPattern = {}
+
+ this.alive = true
+ this.visible = false
+ this.id = params.id != null ? params.id : nextId++
+ this.buffer = params.buffer
+ this.tabLength = params.tabLength
+ this.largeFileMode = params.largeFileMode
+ this.assert = params.assert
+ this.scopedSettingsDelegate = params.scopedSettingsDelegate
+
+ this.setGrammar(params.grammar || NullGrammar)
+ this.disposables.add(this.buffer.registerTextDecorationLayer(this))
+ }
+
+ destroy () {
+ if (!this.alive) return
+ this.alive = false
+ this.disposables.dispose()
+ this.tokenizedLines.length = 0
+ }
+
+ isAlive () {
+ return this.alive
+ }
+
+ isDestroyed () {
+ return !this.alive
+ }
+
+ /*
+ Section - auto-indent
+ */
+
+ // Get the suggested indentation level for an existing line in the buffer.
+ //
+ // * bufferRow - A {Number} indicating the buffer row
+ //
+ // Returns a {Number}.
+ suggestedIndentForBufferRow (bufferRow, options) {
+ const line = this.buffer.lineForRow(bufferRow)
+ const tokenizedLine = this.tokenizedLineForRow(bufferRow)
+ return this._suggestedIndentForTokenizedLineAtBufferRow(bufferRow, line, tokenizedLine, options)
+ }
+
+ // Get the suggested indentation level for a given line of text, if it were inserted at the given
+ // row in the buffer.
+ //
+ // * bufferRow - A {Number} indicating the buffer row
+ //
+ // Returns a {Number}.
+ suggestedIndentForLineAtBufferRow (bufferRow, line, options) {
+ const tokenizedLine = this.buildTokenizedLineForRowWithText(bufferRow, line)
+ return this._suggestedIndentForTokenizedLineAtBufferRow(bufferRow, line, tokenizedLine, options)
+ }
+
+ // Get the suggested indentation level for a line in the buffer on which the user is currently
+ // typing. This may return a different result from {::suggestedIndentForBufferRow} in order
+ // to avoid unexpected changes in indentation. It may also return undefined if no change should
+ // be made.
+ //
+ // * bufferRow - The row {Number}
+ //
+ // Returns a {Number}.
+ suggestedIndentForEditedBufferRow (bufferRow) {
+ const line = this.buffer.lineForRow(bufferRow)
+ const currentIndentLevel = this.indentLevelForLine(line)
+ if (currentIndentLevel === 0) return
+
+ const scopeDescriptor = this.scopeDescriptorForPosition([bufferRow, 0])
+ const decreaseIndentRegex = this.decreaseIndentRegexForScopeDescriptor(scopeDescriptor)
+ if (!decreaseIndentRegex) return
+
+ if (!decreaseIndentRegex.testSync(line)) return
+
+ const precedingRow = this.buffer.previousNonBlankRow(bufferRow)
+ if (precedingRow == null) return
+
+ const precedingLine = this.buffer.lineForRow(precedingRow)
+ let desiredIndentLevel = this.indentLevelForLine(precedingLine)
+
+ const increaseIndentRegex = this.increaseIndentRegexForScopeDescriptor(scopeDescriptor)
+ if (increaseIndentRegex) {
+ if (!increaseIndentRegex.testSync(precedingLine)) desiredIndentLevel -= 1
+ }
+
+ const decreaseNextIndentRegex = this.decreaseNextIndentRegexForScopeDescriptor(scopeDescriptor)
+ if (decreaseNextIndentRegex) {
+ if (decreaseNextIndentRegex.testSync(precedingLine)) desiredIndentLevel -= 1
+ }
+
+ if (desiredIndentLevel < 0) return 0
+ if (desiredIndentLevel >= currentIndentLevel) return
+ return desiredIndentLevel
+ }
+
+ _suggestedIndentForTokenizedLineAtBufferRow (bufferRow, line, tokenizedLine, options) {
+ const iterator = tokenizedLine.getTokenIterator()
+ iterator.next()
+ const scopeDescriptor = new ScopeDescriptor({scopes: iterator.getScopes()})
+
+ const increaseIndentRegex = this.increaseIndentRegexForScopeDescriptor(scopeDescriptor)
+ const decreaseIndentRegex = this.decreaseIndentRegexForScopeDescriptor(scopeDescriptor)
+ const decreaseNextIndentRegex = this.decreaseNextIndentRegexForScopeDescriptor(scopeDescriptor)
+
+ let precedingRow
+ if (!options || options.skipBlankLines !== false) {
+ precedingRow = this.buffer.previousNonBlankRow(bufferRow)
+ if (precedingRow == null) return 0
+ } else {
+ precedingRow = bufferRow - 1
+ if (precedingRow < 0) return 0
+ }
+
+ const precedingLine = this.buffer.lineForRow(precedingRow)
+ let desiredIndentLevel = this.indentLevelForLine(precedingLine)
+ if (!increaseIndentRegex) return desiredIndentLevel
+
+ if (!this.isRowCommented(precedingRow)) {
+ if (increaseIndentRegex && increaseIndentRegex.testSync(precedingLine)) desiredIndentLevel += 1
+ if (decreaseNextIndentRegex && decreaseNextIndentRegex.testSync(precedingLine)) desiredIndentLevel -= 1
+ }
+
+ if (!this.buffer.isRowBlank(precedingRow)) {
+ if (decreaseIndentRegex && decreaseIndentRegex.testSync(line)) desiredIndentLevel -= 1
+ }
+
+ return Math.max(desiredIndentLevel, 0)
+ }
+
+ /*
+ Section - Comments
+ */
+
+ commentStringsForPosition (position) {
+ if (this.scopedSettingsDelegate) {
+ const scope = this.scopeDescriptorForPosition(position)
+ return this.scopedSettingsDelegate.getCommentStrings(scope)
+ } else {
+ return {}
+ }
+ }
+
+ buildIterator () {
+ return new TokenizedBufferIterator(this)
+ }
+
+ classNameForScopeId (id) {
+ const scope = this.grammar.scopeForId(toFirstMateScopeId(id))
+ if (scope) {
+ let prefixedScope = prefixedScopes.get(scope)
+ if (prefixedScope) {
+ return prefixedScope
+ } else {
+ prefixedScope = `syntax--${scope.replace(/\./g, ' syntax--')}`
+ prefixedScopes.set(scope, prefixedScope)
+ return prefixedScope
+ }
+ } else {
+ return null
+ }
+ }
+
+ getInvalidatedRanges () {
+ return []
+ }
+
+ onDidInvalidateRange (fn) {
+ return this.emitter.on('did-invalidate-range', fn)
+ }
+
+ serialize () {
+ return {
+ deserializer: 'TokenizedBuffer',
+ bufferPath: this.buffer.getPath(),
+ bufferId: this.buffer.getId(),
+ tabLength: this.tabLength,
+ largeFileMode: this.largeFileMode
+ }
+ }
+
+ observeGrammar (callback) {
+ callback(this.grammar)
+ return this.onDidChangeGrammar(callback)
+ }
+
+ onDidChangeGrammar (callback) {
+ return this.emitter.on('did-change-grammar', callback)
+ }
+
+ onDidTokenize (callback) {
+ return this.emitter.on('did-tokenize', callback)
+ }
+
+ setGrammar (grammar) {
+ if (!grammar || grammar === this.grammar) return
+
+ this.grammar = grammar
+ this.rootScopeDescriptor = new ScopeDescriptor({scopes: [this.grammar.scopeName]})
+
+ if (this.grammarUpdateDisposable) this.grammarUpdateDisposable.dispose()
+ this.grammarUpdateDisposable = this.grammar.onDidUpdate(() => this.retokenizeLines())
+ this.disposables.add(this.grammarUpdateDisposable)
+
+ this.retokenizeLines()
+ this.emitter.emit('did-change-grammar', grammar)
+ }
+
+ getGrammarSelectionContent () {
+ return this.buffer.getTextInRange([[0, 0], [10, 0]])
+ }
+
+ hasTokenForSelector (selector) {
+ for (const tokenizedLine of this.tokenizedLines) {
+ if (tokenizedLine) {
+ for (let token of tokenizedLine.tokens) {
+ if (selector.matches(token.scopes)) return true
+ }
+ }
+ }
+ return false
+ }
+
+ retokenizeLines () {
+ if (!this.alive) return
+ this.fullyTokenized = false
+ this.tokenizedLines = new Array(this.buffer.getLineCount())
+ this.invalidRows = []
+ if (this.largeFileMode || this.grammar.name === 'Null Grammar') {
+ this.markTokenizationComplete()
+ } else {
+ this.invalidateRow(0)
+ }
+ }
+
+ setVisible (visible) {
+ this.visible = visible
+ if (this.visible && this.grammar.name !== 'Null Grammar' && !this.largeFileMode) {
+ this.tokenizeInBackground()
+ }
+ }
+
+ getTabLength () { return this.tabLength }
+
+ setTabLength (tabLength) {
+ this.tabLength = tabLength
+ }
+
+ tokenizeInBackground () {
+ if (!this.visible || this.pendingChunk || !this.alive) return
+
+ this.pendingChunk = true
+ _.defer(() => {
+ this.pendingChunk = false
+ if (this.isAlive() && this.buffer.isAlive()) this.tokenizeNextChunk()
+ })
+ }
+
+ tokenizeNextChunk () {
+ let rowsRemaining = this.chunkSize
+
+ while (this.firstInvalidRow() != null && rowsRemaining > 0) {
+ var endRow, filledRegion
+ const startRow = this.invalidRows.shift()
+ const lastRow = this.buffer.getLastRow()
+ if (startRow > lastRow) continue
+
+ let row = startRow
+ while (true) {
+ const previousStack = this.stackForRow(row)
+ this.tokenizedLines[row] = this.buildTokenizedLineForRow(row, this.stackForRow(row - 1), this.openScopesForRow(row))
+ if (--rowsRemaining === 0) {
+ filledRegion = false
+ endRow = row
+ break
+ }
+ if (row === lastRow || _.isEqual(this.stackForRow(row), previousStack)) {
+ filledRegion = true
+ endRow = row
+ break
+ }
+ row++
+ }
+
+ this.validateRow(endRow)
+ if (!filledRegion) this.invalidateRow(endRow + 1)
+
+ this.emitter.emit('did-invalidate-range', Range(Point(startRow, 0), Point(endRow + 1, 0)))
+ }
+
+ if (this.firstInvalidRow() != null) {
+ this.tokenizeInBackground()
+ } else {
+ this.markTokenizationComplete()
+ }
+ }
+
+ markTokenizationComplete () {
+ if (!this.fullyTokenized) {
+ this.emitter.emit('did-tokenize')
+ }
+ this.fullyTokenized = true
+ }
+
+ firstInvalidRow () {
+ return this.invalidRows[0]
+ }
+
+ validateRow (row) {
+ while (this.invalidRows[0] <= row) this.invalidRows.shift()
+ }
+
+ invalidateRow (row) {
+ this.invalidRows.push(row)
+ this.invalidRows.sort((a, b) => a - b)
+ this.tokenizeInBackground()
+ }
+
+ updateInvalidRows (start, end, delta) {
+ this.invalidRows = this.invalidRows.map((row) => {
+ if (row < start) {
+ return row
+ } else if (start <= row && row <= end) {
+ return end + delta + 1
+ } else if (row > end) {
+ return row + delta
+ }
+ })
+ }
+
+ bufferDidChange (e) {
+ this.changeCount = this.buffer.changeCount
+
+ const {oldRange, newRange} = e
+ const start = oldRange.start.row
+ const end = oldRange.end.row
+ const delta = newRange.end.row - oldRange.end.row
+ const oldLineCount = (oldRange.end.row - oldRange.start.row) + 1
+ const newLineCount = (newRange.end.row - newRange.start.row) + 1
+
+ this.updateInvalidRows(start, end, delta)
+ const previousEndStack = this.stackForRow(end) // used in spill detection below
+ if (this.largeFileMode || (this.grammar.name === 'Null Grammar')) {
+ _.spliceWithArray(this.tokenizedLines, start, oldLineCount, new Array(newLineCount))
+ } else {
+ const newTokenizedLines = this.buildTokenizedLinesForRows(start, end + delta, this.stackForRow(start - 1), this.openScopesForRow(start))
+ _.spliceWithArray(this.tokenizedLines, start, oldLineCount, newTokenizedLines)
+ const newEndStack = this.stackForRow(end + delta)
+ if (newEndStack && !_.isEqual(newEndStack, previousEndStack)) {
+ this.invalidateRow(end + delta + 1)
+ }
+ }
+ }
+
+ isFoldableAtRow (row) {
+ return this.endRowForFoldAtRow(row, 1, true) != null
+ }
+
+ buildTokenizedLinesForRows (startRow, endRow, startingStack, startingopenScopes) {
+ let ruleStack = startingStack
+ let openScopes = startingopenScopes
+ const stopTokenizingAt = startRow + this.chunkSize
+ const tokenizedLines = []
+ for (let row = startRow, end = endRow; row <= end; row++) {
+ let tokenizedLine
+ if ((ruleStack || (row === 0)) && row < stopTokenizingAt) {
+ tokenizedLine = this.buildTokenizedLineForRow(row, ruleStack, openScopes)
+ ruleStack = tokenizedLine.ruleStack
+ openScopes = this.scopesFromTags(openScopes, tokenizedLine.tags)
+ }
+ tokenizedLines.push(tokenizedLine)
+ }
+
+ if (endRow >= stopTokenizingAt) {
+ this.invalidateRow(stopTokenizingAt)
+ this.tokenizeInBackground()
+ }
+
+ return tokenizedLines
+ }
+
+ buildTokenizedLineForRow (row, ruleStack, openScopes) {
+ return this.buildTokenizedLineForRowWithText(row, this.buffer.lineForRow(row), ruleStack, openScopes)
+ }
+
+ buildTokenizedLineForRowWithText (row, text, currentRuleStack = this.stackForRow(row - 1), openScopes = this.openScopesForRow(row)) {
+ const lineEnding = this.buffer.lineEndingForRow(row)
+ const {tags, ruleStack} = this.grammar.tokenizeLine(text, currentRuleStack, row === 0, false)
+ return new TokenizedLine({
+ openScopes,
+ text,
+ tags,
+ ruleStack,
+ lineEnding,
+ tokenIterator: this.tokenIterator,
+ grammar: this.grammar
+ })
+ }
+
+ tokenizedLineForRow (bufferRow) {
+ if (bufferRow >= 0 && bufferRow <= this.buffer.getLastRow()) {
+ const tokenizedLine = this.tokenizedLines[bufferRow]
+ if (tokenizedLine) {
+ return tokenizedLine
+ } else {
+ const text = this.buffer.lineForRow(bufferRow)
+ const lineEnding = this.buffer.lineEndingForRow(bufferRow)
+ const tags = [
+ this.grammar.startIdForScope(this.grammar.scopeName),
+ text.length,
+ this.grammar.endIdForScope(this.grammar.scopeName)
+ ]
+ this.tokenizedLines[bufferRow] = new TokenizedLine({
+ openScopes: [],
+ text,
+ tags,
+ lineEnding,
+ tokenIterator: this.tokenIterator,
+ grammar: this.grammar
+ })
+ return this.tokenizedLines[bufferRow]
+ }
+ }
+ }
+
+ tokenizedLinesForRows (startRow, endRow) {
+ const result = []
+ for (let row = startRow, end = endRow; row <= end; row++) {
+ result.push(this.tokenizedLineForRow(row))
+ }
+ return result
+ }
+
+ stackForRow (bufferRow) {
+ return this.tokenizedLines[bufferRow] && this.tokenizedLines[bufferRow].ruleStack
+ }
+
+ openScopesForRow (bufferRow) {
+ const precedingLine = this.tokenizedLines[bufferRow - 1]
+ if (precedingLine) {
+ return this.scopesFromTags(precedingLine.openScopes, precedingLine.tags)
+ } else {
+ return []
+ }
+ }
+
+ scopesFromTags (startingScopes, tags) {
+ const scopes = startingScopes.slice()
+ for (const tag of tags) {
+ if (tag < 0) {
+ if (tag % 2 === -1) {
+ scopes.push(tag)
+ } else {
+ const matchingStartTag = tag + 1
+ while (true) {
+ if (scopes.pop() === matchingStartTag) break
+ if (scopes.length === 0) {
+ this.assert(false, 'Encountered an unmatched scope end tag.', error => {
+ error.metadata = {
+ grammarScopeName: this.grammar.scopeName,
+ unmatchedEndTag: this.grammar.scopeForId(tag)
+ }
+ const path = require('path')
+ error.privateMetadataDescription = `The contents of \`${path.basename(this.buffer.getPath())}\``
+ error.privateMetadata = {
+ filePath: this.buffer.getPath(),
+ fileContents: this.buffer.getText()
+ }
+ })
+ break
+ }
+ }
+ }
+ }
+ }
+ return scopes
+ }
+
+ indentLevelForLine (line, tabLength = this.tabLength) {
+ let indentLength = 0
+ for (let i = 0, {length} = line; i < length; i++) {
+ const char = line[i]
+ if (char === '\t') {
+ indentLength += tabLength - (indentLength % tabLength)
+ } else if (char === ' ') {
+ indentLength++
+ } else {
+ break
+ }
+ }
+ return indentLength / tabLength
+ }
+
+ scopeDescriptorForPosition (position) {
+ let scopes
+ const {row, column} = this.buffer.clipPosition(Point.fromObject(position))
+
+ const iterator = this.tokenizedLineForRow(row).getTokenIterator()
+ while (iterator.next()) {
+ if (iterator.getBufferEnd() > column) {
+ scopes = iterator.getScopes()
+ break
+ }
+ }
+
+ // rebuild scope of last token if we iterated off the end
+ if (!scopes) {
+ scopes = iterator.getScopes()
+ scopes.push(...iterator.getScopeEnds().reverse())
+ }
+
+ return new ScopeDescriptor({scopes})
+ }
+
+ tokenForPosition (position) {
+ const {row, column} = Point.fromObject(position)
+ return this.tokenizedLineForRow(row).tokenAtBufferColumn(column)
+ }
+
+ tokenStartPositionForPosition (position) {
+ let {row, column} = Point.fromObject(position)
+ column = this.tokenizedLineForRow(row).tokenStartColumnForBufferColumn(column)
+ return new Point(row, column)
+ }
+
+ bufferRangeForScopeAtPosition (selector, position) {
+ let endColumn, tag, tokenIndex
+ position = Point.fromObject(position)
+
+ const {openScopes, tags} = this.tokenizedLineForRow(position.row)
+ const scopes = openScopes.map(tag => this.grammar.scopeForId(tag))
+
+ let startColumn = 0
+ for (tokenIndex = 0; tokenIndex < tags.length; tokenIndex++) {
+ tag = tags[tokenIndex]
+ if (tag < 0) {
+ if ((tag % 2) === -1) {
+ scopes.push(this.grammar.scopeForId(tag))
+ } else {
+ scopes.pop()
+ }
+ } else {
+ endColumn = startColumn + tag
+ if (endColumn >= position.column) {
+ break
+ } else {
+ startColumn = endColumn
+ }
+ }
+ }
+
+ if (!selectorMatchesAnyScope(selector, scopes)) return
+
+ const startScopes = scopes.slice()
+ for (let startTokenIndex = tokenIndex - 1; startTokenIndex >= 0; startTokenIndex--) {
+ tag = tags[startTokenIndex]
+ if (tag < 0) {
+ if ((tag % 2) === -1) {
+ startScopes.pop()
+ } else {
+ startScopes.push(this.grammar.scopeForId(tag))
+ }
+ } else {
+ if (!selectorMatchesAnyScope(selector, startScopes)) { break }
+ startColumn -= tag
+ }
+ }
+
+ const endScopes = scopes.slice()
+ for (let endTokenIndex = tokenIndex + 1, end = tags.length; endTokenIndex < end; endTokenIndex++) {
+ tag = tags[endTokenIndex]
+ if (tag < 0) {
+ if ((tag % 2) === -1) {
+ endScopes.push(this.grammar.scopeForId(tag))
+ } else {
+ endScopes.pop()
+ }
+ } else {
+ if (!selectorMatchesAnyScope(selector, endScopes)) { break }
+ endColumn += tag
+ }
+ }
+
+ return new Range(new Point(position.row, startColumn), new Point(position.row, endColumn))
+ }
+
+ isRowCommented (row) {
+ return this.tokenizedLines[row] && this.tokenizedLines[row].isComment()
+ }
+
+ getFoldableRangeContainingPoint (point, tabLength) {
+ if (point.column >= this.buffer.lineLengthForRow(point.row)) {
+ const endRow = this.endRowForFoldAtRow(point.row, tabLength)
+ if (endRow != null) {
+ return Range(Point(point.row, Infinity), Point(endRow, Infinity))
+ }
+ }
+
+ for (let row = point.row - 1; row >= 0; row--) {
+ const endRow = this.endRowForFoldAtRow(row, tabLength)
+ if (endRow != null && endRow > point.row) {
+ return Range(Point(row, Infinity), Point(endRow, Infinity))
+ }
+ }
+ return null
+ }
+
+ getFoldableRangesAtIndentLevel (indentLevel, tabLength) {
+ const result = []
+ let row = 0
+ const lineCount = this.buffer.getLineCount()
+ while (row < lineCount) {
+ if (this.indentLevelForLine(this.buffer.lineForRow(row), tabLength) === indentLevel) {
+ const endRow = this.endRowForFoldAtRow(row, tabLength)
+ if (endRow != null) {
+ result.push(Range(Point(row, Infinity), Point(endRow, Infinity)))
+ row = endRow + 1
+ continue
+ }
+ }
+ row++
+ }
+ return result
+ }
+
+ getFoldableRanges (tabLength) {
+ const result = []
+ let row = 0
+ const lineCount = this.buffer.getLineCount()
+ while (row < lineCount) {
+ const endRow = this.endRowForFoldAtRow(row, tabLength)
+ if (endRow != null) {
+ result.push(Range(Point(row, Infinity), Point(endRow, Infinity)))
+ }
+ row++
+ }
+ return result
+ }
+
+ endRowForFoldAtRow (row, tabLength, existenceOnly = false) {
+ if (this.isRowCommented(row)) {
+ return this.endRowForCommentFoldAtRow(row, existenceOnly)
+ } else {
+ return this.endRowForCodeFoldAtRow(row, tabLength, existenceOnly)
+ }
+ }
+
+ endRowForCommentFoldAtRow (row, existenceOnly) {
+ if (this.isRowCommented(row - 1)) return
+
+ let endRow
+ for (let nextRow = row + 1, end = this.buffer.getLineCount(); nextRow < end; nextRow++) {
+ if (!this.isRowCommented(nextRow)) break
+ endRow = nextRow
+ if (existenceOnly) break
+ }
+
+ return endRow
+ }
+
+ endRowForCodeFoldAtRow (row, tabLength, existenceOnly) {
+ let foldEndRow
+ const line = this.buffer.lineForRow(row)
+ if (!NON_WHITESPACE_REGEX.test(line)) return
+ const startIndentLevel = this.indentLevelForLine(line, tabLength)
+ const scopeDescriptor = this.scopeDescriptorForPosition([row, 0])
+ const foldEndRegex = this.foldEndRegexForScopeDescriptor(scopeDescriptor)
+ for (let nextRow = row + 1, end = this.buffer.getLineCount(); nextRow < end; nextRow++) {
+ const line = this.buffer.lineForRow(nextRow)
+ if (!NON_WHITESPACE_REGEX.test(line)) continue
+ const indentation = this.indentLevelForLine(line, tabLength)
+ if (indentation < startIndentLevel) {
+ break
+ } else if (indentation === startIndentLevel) {
+ if (foldEndRegex && foldEndRegex.searchSync(line)) foldEndRow = nextRow
+ break
+ }
+ foldEndRow = nextRow
+ if (existenceOnly) break
+ }
+ return foldEndRow
+ }
+
+ increaseIndentRegexForScopeDescriptor (scopeDescriptor) {
+ if (this.scopedSettingsDelegate) {
+ return this.regexForPattern(this.scopedSettingsDelegate.getIncreaseIndentPattern(scopeDescriptor))
+ }
+ }
+
+ decreaseIndentRegexForScopeDescriptor (scopeDescriptor) {
+ if (this.scopedSettingsDelegate) {
+ return this.regexForPattern(this.scopedSettingsDelegate.getDecreaseIndentPattern(scopeDescriptor))
+ }
+ }
+
+ decreaseNextIndentRegexForScopeDescriptor (scopeDescriptor) {
+ if (this.scopedSettingsDelegate) {
+ return this.regexForPattern(this.scopedSettingsDelegate.getDecreaseNextIndentPattern(scopeDescriptor))
+ }
+ }
+
+ foldEndRegexForScopeDescriptor (scopes) {
+ if (this.scopedSettingsDelegate) {
+ return this.regexForPattern(this.scopedSettingsDelegate.getFoldEndPattern(scopes))
+ }
+ }
+
+ regexForPattern (pattern) {
+ if (pattern) {
+ if (!this.regexesByPattern[pattern]) {
+ this.regexesByPattern[pattern] = new OnigRegExp(pattern)
+ }
+ return this.regexesByPattern[pattern]
+ }
+ }
+
+ logLines (start = 0, end = this.buffer.getLastRow()) {
+ for (let row = start; row <= end; row++) {
+ const line = this.tokenizedLines[row].text
+ console.log(row, line, line.length)
+ }
+ }
+}
+
+module.exports.prototype.chunkSize = 50
+
+function selectorMatchesAnyScope (selector, scopes) {
+ const targetClasses = selector.replace(/^\./, '').split('.')
+ return scopes.some((scope) => {
+ const scopeClasses = scope.split('.')
+ return _.isSubset(targetClasses, scopeClasses)
+ })
+}
diff --git a/src/tooltip-manager.coffee b/src/tooltip-manager.coffee
deleted file mode 100644
index 03630c87f..000000000
--- a/src/tooltip-manager.coffee
+++ /dev/null
@@ -1,176 +0,0 @@
-_ = require 'underscore-plus'
-{Disposable, CompositeDisposable} = require 'event-kit'
-Tooltip = null
-
-# Essential: Associates tooltips with HTML elements.
-#
-# You can get the `TooltipManager` via `atom.tooltips`.
-#
-# ## Examples
-#
-# The essence of displaying a tooltip
-#
-# ```coffee
-# # display it
-# disposable = atom.tooltips.add(div, {title: 'This is a tooltip'})
-#
-# # remove it
-# disposable.dispose()
-# ```
-#
-# In practice there are usually multiple tooltips. So we add them to a
-# CompositeDisposable
-#
-# ```coffee
-# {CompositeDisposable} = require 'atom'
-# subscriptions = new CompositeDisposable
-#
-# div1 = document.createElement('div')
-# div2 = document.createElement('div')
-# subscriptions.add atom.tooltips.add(div1, {title: 'This is a tooltip'})
-# subscriptions.add atom.tooltips.add(div2, {title: 'Another tooltip'})
-#
-# # remove them all
-# subscriptions.dispose()
-# ```
-#
-# You can display a key binding in the tooltip as well with the
-# `keyBindingCommand` option.
-#
-# ```coffee
-# disposable = atom.tooltips.add @caseOptionButton,
-# title: "Match Case"
-# keyBindingCommand: 'find-and-replace:toggle-case-option'
-# keyBindingTarget: @findEditor.element
-# ```
-module.exports =
-class TooltipManager
- defaults:
- trigger: 'hover'
- container: 'body'
- html: true
- placement: 'auto top'
- viewportPadding: 2
-
- hoverDefaults:
- {delay: {show: 1000, hide: 100}}
-
- constructor: ({@keymapManager, @viewRegistry}) ->
- @tooltips = new Map()
-
- # Essential: Add a tooltip to the given element.
- #
- # * `target` An `HTMLElement`
- # * `options` An object with one or more of the following options:
- # * `title` A {String} or {Function} to use for the text in the tip. If
- # a function is passed, `this` will be set to the `target` element. This
- # option is mutually exclusive with the `item` option.
- # * `html` A {Boolean} affecting the interpetation of the `title` option.
- # If `true` (the default), the `title` string will be interpreted as HTML.
- # Otherwise it will be interpreted as plain text.
- # * `item` A view (object with an `.element` property) or a DOM element
- # containing custom content for the tooltip. This option is mutually
- # exclusive with the `title` option.
- # * `class` A {String} with a class to apply to the tooltip element to
- # enable custom styling.
- # * `placement` A {String} or {Function} returning a string to indicate
- # the position of the tooltip relative to `element`. Can be `'top'`,
- # `'bottom'`, `'left'`, `'right'`, or `'auto'`. When `'auto'` is
- # specified, it will dynamically reorient the tooltip. For example, if
- # placement is `'auto left'`, the tooltip will display to the left when
- # possible, otherwise it will display right.
- # When a function is used to determine the placement, it is called with
- # the tooltip DOM node as its first argument and the triggering element
- # DOM node as its second. The `this` context is set to the tooltip
- # instance.
- # * `trigger` A {String} indicating how the tooltip should be displayed.
- # Choose from one of the following options:
- # * `'hover'` Show the tooltip when the mouse hovers over the element.
- # This is the default.
- # * `'click'` Show the tooltip when the element is clicked. The tooltip
- # will be hidden after clicking the element again or anywhere else
- # outside of the tooltip itself.
- # * `'focus'` Show the tooltip when the element is focused.
- # * `'manual'` Show the tooltip immediately and only hide it when the
- # returned disposable is disposed.
- # * `delay` An object specifying the show and hide delay in milliseconds.
- # Defaults to `{show: 1000, hide: 100}` if the `trigger` is `hover` and
- # otherwise defaults to `0` for both values.
- # * `keyBindingCommand` A {String} containing a command name. If you specify
- # this option and a key binding exists that matches the command, it will
- # be appended to the title or rendered alone if no title is specified.
- # * `keyBindingTarget` An `HTMLElement` on which to look up the key binding.
- # If this option is not supplied, the first of all matching key bindings
- # for the given command will be rendered.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to remove the
- # tooltip.
- add: (target, options) ->
- if target.jquery
- disposable = new CompositeDisposable
- disposable.add @add(element, options) for element in target
- return disposable
-
- Tooltip ?= require './tooltip'
-
- {keyBindingCommand, keyBindingTarget} = options
-
- if keyBindingCommand?
- bindings = @keymapManager.findKeyBindings(command: keyBindingCommand, target: keyBindingTarget)
- keystroke = getKeystroke(bindings)
- if options.title? and keystroke?
- options.title += " " + getKeystroke(bindings)
- else if keystroke?
- options.title = getKeystroke(bindings)
-
- delete options.selector
- options = _.defaults(options, @defaults)
- if options.trigger is 'hover'
- options = _.defaults(options, @hoverDefaults)
-
- tooltip = new Tooltip(target, options, @viewRegistry)
-
- if not @tooltips.has(target)
- @tooltips.set(target, [])
- @tooltips.get(target).push(tooltip)
-
- hideTooltip = ->
- tooltip.leave(currentTarget: target)
- tooltip.hide()
-
- window.addEventListener('resize', hideTooltip)
-
- disposable = new Disposable =>
- window.removeEventListener('resize', hideTooltip)
- hideTooltip()
- tooltip.destroy()
-
- if @tooltips.has(target)
- tooltipsForTarget = @tooltips.get(target)
- index = tooltipsForTarget.indexOf(tooltip)
- if index isnt -1
- tooltipsForTarget.splice(index, 1)
- if tooltipsForTarget.length is 0
- @tooltips.delete(target)
-
- disposable
-
- # Extended: Find the tooltips that have been applied to the given element.
- #
- # * `target` The `HTMLElement` to find tooltips on.
- #
- # Returns an {Array} of `Tooltip` objects that match the `target`.
- findTooltips: (target) ->
- if @tooltips.has(target)
- @tooltips.get(target).slice()
- else
- []
-
-humanizeKeystrokes = (keystroke) ->
- keystrokes = keystroke.split(' ')
- keystrokes = (_.humanizeKeystroke(stroke) for stroke in keystrokes)
- keystrokes.join(' ')
-
-getKeystroke = (bindings) ->
- if bindings?.length
- "#{humanizeKeystrokes(bindings[0].keystrokes)}"
diff --git a/src/tooltip-manager.js b/src/tooltip-manager.js
new file mode 100644
index 000000000..937f831d1
--- /dev/null
+++ b/src/tooltip-manager.js
@@ -0,0 +1,199 @@
+const _ = require('underscore-plus')
+const {Disposable, CompositeDisposable} = require('event-kit')
+let Tooltip = null
+
+// Essential: Associates tooltips with HTML elements.
+//
+// You can get the `TooltipManager` via `atom.tooltips`.
+//
+// ## Examples
+//
+// The essence of displaying a tooltip
+//
+// ```javascript
+// // display it
+// const disposable = atom.tooltips.add(div, {title: 'This is a tooltip'})
+//
+// // remove it
+// disposable.dispose()
+// ```
+//
+// In practice there are usually multiple tooltips. So we add them to a
+// CompositeDisposable
+//
+// ```javascript
+// const {CompositeDisposable} = require('atom')
+// const subscriptions = new CompositeDisposable()
+//
+// const div1 = document.createElement('div')
+// const div2 = document.createElement('div')
+// subscriptions.add(atom.tooltips.add(div1, {title: 'This is a tooltip'}))
+// subscriptions.add(atom.tooltips.add(div2, {title: 'Another tooltip'}))
+//
+// // remove them all
+// subscriptions.dispose()
+// ```
+//
+// You can display a key binding in the tooltip as well with the
+// `keyBindingCommand` option.
+//
+// ```javascript
+// disposable = atom.tooltips.add(this.caseOptionButton, {
+// title: 'Match Case',
+// keyBindingCommand: 'find-and-replace:toggle-case-option',
+// keyBindingTarget: this.findEditor.element
+// })
+// ```
+module.exports =
+class TooltipManager {
+ constructor ({keymapManager, viewRegistry}) {
+ this.defaults = {
+ trigger: 'hover',
+ container: 'body',
+ html: true,
+ placement: 'auto top',
+ viewportPadding: 2
+ }
+
+ this.hoverDefaults = {
+ delay: {show: 1000, hide: 100}
+ }
+
+ this.keymapManager = keymapManager
+ this.viewRegistry = viewRegistry
+ this.tooltips = new Map()
+ }
+
+ // Essential: Add a tooltip to the given element.
+ //
+ // * `target` An `HTMLElement`
+ // * `options` An object with one or more of the following options:
+ // * `title` A {String} or {Function} to use for the text in the tip. If
+ // a function is passed, `this` will be set to the `target` element. This
+ // option is mutually exclusive with the `item` option.
+ // * `html` A {Boolean} affecting the interpretation of the `title` option.
+ // If `true` (the default), the `title` string will be interpreted as HTML.
+ // Otherwise it will be interpreted as plain text.
+ // * `item` A view (object with an `.element` property) or a DOM element
+ // containing custom content for the tooltip. This option is mutually
+ // exclusive with the `title` option.
+ // * `class` A {String} with a class to apply to the tooltip element to
+ // enable custom styling.
+ // * `placement` A {String} or {Function} returning a string to indicate
+ // the position of the tooltip relative to `element`. Can be `'top'`,
+ // `'bottom'`, `'left'`, `'right'`, or `'auto'`. When `'auto'` is
+ // specified, it will dynamically reorient the tooltip. For example, if
+ // placement is `'auto left'`, the tooltip will display to the left when
+ // possible, otherwise it will display right.
+ // When a function is used to determine the placement, it is called with
+ // the tooltip DOM node as its first argument and the triggering element
+ // DOM node as its second. The `this` context is set to the tooltip
+ // instance.
+ // * `trigger` A {String} indicating how the tooltip should be displayed.
+ // Choose from one of the following options:
+ // * `'hover'` Show the tooltip when the mouse hovers over the element.
+ // This is the default.
+ // * `'click'` Show the tooltip when the element is clicked. The tooltip
+ // will be hidden after clicking the element again or anywhere else
+ // outside of the tooltip itself.
+ // * `'focus'` Show the tooltip when the element is focused.
+ // * `'manual'` Show the tooltip immediately and only hide it when the
+ // returned disposable is disposed.
+ // * `delay` An object specifying the show and hide delay in milliseconds.
+ // Defaults to `{show: 1000, hide: 100}` if the `trigger` is `hover` and
+ // otherwise defaults to `0` for both values.
+ // * `keyBindingCommand` A {String} containing a command name. If you specify
+ // this option and a key binding exists that matches the command, it will
+ // be appended to the title or rendered alone if no title is specified.
+ // * `keyBindingTarget` An `HTMLElement` on which to look up the key binding.
+ // If this option is not supplied, the first of all matching key bindings
+ // for the given command will be rendered.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to remove the
+ // tooltip.
+ add (target, options) {
+ if (target.jquery) {
+ const disposable = new CompositeDisposable()
+ for (const element of target) { disposable.add(this.add(element, options)) }
+ return disposable
+ }
+
+ if (Tooltip == null) { Tooltip = require('./tooltip') }
+
+ const {keyBindingCommand, keyBindingTarget} = options
+
+ if (keyBindingCommand != null) {
+ const bindings = this.keymapManager.findKeyBindings({command: keyBindingCommand, target: keyBindingTarget})
+ const keystroke = getKeystroke(bindings)
+ if ((options.title != null) && (keystroke != null)) {
+ options.title += ` ${getKeystroke(bindings)}`
+ } else if (keystroke != null) {
+ options.title = getKeystroke(bindings)
+ }
+ }
+
+ delete options.selector
+ options = _.defaults(options, this.defaults)
+ if (options.trigger === 'hover') {
+ options = _.defaults(options, this.hoverDefaults)
+ }
+
+ const tooltip = new Tooltip(target, options, this.viewRegistry)
+
+ if (!this.tooltips.has(target)) {
+ this.tooltips.set(target, [])
+ }
+ this.tooltips.get(target).push(tooltip)
+
+ const hideTooltip = function () {
+ tooltip.leave({currentTarget: target})
+ tooltip.hide()
+ }
+
+ window.addEventListener('resize', hideTooltip)
+
+ const disposable = new Disposable(() => {
+ window.removeEventListener('resize', hideTooltip)
+ hideTooltip()
+ tooltip.destroy()
+
+ if (this.tooltips.has(target)) {
+ const tooltipsForTarget = this.tooltips.get(target)
+ const index = tooltipsForTarget.indexOf(tooltip)
+ if (index !== -1) {
+ tooltipsForTarget.splice(index, 1)
+ }
+ if (tooltipsForTarget.length === 0) {
+ this.tooltips.delete(target)
+ }
+ }
+ })
+
+ return disposable
+ }
+
+ // Extended: Find the tooltips that have been applied to the given element.
+ //
+ // * `target` The `HTMLElement` to find tooltips on.
+ //
+ // Returns an {Array} of `Tooltip` objects that match the `target`.
+ findTooltips (target) {
+ if (this.tooltips.has(target)) {
+ return this.tooltips.get(target).slice()
+ } else {
+ return []
+ }
+ }
+}
+
+function humanizeKeystrokes (keystroke) {
+ let keystrokes = keystroke.split(' ')
+ keystrokes = (keystrokes.map((stroke) => _.humanizeKeystroke(stroke)))
+ return keystrokes.join(' ')
+}
+
+function getKeystroke (bindings) {
+ if (bindings && bindings.length) {
+ return `${humanizeKeystrokes(bindings[0].keystrokes)}`
+ }
+}
diff --git a/src/uri-handler-registry.js b/src/uri-handler-registry.js
new file mode 100644
index 000000000..297f916eb
--- /dev/null
+++ b/src/uri-handler-registry.js
@@ -0,0 +1,129 @@
+const url = require('url')
+const {Emitter, Disposable} = require('event-kit')
+
+// Private: Associates listener functions with URIs from outside the application.
+//
+// The global URI handler registry maps URIs to listener functions. URIs are mapped
+// based on the hostname of the URI; the format is atom://package/command?args.
+// The "core" package name is reserved for URIs handled by Atom core (it is not possible
+// to register a package with the name "core").
+//
+// Because URI handling can be triggered from outside the application (e.g. from
+// the user's browser), package authors should take great care to ensure that malicious
+// activities cannot be performed by an attacker. A good rule to follow is that
+// **URI handlers should not take action on behalf of the user**. For example, clicking
+// a link to open a pane item that prompts the user to install a package is okay;
+// automatically installing the package right away is not.
+//
+// Packages can register their desire to handle URIs via a special key in their
+// `package.json` called "uriHandler". The value of this key should be an object
+// that contains, at minimum, a key named "method". This is the name of the method
+// on your package object that Atom will call when it receives a URI your package
+// is responsible for handling. It will pass the parsed URI as the first argument (by using
+// [Node's `url.parse(uri, true)`](https://nodejs.org/docs/latest/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost))
+// and the raw URI string as the second argument.
+//
+// By default, Atom will defer activation of your package until a URI it needs to handle
+// is triggered. If you need your package to activate right away, you can add
+// `"deferActivation": false` to your "uriHandler" configuration object. When activation
+// is deferred, once Atom receives a request for a URI in your package's namespace, it will
+// activate your pacakge and then call `methodName` on it as before.
+//
+// If your package specifies a deprecated `urlMain` property, you cannot register URI handlers
+// via the `uriHandler` key.
+//
+// ## Example
+//
+// Here is a sample package that will be activated and have its `handleURI` method called
+// when a URI beginning with `atom://my-package` is triggered:
+//
+// `package.json`:
+//
+// ```javascript
+// {
+// "name": "my-package",
+// "main": "./lib/my-package.js",
+// "uriHandler": {
+// "method": "handleURI"
+// }
+// }
+// ```
+//
+// `lib/my-package.js`
+//
+// ```javascript
+// module.exports = {
+// activate: function() {
+// // code to activate your package
+// }
+//
+// handleURI(parsedUri, rawUri) {
+// // parse and handle uri
+// }
+// }
+// ```
+module.exports =
+class URIHandlerRegistry {
+ constructor (maxHistoryLength = 50) {
+ this.registrations = new Map()
+ this.history = []
+ this.maxHistoryLength = maxHistoryLength
+ this._id = 0
+
+ this.emitter = new Emitter()
+ }
+
+ registerHostHandler (host, callback) {
+ if (typeof callback !== 'function') {
+ throw new Error('Cannot register a URI host handler with a non-function callback')
+ }
+
+ if (this.registrations.has(host)) {
+ throw new Error(`There is already a URI host handler for the host ${host}`)
+ } else {
+ this.registrations.set(host, callback)
+ }
+
+ return new Disposable(() => {
+ this.registrations.delete(host)
+ })
+ }
+
+ handleURI (uri) {
+ const parsed = url.parse(uri, true)
+ const {protocol, slashes, auth, port, host} = parsed
+ if (protocol !== 'atom:' || slashes !== true || auth || port) {
+ throw new Error(`URIHandlerRegistry#handleURI asked to handle an invalid URI: ${uri}`)
+ }
+
+ const registration = this.registrations.get(host)
+ const historyEntry = {id: ++this._id, uri: uri, handled: false, host}
+ try {
+ if (registration) {
+ historyEntry.handled = true
+ registration(parsed, uri)
+ }
+ } finally {
+ this.history.unshift(historyEntry)
+ if (this.history.length > this.maxHistoryLength) {
+ this.history.length = this.maxHistoryLength
+ }
+ this.emitter.emit('history-change')
+ }
+ }
+
+ getRecentlyHandledURIs () {
+ return this.history
+ }
+
+ onHistoryChange (cb) {
+ return this.emitter.on('history-change', cb)
+ }
+
+ destroy () {
+ this.emitter.dispose()
+ this.registrations = new Map()
+ this.history = []
+ this._id = 0
+ }
+}
diff --git a/src/view-registry.coffee b/src/view-registry.coffee
deleted file mode 100644
index f300cc031..000000000
--- a/src/view-registry.coffee
+++ /dev/null
@@ -1,201 +0,0 @@
-Grim = require 'grim'
-{Disposable} = require 'event-kit'
-_ = require 'underscore-plus'
-
-AnyConstructor = Symbol('any-constructor')
-
-# Essential: `ViewRegistry` handles the association between model and view
-# types in Atom. We call this association a View Provider. As in, for a given
-# model, this class can provide a view via {::getView}, as long as the
-# model/view association was registered via {::addViewProvider}
-#
-# If you're adding your own kind of pane item, a good strategy for all but the
-# simplest items is to separate the model and the view. The model handles
-# application logic and is the primary point of API interaction. The view
-# just handles presentation.
-#
-# Note: Models can be any object, but must implement a `getTitle()` function
-# if they are to be displayed in a {Pane}
-#
-# View providers inform the workspace how your model objects should be
-# presented in the DOM. A view provider must always return a DOM node, which
-# makes [HTML 5 custom elements](http://www.html5rocks.com/en/tutorials/webcomponents/customelements/)
-# an ideal tool for implementing views in Atom.
-#
-# You can access the `ViewRegistry` object via `atom.views`.
-module.exports =
-class ViewRegistry
- animationFrameRequest: null
- documentReadInProgress: false
-
- constructor: (@atomEnvironment) ->
- @clear()
-
- clear: ->
- @views = new WeakMap
- @providers = []
- @clearDocumentRequests()
-
- # Essential: Add a provider that will be used to construct views in the
- # workspace's view layer based on model objects in its model layer.
- #
- # ## Examples
- #
- # Text editors are divided into a model and a view layer, so when you interact
- # with methods like `atom.workspace.getActiveTextEditor()` you're only going
- # to get the model object. We display text editors on screen by teaching the
- # workspace what view constructor it should use to represent them:
- #
- # ```coffee
- # atom.views.addViewProvider TextEditor, (textEditor) ->
- # textEditorElement = new TextEditorElement
- # textEditorElement.initialize(textEditor)
- # textEditorElement
- # ```
- #
- # * `modelConstructor` (optional) Constructor {Function} for your model. If
- # a constructor is given, the `createView` function will only be used
- # for model objects inheriting from that constructor. Otherwise, it will
- # will be called for any object.
- # * `createView` Factory {Function} that is passed an instance of your model
- # and must return a subclass of `HTMLElement` or `undefined`. If it returns
- # `undefined`, then the registry will continue to search for other view
- # providers.
- #
- # Returns a {Disposable} on which `.dispose()` can be called to remove the
- # added provider.
- addViewProvider: (modelConstructor, createView) ->
- if arguments.length is 1
- switch typeof modelConstructor
- when 'function'
- provider = {createView: modelConstructor, modelConstructor: AnyConstructor}
- when 'object'
- Grim.deprecate("atom.views.addViewProvider now takes 2 arguments: a model constructor and a createView function. See docs for details.")
- provider = modelConstructor
- else
- throw new TypeError("Arguments to addViewProvider must be functions")
- else
- provider = {modelConstructor, createView}
-
- @providers.push(provider)
- new Disposable =>
- @providers = @providers.filter (p) -> p isnt provider
-
- getViewProviderCount: ->
- @providers.length
-
- # Essential: Get the view associated with an object in the workspace.
- #
- # If you're just *using* the workspace, you shouldn't need to access the view
- # layer, but view layer access may be necessary if you want to perform DOM
- # manipulation that isn't supported via the model API.
- #
- # ## View Resolution Algorithm
- #
- # The view associated with the object is resolved using the following
- # sequence
- #
- # 1. Is the object an instance of `HTMLElement`? If true, return the object.
- # 2. Does the object have a method named `getElement` that returns an
- # instance of `HTMLElement`? If true, return that value.
- # 3. Does the object have a property named `element` with a value which is
- # an instance of `HTMLElement`? If true, return the property value.
- # 4. Is the object a jQuery object, indicated by the presence of a `jquery`
- # property? If true, return the root DOM element (i.e. `object[0]`).
- # 5. Has a view provider been registered for the object? If true, use the
- # provider to create a view associated with the object, and return the
- # view.
- #
- # If no associated view is returned by the sequence an error is thrown.
- #
- # Returns a DOM element.
- getView: (object) ->
- return unless object?
-
- if view = @views.get(object)
- view
- else
- view = @createView(object)
- @views.set(object, view)
- view
-
- createView: (object) ->
- if object instanceof HTMLElement
- return object
-
- if typeof object?.getElement is 'function'
- element = object.getElement()
- if element instanceof HTMLElement
- return element
-
- if object?.element instanceof HTMLElement
- return object.element
-
- if object?.jquery
- return object[0]
-
- for provider in @providers
- if provider.modelConstructor is AnyConstructor
- if element = provider.createView(object, @atomEnvironment)
- return element
- continue
-
- if object instanceof provider.modelConstructor
- if element = provider.createView?(object, @atomEnvironment)
- return element
-
- if viewConstructor = provider.viewConstructor
- element = new viewConstructor
- element.initialize?(object) ? element.setModel?(object)
- return element
-
- if viewConstructor = object?.getViewClass?()
- view = new viewConstructor(object)
- return view[0]
-
- throw new Error("Can't create a view for #{object.constructor.name} instance. Please register a view provider.")
-
- updateDocument: (fn) ->
- @documentWriters.push(fn)
- @requestDocumentUpdate() unless @documentReadInProgress
- new Disposable =>
- @documentWriters = @documentWriters.filter (writer) -> writer isnt fn
-
- readDocument: (fn) ->
- @documentReaders.push(fn)
- @requestDocumentUpdate()
- new Disposable =>
- @documentReaders = @documentReaders.filter (reader) -> reader isnt fn
-
- getNextUpdatePromise: ->
- @nextUpdatePromise ?= new Promise (resolve) =>
- @resolveNextUpdatePromise = resolve
-
- clearDocumentRequests: ->
- @documentReaders = []
- @documentWriters = []
- @nextUpdatePromise = null
- @resolveNextUpdatePromise = null
- if @animationFrameRequest?
- cancelAnimationFrame(@animationFrameRequest)
- @animationFrameRequest = null
-
- requestDocumentUpdate: ->
- @animationFrameRequest ?= requestAnimationFrame(@performDocumentUpdate)
-
- performDocumentUpdate: =>
- resolveNextUpdatePromise = @resolveNextUpdatePromise
- @animationFrameRequest = null
- @nextUpdatePromise = null
- @resolveNextUpdatePromise = null
-
- writer() while writer = @documentWriters.shift()
-
- @documentReadInProgress = true
- reader() while reader = @documentReaders.shift()
- @documentReadInProgress = false
-
- # process updates requested as a result of reads
- writer() while writer = @documentWriters.shift()
-
- resolveNextUpdatePromise?()
diff --git a/src/view-registry.js b/src/view-registry.js
new file mode 100644
index 000000000..dcc1624fc
--- /dev/null
+++ b/src/view-registry.js
@@ -0,0 +1,249 @@
+const Grim = require('grim')
+const {Disposable} = require('event-kit')
+
+const AnyConstructor = Symbol('any-constructor')
+
+// Essential: `ViewRegistry` handles the association between model and view
+// types in Atom. We call this association a View Provider. As in, for a given
+// model, this class can provide a view via {::getView}, as long as the
+// model/view association was registered via {::addViewProvider}
+//
+// If you're adding your own kind of pane item, a good strategy for all but the
+// simplest items is to separate the model and the view. The model handles
+// application logic and is the primary point of API interaction. The view
+// just handles presentation.
+//
+// Note: Models can be any object, but must implement a `getTitle()` function
+// if they are to be displayed in a {Pane}
+//
+// View providers inform the workspace how your model objects should be
+// presented in the DOM. A view provider must always return a DOM node, which
+// makes [HTML 5 custom elements](http://www.html5rocks.com/en/tutorials/webcomponents/customelements/)
+// an ideal tool for implementing views in Atom.
+//
+// You can access the `ViewRegistry` object via `atom.views`.
+module.exports =
+class ViewRegistry {
+ constructor (atomEnvironment) {
+ this.animationFrameRequest = null
+ this.documentReadInProgress = false
+ this.performDocumentUpdate = this.performDocumentUpdate.bind(this)
+ this.atomEnvironment = atomEnvironment
+ this.clear()
+ }
+
+ clear () {
+ this.views = new WeakMap()
+ this.providers = []
+ this.clearDocumentRequests()
+ }
+
+ // Essential: Add a provider that will be used to construct views in the
+ // workspace's view layer based on model objects in its model layer.
+ //
+ // ## Examples
+ //
+ // Text editors are divided into a model and a view layer, so when you interact
+ // with methods like `atom.workspace.getActiveTextEditor()` you're only going
+ // to get the model object. We display text editors on screen by teaching the
+ // workspace what view constructor it should use to represent them:
+ //
+ // ```coffee
+ // atom.views.addViewProvider TextEditor, (textEditor) ->
+ // textEditorElement = new TextEditorElement
+ // textEditorElement.initialize(textEditor)
+ // textEditorElement
+ // ```
+ //
+ // * `modelConstructor` (optional) Constructor {Function} for your model. If
+ // a constructor is given, the `createView` function will only be used
+ // for model objects inheriting from that constructor. Otherwise, it will
+ // will be called for any object.
+ // * `createView` Factory {Function} that is passed an instance of your model
+ // and must return a subclass of `HTMLElement` or `undefined`. If it returns
+ // `undefined`, then the registry will continue to search for other view
+ // providers.
+ //
+ // Returns a {Disposable} on which `.dispose()` can be called to remove the
+ // added provider.
+ addViewProvider (modelConstructor, createView) {
+ let provider
+ if (arguments.length === 1) {
+ switch (typeof modelConstructor) {
+ case 'function':
+ provider = {createView: modelConstructor, modelConstructor: AnyConstructor}
+ break
+ case 'object':
+ Grim.deprecate('atom.views.addViewProvider now takes 2 arguments: a model constructor and a createView function. See docs for details.')
+ provider = modelConstructor
+ break
+ default:
+ throw new TypeError('Arguments to addViewProvider must be functions')
+ }
+ } else {
+ provider = {modelConstructor, createView}
+ }
+
+ this.providers.push(provider)
+ return new Disposable(() => {
+ this.providers = this.providers.filter(p => p !== provider)
+ })
+ }
+
+ getViewProviderCount () {
+ return this.providers.length
+ }
+
+ // Essential: Get the view associated with an object in the workspace.
+ //
+ // If you're just *using* the workspace, you shouldn't need to access the view
+ // layer, but view layer access may be necessary if you want to perform DOM
+ // manipulation that isn't supported via the model API.
+ //
+ // ## View Resolution Algorithm
+ //
+ // The view associated with the object is resolved using the following
+ // sequence
+ //
+ // 1. Is the object an instance of `HTMLElement`? If true, return the object.
+ // 2. Does the object have a method named `getElement` that returns an
+ // instance of `HTMLElement`? If true, return that value.
+ // 3. Does the object have a property named `element` with a value which is
+ // an instance of `HTMLElement`? If true, return the property value.
+ // 4. Is the object a jQuery object, indicated by the presence of a `jquery`
+ // property? If true, return the root DOM element (i.e. `object[0]`).
+ // 5. Has a view provider been registered for the object? If true, use the
+ // provider to create a view associated with the object, and return the
+ // view.
+ //
+ // If no associated view is returned by the sequence an error is thrown.
+ //
+ // Returns a DOM element.
+ getView (object) {
+ if (object == null) { return }
+
+ let view = this.views.get(object)
+ if (!view) {
+ view = this.createView(object)
+ this.views.set(object, view)
+ }
+ return view
+ }
+
+ createView (object) {
+ if (object instanceof HTMLElement) { return object }
+
+ let element
+ if (object && (typeof object.getElement === 'function')) {
+ element = object.getElement()
+ if (element instanceof HTMLElement) {
+ return element
+ }
+ }
+
+ if (object && object.element instanceof HTMLElement) {
+ return object.element
+ }
+
+ if (object && object.jquery) {
+ return object[0]
+ }
+
+ for (let provider of this.providers) {
+ if (provider.modelConstructor === AnyConstructor) {
+ element = provider.createView(object, this.atomEnvironment)
+ if (element) { return element }
+ continue
+ }
+
+ if (object instanceof provider.modelConstructor) {
+ element = provider.createView && provider.createView(object, this.atomEnvironment)
+ if (element) { return element }
+
+ let ViewConstructor = provider.viewConstructor
+ if (ViewConstructor) {
+ element = new ViewConstructor()
+ if (element.initialize) {
+ element.initialize(object)
+ } else if (element.setModel) {
+ element.setModel(object)
+ }
+ return element
+ }
+ }
+ }
+
+ if (object && object.getViewClass) {
+ let ViewConstructor = object.getViewClass()
+ if (ViewConstructor) {
+ const view = new ViewConstructor(object)
+ return view[0]
+ }
+ }
+
+ throw new Error(`Can't create a view for ${object.constructor.name} instance. Please register a view provider.`)
+ }
+
+ updateDocument (fn) {
+ this.documentWriters.push(fn)
+ if (!this.documentReadInProgress) { this.requestDocumentUpdate() }
+ return new Disposable(() => {
+ this.documentWriters = this.documentWriters.filter(writer => writer !== fn)
+ })
+ }
+
+ readDocument (fn) {
+ this.documentReaders.push(fn)
+ this.requestDocumentUpdate()
+ return new Disposable(() => {
+ this.documentReaders = this.documentReaders.filter(reader => reader !== fn)
+ })
+ }
+
+ getNextUpdatePromise () {
+ if (this.nextUpdatePromise == null) {
+ this.nextUpdatePromise = new Promise(resolve => {
+ this.resolveNextUpdatePromise = resolve
+ })
+ }
+
+ return this.nextUpdatePromise
+ }
+
+ clearDocumentRequests () {
+ this.documentReaders = []
+ this.documentWriters = []
+ this.nextUpdatePromise = null
+ this.resolveNextUpdatePromise = null
+ if (this.animationFrameRequest != null) {
+ cancelAnimationFrame(this.animationFrameRequest)
+ this.animationFrameRequest = null
+ }
+ }
+
+ requestDocumentUpdate () {
+ if (this.animationFrameRequest == null) {
+ this.animationFrameRequest = requestAnimationFrame(this.performDocumentUpdate)
+ }
+ }
+
+ performDocumentUpdate () {
+ const { resolveNextUpdatePromise } = this
+ this.animationFrameRequest = null
+ this.nextUpdatePromise = null
+ this.resolveNextUpdatePromise = null
+
+ let writer
+ while ((writer = this.documentWriters.shift())) { writer() }
+
+ let reader
+ this.documentReadInProgress = true
+ while ((reader = this.documentReaders.shift())) { reader() }
+ this.documentReadInProgress = false
+
+ // process updates requested as a result of reads
+ while ((writer = this.documentWriters.shift())) { writer() }
+
+ if (resolveNextUpdatePromise) { resolveNextUpdatePromise() }
+ }
+}
diff --git a/src/window-event-handler.coffee b/src/window-event-handler.coffee
deleted file mode 100644
index 6a277b612..000000000
--- a/src/window-event-handler.coffee
+++ /dev/null
@@ -1,189 +0,0 @@
-{Disposable, CompositeDisposable} = require 'event-kit'
-listen = require './delegated-listener'
-
-# Handles low-level events related to the @window.
-module.exports =
-class WindowEventHandler
- constructor: ({@atomEnvironment, @applicationDelegate}) ->
- @reloadRequested = false
- @subscriptions = new CompositeDisposable
-
- @handleNativeKeybindings()
-
- initialize: (@window, @document) ->
- @subscriptions.add @atomEnvironment.commands.add @window,
- 'window:toggle-full-screen': @handleWindowToggleFullScreen
- 'window:close': @handleWindowClose
- 'window:reload': @handleWindowReload
- 'window:toggle-dev-tools': @handleWindowToggleDevTools
-
- if process.platform in ['win32', 'linux']
- @subscriptions.add @atomEnvironment.commands.add @window,
- 'window:toggle-menu-bar': @handleWindowToggleMenuBar
-
- @subscriptions.add @atomEnvironment.commands.add @document,
- 'core:focus-next': @handleFocusNext
- 'core:focus-previous': @handleFocusPrevious
-
- @addEventListener(@window, 'beforeunload', @handleWindowBeforeunload)
- @addEventListener(@window, 'focus', @handleWindowFocus)
- @addEventListener(@window, 'blur', @handleWindowBlur)
-
- @addEventListener(@document, 'keyup', @handleDocumentKeyEvent)
- @addEventListener(@document, 'keydown', @handleDocumentKeyEvent)
- @addEventListener(@document, 'drop', @handleDocumentDrop)
- @addEventListener(@document, 'dragover', @handleDocumentDragover)
- @addEventListener(@document, 'contextmenu', @handleDocumentContextmenu)
- @subscriptions.add listen(@document, 'click', 'a', @handleLinkClick)
- @subscriptions.add listen(@document, 'submit', 'form', @handleFormSubmit)
-
- @subscriptions.add(@applicationDelegate.onDidEnterFullScreen(@handleEnterFullScreen))
- @subscriptions.add(@applicationDelegate.onDidLeaveFullScreen(@handleLeaveFullScreen))
-
- # Wire commands that should be handled by Chromium for elements with the
- # `.native-key-bindings` class.
- handleNativeKeybindings: ->
- bindCommandToAction = (command, action) =>
- @subscriptions.add @atomEnvironment.commands.add(
- '.native-key-bindings',
- command,
- ((event) => @applicationDelegate.getCurrentWindow().webContents[action]()),
- false
- )
-
- bindCommandToAction('core:copy', 'copy')
- bindCommandToAction('core:paste', 'paste')
- bindCommandToAction('core:undo', 'undo')
- bindCommandToAction('core:redo', 'redo')
- bindCommandToAction('core:select-all', 'selectAll')
- bindCommandToAction('core:cut', 'cut')
-
- unsubscribe: ->
- @subscriptions.dispose()
-
- on: (target, eventName, handler) ->
- target.on(eventName, handler)
- @subscriptions.add(new Disposable ->
- target.removeListener(eventName, handler)
- )
-
- addEventListener: (target, eventName, handler) ->
- target.addEventListener(eventName, handler)
- @subscriptions.add(new Disposable(-> target.removeEventListener(eventName, handler)))
-
- handleDocumentKeyEvent: (event) =>
- @atomEnvironment.keymaps.handleKeyboardEvent(event)
- event.stopImmediatePropagation()
-
- handleDrop: (event) ->
- event.preventDefault()
- event.stopPropagation()
-
- handleDragover: (event) ->
- event.preventDefault()
- event.stopPropagation()
- event.dataTransfer.dropEffect = 'none'
-
- eachTabIndexedElement: (callback) ->
- for element in @document.querySelectorAll('[tabindex]')
- continue if element.disabled
- continue unless element.tabIndex >= 0
- callback(element, element.tabIndex)
- return
-
- handleFocusNext: =>
- focusedTabIndex = @document.activeElement.tabIndex ? -Infinity
-
- nextElement = null
- nextTabIndex = Infinity
- lowestElement = null
- lowestTabIndex = Infinity
- @eachTabIndexedElement (element, tabIndex) ->
- if tabIndex < lowestTabIndex
- lowestTabIndex = tabIndex
- lowestElement = element
-
- if focusedTabIndex < tabIndex < nextTabIndex
- nextTabIndex = tabIndex
- nextElement = element
-
- if nextElement?
- nextElement.focus()
- else if lowestElement?
- lowestElement.focus()
-
- handleFocusPrevious: =>
- focusedTabIndex = @document.activeElement.tabIndex ? Infinity
-
- previousElement = null
- previousTabIndex = -Infinity
- highestElement = null
- highestTabIndex = -Infinity
- @eachTabIndexedElement (element, tabIndex) ->
- if tabIndex > highestTabIndex
- highestTabIndex = tabIndex
- highestElement = element
-
- if focusedTabIndex > tabIndex > previousTabIndex
- previousTabIndex = tabIndex
- previousElement = element
-
- if previousElement?
- previousElement.focus()
- else if highestElement?
- highestElement.focus()
-
- handleWindowFocus: ->
- @document.body.classList.remove('is-blurred')
-
- handleWindowBlur: =>
- @document.body.classList.add('is-blurred')
- @atomEnvironment.storeWindowDimensions()
-
- handleEnterFullScreen: =>
- @document.body.classList.add("fullscreen")
-
- handleLeaveFullScreen: =>
- @document.body.classList.remove("fullscreen")
-
- handleWindowBeforeunload: (event) =>
- if not @reloadRequested and not @atomEnvironment.inSpecMode() and @atomEnvironment.getCurrentWindow().isWebViewFocused()
- @atomEnvironment.hide()
- @reloadRequested = false
- @atomEnvironment.storeWindowDimensions()
- @atomEnvironment.unloadEditorWindow()
- @atomEnvironment.destroy()
-
- handleWindowToggleFullScreen: =>
- @atomEnvironment.toggleFullScreen()
-
- handleWindowClose: =>
- @atomEnvironment.close()
-
- handleWindowReload: =>
- @reloadRequested = true
- @atomEnvironment.reload()
-
- handleWindowToggleDevTools: =>
- @atomEnvironment.toggleDevTools()
-
- handleWindowToggleMenuBar: =>
- @atomEnvironment.config.set('core.autoHideMenuBar', not @atomEnvironment.config.get('core.autoHideMenuBar'))
-
- if @atomEnvironment.config.get('core.autoHideMenuBar')
- detail = "To toggle, press the Alt key or execute the window:toggle-menu-bar command"
- @atomEnvironment.notifications.addInfo('Menu bar hidden', {detail})
-
- handleLinkClick: (event) =>
- event.preventDefault()
- uri = event.currentTarget?.getAttribute('href')
- if uri and uri[0] isnt '#' and /^https?:\/\//.test(uri)
- @applicationDelegate.openExternal(uri)
-
- handleFormSubmit: (event) ->
- # Prevent form submits from changing the current window's URL
- event.preventDefault()
-
- handleDocumentContextmenu: (event) =>
- event.preventDefault()
- @atomEnvironment.contextMenu.showForEvent(event)
diff --git a/src/window-event-handler.js b/src/window-event-handler.js
new file mode 100644
index 000000000..6d380819b
--- /dev/null
+++ b/src/window-event-handler.js
@@ -0,0 +1,253 @@
+const {Disposable, CompositeDisposable} = require('event-kit')
+const listen = require('./delegated-listener')
+
+// Handles low-level events related to the `window`.
+module.exports =
+class WindowEventHandler {
+ constructor ({atomEnvironment, applicationDelegate}) {
+ this.handleDocumentKeyEvent = this.handleDocumentKeyEvent.bind(this)
+ this.handleFocusNext = this.handleFocusNext.bind(this)
+ this.handleFocusPrevious = this.handleFocusPrevious.bind(this)
+ this.handleWindowBlur = this.handleWindowBlur.bind(this)
+ this.handleEnterFullScreen = this.handleEnterFullScreen.bind(this)
+ this.handleLeaveFullScreen = this.handleLeaveFullScreen.bind(this)
+ this.handleWindowBeforeunload = this.handleWindowBeforeunload.bind(this)
+ this.handleWindowToggleFullScreen = this.handleWindowToggleFullScreen.bind(this)
+ this.handleWindowClose = this.handleWindowClose.bind(this)
+ this.handleWindowReload = this.handleWindowReload.bind(this)
+ this.handleWindowToggleDevTools = this.handleWindowToggleDevTools.bind(this)
+ this.handleWindowToggleMenuBar = this.handleWindowToggleMenuBar.bind(this)
+ this.handleLinkClick = this.handleLinkClick.bind(this)
+ this.handleDocumentContextmenu = this.handleDocumentContextmenu.bind(this)
+ this.atomEnvironment = atomEnvironment
+ this.applicationDelegate = applicationDelegate
+ this.reloadRequested = false
+ this.subscriptions = new CompositeDisposable()
+
+ this.handleNativeKeybindings()
+ }
+
+ initialize (window, document) {
+ this.window = window
+ this.document = document
+ this.subscriptions.add(this.atomEnvironment.commands.add(this.window, {
+ 'window:toggle-full-screen': this.handleWindowToggleFullScreen,
+ 'window:close': this.handleWindowClose,
+ 'window:reload': this.handleWindowReload,
+ 'window:toggle-dev-tools': this.handleWindowToggleDevTools
+ }))
+
+ if (['win32', 'linux'].includes(process.platform)) {
+ this.subscriptions.add(this.atomEnvironment.commands.add(this.window,
+ {'window:toggle-menu-bar': this.handleWindowToggleMenuBar})
+ )
+ }
+
+ this.subscriptions.add(this.atomEnvironment.commands.add(this.document, {
+ 'core:focus-next': this.handleFocusNext,
+ 'core:focus-previous': this.handleFocusPrevious
+ }))
+
+ this.addEventListener(this.window, 'beforeunload', this.handleWindowBeforeunload)
+ this.addEventListener(this.window, 'focus', this.handleWindowFocus)
+ this.addEventListener(this.window, 'blur', this.handleWindowBlur)
+
+ this.addEventListener(this.document, 'keyup', this.handleDocumentKeyEvent)
+ this.addEventListener(this.document, 'keydown', this.handleDocumentKeyEvent)
+ this.addEventListener(this.document, 'drop', this.handleDocumentDrop)
+ this.addEventListener(this.document, 'dragover', this.handleDocumentDragover)
+ this.addEventListener(this.document, 'contextmenu', this.handleDocumentContextmenu)
+ this.subscriptions.add(listen(this.document, 'click', 'a', this.handleLinkClick))
+ this.subscriptions.add(listen(this.document, 'submit', 'form', this.handleFormSubmit))
+
+ this.subscriptions.add(this.applicationDelegate.onDidEnterFullScreen(this.handleEnterFullScreen))
+ this.subscriptions.add(this.applicationDelegate.onDidLeaveFullScreen(this.handleLeaveFullScreen))
+ }
+
+ // Wire commands that should be handled by Chromium for elements with the
+ // `.native-key-bindings` class.
+ handleNativeKeybindings () {
+ const bindCommandToAction = (command, action) => {
+ this.subscriptions.add(
+ this.atomEnvironment.commands.add(
+ '.native-key-bindings',
+ command,
+ event => this.applicationDelegate.getCurrentWindow().webContents[action](),
+ false
+ )
+ )
+ }
+
+ bindCommandToAction('core:copy', 'copy')
+ bindCommandToAction('core:paste', 'paste')
+ bindCommandToAction('core:undo', 'undo')
+ bindCommandToAction('core:redo', 'redo')
+ bindCommandToAction('core:select-all', 'selectAll')
+ bindCommandToAction('core:cut', 'cut')
+ }
+
+ unsubscribe () {
+ this.subscriptions.dispose()
+ }
+
+ on (target, eventName, handler) {
+ target.on(eventName, handler)
+ this.subscriptions.add(new Disposable(function () {
+ target.removeListener(eventName, handler)
+ }))
+ }
+
+ addEventListener (target, eventName, handler) {
+ target.addEventListener(eventName, handler)
+ this.subscriptions.add(new Disposable(function () {
+ target.removeEventListener(eventName, handler)
+ }))
+ }
+
+ handleDocumentKeyEvent (event) {
+ this.atomEnvironment.keymaps.handleKeyboardEvent(event)
+ event.stopImmediatePropagation()
+ }
+
+ handleDrop (event) {
+ event.preventDefault()
+ event.stopPropagation()
+ }
+
+ handleDragover (event) {
+ event.preventDefault()
+ event.stopPropagation()
+ event.dataTransfer.dropEffect = 'none'
+ }
+
+ eachTabIndexedElement (callback) {
+ for (let element of this.document.querySelectorAll('[tabindex]')) {
+ if (element.disabled) { continue }
+ if (!(element.tabIndex >= 0)) { continue }
+ callback(element, element.tabIndex)
+ }
+ }
+
+ handleFocusNext () {
+ const focusedTabIndex = this.document.activeElement.tabIndex != null ? this.document.activeElement.tabIndex : -Infinity
+
+ let nextElement = null
+ let nextTabIndex = Infinity
+ let lowestElement = null
+ let lowestTabIndex = Infinity
+ this.eachTabIndexedElement(function (element, tabIndex) {
+ if (tabIndex < lowestTabIndex) {
+ lowestTabIndex = tabIndex
+ lowestElement = element
+ }
+
+ if (focusedTabIndex < tabIndex && tabIndex < nextTabIndex) {
+ nextTabIndex = tabIndex
+ nextElement = element
+ }
+ })
+
+ if (nextElement != null) {
+ nextElement.focus()
+ } else if (lowestElement != null) {
+ lowestElement.focus()
+ }
+ }
+
+ handleFocusPrevious () {
+ const focusedTabIndex = this.document.activeElement.tabIndex != null ? this.document.activeElement.tabIndex : Infinity
+
+ let previousElement = null
+ let previousTabIndex = -Infinity
+ let highestElement = null
+ let highestTabIndex = -Infinity
+ this.eachTabIndexedElement(function (element, tabIndex) {
+ if (tabIndex > highestTabIndex) {
+ highestTabIndex = tabIndex
+ highestElement = element
+ }
+
+ if (focusedTabIndex > tabIndex && tabIndex > previousTabIndex) {
+ previousTabIndex = tabIndex
+ previousElement = element
+ }
+ })
+
+ if (previousElement != null) {
+ previousElement.focus()
+ } else if (highestElement != null) {
+ highestElement.focus()
+ }
+ }
+
+ handleWindowFocus () {
+ this.document.body.classList.remove('is-blurred')
+ }
+
+ handleWindowBlur () {
+ this.document.body.classList.add('is-blurred')
+ this.atomEnvironment.storeWindowDimensions()
+ }
+
+ handleEnterFullScreen () {
+ this.document.body.classList.add('fullscreen')
+ }
+
+ handleLeaveFullScreen () {
+ this.document.body.classList.remove('fullscreen')
+ }
+
+ handleWindowBeforeunload (event) {
+ if (!this.reloadRequested && !this.atomEnvironment.inSpecMode() && this.atomEnvironment.getCurrentWindow().isWebViewFocused()) {
+ this.atomEnvironment.hide()
+ }
+ this.reloadRequested = false
+ this.atomEnvironment.storeWindowDimensions()
+ this.atomEnvironment.unloadEditorWindow()
+ this.atomEnvironment.destroy()
+ }
+
+ handleWindowToggleFullScreen () {
+ this.atomEnvironment.toggleFullScreen()
+ }
+
+ handleWindowClose () {
+ this.atomEnvironment.close()
+ }
+
+ handleWindowReload () {
+ this.reloadRequested = true
+ this.atomEnvironment.reload()
+ }
+
+ handleWindowToggleDevTools () {
+ this.atomEnvironment.toggleDevTools()
+ }
+
+ handleWindowToggleMenuBar () {
+ this.atomEnvironment.config.set('core.autoHideMenuBar', !this.atomEnvironment.config.get('core.autoHideMenuBar'))
+
+ if (this.atomEnvironment.config.get('core.autoHideMenuBar')) {
+ const detail = 'To toggle, press the Alt key or execute the window:toggle-menu-bar command'
+ this.atomEnvironment.notifications.addInfo('Menu bar hidden', {detail})
+ }
+ }
+
+ handleLinkClick (event) {
+ event.preventDefault()
+ const uri = event.currentTarget && event.currentTarget.getAttribute('href')
+ if (uri && (uri[0] !== '#') && /^https?:\/\//.test(uri)) {
+ this.applicationDelegate.openExternal(uri)
+ }
+ }
+
+ handleFormSubmit (event) {
+ // Prevent form submits from changing the current window's URL
+ event.preventDefault()
+ }
+
+ handleDocumentContextmenu (event) {
+ event.preventDefault()
+ this.atomEnvironment.contextMenu.showForEvent(event)
+ }
+}
diff --git a/src/workspace-element.js b/src/workspace-element.js
index 3ba2c620f..bd0e1b971 100644
--- a/src/workspace-element.js
+++ b/src/workspace-element.js
@@ -78,10 +78,10 @@ class WorkspaceElement extends HTMLElement {
this.project = project
this.config = config
this.styleManager = styleManager
- if (this.viewRegistry == null) { throw new Error('Must pass a viewRegistry parameter when initializing WorskpaceElements') }
- if (this.project == null) { throw new Error('Must pass a project parameter when initializing WorskpaceElements') }
- if (this.config == null) { throw new Error('Must pass a config parameter when initializing WorskpaceElements') }
- if (this.styleManager == null) { throw new Error('Must pass a styleManager parameter when initializing WorskpaceElements') }
+ if (this.viewRegistry == null) { throw new Error('Must pass a viewRegistry parameter when initializing WorkspaceElements') }
+ if (this.project == null) { throw new Error('Must pass a project parameter when initializing WorkspaceElements') }
+ if (this.config == null) { throw new Error('Must pass a config parameter when initializing WorkspaceElements') }
+ if (this.styleManager == null) { throw new Error('Must pass a styleManager parameter when initializing WorkspaceElements') }
this.subscriptions = new CompositeDisposable(
new Disposable(() => {
diff --git a/src/workspace.js b/src/workspace.js
index d089421f3..80dfc47cb 100644
--- a/src/workspace.js
+++ b/src/workspace.js
@@ -820,7 +820,8 @@ module.exports = class Workspace extends Model {
// Extended: Invoke the given callback when a pane item is about to be
// destroyed, before the user is prompted to save it.
//
- // * `callback` {Function} to be called before pane items are destroyed.
+ // * `callback` {Function} to be called before pane items are destroyed. If this function returns
+ // a {Promise}, then the item will not be destroyed until the promise resolves.
// * `event` {Object} with the following keys:
// * `item` The item to be destroyed.
// * `pane` {Pane} containing the item to be destroyed.