kuji-mercury-rails 0.3.2

data/spec/javascripts/mercury/statusbar_spec.js.coffee

@@ -0,0 +1,150 @@
+describe "Mercury.Statusbar", ->
+
+  template 'mercury/statusbar.html'
+
+  beforeEach ->
+    $.fx.off = true
+    @region = {
+      path: -> [{tagName: 'A'}, {tagName: 'B'}, {tagName: 'C'}]
+    }
+
+  afterEach ->
+    @statusbar = null
+    delete(@statusbar)
+
+  describe "constructor", ->
+
+    beforeEach ->
+      @buildSpy = spyOn(Mercury.Statusbar.prototype, 'build')
+      @bindEventsSpy = spyOn(Mercury.Statusbar.prototype, 'bindEvents')
+      @statusbar = new Mercury.Statusbar({appendTo: '#test', foo: 'bar', visible: false})
+
+    it "accepts options", ->
+      expect(@statusbar.options.foo).toEqual('bar')
+
+    it "sets visible based on options", ->
+      expect(@statusbar.visible).toEqual(false)
+
+    it "calls build", ->
+      expect(@buildSpy.callCount).toEqual(1)
+
+    it "calls bindEvents", ->
+      expect(@bindEventsSpy.callCount).toEqual(1)
+
+
+  describe "#build", ->
+
+    beforeEach ->
+      spyOn(Mercury.Statusbar.prototype, 'bindEvents').andCallFake(=>)
+      @statusbar = new Mercury.Statusbar({appendTo: '#statusbar_container', visible: false})
+
+    it "builds an element", ->
+      expect($('.mercury-statusbar').length).toEqual(1)
+
+    it "builds an about element", ->
+      expect($('.mercury-statusbar-about').length).toEqual(1)
+      expect(@statusbar.aboutElement).toBeDefined()
+
+    it "hides the element if it's not supposed to be visible", ->
+      expect($('.mercury-statusbar').css('visibility')).toEqual('hidden')
+
+    it "can append to any element", ->
+      expect($('#statusbar_container .mercury-statusbar').length).toEqual(1)
+
+
+  describe "observed events ", ->
+
+    beforeEach ->
+      @statusbar = new Mercury.Statusbar({appendTo: '#test'})
+
+    describe "custom event: region:update", ->
+
+      it "calls setPath if a region was provided", ->
+        spy = spyOn(Mercury.Statusbar.prototype, 'setPath').andCallFake(=>)
+        Mercury.trigger('region:update', {region: @region})
+        expect(spy.callCount).toEqual(1)
+
+    describe "clicking on the about element", ->
+
+      it "opens a lightview", ->
+        spy = spyOn(Mercury, 'lightview').andCallFake(=>)
+        jasmine.simulate.click($('.mercury-statusbar-about').get(0))
+        expect(spy.callCount).toEqual(1)
+
+
+  describe "#height", ->
+
+    beforeEach ->
+      spyOn(Mercury.Statusbar.prototype, 'bindEvents').andCallFake(=>)
+      @statusbar = new Mercury.Statusbar({appendTo: '#test', visible: true})
+
+    it "knows it's own height", ->
+      expect(@statusbar.height()).toEqual(20) # styled with css in the template
+
+
+  describe "#top", ->
+
+    describe "when visible", ->
+
+      beforeEach ->
+        spyOn(Mercury.Statusbar.prototype, 'bindEvents').andCallFake(=>)
+        @statusbar = new Mercury.Statusbar({appendTo: '#test', visible: true})
+
+      it "returns the offset top of the element", ->
+        expect(@statusbar.top()).toEqual($('.mercury-statusbar').offset().top)
+
+    describe "when not visible", ->
+
+      beforeEach ->
+        spyOn(Mercury.Statusbar.prototype, 'bindEvents').andCallFake(=>)
+        @statusbar = new Mercury.Statusbar({appendTo: '#test', visible: false})
+
+      it "returns the offset top of the element + it's outer height", ->
+        expect(@statusbar.top()).toEqual($('.mercury-statusbar').offset().top + $('.mercury-statusbar').outerHeight())
+
+
+  describe "#setPath", ->
+
+    beforeEach ->
+      @statusbar = new Mercury.Statusbar({appendTo: '#test'})
+
+    it "builds a path and displays it", ->
+      @statusbar.setPath(@region.path())
+      expect($('.mercury-statusbar').html()).toMatch(/<span><strong>Path: <\/strong><a>c<\/a> .+ <a>b<\/a> .+ <a>a<\/a><\/span>/)
+
+
+  describe "#show", ->
+
+    beforeEach ->
+      @statusbar = new Mercury.Statusbar({appendTo: '#test', visible: false})
+
+    it "sets visible to true", ->
+      @statusbar.visible = false
+      @statusbar.show()
+      expect(@statusbar.visible).toEqual(true)
+
+    it "displays the element", ->
+      $('.mercury-statusbar').css({visibility: 'hidden'})
+      @statusbar.show()
+      expect($('.mercury-statusbar').css('visibility')).toEqual('visible')
+
+    it "sets the opacity of the element", ->
+      $('.mercury-statusbar').css({opacity: 0})
+      @statusbar.show()
+      expect($('.mercury-statusbar').css('opacity')).toEqual('1')
+
+
+  describe "#hide", ->
+
+    beforeEach ->
+      @statusbar = new Mercury.Statusbar({appendTo: '#test', visible: true})
+
+    it "sets visible to false", ->
+      @statusbar.visible = true
+      @statusbar.hide()
+      expect(@statusbar.visible).toEqual(false)
+
+    it "hides the element", ->
+      $('.mercury-statusbar').css({visibility: 'visible'})
+      @statusbar.hide()
+      expect($('.mercury-statusbar').css('visibility')).toEqual('hidden')

data/spec/javascripts/mercury/table_editor_spec.js.coffee

@@ -0,0 +1,194 @@
+describe "Mercury.tableEditor", ->
+
+  template 'mercury/table_editor.html'
+
+  beforeEach ->
+    @table = $('#table1')
+    @cell = @table.find('th, td').first()
+
+  describe "singleton method", ->
+
+    beforeEach ->
+      @loadSpy = spyOn(Mercury.tableEditor, 'load').andCallFake(=>)
+
+    it "calls load", ->
+      Mercury.tableEditor(@table, @cell)
+      expect(@loadSpy.callCount).toEqual(1)
+
+    it "returns the function object", ->
+      ret = Mercury.tableEditor(@table, @cell)
+      expect(ret).toEqual(Mercury.tableEditor)
+
+
+  describe "#load", ->
+
+    it "expects a table and a table cell", ->
+      Mercury.tableEditor(@table, @cell)
+      expect(Mercury.tableEditor.table).toEqual(@table)
+      expect(Mercury.tableEditor.cell).toEqual(@cell)
+
+    it "accepts content that will be placed inside cells", ->
+      Mercury.tableEditor(@table, @cell, '<br/>')
+      expect(Mercury.tableEditor.cellContent).toEqual('<br/>')
+
+    it "sets row based on where the cell is", ->
+      Mercury.tableEditor(@table, @cell)
+      expect(Mercury.tableEditor.row.get(0)).toEqual(@table.find('tr').get(0))
+
+    it "gets the column count", ->
+      Mercury.tableEditor(@table, @cell)
+      expect(Mercury.tableEditor.columnCount).toEqual(6)
+
+    it "gets the row count", ->
+      Mercury.tableEditor(@table, @cell)
+      expect(Mercury.tableEditor.rowCount).toEqual(8)
+
+
+  describe "#getColumnCount", ->
+
+    it "gets the column count from the alpha row", ->
+      Mercury.tableEditor(@table, @cell)
+      expect(Mercury.tableEditor.columnCount).toEqual(6)
+
+
+  describe "#getRowCount", ->
+
+    it "gets the row count", ->
+      Mercury.tableEditor(@table, @cell)
+      expect(Mercury.tableEditor.rowCount).toEqual(8)
+
+
+  describe "#cellIndexFor", ->
+
+    it "gives the right index for different cells", ->
+      cell = @table.find('#row1 td:nth-child(1n)').get(0)
+      expect(Mercury.tableEditor.cellIndexFor(cell)).toEqual(0)
+
+      cell = @table.find('#row2 th:nth-child(2n)').get(0)
+      expect(Mercury.tableEditor.cellIndexFor(cell)).toEqual(1)
+
+      cell = @table.find('#row2 th:nth-child(6n)').get(0)
+      expect(Mercury.tableEditor.cellIndexFor(cell)).toEqual(5)
+
+      cell = @table.find('#row3 td:nth-child(4n)').get(0)
+      expect(Mercury.tableEditor.cellIndexFor(cell)).toEqual(5)
+
+      cell = @table.find('#row7 td:nth-child(2n)').get(0)
+      expect(Mercury.tableEditor.cellIndexFor(cell)).toEqual(2)
+
+
+  describe "#cellSignatureFor", ->
+
+    it "returns an object with cell information", ->
+      cell = @table.find('#row2 th:nth-child(3n)').get(0)
+      sig = Mercury.tableEditor.cellSignatureFor(cell)
+      expect(sig.width).toEqual(1)
+      expect(sig.height).toEqual(2)
+      expect(sig.right).toEqual(3)
+
+      cell = @table.find('#row2 th:nth-child(5n)').get(0)
+      sig = Mercury.tableEditor.cellSignatureFor(cell)
+      expect(sig.width).toEqual(1)
+      expect(sig.height).toEqual(4)
+      expect(sig.right).toEqual(5)
+
+      cell = @table.find('#row7 td:nth-child(1n)').get(0)
+      sig = Mercury.tableEditor.cellSignatureFor(cell)
+      expect(sig.width).toEqual(2)
+      expect(sig.height).toEqual(1)
+      expect(sig.right).toEqual(2)
+
+  describe "#findCellByOptionsFor", ->
+
+    it "finds a matching cell in a specific row, based on right", ->
+      row = @table.find('#row2').get(0)
+      sig = Mercury.tableEditor.findCellByOptionsFor(row, { right: 5 })
+      expect(sig.cell.get(0)).toEqual(@table.find('#row2 th:nth-child(5n)').get(0))
+
+    it "finds a cell based on left", ->
+      row = @table.find('#row5').get(0)
+      sig = Mercury.tableEditor.findCellByOptionsFor(row, { left: 5 })
+      expect(sig.cell.get(0)).toEqual(@table.find('#row5 th:nth-child(5n)').get(0))
+
+    it "finds a cell based on left and width", ->
+      row = @table.find('#row7').get(0)
+      sig = Mercury.tableEditor.findCellByOptionsFor(row, { left: 2, width: 4 })
+      expect(sig.cell.get(0)).toEqual(@table.find('#row7 td:nth-child(2n)').get(0))
+
+    describe "when a cell isn't there", ->
+
+      beforeEach ->
+        @row = @table.find('#row3').get(0)
+
+      it "returns null", ->
+        sig = Mercury.tableEditor.findCellByOptionsFor(@row, { left: 2 })
+        expect(sig).toEqual(null)
+
+      it "can force to an adjacent cell", ->
+        sig = Mercury.tableEditor.findCellByOptionsFor(@row, { left: 2, forceAdjacent: true })
+        expect(sig.cell.get(0)).toEqual(@table.find('#row3 td:nth-child(2n)').get(0))
+        expect(sig.direction).toEqual('after')
+
+
+  describe "#findCellByIntersectionFor", ->
+
+    it "finds cells that intersect vertically, based on the signature of another cell", ->
+      sig = Mercury.tableEditor.cellSignatureFor(@table.find('#row6 td:nth-child(3n)'))
+      intersectingSig = Mercury.tableEditor.findCellByIntersectionFor(@table.find('#row7'), sig)
+      expect(intersectingSig.cell.get(0)).toEqual(@table.find('#row7 td:nth-child(2n)').get(0))
+
+
+  describe "#columnsFor", ->
+
+    it "returns the total number of cells and colspans for a given collection of cells", ->
+      expect(Mercury.tableEditor.columnsFor(@table.find('#row7 td'))).toEqual(6)
+
+
+  describe "#colspanFor", ->
+
+    it "returns the colspan of a given cell", ->
+      cell = @table.find('#row7 td:nth-child(2n)')
+      expect(Mercury.tableEditor.colspanFor(cell)).toEqual(4)
+
+    it "defaults to 1", ->
+      cell = @table.find('#row6 td:first-child')
+      expect(Mercury.tableEditor.colspanFor(cell)).toEqual(1)
+
+
+  describe "#rowspanFor", ->
+
+    it "returns the rowspan of a given cell", ->
+      cell = @table.find('#row2 th:nth-child(5n)')
+      expect(Mercury.tableEditor.rowspanFor(cell)).toEqual(4)
+
+    it "defaults to 1", ->
+      cell = @table.find('#row6 td:first-child')
+      expect(Mercury.tableEditor.rowspanFor(cell)).toEqual(1)
+
+
+  describe "setColspanFor", ->
+
+    beforeEach ->
+      @cell = @table.find('#row2 th:first-child')
+
+    it "sets the colspan for a cell", ->
+      Mercury.tableEditor.setColspanFor(@cell, 20)
+      expect(@cell.attr('colspan')).toEqual('20')
+
+    it "removes the attribute if it's 1", ->
+      Mercury.tableEditor.setColspanFor(@cell, 1)
+      expect(@cell.attr('colspan')).toEqual(undefined)
+
+
+  describe "setRowspanFor", ->
+
+    beforeEach ->
+      @cell = @table.find('#row2 th:first-child')
+
+    it "sets the rowspan for a cell", ->
+      Mercury.tableEditor.setRowspanFor(@cell, 20)
+      expect(@cell.attr('rowspan')).toEqual('20')
+
+    it "removes the attribute if it's 1", ->
+      Mercury.tableEditor.setRowspanFor(@cell, 1)
+      expect(@cell.attr('rowspan')).toEqual(undefined)

data/spec/javascripts/mercury/toolbar.button_group_spec.js.coffee

@@ -0,0 +1,90 @@
+describe "Mercury.Toolbar.ButtonGroup", ->
+
+  template 'mercury/toolbar.button_group.html'
+
+  beforeEach ->
+    Mercury.Toolbar.ButtonGroup.contexts.foo = -> false
+    @region = {
+      element: $('<div class="mercury-region">')
+      currentElement: -> $('<div>')
+    }
+
+  afterEach ->
+    @buttonGroup = null
+    delete(@buttonGroup)
+    $(window).unbind('mercury:region:update')
+
+  describe "constructor", ->
+
+    beforeEach ->
+      @buildSpy = spyOn(Mercury.Toolbar.ButtonGroup.prototype, 'build').andCallThrough()
+      @bindEventsSpy = spyOn(Mercury.Toolbar.ButtonGroup.prototype, 'bindEvents').andCallThrough()
+      @buttonGroup = new Mercury.Toolbar.ButtonGroup('foo', {_context: true})
+
+    it "returns an element", ->
+      html = $('<div>').html(@buttonGroup).html()
+      expect(html).toEqual('<div class="mercury-button-group mercury-foo-group disabled"></div>')
+
+    it "calls build", ->
+      expect(@buildSpy.callCount).toEqual(1)
+
+    it "calls bindEvents", ->
+      expect(@bindEventsSpy.callCount).toEqual(1)
+
+
+  describe "observed events", ->
+
+    describe "custom event: region:update", ->
+
+      it "sets disabled/enabled state based on it's context", ->
+        @buttonGroup = new Mercury.Toolbar.ButtonGroup('foo', {_context: true})
+        contextSpy = spyOn(Mercury.Toolbar.ButtonGroup.contexts, 'foo').andCallFake(-> true)
+
+        expect(@buttonGroup.hasClass('disabled')).toEqual(true)
+
+        Mercury.trigger('region:update', {region: @region})
+        expect(contextSpy.callCount).toEqual(1)
+        expect(@buttonGroup.hasClass('disabled')).toEqual(false)
+
+    describe "custom event: region:focused", ->
+
+      beforeEach ->
+        @region = {
+          type: 'editable'
+          element: $('<div class="mercury-region">')
+        }
+
+      it "disables if the region type isn't supported", ->
+        @buttonGroup = new Mercury.Toolbar.ButtonGroup('foo', {_regions: ['foo']})
+        @buttonGroup.removeClass('disabled')
+        Mercury.trigger('region:focused', {region: @region})
+        expect(@buttonGroup.hasClass('disabled')).toEqual(true)
+
+      it "enables if the region type is supported", ->
+        @buttonGroup = new Mercury.Toolbar.ButtonGroup('foo', {_regions: ['editable']})
+        @buttonGroup.addClass('disabled')
+        Mercury.trigger('region:focused', {region: @region})
+        expect(@buttonGroup.hasClass('disabled')).toEqual(false)
+
+    describe "custom event: region:blurred", ->
+
+      it "disables if it's a button group for specific region types", ->
+        @buttonGroup = new Mercury.Toolbar.ButtonGroup('foo', {_regions: ['editable']})
+        @buttonGroup.removeClass('disabled')
+        Mercury.trigger('region:blurred', {region: @region})
+
+
+
+describe "Mercury.Toolbar.ButtonGroup.contexts", ->
+
+  template 'mercury/toolbar.button_group.html'
+
+  beforeEach ->
+    @contexts = Mercury.Toolbar.ButtonGroup.contexts
+    @region = $('#context_container')
+
+  describe "table", ->
+
+    it "looks up for a table tag", ->
+      expect(@contexts.table($('#context_td'), @region)).toEqual(true)
+      expect(@contexts.table($('#context_em'), @region)).toEqual(false)

data/spec/javascripts/mercury/toolbar.button_spec.js.coffee

@@ -0,0 +1,360 @@
+describe "Mercury.Toolbar.Button", ->
+
+  template 'mercury/toolbar.button.html'
+
+  beforeEach ->
+    Mercury.displayRect = {0, 0, 500, 200}
+    Mercury.Toolbar.Button.contexts.foo = -> true
+    @region = {
+      type: 'editable'
+      element: $('<div class="mercury-region">')
+      currentElement: -> $('<div>')
+    }
+    Mercury.preloadedViews['/nothing'] = 'nothing'
+
+  afterEach ->
+    @button = null
+    delete(@button)
+    $(document).unbind('mercury:region:update')
+    $(document).unbind('mercury:button')
+
+  describe "constructor", ->
+
+    it "expects name and title values", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title')
+      html = $('<div>').html(@button).html()
+      expect(html).toContain('title="title"')
+      expect(html).toContain('class="mercury-button mercury-foo-button"')
+      expect(html).toContain('<em>title</em>')
+
+    it "accepts summary, types and options", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {palette: '/nothing'}, {appendDialogsTo: $('#test')})
+      html = $('<div>').html(@button).html()
+      expect(html).toContain('title="summary"')
+      expect(html).toContain('class="mercury-button mercury-foo-button mercury-button-palette"')
+      expect(html).toContain('<em>title</em>')
+
+    it "calls build", ->
+      spy = spyOn(Mercury.Toolbar.Button.prototype, 'build').andCallFake(=>)
+      spyOn(Mercury.Toolbar.Button.prototype, 'bindEvents').andCallFake(=>)
+      @button = new Mercury.Toolbar.Button('foo', 'title')
+      expect(spy.callCount).toEqual(1)
+
+    it "calls bindEvents", ->
+      spyOn(Mercury.Toolbar.Button.prototype, 'build').andCallFake(=>)
+      spy = spyOn(Mercury.Toolbar.Button.prototype, 'bindEvents').andCallFake(=>)
+      @button = new Mercury.Toolbar.Button('foo', 'title')
+      expect(spy.callCount).toEqual(1)
+
+
+  describe "#build for various button types", ->
+
+    it "attaches an element meant for the expander in button data", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title')
+      expect(@button.data('expander')).toEqual('<div class="mercury-expander-button" data-button="foo"><em></em><span>title</span></div>')
+
+    it "builds toggle buttons, that when clicked toggle their state", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {toggle: true})
+
+      jasmine.simulate.click(@button.get(0))
+      expect(@button.hasClass('pressed')).toEqual(true)
+
+      jasmine.simulate.click(@button.get(0))
+      expect(@button.hasClass('pressed')).toEqual(false)
+
+    it "builds mode buttons, that when clicked fire a mode event", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {mode: true})
+      spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+
+      jasmine.simulate.click(@button.get(0))
+      expect(spy.callCount).toEqual(1)
+      expect(spy.argsForCall[0]).toEqual(['mode', {mode: 'foo'}])
+
+    it "builds buttons that understand context", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {context: true})
+
+      expect(@button.hasClass('active')).toEqual(false)
+      Mercury.trigger('region:update', {region: @region})
+      expect(@button.hasClass('active')).toEqual(true)
+
+    it "builds panel buttons (and assigns toggle)", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {panel: '/blank.html'}, {appendDialogsTo: $('#test')})
+      expect($('#test .mercury-panel').length).toEqual(1)
+
+      jasmine.simulate.click(@button.get(0))
+      expect(@button.hasClass('pressed')).toEqual(true)
+
+      jasmine.simulate.click(@button.get(0))
+      expect(@button.hasClass('pressed')).toEqual(false)
+
+    it "builds palette buttons", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {palette: '/blank.html'}, {appendDialogsTo: $('#test')})
+      expect($('#test .mercury-palette').length).toEqual(1)
+
+    it "builds select buttons", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {select: '/blank.html'}, {appendDialogsTo: $('#test')})
+      expect($('#test .mercury-select').length).toEqual(1)
+
+    it "builds modal buttons", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {modal: '/blank.html'}, {appendDialogsTo: $('#test')})
+      # nothing unique about this in building -- the modal is built/fired on click
+
+    it "builds lightview buttons", ->
+      @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {lightview: '/blank.html'}, {appendDialogsTo: $('#test')})
+      # nothing unique about this in building -- the lightview is built/fired on click
+
+    it "throws an error when an unknown type is encountered", ->
+      expect(=>
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {foo: '/blank.html'})
+      ).toThrow('Unknown button type "foo" used for the "foo" button.')
+
+
+  describe "observed events", ->
+
+    describe "custom event: button", ->
+
+      it "calls click on the button itself", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {context: true})
+        spy = spyOn(@button, 'click').andCallFake(=>)
+
+        Mercury.trigger('button', {action: 'foo'})
+        expect(spy.callCount).toEqual(1)
+
+    describe "custom event: mode", ->
+
+      it "toggles a button when that mode is triggered and the button is toggleable", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {mode: 'preview', toggle: true})
+        spy = spyOn(Mercury.Toolbar.Button.prototype, 'togglePressed').andCallFake(=>)
+
+        Mercury.trigger('mode', {mode: 'preview'})
+        expect(spy.callCount).toEqual(1)
+
+    describe "custom event: region:update", ->
+
+      it "calls contexts if one is available and set", ->
+        contextSpy = spyOn(Mercury.Toolbar.Button.contexts, 'foo').andCallFake(-> true)
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {context: true})
+
+        expect(@button.hasClass('active')).toEqual(false)
+
+        Mercury.trigger('region:update', {region: @region})
+        expect(contextSpy.callCount).toEqual(1)
+        expect(@button.hasClass('active')).toEqual(true)
+
+    describe "custom event: region:focused", ->
+
+      it "disables if the region type isn't supported", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {context: true, regions: ['foo']})
+        @button.removeClass('disabled')
+        Mercury.trigger('region:focused', {region: @region})
+        expect(@button.hasClass('disabled')).toEqual(true)
+
+      it "enables if the region type is supported", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {context: true, regions: ['editable']})
+        @button.addClass('disabled')
+        Mercury.trigger('region:focused', {region: @region})
+        expect(@button.hasClass('disabled')).toEqual(false)
+
+    describe "custom event: region:blurred", ->
+
+      it "disables if it's a button for specific region types", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {context: true, regions: ['editable']})
+        @button.addClass('disabled')
+        Mercury.trigger('region:blurred', {region: @region})
+        expect(@button.hasClass('disabled')).toEqual(true)
+
+    describe "mousedown", ->
+
+      it "sets the active state", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title')
+
+        expect(@button.hasClass('active')).toEqual(false)
+        jasmine.simulate.mousedown(@button.get(0))
+        expect(@button.hasClass('active')).toEqual(true)
+
+    describe "mouseup", ->
+
+      it "removes the active state", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title')
+        @button.addClass('active')
+
+        jasmine.simulate.mouseup(@button.get(0))
+        expect(@button.hasClass('active')).toEqual(false)
+
+    describe "click for various button types", ->
+
+      it "does nothing if the button is disabled", ->
+        spy = spyOn(Mercury.Toolbar.Button.prototype, 'togglePressed').andCallThrough()
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {toggle: true})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.callCount).toEqual(1)
+
+        @button.addClass('disabled')
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.callCount).toEqual(1)
+
+      it "triggers an action event", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary')
+        spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.argsForCall[0]).toEqual(['action', {action: 'foo'}])
+
+      it "triggers a focus:frame event", ->
+        spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {}, {regions: ['editable']})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.argsForCall[1]).toEqual(['focus:frame'])
+
+      it "toggles toggle button pressed state", ->
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {toggle: true})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(@button.hasClass('pressed')).toEqual(true)
+
+        jasmine.simulate.click(@button.get(0))
+        expect(@button.hasClass('pressed')).toEqual(false)
+
+      it "triggers a mode event", ->
+        spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {mode: true})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.argsForCall[0]).toEqual(['mode', {mode: 'foo'}])
+
+      it "opens a modal window", ->
+        spy = spyOn(Mercury, 'modal').andCallFake(=>)
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {modal: '/blank.html'})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.argsForCall[0]).toEqual(['/blank.html', {title: 'summary', handler: 'foo'}])
+
+      it "opens a lightview window", ->
+        spy = spyOn(Mercury, 'lightview').andCallFake(=>)
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {lightview: '/blank.html'})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.argsForCall[0]).toEqual(['/blank.html', {title: 'summary', handler: 'foo', closeButton: true}])
+
+      it "shows and hides palettes", ->
+        spy = spyOn(Mercury.Palette.prototype, 'toggle').andCallFake(=>)
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {palette: '/blank.html'})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.callCount).toEqual(1)
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.callCount).toEqual(2)
+
+      it "shows and hides selects", ->
+        spy = spyOn(Mercury.Select.prototype, 'toggle').andCallFake(=>)
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {select: '/blank.html'})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.callCount).toEqual(1)
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.callCount).toEqual(2)
+
+      it "shows and hides panels, and toggles the button pressed state", ->
+        spy = spyOn(Mercury.Panel.prototype, 'toggle').andCallFake(=>)
+        @button = new Mercury.Toolbar.Button('foo', 'title', 'summary', {panel: '/blank.html'})
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.callCount).toEqual(1)
+
+        jasmine.simulate.click(@button.get(0))
+        expect(spy.callCount).toEqual(2)
+
+
+describe "Mercury.Toolbar.Button.contexts", ->
+
+  template 'mercury/toolbar.button.html'
+
+  beforeEach ->
+    @contexts = Mercury.Toolbar.Button.contexts
+    @region = $('#context_container')
+    @element = $('#context_button')
+
+  it "handles background color", ->
+    @contexts.backColor.call(@, $('#context_backcolor'), @region)
+    expect(@element.css('background-color')).toEqual('rgb(255, 0, 0)')
+
+    @contexts.backColor.call(@, $('#context_none'), @region)
+    if $.browser.mozilla
+      expect(@element.css('background-color')).toEqual('transparent')
+    else
+      expect(@element.css('background-color')).toEqual('rgba(0, 0, 0, 0)')
+
+  it "handles foreground color", ->
+    @contexts.foreColor.call(@, $('#context_forecolor'), @region)
+    expect(@element.css('background-color')).toEqual('rgb(0, 255, 0)')
+
+    @contexts.foreColor.call(@, $('#context_none'), @region)
+    expect(@element.css('background-color')).toEqual('rgb(0, 0, 0)')
+
+  it "knows when something is bold", ->
+    expect(@contexts.bold.call(@, $('#context_bold1 span'), @region)).toEqual(true)
+    expect(@contexts.bold.call(@, $('#context_bold2 span'), @region)).toEqual(true)
+    expect(@contexts.bold.call(@, $('#context_bold3 span'), @region)).toEqual(true)
+    expect(@contexts.bold.call(@, $('#context_bold4 span'), @region)).toEqual(true)
+    expect(@contexts.bold.call(@, $('#context_bold5 span'), @region)).toEqual(false)
+    expect(@contexts.bold.call(@, $('#context_bold6 span'), @region)).toEqual(true)
+    expect(@contexts.bold.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is italic", ->
+    expect(@contexts.italic.call(@, $('#context_italic1 span'), @region)).toEqual(true)
+    expect(@contexts.italic.call(@, $('#context_italic2 span'), @region)).toEqual(true)
+    expect(@contexts.italic.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is overlined", ->
+    expect(@contexts.overline.call(@, $('#context_overline'), @region)).toEqual(true)
+    expect(@contexts.overline.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is striked through", ->
+    expect(@contexts.strikethrough.call(@, $('#context_strikethrough1 span'), @region)).toEqual(true)
+    expect(@contexts.strikethrough.call(@, $('#context_strikethrough2'), @region)).toEqual(true)
+    expect(@contexts.strikethrough.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is underlined", ->
+    expect(@contexts.underline.call(@, $('#context_underline1 span'), @region)).toEqual(true)
+    expect(@contexts.underline.call(@, $('#context_underline2'), @region)).toEqual(true)
+    expect(@contexts.underline.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is subscript", ->
+    expect(@contexts.subscript.call(@, $('#context_subscript span'), @region)).toEqual(true)
+    expect(@contexts.subscript.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is superscript", ->
+    expect(@contexts.superscript.call(@, $('#context_superscript span'), @region)).toEqual(true)
+    expect(@contexts.superscript.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is justified left", ->
+    expect(@contexts.justifyLeft.call(@, $('#context_justifyLeft span'), @region)).toEqual(true)
+    expect(@contexts.justifyLeft.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is justified center", ->
+    expect(@contexts.justifyCenter.call(@, $('#context_justifyCenter span'), @region)).toEqual(true)
+    expect(@contexts.justifyCenter.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is justified right", ->
+    expect(@contexts.justifyRight.call(@, $('#context_justifyRight span'), @region)).toEqual(true)
+    expect(@contexts.justifyRight.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is justified fully", ->
+    expect(@contexts.justifyFull.call(@, $('#context_justifyFull span'), @region)).toEqual(true)
+    expect(@contexts.justifyFull.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is inside an ordered list", ->
+    expect(@contexts.insertOrderedList.call(@, $('#context_orderedlist span'), @region)).toEqual(true)
+    expect(@contexts.insertOrderedList.call(@, $('#context_none'), @region)).toEqual(false)
+
+  it "knows when something is inside an unordered list", ->
+    expect(@contexts.insertUnorderedList.call(@, $('#context_unorderedlist span'), @region)).toEqual(true)
+    expect(@contexts.insertUnorderedList.call(@, $('#context_none'), @region)).toEqual(false)
+
+# todo: fix in jquery
+#  it "understands nested text-decoration styles", ->
+#    expect(@contexts.underline.call(@, $('#context_decoration'), @region)).toEqual(true)