vapid 0.1.0

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

@@ -0,0 +1,538 @@
+#= require trix/models/block
+#= require trix/models/splittable_list
+#= require trix/models/html_parser
+
+{arraysAreEqual, normalizeRange, rangeIsCollapsed, getBlockConfig} = Trix
+
+class Trix.Document extends Trix.Object
+  @fromJSON: (documentJSON) ->
+    blocks = for blockJSON in documentJSON
+      Trix.Block.fromJSON blockJSON
+    new this blocks
+
+  @fromHTML: (html, options) ->
+    Trix.HTMLParser.parse(html, options).getDocument()
+
+  @fromString: (string, textAttributes) ->
+    text = Trix.Text.textForStringWithAttributes(string, textAttributes)
+    new this [new Trix.Block text]
+
+
+  constructor: (blocks = []) ->
+    super
+    blocks = [new Trix.Block] if blocks.length is 0
+    @blockList = Trix.SplittableList.box(blocks)
+
+  isEmpty: ->
+    @blockList.length is 1 and (
+      block = @getBlockAtIndex(0)
+      block.isEmpty() and not block.hasAttributes()
+    )
+
+  copy: (options = {})->
+    blocks = if options.consolidateBlocks
+      @blockList.consolidate().toArray()
+    else
+      @blockList.toArray()
+
+    new @constructor blocks
+
+  copyUsingObjectsFromDocument: (sourceDocument) ->
+    objectMap = new Trix.ObjectMap sourceDocument.getObjects()
+    @copyUsingObjectMap(objectMap)
+
+  copyUsingObjectMap: (objectMap) ->
+    blocks = for block in @getBlocks()
+      if mappedBlock = objectMap.find(block)
+        mappedBlock
+      else
+        block.copyUsingObjectMap(objectMap)
+    new @constructor blocks
+
+  copyWithBaseBlockAttributes: (blockAttributes = []) ->
+    blocks = for block in @getBlocks()
+      attributes = blockAttributes.concat(block.getAttributes())
+      block.copyWithAttributes(attributes)
+    new @constructor blocks
+
+  replaceBlock: (oldBlock, newBlock) ->
+    index = @blockList.indexOf(oldBlock)
+    return this if index is -1
+    new @constructor @blockList.replaceObjectAtIndex(newBlock, index)
+
+  insertDocumentAtRange: (document, range) ->
+    {blockList} = document
+    [position] = range = normalizeRange(range)
+    {index, offset} = @locationFromPosition(position)
+
+    result = this
+    block = @getBlockAtPosition(position)
+
+    if rangeIsCollapsed(range) and block.isEmpty() and not block.hasAttributes()
+      result = new @constructor result.blockList.removeObjectAtIndex(index)
+    else if block.getBlockBreakPosition() is offset
+      position++
+
+    result = result.removeTextAtRange(range)
+    new @constructor result.blockList.insertSplittableListAtPosition(blockList, position)
+
+  mergeDocumentAtRange: (document, range) ->
+    [startPosition] = range = normalizeRange(range)
+    startLocation = @locationFromPosition(startPosition)
+    blockAttributes = @getBlockAtIndex(startLocation.index).getAttributes()
+    baseBlockAttributes = document.getBaseBlockAttributes()
+    trailingBlockAttributes = blockAttributes.slice(-baseBlockAttributes.length)
+
+    if arraysAreEqual(baseBlockAttributes, trailingBlockAttributes)
+      leadingBlockAttributes = blockAttributes.slice(0, -baseBlockAttributes.length)
+      formattedDocument = document.copyWithBaseBlockAttributes(leadingBlockAttributes)
+    else
+      formattedDocument = document.copy(consolidateBlocks: true).copyWithBaseBlockAttributes(blockAttributes)
+
+    blockCount = formattedDocument.getBlockCount()
+    firstBlock = formattedDocument.getBlockAtIndex(0)
+
+    if arraysAreEqual(blockAttributes, firstBlock.getAttributes())
+      firstText = firstBlock.getTextWithoutBlockBreak()
+      result = @insertTextAtRange(firstText, range)
+
+      if blockCount > 1
+        formattedDocument = new @constructor formattedDocument.getBlocks().slice(1)
+        position = startPosition + firstText.getLength()
+        result = result.insertDocumentAtRange(formattedDocument, position)
+    else
+      result = @insertDocumentAtRange(formattedDocument, range)
+
+    result
+
+  insertTextAtRange: (text, range) ->
+    [startPosition] = range = normalizeRange(range)
+    {index, offset} = @locationFromPosition(startPosition)
+
+    document = @removeTextAtRange(range)
+    new @constructor document.blockList.editObjectAtIndex index, (block) ->
+      block.copyWithText(block.text.insertTextAtPosition(text, offset))
+
+  removeTextAtRange: (range) ->
+    [leftPosition, rightPosition] = range = normalizeRange(range)
+    return this if rangeIsCollapsed(range)
+    [leftLocation, rightLocation] = @locationRangeFromRange(range)
+
+    leftIndex = leftLocation.index
+    leftOffset = leftLocation.offset
+    leftBlock = @getBlockAtIndex(leftIndex)
+
+    rightIndex = rightLocation.index
+    rightOffset = rightLocation.offset
+    rightBlock = @getBlockAtIndex(rightIndex)
+
+    removeRightNewline = rightPosition - leftPosition is 1 and
+      leftBlock.getBlockBreakPosition() is leftOffset and
+      rightBlock.getBlockBreakPosition() isnt rightOffset and
+      rightBlock.text.getStringAtPosition(rightOffset) is "\n"
+
+    if removeRightNewline
+      blocks = @blockList.editObjectAtIndex rightIndex, (block) ->
+        block.copyWithText(block.text.removeTextAtRange([rightOffset, rightOffset + 1]))
+    else
+      leftText = leftBlock.text.getTextAtRange([0, leftOffset])
+      rightText = rightBlock.text.getTextAtRange([rightOffset, rightBlock.getLength()])
+      text = leftText.appendText(rightText)
+
+      removingLeftBlock = leftIndex isnt rightIndex and leftOffset is 0
+      useRightBlock = removingLeftBlock and leftBlock.getAttributeLevel() >= rightBlock.getAttributeLevel()
+
+      if useRightBlock
+        block = rightBlock.copyWithText(text)
+      else
+        block = leftBlock.copyWithText(text)
+
+      affectedBlockCount = rightIndex + 1 - leftIndex
+      blocks = @blockList.splice(leftIndex, affectedBlockCount, block)
+
+    new @constructor blocks
+
+  moveTextFromRangeToPosition: (range, position) ->
+    [startPosition, endPosition] = range = normalizeRange(range)
+    return this if startPosition <= position <= endPosition
+
+    document = @getDocumentAtRange(range)
+    result = @removeTextAtRange(range)
+
+    movingRightward = startPosition < position
+    position -= document.getLength() if movingRightward
+
+    unless result.firstBlockInRangeIsEntirelySelected(range)
+      [firstBlock, blocks...] = document.getBlocks()
+      if blocks.length is 0
+        text = firstBlock.getTextWithoutBlockBreak()
+        position += 1 if movingRightward
+      else
+        text = firstBlock.text
+
+      result = result.insertTextAtRange(text, position)
+      return result if blocks.length is 0
+
+      document = new @constructor blocks
+      position += text.getLength()
+
+    result.insertDocumentAtRange(document, position)
+
+  addAttributeAtRange: (attribute, value, range) ->
+    blockList = @blockList
+    @eachBlockAtRange range, (block, textRange, index) ->
+      blockList = blockList.editObjectAtIndex index, ->
+        if getBlockConfig(attribute)
+          block.addAttribute(attribute, value)
+        else
+          if textRange[0] is textRange[1]
+            block
+          else
+            block.copyWithText(block.text.addAttributeAtRange(attribute, value, textRange))
+    new @constructor blockList
+
+  addAttribute: (attribute, value) ->
+    blockList = @blockList
+    @eachBlock (block, index) ->
+      blockList = blockList.editObjectAtIndex (index), ->
+        block.addAttribute(attribute, value)
+    new @constructor blockList
+
+  removeAttributeAtRange: (attribute, range) ->
+    blockList = @blockList
+    @eachBlockAtRange range, (block, textRange, index) ->
+      if getBlockConfig(attribute)
+        blockList = blockList.editObjectAtIndex index, ->
+          block.removeAttribute(attribute)
+      else if textRange[0] isnt textRange[1]
+        blockList = blockList.editObjectAtIndex index, ->
+          block.copyWithText(block.text.removeAttributeAtRange(attribute, textRange))
+    new @constructor blockList
+
+  updateAttributesForAttachment: (attributes, attachment) ->
+    [startPosition] = range = @getRangeOfAttachment(attachment)
+    {index} = @locationFromPosition(startPosition)
+    text = @getTextAtIndex(index)
+
+    new @constructor @blockList.editObjectAtIndex index, (block) ->
+      block.copyWithText(text.updateAttributesForAttachment(attributes, attachment))
+
+  removeAttributeForAttachment: (attribute, attachment) ->
+    range = @getRangeOfAttachment(attachment)
+    @removeAttributeAtRange(attribute, range)
+
+  insertBlockBreakAtRange: (range) ->
+    [startPosition] = range = normalizeRange(range)
+    {offset} = @locationFromPosition(startPosition)
+
+    document = @removeTextAtRange(range)
+    blocks = [new Trix.Block] if offset is 0
+    new @constructor document.blockList.insertSplittableListAtPosition(new Trix.SplittableList(blocks), startPosition)
+
+  applyBlockAttributeAtRange: (attributeName, value, range) ->
+    {document, range} = @expandRangeToLineBreaksAndSplitBlocks(range)
+    config = getBlockConfig(attributeName)
+
+    if config.listAttribute
+      document = document.removeLastListAttributeAtRange(range, exceptAttributeName: attributeName)
+      {document, range} = document.convertLineBreaksToBlockBreaksInRange(range)
+    else if config.terminal
+      document = document.removeLastTerminalAttributeAtRange(range)
+    else
+      document = document.consolidateBlocksAtRange(range)
+
+    document.addAttributeAtRange(attributeName, value, range)
+
+  removeLastListAttributeAtRange: (range, options = {}) ->
+    blockList = @blockList
+    @eachBlockAtRange range, (block, textRange, index) ->
+      return unless lastAttributeName = block.getLastAttribute()
+      return unless getBlockConfig(lastAttributeName).listAttribute
+      return if lastAttributeName is options.exceptAttributeName
+      blockList = blockList.editObjectAtIndex index, ->
+        block.removeAttribute(lastAttributeName)
+    new @constructor blockList
+
+  removeLastTerminalAttributeAtRange: (range) ->
+    blockList = @blockList
+    @eachBlockAtRange range, (block, textRange, index) ->
+      return unless lastAttributeName = block.getLastAttribute()
+      return unless getBlockConfig(lastAttributeName).terminal
+      blockList = blockList.editObjectAtIndex index, ->
+        block.removeAttribute(lastAttributeName)
+    new @constructor blockList
+
+  firstBlockInRangeIsEntirelySelected: (range) ->
+    [startPosition, endPosition] = range = normalizeRange(range)
+    leftLocation = @locationFromPosition(startPosition)
+    rightLocation = @locationFromPosition(endPosition)
+
+    if leftLocation.offset is 0 and leftLocation.index < rightLocation.index
+      true
+    else if leftLocation.index is rightLocation.index
+      length = @getBlockAtIndex(leftLocation.index).getLength()
+      leftLocation.offset is 0 and rightLocation.offset is length
+    else
+      false
+
+  expandRangeToLineBreaksAndSplitBlocks: (range) ->
+    [startPosition, endPosition] = range = normalizeRange(range)
+    startLocation = @locationFromPosition(startPosition)
+    endLocation = @locationFromPosition(endPosition)
+    document = this
+
+    startBlock = document.getBlockAtIndex(startLocation.index)
+    if (startLocation.offset = startBlock.findLineBreakInDirectionFromPosition("backward", startLocation.offset))?
+      position = document.positionFromLocation(startLocation)
+      document = document.insertBlockBreakAtRange([position, position + 1])
+      endLocation.index += 1
+      endLocation.offset -= document.getBlockAtIndex(startLocation.index).getLength()
+      startLocation.index += 1
+    startLocation.offset = 0
+
+    if endLocation.offset is 0 and endLocation.index > startLocation.index
+      endLocation.index -= 1
+      endLocation.offset = document.getBlockAtIndex(endLocation.index).getBlockBreakPosition()
+    else
+      endBlock = document.getBlockAtIndex(endLocation.index)
+      if endBlock.text.getStringAtRange([endLocation.offset - 1, endLocation.offset]) is "\n"
+        endLocation.offset -= 1
+      else
+        endLocation.offset = endBlock.findLineBreakInDirectionFromPosition("forward", endLocation.offset)
+      unless endLocation.offset is endBlock.getBlockBreakPosition()
+        position = document.positionFromLocation(endLocation)
+        document = document.insertBlockBreakAtRange([position, position + 1])
+
+    startPosition = document.positionFromLocation(startLocation)
+    endPosition = document.positionFromLocation(endLocation)
+    range = normalizeRange([startPosition, endPosition])
+
+    {document, range}
+
+  convertLineBreaksToBlockBreaksInRange: (range) ->
+    [position] = range = normalizeRange(range)
+    string = @getStringAtRange(range).slice(0, -1)
+    document = this
+
+    string.replace /.*?\n/g, (match) ->
+      position += match.length
+      document = document.insertBlockBreakAtRange([position - 1, position])
+
+    {document, range}
+
+  consolidateBlocksAtRange: (range) ->
+    [startPosition, endPosition] = range = normalizeRange(range)
+    startIndex = @locationFromPosition(startPosition).index
+    endIndex = @locationFromPosition(endPosition).index
+    new @constructor @blockList.consolidateFromIndexToIndex(startIndex, endIndex)
+
+  getDocumentAtRange: (range) ->
+    range = normalizeRange(range)
+    blocks = @blockList.getSplittableListInRange(range).toArray()
+    new @constructor blocks
+
+  getStringAtRange: (range) ->
+    @getDocumentAtRange(range).toString()
+
+  getBlockAtIndex: (index) ->
+    @blockList.getObjectAtIndex(index)
+
+  getBlockAtPosition: (position) ->
+    {index} = @locationFromPosition(position)
+    @getBlockAtIndex(index)
+
+  getTextAtIndex: (index) ->
+    @getBlockAtIndex(index)?.text
+
+  getTextAtPosition: (position) ->
+    {index} = @locationFromPosition(position)
+    @getTextAtIndex(index)
+
+  getPieceAtPosition: (position) ->
+    {index, offset} = @locationFromPosition(position)
+    @getTextAtIndex(index).getPieceAtPosition(offset)
+
+  getCharacterAtPosition: (position) ->
+    {index, offset} = @locationFromPosition(position)
+    @getTextAtIndex(index).getStringAtRange([offset, offset + 1])
+
+  getLength: ->
+    @blockList.getEndPosition()
+
+  getBlocks: ->
+    @blockList.toArray()
+
+  getBlockCount: ->
+    @blockList.length
+
+  getEditCount: ->
+    @editCount
+
+  eachBlock: (callback) ->
+    @blockList.eachObject(callback)
+
+  eachBlockAtRange: (range, callback) ->
+    [startPosition, endPosition] = range = normalizeRange(range)
+    startLocation = @locationFromPosition(startPosition)
+    endLocation = @locationFromPosition(endPosition)
+
+    if startLocation.index is endLocation.index
+      block = @getBlockAtIndex(startLocation.index)
+      textRange = [startLocation.offset, endLocation.offset]
+      callback(block, textRange, startLocation.index)
+    else
+      for index in [startLocation.index..endLocation.index]
+        if block = @getBlockAtIndex(index)
+          textRange = switch index
+            when startLocation.index
+              [startLocation.offset, block.text.getLength()]
+            when endLocation.index
+              [0, endLocation.offset]
+            else
+              [0, block.text.getLength()]
+          callback(block, textRange, index)
+
+  getCommonAttributesAtRange: (range) ->
+    [startPosition] = range = normalizeRange(range)
+    if rangeIsCollapsed(range)
+      @getCommonAttributesAtPosition(startPosition)
+    else
+      textAttributes = []
+      blockAttributes = []
+
+      @eachBlockAtRange range, (block, textRange) ->
+        unless textRange[0] is textRange[1]
+          textAttributes.push(block.text.getCommonAttributesAtRange(textRange))
+          blockAttributes.push(attributesForBlock(block))
+
+      Trix.Hash.fromCommonAttributesOfObjects(textAttributes)
+        .merge(Trix.Hash.fromCommonAttributesOfObjects(blockAttributes))
+        .toObject()
+
+  getCommonAttributesAtPosition: (position) ->
+    {index, offset} = @locationFromPosition(position)
+    block = @getBlockAtIndex(index)
+    return {} unless block
+
+    commonAttributes = attributesForBlock(block)
+    attributes = block.text.getAttributesAtPosition(offset)
+    attributesLeft = block.text.getAttributesAtPosition(offset - 1)
+    inheritableAttributes = (key for key, value of Trix.config.textAttributes when value.inheritable)
+
+    for key, value of attributesLeft
+      if value is attributes[key] or key in inheritableAttributes
+        commonAttributes[key] = value
+
+    commonAttributes
+
+  getRangeOfCommonAttributeAtPosition: (attributeName, position) ->
+    {index, offset} = @locationFromPosition(position)
+    text = @getTextAtIndex(index)
+    [startOffset, endOffset] = text.getExpandedRangeForAttributeAtOffset(attributeName, offset)
+
+    start = @positionFromLocation {index, offset: startOffset}
+    end = @positionFromLocation {index, offset: endOffset}
+    normalizeRange([start, end])
+
+  getBaseBlockAttributes: ->
+    baseBlockAttributes = @getBlockAtIndex(0).getAttributes()
+
+    for blockIndex in [1...@getBlockCount()]
+      blockAttributes = @getBlockAtIndex(blockIndex).getAttributes()
+      lastAttributeIndex = Math.min(baseBlockAttributes.length, blockAttributes.length)
+
+      baseBlockAttributes = for index in [0...lastAttributeIndex]
+        break unless blockAttributes[index] is baseBlockAttributes[index]
+        blockAttributes[index]
+
+    baseBlockAttributes
+
+  attributesForBlock = (block) ->
+    attributes = {}
+    if attributeName = block.getLastAttribute()
+      attributes[attributeName] = true
+    attributes
+
+  getAttachmentById: (attachmentId) ->
+    return attachment for attachment in @getAttachments() when attachment.id is attachmentId
+
+  getAttachmentPieces: ->
+    attachmentPieces = []
+    @blockList.eachObject ({text}) ->
+      attachmentPieces = attachmentPieces.concat(text.getAttachmentPieces())
+    attachmentPieces
+
+  getAttachments: ->
+    piece.attachment for piece in @getAttachmentPieces()
+
+  getRangeOfAttachment: (attachment) ->
+    position = 0
+    for {text}, index in @blockList.toArray()
+      if textRange = text.getRangeOfAttachment(attachment)
+        return normalizeRange([position + textRange[0], position + textRange[1]])
+      position += text.getLength()
+    return
+
+  getLocationRangeOfAttachment: (attachment) ->
+    range = @getRangeOfAttachment(attachment)
+    @locationRangeFromRange(range)
+
+  getAttachmentPieceForAttachment: (attachment) ->
+    return piece for piece in @getAttachmentPieces() when piece.attachment is attachment
+
+  locationFromPosition: (position) ->
+    location = @blockList.findIndexAndOffsetAtPosition(Math.max(0, position))
+    if location.index?
+      location
+    else
+      blocks = @getBlocks()
+      index: blocks.length - 1, offset: blocks[blocks.length - 1].getLength()
+
+  positionFromLocation: (location) ->
+    @blockList.findPositionAtIndexAndOffset(location.index, location.offset)
+
+  locationRangeFromPosition: (position) ->
+    normalizeRange(@locationFromPosition(position))
+
+  locationRangeFromRange: (range) ->
+    return unless range = normalizeRange(range)
+    [startPosition, endPosition] = range
+    startLocation = @locationFromPosition(startPosition)
+    endLocation = @locationFromPosition(endPosition)
+    normalizeRange([startLocation, endLocation])
+
+  rangeFromLocationRange: (locationRange) ->
+    locationRange = normalizeRange(locationRange)
+    leftPosition = @positionFromLocation(locationRange[0])
+    rightPosition = @positionFromLocation(locationRange[1]) unless rangeIsCollapsed(locationRange)
+    normalizeRange([leftPosition, rightPosition])
+
+  isEqualTo: (document) ->
+    @blockList.isEqualTo(document?.blockList)
+
+  getTexts: ->
+    block.text for block in @getBlocks()
+
+  getPieces: ->
+    pieces = []
+    for text in @getTexts()
+      pieces.push(text.getPieces()...)
+    pieces
+
+  getObjects: ->
+    @getBlocks().concat(@getTexts()).concat(@getPieces())
+
+  toSerializableDocument: ->
+    blocks = []
+    @blockList.eachObject (block) ->
+      blocks.push(block.copyWithText(block.text.toSerializableText()))
+    new @constructor blocks
+
+  toString: ->
+    @blockList.toString()
+
+  toJSON: ->
+    @blockList.toJSON()
+
+  toConsole: ->
+    JSON.stringify(JSON.parse(block.text.toConsole()) for block in @blockList.toArray())