vapid 0.1.0

data/lib/vapid/vendor/trix/src/trix/models/splittable_list.coffee

@@ -0,0 +1,168 @@
+{spliceArray} = Trix
+
+class Trix.SplittableList extends Trix.Object
+  @box: (objects) ->
+    if objects instanceof this
+      objects
+    else
+      new this objects
+
+  constructor: (objects = []) ->
+    super
+    @objects = objects.slice(0)
+    @length = @objects.length
+
+  indexOf: (object) ->
+    @objects.indexOf(object)
+
+  splice: (args...) ->
+    new @constructor spliceArray(@objects, args...)
+
+  eachObject: (callback) ->
+    callback(object, index) for object, index in @objects
+
+  insertObjectAtIndex: (object, index) ->
+    @splice(index, 0, object)
+
+  insertSplittableListAtIndex: (splittableList, index) ->
+    @splice(index, 0, splittableList.objects...)
+
+  insertSplittableListAtPosition: (splittableList, position) ->
+    [objects, index] = @splitObjectAtPosition(position)
+    new @constructor(objects).insertSplittableListAtIndex(splittableList, index)
+
+  editObjectAtIndex: (index, callback) ->
+    @replaceObjectAtIndex(callback(@objects[index]), index)
+
+  replaceObjectAtIndex: (object, index) ->
+    @splice(index, 1, object)
+
+  removeObjectAtIndex: (index) ->
+    @splice(index, 1)
+
+  getObjectAtIndex: (index) ->
+    @objects[index]
+
+  getSplittableListInRange: (range) ->
+    [objects, leftIndex, rightIndex] = @splitObjectsAtRange(range)
+    new @constructor objects.slice(leftIndex, rightIndex + 1)
+
+  selectSplittableList: (test) ->
+    objects = (object for object in @objects when test(object))
+    new @constructor objects
+
+  removeObjectsInRange: (range) ->
+    [objects, leftIndex, rightIndex] = @splitObjectsAtRange(range)
+    new @constructor(objects).splice(leftIndex, rightIndex - leftIndex + 1)
+
+  transformObjectsInRange: (range, transform) ->
+    [objects, leftIndex, rightIndex] = @splitObjectsAtRange(range)
+    transformedObjects = for object, index in objects
+      if leftIndex <= index <= rightIndex
+        transform(object)
+      else
+        object
+    new @constructor transformedObjects
+
+  splitObjectsAtRange: (range) ->
+    [objects, leftInnerIndex, offset] = @splitObjectAtPosition(startOfRange(range))
+    [objects, rightOuterIndex] = new @constructor(objects).splitObjectAtPosition(endOfRange(range) + offset)
+    [objects, leftInnerIndex, rightOuterIndex - 1]
+
+  getObjectAtPosition: (position) ->
+    {index, offset} = @findIndexAndOffsetAtPosition(position)
+    @objects[index]
+
+  splitObjectAtPosition: (position) ->
+    {index, offset} = @findIndexAndOffsetAtPosition(position)
+    objects = @objects.slice(0)
+    if index?
+      if offset is 0
+        splitIndex = index
+        splitOffset = 0
+      else
+        object = @getObjectAtIndex(index)
+        [leftObject, rightObject] = object.splitAtOffset(offset)
+        objects.splice(index, 1, leftObject, rightObject)
+        splitIndex = index + 1
+        splitOffset = leftObject.getLength() - offset
+    else
+      splitIndex = objects.length
+      splitOffset = 0
+
+    [objects, splitIndex, splitOffset]
+
+  consolidate: ->
+    objects = []
+    pendingObject = @objects[0]
+
+    for object in @objects[1..]
+      if pendingObject.canBeConsolidatedWith?(object)
+        pendingObject = pendingObject.consolidateWith(object)
+      else
+        objects.push(pendingObject)
+        pendingObject = object
+
+    if pendingObject?
+      objects.push(pendingObject)
+
+    new @constructor objects
+
+  consolidateFromIndexToIndex: (startIndex, endIndex) ->
+    objects = @objects.slice(0)
+    objectsInRange = objects.slice(startIndex, endIndex + 1)
+    consolidatedInRange = new @constructor(objectsInRange).consolidate().toArray()
+    @splice(startIndex, objectsInRange.length, consolidatedInRange...)
+
+  findIndexAndOffsetAtPosition: (position) ->
+    currentPosition = 0
+    for object, index in @objects
+      nextPosition = currentPosition + object.getLength()
+      if currentPosition <= position < nextPosition
+        return index: index, offset: position - currentPosition
+      currentPosition = nextPosition
+    index: null, offset: null
+
+  findPositionAtIndexAndOffset: (index, offset) ->
+    position = 0
+    for object, currentIndex in @objects
+      if currentIndex < index
+        position += object.getLength()
+      else if currentIndex is index
+        position += offset
+        break
+    position
+
+  getEndPosition: ->
+    @endPosition ?= (
+      position = 0
+      position += object.getLength() for object in @objects
+      position
+    )
+
+  toString: ->
+    @objects.join("")
+
+  toArray: ->
+    @objects.slice(0)
+
+  toJSON: ->
+    @toArray()
+
+  isEqualTo: (splittableList) ->
+    super or objectArraysAreEqual(@objects, splittableList?.objects)
+
+  objectArraysAreEqual = (left, right = []) ->
+    return false unless left.length is right.length
+    result = true
+    result = false for object, index in left when result and not object.isEqualTo(right[index])
+    result
+
+  contentsForInspection: ->
+    objects: "[#{(object.inspect() for object in @objects).join(", ")}]"
+
+  startOfRange = (range) ->
+    range[0]
+
+  endOfRange = (range) ->
+    range[1]

data/lib/vapid/vendor/trix/src/trix/models/string_piece.coffee

@@ -0,0 +1,49 @@
+#= require trix/models/piece
+
+Trix.Piece.registerType "string", class Trix.StringPiece extends Trix.Piece
+  @fromJSON: (pieceJSON) ->
+    new this pieceJSON.string, pieceJSON.attributes
+
+  constructor: (string) ->
+    super
+    @string = string
+    @length = @string.length
+
+  getValue: ->
+    @string
+
+  toString: ->
+    @string.toString()
+
+  isBlockBreak: ->
+    @toString() is "\n" and @getAttribute("blockBreak") is true
+
+  toJSON: ->
+    result = super
+    result.string = @string
+    result
+
+  # Splittable
+
+  canBeConsolidatedWith: (piece) ->
+    piece? and @hasSameConstructorAs(piece) and @hasSameAttributesAsPiece(piece)
+
+  consolidateWith: (piece) ->
+    new @constructor @toString() + piece.toString(), @attributes
+
+  splitAtOffset: (offset) ->
+    if offset is 0
+      left = null
+      right = this
+    else if offset is @length
+      left = this
+      right = null
+    else
+      left = new @constructor @string.slice(0, offset), @attributes
+      right = new @constructor @string.slice(offset), @attributes
+    [left, right]
+
+  toConsole: ->
+    string = @string
+    string = string.slice(0, 14) + "…" if string.length > 15
+    JSON.stringify(string.toString())

data/lib/vapid/vendor/trix/src/trix/models/text.coffee

@@ -0,0 +1,168 @@
+#= require trix/models/attachment_piece
+#= require trix/models/string_piece
+#= require trix/models/splittable_list
+
+class Trix.Text extends Trix.Object
+  @textForAttachmentWithAttributes: (attachment, attributes) ->
+    piece = new Trix.AttachmentPiece attachment, attributes
+    new this [piece]
+
+  @textForStringWithAttributes: (string, attributes) ->
+    piece = new Trix.StringPiece string, attributes
+    new this [piece]
+
+  @fromJSON: (textJSON) ->
+    pieces = for pieceJSON in textJSON
+      Trix.Piece.fromJSON pieceJSON
+    new this pieces
+
+  constructor: (pieces = []) ->
+    super
+    @pieceList = new Trix.SplittableList (piece for piece in pieces when not piece.isEmpty())
+
+  copy: ->
+    @copyWithPieceList @pieceList
+
+  copyWithPieceList: (pieceList) ->
+    new @constructor pieceList.consolidate().toArray()
+
+  copyUsingObjectMap: (objectMap) ->
+    pieces = for piece in @getPieces()
+      objectMap.find(piece) ? piece
+    new @constructor pieces
+
+  appendText: (text) ->
+    @insertTextAtPosition(text, @getLength())
+
+  insertTextAtPosition: (text, position) ->
+    @copyWithPieceList @pieceList.insertSplittableListAtPosition(text.pieceList, position)
+
+  removeTextAtRange: (range) ->
+    @copyWithPieceList @pieceList.removeObjectsInRange(range)
+
+  replaceTextAtRange: (text, range) ->
+    @removeTextAtRange(range).insertTextAtPosition(text, range[0])
+
+  moveTextFromRangeToPosition: (range, position) ->
+    return if range[0] <= position <= range[1]
+    text = @getTextAtRange(range)
+    length = text.getLength()
+    position -= length if range[0] < position
+    @removeTextAtRange(range).insertTextAtPosition(text, position)
+
+  addAttributeAtRange: (attribute, value, range) ->
+    attributes = {}
+    attributes[attribute] = value
+    @addAttributesAtRange(attributes, range)
+
+  addAttributesAtRange: (attributes, range) ->
+    @copyWithPieceList @pieceList.transformObjectsInRange range, (piece) ->
+      piece.copyWithAdditionalAttributes(attributes)
+
+  removeAttributeAtRange: (attribute, range) ->
+    @copyWithPieceList @pieceList.transformObjectsInRange range, (piece) ->
+      piece.copyWithoutAttribute(attribute)
+
+  setAttributesAtRange: (attributes, range) ->
+    @copyWithPieceList @pieceList.transformObjectsInRange range, (piece) ->
+      piece.copyWithAttributes(attributes)
+
+  getAttributesAtPosition: (position) ->
+    @pieceList.getObjectAtPosition(position)?.getAttributes() ? {}
+
+  getCommonAttributes: ->
+    objects = (piece.getAttributes() for piece in @pieceList.toArray())
+    Trix.Hash.fromCommonAttributesOfObjects(objects).toObject()
+
+  getCommonAttributesAtRange: (range) ->
+    @getTextAtRange(range).getCommonAttributes() ? {}
+
+  getExpandedRangeForAttributeAtOffset: (attributeName, offset) ->
+    left = right = offset
+    length = @getLength()
+
+    left-- while left > 0 and @getCommonAttributesAtRange([left - 1, right])[attributeName]
+    right++ while right < length and @getCommonAttributesAtRange([offset, right + 1])[attributeName]
+
+    [left, right]
+
+  getTextAtRange: (range) ->
+    @copyWithPieceList @pieceList.getSplittableListInRange(range)
+
+  getStringAtRange: (range) ->
+    @pieceList.getSplittableListInRange(range).toString()
+
+  getStringAtPosition: (position) ->
+    @getStringAtRange([position, position + 1])
+
+  startsWithString: (string) ->
+    @getStringAtRange([0, string.length]) is string
+
+  endsWithString: (string) ->
+    length = @getLength()
+    @getStringAtRange([length - string.length, length]) is string
+
+  getAttachmentPieces: ->
+    piece for piece in @pieceList.toArray() when piece.attachment?
+
+  getAttachments: ->
+    piece.attachment for piece in @getAttachmentPieces()
+
+  getAttachmentAndPositionById: (attachmentId) ->
+    position = 0
+    for piece in @pieceList.toArray()
+      if piece.attachment?.id is attachmentId
+        return { attachment: piece.attachment, position }
+      position += piece.length
+    attachment: null, position: null
+
+  getAttachmentById: (attachmentId) ->
+    {attachment, position} = @getAttachmentAndPositionById(attachmentId)
+    attachment
+
+  getRangeOfAttachment: (attachment) ->
+    {attachment, position} = @getAttachmentAndPositionById(attachment.id)
+    [position, position + 1] if attachment?
+
+  updateAttributesForAttachment: (attributes, attachment) ->
+    if range = @getRangeOfAttachment(attachment)
+      @addAttributesAtRange(attributes, range)
+    else
+      this
+
+  getLength: ->
+    @pieceList.getEndPosition()
+
+  isEmpty: ->
+    @getLength() is 0
+
+  isEqualTo: (text) ->
+    super or text?.pieceList?.isEqualTo(@pieceList)
+
+  isBlockBreak: ->
+    @getLength() is 1 and @pieceList.getObjectAtIndex(0).isBlockBreak()
+
+  eachPiece: (callback) ->
+    @pieceList.eachObject(callback)
+
+  getPieces: ->
+    @pieceList.toArray()
+
+  getPieceAtPosition: (position) ->
+    @pieceList.getObjectAtPosition(position)
+
+  contentsForInspection: ->
+    pieceList: @pieceList.inspect()
+
+  toSerializableText: ->
+    pieceList = @pieceList.selectSplittableList (piece) -> piece.isSerializable()
+    @copyWithPieceList(pieceList)
+
+  toString: ->
+    @pieceList.toString()
+
+  toJSON: ->
+    @pieceList.toJSON()
+
+  toConsole: ->
+    JSON.stringify(JSON.parse(piece.toConsole()) for piece in @pieceList.toArray())

data/lib/vapid/vendor/trix/src/trix/models/undo_manager.coffee

@@ -0,0 +1,40 @@
+class Trix.UndoManager extends Trix.BasicObject
+  constructor: (@composition) ->
+    @undoEntries = []
+    @redoEntries = []
+
+  recordUndoEntry: (description, {context, consolidatable} = {}) ->
+    previousEntry = @undoEntries[-1..][0]
+
+    unless consolidatable and entryHasDescriptionAndContext(previousEntry, description, context)
+      undoEntry = @createEntry({description, context})
+      @undoEntries.push(undoEntry)
+      @redoEntries = []
+
+  undo: ->
+    if undoEntry = @undoEntries.pop()
+      redoEntry = @createEntry(undoEntry)
+      @redoEntries.push(redoEntry)
+      @composition.loadSnapshot(undoEntry.snapshot)
+
+  redo: ->
+    if redoEntry = @redoEntries.pop()
+      undoEntry = @createEntry(redoEntry)
+      @undoEntries.push(undoEntry)
+      @composition.loadSnapshot(redoEntry.snapshot)
+
+  canUndo: ->
+    @undoEntries.length > 0
+
+  canRedo: ->
+    @redoEntries.length > 0
+
+  # Private
+
+  createEntry: ({description, context} = {}) ->
+    description: description?.toString()
+    context: JSON.stringify(context)
+    snapshot: @composition.getSnapshot()
+
+  entryHasDescriptionAndContext = (entry, description, context) ->
+    entry?.description is description?.toString() and entry?.context is JSON.stringify(context)

data/lib/vapid/vendor/trix/src/trix/observers/mutation_observer.coffee

@@ -0,0 +1,131 @@
+{findClosestElementFromNode, nodeIsEmptyTextNode, nodeIsBlockStartComment, normalizeSpaces, summarizeStringChange, tagName} = Trix
+
+class Trix.MutationObserver extends Trix.BasicObject
+  mutableAttributeName = "data-trix-mutable"
+  mutableSelector = "[#{mutableAttributeName}]"
+
+  options =
+    attributes: true
+    childList: true
+    characterData: true
+    characterDataOldValue: true
+    subtree: true
+
+  constructor: (@element) ->
+    @observer = new window.MutationObserver @didMutate
+    @start()
+
+  start: ->
+    @reset()
+    @observer.observe(@element, options)
+
+  stop: ->
+    @observer.disconnect()
+
+  didMutate: (mutations) =>
+    @mutations.push(@findSignificantMutations(mutations)...)
+
+    if @mutations.length
+      @delegate?.elementDidMutate?(@getMutationSummary())
+      @reset()
+
+  # Private
+
+  reset: ->
+    @mutations = []
+
+  findSignificantMutations: (mutations) ->
+    mutation for mutation in mutations when @mutationIsSignificant(mutation)
+
+  mutationIsSignificant: (mutation) ->
+    return true for node in @nodesModifiedByMutation(mutation) when @nodeIsSignificant(node)
+    false
+
+  nodeIsSignificant: (node) ->
+    node isnt @element and not @nodeIsMutable(node) and not nodeIsEmptyTextNode(node)
+
+  nodeIsMutable: (node) ->
+    findClosestElementFromNode(node, matchingSelector: mutableSelector)
+
+  nodesModifiedByMutation: (mutation) ->
+    nodes = []
+    switch mutation.type
+      when "attributes"
+        unless mutation.attributeName is mutableAttributeName
+          nodes.push(mutation.target)
+      when "characterData"
+        # Changes to text nodes should consider the parent element
+        nodes.push(mutation.target.parentNode)
+        nodes.push(mutation.target)
+      when "childList"
+        # Consider each added or removed node
+        nodes.push(mutation.addedNodes...)
+        nodes.push(mutation.removedNodes...)
+    nodes
+
+  getMutationSummary: ->
+    @getTextMutationSummary()
+
+  getTextMutationSummary: ->
+    {additions, deletions} = @getTextChangesFromCharacterData()
+
+    textChanges = @getTextChangesFromChildList()
+    additions.push(addition) for addition in textChanges.additions when addition not in additions
+    deletions.push(textChanges.deletions...)
+
+    summary = {}
+    summary.textAdded = added if added = additions.join("")
+    summary.textDeleted = deleted if deleted = deletions.join("")
+    summary
+
+  getMutationsByType: (type) ->
+    mutation for mutation in @mutations when mutation.type is type
+
+  getTextChangesFromChildList: ->
+    addedNodes = []
+    removedNodes = []
+
+    for mutation in @getMutationsByType("childList")
+      addedNodes.push(mutation.addedNodes...)
+      removedNodes.push(mutation.removedNodes...)
+
+    singleBlockCommentRemoved =
+      addedNodes.length is 0 and
+        removedNodes.length is 1 and
+        nodeIsBlockStartComment(removedNodes[0])
+
+    if singleBlockCommentRemoved
+      textAdded = []
+      textRemoved = ["\n"]
+    else
+      textAdded = getTextForNodes(addedNodes)
+      textRemoved = getTextForNodes(removedNodes)
+
+    additions: (normalizeSpaces(text) for text, index in textAdded when text isnt textRemoved[index])
+    deletions: (normalizeSpaces(text) for text, index in textRemoved when text isnt textAdded[index])
+
+  getTextChangesFromCharacterData: ->
+    characterMutations = @getMutationsByType("characterData")
+
+    if characterMutations.length
+      [startMutation, ..., endMutation] = characterMutations
+
+      oldString = normalizeSpaces(startMutation.oldValue)
+      newString = normalizeSpaces(endMutation.target.data)
+      {added, removed} = summarizeStringChange(oldString, newString)
+
+    additions: if added then [added] else []
+    deletions: if removed then [removed] else []
+
+  getTextForNodes = (nodes = []) ->
+    text = []
+    for node in nodes
+      switch node.nodeType
+        when Node.TEXT_NODE
+          text.push(node.data)
+        when Node.ELEMENT_NODE
+          if tagName(node) is "br"
+            text.push("\n")
+          else
+            text.push(getTextForNodes(node.childNodes)...)
+    text