pulsar-edit/pulsar
1
1
Fork 0
mirror of https://github.com/pulsar-edit/pulsar.git synced 2024-09-21 07:58:04 +03:00
Code Issues Packages Projects Releases Wiki Activity
bee1efed5c
pulsar/spec/app/pane-spec.coffee

108 lines
4.6 KiB
CoffeeScript
Raw Normal View History

Construct Pane w/ multiple items. Show first item on construction.
2013-02-18 21:45:02 +04:00
Editor = require 'editor'
Pane = require 'pane'
{$$} = require 'space-pen'
describe "Pane", ->
[view1, view2, editSession1, editSession2, pane] = []
beforeEach ->
view1 = $$ -> @div id: 'view-1', 'View 1'
Allow panes to have model objects as items in addition to views The problem I've been struggling with is that we need to potentially assign tabs both to EditSessions and also to other views added by extensions, like a markdown preview view. EditSessions are however not actually views… instead they plug into editors. The solution is to have the pane ask a model object what view should be used to render it. When asked to show a non-view item, the pane constructs and appends a view for that item or recycles an appropriate view that it has already appended.
2013-02-18 22:15:33 +04:00
view2 = $$ -> @div id: 'view-2', 'View 2'
Construct Pane w/ multiple items. Show first item on construction.
2013-02-18 21:45:02 +04:00
editSession1 = project.buildEditSession('sample.js')
editSession2 = project.buildEditSession('sample.txt')
pane = new Pane(view1, editSession1, view2, editSession2)
describe ".initialize(items...)", ->
it "displays the first item in the pane", ->
Allow panes to have model objects as items in addition to views The problem I've been struggling with is that we need to potentially assign tabs both to EditSessions and also to other views added by extensions, like a markdown preview view. EditSessions are however not actually views… instead they plug into editors. The solution is to have the pane ask a model object what view should be used to render it. When asked to show a non-view item, the pane constructs and appends a view for that item or recycles an appropriate view that it has already appended.
2013-02-18 22:15:33 +04:00
expect(pane.itemViews.find('#view-1')).toExist()
describe ".showItem(item)", ->
Add show next / previous item.
2013-02-18 22:44:51 +04:00
it "hides all item views except the one being shown and sets the currentItem", ->
expect(pane.currentItem).toBe view1
Allow panes to have model objects as items in addition to views The problem I've been struggling with is that we need to potentially assign tabs both to EditSessions and also to other views added by extensions, like a markdown preview view. EditSessions are however not actually views… instead they plug into editors. The solution is to have the pane ask a model object what view should be used to render it. When asked to show a non-view item, the pane constructs and appends a view for that item or recycles an appropriate view that it has already appended.
2013-02-18 22:15:33 +04:00
pane.showItem(view2)
expect(view1.css('display')).toBe 'none'
expect(view2.css('display')).toBe ''
Add show next / previous item.
2013-02-18 22:44:51 +04:00
expect(pane.currentItem).toBe view2
Allow panes to have model objects as items in addition to views The problem I've been struggling with is that we need to potentially assign tabs both to EditSessions and also to other views added by extensions, like a markdown preview view. EditSessions are however not actually views… instead they plug into editors. The solution is to have the pane ask a model object what view should be used to render it. When asked to show a non-view item, the pane constructs and appends a view for that item or recycles an appropriate view that it has already appended.
2013-02-18 22:15:33 +04:00
When showing an item on a pane, add it to the items list if needed
2013-02-19 02:38:43 +04:00
describe "when the given item isn't yet in the items list on the pane", ->
it "adds it to the items list after the current item", ->
view3 = $$ -> @div id: 'view-3', "View 3"
pane.showItem(editSession1)
expect(pane.getCurrentItemIndex()).toBe 1
pane.showItem(view3)
expect(pane.getItems()).toEqual [view1, editSession1, view3, view2, editSession2]
expect(pane.currentItem).toBe view3
expect(pane.getCurrentItemIndex()).toBe 2
Allow panes to have model objects as items in addition to views The problem I've been struggling with is that we need to potentially assign tabs both to EditSessions and also to other views added by extensions, like a markdown preview view. EditSessions are however not actually views… instead they plug into editors. The solution is to have the pane ask a model object what view should be used to render it. When asked to show a non-view item, the pane constructs and appends a view for that item or recycles an appropriate view that it has already appended.
2013-02-18 22:15:33 +04:00
describe "when showing a model item", ->
describe "when no view has yet been appended for that item", ->
it "appends and shows a view to display the item based on its `.getViewClass` method", ->
pane.showItem(editSession1)
editor = pane.itemViews.find('.editor').view()
expect(editor.activeEditSession).toBe editSession1
describe "when a valid view has already been appended for another item", ->
it "recycles the existing view by assigning the selected item to it", ->
pane.showItem(editSession1)
pane.showItem(editSession2)
expect(pane.itemViews.find('.editor').length).toBe 1
editor = pane.itemViews.find('.editor').view()
expect(editor.activeEditSession).toBe editSession2
describe "when showing a view item", ->
it "appends it to the itemViews div if it hasn't already been appended and show it", ->
expect(pane.itemViews.find('#view-2')).not.toExist()
pane.showItem(view2)
expect(pane.itemViews.find('#view-2')).toExist()
Add show next / previous item.
2013-02-18 22:44:51 +04:00
Add `Pane.removeItem`
2013-02-19 02:23:23 +04:00
describe ".removeItem(item)", ->
it "removes the item from the items list and shows the next item if it was showing", ->
pane.removeItem(view1)
expect(pane.getItems()).toEqual [editSession1, view2, editSession2]
expect(pane.currentItem).toBe editSession1
pane.showItem(editSession2)
pane.removeItem(editSession2)
expect(pane.getItems()).toEqual [editSession1, view2]
expect(pane.currentItem).toBe editSession1
describe "when the item is a view", ->
it "removes the item from the 'item-views' div", ->
expect(view1.parent()).toMatchSelector pane.itemViews
pane.removeItem(view1)
expect(view1.parent()).not.toMatchSelector pane.itemViews
describe "when the item is a model", ->
it "removes the associated view only when all items that require it have been removed", ->
pane.showItem(editSession2)
pane.removeItem(editSession2)
expect(pane.itemViews.find('.editor')).toExist()
pane.removeItem(editSession1)
expect(pane.itemViews.find('.editor')).not.toExist()
Panes destroy their items when they are removed As a consequence of these changes, editors will no longer need to listen for destruction of their edit sessions. An editor will eventually only ever be displaying a single edit session, and the editor will destroy that edit session when it is removed. Panes will be responsible for supporting multiple edit sessions, and they will automatically remove the editor when they have no more edit session items.
2013-02-19 03:22:09 +04:00
it "calls destroy on the model", ->
pane.removeItem(editSession2)
expect(editSession2.destroyed).toBeTruthy()
Add show next / previous item.
2013-02-18 22:44:51 +04:00
describe "pane:show-next-item and pane:show-preview-item", ->
it "advances forward/backward through the pane's items, looping around at either end", ->
expect(pane.currentItem).toBe view1
pane.trigger 'pane:show-previous-item'
expect(pane.currentItem).toBe editSession2
pane.trigger 'pane:show-previous-item'
expect(pane.currentItem).toBe view2
pane.trigger 'pane:show-next-item'
expect(pane.currentItem).toBe editSession2
pane.trigger 'pane:show-next-item'
expect(pane.currentItem).toBe view1
Panes destroy their items when they are removed As a consequence of these changes, editors will no longer need to listen for destruction of their edit sessions. An editor will eventually only ever be displaying a single edit session, and the editor will destroy that edit session when it is removed. Panes will be responsible for supporting multiple edit sessions, and they will automatically remove the editor when they have no more edit session items.
2013-02-19 03:22:09 +04:00
describe ".remove()", ->
it "destroys all the pane's items", ->
pane.remove()
expect(editSession1.destroyed).toBeTruthy()
expect(editSession2.destroyed).toBeTruthy()
Add `Pane.itemForPath`
2013-02-19 03:37:13 +04:00
describe ".itemForPath(path)", ->
it "returns the item for which a call to .getPath() returns the given path", ->
expect(pane.itemForPath(editSession1.getPath())).toBe editSession1
expect(pane.itemForPath(editSession2.getPath())).toBe editSession2
Reference in New Issue Copy Permalink