/** @babel */ /* global advanceClock, HTMLElement, waits */ const path = require('path') const temp = require('temp').track() const TextEditor = require('../src/text-editor') const Workspace = require('../src/workspace') const Project = require('../src/project') const platform = require('./spec-helper-platform') const _ = require('underscore-plus') const fstream = require('fstream') const fs = require('fs-plus') const AtomEnvironment = require('../src/atom-environment') const {it, fit, ffit, fffit, beforeEach, afterEach} = require('./async-spec-helpers') describe('Workspace', () => { let workspace let setDocumentEdited beforeEach(() => { workspace = atom.workspace workspace.resetFontSize() spyOn(atom.applicationDelegate, 'confirm') setDocumentEdited = spyOn(atom.applicationDelegate, 'setWindowDocumentEdited') atom.project.setPaths([atom.project.getDirectories()[0].resolve('dir')]) waits(1) waitsForPromise(() => atom.workspace.itemLocationStore.clear()) }) afterEach(() => temp.cleanupSync()) describe('serialization', () => { const simulateReload = () => { const workspaceState = atom.workspace.serialize() const projectState = atom.project.serialize({isUnloading: true}) atom.workspace.destroy() atom.project.destroy() atom.project = new Project({ notificationManager: atom.notifications, packageManager: atom.packages, confirm: atom.confirm.bind(atom), applicationDelegate: atom.applicationDelegate }) atom.project.deserialize(projectState) atom.workspace = new Workspace({ config: atom.config, project: atom.project, packageManager: atom.packages, grammarRegistry: atom.grammars, styleManager: atom.styles, deserializerManager: atom.deserializers, notificationManager: atom.notifications, applicationDelegate: atom.applicationDelegate, viewRegistry: atom.views, assert: atom.assert.bind(atom), textEditorRegistry: atom.textEditors }) return atom.workspace.deserialize(workspaceState, atom.deserializers) } describe('when the workspace contains text editors', () => { it('constructs the view with the same panes', () => { const pane1 = atom.workspace.getActivePane() const pane2 = pane1.splitRight({copyActiveItem: true}) const pane3 = pane2.splitRight({copyActiveItem: true}) let pane4 = null waitsForPromise(() => atom.workspace.open(null).then(editor => editor.setText('An untitled editor.'))) waitsForPromise(() => atom.workspace.open('b').then(editor => pane2.activateItem(editor.copy())) ) waitsForPromise(() => atom.workspace.open('../sample.js').then(editor => pane3.activateItem(editor)) ) runs(() => { pane3.activeItem.setCursorScreenPosition([2, 4]) pane4 = pane2.splitDown() }) waitsForPromise(() => atom.workspace.open('../sample.txt').then(editor => pane4.activateItem(editor)) ) runs(() => { pane4.getActiveItem().setCursorScreenPosition([0, 2]) pane2.activate() simulateReload() expect(atom.workspace.getTextEditors().length).toBe(5) const [editor1, editor2, untitledEditor, editor3, editor4] = atom.workspace.getTextEditors() const firstDirectory = atom.project.getDirectories()[0] expect(firstDirectory).toBeDefined() expect(editor1.getPath()).toBe(firstDirectory.resolve('b')) expect(editor2.getPath()).toBe(firstDirectory.resolve('../sample.txt')) expect(editor2.getCursorScreenPosition()).toEqual([0, 2]) expect(editor3.getPath()).toBe(firstDirectory.resolve('b')) expect(editor4.getPath()).toBe(firstDirectory.resolve('../sample.js')) expect(editor4.getCursorScreenPosition()).toEqual([2, 4]) expect(untitledEditor.getPath()).toBeUndefined() expect(untitledEditor.getText()).toBe('An untitled editor.') expect(atom.workspace.getActiveTextEditor().getPath()).toBe(editor3.getPath()) const pathEscaped = fs.tildify(escapeStringRegex(atom.project.getPaths()[0])) expect(document.title).toMatch(new RegExp(`^${path.basename(editor3.getLongTitle())} \\u2014 ${pathEscaped}`)) }) }) }) describe('where there are no open panes or editors', () => { it('constructs the view with no open editors', () => { atom.workspace.getActivePane().destroy() expect(atom.workspace.getTextEditors().length).toBe(0) simulateReload() expect(atom.workspace.getTextEditors().length).toBe(0) }) }) describe('where a dock contains an editor', () => { afterEach(() => { atom.workspace.getRightDock().paneContainer.destroy() }) it('constructs the view with the same panes', () => { const pane1 = atom.workspace.getRightDock().getActivePane() const pane2 = pane1.splitRight({copyActiveItem: true}) const pane3 = pane2.splitRight({copyActiveItem: true}) let pane4 = null waitsForPromise(() => atom.workspace.open(null, {location: 'right'}).then(editor => editor.setText('An untitled editor.')) ) waitsForPromise(() => atom.workspace.open('b', {location: 'right'}).then(editor => pane2.activateItem(editor.copy())) ) waitsForPromise(() => atom.workspace.open('../sample.js', {location: 'right'}).then(editor => pane3.activateItem(editor)) ) runs(() => { pane3.activeItem.setCursorScreenPosition([2, 4]) pane4 = pane2.splitDown() }) waitsForPromise(() => atom.workspace.open('../sample.txt', {location: 'right'}).then(editor => pane4.activateItem(editor)) ) runs(() => { pane4.getActiveItem().setCursorScreenPosition([0, 2]) pane2.activate() simulateReload() expect(atom.workspace.getTextEditors().length).toBe(5) const [editor1, editor2, untitledEditor, editor3, editor4] = atom.workspace.getTextEditors() const firstDirectory = atom.project.getDirectories()[0] expect(firstDirectory).toBeDefined() expect(editor1.getPath()).toBe(firstDirectory.resolve('b')) expect(editor2.getPath()).toBe(firstDirectory.resolve('../sample.txt')) expect(editor2.getCursorScreenPosition()).toEqual([0, 2]) expect(editor3.getPath()).toBe(firstDirectory.resolve('b')) expect(editor4.getPath()).toBe(firstDirectory.resolve('../sample.js')) expect(editor4.getCursorScreenPosition()).toEqual([2, 4]) expect(untitledEditor.getPath()).toBeUndefined() expect(untitledEditor.getText()).toBe('An untitled editor.') expect(atom.workspace.getRightDock().getActiveTextEditor().getPath()).toBe(editor3.getPath()) }) }) }) }) describe('::open(itemOrURI, options)', () => { let openEvents = null beforeEach(() => { openEvents = [] workspace.onDidOpen(event => openEvents.push(event)) spyOn(workspace.getActivePane(), 'activate').andCallThrough() }) describe("when the 'searchAllPanes' option is false (default)", () => { describe('when called without a uri or item', () => { it('adds and activates an empty editor on the active pane', () => { let editor1 let editor2 waitsForPromise(() => workspace.open().then(editor => { editor1 = editor })) runs(() => { expect(editor1.getPath()).toBeUndefined() expect(workspace.getActivePane().items).toEqual([editor1]) expect(workspace.getActivePaneItem()).toBe(editor1) expect(workspace.getActivePane().activate).toHaveBeenCalled() expect(openEvents).toEqual([{uri: undefined, pane: workspace.getActivePane(), item: editor1, index: 0}]) openEvents = [] }) waitsForPromise(() => workspace.open().then(editor => { editor2 = editor })) runs(() => { expect(editor2.getPath()).toBeUndefined() expect(workspace.getActivePane().items).toEqual([editor1, editor2]) expect(workspace.getActivePaneItem()).toBe(editor2) expect(workspace.getActivePane().activate).toHaveBeenCalled() expect(openEvents).toEqual([{uri: undefined, pane: workspace.getActivePane(), item: editor2, index: 1}]) }) }) }) describe('when called with a uri', () => { describe('when the active pane already has an editor for the given uri', () => { it('activates the existing editor on the active pane', () => { let editor = null let editor1 = null let editor2 = null waitsForPromise(() => workspace.open('a').then(o => { editor1 = o return workspace.open('b').then(o => { editor2 = o return workspace.open('a').then(o => { editor = o }) }) }) ) runs(() => { expect(editor).toBe(editor1) expect(workspace.getActivePaneItem()).toBe(editor) expect(workspace.getActivePane().activate).toHaveBeenCalled() const firstDirectory = atom.project.getDirectories()[0] expect(firstDirectory).toBeDefined() expect(openEvents).toEqual([ { uri: firstDirectory.resolve('a'), item: editor1, pane: atom.workspace.getActivePane(), index: 0 }, { uri: firstDirectory.resolve('b'), item: editor2, pane: atom.workspace.getActivePane(), index: 1 }, { uri: firstDirectory.resolve('a'), item: editor1, pane: atom.workspace.getActivePane(), index: 0 } ]) }) }) it('finds items in docks', () => { const dock = atom.workspace.getRightDock() const ITEM_URI = 'atom://test' const item = { getURI: () => ITEM_URI, getDefaultLocation: () => 'left', getElement: () => document.createElement('div') } dock.getActivePane().addItem(item) expect(dock.getPaneItems()).toHaveLength(1) waitsForPromise(() => atom.workspace.open(ITEM_URI, {searchAllPanes: true})) runs(() => { expect(atom.workspace.getPaneItems()).toHaveLength(1) expect(dock.getPaneItems()).toHaveLength(1) expect(dock.getPaneItems()[0]).toBe(item) }) }) }) describe("when the 'activateItem' option is false", () => { it('adds the item to the workspace', () => { let editor waitsForPromise(() => workspace.open('a')) waitsForPromise(() => workspace.open('b', {activateItem: false}).then(o => { editor = o })) runs(() => { expect(workspace.getPaneItems()).toContain(editor) expect(workspace.getActivePaneItem()).not.toBe(editor) }) }) }) describe('when the active pane does not have an editor for the given uri', () => { beforeEach(() => { atom.workspace.enablePersistence = true }) afterEach(async () => { await atom.workspace.itemLocationStore.clear() atom.workspace.enablePersistence = false }) it('adds and activates a new editor for the given path on the active pane', () => { let editor = null waitsForPromise(() => workspace.open('a').then(o => { editor = o })) runs(() => { const firstDirectory = atom.project.getDirectories()[0] expect(firstDirectory).toBeDefined() expect(editor.getURI()).toBe(firstDirectory.resolve('a')) expect(workspace.getActivePaneItem()).toBe(editor) expect(workspace.getActivePane().items).toEqual([editor]) expect(workspace.getActivePane().activate).toHaveBeenCalled() }) }) it("uses the location specified by the model's `getDefaultLocation()` method", () => { const item = { getDefaultLocation: jasmine.createSpy().andReturn('right'), getElement: () => document.createElement('div') } const opener = jasmine.createSpy().andReturn(item) const dock = atom.workspace.getRightDock() spyOn(atom.workspace.itemLocationStore, 'load').andReturn(Promise.resolve()) spyOn(atom.workspace, 'getOpeners').andReturn([opener]) expect(dock.getPaneItems()).toHaveLength(0) waitsForPromise(() => atom.workspace.open('a')) runs(() => { expect(dock.getPaneItems()).toHaveLength(1) expect(opener).toHaveBeenCalled() expect(item.getDefaultLocation).toHaveBeenCalled() }) }) it('prefers the last location the user used for that item', () => { const ITEM_URI = 'atom://test' const item = { getURI: () => ITEM_URI, getDefaultLocation: () => 'left', getElement: () => document.createElement('div') } const opener = uri => uri === ITEM_URI ? item : null const dock = atom.workspace.getRightDock() spyOn(atom.workspace.itemLocationStore, 'load').andCallFake(uri => uri === 'atom://test' ? Promise.resolve('right') : Promise.resolve() ) spyOn(atom.workspace, 'getOpeners').andReturn([opener]) expect(dock.getPaneItems()).toHaveLength(0) waitsForPromise(() => atom.workspace.open(ITEM_URI)) runs(() => { expect(dock.getPaneItems()).toHaveLength(1) expect(dock.getPaneItems()[0]).toBe(item) }) }) }) }) describe('when an item with the given uri exists in an inactive pane container', () => { it('activates that item if it is in that container\'s active pane', async () => { const item = await atom.workspace.open('a') atom.workspace.getLeftDock().activate() expect(await atom.workspace.open('a', {searchAllPanes: false})).toBe(item) expect(atom.workspace.getActivePaneContainer().getLocation()).toBe('center') expect(atom.workspace.getPaneItems()).toEqual([item]) atom.workspace.getActivePane().splitRight() atom.workspace.getLeftDock().activate() const item2 = await atom.workspace.open('a', {searchAllPanes: false}) expect(item2).not.toBe(item) expect(atom.workspace.getActivePaneContainer().getLocation()).toBe('center') expect(atom.workspace.getPaneItems()).toEqual([item, item2]) }) }) }) describe("when the 'searchAllPanes' option is true", () => { describe('when an editor for the given uri is already open on an inactive pane', () => { it('activates the existing editor on the inactive pane, then activates that pane', () => { let editor1 = null let editor2 = null const pane1 = workspace.getActivePane() const pane2 = workspace.getActivePane().splitRight() waitsForPromise(() => { pane1.activate() return workspace.open('a').then(o => { editor1 = o }) }) waitsForPromise(() => { pane2.activate() return workspace.open('b').then(o => { editor2 = o }) }) runs(() => expect(workspace.getActivePaneItem()).toBe(editor2)) waitsForPromise(() => workspace.open('a', {searchAllPanes: true})) runs(() => { expect(workspace.getActivePane()).toBe(pane1) expect(workspace.getActivePaneItem()).toBe(editor1) }) }) it('activates the pane in the dock with the matching item', () => { const dock = atom.workspace.getRightDock() const ITEM_URI = 'atom://test' const item = { getURI: () => ITEM_URI, getDefaultLocation: jasmine.createSpy().andReturn('left'), getElement: () => document.createElement('div') } dock.getActivePane().addItem(item) spyOn(dock.paneForItem(item), 'activate') waitsForPromise(() => atom.workspace.open(ITEM_URI, {searchAllPanes: true})) runs(() => expect(dock.paneForItem(item).activate).toHaveBeenCalled()) }) }) describe('when no editor for the given uri is open in any pane', () => { it('opens an editor for the given uri in the active pane', () => { let editor = null waitsForPromise(() => workspace.open('a', {searchAllPanes: true}).then(o => { editor = o })) runs(() => expect(workspace.getActivePaneItem()).toBe(editor)) }) }) }) describe('when called with an item rather than a URI', () => { it('adds the item itself to the workspace', async () => { const item = document.createElement('div') await atom.workspace.open(item) expect(atom.workspace.getActivePaneItem()).toBe(item) }) describe('when the active pane already contains the item', () => { it('activates the item', async () => { const item = document.createElement('div') await atom.workspace.open(item) await atom.workspace.open() expect(atom.workspace.getActivePaneItem()).not.toBe(item) expect(atom.workspace.getActivePane().getItems().length).toBe(2) await atom.workspace.open(item) expect(atom.workspace.getActivePaneItem()).toBe(item) expect(atom.workspace.getActivePane().getItems().length).toBe(2) }) }) describe('when the item already exists in another pane', () => { it('rejects the promise', async () => { const item = document.createElement('div') await atom.workspace.open(item) await atom.workspace.open(null, {split: 'right'}) expect(atom.workspace.getActivePaneItem()).not.toBe(item) expect(atom.workspace.getActivePane().getItems().length).toBe(1) let rejection try { await atom.workspace.open(item) } catch (error) { rejection = error } expect(rejection.message).toMatch(/The workspace can only contain one instance of item/) }) }) }) describe("when the 'split' option is set", () => { describe("when the 'split' option is 'left'", () => { it('opens the editor in the leftmost pane of the current pane axis', () => { const pane1 = workspace.getActivePane() const pane2 = pane1.splitRight() expect(workspace.getActivePane()).toBe(pane2) let editor = null waitsForPromise(() => workspace.open('a', {split: 'left'}).then(o => { editor = o })) runs(() => { expect(workspace.getActivePane()).toBe(pane1) expect(pane1.items).toEqual([editor]) expect(pane2.items).toEqual([]) }) // Focus right pane and reopen the file on the left waitsForPromise(() => { pane2.focus() return workspace.open('a', {split: 'left'}).then(o => { editor = o }) }) runs(() => { expect(workspace.getActivePane()).toBe(pane1) expect(pane1.items).toEqual([editor]) expect(pane2.items).toEqual([]) }) }) }) describe('when a pane axis is the leftmost sibling of the current pane', () => { it('opens the new item in the current pane', () => { let editor = null const pane1 = workspace.getActivePane() const pane2 = pane1.splitLeft() pane2.splitDown() pane1.activate() expect(workspace.getActivePane()).toBe(pane1) waitsForPromise(() => workspace.open('a', {split: 'left'}).then(o => { editor = o })) runs(() => { expect(workspace.getActivePane()).toBe(pane1) expect(pane1.items).toEqual([editor]) }) }) }) describe("when the 'split' option is 'right'", () => { it('opens the editor in the rightmost pane of the current pane axis', () => { let editor = null const pane1 = workspace.getActivePane() let pane2 = null waitsForPromise(() => workspace.open('a', {split: 'right'}).then(o => { editor = o })) runs(() => { pane2 = workspace.getPanes().filter(p => p !== pane1)[0] expect(workspace.getActivePane()).toBe(pane2) expect(pane1.items).toEqual([]) expect(pane2.items).toEqual([editor]) }) // Focus right pane and reopen the file on the right waitsForPromise(() => { pane1.focus() return workspace.open('a', {split: 'right'}).then(o => { editor = o }) }) runs(() => { expect(workspace.getActivePane()).toBe(pane2) expect(pane1.items).toEqual([]) expect(pane2.items).toEqual([editor]) }) }) describe('when a pane axis is the rightmost sibling of the current pane', () => { it('opens the new item in a new pane split to the right of the current pane', () => { let editor = null const pane1 = workspace.getActivePane() const pane2 = pane1.splitRight() pane2.splitDown() pane1.activate() expect(workspace.getActivePane()).toBe(pane1) let pane4 = null waitsForPromise(() => workspace.open('a', {split: 'right'}).then(o => { editor = o })) runs(() => { pane4 = workspace.getPanes().filter(p => p !== pane1)[0] expect(workspace.getActivePane()).toBe(pane4) expect(pane4.items).toEqual([editor]) expect(workspace.getCenter().paneContainer.root.children[0]).toBe(pane1) expect(workspace.getCenter().paneContainer.root.children[1]).toBe(pane4) }) }) }) }) describe("when the 'split' option is 'up'", () => { it('opens the editor in the topmost pane of the current pane axis', () => { const pane1 = workspace.getActivePane() const pane2 = pane1.splitDown() expect(workspace.getActivePane()).toBe(pane2) let editor = null waitsForPromise(() => workspace.open('a', {split: 'up'}).then(o => { editor = o })) runs(() => { expect(workspace.getActivePane()).toBe(pane1) expect(pane1.items).toEqual([editor]) expect(pane2.items).toEqual([]) }) // Focus bottom pane and reopen the file on the top waitsForPromise(() => { pane2.focus() return workspace.open('a', {split: 'up'}).then(o => { editor = o }) }) runs(() => { expect(workspace.getActivePane()).toBe(pane1) expect(pane1.items).toEqual([editor]) expect(pane2.items).toEqual([]) }) }) }) describe('when a pane axis is the topmost sibling of the current pane', () => { it('opens the new item in the current pane', () => { let editor = null const pane1 = workspace.getActivePane() const pane2 = pane1.splitUp() pane2.splitRight() pane1.activate() expect(workspace.getActivePane()).toBe(pane1) waitsForPromise(() => workspace.open('a', {split: 'up'}).then(o => { editor = o })) runs(() => { expect(workspace.getActivePane()).toBe(pane1) expect(pane1.items).toEqual([editor]) }) }) }) describe("when the 'split' option is 'down'", () => { it('opens the editor in the bottommost pane of the current pane axis', () => { let editor = null const pane1 = workspace.getActivePane() let pane2 = null waitsForPromise(() => workspace.open('a', {split: 'down'}).then(o => { editor = o })) runs(() => { pane2 = workspace.getPanes().filter(p => p !== pane1)[0] expect(workspace.getActivePane()).toBe(pane2) expect(pane1.items).toEqual([]) expect(pane2.items).toEqual([editor]) }) // Focus bottom pane and reopen the file on the right waitsForPromise(() => { pane1.focus() return workspace.open('a', {split: 'down'}).then(o => { editor = o }) }) runs(() => { expect(workspace.getActivePane()).toBe(pane2) expect(pane1.items).toEqual([]) expect(pane2.items).toEqual([editor]) }) }) describe('when a pane axis is the bottommost sibling of the current pane', () => { it('opens the new item in a new pane split to the bottom of the current pane', () => { let editor = null const pane1 = workspace.getActivePane() const pane2 = pane1.splitDown() pane1.activate() expect(workspace.getActivePane()).toBe(pane1) let pane4 = null waitsForPromise(() => workspace.open('a', {split: 'down'}).then(o => { editor = o })) runs(() => { pane4 = workspace.getPanes().filter(p => p !== pane1)[0] expect(workspace.getActivePane()).toBe(pane4) expect(pane4.items).toEqual([editor]) expect(workspace.getCenter().paneContainer.root.children[0]).toBe(pane1) expect(workspace.getCenter().paneContainer.root.children[1]).toBe(pane2) }) }) }) }) }) describe('when an initialLine and initialColumn are specified', () => { it('moves the cursor to the indicated location', () => { waitsForPromise(() => workspace.open('a', {initialLine: 1, initialColumn: 5})) runs(() => expect(workspace.getActiveTextEditor().getCursorBufferPosition()).toEqual([1, 5])) waitsForPromise(() => workspace.open('a', {initialLine: 2, initialColumn: 4})) runs(() => expect(workspace.getActiveTextEditor().getCursorBufferPosition()).toEqual([2, 4])) waitsForPromise(() => workspace.open('a', {initialLine: 0, initialColumn: 0})) runs(() => expect(workspace.getActiveTextEditor().getCursorBufferPosition()).toEqual([0, 0])) waitsForPromise(() => workspace.open('a', {initialLine: NaN, initialColumn: 4})) runs(() => expect(workspace.getActiveTextEditor().getCursorBufferPosition()).toEqual([0, 4])) waitsForPromise(() => workspace.open('a', {initialLine: 2, initialColumn: NaN})) runs(() => expect(workspace.getActiveTextEditor().getCursorBufferPosition()).toEqual([2, 0])) waitsForPromise(() => workspace.open('a', {initialLine: Infinity, initialColumn: Infinity})) runs(() => expect(workspace.getActiveTextEditor().getCursorBufferPosition()).toEqual([2, 11])) }) }) describe('when the file is over 2MB', () => { it('opens the editor with largeFileMode: true', () => { spyOn(fs, 'getSizeSync').andReturn(2 * 1048577) // 2MB let editor = null waitsForPromise(() => workspace.open('sample.js').then(e => { editor = e })) runs(() => expect(editor.largeFileMode).toBe(true)) }) }) describe('when the file is over user-defined limit', () => { const shouldPromptForFileOfSize = (size, shouldPrompt) => { spyOn(fs, 'getSizeSync').andReturn(size * 1048577) atom.applicationDelegate.confirm.andCallFake(() => selectedButtonIndex) atom.applicationDelegate.confirm() var selectedButtonIndex = 1 // cancel let editor = null waitsForPromise(() => workspace.open('sample.js').then(e => { editor = e })) if (shouldPrompt) { runs(() => { expect(editor).toBeUndefined() expect(atom.applicationDelegate.confirm).toHaveBeenCalled() atom.applicationDelegate.confirm.reset() selectedButtonIndex = 0 }) // open the file waitsForPromise(() => workspace.open('sample.js').then(e => { editor = e })) runs(() => { expect(atom.applicationDelegate.confirm).toHaveBeenCalled() expect(editor.largeFileMode).toBe(true) }) } else { runs(() => expect(editor).not.toBeUndefined()) } } it('prompts the user to make sure they want to open a file this big', () => { atom.config.set('core.warnOnLargeFileLimit', 20) shouldPromptForFileOfSize(20, true) }) it("doesn't prompt on files below the limit", () => { atom.config.set('core.warnOnLargeFileLimit', 30) shouldPromptForFileOfSize(20, false) }) it('prompts for smaller files with a lower limit', () => { atom.config.set('core.warnOnLargeFileLimit', 5) shouldPromptForFileOfSize(10, true) }) }) describe('when passed a path that matches a custom opener', () => { it('returns the resource returned by the custom opener', () => { const fooOpener = (pathToOpen, options) => { if (pathToOpen != null ? pathToOpen.match(/\.foo/) : undefined) { return {foo: pathToOpen, options} } } const barOpener = (pathToOpen) => { if (pathToOpen != null ? pathToOpen.match(/^bar:\/\//) : undefined) { return {bar: pathToOpen} } } workspace.addOpener(fooOpener) workspace.addOpener(barOpener) waitsForPromise(() => { const pathToOpen = atom.project.getDirectories()[0].resolve('a.foo') return workspace.open(pathToOpen, {hey: 'there'}).then(item => expect(item).toEqual({foo: pathToOpen, options: {hey: 'there'}})) }) waitsForPromise(() => workspace.open('bar://baz').then(item => expect(item).toEqual({bar: 'bar://baz'}))) }) }) it("adds the file to the application's recent documents list", () => { if (process.platform !== 'darwin') { return } // Feature only supported on macOS spyOn(atom.applicationDelegate, 'addRecentDocument') waitsForPromise(() => workspace.open()) runs(() => expect(atom.applicationDelegate.addRecentDocument).not.toHaveBeenCalled()) waitsForPromise(() => workspace.open('something://a/url')) runs(() => expect(atom.applicationDelegate.addRecentDocument).not.toHaveBeenCalled()) waitsForPromise(() => workspace.open(__filename)) runs(() => expect(atom.applicationDelegate.addRecentDocument).toHaveBeenCalledWith(__filename)) }) it('notifies ::onDidAddTextEditor observers', () => { const absolutePath = require.resolve('./fixtures/dir/a') const newEditorHandler = jasmine.createSpy('newEditorHandler') workspace.onDidAddTextEditor(newEditorHandler) let editor = null waitsForPromise(() => workspace.open(absolutePath).then(e => { editor = e })) runs(() => expect(newEditorHandler.argsForCall[0][0].textEditor).toBe(editor)) }) describe('when there is an error opening the file', () => { let notificationSpy = null beforeEach(() => atom.notifications.onDidAddNotification(notificationSpy = jasmine.createSpy())) describe('when a file does not exist', () => { it('creates an empty buffer for the specified path', () => { waitsForPromise(() => workspace.open('not-a-file.md')) runs(() => { const editor = workspace.getActiveTextEditor() expect(notificationSpy).not.toHaveBeenCalled() expect(editor.getPath()).toContain('not-a-file.md') }) }) }) describe('when the user does not have access to the file', () => { beforeEach(() => spyOn(fs, 'openSync').andCallFake(path => { const error = new Error(`EACCES, permission denied '${path}'`) error.path = path error.code = 'EACCES' throw error }) ) it('creates a notification', () => { waitsForPromise(() => workspace.open('file1')) runs(() => { expect(notificationSpy).toHaveBeenCalled() const notification = notificationSpy.mostRecentCall.args[0] expect(notification.getType()).toBe('warning') expect(notification.getMessage()).toContain('Permission denied') expect(notification.getMessage()).toContain('file1') }) }) }) describe('when the the operation is not permitted', () => { beforeEach(() => spyOn(fs, 'openSync').andCallFake(path => { const error = new Error(`EPERM, operation not permitted '${path}'`) error.path = path error.code = 'EPERM' throw error }) ) it('creates a notification', () => { waitsForPromise(() => workspace.open('file1')) runs(() => { expect(notificationSpy).toHaveBeenCalled() const notification = notificationSpy.mostRecentCall.args[0] expect(notification.getType()).toBe('warning') expect(notification.getMessage()).toContain('Unable to open') expect(notification.getMessage()).toContain('file1') }) }) }) describe('when the the file is already open in windows', () => { beforeEach(() => spyOn(fs, 'openSync').andCallFake(path => { const error = new Error(`EBUSY, resource busy or locked '${path}'`) error.path = path error.code = 'EBUSY' throw error }) ) it('creates a notification', () => { waitsForPromise(() => workspace.open('file1')) runs(() => { expect(notificationSpy).toHaveBeenCalled() const notification = notificationSpy.mostRecentCall.args[0] expect(notification.getType()).toBe('warning') expect(notification.getMessage()).toContain('Unable to open') expect(notification.getMessage()).toContain('file1') }) }) }) describe('when there is an unhandled error', () => { beforeEach(() => spyOn(fs, 'openSync').andCallFake(path => { throw new Error('I dont even know what is happening right now!!') }) ) it('rejects the promise', () => { waitsFor((done) => { workspace.open('file1').catch(error => { expect(error.message).toBe('I dont even know what is happening right now!!') done() }) }) }) }) }) describe('when the file is already open in pending state', () => { it('should terminate the pending state', () => { let editor = null let pane = null waitsForPromise(() => atom.workspace.open('sample.js', {pending: true}).then(o => { editor = o pane = atom.workspace.getActivePane() }) ) runs(() => expect(pane.getPendingItem()).toEqual(editor)) waitsForPromise(() => atom.workspace.open('sample.js')) runs(() => expect(pane.getPendingItem()).toBeNull()) }) }) describe('when opening will switch from a pending tab to a permanent tab', () => { it('keeps the pending tab open', () => { let editor1 = null let editor2 = null waitsForPromise(() => atom.workspace.open('sample.txt').then(o => { editor1 = o }) ) waitsForPromise(() => atom.workspace.open('sample2.txt', {pending: true}).then(o => { editor2 = o }) ) runs(() => { const pane = atom.workspace.getActivePane() pane.activateItem(editor1) expect(pane.getItems().length).toBe(2) expect(pane.getItems()).toEqual([editor1, editor2]) }) }) }) describe('when replacing a pending item which is the last item in a second pane', () => { it('does not destroy the pane even if core.destroyEmptyPanes is on', () => { atom.config.set('core.destroyEmptyPanes', true) let editor1 = null let editor2 = null const leftPane = atom.workspace.getActivePane() let rightPane = null waitsForPromise(() => atom.workspace.open('sample.js', {pending: true, split: 'right'}).then(o => { editor1 = o rightPane = atom.workspace.getActivePane() spyOn(rightPane, 'destroy').andCallThrough() }) ) runs(() => { expect(leftPane).not.toBe(rightPane) expect(atom.workspace.getActivePane()).toBe(rightPane) expect(atom.workspace.getActivePane().getItems().length).toBe(1) expect(rightPane.getPendingItem()).toBe(editor1) }) waitsForPromise(() => atom.workspace.open('sample.txt', {pending: true}).then(o => { editor2 = o }) ) runs(() => { expect(rightPane.getPendingItem()).toBe(editor2) expect(rightPane.destroy.callCount).toBe(0) }) }) }) }) describe('::hide(uri)', () => { let item const URI = 'atom://hide-test' beforeEach(() => { const el = document.createElement('div') item = { getTitle: () => 'Item', getElement: () => el, getURI: () => URI } }) describe('when called with a URI', () => { it('if the item for the given URI is in the center, removes it', () => { const pane = atom.workspace.getActivePane() pane.addItem(item) atom.workspace.hide(URI) expect(pane.getItems().length).toBe(0) }) it('if the item for the given URI is in a dock, hides the dock', () => { const dock = atom.workspace.getLeftDock() const pane = dock.getActivePane() pane.addItem(item) dock.activate() expect(dock.isVisible()).toBe(true) const itemFound = atom.workspace.hide(URI) expect(itemFound).toBe(true) expect(dock.isVisible()).toBe(false) }) }) describe('when called with an item', () => { it('if the item is in the center, removes it', () => { const pane = atom.workspace.getActivePane() pane.addItem(item) atom.workspace.hide(item) expect(pane.getItems().length).toBe(0) }) it('if the item is in a dock, hides the dock', () => { const dock = atom.workspace.getLeftDock() const pane = dock.getActivePane() pane.addItem(item) dock.activate() expect(dock.isVisible()).toBe(true) const itemFound = atom.workspace.hide(item) expect(itemFound).toBe(true) expect(dock.isVisible()).toBe(false) }) }) }) describe('::toggle(itemOrUri)', () => { describe('when the location resolves to a dock', () => { it('adds or shows the item and its dock if it is not currently visible, and otherwise hides the containing dock', async () => { const item1 = { getDefaultLocation () { return 'left' }, getElement () { return (this.element = document.createElement('div')) } } const item2 = { getDefaultLocation () { return 'left' }, getElement () { return (this.element = document.createElement('div')) } } const dock = workspace.getLeftDock() expect(dock.isVisible()).toBe(false) await workspace.toggle(item1) expect(dock.isVisible()).toBe(true) expect(dock.getActivePaneItem()).toBe(item1) await workspace.toggle(item2) expect(dock.isVisible()).toBe(true) expect(dock.getActivePaneItem()).toBe(item2) await workspace.toggle(item1) expect(dock.isVisible()).toBe(true) expect(dock.getActivePaneItem()).toBe(item1) await workspace.toggle(item1) expect(dock.isVisible()).toBe(false) expect(dock.getActivePaneItem()).toBe(item1) await workspace.toggle(item2) expect(dock.isVisible()).toBe(true) expect(dock.getActivePaneItem()).toBe(item2) }) }) describe('when the location resolves to the center', () => { it('adds or shows the item if it is not currently the active pane item, and otherwise removes the item', async () => { const item1 = { getDefaultLocation () { return 'center' }, getElement () { return (this.element = document.createElement('div')) } } const item2 = { getDefaultLocation () { return 'center' }, getElement () { return (this.element = document.createElement('div')) } } expect(workspace.getActivePaneItem()).toBeUndefined() await workspace.toggle(item1) expect(workspace.getActivePaneItem()).toBe(item1) await workspace.toggle(item2) expect(workspace.getActivePaneItem()).toBe(item2) await workspace.toggle(item1) expect(workspace.getActivePaneItem()).toBe(item1) await workspace.toggle(item1) expect(workspace.paneForItem(item1)).toBeUndefined() expect(workspace.getActivePaneItem()).toBe(item2) }) }) }) describe('active pane containers', () => { it('maintains the active pane and item globally across active pane containers', () => { const leftDock = workspace.getLeftDock() const leftItem1 = {element: document.createElement('div')} const leftItem2 = {element: document.createElement('div')} const leftItem3 = {element: document.createElement('div')} const leftPane1 = leftDock.getActivePane() leftPane1.addItems([leftItem1, leftItem2]) const leftPane2 = leftPane1.splitDown({items: [leftItem3]}) const rightDock = workspace.getRightDock() const rightItem1 = {element: document.createElement('div')} const rightItem2 = {element: document.createElement('div')} const rightItem3 = {element: document.createElement('div')} const rightPane1 = rightDock.getActivePane() rightPane1.addItems([rightItem1, rightItem2]) const rightPane2 = rightPane1.splitDown({items: [rightItem3]}) const bottomDock = workspace.getBottomDock() const bottomItem1 = {element: document.createElement('div')} const bottomItem2 = {element: document.createElement('div')} const bottomItem3 = {element: document.createElement('div')} const bottomPane1 = bottomDock.getActivePane() bottomPane1.addItems([bottomItem1, bottomItem2]) const bottomPane2 = bottomPane1.splitDown({items: [bottomItem3]}) const center = workspace.getCenter() const centerItem1 = {element: document.createElement('div')} const centerItem2 = {element: document.createElement('div')} const centerItem3 = {element: document.createElement('div')} const centerPane1 = center.getActivePane() centerPane1.addItems([centerItem1, centerItem2]) const centerPane2 = centerPane1.splitDown({items: [centerItem3]}) const activePaneContainers = [] const activePanes = [] const activeItems = [] workspace.onDidChangeActivePaneContainer((container) => activePaneContainers.push(container)) workspace.onDidChangeActivePane((pane) => activePanes.push(pane)) workspace.onDidChangeActivePaneItem((item) => activeItems.push(item)) function clearEvents () { activePaneContainers.length = 0 activePanes.length = 0 activeItems.length = 0 } expect(workspace.getActivePaneContainer()).toBe(center) expect(workspace.getActivePane()).toBe(centerPane2) expect(workspace.getActivePaneItem()).toBe(centerItem3) leftDock.activate() expect(workspace.getActivePaneContainer()).toBe(leftDock) expect(workspace.getActivePane()).toBe(leftPane2) expect(workspace.getActivePaneItem()).toBe(leftItem3) expect(activePaneContainers).toEqual([leftDock]) expect(activePanes).toEqual([leftPane2]) expect(activeItems).toEqual([leftItem3]) clearEvents() leftPane1.activate() leftPane1.activate() expect(workspace.getActivePaneContainer()).toBe(leftDock) expect(workspace.getActivePane()).toBe(leftPane1) expect(workspace.getActivePaneItem()).toBe(leftItem1) expect(activePaneContainers).toEqual([]) expect(activePanes).toEqual([leftPane1]) expect(activeItems).toEqual([leftItem1]) clearEvents() leftPane1.activateItem(leftItem2) leftPane1.activateItem(leftItem2) expect(workspace.getActivePaneContainer()).toBe(leftDock) expect(workspace.getActivePane()).toBe(leftPane1) expect(workspace.getActivePaneItem()).toBe(leftItem2) expect(activePaneContainers).toEqual([]) expect(activePanes).toEqual([]) expect(activeItems).toEqual([leftItem2]) clearEvents() expect(rightDock.getActivePane()).toBe(rightPane2) rightPane1.activate() rightPane1.activate() expect(workspace.getActivePaneContainer()).toBe(rightDock) expect(workspace.getActivePane()).toBe(rightPane1) expect(workspace.getActivePaneItem()).toBe(rightItem1) expect(activePaneContainers).toEqual([rightDock]) expect(activePanes).toEqual([rightPane1]) expect(activeItems).toEqual([rightItem1]) clearEvents() rightPane1.activateItem(rightItem2) expect(workspace.getActivePaneContainer()).toBe(rightDock) expect(workspace.getActivePane()).toBe(rightPane1) expect(workspace.getActivePaneItem()).toBe(rightItem2) expect(activePaneContainers).toEqual([]) expect(activePanes).toEqual([]) expect(activeItems).toEqual([rightItem2]) clearEvents() expect(bottomDock.getActivePane()).toBe(bottomPane2) bottomPane2.activate() bottomPane2.activate() expect(workspace.getActivePaneContainer()).toBe(bottomDock) expect(workspace.getActivePane()).toBe(bottomPane2) expect(workspace.getActivePaneItem()).toBe(bottomItem3) expect(activePaneContainers).toEqual([bottomDock]) expect(activePanes).toEqual([bottomPane2]) expect(activeItems).toEqual([bottomItem3]) clearEvents() center.activate() center.activate() expect(workspace.getActivePaneContainer()).toBe(center) expect(workspace.getActivePane()).toBe(centerPane2) expect(workspace.getActivePaneItem()).toBe(centerItem3) expect(activePaneContainers).toEqual([center]) expect(activePanes).toEqual([centerPane2]) expect(activeItems).toEqual([centerItem3]) clearEvents() centerPane1.activate() centerPane1.activate() expect(workspace.getActivePaneContainer()).toBe(center) expect(workspace.getActivePane()).toBe(centerPane1) expect(workspace.getActivePaneItem()).toBe(centerItem1) expect(activePaneContainers).toEqual([]) expect(activePanes).toEqual([centerPane1]) expect(activeItems).toEqual([centerItem1]) }) }) describe('::onDidStopChangingActivePaneItem()', function () { it('invokes observers when the active item of the active pane stops changing', function () { const pane1 = atom.workspace.getCenter().getActivePane() const pane2 = pane1.splitRight({items: [document.createElement('div'), document.createElement('div')]}); atom.workspace.getLeftDock().getActivePane().addItem(document.createElement('div')) emittedItems = [] atom.workspace.onDidStopChangingActivePaneItem(item => emittedItems.push(item)) pane2.activateNextItem() pane2.activateNextItem() pane1.activate() atom.workspace.getLeftDock().activate() advanceClock(100) expect(emittedItems).toEqual([atom.workspace.getLeftDock().getActivePaneItem()]) }) }) describe('the grammar-used hook', () => { it('fires when opening a file or changing the grammar of an open file', () => { let editor = null let javascriptGrammarUsed = false let coffeescriptGrammarUsed = false atom.packages.triggerDeferredActivationHooks() runs(() => { atom.packages.onDidTriggerActivationHook('language-javascript:grammar-used', () => { javascriptGrammarUsed = true }) atom.packages.onDidTriggerActivationHook('language-coffee-script:grammar-used', () => { coffeescriptGrammarUsed = true }) }) waitsForPromise(() => atom.workspace.open('sample.js', {autoIndent: false}).then(o => { editor = o })) waitsForPromise(() => atom.packages.activatePackage('language-javascript')) waitsFor(() => javascriptGrammarUsed) waitsForPromise(() => atom.packages.activatePackage('language-coffee-script')) runs(() => editor.setGrammar(atom.grammars.selectGrammar('.coffee'))) waitsFor(() => coffeescriptGrammarUsed) }) }) describe('::reopenItem()', () => { it("opens the uri associated with the last closed pane that isn't currently open", () => { const pane = workspace.getActivePane() waitsForPromise(() => workspace.open('a').then(() => workspace.open('b').then(() => workspace.open('file1').then(() => workspace.open()) ) ) ) runs(() => { // does not reopen items with no uri expect(workspace.getActivePaneItem().getURI()).toBeUndefined() pane.destroyActiveItem() }) waitsForPromise(() => workspace.reopenItem()) const firstDirectory = atom.project.getDirectories()[0] expect(firstDirectory).toBeDefined() runs(() => { expect(workspace.getActivePaneItem().getURI()).not.toBeUndefined() // destroy all items expect(workspace.getActivePaneItem().getURI()).toBe(firstDirectory.resolve('file1')) pane.destroyActiveItem() expect(workspace.getActivePaneItem().getURI()).toBe(firstDirectory.resolve('b')) pane.destroyActiveItem() expect(workspace.getActivePaneItem().getURI()).toBe(firstDirectory.resolve('a')) pane.destroyActiveItem() // reopens items with uris expect(workspace.getActivePaneItem()).toBeUndefined() }) waitsForPromise(() => workspace.reopenItem()) runs(() => expect(workspace.getActivePaneItem().getURI()).toBe(firstDirectory.resolve('a'))) // does not reopen items that are already open waitsForPromise(() => workspace.open('b')) runs(() => expect(workspace.getActivePaneItem().getURI()).toBe(firstDirectory.resolve('b'))) waitsForPromise(() => workspace.reopenItem()) runs(() => expect(workspace.getActivePaneItem().getURI()).toBe(firstDirectory.resolve('file1'))) }) }) describe('::increase/decreaseFontSize()', () => { it('increases/decreases the font size without going below 1', () => { atom.config.set('editor.fontSize', 1) workspace.increaseFontSize() expect(atom.config.get('editor.fontSize')).toBe(2) workspace.increaseFontSize() expect(atom.config.get('editor.fontSize')).toBe(3) workspace.decreaseFontSize() expect(atom.config.get('editor.fontSize')).toBe(2) workspace.decreaseFontSize() expect(atom.config.get('editor.fontSize')).toBe(1) workspace.decreaseFontSize() expect(atom.config.get('editor.fontSize')).toBe(1) }) }) describe('::resetFontSize()', () => { it("resets the font size to the window's starting font size", () => { const originalFontSize = atom.config.get('editor.fontSize') workspace.increaseFontSize() expect(atom.config.get('editor.fontSize')).toBe(originalFontSize + 1) workspace.resetFontSize() expect(atom.config.get('editor.fontSize')).toBe(originalFontSize) workspace.decreaseFontSize() expect(atom.config.get('editor.fontSize')).toBe(originalFontSize - 1) workspace.resetFontSize() expect(atom.config.get('editor.fontSize')).toBe(originalFontSize) }) it('does nothing if the font size has not been changed', () => { const originalFontSize = atom.config.get('editor.fontSize') workspace.resetFontSize() expect(atom.config.get('editor.fontSize')).toBe(originalFontSize) }) it("resets the font size when the editor's font size changes", () => { const originalFontSize = atom.config.get('editor.fontSize') atom.config.set('editor.fontSize', originalFontSize + 1) workspace.resetFontSize() expect(atom.config.get('editor.fontSize')).toBe(originalFontSize) atom.config.set('editor.fontSize', originalFontSize - 1) workspace.resetFontSize() expect(atom.config.get('editor.fontSize')).toBe(originalFontSize) }) }) describe('::openLicense()', () => { it('opens the license as plain-text in a buffer', () => { waitsForPromise(() => workspace.openLicense()) runs(() => expect(workspace.getActivePaneItem().getText()).toMatch(/Copyright/)) }) }) describe('::isTextEditor(obj)', () => { it('returns true when the passed object is an instance of `TextEditor`', () => { expect(workspace.isTextEditor(new TextEditor())).toBe(true) expect(workspace.isTextEditor({getText: () => null})).toBe(false) expect(workspace.isTextEditor(null)).toBe(false) expect(workspace.isTextEditor(undefined)).toBe(false) }) }) describe('::observeTextEditors()', () => { it('invokes the observer with current and future text editors', () => { const observed = [] waitsForPromise(() => workspace.open()) waitsForPromise(() => workspace.open()) waitsForPromise(() => workspace.openLicense()) runs(() => workspace.observeTextEditors(editor => observed.push(editor))) waitsForPromise(() => workspace.open()) expect(observed).toEqual(workspace.getTextEditors()) }) }) describe('when an editor is destroyed', () => { it('removes the editor', () => { let editor = null waitsForPromise(() => workspace.open('a').then(e => { editor = e })) runs(() => { expect(workspace.getTextEditors()).toHaveLength(1) editor.destroy() expect(workspace.getTextEditors()).toHaveLength(0) }) }) }) describe('when an editor is copied because its pane is split', () => { it('sets up the new editor to be configured by the text editor registry', () => { waitsForPromise(() => atom.packages.activatePackage('language-javascript')) waitsForPromise(() => workspace.open('a').then(editor => { atom.textEditors.setGrammarOverride(editor, 'source.js') expect(editor.getGrammar().name).toBe('JavaScript') workspace.getActivePane().splitRight({copyActiveItem: true}) const newEditor = workspace.getActiveTextEditor() expect(newEditor).not.toBe(editor) expect(newEditor.getGrammar().name).toBe('JavaScript') }) ) }) }) it('stores the active grammars used by all the open editors', () => { waitsForPromise(() => atom.packages.activatePackage('language-javascript')) waitsForPromise(() => atom.packages.activatePackage('language-coffee-script')) waitsForPromise(() => atom.packages.activatePackage('language-todo')) waitsForPromise(() => atom.workspace.open('sample.coffee')) runs(function () { atom.workspace.getActiveTextEditor().setText(`\ i = /test/; #FIXME\ ` ) const atom2 = new AtomEnvironment({applicationDelegate: atom.applicationDelegate}) atom2.initialize({ window: document.createElement('div'), document: Object.assign( document.createElement('div'), { body: document.createElement('div'), head: document.createElement('div') } ) }) atom2.packages.loadPackage('language-javascript') atom2.packages.loadPackage('language-coffee-script') atom2.packages.loadPackage('language-todo') 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)', 'JavaScript', 'Null Grammar', 'Regular Expression Replacement (JavaScript)', 'Regular Expressions (JavaScript)', 'TODO' ]) atom2.destroy() }) }) describe('document.title', () => { describe('when there is no item open', () => { it('sets the title to the project path', () => expect(document.title).toMatch(escapeStringRegex(fs.tildify(atom.project.getPaths()[0])))) it("sets the title to 'untitled' if there is no project path", () => { atom.project.setPaths([]) expect(document.title).toMatch(/^untitled/) }) }) describe("when the active pane item's path is not inside a project path", () => { beforeEach(() => waitsForPromise(() => atom.workspace.open('b').then(() => atom.project.setPaths([])) ) ) it("sets the title to the pane item's title plus the item's path", () => { const item = atom.workspace.getActivePaneItem() const pathEscaped = fs.tildify(escapeStringRegex(path.dirname(item.getPath()))) expect(document.title).toMatch(new RegExp(`^${item.getTitle()} \\u2014 ${pathEscaped}`)) }) describe('when the title of the active pane item changes', () => { it("updates the window title based on the item's new title", () => { const editor = atom.workspace.getActivePaneItem() editor.buffer.setPath(path.join(temp.dir, 'hi')) const pathEscaped = fs.tildify(escapeStringRegex(path.dirname(editor.getPath()))) expect(document.title).toMatch(new RegExp(`^${editor.getTitle()} \\u2014 ${pathEscaped}`)) }) }) describe("when the active pane's item changes", () => { it("updates the title to the new item's title plus the project path", () => { atom.workspace.getActivePane().activateNextItem() const item = atom.workspace.getActivePaneItem() const pathEscaped = fs.tildify(escapeStringRegex(path.dirname(item.getPath()))) expect(document.title).toMatch(new RegExp(`^${item.getTitle()} \\u2014 ${pathEscaped}`)) }) }) describe("when an inactive pane's item changes", () => { it('does not update the title', () => { const pane = atom.workspace.getActivePane() pane.splitRight() const initialTitle = document.title pane.activateNextItem() expect(document.title).toBe(initialTitle) }) }) }) describe('when the active pane item is inside a project path', () => { beforeEach(() => waitsForPromise(() => atom.workspace.open('b')) ) describe('when there is an active pane item', () => { it("sets the title to the pane item's title plus the project path", () => { const item = atom.workspace.getActivePaneItem() const pathEscaped = fs.tildify(escapeStringRegex(atom.project.getPaths()[0])) expect(document.title).toMatch(new RegExp(`^${item.getTitle()} \\u2014 ${pathEscaped}`)) }) }) describe('when the title of the active pane item changes', () => { it("updates the window title based on the item's new title", () => { const editor = atom.workspace.getActivePaneItem() editor.buffer.setPath(path.join(atom.project.getPaths()[0], 'hi')) const pathEscaped = fs.tildify(escapeStringRegex(atom.project.getPaths()[0])) expect(document.title).toMatch(new RegExp(`^${editor.getTitle()} \\u2014 ${pathEscaped}`)) }) }) describe("when the active pane's item changes", () => { it("updates the title to the new item's title plus the project path", () => { atom.workspace.getActivePane().activateNextItem() const item = atom.workspace.getActivePaneItem() const pathEscaped = fs.tildify(escapeStringRegex(atom.project.getPaths()[0])) expect(document.title).toMatch(new RegExp(`^${item.getTitle()} \\u2014 ${pathEscaped}`)) }) }) describe('when the last pane item is removed', () => { it("updates the title to the project's first path", () => { atom.workspace.getActivePane().destroy() expect(atom.workspace.getActivePaneItem()).toBeUndefined() expect(document.title).toMatch(escapeStringRegex(fs.tildify(atom.project.getPaths()[0]))) }) }) describe("when an inactive pane's item changes", () => { it('does not update the title', () => { const pane = atom.workspace.getActivePane() pane.splitRight() const initialTitle = document.title pane.activateNextItem() expect(document.title).toBe(initialTitle) }) }) }) describe('when the workspace is deserialized', () => { beforeEach(() => waitsForPromise(() => atom.workspace.open('a'))) it("updates the title to contain the project's path", () => { document.title = null const atom2 = new AtomEnvironment({applicationDelegate: atom.applicationDelegate}) atom2.initialize({ window: document.createElement('div'), document: Object.assign( document.createElement('div'), { body: document.createElement('div'), head: document.createElement('div') } ) }) atom2.project.deserialize(atom.project.serialize()) atom2.workspace.deserialize(atom.workspace.serialize(), atom2.deserializers) const item = atom2.workspace.getActivePaneItem() const pathEscaped = fs.tildify(escapeStringRegex(atom.project.getPaths()[0])) expect(document.title).toMatch(new RegExp(`^${item.getLongTitle()} \\u2014 ${pathEscaped}`)) atom2.destroy() }) }) }) describe('document edited status', () => { let item1 let item2 beforeEach(() => { waitsForPromise(() => atom.workspace.open('a')) waitsForPromise(() => atom.workspace.open('b')) runs(() => { [item1, item2] = atom.workspace.getPaneItems() }) }) it('calls setDocumentEdited when the active item changes', () => { expect(atom.workspace.getActivePaneItem()).toBe(item2) item1.insertText('a') expect(item1.isModified()).toBe(true) atom.workspace.getActivePane().activateNextItem() expect(setDocumentEdited).toHaveBeenCalledWith(true) }) it("calls atom.setDocumentEdited when the active item's modified status changes", () => { expect(atom.workspace.getActivePaneItem()).toBe(item2) item2.insertText('a') advanceClock(item2.getBuffer().getStoppedChangingDelay()) expect(item2.isModified()).toBe(true) expect(setDocumentEdited).toHaveBeenCalledWith(true) item2.undo() advanceClock(item2.getBuffer().getStoppedChangingDelay()) expect(item2.isModified()).toBe(false) expect(setDocumentEdited).toHaveBeenCalledWith(false) }) }) describe('adding panels', () => { class TestItem {} // Don't use ES6 classes because then we'll have to call `super()` which we can't do with // HTMLElement function TestItemElement () { this.constructor = TestItemElement } function Ctor () { this.constructor = TestItemElement } Ctor.prototype = HTMLElement.prototype TestItemElement.prototype = new Ctor() TestItemElement.__super__ = HTMLElement.prototype TestItemElement.prototype.initialize = function (model) { this.model = model; return this } TestItemElement.prototype.getModel = function () { return this.model } beforeEach(() => atom.views.addViewProvider(TestItem, model => new TestItemElement().initialize(model)) ) describe('::addLeftPanel(model)', () => { it('adds a panel to the correct panel container', () => { let addPanelSpy expect(atom.workspace.getLeftPanels().length).toBe(0) atom.workspace.panelContainers.left.onDidAddPanel(addPanelSpy = jasmine.createSpy()) const model = new TestItem() const panel = atom.workspace.addLeftPanel({item: model}) expect(panel).toBeDefined() expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0}) const itemView = atom.views.getView(atom.workspace.getLeftPanels()[0].getItem()) expect(itemView instanceof TestItemElement).toBe(true) expect(itemView.getModel()).toBe(model) }) }) describe('::addRightPanel(model)', () => { it('adds a panel to the correct panel container', () => { let addPanelSpy expect(atom.workspace.getRightPanels().length).toBe(0) atom.workspace.panelContainers.right.onDidAddPanel(addPanelSpy = jasmine.createSpy()) const model = new TestItem() const panel = atom.workspace.addRightPanel({item: model}) expect(panel).toBeDefined() expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0}) const itemView = atom.views.getView(atom.workspace.getRightPanels()[0].getItem()) expect(itemView instanceof TestItemElement).toBe(true) expect(itemView.getModel()).toBe(model) }) }) describe('::addTopPanel(model)', () => { it('adds a panel to the correct panel container', () => { let addPanelSpy expect(atom.workspace.getTopPanels().length).toBe(0) atom.workspace.panelContainers.top.onDidAddPanel(addPanelSpy = jasmine.createSpy()) const model = new TestItem() const panel = atom.workspace.addTopPanel({item: model}) expect(panel).toBeDefined() expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0}) const itemView = atom.views.getView(atom.workspace.getTopPanels()[0].getItem()) expect(itemView instanceof TestItemElement).toBe(true) expect(itemView.getModel()).toBe(model) }) }) describe('::addBottomPanel(model)', () => { it('adds a panel to the correct panel container', () => { let addPanelSpy expect(atom.workspace.getBottomPanels().length).toBe(0) atom.workspace.panelContainers.bottom.onDidAddPanel(addPanelSpy = jasmine.createSpy()) const model = new TestItem() const panel = atom.workspace.addBottomPanel({item: model}) expect(panel).toBeDefined() expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0}) const itemView = atom.views.getView(atom.workspace.getBottomPanels()[0].getItem()) expect(itemView instanceof TestItemElement).toBe(true) expect(itemView.getModel()).toBe(model) }) }) describe('::addHeaderPanel(model)', () => { it('adds a panel to the correct panel container', () => { let addPanelSpy expect(atom.workspace.getHeaderPanels().length).toBe(0) atom.workspace.panelContainers.header.onDidAddPanel(addPanelSpy = jasmine.createSpy()) const model = new TestItem() const panel = atom.workspace.addHeaderPanel({item: model}) expect(panel).toBeDefined() expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0}) const itemView = atom.views.getView(atom.workspace.getHeaderPanels()[0].getItem()) expect(itemView instanceof TestItemElement).toBe(true) expect(itemView.getModel()).toBe(model) }) }) describe('::addFooterPanel(model)', () => { it('adds a panel to the correct panel container', () => { let addPanelSpy expect(atom.workspace.getFooterPanels().length).toBe(0) atom.workspace.panelContainers.footer.onDidAddPanel(addPanelSpy = jasmine.createSpy()) const model = new TestItem() const panel = atom.workspace.addFooterPanel({item: model}) expect(panel).toBeDefined() expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0}) const itemView = atom.views.getView(atom.workspace.getFooterPanels()[0].getItem()) expect(itemView instanceof TestItemElement).toBe(true) expect(itemView.getModel()).toBe(model) }) }) describe('::addModalPanel(model)', () => { it('adds a panel to the correct panel container', () => { let addPanelSpy expect(atom.workspace.getModalPanels().length).toBe(0) atom.workspace.panelContainers.modal.onDidAddPanel(addPanelSpy = jasmine.createSpy()) const model = new TestItem() const panel = atom.workspace.addModalPanel({item: model}) expect(panel).toBeDefined() expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0}) const itemView = atom.views.getView(atom.workspace.getModalPanels()[0].getItem()) expect(itemView instanceof TestItemElement).toBe(true) expect(itemView.getModel()).toBe(model) }) }) describe('::panelForItem(item)', () => { it('returns the panel associated with the item', () => { const item = new TestItem() const panel = atom.workspace.addLeftPanel({item}) const itemWithNoPanel = new TestItem() expect(atom.workspace.panelForItem(item)).toBe(panel) expect(atom.workspace.panelForItem(itemWithNoPanel)).toBe(null) }) }) }) describe('::scan(regex, options, callback)', () => { describe('when called with a regex', () => { it('calls the callback with all regex results in all files in the project', () => { const results = [] waitsForPromise(() => atom.workspace.scan( /(a)+/, {leadingContextLineCount: 1, trailingContextLineCount: 1}, result => results.push(result)) ) runs(() => { expect(results).toHaveLength(3) expect(results[0].filePath).toBe(atom.project.getDirectories()[0].resolve('a')) expect(results[0].matches).toHaveLength(3) expect(results[0].matches[0]).toEqual({ matchText: 'aaa', lineText: 'aaa bbb', lineTextOffset: 0, range: [[0, 0], [0, 3]], leadingContextLines: [], trailingContextLines: ['cc aa cc'] }) }) }) it('works with with escaped literals (like $ and ^)', () => { const results = [] waitsForPromise(() => atom.workspace.scan( /\$\w+/, {leadingContextLineCount: 1, trailingContextLineCount: 1}, result => results.push(result))) runs(() => { expect(results.length).toBe(1) const {filePath, matches} = results[0] expect(filePath).toBe(atom.project.getDirectories()[0].resolve('a')) expect(matches).toHaveLength(1) expect(matches[0]).toEqual({ matchText: '$bill', lineText: 'dollar$bill', lineTextOffset: 0, range: [[2, 6], [2, 11]], leadingContextLines: ['cc aa cc'], trailingContextLines: [] }) }) }) it('works on evil filenames', () => { atom.config.set('core.excludeVcsIgnoredPaths', false) platform.generateEvilFiles() atom.project.setPaths([path.join(__dirname, 'fixtures', 'evil-files')]) const paths = [] let matches = [] waitsForPromise(() => atom.workspace.scan(/evil/, result => { paths.push(result.filePath) matches = matches.concat(result.matches) }) ) runs(() => { _.each(matches, m => expect(m.matchText).toEqual('evil')) if (platform.isWindows()) { expect(paths.length).toBe(3) expect(paths[0]).toMatch(/a_file_with_utf8.txt$/) expect(paths[1]).toMatch(/file with spaces.txt$/) expect(path.basename(paths[2])).toBe('utfa\u0306.md') } else { expect(paths.length).toBe(5) expect(paths[0]).toMatch(/a_file_with_utf8.txt$/) expect(paths[1]).toMatch(/file with spaces.txt$/) expect(paths[2]).toMatch(/goddam\nnewlines$/m) expect(paths[3]).toMatch(/quote".txt$/m) expect(path.basename(paths[4])).toBe('utfa\u0306.md') } }) }) it('ignores case if the regex includes the `i` flag', () => { const results = [] waitsForPromise(() => atom.workspace.scan(/DOLLAR/i, result => results.push(result))) runs(() => expect(results).toHaveLength(1)) }) describe('when the core.excludeVcsIgnoredPaths config is truthy', () => { let projectPath let ignoredPath beforeEach(() => { const sourceProjectPath = path.join(__dirname, 'fixtures', 'git', 'working-dir') projectPath = path.join(temp.mkdirSync('atom')) const writerStream = fstream.Writer(projectPath) fstream.Reader(sourceProjectPath).pipe(writerStream) waitsFor(done => { writerStream.on('close', done) writerStream.on('error', done) }) runs(() => { fs.rename(path.join(projectPath, 'git.git'), path.join(projectPath, '.git')) ignoredPath = path.join(projectPath, 'ignored.txt') fs.writeFileSync(ignoredPath, 'this match should not be included') }) }) afterEach(() => { if (fs.existsSync(projectPath)) { fs.removeSync(projectPath) } }) it('excludes ignored files', () => { atom.project.setPaths([projectPath]) atom.config.set('core.excludeVcsIgnoredPaths', true) const resultHandler = jasmine.createSpy('result found') waitsForPromise(() => atom.workspace.scan(/match/, results => resultHandler()) ) runs(() => expect(resultHandler).not.toHaveBeenCalled()) }) }) it('includes only files when a directory filter is specified', () => { const projectPath = path.join(path.join(__dirname, 'fixtures', 'dir')) atom.project.setPaths([projectPath]) const filePath = path.join(projectPath, 'a-dir', 'oh-git') const paths = [] let matches = [] waitsForPromise(() => atom.workspace.scan(/aaa/, {paths: [`a-dir${path.sep}`]}, result => { paths.push(result.filePath) matches = matches.concat(result.matches) }) ) runs(() => { expect(paths.length).toBe(1) expect(paths[0]).toBe(filePath) expect(matches.length).toBe(1) }) }) it("includes files and folders that begin with a '.'", () => { const projectPath = temp.mkdirSync('atom-spec-workspace') const filePath = path.join(projectPath, '.text') fs.writeFileSync(filePath, 'match this') atom.project.setPaths([projectPath]) const paths = [] let matches = [] waitsForPromise(() => atom.workspace.scan(/match this/, result => { paths.push(result.filePath) matches = matches.concat(result.matches) }) ) runs(() => { expect(paths.length).toBe(1) expect(paths[0]).toBe(filePath) expect(matches.length).toBe(1) }) }) it('excludes values in core.ignoredNames', () => { const ignoredNames = atom.config.get('core.ignoredNames') ignoredNames.push('a') atom.config.set('core.ignoredNames', ignoredNames) const resultHandler = jasmine.createSpy('result found') waitsForPromise(() => atom.workspace.scan(/dollar/, results => resultHandler()) ) runs(() => expect(resultHandler).not.toHaveBeenCalled()) }) it('scans buffer contents if the buffer is modified', () => { let editor = null const results = [] waitsForPromise(() => atom.workspace.open('a').then(o => { editor = o editor.setText('Elephant') }) ) waitsForPromise(() => atom.workspace.scan(/a|Elephant/, result => results.push(result))) runs(() => { expect(results).toHaveLength(3) const resultForA = _.find(results, ({filePath}) => path.basename(filePath) === 'a') expect(resultForA.matches).toHaveLength(1) expect(resultForA.matches[0].matchText).toBe('Elephant') }) }) it('ignores buffers outside the project', () => { let editor = null const results = [] waitsForPromise(() => atom.workspace.open(temp.openSync().path).then(o => { editor = o editor.setText('Elephant') }) ) waitsForPromise(() => atom.workspace.scan(/Elephant/, result => results.push(result))) runs(() => expect(results).toHaveLength(0)) }) describe('when the project has multiple root directories', () => { let dir1 let dir2 let file1 let file2 beforeEach(() => { dir1 = atom.project.getPaths()[0] file1 = path.join(dir1, 'a-dir', 'oh-git') dir2 = temp.mkdirSync('a-second-dir') const aDir2 = path.join(dir2, 'a-dir') file2 = path.join(aDir2, 'a-file') fs.mkdirSync(aDir2) fs.writeFileSync(file2, 'ccc aaaa') atom.project.addPath(dir2) }) it("searches matching files in all of the project's root directories", () => { const resultPaths = [] waitsForPromise(() => atom.workspace.scan(/aaaa/, ({filePath}) => resultPaths.push(filePath)) ) runs(() => expect(resultPaths.sort()).toEqual([file1, file2].sort())) }) describe('when an inclusion path starts with the basename of a root directory', () => { it('interprets the inclusion path as starting from that directory', () => { waitsForPromise(() => { const resultPaths = [] return atom.workspace .scan(/aaaa/, {paths: ['dir']}, ({filePath}) => { if (!resultPaths.includes(filePath)) { resultPaths.push(filePath) } }) .then(() => expect(resultPaths).toEqual([file1])) }) waitsForPromise(() => { const resultPaths = [] return atom.workspace .scan(/aaaa/, {paths: [path.join('dir', 'a-dir')]}, ({filePath}) => { if (!resultPaths.includes(filePath)) { resultPaths.push(filePath) } }) .then(() => expect(resultPaths).toEqual([file1])) }) waitsForPromise(() => { const resultPaths = [] return atom.workspace .scan(/aaaa/, {paths: [path.basename(dir2)]}, ({filePath}) => { if (!resultPaths.includes(filePath)) { resultPaths.push(filePath) } }) .then(() => expect(resultPaths).toEqual([file2])) }) waitsForPromise(() => { const resultPaths = [] return atom.workspace .scan(/aaaa/, {paths: [path.join(path.basename(dir2), 'a-dir')]}, ({filePath}) => { if (!resultPaths.includes(filePath)) { resultPaths.push(filePath) } }) .then(() => expect(resultPaths).toEqual([file2])) }) }) }) describe('when a custom directory searcher is registered', () => { let fakeSearch = null // Function that is invoked once all of the fields on fakeSearch are set. let onFakeSearchCreated = null class FakeSearch { constructor (options) { // Note that hoisting resolve and reject in this way is generally frowned upon. this.options = options this.promise = new Promise((resolve, reject) => { this.hoistedResolve = resolve this.hoistedReject = reject if (typeof onFakeSearchCreated === 'function') { onFakeSearchCreated(this) } }) } then (...args) { return this.promise.then.apply(this.promise, args) } cancel () { this.cancelled = true // According to the spec for a DirectorySearcher, invoking `cancel()` should // resolve the thenable rather than reject it. this.hoistedResolve() } } beforeEach(() => { fakeSearch = null onFakeSearchCreated = null atom.packages.serviceHub.provide('atom.directory-searcher', '0.1.0', { canSearchDirectory (directory) { return directory.getPath() === dir1 }, search (directory, regex, options) { fakeSearch = new FakeSearch(options) return fakeSearch } }) waitsFor(() => atom.workspace.directorySearchers.length > 0) }) it('can override the DefaultDirectorySearcher on a per-directory basis', () => { const foreignFilePath = 'ssh://foreign-directory:8080/hello.txt' const numPathsSearchedInDir2 = 1 const numPathsToPretendToSearchInCustomDirectorySearcher = 10 const searchResult = { filePath: foreignFilePath, matches: [ { lineText: 'Hello world', lineTextOffset: 0, matchText: 'Hello', range: [[0, 0], [0, 5]] } ] } onFakeSearchCreated = fakeSearch => { fakeSearch.options.didMatch(searchResult) fakeSearch.options.didSearchPaths(numPathsToPretendToSearchInCustomDirectorySearcher) fakeSearch.hoistedResolve() } const resultPaths = [] const onPathsSearched = jasmine.createSpy('onPathsSearched') waitsForPromise(() => atom.workspace.scan(/aaaa/, {onPathsSearched}, ({filePath}) => resultPaths.push(filePath)) ) runs(() => { expect(resultPaths.sort()).toEqual([foreignFilePath, file2].sort()) // onPathsSearched should be called once by each DirectorySearcher. The order is not // guaranteed, so we can only verify the total number of paths searched is correct // after the second call. expect(onPathsSearched.callCount).toBe(2) expect(onPathsSearched.mostRecentCall.args[0]).toBe( numPathsToPretendToSearchInCustomDirectorySearcher + numPathsSearchedInDir2) }) }) it('can be cancelled when the object returned by scan() has its cancel() method invoked', () => { const thenable = atom.workspace.scan(/aaaa/, () => {}) let resultOfPromiseSearch = null waitsFor('fakeSearch to be defined', () => fakeSearch != null) runs(() => { expect(fakeSearch.cancelled).toBe(undefined) thenable.cancel() expect(fakeSearch.cancelled).toBe(true) }) waitsForPromise(() => thenable.then(promiseResult => { resultOfPromiseSearch = promiseResult })) runs(() => expect(resultOfPromiseSearch).toBe('cancelled')) }) it('will have the side-effect of failing the overall search if it fails', () => { // This provider's search should be cancelled when the first provider fails let cancelableSearch let fakeSearch2 = null atom.packages.serviceHub.provide('atom.directory-searcher', '0.1.0', { canSearchDirectory (directory) { return directory.getPath() === dir2 }, search (directory, regex, options) { fakeSearch2 = new FakeSearch(options) return fakeSearch2 } }) let didReject = false const promise = cancelableSearch = atom.workspace.scan(/aaaa/, () => {}) waitsFor('fakeSearch to be defined', () => fakeSearch != null) runs(() => fakeSearch.hoistedReject()) waitsForPromise(() => cancelableSearch.catch(() => { didReject = true })) waitsFor(done => promise.then(null, done)) runs(() => { expect(didReject).toBe(true) expect(fakeSearch2.cancelled).toBe(true) }) }) }) }) }) }) // Cancels other ongoing searches describe('::replace(regex, replacementText, paths, iterator)', () => { let filePath let commentFilePath let sampleContent let sampleCommentContent beforeEach(() => { atom.project.setPaths([atom.project.getDirectories()[0].resolve('../')]) filePath = atom.project.getDirectories()[0].resolve('sample.js') commentFilePath = atom.project.getDirectories()[0].resolve('sample-with-comments.js') sampleContent = fs.readFileSync(filePath).toString() sampleCommentContent = fs.readFileSync(commentFilePath).toString() }) afterEach(() => { fs.writeFileSync(filePath, sampleContent) fs.writeFileSync(commentFilePath, sampleCommentContent) }) describe("when a file doesn't exist", () => { it('calls back with an error', () => { const errors = [] const missingPath = path.resolve('/not-a-file.js') expect(fs.existsSync(missingPath)).toBeFalsy() waitsForPromise(() => atom.workspace.replace(/items/gi, 'items', [missingPath], (result, error) => errors.push(error)) ) runs(() => { expect(errors).toHaveLength(1) expect(errors[0].path).toBe(missingPath) }) }) }) describe('when called with unopened files', () => { it('replaces properly', () => { const results = [] waitsForPromise(() => atom.workspace.replace(/items/gi, 'items', [filePath], result => results.push(result)) ) runs(() => { expect(results).toHaveLength(1) expect(results[0].filePath).toBe(filePath) expect(results[0].replacements).toBe(6) }) }) }) describe('when a buffer is already open', () => { it('replaces properly and saves when not modified', () => { let editor = null const results = [] waitsForPromise(() => atom.workspace.open('sample.js').then(o => { editor = o })) runs(() => expect(editor.isModified()).toBeFalsy()) waitsForPromise(() => atom.workspace.replace(/items/gi, 'items', [filePath], result => results.push(result)) ) runs(() => { expect(results).toHaveLength(1) expect(results[0].filePath).toBe(filePath) expect(results[0].replacements).toBe(6) expect(editor.isModified()).toBeFalsy() }) }) it('does not replace when the path is not specified', () => { const results = [] waitsForPromise(() => atom.workspace.open('sample-with-comments.js')) waitsForPromise(() => atom.workspace.replace(/items/gi, 'items', [commentFilePath], result => results.push(result)) ) runs(() => { expect(results).toHaveLength(1) expect(results[0].filePath).toBe(commentFilePath) }) }) it('does NOT save when modified', () => { let editor = null const results = [] waitsForPromise(() => atom.workspace.open('sample.js').then(o => { editor = o })) runs(() => { editor.buffer.setTextInRange([[0, 0], [0, 0]], 'omg') expect(editor.isModified()).toBeTruthy() }) waitsForPromise(() => atom.workspace.replace(/items/gi, 'okthen', [filePath], result => results.push(result)) ) runs(() => { expect(results).toHaveLength(1) expect(results[0].filePath).toBe(filePath) expect(results[0].replacements).toBe(6) expect(editor.isModified()).toBeTruthy() }) }) }) }) describe('::saveActivePaneItem()', () => { let editor = null beforeEach(() => waitsForPromise(() => atom.workspace.open('sample.js').then(o => { editor = o })) ) describe('when there is an error', () => { it('emits a warning notification when the file cannot be saved', () => { let addedSpy spyOn(editor, 'save').andCallFake(() => { throw new Error("'/some/file' is a directory") }) atom.notifications.onDidAddNotification(addedSpy = jasmine.createSpy()) atom.workspace.saveActivePaneItem() expect(addedSpy).toHaveBeenCalled() expect(addedSpy.mostRecentCall.args[0].getType()).toBe('warning') }) it('emits a warning notification when the directory cannot be written to', () => { let addedSpy spyOn(editor, 'save').andCallFake(() => { throw new Error("ENOTDIR, not a directory '/Some/dir/and-a-file.js'") }) atom.notifications.onDidAddNotification(addedSpy = jasmine.createSpy()) atom.workspace.saveActivePaneItem() expect(addedSpy).toHaveBeenCalled() expect(addedSpy.mostRecentCall.args[0].getType()).toBe('warning') }) it('emits a warning notification when the user does not have permission', () => { let addedSpy spyOn(editor, 'save').andCallFake(() => { const error = new Error("EACCES, permission denied '/Some/dir/and-a-file.js'") error.code = 'EACCES' error.path = '/Some/dir/and-a-file.js' throw error }) atom.notifications.onDidAddNotification(addedSpy = jasmine.createSpy()) atom.workspace.saveActivePaneItem() expect(addedSpy).toHaveBeenCalled() expect(addedSpy.mostRecentCall.args[0].getType()).toBe('warning') }) it('emits a warning notification when the operation is not permitted', () => { spyOn(editor, 'save').andCallFake(() => { const error = new Error("EPERM, operation not permitted '/Some/dir/and-a-file.js'") error.code = 'EPERM' error.path = '/Some/dir/and-a-file.js' throw error }) }) it('emits a warning notification when the file is already open by another app', () => { let addedSpy spyOn(editor, 'save').andCallFake(() => { const error = new Error("EBUSY, resource busy or locked '/Some/dir/and-a-file.js'") error.code = 'EBUSY' error.path = '/Some/dir/and-a-file.js' throw error }) atom.notifications.onDidAddNotification(addedSpy = jasmine.createSpy()) atom.workspace.saveActivePaneItem() expect(addedSpy).toHaveBeenCalled() const notificaiton = addedSpy.mostRecentCall.args[0] expect(notificaiton.getType()).toBe('warning') expect(notificaiton.getMessage()).toContain('Unable to save') }) it('emits a warning notification when the file system is read-only', () => { let addedSpy spyOn(editor, 'save').andCallFake(() => { const error = new Error("EROFS, read-only file system '/Some/dir/and-a-file.js'") error.code = 'EROFS' error.path = '/Some/dir/and-a-file.js' throw error }) atom.notifications.onDidAddNotification(addedSpy = jasmine.createSpy()) atom.workspace.saveActivePaneItem() expect(addedSpy).toHaveBeenCalled() const notification = addedSpy.mostRecentCall.args[0] expect(notification.getType()).toBe('warning') expect(notification.getMessage()).toContain('Unable to save') }) it('emits a warning notification when the file cannot be saved', () => { spyOn(editor, 'save').andCallFake(() => { throw new Error('no one knows') }) const save = () => atom.workspace.saveActivePaneItem() expect(save).toThrow() }) }) }) describe('::closeActivePaneItemOrEmptyPaneOrWindow', () => { beforeEach(() => { spyOn(atom, 'close') waitsForPromise(() => atom.workspace.open()) }) it('closes the active pane item, or the active pane if it is empty, or the current window if there is only the empty root pane', () => { atom.config.set('core.destroyEmptyPanes', false) const pane1 = atom.workspace.getActivePane() const pane2 = pane1.splitRight({copyActiveItem: true}) expect(atom.workspace.getCenter().getPanes().length).toBe(2) expect(pane2.getItems().length).toBe(1) atom.workspace.closeActivePaneItemOrEmptyPaneOrWindow() expect(atom.workspace.getCenter().getPanes().length).toBe(2) expect(pane2.getItems().length).toBe(0) atom.workspace.closeActivePaneItemOrEmptyPaneOrWindow() expect(atom.workspace.getCenter().getPanes().length).toBe(1) expect(pane1.getItems().length).toBe(1) atom.workspace.closeActivePaneItemOrEmptyPaneOrWindow() expect(atom.workspace.getCenter().getPanes().length).toBe(1) expect(pane1.getItems().length).toBe(0) atom.workspace.closeActivePaneItemOrEmptyPaneOrWindow() expect(atom.workspace.getCenter().getPanes().length).toBe(1) atom.workspace.closeActivePaneItemOrEmptyPaneOrWindow() expect(atom.close).toHaveBeenCalled() }) }) describe('when the core.allowPendingPaneItems option is falsey', () => { it('does not open item with `pending: true` option as pending', () => { let pane = null atom.config.set('core.allowPendingPaneItems', false) waitsForPromise(() => atom.workspace.open('sample.js', {pending: true}).then(() => { pane = atom.workspace.getActivePane() }) ) runs(() => expect(pane.getPendingItem()).toBeFalsy()) }) }) describe('grammar activation', () => { it('notifies the workspace of which grammar is used', () => { atom.packages.triggerDeferredActivationHooks() const javascriptGrammarUsed = jasmine.createSpy('js grammar used') const rubyGrammarUsed = jasmine.createSpy('ruby grammar used') const cGrammarUsed = jasmine.createSpy('c grammar used') atom.packages.onDidTriggerActivationHook('language-javascript:grammar-used', javascriptGrammarUsed) atom.packages.onDidTriggerActivationHook('language-ruby:grammar-used', rubyGrammarUsed) atom.packages.onDidTriggerActivationHook('language-c:grammar-used', cGrammarUsed) waitsForPromise(() => atom.packages.activatePackage('language-ruby')) waitsForPromise(() => atom.packages.activatePackage('language-javascript')) waitsForPromise(() => atom.packages.activatePackage('language-c')) waitsForPromise(() => atom.workspace.open('sample-with-comments.js')) runs(() => { // Hooks are triggered when opening new editors expect(javascriptGrammarUsed).toHaveBeenCalled() // Hooks are triggered when changing existing editors grammars atom.workspace.getActiveTextEditor().setGrammar(atom.grammars.grammarForScopeName('source.c')) expect(cGrammarUsed).toHaveBeenCalled() // Hooks are triggered when editors are added in other ways. atom.workspace.getActivePane().splitRight({copyActiveItem: true}) atom.workspace.getActiveTextEditor().setGrammar(atom.grammars.grammarForScopeName('source.ruby')) expect(rubyGrammarUsed).toHaveBeenCalled() }) }) }) describe('.checkoutHeadRevision()', () => { let editor = null beforeEach(() => { atom.config.set('editor.confirmCheckoutHeadRevision', false) waitsForPromise(() => atom.workspace.open('sample-with-comments.js').then(o => { editor = o })) }) it('reverts to the version of its file checked into the project repository', () => { editor.setCursorBufferPosition([0, 0]) editor.insertText('---\n') expect(editor.lineTextForBufferRow(0)).toBe('---') waitsForPromise(() => atom.workspace.checkoutHeadRevision(editor)) runs(() => expect(editor.lineTextForBufferRow(0)).toBe('')) }) describe("when there's no repository for the editor's file", () => { it("doesn't do anything", () => { editor = new TextEditor() editor.setText('stuff') atom.workspace.checkoutHeadRevision(editor) waitsForPromise(() => atom.workspace.checkoutHeadRevision(editor)) }) }) }) describe('when an item is moved', () => { beforeEach(() => { atom.workspace.enablePersistence = true }) afterEach(async () => { await atom.workspace.itemLocationStore.clear() atom.workspace.enablePersistence = false }) it("stores the new location if it's not the default", () => { const ITEM_URI = 'atom://test' const item = { getURI: () => ITEM_URI, getDefaultLocation: () => 'left', getElement: () => document.createElement('div') } const centerPane = workspace.getActivePane() centerPane.addItem(item) const dockPane = atom.workspace.getRightDock().getActivePane() spyOn(workspace.itemLocationStore, 'save') centerPane.moveItemToPane(item, dockPane) expect(workspace.itemLocationStore.save).toHaveBeenCalledWith(ITEM_URI, 'right') }) it("clears the location if it's the default", () => { const ITEM_URI = 'atom://test' const item = { getURI: () => ITEM_URI, getDefaultLocation: () => 'right', getElement: () => document.createElement('div') } const centerPane = workspace.getActivePane() centerPane.addItem(item) const dockPane = atom.workspace.getRightDock().getActivePane() spyOn(workspace.itemLocationStore, 'save') spyOn(workspace.itemLocationStore, 'delete') centerPane.moveItemToPane(item, dockPane) expect(workspace.itemLocationStore.delete).toHaveBeenCalledWith(ITEM_URI) expect(workspace.itemLocationStore.save).not.toHaveBeenCalled() }) }) }) const escapeStringRegex = str => str.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')