mercury-rails 0.1.0

data/app/assets/javascripts/mercury/select.js.coffee

@@ -0,0 +1,40 @@
+class @Mercury.Select extends Mercury.Dialog
+
+  constructor: (@url, @name, @options = {}) ->
+    super
+
+
+  build: ->
+    @element = $('<div>', {class: "mercury-select mercury-#{@name}-select loading", style: 'display:none'})
+    @element.appendTo($(@options.appendTo).get(0) ? 'body')
+
+
+  bindEvents: ->
+    Mercury.bind 'hide:dialogs', (event, dialog) => @hide() unless dialog == @
+    super
+
+
+  position: (keepVisible) ->
+    @element.css({top: 0, left: 0, display: 'block', visibility: 'hidden'})
+    position = @button.offset()
+    elementWidth = @element.width()
+    elementHeight = @element.height()
+    documentHeight = $(document).height()
+
+    top = position.top + (@button.height() / 2) - (elementHeight / 2)
+    top = position.top - 100 if top < position.top - 100
+    top = 20 if top < 20
+
+    height = if @loaded then 'auto' else elementHeight
+    height = documentHeight - top - 20 if top + elementHeight >= documentHeight - 20
+
+    left = position.left
+    left = left - elementWidth + @button.width() if left + elementWidth > $(window).width()
+
+    @element.css {
+      top: top,
+      left: left,
+      height: height,
+      display: if keepVisible then 'block' else 'none',
+      visibility: 'visible'
+    }

data/app/assets/javascripts/mercury/snippet.js.coffee

@@ -0,0 +1,92 @@
+class @Mercury.Snippet
+
+  @all: []
+
+  @displayOptionsFor: (name) ->
+    Mercury.modal("/mercury/snippets/#{name}/options", {title: 'Snippet Options', handler: 'insertsnippet'})
+    Mercury.snippet = null
+
+
+  @create: (name, options) ->
+    identity = "snippet_#{@all.length}"
+    instance = new Mercury.Snippet(name, identity, options)
+    @all.push(instance)
+    return instance
+
+
+  @find: (identity) ->
+    for snippet in @all
+      return snippet if snippet.identity == identity
+    return null
+
+
+  @load: (snippets) ->
+    for identity, details of snippets
+      instance = new Mercury.Snippet(details.name, identity, details.options)
+      @all.push(instance)
+
+
+  constructor: (@name, @identity, options = {}) ->
+    @version = 0
+    @data = ''
+    @history = new Mercury.HistoryBuffer()
+    @setOptions(options)
+
+
+  getHTML: (context, callback = null) ->
+    element = $('<div class="mercury-snippet" contenteditable="false">', context)
+    element.attr({'data-snippet': @identity})
+    element.attr({'data-version': @version})
+    element.html("[#{@identity}]")
+    @loadPreview(element, callback)
+    return element
+
+
+  getText: (callback) ->
+    return "[--#{@identity}--]"
+
+
+  loadPreview: (element, callback = null) ->
+    $.ajax "/mercury/snippets/#{@name}/preview", {
+      type: 'POST'
+      data: @options
+      success: (data) =>
+        @data = data
+        element.html(data)
+        callback() if callback
+      error: =>
+        alert("Error loading the preview for the #{@name} snippet.")
+    }
+
+
+  displayOptions: ->
+    Mercury.snippet = @
+    Mercury.modal "/mercury/snippets/#{@name}/options", {
+      title: 'Snippet Options',
+      handler: 'insertsnippet',
+      loadType: 'post',
+      loadData: @options
+    }
+
+
+  setOptions: (@options) ->
+    delete(@options['authenticity_token'])
+    delete(@options['utf8'])
+    @version += 1
+    @history.push(@options)
+
+
+  setVersion: (version = null) ->
+    version = parseInt(version)
+    if version && @history.stack[version - 1]
+      @version = version - 1
+      @options = @history.stack[@version]
+      return true
+    return false
+
+
+  serialize: ->
+    return {
+      name: @name,
+      options: @options
+    }

data/app/assets/javascripts/mercury/snippet_toolbar.js.coffee

@@ -0,0 +1,69 @@
+class @Mercury.SnippetToolbar extends Mercury.Toolbar
+
+  constructor: (@document, @options = {}) ->
+    super(@options)
+
+
+  build: ->
+    @element = $('<div>', {class: 'mercury-toolbar mercury-snippet-toolbar', style: 'display:none'})
+    @element.appendTo($(@options.appendTo).get(0) ? 'body')
+
+    for buttonName, options of Mercury.config.toolbars.snippetable
+      button = @buildButton(buttonName, options)
+      button.appendTo(@element) if button
+
+
+  bindEvents: ->
+    Mercury.bind 'show:toolbar', (event, options) =>
+      return unless options.snippet
+      options.snippet.mouseout => @hide()
+      @show(options.snippet)
+
+    Mercury.bind 'hide:toolbar', (event, options) =>
+      return unless options.type && options.type == 'snippet'
+      @hide(options.immediately)
+
+    $(@document).scroll => @position() if @visible
+
+    @element.mousemove => clearTimeout(@hideTimeout)
+    @element.mouseout => @hide()
+
+
+  show: (@snippet) ->
+    Mercury.tooltip.hide()
+    @position()
+    @appear()
+
+
+  position: ->
+    offset = @snippet.offset()
+
+    top = offset.top + Mercury.displayRect.top - $(@document).scrollTop() - @height() + 10
+    left = offset.left - $(@document).scrollLeft()
+
+    @element.css {
+      top: top,
+      left: left
+    }
+
+
+  appear: ->
+    clearTimeout(@hideTimeout)
+    return if @visible
+    @visible = true
+    @element.css({display: 'block', opacity: 0})
+    @element.stop().animate({opacity: 1}, 200, 'easeInOutSine')
+
+
+  hide: (immediately = false) ->
+    clearTimeout(@hideTimeout)
+    if immediately
+      @element.hide()
+      @visible = false
+    else
+      @hideTimeout = setTimeout((=>
+        @element.stop().animate {opacity: 0}, 300, 'easeInOutSine', =>
+          @element.hide()
+        @visible = false
+      ), 500)
+

data/app/assets/javascripts/mercury/statusbar.js.coffee

@@ -0,0 +1,25 @@
+class @Mercury.Statusbar
+
+  constructor: (@options = {}) ->
+    @build()
+    @bindEvents()
+
+
+  build: ->
+    @element = $('<div>', {class: 'mercury-statusbar'}).appendTo($(@options.appendTo).get(0) ? 'body')
+
+
+  bindEvents: ->
+    Mercury.bind 'region:update', (event, options) =>
+      @setPath(options.region.path()) if options.region && $.type(options.region.path) == 'function'
+
+
+  height: ->
+    @element.outerHeight()
+
+
+  setPath: (elements) ->
+    path = []
+    path.push("<a>#{element.tagName.toLowerCase()}</a>") for element in elements
+
+    @element.html("<span><strong>Path: </strong></span>#{path.reverse().join(' &raquo; ')}")

data/app/assets/javascripts/mercury/table_editor.js.coffee

@@ -0,0 +1,266 @@
+@Mercury.tableEditor = (table, cell) ->
+  Mercury.tableEditor.load(table, cell)
+  return Mercury.tableEditor
+
+$.extend Mercury.tableEditor, {
+
+  load: (@table, @cell) ->
+    @row = @cell.parent('tr')
+    @columnCount = @getColumnCount()
+    @rowCount = @getRowCount()
+
+
+  addColumn: (position = 'after') ->
+    sig = @cellSignatureFor(@cell)
+
+    for row, i in @table.find('tr')
+      rowSpan = 1
+      matchOptions = if position == 'after' then {right: sig.right} else {left: sig.left}
+      if matching = @findCellByOptionsFor(row, matchOptions)
+        newCell = $("<#{matching.cell.get(0).tagName}>").text('\00')
+        @setRowspanFor(newCell, matching.height)
+        if position == 'before' then matching.cell.before(newCell) else matching.cell.after(newCell)
+        i += matching.height - 1
+      else if intersecting = @findCellByIntersectionFor(row, sig)
+        @setColspanFor(intersecting.cell, intersecting.width + 1)
+
+
+  removeColumn: ->
+    sig = @cellSignatureFor(@cell)
+    return if sig.width > 1
+
+    removing = []
+    adjusting = []
+    for row, i in @table.find('tr')
+      if matching = @findCellByOptionsFor(row, {left: sig.left, width: sig.width})
+        removing.push(matching.cell)
+        i += matching.height - 1
+      else if intersecting = @findCellByIntersectionFor(row, sig)
+        adjusting.push(intersecting.cell)
+
+    $(cell).remove() for cell in removing
+    @setColspanFor(cell, @colspanFor(cell) - 1) for cell in adjusting
+
+
+  addRow: (position = 'after') ->
+    newRow = $('<tr>')
+
+    if (rowspan = @rowspanFor(@cell)) > 1 && position == 'after'
+      @row = $(@row.nextAll('tr')[rowspan - 2])
+
+    cellCount = 0
+    for cell in @row.find('th, td')
+      colspan = @colspanFor(cell)
+      newCell = $("<#{cell.tagName}>").text('\00')
+      @setColspanFor(newCell, colspan)
+      cellCount += colspan
+      if (rowspan = @rowspanFor(cell)) > 1 && position == 'after'
+        @setRowspanFor(cell, rowspan + 1)
+        continue
+
+      newRow.append(newCell)
+
+    if cellCount < @columnCount
+      rowCount = 0
+      for previousRow in @row.prevAll('tr')
+        rowCount += 1
+        for cell in $(previousRow).find('td[rowspan], th[rowspan]')
+          rowspan = @rowspanFor(cell)
+          if rowspan - 1 >= rowCount && position == 'before'
+            @setRowspanFor(cell, rowspan + 1)
+          else if rowspan - 1 >= rowCount && position == 'after'
+            if rowspan - 1 == rowCount
+              newCell = $("<#{cell.tagName}>", {colspan: @colspanFor(cell)})
+              newRow.append(newCell);
+            else
+              @setRowspanFor(cell, rowspan + 1)
+
+    if position == 'before' then @row.before(newRow) else @row.after(newRow)
+
+
+  removeRow: ->
+    # check to see that all cells have the same rowspan, and figure out the minimum rowspan
+    rowspansMatch = true
+    prevRowspan = 0
+    minRowspan = 0
+    for cell in @row.find('td, th')
+      rowspan = @rowspanFor(cell)
+      rowspansMatch = false if prevRowspan && rowspan != prevRowspan
+      minRowspan = rowspan if rowspan < minRowspan || !minRowspan
+      prevRowspan = rowspan
+
+    return if !rowspansMatch && @rowspanFor(@cell) > minRowspan
+
+    # remove any emtpy rows below
+    if minRowspan > 1
+      $(@row.nextAll('tr')[i]).remove() for i in [0..minRowspan - 2]
+
+    # find and move down any cells that have a larger rowspan
+    for cell in @row.find('td[rowspan], th[rowspan]')
+      sig = @cellSignatureFor(cell)
+      continue if sig.height == minRowspan
+      if match = @findCellByOptionsFor(@row.nextAll('tr')[minRowspan - 1], {left: sig.left, forceAdjacent: true})
+        @setRowspanFor(cell, @rowspanFor(cell) - @rowspanFor(@cell))
+        if match.direction == 'before' then match.cell.before($(cell).clone()) else match.cell.after($(cell).clone())
+
+    if @columnsFor(@row.find('td, th')) < @columnCount
+      # move up rows looking for cells with rowspans that might intersect
+      rowsAbove = 0
+      for aboveRow in @row.prevAll('tr')
+        rowsAbove += 1
+        for cell in $(aboveRow).find('td[rowspan], th[rowspan]')
+          # if the cell intersects with the row we're trying to calculate on, and it's index is less than where we've
+          # gotten so far, add it
+          rowspan = @rowspanFor(cell)
+          @setRowspanFor(cell, rowspan - @rowspanFor(@cell)) if rowspan > rowsAbove
+
+    @row.remove()
+
+
+  increaseColspan: ->
+    cell = @cell.next('td, th')
+    return unless cell.length
+    return if @rowspanFor(cell) != @rowspanFor(@cell)
+    return if @cellIndexFor(cell) > @cellIndexFor(@cell) + @colspanFor(@cell)
+    @setColspanFor(@cell, @colspanFor(@cell) + @colspanFor(cell))
+    cell.remove()
+
+
+  decreaseColspan: ->
+    return if @colspanFor(@cell) == 1
+    @setColspanFor(@cell, @colspanFor(@cell) - 1)
+    newCell = $("<#{@cell.get(0).tagName}>").text('\00')
+    @setRowspanFor(newCell, @rowspanFor(@cell))
+    @cell.after(newCell)
+
+
+  increaseRowspan: ->
+    sig = @cellSignatureFor(@cell)
+    nextRow = @row.nextAll('tr')[sig.height - 1]
+    if nextRow && match = @findCellByOptionsFor(nextRow, {left: sig.left, width: sig.width})
+      @setRowspanFor(@cell, sig.height + match.height)
+      match.cell.remove()
+
+  decreaseRowspan: ->
+    sig = @cellSignatureFor(@cell)
+    return if sig.height == 1
+    nextRow = @row.nextAll('tr')[sig.height - 2]
+    if match = @findCellByOptionsFor(nextRow, {left: sig.left, forceAdjacent: true})
+      newCell = $("<#{@cell.get(0).tagName}>").text('\00')
+      @setColspanFor(newCell, @colspanFor(@cell))
+      @setRowspanFor(@cell, sig.height - 1)
+      if match.direction == 'before' then match.cell.before(newCell) else match.cell.after(newCell)
+
+  # Counts the columns of the first row (alpha row) in the table.  We can safely rely on the first row always being
+  # comprised of a full set of cells or cells with colspans.
+  getColumnCount: ->
+    return @columnsFor(@table.find('thead tr:first-child, tbody tr:first-child, tfoot tr:first-child').first().find('td, th'))
+
+
+  # Counts the rows of the table.
+  getRowCount: ->
+    return @table.find('tr').length
+
+
+  # Gets the index for a given cell, taking into account that rows above it can have cells that have rowspans.
+  cellIndexFor: (cell) ->
+    cell = $(cell)
+
+    # get the row for the cell and calculate all the columns in it
+    row = cell.parent('tr')
+    columns = @columnsFor(row.find('td, th'))
+    index = @columnsFor(cell.prevAll('td, th'))
+
+    # if the columns is less than expected, we need to look above for rowspans
+    if columns < @columnCount
+      # move up rows looking for cells with rowspans that might intersect
+      rowsAbove = 0
+      for aboveRow in row.prevAll('tr')
+        rowsAbove += 1
+        for aboveCell in $(aboveRow).find('td[rowspan], th[rowspan]')
+          # if the cell intersects with the row we're trying to calculate on, and it's index is less than where we've
+          # gotten so far, add it
+          if @rowspanFor(aboveCell) > rowsAbove && @cellIndexFor(aboveCell) <= index
+            index += @colspanFor(aboveCell)
+
+    return index
+
+  # Creates a signature for a given cell, which is made up if it's size, and itself.
+  cellSignatureFor: (cell) ->
+    sig = {cell: $(cell)}
+    sig.left = @cellIndexFor(cell)
+    sig.width = @colspanFor(cell)
+    sig.height = @rowspanFor(cell)
+    sig.right = sig.left + sig.width
+    return sig
+
+  # Find a cell based on options.  Options can be:
+  # right
+  # or
+  # left, [width], [forceAdjacent]
+  # eg. findCellByOptionsFor(@row, {left: 1, width: 2, forceAdjacent: true})
+  findCellByOptionsFor: (row, options) ->
+    for cell in $(row).find('td, th')
+      sig = @cellSignatureFor(cell)
+      if typeof(options.right) != 'undefined'
+        return sig if sig.right == options.right
+      if typeof(options.left) != 'undefined'
+
+        if options.width
+          return sig if sig.left == options.left && sig.width == options.width
+        else if !options.forceAdjacent
+          return sig if sig.left == options.left
+        else if options.forceAdjacent
+          if sig.left > options.left
+            prev = $(cell).prev('td, th')
+            if prev.length
+              sig = @cellSignatureFor(prev)
+              sig.direction = 'after'
+            else
+              sig.direction = 'before'
+            return sig
+
+    if options.forceAdjacent
+      sig.direction = 'after'
+      return sig
+
+    return null
+
+  # Finds a cell that intersects with the current signature
+  findCellByIntersectionFor: (row, signature) ->
+    for cell in $(row).find('td, th')
+      sig = @cellSignatureFor(cell)
+      return sig if sig.right - signature.left >= 0 && sig.right > signature.left
+    return null
+
+
+  # Counts all the columns in a given array of columns, taking colspans into
+  # account.
+  columnsFor: (cells) ->
+    count = 0
+    count += @colspanFor(cell) for cell in cells
+    return count
+
+
+  # Tries to get the colspan of a cell, falling back to 1 if there's none
+  # specified.
+  colspanFor: (cell) ->
+    return parseInt($(cell).attr('colspan')) || 1
+
+
+  # Tries to get the rowspan of a cell, falling back to 1 if there's none
+  # specified.
+  rowspanFor: (cell) ->
+    return parseInt($(cell).attr('rowspan')) || 1
+
+
+  # Sets the colspan of a cell, removing it if it's 1.
+  setColspanFor: (cell, value) ->
+    $(cell).attr('colspan', if value > 1 then value else null)
+
+
+  # Sets the rowspan of a cell, removing it if it's 1
+  setRowspanFor: (cell, value) ->
+    $(cell).attr('rowspan', if value > 1 then value else null)
+
+}