kiteditor 1.0.1

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

@@ -0,0 +1,184 @@
+describe "Mercury.SnippetToolbar", ->
+
+  template 'mercury/snippet_toolbar.html'
+
+  beforeEach ->
+    $.fx.off = true
+
+  afterEach ->
+    @snippetToolbar = null
+    delete(@snippetToolbar)
+    $(window).unbind('mercury:hide:toolbar')
+    $(window).unbind('mercury:show:toolbar')
+
+  describe "constructor", ->
+
+    beforeEach ->
+      spyOn(Mercury.SnippetToolbar.prototype, 'build').andCallFake(=>)
+      spyOn(Mercury.SnippetToolbar.prototype, 'bindEvents').andCallFake(=>)
+
+    it "expects document", ->
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'))
+      expect(@snippetToolbar.document).toEqual($('document'))
+
+    it "accepts options", ->
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'))
+      expect(@snippetToolbar.document).toEqual($('document'))
+
+
+  describe "#build", ->
+
+    it "builds an element", ->
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'), {appendTo: '#test'})
+      html = $('<div>').html(@snippetToolbar.element).html()
+      expect(html).toContain('class="mercury-toolbar mercury-snippet-toolbar"')
+      expect(html).toContain('style="display:none"')
+
+    it "appends to any element", ->
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'), {appendTo: '#snippet_toolbar_container'})
+      expect($('#snippet_toolbar_container .mercury-toolbar').length).toEqual(1)
+
+
+  describe "observed events", ->
+
+    beforeEach ->
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'), {appendTo: '#test'})
+
+    describe "custom event: show:toolbar", ->
+
+      it "does nothing if there's no snippet", ->
+        spy = spyOn(Mercury.SnippetToolbar.prototype, 'show').andCallFake(=>)
+        Mercury.trigger('show:toolbar', {snippet: null})
+        expect(spy.callCount).toEqual(0)
+
+      it "calls show", ->
+        spy = spyOn(Mercury.SnippetToolbar.prototype, 'show').andCallFake(=>)
+        Mercury.trigger('show:toolbar', {snippet: $('#snippet')})
+        expect(spy.callCount).toEqual(1)
+
+    describe "custom event: hide:toolbar", ->
+
+      it "does nothing if it's not for the snippet toolbar", ->
+        spy = spyOn(Mercury.SnippetToolbar.prototype, 'hide').andCallFake(=>)
+        Mercury.trigger('hide:toolbar', {type: 'foo'})
+        expect(spy.callCount).toEqual(0)
+
+      it "calls hide", ->
+        spy = spyOn(Mercury.SnippetToolbar.prototype, 'hide').andCallFake(=>)
+        Mercury.trigger('hide:toolbar', {type: 'snippet'})
+        expect(spy.callCount).toEqual(1)
+
+    describe "mousemove", ->
+
+      it "clears the hide timeout", ->
+        spy = spyOn(window, 'clearTimeout').andCallFake(=>)
+        jasmine.simulate.mousemove($('#test .mercury-snippet-toolbar').get(0))
+        expect(spy.callCount).toEqual(1)
+
+    describe "mouseout", ->
+
+      it "calls hide", ->
+        spy = spyOn(Mercury.SnippetToolbar.prototype, 'hide').andCallFake(=>)
+        jasmine.simulate.mouseout($('#test .mercury-snippet-toolbar').get(0))
+        expect(spy.callCount).toEqual(1)
+
+
+  describe "#show", ->
+
+    beforeEach ->
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'), {appendTo: '#test'})
+      @positionSpy = spyOn(Mercury.SnippetToolbar.prototype, 'position').andCallFake(=>)
+      @appearSpy = spyOn(Mercury.SnippetToolbar.prototype, 'appear').andCallFake(=>)
+
+    it "expects a snippet", ->
+      @snippetToolbar.show({snippet: 'foo'})
+      expect(@snippetToolbar.snippet).toEqual({snippet: 'foo'})
+
+    it "calls position", ->
+      @snippetToolbar.show()
+      expect(@positionSpy.callCount).toEqual(1)
+
+    it "calls appear", ->
+      @snippetToolbar.show()
+      expect(@appearSpy.callCount).toEqual(1)
+
+
+  describe "#position", ->
+
+    beforeEach ->
+      Mercury.displayRect = {top: 20}
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'), {appendTo: '#test', visible: true})
+      @snippetToolbar.snippet = $('#snippet')
+
+    it "positions itself based on the snippet", ->
+      @snippetToolbar.element.show()
+      @snippetToolbar.position()
+      if $.browser.webkit
+        expect(@snippetToolbar.element.offset()).toEqual({top: 18, left : 200})
+      else
+        expect(@snippetToolbar.element.offset()).toEqual({top: 14, left : 200})
+
+
+  describe "#appear", ->
+
+    beforeEach ->
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'), {appendTo: '#test'})
+
+    it "clears the hide timeout", ->
+      spy = spyOn(window, 'clearTimeout').andCallFake(=>)
+      @snippetToolbar.appear()
+      expect(spy.callCount).toEqual(1)
+
+    it "sets visible", ->
+      @snippetToolbar.appear()
+      expect(@snippetToolbar.visible).toEqual(true)
+
+    it "shows the element", ->
+      @snippetToolbar.appear()
+      expect(@snippetToolbar.element.css('display')).toEqual('block')
+
+
+  describe "#hide", ->
+
+    beforeEach ->
+      @snippetToolbar = new Mercury.SnippetToolbar($('document'), {appendTo: '#test'})
+
+    it "it clears the hide timeout", ->
+      spy = spyOn(window, 'clearTimeout').andCallFake(=>)
+      @snippetToolbar.hide()
+      expect(spy.callCount).toEqual(1)
+
+    describe "immediately", ->
+
+      beforeEach ->
+        @snippetToolbar.element.show()
+
+      it "hides the element", ->
+        @snippetToolbar.hide(true)
+        expect(@snippetToolbar.element.css('display')).toEqual('none')
+
+      it "sets visible", ->
+        @snippetToolbar.visible = true
+        @snippetToolbar.hide(true)
+        expect(@snippetToolbar.visible).toEqual(false)
+
+    describe "not immediately", ->
+
+      beforeEach ->
+        @snippetToolbar.element.show()
+        @setTimeoutSpy = spyOn(window, 'setTimeout')
+
+      it "sets a timeout", ->
+        @setTimeoutSpy.andCallFake(=>)
+        @snippetToolbar.hide()
+        expect(@setTimeoutSpy.callCount).toEqual(1)
+
+      it "hides the element", ->
+        @setTimeoutSpy.andCallFake((timeout, callback) => callback())
+        @snippetToolbar.hide()
+        expect(@snippetToolbar.element.css('display')).toEqual('none')
+
+      it "sets visible", ->
+        @setTimeoutSpy.andCallFake((timeout, callback) => callback())
+        @snippetToolbar.hide()
+        expect(@snippetToolbar.visible).toEqual(false)

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)