mirror of
https://github.com/pulsar-edit/pulsar.git
synced 2024-11-10 10:17:11 +03:00
1701 lines
56 KiB
JavaScript
1701 lines
56 KiB
JavaScript
const { extend } = require('underscore-plus')
|
|
const { Emitter } = require('event-kit')
|
|
const Grim = require('grim')
|
|
const Pane = require('../src/pane')
|
|
const PaneContainer = require('../src/pane-container')
|
|
const { conditionPromise, timeoutPromise } = require('./async-spec-helpers')
|
|
|
|
describe('Pane', () => {
|
|
let confirm, showSaveDialog, deserializerDisposable
|
|
|
|
class Item {
|
|
static deserialize ({ name, uri }) {
|
|
return new Item(name, uri)
|
|
}
|
|
|
|
constructor (name, uri) {
|
|
this.name = name
|
|
this.uri = uri
|
|
this.emitter = new Emitter()
|
|
this.destroyed = false
|
|
}
|
|
|
|
getURI () {
|
|
return this.uri
|
|
}
|
|
getPath () {
|
|
return this.path
|
|
}
|
|
isEqual (other) {
|
|
return this.name === (other && other.name)
|
|
}
|
|
isPermanentDockItem () {
|
|
return false
|
|
}
|
|
isDestroyed () {
|
|
return this.destroyed
|
|
}
|
|
|
|
serialize () {
|
|
return { deserializer: 'Item', name: this.name, uri: this.uri }
|
|
}
|
|
|
|
copy () {
|
|
return new Item(this.name, this.uri)
|
|
}
|
|
|
|
destroy () {
|
|
this.destroyed = true
|
|
return this.emitter.emit('did-destroy')
|
|
}
|
|
|
|
onDidDestroy (fn) {
|
|
return this.emitter.on('did-destroy', fn)
|
|
}
|
|
|
|
onDidTerminatePendingState (callback) {
|
|
return this.emitter.on('terminate-pending-state', callback)
|
|
}
|
|
|
|
terminatePendingState () {
|
|
return this.emitter.emit('terminate-pending-state')
|
|
}
|
|
}
|
|
|
|
beforeEach(() => {
|
|
confirm = spyOn(atom.applicationDelegate, 'confirm')
|
|
showSaveDialog = spyOn(atom.applicationDelegate, 'showSaveDialog')
|
|
deserializerDisposable = atom.deserializers.add(Item)
|
|
})
|
|
|
|
afterEach(() => {
|
|
deserializerDisposable.dispose()
|
|
})
|
|
|
|
function paneParams (params) {
|
|
return extend(
|
|
{
|
|
applicationDelegate: atom.applicationDelegate,
|
|
config: atom.config,
|
|
deserializerManager: atom.deserializers,
|
|
notificationManager: atom.notifications
|
|
},
|
|
params
|
|
)
|
|
}
|
|
|
|
describe('construction', () => {
|
|
it('sets the active item to the first item', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B')] })
|
|
)
|
|
expect(pane.getActiveItem()).toBe(pane.itemAtIndex(0))
|
|
})
|
|
|
|
it('compacts the items array', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [undefined, new Item('A'), null, new Item('B')] })
|
|
)
|
|
expect(pane.getItems().length).toBe(2)
|
|
expect(pane.getActiveItem()).toBe(pane.itemAtIndex(0))
|
|
})
|
|
})
|
|
|
|
describe('::activate()', () => {
|
|
let container, pane1, pane2
|
|
|
|
beforeEach(() => {
|
|
container = new PaneContainer({
|
|
location: 'center',
|
|
config: atom.config,
|
|
applicationDelegate: atom.applicationDelegate
|
|
})
|
|
container.getActivePane().splitRight()
|
|
;[pane1, pane2] = container.getPanes()
|
|
})
|
|
|
|
it('changes the active pane on the container', () => {
|
|
expect(container.getActivePane()).toBe(pane2)
|
|
pane1.activate()
|
|
expect(container.getActivePane()).toBe(pane1)
|
|
pane2.activate()
|
|
expect(container.getActivePane()).toBe(pane2)
|
|
})
|
|
|
|
it('invokes ::onDidChangeActivePane observers on the container', () => {
|
|
const observed = []
|
|
container.onDidChangeActivePane(activePane => observed.push(activePane))
|
|
|
|
pane1.activate()
|
|
pane1.activate()
|
|
pane2.activate()
|
|
pane1.activate()
|
|
expect(observed).toEqual([pane1, pane2, pane1])
|
|
})
|
|
|
|
it('invokes ::onDidChangeActive observers on the relevant panes', () => {
|
|
const observed = []
|
|
pane1.onDidChangeActive(active => observed.push(active))
|
|
pane1.activate()
|
|
pane2.activate()
|
|
expect(observed).toEqual([true, false])
|
|
})
|
|
|
|
it('invokes ::onDidActivate() observers', () => {
|
|
let eventCount = 0
|
|
pane1.onDidActivate(() => eventCount++)
|
|
pane1.activate()
|
|
pane1.activate()
|
|
pane2.activate()
|
|
expect(eventCount).toBe(2)
|
|
})
|
|
})
|
|
|
|
describe('::addItem(item, index)', () => {
|
|
it('adds the item at the given index', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B')] })
|
|
)
|
|
const [item1, item2] = pane.getItems()
|
|
const item3 = new Item('C')
|
|
pane.addItem(item3, { index: 1 })
|
|
expect(pane.getItems()).toEqual([item1, item3, item2])
|
|
})
|
|
|
|
it('adds the item after the active item if no index is provided', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
const [item1, item2, item3] = pane.getItems()
|
|
pane.activateItem(item2)
|
|
const item4 = new Item('D')
|
|
pane.addItem(item4)
|
|
expect(pane.getItems()).toEqual([item1, item2, item4, item3])
|
|
})
|
|
|
|
it('sets the active item after adding the first item', () => {
|
|
const pane = new Pane(paneParams())
|
|
const item = new Item('A')
|
|
pane.addItem(item)
|
|
expect(pane.getActiveItem()).toBe(item)
|
|
})
|
|
|
|
it('invokes ::onDidAddItem() observers', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B')] })
|
|
)
|
|
const events = []
|
|
pane.onDidAddItem(event => events.push(event))
|
|
|
|
const item = new Item('C')
|
|
pane.addItem(item, { index: 1 })
|
|
expect(events).toEqual([{ item, index: 1, moved: false }])
|
|
})
|
|
|
|
it('throws an exception if the item is already present on a pane', () => {
|
|
const item = new Item('A')
|
|
const container = new PaneContainer({
|
|
config: atom.config,
|
|
applicationDelegate: atom.applicationDelegate
|
|
})
|
|
const pane1 = container.getActivePane()
|
|
pane1.addItem(item)
|
|
const pane2 = pane1.splitRight()
|
|
expect(() => pane2.addItem(item)).toThrow()
|
|
})
|
|
|
|
it("throws an exception if the item isn't an object", () => {
|
|
const pane = new Pane(paneParams({ items: [] }))
|
|
expect(() => pane.addItem(null)).toThrow()
|
|
expect(() => pane.addItem('foo')).toThrow()
|
|
expect(() => pane.addItem(1)).toThrow()
|
|
})
|
|
|
|
it('destroys any existing pending item', () => {
|
|
const pane = new Pane(paneParams({ items: [] }))
|
|
const itemA = new Item('A')
|
|
const itemB = new Item('B')
|
|
const itemC = new Item('C')
|
|
pane.addItem(itemA, { pending: false })
|
|
pane.addItem(itemB, { pending: true })
|
|
pane.addItem(itemC, { pending: false })
|
|
expect(itemB.isDestroyed()).toBe(true)
|
|
})
|
|
|
|
it('adds the new item before destroying any existing pending item', () => {
|
|
const eventOrder = []
|
|
|
|
const pane = new Pane(paneParams({ items: [] }))
|
|
const itemA = new Item('A')
|
|
const itemB = new Item('B')
|
|
pane.addItem(itemA, { pending: true })
|
|
|
|
pane.onDidAddItem(function ({ item }) {
|
|
if (item === itemB) eventOrder.push('add')
|
|
})
|
|
|
|
pane.onDidRemoveItem(function ({ item }) {
|
|
if (item === itemA) eventOrder.push('remove')
|
|
})
|
|
|
|
pane.addItem(itemB)
|
|
|
|
waitsFor(() => eventOrder.length === 2)
|
|
|
|
runs(() => expect(eventOrder).toEqual(['add', 'remove']))
|
|
})
|
|
|
|
it('subscribes to be notified when item terminates its pending state', () => {
|
|
const fakeDisposable = { dispose: () => {} }
|
|
const spy = jasmine
|
|
.createSpy('onDidTerminatePendingState')
|
|
.andReturn(fakeDisposable)
|
|
|
|
const pane = new Pane(paneParams({ items: [] }))
|
|
const item = {
|
|
getTitle: () => '',
|
|
onDidTerminatePendingState: spy
|
|
}
|
|
pane.addItem(item)
|
|
|
|
expect(spy).toHaveBeenCalled()
|
|
})
|
|
|
|
it('subscribes to be notified when item is destroyed', () => {
|
|
const fakeDisposable = { dispose: () => {} }
|
|
const spy = jasmine.createSpy('onDidDestroy').andReturn(fakeDisposable)
|
|
|
|
const pane = new Pane(paneParams({ items: [] }))
|
|
const item = {
|
|
getTitle: () => '',
|
|
onDidDestroy: spy
|
|
}
|
|
pane.addItem(item)
|
|
|
|
expect(spy).toHaveBeenCalled()
|
|
})
|
|
|
|
describe('when using the old API of ::addItem(item, index)', () => {
|
|
beforeEach(() => spyOn(Grim, 'deprecate'))
|
|
|
|
it('supports the older public API', () => {
|
|
const pane = new Pane(paneParams({ items: [] }))
|
|
const itemA = new Item('A')
|
|
const itemB = new Item('B')
|
|
const itemC = new Item('C')
|
|
pane.addItem(itemA, 0)
|
|
pane.addItem(itemB, 0)
|
|
pane.addItem(itemC, 0)
|
|
expect(pane.getItems()).toEqual([itemC, itemB, itemA])
|
|
})
|
|
|
|
it('shows a deprecation warning', () => {
|
|
const pane = new Pane(paneParams({ items: [] }))
|
|
pane.addItem(new Item(), 2)
|
|
expect(Grim.deprecate).toHaveBeenCalledWith(
|
|
'Pane::addItem(item, 2) is deprecated in favor of Pane::addItem(item, {index: 2})'
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::activateItem(item)', () => {
|
|
let pane = null
|
|
|
|
beforeEach(() => {
|
|
pane = new Pane(paneParams({ items: [new Item('A'), new Item('B')] }))
|
|
})
|
|
|
|
it('changes the active item to the current item', () => {
|
|
expect(pane.getActiveItem()).toBe(pane.itemAtIndex(0))
|
|
pane.activateItem(pane.itemAtIndex(1))
|
|
expect(pane.getActiveItem()).toBe(pane.itemAtIndex(1))
|
|
})
|
|
|
|
it("adds the given item if it isn't present in ::items", () => {
|
|
const item = new Item('C')
|
|
pane.activateItem(item)
|
|
expect(pane.getItems().includes(item)).toBe(true)
|
|
expect(pane.getActiveItem()).toBe(item)
|
|
})
|
|
|
|
it('invokes ::onDidChangeActiveItem() observers', () => {
|
|
const observed = []
|
|
pane.onDidChangeActiveItem(item => observed.push(item))
|
|
pane.activateItem(pane.itemAtIndex(1))
|
|
expect(observed).toEqual([pane.itemAtIndex(1)])
|
|
})
|
|
|
|
describe('when the item being activated is pending', () => {
|
|
let itemC = null
|
|
let itemD = null
|
|
|
|
beforeEach(() => {
|
|
itemC = new Item('C')
|
|
itemD = new Item('D')
|
|
})
|
|
|
|
it('replaces the active item if it is pending', () => {
|
|
pane.activateItem(itemC, { pending: true })
|
|
expect(pane.getItems().map(item => item.name)).toEqual(['A', 'C', 'B'])
|
|
pane.activateItem(itemD, { pending: true })
|
|
expect(pane.getItems().map(item => item.name)).toEqual(['A', 'D', 'B'])
|
|
})
|
|
|
|
it('adds the item after the active item if it is not pending', () => {
|
|
pane.activateItem(itemC, { pending: true })
|
|
pane.activateItemAtIndex(2)
|
|
pane.activateItem(itemD, { pending: true })
|
|
expect(pane.getItems().map(item => item.name)).toEqual(['A', 'B', 'D'])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::setPendingItem', () => {
|
|
let pane = null
|
|
|
|
beforeEach(() => {
|
|
pane = atom.workspace.getActivePane()
|
|
})
|
|
|
|
it('changes the pending item', () => {
|
|
expect(pane.getPendingItem()).toBeNull()
|
|
pane.setPendingItem('fake item')
|
|
expect(pane.getPendingItem()).toEqual('fake item')
|
|
})
|
|
})
|
|
|
|
describe('::onItemDidTerminatePendingState callback', () => {
|
|
let pane = null
|
|
let callbackCalled = false
|
|
|
|
beforeEach(() => {
|
|
pane = atom.workspace.getActivePane()
|
|
callbackCalled = false
|
|
})
|
|
|
|
it('is called when the pending item changes', () => {
|
|
pane.setPendingItem('fake item one')
|
|
pane.onItemDidTerminatePendingState(function (item) {
|
|
callbackCalled = true
|
|
expect(item).toEqual('fake item one')
|
|
})
|
|
pane.setPendingItem('fake item two')
|
|
expect(callbackCalled).toBeTruthy()
|
|
})
|
|
|
|
it('has access to the new pending item via ::getPendingItem', () => {
|
|
pane.setPendingItem('fake item one')
|
|
pane.onItemDidTerminatePendingState(function (item) {
|
|
callbackCalled = true
|
|
expect(pane.getPendingItem()).toEqual('fake item two')
|
|
})
|
|
pane.setPendingItem('fake item two')
|
|
expect(callbackCalled).toBeTruthy()
|
|
})
|
|
|
|
it("isn't called when a pending item is replaced with a new one", async () => {
|
|
pane = null
|
|
const pendingSpy = jasmine.createSpy('onItemDidTerminatePendingState')
|
|
const destroySpy = jasmine.createSpy('onWillDestroyItem')
|
|
|
|
await atom.workspace.open('sample.txt', { pending: true }).then(() => {
|
|
pane = atom.workspace.getActivePane()
|
|
})
|
|
|
|
pane.onItemDidTerminatePendingState(pendingSpy)
|
|
pane.onWillDestroyItem(destroySpy)
|
|
|
|
await atom.workspace.open('sample.js', { pending: true })
|
|
|
|
expect(destroySpy).toHaveBeenCalled()
|
|
expect(pendingSpy).not.toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
describe('::activateNextRecentlyUsedItem() and ::activatePreviousRecentlyUsedItem()', () => {
|
|
it('sets the active item to the next/previous item in the itemStack, looping around at either end', () => {
|
|
const pane = new Pane(
|
|
paneParams({
|
|
items: [
|
|
new Item('A'),
|
|
new Item('B'),
|
|
new Item('C'),
|
|
new Item('D'),
|
|
new Item('E')
|
|
]
|
|
})
|
|
)
|
|
const [item1, item2, item3, item4, item5] = pane.getItems()
|
|
pane.itemStack = [item3, item1, item2, item5, item4]
|
|
|
|
pane.activateItem(item4)
|
|
expect(pane.getActiveItem()).toBe(item4)
|
|
pane.activateNextRecentlyUsedItem()
|
|
expect(pane.getActiveItem()).toBe(item5)
|
|
pane.activateNextRecentlyUsedItem()
|
|
expect(pane.getActiveItem()).toBe(item2)
|
|
pane.activatePreviousRecentlyUsedItem()
|
|
expect(pane.getActiveItem()).toBe(item5)
|
|
pane.activatePreviousRecentlyUsedItem()
|
|
expect(pane.getActiveItem()).toBe(item4)
|
|
pane.activatePreviousRecentlyUsedItem()
|
|
expect(pane.getActiveItem()).toBe(item3)
|
|
pane.activatePreviousRecentlyUsedItem()
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
pane.activateNextRecentlyUsedItem()
|
|
expect(pane.getActiveItem()).toBe(item3)
|
|
pane.activateNextRecentlyUsedItem()
|
|
expect(pane.getActiveItem()).toBe(item4)
|
|
pane.activateNextRecentlyUsedItem()
|
|
pane.moveActiveItemToTopOfStack()
|
|
expect(pane.getActiveItem()).toBe(item5)
|
|
expect(pane.itemStack[4]).toBe(item5)
|
|
})
|
|
})
|
|
|
|
describe('::activateNextItem() and ::activatePreviousItem()', () => {
|
|
it('sets the active item to the next/previous item, looping around at either end', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
const [item1, item2, item3] = pane.getItems()
|
|
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
pane.activatePreviousItem()
|
|
expect(pane.getActiveItem()).toBe(item3)
|
|
pane.activatePreviousItem()
|
|
expect(pane.getActiveItem()).toBe(item2)
|
|
pane.activateNextItem()
|
|
expect(pane.getActiveItem()).toBe(item3)
|
|
pane.activateNextItem()
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
})
|
|
})
|
|
|
|
describe('::activateLastItem()', () => {
|
|
it('sets the active item to the last item', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
const [item1, , item3] = pane.getItems()
|
|
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
pane.activateLastItem()
|
|
expect(pane.getActiveItem()).toBe(item3)
|
|
})
|
|
})
|
|
|
|
describe('::moveItemRight() and ::moveItemLeft()', () => {
|
|
it('moves the active item to the right and left, without looping around at either end', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
const [item1, item2, item3] = pane.getItems()
|
|
|
|
pane.activateItemAtIndex(0)
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
pane.moveItemLeft()
|
|
expect(pane.getItems()).toEqual([item1, item2, item3])
|
|
pane.moveItemRight()
|
|
expect(pane.getItems()).toEqual([item2, item1, item3])
|
|
pane.moveItemLeft()
|
|
expect(pane.getItems()).toEqual([item1, item2, item3])
|
|
pane.activateItemAtIndex(2)
|
|
expect(pane.getActiveItem()).toBe(item3)
|
|
pane.moveItemRight()
|
|
expect(pane.getItems()).toEqual([item1, item2, item3])
|
|
})
|
|
})
|
|
|
|
describe('::activateItemAtIndex(index)', () => {
|
|
it('activates the item at the given index', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
const [item1, item2, item3] = pane.getItems()
|
|
pane.activateItemAtIndex(2)
|
|
expect(pane.getActiveItem()).toBe(item3)
|
|
pane.activateItemAtIndex(1)
|
|
expect(pane.getActiveItem()).toBe(item2)
|
|
pane.activateItemAtIndex(0)
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
|
|
// Doesn't fail with out-of-bounds indices
|
|
pane.activateItemAtIndex(100)
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
pane.activateItemAtIndex(-1)
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
})
|
|
})
|
|
|
|
describe('::destroyItem(item)', () => {
|
|
let pane, item1, item2, item3
|
|
|
|
beforeEach(() => {
|
|
pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
;[item1, item2, item3] = pane.getItems()
|
|
})
|
|
|
|
it('removes the item from the items list and destroys it', () => {
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
pane.destroyItem(item2)
|
|
expect(pane.getItems().includes(item2)).toBe(false)
|
|
expect(item2.isDestroyed()).toBe(true)
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
|
|
pane.destroyItem(item1)
|
|
expect(pane.getItems().includes(item1)).toBe(false)
|
|
expect(item1.isDestroyed()).toBe(true)
|
|
})
|
|
|
|
it('removes the item from the itemStack', () => {
|
|
pane.itemStack = [item2, item3, item1]
|
|
|
|
pane.activateItem(item1)
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
pane.destroyItem(item3)
|
|
expect(pane.itemStack).toEqual([item2, item1])
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
|
|
pane.destroyItem(item1)
|
|
expect(pane.itemStack).toEqual([item2])
|
|
expect(pane.getActiveItem()).toBe(item2)
|
|
|
|
pane.destroyItem(item2)
|
|
expect(pane.itemStack).toEqual([])
|
|
expect(pane.getActiveItem()).toBeUndefined()
|
|
})
|
|
|
|
it('invokes ::onWillDestroyItem() and PaneContainer::onWillDestroyPaneItem observers before destroying the item', async () => {
|
|
jasmine.useRealClock()
|
|
pane.container = new PaneContainer({ config: atom.config, confirm })
|
|
const events = []
|
|
|
|
pane.onWillDestroyItem(async event => {
|
|
expect(item2.isDestroyed()).toBe(false)
|
|
await timeoutPromise(50)
|
|
expect(item2.isDestroyed()).toBe(false)
|
|
events.push(['will-destroy-item', event])
|
|
})
|
|
|
|
pane.container.onWillDestroyPaneItem(async event => {
|
|
expect(item2.isDestroyed()).toBe(false)
|
|
await timeoutPromise(50)
|
|
expect(item2.isDestroyed()).toBe(false)
|
|
events.push(['will-destroy-pane-item', event])
|
|
})
|
|
|
|
await pane.destroyItem(item2)
|
|
expect(item2.isDestroyed()).toBe(true)
|
|
expect(events).toEqual([
|
|
['will-destroy-item', { item: item2, index: 1 }],
|
|
['will-destroy-pane-item', { item: item2, index: 1, pane }]
|
|
])
|
|
})
|
|
|
|
it('invokes ::onWillRemoveItem() observers', () => {
|
|
const events = []
|
|
pane.onWillRemoveItem(event => events.push(event))
|
|
pane.destroyItem(item2)
|
|
expect(events).toEqual([
|
|
{ item: item2, index: 1, moved: false, destroyed: true }
|
|
])
|
|
})
|
|
|
|
it('invokes ::onDidRemoveItem() observers', () => {
|
|
const events = []
|
|
pane.onDidRemoveItem(event => events.push(event))
|
|
pane.destroyItem(item2)
|
|
expect(events).toEqual([
|
|
{ item: item2, index: 1, moved: false, destroyed: true }
|
|
])
|
|
})
|
|
|
|
describe('when the destroyed item is the active item and is the first item', () => {
|
|
it('activates the next item', () => {
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
pane.destroyItem(item1)
|
|
expect(pane.getActiveItem()).toBe(item2)
|
|
})
|
|
})
|
|
|
|
describe('when the destroyed item is the active item and is not the first item', () => {
|
|
beforeEach(() => pane.activateItem(item2))
|
|
|
|
it('activates the previous item', () => {
|
|
expect(pane.getActiveItem()).toBe(item2)
|
|
pane.destroyItem(item2)
|
|
expect(pane.getActiveItem()).toBe(item1)
|
|
})
|
|
})
|
|
|
|
describe('if the item is modified', () => {
|
|
let itemURI = null
|
|
|
|
beforeEach(() => {
|
|
item1.shouldPromptToSave = () => true
|
|
item1.save = jasmine.createSpy('save')
|
|
item1.saveAs = jasmine.createSpy('saveAs')
|
|
item1.getURI = () => itemURI
|
|
})
|
|
|
|
describe('if the [Save] option is selected', () => {
|
|
describe('when the item has a uri', () => {
|
|
it('saves the item before destroying it', async () => {
|
|
itemURI = 'test'
|
|
confirm.andCallFake((options, callback) => callback(0))
|
|
|
|
const success = await pane.destroyItem(item1)
|
|
expect(item1.save).toHaveBeenCalled()
|
|
expect(pane.getItems().includes(item1)).toBe(false)
|
|
expect(item1.isDestroyed()).toBe(true)
|
|
expect(success).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe('when the item has no uri', () => {
|
|
it('presents a save-as dialog, then saves the item with the given uri before removing and destroying it', async () => {
|
|
jasmine.useRealClock()
|
|
|
|
itemURI = null
|
|
|
|
showSaveDialog.andCallFake((options, callback) =>
|
|
callback('/selected/path')
|
|
)
|
|
confirm.andCallFake((options, callback) => callback(0))
|
|
|
|
const success = await pane.destroyItem(item1)
|
|
expect(showSaveDialog.mostRecentCall.args[0]).toEqual({})
|
|
|
|
await conditionPromise(() => item1.saveAs.callCount === 1)
|
|
expect(item1.saveAs).toHaveBeenCalledWith('/selected/path')
|
|
expect(pane.getItems().includes(item1)).toBe(false)
|
|
expect(item1.isDestroyed()).toBe(true)
|
|
expect(success).toBe(true)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("if the [Don't Save] option is selected", () => {
|
|
it('removes and destroys the item without saving it', async () => {
|
|
confirm.andCallFake((options, callback) => callback(2))
|
|
|
|
const success = await pane.destroyItem(item1)
|
|
expect(item1.save).not.toHaveBeenCalled()
|
|
expect(pane.getItems().includes(item1)).toBe(false)
|
|
expect(item1.isDestroyed()).toBe(true)
|
|
expect(success).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe('if the [Cancel] option is selected', () => {
|
|
it('does not save, remove, or destroy the item', async () => {
|
|
confirm.andCallFake((options, callback) => callback(1))
|
|
|
|
const success = await pane.destroyItem(item1)
|
|
expect(item1.save).not.toHaveBeenCalled()
|
|
expect(pane.getItems().includes(item1)).toBe(true)
|
|
expect(item1.isDestroyed()).toBe(false)
|
|
expect(success).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('when force=true', () => {
|
|
it('destroys the item immediately', async () => {
|
|
const success = await pane.destroyItem(item1, true)
|
|
expect(item1.save).not.toHaveBeenCalled()
|
|
expect(pane.getItems().includes(item1)).toBe(false)
|
|
expect(item1.isDestroyed()).toBe(true)
|
|
expect(success).toBe(true)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('when the last item is destroyed', () => {
|
|
describe("when the 'core.destroyEmptyPanes' config option is false (the default)", () => {
|
|
it('does not destroy the pane, but leaves it in place with empty items', () => {
|
|
expect(atom.config.get('core.destroyEmptyPanes')).toBe(false)
|
|
for (let item of pane.getItems()) {
|
|
pane.destroyItem(item)
|
|
}
|
|
expect(pane.isDestroyed()).toBe(false)
|
|
expect(pane.getActiveItem()).toBeUndefined()
|
|
expect(() => pane.saveActiveItem()).not.toThrow()
|
|
expect(() => pane.saveActiveItemAs()).not.toThrow()
|
|
})
|
|
})
|
|
|
|
describe("when the 'core.destroyEmptyPanes' config option is true", () => {
|
|
it('destroys the pane', () => {
|
|
atom.config.set('core.destroyEmptyPanes', true)
|
|
for (let item of pane.getItems()) {
|
|
pane.destroyItem(item)
|
|
}
|
|
expect(pane.isDestroyed()).toBe(true)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('when passed a permanent dock item', () => {
|
|
it("doesn't destroy the item", async () => {
|
|
spyOn(item1, 'isPermanentDockItem').andReturn(true)
|
|
const success = await pane.destroyItem(item1)
|
|
expect(pane.getItems().includes(item1)).toBe(true)
|
|
expect(item1.isDestroyed()).toBe(false)
|
|
expect(success).toBe(false)
|
|
})
|
|
|
|
it('destroy the item if force=true', async () => {
|
|
spyOn(item1, 'isPermanentDockItem').andReturn(true)
|
|
const success = await pane.destroyItem(item1, true)
|
|
expect(pane.getItems().includes(item1)).toBe(false)
|
|
expect(item1.isDestroyed()).toBe(true)
|
|
expect(success).toBe(true)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::destroyActiveItem()', () => {
|
|
it('destroys the active item', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B')] })
|
|
)
|
|
const activeItem = pane.getActiveItem()
|
|
pane.destroyActiveItem()
|
|
expect(activeItem.isDestroyed()).toBe(true)
|
|
expect(pane.getItems().includes(activeItem)).toBe(false)
|
|
})
|
|
|
|
it('does not throw an exception if there are no more items', () => {
|
|
const pane = new Pane(paneParams())
|
|
pane.destroyActiveItem()
|
|
})
|
|
})
|
|
|
|
describe('::destroyItems()', () => {
|
|
it('destroys all items', async () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
const [item1, item2, item3] = pane.getItems()
|
|
|
|
await pane.destroyItems()
|
|
expect(item1.isDestroyed()).toBe(true)
|
|
expect(item2.isDestroyed()).toBe(true)
|
|
expect(item3.isDestroyed()).toBe(true)
|
|
expect(pane.getItems()).toEqual([])
|
|
})
|
|
})
|
|
|
|
describe('::observeItems()', () => {
|
|
it('invokes the observer with all current and future items', () => {
|
|
const pane = new Pane(paneParams({ items: [new Item(), new Item()] }))
|
|
const [item1, item2] = pane.getItems()
|
|
|
|
const observed = []
|
|
pane.observeItems(item => observed.push(item))
|
|
|
|
const item3 = new Item()
|
|
pane.addItem(item3)
|
|
|
|
expect(observed).toEqual([item1, item2, item3])
|
|
})
|
|
})
|
|
|
|
describe('when an item emits a destroyed event', () => {
|
|
it('removes it from the list of items', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
const [item1, , item3] = pane.getItems()
|
|
pane.itemAtIndex(1).destroy()
|
|
expect(pane.getItems()).toEqual([item1, item3])
|
|
})
|
|
})
|
|
|
|
describe('::destroyInactiveItems()', () => {
|
|
it('destroys all items but the active item', () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
|
|
)
|
|
const [, item2] = pane.getItems()
|
|
pane.activateItem(item2)
|
|
pane.destroyInactiveItems()
|
|
expect(pane.getItems()).toEqual([item2])
|
|
})
|
|
})
|
|
|
|
describe('::saveActiveItem()', () => {
|
|
let pane
|
|
|
|
beforeEach(() => {
|
|
pane = new Pane(paneParams({ items: [new Item('A')] }))
|
|
showSaveDialog.andCallFake((options, callback) =>
|
|
callback('/selected/path')
|
|
)
|
|
})
|
|
|
|
describe('when the active item has a uri', () => {
|
|
beforeEach(() => {
|
|
pane.getActiveItem().uri = 'test'
|
|
})
|
|
|
|
describe('when the active item has a save method', () => {
|
|
it('saves the current item', () => {
|
|
pane.getActiveItem().save = jasmine.createSpy('save')
|
|
pane.saveActiveItem()
|
|
expect(pane.getActiveItem().save).toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
describe('when the current item has no save method', () => {
|
|
it('does nothing', () => {
|
|
expect(pane.getActiveItem().save).toBeUndefined()
|
|
pane.saveActiveItem()
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('when the current item has no uri', () => {
|
|
describe('when the current item has a saveAs method', () => {
|
|
it('opens a save dialog and saves the current item as the selected path', async () => {
|
|
pane.getActiveItem().saveAs = jasmine.createSpy('saveAs')
|
|
await pane.saveActiveItem()
|
|
expect(showSaveDialog.mostRecentCall.args[0]).toEqual({})
|
|
expect(pane.getActiveItem().saveAs).toHaveBeenCalledWith(
|
|
'/selected/path'
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when the current item has no saveAs method', () => {
|
|
it('does nothing', async () => {
|
|
expect(pane.getActiveItem().saveAs).toBeUndefined()
|
|
await pane.saveActiveItem()
|
|
expect(showSaveDialog).not.toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
it('does nothing if the user cancels choosing a path', async () => {
|
|
pane.getActiveItem().saveAs = jasmine.createSpy('saveAs')
|
|
showSaveDialog.andCallFake((options, callback) => callback(undefined))
|
|
await pane.saveActiveItem()
|
|
expect(pane.getActiveItem().saveAs).not.toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
describe("when the item's saveAs rejects with a well-known IO error", () => {
|
|
it('creates a notification', () => {
|
|
pane.getActiveItem().saveAs = () => {
|
|
const error = new Error("EACCES, permission denied '/foo'")
|
|
error.path = '/foo'
|
|
error.code = 'EACCES'
|
|
return Promise.reject(error)
|
|
}
|
|
|
|
waitsFor(done => {
|
|
const subscription = atom.notifications.onDidAddNotification(
|
|
function (notification) {
|
|
expect(notification.getType()).toBe('warning')
|
|
expect(notification.getMessage()).toContain('Permission denied')
|
|
expect(notification.getMessage()).toContain('/foo')
|
|
subscription.dispose()
|
|
done()
|
|
}
|
|
)
|
|
pane.saveActiveItem()
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("when the item's saveAs throws a well-known IO error", () => {
|
|
it('creates a notification', () => {
|
|
pane.getActiveItem().saveAs = () => {
|
|
const error = new Error("EACCES, permission denied '/foo'")
|
|
error.path = '/foo'
|
|
error.code = 'EACCES'
|
|
throw error
|
|
}
|
|
|
|
waitsFor(done => {
|
|
const subscription = atom.notifications.onDidAddNotification(
|
|
function (notification) {
|
|
expect(notification.getType()).toBe('warning')
|
|
expect(notification.getMessage()).toContain('Permission denied')
|
|
expect(notification.getMessage()).toContain('/foo')
|
|
subscription.dispose()
|
|
done()
|
|
}
|
|
)
|
|
pane.saveActiveItem()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::saveActiveItemAs()', () => {
|
|
let pane = null
|
|
|
|
beforeEach(() => {
|
|
pane = new Pane(paneParams({ items: [new Item('A')] }))
|
|
showSaveDialog.andCallFake((options, callback) =>
|
|
callback('/selected/path')
|
|
)
|
|
})
|
|
|
|
describe('when the current item has a saveAs method', () => {
|
|
it('opens the save dialog and calls saveAs on the item with the selected path', async () => {
|
|
jasmine.useRealClock()
|
|
|
|
pane.getActiveItem().path = __filename
|
|
pane.getActiveItem().saveAs = jasmine.createSpy('saveAs')
|
|
pane.saveActiveItemAs()
|
|
expect(showSaveDialog.mostRecentCall.args[0]).toEqual({
|
|
defaultPath: __filename
|
|
})
|
|
|
|
await conditionPromise(
|
|
() => pane.getActiveItem().saveAs.callCount === 1
|
|
)
|
|
expect(pane.getActiveItem().saveAs).toHaveBeenCalledWith(
|
|
'/selected/path'
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when the current item does not have a saveAs method', () => {
|
|
it('does nothing', () => {
|
|
expect(pane.getActiveItem().saveAs).toBeUndefined()
|
|
pane.saveActiveItemAs()
|
|
expect(showSaveDialog).not.toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
describe("when the item's saveAs method throws a well-known IO error", () => {
|
|
it('creates a notification', () => {
|
|
pane.getActiveItem().saveAs = () => {
|
|
const error = new Error("EACCES, permission denied '/foo'")
|
|
error.path = '/foo'
|
|
error.code = 'EACCES'
|
|
return Promise.reject(error)
|
|
}
|
|
|
|
waitsFor(done => {
|
|
const subscription = atom.notifications.onDidAddNotification(
|
|
function (notification) {
|
|
expect(notification.getType()).toBe('warning')
|
|
expect(notification.getMessage()).toContain('Permission denied')
|
|
expect(notification.getMessage()).toContain('/foo')
|
|
subscription.dispose()
|
|
done()
|
|
}
|
|
)
|
|
pane.saveActiveItemAs()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::itemForURI(uri)', () => {
|
|
it('returns the item for which a call to .getURI() returns the given uri', () => {
|
|
const pane = new Pane(
|
|
paneParams({
|
|
items: [new Item('A'), new Item('B'), new Item('C'), new Item('D')]
|
|
})
|
|
)
|
|
const [item1, item2] = pane.getItems()
|
|
item1.uri = 'a'
|
|
item2.uri = 'b'
|
|
expect(pane.itemForURI('a')).toBe(item1)
|
|
expect(pane.itemForURI('b')).toBe(item2)
|
|
expect(pane.itemForURI('bogus')).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('::moveItem(item, index)', () => {
|
|
let pane, item1, item2, item3, item4
|
|
|
|
beforeEach(() => {
|
|
pane = new Pane(
|
|
paneParams({
|
|
items: [new Item('A'), new Item('B'), new Item('C'), new Item('D')]
|
|
})
|
|
)
|
|
;[item1, item2, item3, item4] = pane.getItems()
|
|
})
|
|
|
|
it('moves the item to the given index and invokes ::onDidMoveItem observers', () => {
|
|
pane.moveItem(item1, 2)
|
|
expect(pane.getItems()).toEqual([item2, item3, item1, item4])
|
|
|
|
pane.moveItem(item2, 3)
|
|
expect(pane.getItems()).toEqual([item3, item1, item4, item2])
|
|
|
|
pane.moveItem(item2, 1)
|
|
expect(pane.getItems()).toEqual([item3, item2, item1, item4])
|
|
})
|
|
|
|
it('invokes ::onDidMoveItem() observers', () => {
|
|
const events = []
|
|
pane.onDidMoveItem(event => events.push(event))
|
|
|
|
pane.moveItem(item1, 2)
|
|
pane.moveItem(item2, 3)
|
|
expect(events).toEqual([
|
|
{ item: item1, oldIndex: 0, newIndex: 2 },
|
|
{ item: item2, oldIndex: 0, newIndex: 3 }
|
|
])
|
|
})
|
|
})
|
|
|
|
describe('::moveItemToPane(item, pane, index)', () => {
|
|
let container, pane1, pane2
|
|
let item1, item2, item3, item4, item5
|
|
|
|
beforeEach(() => {
|
|
container = new PaneContainer({ config: atom.config, confirm })
|
|
pane1 = container.getActivePane()
|
|
pane1.addItems([new Item('A'), new Item('B'), new Item('C')])
|
|
pane2 = pane1.splitRight({ items: [new Item('D'), new Item('E')] })
|
|
;[item1, item2, item3] = pane1.getItems()
|
|
;[item4, item5] = pane2.getItems()
|
|
})
|
|
|
|
it('moves the item to the given pane at the given index', () => {
|
|
pane1.moveItemToPane(item2, pane2, 1)
|
|
expect(pane1.getItems()).toEqual([item1, item3])
|
|
expect(pane2.getItems()).toEqual([item4, item2, item5])
|
|
})
|
|
|
|
it('invokes ::onWillRemoveItem() observers', () => {
|
|
const events = []
|
|
pane1.onWillRemoveItem(event => events.push(event))
|
|
pane1.moveItemToPane(item2, pane2, 1)
|
|
|
|
expect(events).toEqual([
|
|
{ item: item2, index: 1, moved: true, destroyed: false }
|
|
])
|
|
})
|
|
|
|
it('invokes ::onDidRemoveItem() observers', () => {
|
|
const events = []
|
|
pane1.onDidRemoveItem(event => events.push(event))
|
|
pane1.moveItemToPane(item2, pane2, 1)
|
|
|
|
expect(events).toEqual([
|
|
{ item: item2, index: 1, moved: true, destroyed: false }
|
|
])
|
|
})
|
|
|
|
it('does not invoke ::onDidAddPaneItem observers on the container', () => {
|
|
const addedItems = []
|
|
container.onDidAddPaneItem(item => addedItems.push(item))
|
|
pane1.moveItemToPane(item2, pane2, 1)
|
|
expect(addedItems).toEqual([])
|
|
})
|
|
|
|
describe('when the moved item the last item in the source pane', () => {
|
|
beforeEach(() => item5.destroy())
|
|
|
|
describe("when the 'core.destroyEmptyPanes' config option is false (the default)", () => {
|
|
it('does not destroy the pane or the item', () => {
|
|
pane2.moveItemToPane(item4, pane1, 0)
|
|
expect(pane2.isDestroyed()).toBe(false)
|
|
expect(item4.isDestroyed()).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe("when the 'core.destroyEmptyPanes' config option is true", () => {
|
|
it('destroys the pane, but not the item', () => {
|
|
atom.config.set('core.destroyEmptyPanes', true)
|
|
pane2.moveItemToPane(item4, pane1, 0)
|
|
expect(pane2.isDestroyed()).toBe(true)
|
|
expect(item4.isDestroyed()).toBe(false)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('when the item being moved is pending', () => {
|
|
it('is made permanent in the new pane', () => {
|
|
const item6 = new Item('F')
|
|
pane1.addItem(item6, { pending: true })
|
|
expect(pane1.getPendingItem()).toEqual(item6)
|
|
pane1.moveItemToPane(item6, pane2, 0)
|
|
expect(pane2.getPendingItem()).not.toEqual(item6)
|
|
})
|
|
})
|
|
|
|
describe('when the target pane has a pending item', () => {
|
|
it('does not destroy the pending item', () => {
|
|
const item6 = new Item('F')
|
|
pane1.addItem(item6, { pending: true })
|
|
expect(pane1.getPendingItem()).toEqual(item6)
|
|
pane2.moveItemToPane(item5, pane1, 0)
|
|
expect(pane1.getPendingItem()).toEqual(item6)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('split methods', () => {
|
|
let pane1, item1, container
|
|
|
|
beforeEach(() => {
|
|
container = new PaneContainer({
|
|
config: atom.config,
|
|
confirm,
|
|
deserializerManager: atom.deserializers
|
|
})
|
|
pane1 = container.getActivePane()
|
|
item1 = new Item('A')
|
|
pane1.addItem(item1)
|
|
})
|
|
|
|
describe('::splitLeft(params)', () => {
|
|
describe('when the parent is the container root', () => {
|
|
it('replaces itself with a row and inserts a new pane to the left of itself', () => {
|
|
const pane2 = pane1.splitLeft({ items: [new Item('B')] })
|
|
const pane3 = pane1.splitLeft({ items: [new Item('C')] })
|
|
expect(container.root.orientation).toBe('horizontal')
|
|
expect(container.root.children).toEqual([pane2, pane3, pane1])
|
|
})
|
|
})
|
|
|
|
describe('when `moveActiveItem: true` is passed in the params', () => {
|
|
it('moves the active item', () => {
|
|
const pane2 = pane1.splitLeft({ moveActiveItem: true })
|
|
expect(pane2.getActiveItem()).toBe(item1)
|
|
})
|
|
})
|
|
|
|
describe('when `copyActiveItem: true` is passed in the params', () => {
|
|
it('duplicates the active item', () => {
|
|
const pane2 = pane1.splitLeft({ copyActiveItem: true })
|
|
expect(pane2.getActiveItem()).toEqual(pane1.getActiveItem())
|
|
})
|
|
|
|
it("does nothing if the active item doesn't implement .copy()", () => {
|
|
item1.copy = null
|
|
const pane2 = pane1.splitLeft({ copyActiveItem: true })
|
|
expect(pane2.getActiveItem()).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('when the parent is a column', () => {
|
|
it('replaces itself with a row and inserts a new pane to the left of itself', () => {
|
|
pane1.splitDown()
|
|
const pane2 = pane1.splitLeft({ items: [new Item('B')] })
|
|
const pane3 = pane1.splitLeft({ items: [new Item('C')] })
|
|
const row = container.root.children[0]
|
|
expect(row.orientation).toBe('horizontal')
|
|
expect(row.children).toEqual([pane2, pane3, pane1])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::splitRight(params)', () => {
|
|
describe('when the parent is the container root', () => {
|
|
it('replaces itself with a row and inserts a new pane to the right of itself', () => {
|
|
const pane2 = pane1.splitRight({ items: [new Item('B')] })
|
|
const pane3 = pane1.splitRight({ items: [new Item('C')] })
|
|
expect(container.root.orientation).toBe('horizontal')
|
|
expect(container.root.children).toEqual([pane1, pane3, pane2])
|
|
})
|
|
})
|
|
|
|
describe('when `moveActiveItem: true` is passed in the params', () => {
|
|
it('moves the active item', () => {
|
|
const pane2 = pane1.splitRight({ moveActiveItem: true })
|
|
expect(pane2.getActiveItem()).toBe(item1)
|
|
})
|
|
})
|
|
|
|
describe('when `copyActiveItem: true` is passed in the params', () => {
|
|
it('duplicates the active item', () => {
|
|
const pane2 = pane1.splitRight({ copyActiveItem: true })
|
|
expect(pane2.getActiveItem()).toEqual(pane1.getActiveItem())
|
|
})
|
|
})
|
|
|
|
describe('when the parent is a column', () => {
|
|
it('replaces itself with a row and inserts a new pane to the right of itself', () => {
|
|
pane1.splitDown()
|
|
const pane2 = pane1.splitRight({ items: [new Item('B')] })
|
|
const pane3 = pane1.splitRight({ items: [new Item('C')] })
|
|
const row = container.root.children[0]
|
|
expect(row.orientation).toBe('horizontal')
|
|
expect(row.children).toEqual([pane1, pane3, pane2])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::splitUp(params)', () => {
|
|
describe('when the parent is the container root', () => {
|
|
it('replaces itself with a column and inserts a new pane above itself', () => {
|
|
const pane2 = pane1.splitUp({ items: [new Item('B')] })
|
|
const pane3 = pane1.splitUp({ items: [new Item('C')] })
|
|
expect(container.root.orientation).toBe('vertical')
|
|
expect(container.root.children).toEqual([pane2, pane3, pane1])
|
|
})
|
|
})
|
|
|
|
describe('when `moveActiveItem: true` is passed in the params', () => {
|
|
it('moves the active item', () => {
|
|
const pane2 = pane1.splitUp({ moveActiveItem: true })
|
|
expect(pane2.getActiveItem()).toBe(item1)
|
|
})
|
|
})
|
|
|
|
describe('when `copyActiveItem: true` is passed in the params', () => {
|
|
it('duplicates the active item', () => {
|
|
const pane2 = pane1.splitUp({ copyActiveItem: true })
|
|
expect(pane2.getActiveItem()).toEqual(pane1.getActiveItem())
|
|
})
|
|
})
|
|
|
|
describe('when the parent is a row', () => {
|
|
it('replaces itself with a column and inserts a new pane above itself', () => {
|
|
pane1.splitRight()
|
|
const pane2 = pane1.splitUp({ items: [new Item('B')] })
|
|
const pane3 = pane1.splitUp({ items: [new Item('C')] })
|
|
const column = container.root.children[0]
|
|
expect(column.orientation).toBe('vertical')
|
|
expect(column.children).toEqual([pane2, pane3, pane1])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::splitDown(params)', () => {
|
|
describe('when the parent is the container root', () => {
|
|
it('replaces itself with a column and inserts a new pane below itself', () => {
|
|
const pane2 = pane1.splitDown({ items: [new Item('B')] })
|
|
const pane3 = pane1.splitDown({ items: [new Item('C')] })
|
|
expect(container.root.orientation).toBe('vertical')
|
|
expect(container.root.children).toEqual([pane1, pane3, pane2])
|
|
})
|
|
})
|
|
|
|
describe('when `moveActiveItem: true` is passed in the params', () => {
|
|
it('moves the active item', () => {
|
|
const pane2 = pane1.splitDown({ moveActiveItem: true })
|
|
expect(pane2.getActiveItem()).toBe(item1)
|
|
})
|
|
})
|
|
|
|
describe('when `copyActiveItem: true` is passed in the params', () => {
|
|
it('duplicates the active item', () => {
|
|
const pane2 = pane1.splitDown({ copyActiveItem: true })
|
|
expect(pane2.getActiveItem()).toEqual(pane1.getActiveItem())
|
|
})
|
|
})
|
|
|
|
describe('when the parent is a row', () => {
|
|
it('replaces itself with a column and inserts a new pane below itself', () => {
|
|
pane1.splitRight()
|
|
const pane2 = pane1.splitDown({ items: [new Item('B')] })
|
|
const pane3 = pane1.splitDown({ items: [new Item('C')] })
|
|
const column = container.root.children[0]
|
|
expect(column.orientation).toBe('vertical')
|
|
expect(column.children).toEqual([pane1, pane3, pane2])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('when the pane is empty', () => {
|
|
describe('when `moveActiveItem: true` is passed in the params', () => {
|
|
it('gracefully ignores the moveActiveItem parameter', () => {
|
|
pane1.destroyItem(item1)
|
|
expect(pane1.getActiveItem()).toBe(undefined)
|
|
|
|
const pane2 = pane1.split('horizontal', 'before', {
|
|
moveActiveItem: true
|
|
})
|
|
expect(container.root.children).toEqual([pane2, pane1])
|
|
|
|
expect(pane2.getActiveItem()).toBe(undefined)
|
|
})
|
|
})
|
|
|
|
describe('when `copyActiveItem: true` is passed in the params', () => {
|
|
it('gracefully ignores the copyActiveItem parameter', () => {
|
|
pane1.destroyItem(item1)
|
|
expect(pane1.getActiveItem()).toBe(undefined)
|
|
|
|
const pane2 = pane1.split('horizontal', 'before', {
|
|
copyActiveItem: true
|
|
})
|
|
expect(container.root.children).toEqual([pane2, pane1])
|
|
|
|
expect(pane2.getActiveItem()).toBe(undefined)
|
|
})
|
|
})
|
|
})
|
|
|
|
it('activates the new pane', () => {
|
|
expect(pane1.isActive()).toBe(true)
|
|
const pane2 = pane1.splitRight()
|
|
expect(pane1.isActive()).toBe(false)
|
|
expect(pane2.isActive()).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe('::close()', () => {
|
|
it('prompts to save unsaved items before destroying the pane', async () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B')] })
|
|
)
|
|
const [item1] = pane.getItems()
|
|
|
|
item1.shouldPromptToSave = () => true
|
|
item1.getURI = () => '/test/path'
|
|
item1.save = jasmine.createSpy('save')
|
|
|
|
confirm.andCallFake((options, callback) => callback(0))
|
|
await pane.close()
|
|
expect(confirm).toHaveBeenCalled()
|
|
expect(item1.save).toHaveBeenCalled()
|
|
expect(pane.isDestroyed()).toBe(true)
|
|
})
|
|
|
|
it('does not destroy the pane if the user clicks cancel', async () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B')] })
|
|
)
|
|
const [item1] = pane.getItems()
|
|
|
|
item1.shouldPromptToSave = () => true
|
|
item1.getURI = () => '/test/path'
|
|
item1.save = jasmine.createSpy('save')
|
|
|
|
confirm.andCallFake((options, callback) => callback(1))
|
|
|
|
await pane.close()
|
|
expect(confirm).toHaveBeenCalled()
|
|
expect(item1.save).not.toHaveBeenCalled()
|
|
expect(pane.isDestroyed()).toBe(false)
|
|
})
|
|
|
|
it('does not destroy the pane if the user starts to save but then does not choose a path', async () => {
|
|
const pane = new Pane(
|
|
paneParams({ items: [new Item('A'), new Item('B')] })
|
|
)
|
|
const [item1] = pane.getItems()
|
|
|
|
item1.shouldPromptToSave = () => true
|
|
item1.saveAs = jasmine.createSpy('saveAs')
|
|
|
|
confirm.andCallFake((options, callback) => callback(0))
|
|
showSaveDialog.andCallFake((options, callback) => callback(undefined))
|
|
|
|
await pane.close()
|
|
expect(atom.applicationDelegate.confirm).toHaveBeenCalled()
|
|
expect(confirm.callCount).toBe(1)
|
|
expect(item1.saveAs).not.toHaveBeenCalled()
|
|
expect(pane.isDestroyed()).toBe(false)
|
|
})
|
|
|
|
describe('when item fails to save', () => {
|
|
let pane, item1
|
|
|
|
beforeEach(() => {
|
|
pane = new Pane({
|
|
items: [new Item('A'), new Item('B')],
|
|
applicationDelegate: atom.applicationDelegate,
|
|
config: atom.config
|
|
})
|
|
;[item1] = pane.getItems()
|
|
|
|
item1.shouldPromptToSave = () => true
|
|
item1.getURI = () => '/test/path'
|
|
|
|
item1.save = jasmine.createSpy('save').andCallFake(() => {
|
|
const error = new Error("EACCES, permission denied '/test/path'")
|
|
error.path = '/test/path'
|
|
error.code = 'EACCES'
|
|
throw error
|
|
})
|
|
})
|
|
|
|
it('does not destroy the pane if save fails and user clicks cancel', async () => {
|
|
let confirmations = 0
|
|
confirm.andCallFake((options, callback) => {
|
|
confirmations++
|
|
if (confirmations === 1) {
|
|
callback(0) // click save
|
|
} else {
|
|
callback(1)
|
|
}
|
|
}) // click cancel
|
|
|
|
await pane.close()
|
|
expect(atom.applicationDelegate.confirm).toHaveBeenCalled()
|
|
expect(confirmations).toBe(2)
|
|
expect(item1.save).toHaveBeenCalled()
|
|
expect(pane.isDestroyed()).toBe(false)
|
|
})
|
|
|
|
it('does destroy the pane if the user saves the file under a new name', async () => {
|
|
item1.saveAs = jasmine.createSpy('saveAs').andReturn(true)
|
|
|
|
let confirmations = 0
|
|
confirm.andCallFake((options, callback) => {
|
|
confirmations++
|
|
callback(0)
|
|
}) // save and then save as
|
|
|
|
showSaveDialog.andCallFake((options, callback) => callback('new/path'))
|
|
|
|
await pane.close()
|
|
expect(atom.applicationDelegate.confirm).toHaveBeenCalled()
|
|
expect(confirmations).toBe(2)
|
|
expect(
|
|
atom.applicationDelegate.showSaveDialog.mostRecentCall.args[0]
|
|
).toEqual({})
|
|
expect(item1.save).toHaveBeenCalled()
|
|
expect(item1.saveAs).toHaveBeenCalled()
|
|
expect(pane.isDestroyed()).toBe(true)
|
|
})
|
|
|
|
it('asks again if the saveAs also fails', async () => {
|
|
item1.saveAs = jasmine.createSpy('saveAs').andCallFake(() => {
|
|
const error = new Error("EACCES, permission denied '/test/path'")
|
|
error.path = '/test/path'
|
|
error.code = 'EACCES'
|
|
throw error
|
|
})
|
|
|
|
let confirmations = 0
|
|
confirm.andCallFake((options, callback) => {
|
|
confirmations++
|
|
if (confirmations < 3) {
|
|
callback(0) // save, save as, save as
|
|
} else {
|
|
callback(2) // don't save
|
|
}
|
|
})
|
|
|
|
showSaveDialog.andCallFake((options, callback) => callback('new/path'))
|
|
|
|
await pane.close()
|
|
expect(atom.applicationDelegate.confirm).toHaveBeenCalled()
|
|
expect(confirmations).toBe(3)
|
|
expect(
|
|
atom.applicationDelegate.showSaveDialog.mostRecentCall.args[0]
|
|
).toEqual({})
|
|
expect(item1.save).toHaveBeenCalled()
|
|
expect(item1.saveAs).toHaveBeenCalled()
|
|
expect(pane.isDestroyed()).toBe(true)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('::destroy()', () => {
|
|
let container, pane1, pane2
|
|
|
|
beforeEach(() => {
|
|
container = new PaneContainer({ config: atom.config, confirm })
|
|
pane1 = container.root
|
|
pane1.addItems([new Item('A'), new Item('B')])
|
|
pane2 = pane1.splitRight()
|
|
})
|
|
|
|
it('invokes ::onWillDestroy observers before destroying items', () => {
|
|
let itemsDestroyed = null
|
|
pane1.onWillDestroy(() => {
|
|
itemsDestroyed = pane1.getItems().map(item => item.isDestroyed())
|
|
})
|
|
pane1.destroy()
|
|
expect(itemsDestroyed).toEqual([false, false])
|
|
})
|
|
|
|
it("destroys the pane's destroyable items", () => {
|
|
const [item1, item2] = pane1.getItems()
|
|
pane1.destroy()
|
|
expect(item1.isDestroyed()).toBe(true)
|
|
expect(item2.isDestroyed()).toBe(true)
|
|
})
|
|
|
|
describe('if the pane is active', () => {
|
|
it('makes the next pane active', () => {
|
|
expect(pane2.isActive()).toBe(true)
|
|
pane2.destroy()
|
|
expect(pane1.isActive()).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe("if the pane's parent has more than two children", () => {
|
|
it('removes the pane from its parent', () => {
|
|
const pane3 = pane2.splitRight()
|
|
|
|
expect(container.root.children).toEqual([pane1, pane2, pane3])
|
|
pane2.destroy()
|
|
expect(container.root.children).toEqual([pane1, pane3])
|
|
})
|
|
})
|
|
|
|
describe("if the pane's parent has two children", () => {
|
|
it('replaces the parent with its last remaining child', () => {
|
|
const pane3 = pane2.splitDown()
|
|
|
|
expect(container.root.children[0]).toBe(pane1)
|
|
expect(container.root.children[1].children).toEqual([pane2, pane3])
|
|
pane3.destroy()
|
|
expect(container.root.children).toEqual([pane1, pane2])
|
|
pane2.destroy()
|
|
expect(container.root).toBe(pane1)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('pending state', () => {
|
|
let editor1, pane, eventCount
|
|
|
|
beforeEach(async () => {
|
|
editor1 = await atom.workspace.open('sample.txt', { pending: true })
|
|
pane = atom.workspace.getActivePane()
|
|
eventCount = 0
|
|
editor1.onDidTerminatePendingState(() => eventCount++)
|
|
})
|
|
|
|
it('does not open file in pending state by default', async () => {
|
|
await atom.workspace.open('sample.js')
|
|
expect(pane.getPendingItem()).toBeNull()
|
|
})
|
|
|
|
it("opens file in pending state if 'pending' option is true", () => {
|
|
expect(pane.getPendingItem()).toEqual(editor1)
|
|
})
|
|
|
|
it('terminates pending state if ::terminatePendingState is invoked', () => {
|
|
editor1.terminatePendingState()
|
|
|
|
expect(pane.getPendingItem()).toBeNull()
|
|
expect(eventCount).toBe(1)
|
|
})
|
|
|
|
it('terminates pending state when buffer is changed', () => {
|
|
editor1.insertText("I'll be back!")
|
|
advanceClock(editor1.getBuffer().stoppedChangingDelay)
|
|
|
|
expect(pane.getPendingItem()).toBeNull()
|
|
expect(eventCount).toBe(1)
|
|
})
|
|
|
|
it('only calls terminate handler once when text is modified twice', async () => {
|
|
const originalText = editor1.getText()
|
|
editor1.insertText('Some text')
|
|
advanceClock(editor1.getBuffer().stoppedChangingDelay)
|
|
|
|
await editor1.save()
|
|
|
|
editor1.insertText('More text')
|
|
advanceClock(editor1.getBuffer().stoppedChangingDelay)
|
|
|
|
expect(pane.getPendingItem()).toBeNull()
|
|
expect(eventCount).toBe(1)
|
|
|
|
// Reset fixture back to original state
|
|
editor1.setText(originalText)
|
|
await editor1.save()
|
|
})
|
|
|
|
it('only calls clearPendingItem if there is a pending item to clear', () => {
|
|
spyOn(pane, 'clearPendingItem').andCallThrough()
|
|
|
|
editor1.terminatePendingState()
|
|
editor1.terminatePendingState()
|
|
|
|
expect(pane.getPendingItem()).toBeNull()
|
|
expect(pane.clearPendingItem.callCount).toBe(1)
|
|
})
|
|
})
|
|
|
|
describe('serialization', () => {
|
|
let pane = null
|
|
|
|
beforeEach(() => {
|
|
pane = new Pane(
|
|
paneParams({
|
|
items: [new Item('A', 'a'), new Item('B', 'b'), new Item('C', 'c')],
|
|
flexScale: 2
|
|
})
|
|
)
|
|
})
|
|
|
|
it('can serialize and deserialize the pane and all its items', () => {
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.getItems()).toEqual(pane.getItems())
|
|
})
|
|
|
|
it('restores the active item on deserialization', () => {
|
|
pane.activateItemAtIndex(1)
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.getActiveItem()).toEqual(newPane.itemAtIndex(1))
|
|
})
|
|
|
|
it("restores the active item when it doesn't implement getURI()", () => {
|
|
pane.items[1].getURI = null
|
|
pane.activateItemAtIndex(1)
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.getActiveItem()).toEqual(newPane.itemAtIndex(1))
|
|
})
|
|
|
|
it("restores the correct item when it doesn't implement getURI() and some items weren't deserialized", () => {
|
|
const unserializable = {}
|
|
pane.addItem(unserializable, { index: 0 })
|
|
pane.items[2].getURI = null
|
|
pane.activateItemAtIndex(2)
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.getActiveItem()).toEqual(newPane.itemAtIndex(1))
|
|
})
|
|
|
|
it('does not include items that cannot be deserialized', () => {
|
|
spyOn(console, 'warn')
|
|
const unserializable = {}
|
|
pane.activateItem(unserializable)
|
|
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.getActiveItem()).toEqual(pane.itemAtIndex(0))
|
|
expect(newPane.getItems().length).toBe(pane.getItems().length - 1)
|
|
})
|
|
|
|
it("includes the pane's focus state in the serialized state", () => {
|
|
pane.focus()
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.focused).toBe(true)
|
|
})
|
|
|
|
it('can serialize and deserialize the order of the items in the itemStack', () => {
|
|
const [item1, item2, item3] = pane.getItems()
|
|
pane.itemStack = [item3, item1, item2]
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.itemStack).toEqual(pane.itemStack)
|
|
expect(newPane.itemStack[2]).toEqual(item2)
|
|
})
|
|
|
|
it('builds the itemStack if the itemStack is not serialized', () => {
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.getItems()).toEqual(newPane.itemStack)
|
|
})
|
|
|
|
it('rebuilds the itemStack if items.length does not match itemStack.length', () => {
|
|
const [, item2, item3] = pane.getItems()
|
|
pane.itemStack = [item2, item3]
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.getItems()).toEqual(newPane.itemStack)
|
|
})
|
|
|
|
it('does not serialize the reference to the items in the itemStack for pane items that will not be serialized', () => {
|
|
const [item1, item2, item3] = pane.getItems()
|
|
pane.itemStack = [item2, item1, item3]
|
|
const unserializable = {}
|
|
pane.activateItem(unserializable)
|
|
|
|
const newPane = Pane.deserialize(pane.serialize(), atom)
|
|
expect(newPane.itemStack).toEqual([item2, item1, item3])
|
|
})
|
|
})
|
|
})
|