tui_editor-rails 1.0.2.0

data/vendor/assets/components/codemirror/src/model/change_measurement.js

@@ -0,0 +1,61 @@
+import { cmp, Pos } from "../line/pos.js"
+import { lst } from "../util/misc.js"
+
+import { normalizeSelection, Range, Selection } from "./selection.js"
+
+// Compute the position of the end of a change (its 'to' property
+// refers to the pre-change end).
+export function changeEnd(change) {
+  if (!change.text) return change.to
+  return Pos(change.from.line + change.text.length - 1,
+             lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0))
+}
+
+// Adjust a position to refer to the post-change position of the
+// same text, or the end of the change if the change covers it.
+function adjustForChange(pos, change) {
+  if (cmp(pos, change.from) < 0) return pos
+  if (cmp(pos, change.to) <= 0) return changeEnd(change)
+
+  let line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch
+  if (pos.line == change.to.line) ch += changeEnd(change).ch - change.to.ch
+  return Pos(line, ch)
+}
+
+export function computeSelAfterChange(doc, change) {
+  let out = []
+  for (let i = 0; i < doc.sel.ranges.length; i++) {
+    let range = doc.sel.ranges[i]
+    out.push(new Range(adjustForChange(range.anchor, change),
+                       adjustForChange(range.head, change)))
+  }
+  return normalizeSelection(out, doc.sel.primIndex)
+}
+
+function offsetPos(pos, old, nw) {
+  if (pos.line == old.line)
+    return Pos(nw.line, pos.ch - old.ch + nw.ch)
+  else
+    return Pos(nw.line + (pos.line - old.line), pos.ch)
+}
+
+// Used by replaceSelections to allow moving the selection to the
+// start or around the replaced test. Hint may be "start" or "around".
+export function computeReplacedSel(doc, changes, hint) {
+  let out = []
+  let oldPrev = Pos(doc.first, 0), newPrev = oldPrev
+  for (let i = 0; i < changes.length; i++) {
+    let change = changes[i]
+    let from = offsetPos(change.from, oldPrev, newPrev)
+    let to = offsetPos(changeEnd(change), oldPrev, newPrev)
+    oldPrev = change.to
+    newPrev = to
+    if (hint == "around") {
+      let range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0
+      out[i] = new Range(inv ? to : from, inv ? from : to)
+    } else {
+      out[i] = new Range(from, from)
+    }
+  }
+  return new Selection(out, doc.sel.primIndex)
+}

data/vendor/assets/components/codemirror/src/model/changes.js

@@ -0,0 +1,330 @@
+import { retreatFrontier } from "../line/highlight.js"
+import { startWorker } from "../display/highlight_worker.js"
+import { operation } from "../display/operations.js"
+import { regChange, regLineChange } from "../display/view_tracking.js"
+import { clipLine, clipPos, cmp, Pos } from "../line/pos.js"
+import { sawReadOnlySpans } from "../line/saw_special_spans.js"
+import { lineLength, removeReadOnlyRanges, stretchSpansOverChange, visualLine } from "../line/spans.js"
+import { getBetween, getLine, lineNo } from "../line/utils_line.js"
+import { estimateHeight } from "../measurement/position_measurement.js"
+import { hasHandler, signal, signalCursorActivity } from "../util/event.js"
+import { indexOf, lst, map, sel_dontScroll } from "../util/misc.js"
+import { signalLater } from "../util/operation_group.js"
+
+import { changeEnd, computeSelAfterChange } from "./change_measurement.js"
+import { isWholeLineUpdate, linkedDocs, updateDoc } from "./document_data.js"
+import { addChangeToHistory, historyChangeFromChange, mergeOldSpans, pushSelectionToHistory } from "./history.js"
+import { Range, Selection } from "./selection.js"
+import { setSelection, setSelectionNoUndo } from "./selection_updates.js"
+
+// UPDATING
+
+// Allow "beforeChange" event handlers to influence a change
+function filterChange(doc, change, update) {
+  let obj = {
+    canceled: false,
+    from: change.from,
+    to: change.to,
+    text: change.text,
+    origin: change.origin,
+    cancel: () => obj.canceled = true
+  }
+  if (update) obj.update = (from, to, text, origin) => {
+    if (from) obj.from = clipPos(doc, from)
+    if (to) obj.to = clipPos(doc, to)
+    if (text) obj.text = text
+    if (origin !== undefined) obj.origin = origin
+  }
+  signal(doc, "beforeChange", doc, obj)
+  if (doc.cm) signal(doc.cm, "beforeChange", doc.cm, obj)
+
+  if (obj.canceled) return null
+  return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}
+}
+
+// Apply a change to a document, and add it to the document's
+// history, and propagating it to all linked documents.
+export function makeChange(doc, change, ignoreReadOnly) {
+  if (doc.cm) {
+    if (!doc.cm.curOp) return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly)
+    if (doc.cm.state.suppressEdits) return
+  }
+
+  if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
+    change = filterChange(doc, change, true)
+    if (!change) return
+  }
+
+  // Possibly split or suppress the update based on the presence
+  // of read-only spans in its range.
+  let split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to)
+  if (split) {
+    for (let i = split.length - 1; i >= 0; --i)
+      makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text, origin: change.origin})
+  } else {
+    makeChangeInner(doc, change)
+  }
+}
+
+function makeChangeInner(doc, change) {
+  if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) return
+  let selAfter = computeSelAfterChange(doc, change)
+  addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN)
+
+  makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change))
+  let rebased = []
+
+  linkedDocs(doc, (doc, sharedHist) => {
+    if (!sharedHist && indexOf(rebased, doc.history) == -1) {
+      rebaseHist(doc.history, change)
+      rebased.push(doc.history)
+    }
+    makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change))
+  })
+}
+
+// Revert a change stored in a document's history.
+export function makeChangeFromHistory(doc, type, allowSelectionOnly) {
+  if (doc.cm && doc.cm.state.suppressEdits && !allowSelectionOnly) return
+
+  let hist = doc.history, event, selAfter = doc.sel
+  let source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done
+
+  // Verify that there is a useable event (so that ctrl-z won't
+  // needlessly clear selection events)
+  let i = 0
+  for (; i < source.length; i++) {
+    event = source[i]
+    if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
+      break
+  }
+  if (i == source.length) return
+  hist.lastOrigin = hist.lastSelOrigin = null
+
+  for (;;) {
+    event = source.pop()
+    if (event.ranges) {
+      pushSelectionToHistory(event, dest)
+      if (allowSelectionOnly && !event.equals(doc.sel)) {
+        setSelection(doc, event, {clearRedo: false})
+        return
+      }
+      selAfter = event
+    }
+    else break
+  }
+
+  // Build up a reverse change object to add to the opposite history
+  // stack (redo when undoing, and vice versa).
+  let antiChanges = []
+  pushSelectionToHistory(selAfter, dest)
+  dest.push({changes: antiChanges, generation: hist.generation})
+  hist.generation = event.generation || ++hist.maxGeneration
+
+  let filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")
+
+  for (let i = event.changes.length - 1; i >= 0; --i) {
+    let change = event.changes[i]
+    change.origin = type
+    if (filter && !filterChange(doc, change, false)) {
+      source.length = 0
+      return
+    }
+
+    antiChanges.push(historyChangeFromChange(doc, change))
+
+    let after = i ? computeSelAfterChange(doc, change) : lst(source)
+    makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change))
+    if (!i && doc.cm) doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)})
+    let rebased = []
+
+    // Propagate to the linked documents
+    linkedDocs(doc, (doc, sharedHist) => {
+      if (!sharedHist && indexOf(rebased, doc.history) == -1) {
+        rebaseHist(doc.history, change)
+        rebased.push(doc.history)
+      }
+      makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change))
+    })
+  }
+}
+
+// Sub-views need their line numbers shifted when text is added
+// above or below them in the parent document.
+function shiftDoc(doc, distance) {
+  if (distance == 0) return
+  doc.first += distance
+  doc.sel = new Selection(map(doc.sel.ranges, range => new Range(
+    Pos(range.anchor.line + distance, range.anchor.ch),
+    Pos(range.head.line + distance, range.head.ch)
+  )), doc.sel.primIndex)
+  if (doc.cm) {
+    regChange(doc.cm, doc.first, doc.first - distance, distance)
+    for (let d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
+      regLineChange(doc.cm, l, "gutter")
+  }
+}
+
+// More lower-level change function, handling only a single document
+// (not linked ones).
+function makeChangeSingleDoc(doc, change, selAfter, spans) {
+  if (doc.cm && !doc.cm.curOp)
+    return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans)
+
+  if (change.to.line < doc.first) {
+    shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line))
+    return
+  }
+  if (change.from.line > doc.lastLine()) return
+
+  // Clip the change to the size of this doc
+  if (change.from.line < doc.first) {
+    let shift = change.text.length - 1 - (doc.first - change.from.line)
+    shiftDoc(doc, shift)
+    change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
+              text: [lst(change.text)], origin: change.origin}
+  }
+  let last = doc.lastLine()
+  if (change.to.line > last) {
+    change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
+              text: [change.text[0]], origin: change.origin}
+  }
+
+  change.removed = getBetween(doc, change.from, change.to)
+
+  if (!selAfter) selAfter = computeSelAfterChange(doc, change)
+  if (doc.cm) makeChangeSingleDocInEditor(doc.cm, change, spans)
+  else updateDoc(doc, change, spans)
+  setSelectionNoUndo(doc, selAfter, sel_dontScroll)
+}
+
+// Handle the interaction of a change to a document with the editor
+// that this document is part of.
+function makeChangeSingleDocInEditor(cm, change, spans) {
+  let doc = cm.doc, display = cm.display, from = change.from, to = change.to
+
+  let recomputeMaxLength = false, checkWidthStart = from.line
+  if (!cm.options.lineWrapping) {
+    checkWidthStart = lineNo(visualLine(getLine(doc, from.line)))
+    doc.iter(checkWidthStart, to.line + 1, line => {
+      if (line == display.maxLine) {
+        recomputeMaxLength = true
+        return true
+      }
+    })
+  }
+
+  if (doc.sel.contains(change.from, change.to) > -1)
+    signalCursorActivity(cm)
+
+  updateDoc(doc, change, spans, estimateHeight(cm))
+
+  if (!cm.options.lineWrapping) {
+    doc.iter(checkWidthStart, from.line + change.text.length, line => {
+      let len = lineLength(line)
+      if (len > display.maxLineLength) {
+        display.maxLine = line
+        display.maxLineLength = len
+        display.maxLineChanged = true
+        recomputeMaxLength = false
+      }
+    })
+    if (recomputeMaxLength) cm.curOp.updateMaxLine = true
+  }
+
+  retreatFrontier(doc, from.line)
+  startWorker(cm, 400)
+
+  let lendiff = change.text.length - (to.line - from.line) - 1
+  // Remember that these lines changed, for updating the display
+  if (change.full)
+    regChange(cm)
+  else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
+    regLineChange(cm, from.line, "text")
+  else
+    regChange(cm, from.line, to.line + 1, lendiff)
+
+  let changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change")
+  if (changeHandler || changesHandler) {
+    let obj = {
+      from: from, to: to,
+      text: change.text,
+      removed: change.removed,
+      origin: change.origin
+    }
+    if (changeHandler) signalLater(cm, "change", cm, obj)
+    if (changesHandler) (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj)
+  }
+  cm.display.selForContextMenu = null
+}
+
+export function replaceRange(doc, code, from, to, origin) {
+  if (!to) to = from
+  if (cmp(to, from) < 0) [from, to] = [to, from]
+  if (typeof code == "string") code = doc.splitLines(code)
+  makeChange(doc, {from, to, text: code, origin})
+}
+
+// Rebasing/resetting history to deal with externally-sourced changes
+
+function rebaseHistSelSingle(pos, from, to, diff) {
+  if (to < pos.line) {
+    pos.line += diff
+  } else if (from < pos.line) {
+    pos.line = from
+    pos.ch = 0
+  }
+}
+
+// Tries to rebase an array of history events given a change in the
+// document. If the change touches the same lines as the event, the
+// event, and everything 'behind' it, is discarded. If the change is
+// before the event, the event's positions are updated. Uses a
+// copy-on-write scheme for the positions, to avoid having to
+// reallocate them all on every rebase, but also avoid problems with
+// shared position objects being unsafely updated.
+function rebaseHistArray(array, from, to, diff) {
+  for (let i = 0; i < array.length; ++i) {
+    let sub = array[i], ok = true
+    if (sub.ranges) {
+      if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true }
+      for (let j = 0; j < sub.ranges.length; j++) {
+        rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff)
+        rebaseHistSelSingle(sub.ranges[j].head, from, to, diff)
+      }
+      continue
+    }
+    for (let j = 0; j < sub.changes.length; ++j) {
+      let cur = sub.changes[j]
+      if (to < cur.from.line) {
+        cur.from = Pos(cur.from.line + diff, cur.from.ch)
+        cur.to = Pos(cur.to.line + diff, cur.to.ch)
+      } else if (from <= cur.to.line) {
+        ok = false
+        break
+      }
+    }
+    if (!ok) {
+      array.splice(0, i + 1)
+      i = 0
+    }
+  }
+}
+
+function rebaseHist(hist, change) {
+  let from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1
+  rebaseHistArray(hist.done, from, to, diff)
+  rebaseHistArray(hist.undone, from, to, diff)
+}
+
+// Utility for applying a change to a line by handle or number,
+// returning the number and optionally registering the line as
+// changed.
+export function changeLine(doc, handle, changeType, op) {
+  let no = handle, line = handle
+  if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle))
+  else no = lineNo(handle)
+  if (no == null) return null
+  if (op(line, no) && doc.cm) regLineChange(doc.cm, no, changeType)
+  return line
+}

data/vendor/assets/components/codemirror/src/model/chunk.js

@@ -0,0 +1,167 @@
+import { cleanUpLine } from "../line/line_data.js"
+import { indexOf } from "../util/misc.js"
+import { signalLater } from "../util/operation_group.js"
+
+// The document is represented as a BTree consisting of leaves, with
+// chunk of lines in them, and branches, with up to ten leaves or
+// other branch nodes below them. The top node is always a branch
+// node, and is the document object itself (meaning it has
+// additional methods and properties).
+//
+// All nodes have parent links. The tree is used both to go from
+// line numbers to line objects, and to go from objects to numbers.
+// It also indexes by height, and is used to convert between height
+// and line object, and to find the total height of the document.
+//
+// See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html
+
+export function LeafChunk(lines) {
+  this.lines = lines
+  this.parent = null
+  let height = 0
+  for (let i = 0; i < lines.length; ++i) {
+    lines[i].parent = this
+    height += lines[i].height
+  }
+  this.height = height
+}
+
+LeafChunk.prototype = {
+  chunkSize() { return this.lines.length },
+
+  // Remove the n lines at offset 'at'.
+  removeInner(at, n) {
+    for (let i = at, e = at + n; i < e; ++i) {
+      let line = this.lines[i]
+      this.height -= line.height
+      cleanUpLine(line)
+      signalLater(line, "delete")
+    }
+    this.lines.splice(at, n)
+  },
+
+  // Helper used to collapse a small branch into a single leaf.
+  collapse(lines) {
+    lines.push.apply(lines, this.lines)
+  },
+
+  // Insert the given array of lines at offset 'at', count them as
+  // having the given height.
+  insertInner(at, lines, height) {
+    this.height += height
+    this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at))
+    for (let i = 0; i < lines.length; ++i) lines[i].parent = this
+  },
+
+  // Used to iterate over a part of the tree.
+  iterN(at, n, op) {
+    for (let e = at + n; at < e; ++at)
+      if (op(this.lines[at])) return true
+  }
+}
+
+export function BranchChunk(children) {
+  this.children = children
+  let size = 0, height = 0
+  for (let i = 0; i < children.length; ++i) {
+    let ch = children[i]
+    size += ch.chunkSize(); height += ch.height
+    ch.parent = this
+  }
+  this.size = size
+  this.height = height
+  this.parent = null
+}
+
+BranchChunk.prototype = {
+  chunkSize() { return this.size },
+
+  removeInner(at, n) {
+    this.size -= n
+    for (let i = 0; i < this.children.length; ++i) {
+      let child = this.children[i], sz = child.chunkSize()
+      if (at < sz) {
+        let rm = Math.min(n, sz - at), oldHeight = child.height
+        child.removeInner(at, rm)
+        this.height -= oldHeight - child.height
+        if (sz == rm) { this.children.splice(i--, 1); child.parent = null }
+        if ((n -= rm) == 0) break
+        at = 0
+      } else at -= sz
+    }
+    // If the result is smaller than 25 lines, ensure that it is a
+    // single leaf node.
+    if (this.size - n < 25 &&
+        (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
+      let lines = []
+      this.collapse(lines)
+      this.children = [new LeafChunk(lines)]
+      this.children[0].parent = this
+    }
+  },
+
+  collapse(lines) {
+    for (let i = 0; i < this.children.length; ++i) this.children[i].collapse(lines)
+  },
+
+  insertInner(at, lines, height) {
+    this.size += lines.length
+    this.height += height
+    for (let i = 0; i < this.children.length; ++i) {
+      let child = this.children[i], sz = child.chunkSize()
+      if (at <= sz) {
+        child.insertInner(at, lines, height)
+        if (child.lines && child.lines.length > 50) {
+          // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.
+          // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.
+          let remaining = child.lines.length % 25 + 25
+          for (let pos = remaining; pos < child.lines.length;) {
+            let leaf = new LeafChunk(child.lines.slice(pos, pos += 25))
+            child.height -= leaf.height
+            this.children.splice(++i, 0, leaf)
+            leaf.parent = this
+          }
+          child.lines = child.lines.slice(0, remaining)
+          this.maybeSpill()
+        }
+        break
+      }
+      at -= sz
+    }
+  },
+
+  // When a node has grown, check whether it should be split.
+  maybeSpill() {
+    if (this.children.length <= 10) return
+    let me = this
+    do {
+      let spilled = me.children.splice(me.children.length - 5, 5)
+      let sibling = new BranchChunk(spilled)
+      if (!me.parent) { // Become the parent node
+        let copy = new BranchChunk(me.children)
+        copy.parent = me
+        me.children = [copy, sibling]
+        me = copy
+     } else {
+        me.size -= sibling.size
+        me.height -= sibling.height
+        let myIndex = indexOf(me.parent.children, me)
+        me.parent.children.splice(myIndex + 1, 0, sibling)
+      }
+      sibling.parent = me.parent
+    } while (me.children.length > 10)
+    me.parent.maybeSpill()
+  },
+
+  iterN(at, n, op) {
+    for (let i = 0; i < this.children.length; ++i) {
+      let child = this.children[i], sz = child.chunkSize()
+      if (at < sz) {
+        let used = Math.min(n, sz - at)
+        if (child.iterN(at, used, op)) return true
+        if ((n -= used) == 0) break
+        at = 0
+      } else at -= sz
+    }
+  }
+}