vapid 0.1.0

data/lib/vapid/vendor/trix/test/src/system/caching_test.coffee

@@ -0,0 +1,21 @@
+{assert, clickToolbarButton, moveCursor, test, testGroup, typeCharacters} = Trix.TestHelpers
+
+testGroup "View caching", template: "editor_empty", ->
+  test "reparsing and rendering identical texts", (done) ->
+    typeCharacters "a\nb\na", ->
+      moveCursor direction: "left", times: 2, ->
+        clickToolbarButton attribute: "quote", ->
+          html = getEditorElement().innerHTML
+          getEditorController().reparse()
+          getEditorController().render()
+          assert.equal getEditorElement().innerHTML, html
+          done()
+
+  test "reparsing and rendering identical blocks", (done) ->
+    clickToolbarButton attribute: "bullet", ->
+      typeCharacters "a\na", ->
+        html = getEditorElement().innerHTML
+        getEditorController().reparse()
+        getEditorController().render()
+        assert.equal getEditorElement().innerHTML, html
+        done()

data/lib/vapid/vendor/trix/test/src/system/composition_input_test.coffee

@@ -0,0 +1,138 @@
+{assert, clickToolbarButton, defer, endComposition, insertNode, pressKey, selectNode, startComposition, test, testGroup, triggerEvent, typeCharacters, updateComposition} = Trix.TestHelpers
+
+testGroup "Composition input", template: "editor_empty", ->
+  test "composing", (expectDocument) ->
+    startComposition "a", ->
+      updateComposition "ab", ->
+        endComposition "abc", ->
+          expectDocument "abc\n"
+
+  test "typing and composing", (expectDocument) ->
+    typeCharacters "a", ->
+      startComposition "b", ->
+        updateComposition "bc", ->
+          endComposition "bcd", ->
+            typeCharacters "e", ->
+              expectDocument "abcde\n"
+
+  test "composition input is serialized", (expectDocument) ->
+    startComposition "´", ->
+      endComposition "é", ->
+        assert.equal getEditorElement().value, "<div>é</div>"
+        expectDocument "é\n"
+
+  test "pressing return after a canceled composition", (expectDocument) ->
+    typeCharacters "ab", ->
+      triggerEvent document.activeElement, "compositionend", data: "ab"
+      pressKey "return", ->
+        expectDocument "ab\n\n"
+
+  test "composing formatted text", (expectDocument) ->
+    typeCharacters "abc", ->
+      clickToolbarButton attribute: "bold", ->
+        startComposition "d", ->
+          updateComposition "de", ->
+            endComposition "def", ->
+              assert.textAttributes([0, 3], {})
+              assert.textAttributes([3, 6], bold: true)
+              expectDocument("abcdef\n")
+
+  test "composing away from formatted text", (expectDocument) ->
+    clickToolbarButton attribute: "bold", ->
+      typeCharacters "abc", ->
+        clickToolbarButton attribute: "bold", ->
+          startComposition "d", ->
+            updateComposition "de", ->
+              endComposition "def", ->
+                assert.textAttributes([0, 3], bold: true)
+                assert.textAttributes([3, 6], {})
+                expectDocument("abcdef\n")
+
+  test "composing another language using a QWERTY keyboard", (expectDocument) ->
+    element = getEditorElement()
+    keyCodes = x: 120, i: 105
+
+    triggerEvent(element, "keypress", charCode: keyCodes.x, keyCode: keyCodes.x, which: keyCodes.x)
+    startComposition "x", ->
+      triggerEvent(element, "keypress", charCode: keyCodes.i, keyCode: keyCodes.i, which: keyCodes.i)
+      updateComposition "xi", ->
+        endComposition "喜", ->
+          expectDocument "喜\n"
+
+  # Simulates the sequence of events when pressing backspace through a word on Android
+  test "backspacing through a composition", (expectDocument) ->
+    element = getEditorElement()
+    element.editor.insertString("a cat")
+
+    triggerEvent(element, "keydown", charCode: 0, keyCode: 229, which: 229)
+    triggerEvent(element, "compositionupdate", data: "ca")
+    removeCharacters -1, ->
+      triggerEvent(element, "keydown", charCode: 0, keyCode: 229, which: 229)
+      triggerEvent(element, "compositionupdate", data: "c")
+      triggerEvent(element, "compositionend", data: "c")
+      removeCharacters -1, ->
+        pressKey "backspace", ->
+          expectDocument "a \n"
+
+  # Simulates the sequence of events when pressing backspace at the end of a
+  # word and updating it on Android (running older versions of System WebView)
+  test "updating a composition", (expectDocument) ->
+    element = getEditorElement()
+    element.editor.insertString("cat")
+
+    triggerEvent(element, "keydown", charCode: 0, keyCode: 229, which: 229)
+    triggerEvent(element, "compositionstart", data: "cat")
+    triggerEvent(element, "compositionupdate", data: "cat")
+    removeCharacters -1, ->
+      triggerEvent(element, "keydown", charCode: 0, keyCode: 229, which: 229)
+      triggerEvent(element, "compositionupdate", data: "car")
+      triggerEvent(element, "compositionend", data: "car")
+      insertNode document.createTextNode("r"), ->
+        expectDocument("car\n")
+
+  # Simulates the sequence of events when typing on Android and then tapping elsewhere
+  test "leaving a composition", (expectDocument) ->
+    element = getEditorElement()
+
+    triggerEvent(element, "keydown", charCode: 0, keyCode: 229, which: 229)
+    triggerEvent(element, "compositionstart", data: "")
+    triggerEvent(element, "compositionupdate", data: "c")
+    node = document.createTextNode("c")
+    insertNode(node)
+    defer ->
+      triggerEvent(element, "keydown", charCode: 0, keyCode: 229, which: 229)
+      triggerEvent(element, "compositionupdate", data: "ca")
+      node.data = "ca"
+      defer ->
+        triggerEvent(element, "compositionend", data: "")
+        defer ->
+          expectDocument("ca\n")
+
+  # Simulates compositions in Firefox where the final composition data is
+  # dispatched as both compositionupdate and compositionend.
+  test "composition ending with same data as last update", (expectDocument) ->
+    element = getEditorElement()
+
+    triggerEvent(element, "compositionstart", data: "")
+    triggerEvent(element, "compositionupdate", data: "´")
+    node = document.createTextNode("´")
+    insertNode(node)
+    selectNode(node)
+    defer ->
+      triggerEvent(element, "compositionupdate", data: "é")
+      node.data = "é"
+      defer ->
+        triggerEvent(element, "compositionupdate", data: "éé")
+        node.data = "éé"
+        defer ->
+          triggerEvent(element, "compositionend", data: "éé")
+          defer ->
+            assert.locationRange(index: 0, offset: 2)
+            expectDocument("éé\n")
+
+removeCharacters = (direction, callback) ->
+  selection = rangy.getSelection()
+  range = selection.getRangeAt(0)
+  range.moveStart("character", direction)
+  range.deleteContents()
+  defer(callback)

data/lib/vapid/vendor/trix/test/src/system/cursor_movement_test.coffee

@@ -0,0 +1,54 @@
+{assert, createFile, expandSelection, insertFile, insertString, moveCursor, test, testGroup} = Trix.TestHelpers
+
+testGroup "Cursor movement", template: "editor_empty", ->
+  test "move cursor around attachment", (done) ->
+    insertFile(createFile())
+    assert.locationRange(index: 0, offset: 1)
+    moveCursor "left", ->
+      assert.locationRange({index: 0, offset: 0}, {index: 0, offset: 1})
+      moveCursor "left", ->
+        assert.locationRange(index: 0, offset: 0)
+        moveCursor "right", ->
+          assert.locationRange({index: 0, offset: 0}, {index: 0, offset: 1})
+          moveCursor "right", ->
+            assert.locationRange(index: 0, offset: 1)
+            done()
+
+  test "move cursor around attachment and text", (done) ->
+    insertString("a")
+    insertFile(createFile())
+    insertString("b")
+    assert.locationRange(index: 0, offset: 3)
+    moveCursor "left", ->
+      assert.locationRange(index: 0, offset: 2)
+      moveCursor "left", ->
+        assert.locationRange({index: 0, offset: 1}, {index: 0, offset: 2})
+        moveCursor "left", ->
+          assert.locationRange(index: 0, offset: 1)
+          moveCursor "left", ->
+            assert.locationRange(index: 0, offset: 0)
+            done()
+
+  test "expand selection over attachment", (done) ->
+    insertFile(createFile())
+    assert.locationRange(index: 0, offset: 1)
+    expandSelection "left", ->
+      assert.locationRange({index: 0, offset: 0}, {index: 0, offset: 1})
+      moveCursor "left", ->
+        assert.locationRange(index: 0, offset: 0)
+        expandSelection "right", ->
+          assert.locationRange({index: 0, offset: 0}, {index: 0, offset: 1})
+          done()
+
+  test "expand selection over attachment and text", (done) ->
+    insertString("a")
+    insertFile(createFile())
+    insertString("b")
+    assert.locationRange(index: 0, offset: 3)
+    expandSelection "left", ->
+      assert.locationRange({index: 0, offset: 2}, {index: 0, offset: 3})
+      expandSelection "left", ->
+        assert.locationRange({index: 0, offset: 1}, {index: 0, offset: 3})
+        expandSelection "left", ->
+          assert.locationRange({index: 0, offset: 0}, {index: 0, offset: 3})
+          done()

data/lib/vapid/vendor/trix/test/src/system/custom_element_test.coffee

@@ -0,0 +1,314 @@
+{after, assert, clickElement, clickToolbarButton, createFile, defer, insertImageAttachment, moveCursor, pasteContent, skip, test, testGroup, triggerEvent, typeCharacters, typeInToolbarDialog} = Trix.TestHelpers
+
+testGroup "Custom element API", template: "editor_empty", ->
+  test "files are accepted by default", ->
+    getComposition().insertFile(createFile())
+    assert.equal getComposition().getAttachments().length, 1
+
+  test "rejecting a file by canceling the trix-file-accept event", ->
+    getEditorElement().addEventListener "trix-file-accept", (event) -> event.preventDefault()
+    getComposition().insertFile(createFile())
+    assert.equal getComposition().getAttachments().length, 0
+
+  test "element triggers attachment events", ->
+    file = createFile()
+    element = getEditorElement()
+    composition = getComposition()
+    attachment = null
+    events = []
+
+    element.addEventListener "trix-file-accept", (event) ->
+      events.push(event.type)
+      assert.ok file is event.file
+
+    element.addEventListener "trix-attachment-add", (event) ->
+      events.push(event.type)
+      attachment = event.attachment
+
+    composition.insertFile(file)
+    assert.deepEqual events, ["trix-file-accept", "trix-attachment-add"]
+
+    element.addEventListener "trix-attachment-remove", (event) ->
+      events.push(event.type)
+      assert.ok attachment is event.attachment
+
+    attachment.remove()
+    assert.deepEqual events, ["trix-file-accept", "trix-attachment-add", "trix-attachment-remove"]
+
+  test "element triggers trix-change when an attachment is edited", ->
+    file = createFile()
+    element = getEditorElement()
+    composition = getComposition()
+    attachment = null
+    events = []
+
+    element.addEventListener "trix-attachment-add", (event) ->
+      attachment = event.attachment
+
+    composition.insertFile(file)
+
+    element.addEventListener "trix-attachment-edit", (event) ->
+      events.push(event.type)
+
+    element.addEventListener "trix-change", (event) ->
+      events.push(event.type)
+
+    attachment.setAttributes(width: 9876)
+    assert.deepEqual events, ["trix-attachment-edit", "trix-change"]
+
+  test "editing the document in a trix-attachment-add handler doesn't trigger trix-attachment-add again", ->
+    element = getEditorElement()
+    composition = getComposition()
+    eventCount = 0
+
+    element.addEventListener "trix-attachment-add", ->
+      if eventCount++ is 0
+        element.editor.setSelectedRange([0,1])
+        element.editor.activateAttribute("bold")
+
+    composition.insertFile(createFile())
+    assert.equal eventCount, 1
+
+  test "element triggers trix-change events when the document changes", (done) ->
+    element = getEditorElement()
+    eventCount = 0
+    element.addEventListener "trix-change", (event) -> eventCount++
+
+    typeCharacters "a", ->
+      assert.equal eventCount, 1
+      moveCursor "left", ->
+        assert.equal eventCount, 1
+        typeCharacters "bcd", ->
+          assert.equal eventCount, 4
+          clickToolbarButton action: "undo", ->
+            assert.equal eventCount, 5
+            done()
+
+  test "element triggers trix-change event after toggling attributes", (done) ->
+    element = getEditorElement()
+    editor = element.editor
+
+    afterChangeEvent = (edit, callback) ->
+      element.addEventListener "trix-change", handler = (event) ->
+        element.removeEventListener("trix-change", handler)
+        callback(event)
+      edit()
+
+    typeCharacters "hello", ->
+      edit = -> editor.activateAttribute("quote")
+      afterChangeEvent edit, ->
+        assert.ok editor.attributeIsActive("quote")
+
+        edit = -> editor.deactivateAttribute("quote")
+        afterChangeEvent edit, ->
+          assert.notOk editor.attributeIsActive("quote")
+
+          editor.setSelectedRange([0, 5])
+          edit = -> editor.activateAttribute("bold")
+          afterChangeEvent edit, ->
+            assert.ok editor.attributeIsActive("bold")
+
+            edit = -> editor.deactivateAttribute("bold")
+            afterChangeEvent edit, ->
+              assert.notOk editor.attributeIsActive("bold")
+              done()
+
+  test "disabled attributes aren't considered active", (done) ->
+    {editor} = getEditorElement()
+    editor.activateAttribute("heading1")
+    assert.notOk editor.attributeIsActive("code")
+    assert.notOk editor.attributeIsActive("quote")
+    done()
+
+  test "element triggers trix-selection-change events when the location range changes", (done) ->
+    element = getEditorElement()
+    eventCount = 0
+    element.addEventListener "trix-selection-change", (event) -> eventCount++
+
+    typeCharacters "a", ->
+      assert.equal eventCount, 1
+      moveCursor "left", ->
+        assert.equal eventCount, 2
+        done()
+
+  test "only triggers trix-selection-change events on the active element", (done) ->
+    elementA = getEditorElement()
+    elementB = document.createElement("trix-editor")
+    elementA.parentNode.insertBefore(elementB, elementA.nextSibling)
+
+    elementB.addEventListener "trix-initialize", ->
+      elementA.editor.insertString("a")
+      elementB.editor.insertString("b")
+      rangy.getSelection().removeAllRanges()
+
+      eventCountA = 0
+      eventCountB = 0
+      elementA.addEventListener "trix-selection-change", (event) -> eventCountA++
+      elementB.addEventListener "trix-selection-change", (event) -> eventCountB++
+
+      elementA.editor.setSelectedRange(0)
+      assert.equal eventCountA, 1
+      assert.equal eventCountB, 0
+
+      elementB.editor.setSelectedRange(0)
+      assert.equal eventCountA, 1
+      assert.equal eventCountB, 1
+
+      elementA.editor.setSelectedRange(1)
+      assert.equal eventCountA, 2
+      assert.equal eventCountB, 1
+      done()
+
+  test "element triggers toolbar dialog events", (done) ->
+    element = getEditorElement()
+    events = []
+
+    element.addEventListener "trix-toolbar-dialog-show", (event) ->
+      events.push(event.type)
+
+    element.addEventListener "trix-toolbar-dialog-hide", (event) ->
+      events.push(event.type)
+
+    clickToolbarButton action: "link", ->
+      typeInToolbarDialog "http://example.com", attribute: "href", ->
+        defer ->
+          assert.deepEqual events, ["trix-toolbar-dialog-show", "trix-toolbar-dialog-hide"]
+          done()
+
+  test "element triggers paste event with position range", (done) ->
+    element = getEditorElement()
+    eventCount = 0
+    range = null
+
+    element.addEventListener "trix-paste", (event) ->
+      eventCount++
+      {range} = event
+
+    typeCharacters "", ->
+      pasteContent "text/html", "<strong>hello</strong>", ->
+        assert.equal eventCount, 1
+        assert.ok Trix.rangesAreEqual([5, 5], range)
+        done()
+
+  test "element triggers attribute change events", (done) ->
+    element = getEditorElement()
+    eventCount = 0
+    attributes = null
+
+    element.addEventListener "trix-attributes-change", (event) ->
+      eventCount++
+      {attributes} = event
+
+    typeCharacters "", ->
+      assert.equal eventCount, 0
+      clickToolbarButton attribute: "bold", ->
+        assert.equal eventCount, 1
+        assert.deepEqual { bold: true }, attributes
+        done()
+
+  test "element triggers action change events", (done) ->
+    element = getEditorElement()
+    eventCount = 0
+    actions = null
+
+    element.addEventListener "trix-actions-change", (event) ->
+      eventCount++
+      {actions} = event
+
+    typeCharacters "", ->
+      assert.equal eventCount, 0
+      clickToolbarButton attribute: "bullet", ->
+        assert.equal eventCount, 1
+        assert.equal actions.decreaseNestingLevel, true
+        assert.equal actions.increaseNestingLevel, false
+        done()
+
+  test "element triggers custom focus and blur events", (done) ->
+    element = getEditorElement()
+
+    focusEventCount = 0
+    blurEventCount = 0
+    element.addEventListener "trix-focus", -> focusEventCount++
+    element.addEventListener "trix-blur", -> blurEventCount++
+
+    triggerEvent(element, "blur")
+    defer ->
+      assert.equal blurEventCount, 1
+      assert.equal focusEventCount, 0
+
+      triggerEvent(element, "focus")
+      defer ->
+        assert.equal blurEventCount, 1
+        assert.equal focusEventCount, 1
+
+        insertImageAttachment()
+        after 20, ->
+          clickElement element.querySelector("figure"), ->
+            clickElement element.querySelector("figcaption"), ->
+              defer ->
+                assert.equal document.activeElement, element.querySelector("textarea")
+                assert.equal blurEventCount, 1
+                assert.equal focusEventCount, 1
+                done()
+
+  # Selenium doesn't seem to focus windows properly in some browsers (FF 47 on OS X)
+  # so skip this test when unfocused pending a better solution.
+  testOrSkip = if document.hasFocus() then test else skip
+  testOrSkip "element triggers custom focus event when autofocusing", (done) ->
+    element = document.createElement("trix-editor")
+    element.setAttribute("autofocus", "")
+
+    focusEventCount = 0
+    element.addEventListener "trix-focus", -> focusEventCount++
+
+    container = document.getElementById("trix-container")
+    container.innerHTML = ""
+    container.appendChild(element)
+
+    element.addEventListener "trix-initialize", ->
+      assert.equal focusEventCount, 1
+      done()
+
+  test "element serializes HTML after attribute changes", (done) ->
+    element = getEditorElement()
+    serializedHTML = element.value
+
+    typeCharacters "a", ->
+      assert.notEqual serializedHTML, element.value
+      serializedHTML = element.value
+
+      clickToolbarButton attribute: "quote", ->
+        assert.notEqual serializedHTML, element.value
+        serializedHTML = element.value
+
+        clickToolbarButton attribute: "quote", ->
+          assert.notEqual serializedHTML, element.value
+          done()
+
+  test "editor resets to its original value on form reset", (expectDocument) ->
+    element = getEditorElement()
+    form = element.inputElement.form
+
+    typeCharacters "hello", ->
+      form.reset()
+      expectDocument("\n")
+
+  test "editor resets to last-set value on form reset", (expectDocument) ->
+    element = getEditorElement()
+    form = element.inputElement.form
+
+    element.value = "hi"
+    typeCharacters "hello", ->
+      form.reset()
+      expectDocument("hi\n")
+
+  test "editor respects preventDefault on form reset", (expectDocument) ->
+    element = getEditorElement()
+    form = element.inputElement.form
+    preventDefault = (event) -> event.preventDefault()
+
+    typeCharacters "hello", ->
+      form.addEventListener("reset", preventDefault, false)
+      form.reset()
+      form.removeEventListener("reset", preventDefault, false)
+      expectDocument("hello\n")