LaravelTest

1
// CodeMirror, copyright (c) by Marijn Haverbeke and others
2
// Distributed under an MIT license: https://codemirror.net/LICENSE
3

4
// Glue code between CodeMirror and Tern.
5
//
6
// Create a CodeMirror.TernServer to wrap an actual Tern server,
7
// register open documents (CodeMirror.Doc instances) with it, and
8
// call its methods to activate the assisting functions that Tern
9
// provides.
10
//
11
// Options supported (all optional):
12
// * defs: An array of JSON definition data structures.
13
// * plugins: An object mapping plugin names to configuration
14
//   options.
15
// * getFile: A function(name, c) that can be used to access files in
16
//   the project that haven't been loaded yet. Simply do c(null) to
17
//   indicate that a file is not available.
18
// * fileFilter: A function(value, docName, doc) that will be applied
19
//   to documents before passing them on to Tern.
20
// * switchToDoc: A function(name, doc) that should, when providing a
21
//   multi-file view, switch the view or focus to the named file.
22
// * showError: A function(editor, message) that can be used to
23
//   override the way errors are displayed.
24
// * completionTip: Customize the content in tooltips for completions.
25
//   Is passed a single argument—the completion's data as returned by
26
//   Tern—and may return a string, DOM node, or null to indicate that
27
//   no tip should be shown. By default the docstring is shown.
28
// * typeTip: Like completionTip, but for the tooltips shown for type
29
//   queries.
30
// * responseFilter: A function(doc, query, request, error, data) that
31
//   will be applied to the Tern responses before treating them
32
//
33
//
34
// It is possible to run the Tern server in a web worker by specifying
35
// these additional options:
36
// * useWorker: Set to true to enable web worker mode. You'll probably
37
//   want to feature detect the actual value you use here, for example
38
//   !!window.Worker.
39
// * workerScript: The main script of the worker. Point this to
40
//   wherever you are hosting worker.js from this directory.
41
// * workerDeps: An array of paths pointing (relative to workerScript)
42
//   to the Acorn and Tern libraries and any Tern plugins you want to
43
//   load. Or, if you minified those into a single script and included
44
//   them in the workerScript, simply leave this undefined.
45

46
(function(mod) {
47
  if (typeof exports == "object" && typeof module == "object") // CommonJS
48
    mod(require("../../lib/codemirror"));
49
  else if (typeof define == "function" && define.amd) // AMD
50
    define(["../../lib/codemirror"], mod);
51
  else // Plain browser env
52
    mod(CodeMirror);
53
})(function(CodeMirror) {
54
  "use strict";
55
  // declare global: tern
56

57
  CodeMirror.TernServer = function(options) {
58
    var self = this;
59
    this.options = options || {};
60
    var plugins = this.options.plugins || (this.options.plugins = {});
61
    if (!plugins.doc_comment) plugins.doc_comment = true;
62
    this.docs = Object.create(null);
63
    if (this.options.useWorker) {
64
      this.server = new WorkerServer(this);
65
    } else {
66
      this.server = new tern.Server({
67
        getFile: function(name, c) { return getFile(self, name, c); },
68
        async: true,
69
        defs: this.options.defs || [],
70
        plugins: plugins
71
      });
72
    }
73
    this.trackChange = function(doc, change) { trackChange(self, doc, change); };
74

75
    this.cachedArgHints = null;
76
    this.activeArgHints = null;
77
    this.jumpStack = [];
78

79
    this.getHint = function(cm, c) { return hint(self, cm, c); };
80
    this.getHint.async = true;
81
  };
82

83
  CodeMirror.TernServer.prototype = {
84
    addDoc: function(name, doc) {
85
      var data = {doc: doc, name: name, changed: null};
86
      this.server.addFile(name, docValue(this, data));
87
      CodeMirror.on(doc, "change", this.trackChange);
88
      return this.docs[name] = data;
89
    },
90

91
    delDoc: function(id) {
92
      var found = resolveDoc(this, id);
93
      if (!found) return;
94
      CodeMirror.off(found.doc, "change", this.trackChange);
95
      delete this.docs[found.name];
96
      this.server.delFile(found.name);
97
    },
98

99
    hideDoc: function(id) {
100
      closeArgHints(this);
101
      var found = resolveDoc(this, id);
102
      if (found && found.changed) sendDoc(this, found);
103
    },
104

105
    complete: function(cm) {
106
      cm.showHint({hint: this.getHint});
107
    },
108

109
    showType: function(cm, pos, c) { showContextInfo(this, cm, pos, "type", c); },
110

111
    showDocs: function(cm, pos, c) { showContextInfo(this, cm, pos, "documentation", c); },
112

113
    updateArgHints: function(cm) { updateArgHints(this, cm); },
114

115
    jumpToDef: function(cm) { jumpToDef(this, cm); },
116

117
    jumpBack: function(cm) { jumpBack(this, cm); },
118

119
    rename: function(cm) { rename(this, cm); },
120

121
    selectName: function(cm) { selectName(this, cm); },
122

123
    request: function (cm, query, c, pos) {
124
      var self = this;
125
      var doc = findDoc(this, cm.getDoc());
126
      var request = buildRequest(this, doc, query, pos);
127
      var extraOptions = request.query && this.options.queryOptions && this.options.queryOptions[request.query.type]
128
      if (extraOptions) for (var prop in extraOptions) request.query[prop] = extraOptions[prop];
129

130
      this.server.request(request, function (error, data) {
131
        if (!error && self.options.responseFilter)
132
          data = self.options.responseFilter(doc, query, request, error, data);
133
        c(error, data);
134
      });
135
    },
136

137
    destroy: function () {
138
      closeArgHints(this)
139
      if (this.worker) {
140
        this.worker.terminate();
141
        this.worker = null;
142
      }
143
    }
144
  };
145

146
  var Pos = CodeMirror.Pos;
147
  var cls = "CodeMirror-Tern-";
148
  var bigDoc = 250;
149

150
  function getFile(ts, name, c) {
151
    var buf = ts.docs[name];
152
    if (buf)
153
      c(docValue(ts, buf));
154
    else if (ts.options.getFile)
155
      ts.options.getFile(name, c);
156
    else
157
      c(null);
158
  }
159

160
  function findDoc(ts, doc, name) {
161
    for (var n in ts.docs) {
162
      var cur = ts.docs[n];
163
      if (cur.doc == doc) return cur;
164
    }
165
    if (!name) for (var i = 0;; ++i) {
166
      n = "[doc" + (i || "") + "]";
167
      if (!ts.docs[n]) { name = n; break; }
168
    }
169
    return ts.addDoc(name, doc);
170
  }
171

172
  function resolveDoc(ts, id) {
173
    if (typeof id == "string") return ts.docs[id];
174
    if (id instanceof CodeMirror) id = id.getDoc();
175
    if (id instanceof CodeMirror.Doc) return findDoc(ts, id);
176
  }
177

178
  function trackChange(ts, doc, change) {
179
    var data = findDoc(ts, doc);
180

181
    var argHints = ts.cachedArgHints;
182
    if (argHints && argHints.doc == doc && cmpPos(argHints.start, change.to) >= 0)
183
      ts.cachedArgHints = null;
184

185
    var changed = data.changed;
186
    if (changed == null)
187
      data.changed = changed = {from: change.from.line, to: change.from.line};
188
    var end = change.from.line + (change.text.length - 1);
189
    if (change.from.line < changed.to) changed.to = changed.to - (change.to.line - end);
190
    if (end >= changed.to) changed.to = end + 1;
191
    if (changed.from > change.from.line) changed.from = change.from.line;
192

193
    if (doc.lineCount() > bigDoc && change.to - changed.from > 100) setTimeout(function() {
194
      if (data.changed && data.changed.to - data.changed.from > 100) sendDoc(ts, data);
195
    }, 200);
196
  }
197

198
  function sendDoc(ts, doc) {
199
    ts.server.request({files: [{type: "full", name: doc.name, text: docValue(ts, doc)}]}, function(error) {
200
      if (error) window.console.error(error);
201
      else doc.changed = null;
202
    });
203
  }
204

205
  // Completion
206

207
  function hint(ts, cm, c) {
208
    ts.request(cm, {type: "completions", types: true, docs: true, urls: true}, function(error, data) {
209
      if (error) return showError(ts, cm, error);
210
      var completions = [], after = "";
211
      var from = data.start, to = data.end;
212
      if (cm.getRange(Pos(from.line, from.ch - 2), from) == "[\"" &&
213
          cm.getRange(to, Pos(to.line, to.ch + 2)) != "\"]")
214
        after = "\"]";
215

216
      for (var i = 0; i < data.completions.length; ++i) {
217
        var completion = data.completions[i], className = typeToIcon(completion.type);
218
        if (data.guess) className += " " + cls + "guess";
219
        completions.push({text: completion.name + after,
220
                          displayText: completion.displayName || completion.name,
221
                          className: className,
222
                          data: completion});
223
      }
224

225
      var obj = {from: from, to: to, list: completions};
226
      var tooltip = null;
227
      CodeMirror.on(obj, "close", function() { remove(tooltip); });
228
      CodeMirror.on(obj, "update", function() { remove(tooltip); });
229
      CodeMirror.on(obj, "select", function(cur, node) {
230
        remove(tooltip);
231
        var content = ts.options.completionTip ? ts.options.completionTip(cur.data) : cur.data.doc;
232
        if (content) {
233
          tooltip = makeTooltip(node.parentNode.getBoundingClientRect().right + window.pageXOffset,
234
                                node.getBoundingClientRect().top + window.pageYOffset, content, cm, cls + "hint-doc");
235
        }
236
      });
237
      c(obj);
238
    });
239
  }
240

241
  function typeToIcon(type) {
242
    var suffix;
243
    if (type == "?") suffix = "unknown";
244
    else if (type == "number" || type == "string" || type == "bool") suffix = type;
245
    else if (/^fn\(/.test(type)) suffix = "fn";
246
    else if (/^\[/.test(type)) suffix = "array";
247
    else suffix = "object";
248
    return cls + "completion " + cls + "completion-" + suffix;
249
  }
250

251
  // Type queries
252

253
  function showContextInfo(ts, cm, pos, queryName, c) {
254
    ts.request(cm, queryName, function(error, data) {
255
      if (error) return showError(ts, cm, error);
256
      if (ts.options.typeTip) {
257
        var tip = ts.options.typeTip(data);
258
      } else {
259
        var tip = elt("span", null, elt("strong", null, data.type || "not found"));
260
        if (data.doc)
261
          tip.appendChild(document.createTextNode(" — " + data.doc));
262
        if (data.url) {
263
          tip.appendChild(document.createTextNode(" "));
264
          var child = tip.appendChild(elt("a", null, "[docs]"));
265
          child.href = data.url;
266
          child.target = "_blank";
267
        }
268
      }
269
      tempTooltip(cm, tip, ts);
270
      if (c) c();
271
    }, pos);
272
  }
273

274
  // Maintaining argument hints
275

276
  function updateArgHints(ts, cm) {
277
    closeArgHints(ts);
278

279
    if (cm.somethingSelected()) return;
280
    var state = cm.getTokenAt(cm.getCursor()).state;
281
    var inner = CodeMirror.innerMode(cm.getMode(), state);
282
    if (inner.mode.name != "javascript") return;
283
    var lex = inner.state.lexical;
284
    if (lex.info != "call") return;
285

286
    var ch, argPos = lex.pos || 0, tabSize = cm.getOption("tabSize");
287
    for (var line = cm.getCursor().line, e = Math.max(0, line - 9), found = false; line >= e; --line) {
288
      var str = cm.getLine(line), extra = 0;
289
      for (var pos = 0;;) {
290
        var tab = str.indexOf("\t", pos);
291
        if (tab == -1) break;
292
        extra += tabSize - (tab + extra) % tabSize - 1;
293
        pos = tab + 1;
294
      }
295
      ch = lex.column - extra;
296
      if (str.charAt(ch) == "(") {found = true; break;}
297
    }
298
    if (!found) return;
299

300
    var start = Pos(line, ch);
301
    var cache = ts.cachedArgHints;
302
    if (cache && cache.doc == cm.getDoc() && cmpPos(start, cache.start) == 0)
303
      return showArgHints(ts, cm, argPos);
304

305
    ts.request(cm, {type: "type", preferFunction: true, end: start}, function(error, data) {
306
      if (error || !data.type || !(/^fn\(/).test(data.type)) return;
307
      ts.cachedArgHints = {
308
        start: start,
309
        type: parseFnType(data.type),
310
        name: data.exprName || data.name || "fn",
311
        guess: data.guess,
312
        doc: cm.getDoc()
313
      };
314
      showArgHints(ts, cm, argPos);
315
    });
316
  }
317

318
  function showArgHints(ts, cm, pos) {
319
    closeArgHints(ts);
320

321
    var cache = ts.cachedArgHints, tp = cache.type;
322
    var tip = elt("span", cache.guess ? cls + "fhint-guess" : null,
323
                  elt("span", cls + "fname", cache.name), "(");
324
    for (var i = 0; i < tp.args.length; ++i) {
325
      if (i) tip.appendChild(document.createTextNode(", "));
326
      var arg = tp.args[i];
327
      tip.appendChild(elt("span", cls + "farg" + (i == pos ? " " + cls + "farg-current" : ""), arg.name || "?"));
328
      if (arg.type != "?") {
329
        tip.appendChild(document.createTextNode(":\u00a0"));
330
        tip.appendChild(elt("span", cls + "type", arg.type));
331
      }
332
    }
333
    tip.appendChild(document.createTextNode(tp.rettype ? ") ->\u00a0" : ")"));
334
    if (tp.rettype) tip.appendChild(elt("span", cls + "type", tp.rettype));
335
    var place = cm.cursorCoords(null, "page");
336
    var tooltip = ts.activeArgHints = makeTooltip(place.right + 1, place.bottom, tip, cm)
337
    setTimeout(function() {
338
      tooltip.clear = onEditorActivity(cm, function() {
339
        if (ts.activeArgHints == tooltip) closeArgHints(ts) })
340
    }, 20)
341
  }
342

343
  function parseFnType(text) {
344
    var args = [], pos = 3;
345

346
    function skipMatching(upto) {
347
      var depth = 0, start = pos;
348
      for (;;) {
349
        var next = text.charAt(pos);
350
        if (upto.test(next) && !depth) return text.slice(start, pos);
351
        if (/[{\[\(]/.test(next)) ++depth;
352
        else if (/[}\]\)]/.test(next)) --depth;
353
        ++pos;
354
      }
355
    }
356

357
    // Parse arguments
358
    if (text.charAt(pos) != ")") for (;;) {
359
      var name = text.slice(pos).match(/^([^, \(\[\{]+): /);
360
      if (name) {
361
        pos += name[0].length;
362
        name = name[1];
363
      }
364
      args.push({name: name, type: skipMatching(/[\),]/)});
365
      if (text.charAt(pos) == ")") break;
366
      pos += 2;
367
    }
368

369
    var rettype = text.slice(pos).match(/^\) -> (.*)$/);
370

371
    return {args: args, rettype: rettype && rettype[1]};
372
  }
373

374
  // Moving to the definition of something
375

376
  function jumpToDef(ts, cm) {
377
    function inner(varName) {
378
      var req = {type: "definition", variable: varName || null};
379
      var doc = findDoc(ts, cm.getDoc());
380
      ts.server.request(buildRequest(ts, doc, req), function(error, data) {
381
        if (error) return showError(ts, cm, error);
382
        if (!data.file && data.url) { window.open(data.url); return; }
383

384
        if (data.file) {
385
          var localDoc = ts.docs[data.file], found;
386
          if (localDoc && (found = findContext(localDoc.doc, data))) {
387
            ts.jumpStack.push({file: doc.name,
388
                               start: cm.getCursor("from"),
389
                               end: cm.getCursor("to")});
390
            moveTo(ts, doc, localDoc, found.start, found.end);
391
            return;
392
          }
393
        }
394
        showError(ts, cm, "Could not find a definition.");
395
      });
396
    }
397

398
    if (!atInterestingExpression(cm))
399
      dialog(cm, "Jump to variable", function(name) { if (name) inner(name); });
400
    else
401
      inner();
402
  }
403

404
  function jumpBack(ts, cm) {
405
    var pos = ts.jumpStack.pop(), doc = pos && ts.docs[pos.file];
406
    if (!doc) return;
407
    moveTo(ts, findDoc(ts, cm.getDoc()), doc, pos.start, pos.end);
408
  }
409

410
  function moveTo(ts, curDoc, doc, start, end) {
411
    doc.doc.setSelection(start, end);
412
    if (curDoc != doc && ts.options.switchToDoc) {
413
      closeArgHints(ts);
414
      ts.options.switchToDoc(doc.name, doc.doc);
415
    }
416
  }
417

418
  // The {line,ch} representation of positions makes this rather awkward.
419
  function findContext(doc, data) {
420
    var before = data.context.slice(0, data.contextOffset).split("\n");
421
    var startLine = data.start.line - (before.length - 1);
422
    var start = Pos(startLine, (before.length == 1 ? data.start.ch : doc.getLine(startLine).length) - before[0].length);
423

424
    var text = doc.getLine(startLine).slice(start.ch);
425
    for (var cur = startLine + 1; cur < doc.lineCount() && text.length < data.context.length; ++cur)
426
      text += "\n" + doc.getLine(cur);
427
    if (text.slice(0, data.context.length) == data.context) return data;
428

429
    var cursor = doc.getSearchCursor(data.context, 0, false);
430
    var nearest, nearestDist = Infinity;
431
    while (cursor.findNext()) {
432
      var from = cursor.from(), dist = Math.abs(from.line - start.line) * 10000;
433
      if (!dist) dist = Math.abs(from.ch - start.ch);
434
      if (dist < nearestDist) { nearest = from; nearestDist = dist; }
435
    }
436
    if (!nearest) return null;
437

438
    if (before.length == 1)
439
      nearest.ch += before[0].length;
440
    else
441
      nearest = Pos(nearest.line + (before.length - 1), before[before.length - 1].length);
442
    if (data.start.line == data.end.line)
443
      var end = Pos(nearest.line, nearest.ch + (data.end.ch - data.start.ch));
444
    else
445
      var end = Pos(nearest.line + (data.end.line - data.start.line), data.end.ch);
446
    return {start: nearest, end: end};
447
  }
448

449
  function atInterestingExpression(cm) {
450
    var pos = cm.getCursor("end"), tok = cm.getTokenAt(pos);
451
    if (tok.start < pos.ch && tok.type == "comment") return false;
452
    return /[\w)\]]/.test(cm.getLine(pos.line).slice(Math.max(pos.ch - 1, 0), pos.ch + 1));
453
  }
454

455
  // Variable renaming
456

457
  function rename(ts, cm) {
458
    var token = cm.getTokenAt(cm.getCursor());
459
    if (!/\w/.test(token.string)) return showError(ts, cm, "Not at a variable");
460
    dialog(cm, "New name for " + token.string, function(newName) {
461
      ts.request(cm, {type: "rename", newName: newName, fullDocs: true}, function(error, data) {
462
        if (error) return showError(ts, cm, error);
463
        applyChanges(ts, data.changes);
464
      });
465
    });
466
  }
467

468
  function selectName(ts, cm) {
469
    var name = findDoc(ts, cm.doc).name;
470
    ts.request(cm, {type: "refs"}, function(error, data) {
471
      if (error) return showError(ts, cm, error);
472
      var ranges = [], cur = 0;
473
      var curPos = cm.getCursor();
474
      for (var i = 0; i < data.refs.length; i++) {
475
        var ref = data.refs[i];
476
        if (ref.file == name) {
477
          ranges.push({anchor: ref.start, head: ref.end});
478
          if (cmpPos(curPos, ref.start) >= 0 && cmpPos(curPos, ref.end) <= 0)
479
            cur = ranges.length - 1;
480
        }
481
      }
482
      cm.setSelections(ranges, cur);
483
    });
484
  }
485

486
  var nextChangeOrig = 0;
487
  function applyChanges(ts, changes) {
488
    var perFile = Object.create(null);
489
    for (var i = 0; i < changes.length; ++i) {
490
      var ch = changes[i];
491
      (perFile[ch.file] || (perFile[ch.file] = [])).push(ch);
492
    }
493
    for (var file in perFile) {
494
      var known = ts.docs[file], chs = perFile[file];;
495
      if (!known) continue;
496
      chs.sort(function(a, b) { return cmpPos(b.start, a.start); });
497
      var origin = "*rename" + (++nextChangeOrig);
498
      for (var i = 0; i < chs.length; ++i) {
499
        var ch = chs[i];
500
        known.doc.replaceRange(ch.text, ch.start, ch.end, origin);
501
      }
502
    }
503
  }
504

505
  // Generic request-building helper
506

507
  function buildRequest(ts, doc, query, pos) {
508
    var files = [], offsetLines = 0, allowFragments = !query.fullDocs;
509
    if (!allowFragments) delete query.fullDocs;
510
    if (typeof query == "string") query = {type: query};
511
    query.lineCharPositions = true;
512
    if (query.end == null) {
513
      query.end = pos || doc.doc.getCursor("end");
514
      if (doc.doc.somethingSelected())
515
        query.start = doc.doc.getCursor("start");
516
    }
517
    var startPos = query.start || query.end;
518

519
    if (doc.changed) {
520
      if (doc.doc.lineCount() > bigDoc && allowFragments !== false &&
521
          doc.changed.to - doc.changed.from < 100 &&
522
          doc.changed.from <= startPos.line && doc.changed.to > query.end.line) {
523
        files.push(getFragmentAround(doc, startPos, query.end));
524
        query.file = "#0";
525
        var offsetLines = files[0].offsetLines;
526
        if (query.start != null) query.start = Pos(query.start.line - -offsetLines, query.start.ch);
527
        query.end = Pos(query.end.line - offsetLines, query.end.ch);
528
      } else {
529
        files.push({type: "full",
530
                    name: doc.name,
531
                    text: docValue(ts, doc)});
532
        query.file = doc.name;
533
        doc.changed = null;
534
      }
535
    } else {
536
      query.file = doc.name;
537
    }
538
    for (var name in ts.docs) {
539
      var cur = ts.docs[name];
540
      if (cur.changed && cur != doc) {
541
        files.push({type: "full", name: cur.name, text: docValue(ts, cur)});
542
        cur.changed = null;
543
      }
544
    }
545

546
    return {query: query, files: files};
547
  }
548

549
  function getFragmentAround(data, start, end) {
550
    var doc = data.doc;
551
    var minIndent = null, minLine = null, endLine, tabSize = 4;
552
    for (var p = start.line - 1, min = Math.max(0, p - 50); p >= min; --p) {
553
      var line = doc.getLine(p), fn = line.search(/\bfunction\b/);
554
      if (fn < 0) continue;
555
      var indent = CodeMirror.countColumn(line, null, tabSize);
556
      if (minIndent != null && minIndent <= indent) continue;
557
      minIndent = indent;
558
      minLine = p;
559
    }
560
    if (minLine == null) minLine = min;
561
    var max = Math.min(doc.lastLine(), end.line + 20);
562
    if (minIndent == null || minIndent == CodeMirror.countColumn(doc.getLine(start.line), null, tabSize))
563
      endLine = max;
564
    else for (endLine = end.line + 1; endLine < max; ++endLine) {
565
      var indent = CodeMirror.countColumn(doc.getLine(endLine), null, tabSize);
566
      if (indent <= minIndent) break;
567
    }
568
    var from = Pos(minLine, 0);
569

570
    return {type: "part",
571
            name: data.name,
572
            offsetLines: from.line,
573
            text: doc.getRange(from, Pos(endLine, end.line == endLine ? null : 0))};
574
  }
575

576
  // Generic utilities
577

578
  var cmpPos = CodeMirror.cmpPos;
579

580
  function elt(tagname, cls /*, ... elts*/) {
581
    var e = document.createElement(tagname);
582
    if (cls) e.className = cls;
583
    for (var i = 2; i < arguments.length; ++i) {
584
      var elt = arguments[i];
585
      if (typeof elt == "string") elt = document.createTextNode(elt);
586
      e.appendChild(elt);
587
    }
588
    return e;
589
  }
590

591
  function dialog(cm, text, f) {
592
    if (cm.openDialog)
593
      cm.openDialog(text + ": <input type=text>", f);
594
    else
595
      f(prompt(text, ""));
596
  }
597

598
  // Tooltips
599

600
  function tempTooltip(cm, content, ts) {
601
    if (cm.state.ternTooltip) remove(cm.state.ternTooltip);
602
    var where = cm.cursorCoords();
603
    var tip = cm.state.ternTooltip = makeTooltip(where.right + 1, where.bottom, content, cm);
604
    function maybeClear() {
605
      old = true;
606
      if (!mouseOnTip) clear();
607
    }
608
    function clear() {
609
      cm.state.ternTooltip = null;
610
      if (tip.parentNode) fadeOut(tip)
611
      clearActivity()
612
    }
613
    var mouseOnTip = false, old = false;
614
    CodeMirror.on(tip, "mousemove", function() { mouseOnTip = true; });
615
    CodeMirror.on(tip, "mouseout", function(e) {
616
      var related = e.relatedTarget || e.toElement
617
      if (!related || !CodeMirror.contains(tip, related)) {
618
        if (old) clear();
619
        else mouseOnTip = false;
620
      }
621
    });
622
    setTimeout(maybeClear, ts.options.hintDelay ? ts.options.hintDelay : 1700);
623
    var clearActivity = onEditorActivity(cm, clear)
624
  }
625

626
  function onEditorActivity(cm, f) {
627
    cm.on("cursorActivity", f)
628
    cm.on("blur", f)
629
    cm.on("scroll", f)
630
    cm.on("setDoc", f)
631
    return function() {
632
      cm.off("cursorActivity", f)
633
      cm.off("blur", f)
634
      cm.off("scroll", f)
635
      cm.off("setDoc", f)
636
    }
637
  }
638

639
  function makeTooltip(x, y, content, cm, className) {
640
    var node = elt("div", cls + "tooltip" + " " + (className || ""), content);
641
    node.style.left = x + "px";
642
    node.style.top = y + "px";
643
    var container = ((cm.options || {}).hintOptions || {}).container || document.body;
644
    container.appendChild(node);
645

646
    var pos = cm.cursorCoords();
647
    var winW = window.innerWidth;
648
    var winH = window.innerHeight;
649
    var box = node.getBoundingClientRect();
650
    var hints = document.querySelector(".CodeMirror-hints");
651
    var overlapY = box.bottom - winH;
652
    var overlapX = box.right - winW;
653

654
    if (hints && overlapX > 0) {
655
      node.style.left = 0;
656
      var box = node.getBoundingClientRect();
657
      node.style.left = (x = x - hints.offsetWidth - box.width) + "px";
658
      overlapX = box.right - winW;
659
    }
660
    if (overlapY > 0) {
661
      var height = box.bottom - box.top, curTop = pos.top - (pos.bottom - box.top);
662
      if (curTop - height > 0) { // Fits above cursor
663
        node.style.top = (pos.top - height) + "px";
664
      } else if (height > winH) {
665
        node.style.height = (winH - 5) + "px";
666
        node.style.top = (pos.bottom - box.top) + "px";
667
      }
668
    }
669
    if (overlapX > 0) {
670
      if (box.right - box.left > winW) {
671
        node.style.width = (winW - 5) + "px";
672
        overlapX -= (box.right - box.left) - winW;
673
      }
674
      node.style.left = (x - overlapX) + "px";
675
    }
676

677
    return node;
678
  }
679

680
  function remove(node) {
681
    var p = node && node.parentNode;
682
    if (p) p.removeChild(node);
683
  }
684

685
  function fadeOut(tooltip) {
686
    tooltip.style.opacity = "0";
687
    setTimeout(function() { remove(tooltip); }, 1100);
688
  }
689

690
  function showError(ts, cm, msg) {
691
    if (ts.options.showError)
692
      ts.options.showError(cm, msg);
693
    else
694
      tempTooltip(cm, String(msg), ts);
695
  }
696

697
  function closeArgHints(ts) {
698
    if (ts.activeArgHints) {
699
      if (ts.activeArgHints.clear) ts.activeArgHints.clear()
700
      remove(ts.activeArgHints)
701
      ts.activeArgHints = null
702
    }
703
  }
704

705
  function docValue(ts, doc) {
706
    var val = doc.doc.getValue();
707
    if (ts.options.fileFilter) val = ts.options.fileFilter(val, doc.name, doc.doc);
708
    return val;
709
  }
710

711
  // Worker wrapper
712

713
  function WorkerServer(ts) {
714
    var worker = ts.worker = new Worker(ts.options.workerScript);
715
    worker.postMessage({type: "init",
716
                        defs: ts.options.defs,
717
                        plugins: ts.options.plugins,
718
                        scripts: ts.options.workerDeps});
719
    var msgId = 0, pending = {};
720

721
    function send(data, c) {
722
      if (c) {
723
        data.id = ++msgId;
724
        pending[msgId] = c;
725
      }
726
      worker.postMessage(data);
727
    }
728
    worker.onmessage = function(e) {
729
      var data = e.data;
730
      if (data.type == "getFile") {
731
        getFile(ts, data.name, function(err, text) {
732
          send({type: "getFile", err: String(err), text: text, id: data.id});
733
        });
734
      } else if (data.type == "debug") {
735
        window.console.log(data.message);
736
      } else if (data.id && pending[data.id]) {
737
        pending[data.id](data.err, data.body);
738
        delete pending[data.id];
739
      }
740
    };
741
    worker.onerror = function(e) {
742
      for (var id in pending) pending[id](e);
743
      pending = {};
744
    };
745

746
    this.addFile = function(name, text) { send({type: "add", name: name, text: text}); };
747
    this.delFile = function(name) { send({type: "del", name: name}); };
748
    this.request = function(body, c) { send({type: "req", body: body}, c); };
749
  }
750
});
751