GPQAPP

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

4
(function(mod) {
5
  if (typeof exports == "object" && typeof module == "object") // CommonJS
6
    mod(require("../../lib/codemirror"));
7
  else if (typeof define == "function" && define.amd) // AMD
8
    define(["../../lib/codemirror"], mod);
9
  else // Plain browser env
10
    mod(CodeMirror);
11
})(function(CodeMirror) {
12
  "use strict";
13
  var GUTTER_ID = "CodeMirror-lint-markers";
14
  var LINT_LINE_ID = "CodeMirror-lint-line-";
15

16
  function showTooltip(cm, e, content) {
17
    var tt = document.createElement("div");
18
    tt.className = "CodeMirror-lint-tooltip cm-s-" + cm.options.theme;
19
    tt.appendChild(content.cloneNode(true));
20
    if (cm.state.lint.options.selfContain)
21
      cm.getWrapperElement().appendChild(tt);
22
    else
23
      document.body.appendChild(tt);
24

25
    function position(e) {
26
      if (!tt.parentNode) return CodeMirror.off(document, "mousemove", position);
27
      tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px";
28
      tt.style.left = (e.clientX + 5) + "px";
29
    }
30
    CodeMirror.on(document, "mousemove", position);
31
    position(e);
32
    if (tt.style.opacity != null) tt.style.opacity = 1;
33
    return tt;
34
  }
35
  function rm(elt) {
36
    if (elt.parentNode) elt.parentNode.removeChild(elt);
37
  }
38
  function hideTooltip(tt) {
39
    if (!tt.parentNode) return;
40
    if (tt.style.opacity == null) rm(tt);
41
    tt.style.opacity = 0;
42
    setTimeout(function() { rm(tt); }, 600);
43
  }
44

45
  function showTooltipFor(cm, e, content, node) {
46
    var tooltip = showTooltip(cm, e, content);
47
    function hide() {
48
      CodeMirror.off(node, "mouseout", hide);
49
      if (tooltip) { hideTooltip(tooltip); tooltip = null; }
50
    }
51
    var poll = setInterval(function() {
52
      if (tooltip) for (var n = node;; n = n.parentNode) {
53
        if (n && n.nodeType == 11) n = n.host;
54
        if (n == document.body) return;
55
        if (!n) { hide(); break; }
56
      }
57
      if (!tooltip) return clearInterval(poll);
58
    }, 400);
59
    CodeMirror.on(node, "mouseout", hide);
60
  }
61

62
  function LintState(cm, conf, hasGutter) {
63
    this.marked = [];
64
    if (conf instanceof Function) conf = {getAnnotations: conf};
65
    if (!conf || conf === true) conf = {};
66
    this.options = {};
67
    this.linterOptions = conf.options || {};
68
    for (var prop in defaults) this.options[prop] = defaults[prop];
69
    for (var prop in conf) {
70
      if (defaults.hasOwnProperty(prop)) {
71
        if (conf[prop] != null) this.options[prop] = conf[prop];
72
      } else if (!conf.options) {
73
        this.linterOptions[prop] = conf[prop];
74
      }
75
    }
76
    this.timeout = null;
77
    this.hasGutter = hasGutter;
78
    this.onMouseOver = function(e) { onMouseOver(cm, e); };
79
    this.waitingFor = 0
80
  }
81

82
  var defaults = {
83
    highlightLines: false,
84
    tooltips: true,
85
    delay: 500,
86
    lintOnChange: true,
87
    getAnnotations: null,
88
    async: false,
89
    selfContain: null,
90
    formatAnnotation: null,
91
    onUpdateLinting: null
92
  }
93

94
  function clearMarks(cm) {
95
    var state = cm.state.lint;
96
    if (state.hasGutter) cm.clearGutter(GUTTER_ID);
97
    if (state.options.highlightLines) clearErrorLines(cm);
98
    for (var i = 0; i < state.marked.length; ++i)
99
      state.marked[i].clear();
100
    state.marked.length = 0;
101
  }
102

103
  function clearErrorLines(cm) {
104
    cm.eachLine(function(line) {
105
      var has = line.wrapClass && /\bCodeMirror-lint-line-\w+\b/.exec(line.wrapClass);
106
      if (has) cm.removeLineClass(line, "wrap", has[0]);
107
    })
108
  }
109

110
  function makeMarker(cm, labels, severity, multiple, tooltips) {
111
    var marker = document.createElement("div"), inner = marker;
112
    marker.className = "CodeMirror-lint-marker CodeMirror-lint-marker-" + severity;
113
    if (multiple) {
114
      inner = marker.appendChild(document.createElement("div"));
115
      inner.className = "CodeMirror-lint-marker CodeMirror-lint-marker-multiple";
116
    }
117

118
    if (tooltips != false) CodeMirror.on(inner, "mouseover", function(e) {
119
      showTooltipFor(cm, e, labels, inner);
120
    });
121

122
    return marker;
123
  }
124

125
  function getMaxSeverity(a, b) {
126
    if (a == "error") return a;
127
    else return b;
128
  }
129

130
  function groupByLine(annotations) {
131
    var lines = [];
132
    for (var i = 0; i < annotations.length; ++i) {
133
      var ann = annotations[i], line = ann.from.line;
134
      (lines[line] || (lines[line] = [])).push(ann);
135
    }
136
    return lines;
137
  }
138

139
  function annotationTooltip(ann) {
140
    var severity = ann.severity;
141
    if (!severity) severity = "error";
142
    var tip = document.createElement("div");
143
    tip.className = "CodeMirror-lint-message CodeMirror-lint-message-" + severity;
144
    if (typeof ann.messageHTML != 'undefined') {
145
      tip.innerHTML = ann.messageHTML;
146
    } else {
147
      tip.appendChild(document.createTextNode(ann.message));
148
    }
149
    return tip;
150
  }
151

152
  function lintAsync(cm, getAnnotations) {
153
    var state = cm.state.lint
154
    var id = ++state.waitingFor
155
    function abort() {
156
      id = -1
157
      cm.off("change", abort)
158
    }
159
    cm.on("change", abort)
160
    getAnnotations(cm.getValue(), function(annotations, arg2) {
161
      cm.off("change", abort)
162
      if (state.waitingFor != id) return
163
      if (arg2 && annotations instanceof CodeMirror) annotations = arg2
164
      cm.operation(function() {updateLinting(cm, annotations)})
165
    }, state.linterOptions, cm);
166
  }
167

168
  function startLinting(cm) {
169
    var state = cm.state.lint;
170
    if (!state) return;
171
    var options = state.options;
172
    /*
173
     * Passing rules in `options` property prevents JSHint (and other linters) from complaining
174
     * about unrecognized rules like `onUpdateLinting`, `delay`, `lintOnChange`, etc.
175
     */
176
    var getAnnotations = options.getAnnotations || cm.getHelper(CodeMirror.Pos(0, 0), "lint");
177
    if (!getAnnotations) return;
178
    if (options.async || getAnnotations.async) {
179
      lintAsync(cm, getAnnotations)
180
    } else {
181
      var annotations = getAnnotations(cm.getValue(), state.linterOptions, cm);
182
      if (!annotations) return;
183
      if (annotations.then) annotations.then(function(issues) {
184
        cm.operation(function() {updateLinting(cm, issues)})
185
      });
186
      else cm.operation(function() {updateLinting(cm, annotations)})
187
    }
188
  }
189

190
  function updateLinting(cm, annotationsNotSorted) {
191
    var state = cm.state.lint;
192
    if (!state) return;
193
    var options = state.options;
194
    clearMarks(cm);
195

196
    var annotations = groupByLine(annotationsNotSorted);
197

198
    for (var line = 0; line < annotations.length; ++line) {
199
      var anns = annotations[line];
200
      if (!anns) continue;
201

202
      // filter out duplicate messages
203
      var message = [];
204
      anns = anns.filter(function(item) { return message.indexOf(item.message) > -1 ? false : message.push(item.message) });
205

206
      var maxSeverity = null;
207
      var tipLabel = state.hasGutter && document.createDocumentFragment();
208

209
      for (var i = 0; i < anns.length; ++i) {
210
        var ann = anns[i];
211
        var severity = ann.severity;
212
        if (!severity) severity = "error";
213
        maxSeverity = getMaxSeverity(maxSeverity, severity);
214

215
        if (options.formatAnnotation) ann = options.formatAnnotation(ann);
216
        if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann));
217

218
        if (ann.to) state.marked.push(cm.markText(ann.from, ann.to, {
219
          className: "CodeMirror-lint-mark CodeMirror-lint-mark-" + severity,
220
          __annotation: ann
221
        }));
222
      }
223
      // use original annotations[line] to show multiple messages
224
      if (state.hasGutter)
225
        cm.setGutterMarker(line, GUTTER_ID, makeMarker(cm, tipLabel, maxSeverity, annotations[line].length > 1,
226
                                                       options.tooltips));
227

228
      if (options.highlightLines)
229
        cm.addLineClass(line, "wrap", LINT_LINE_ID + maxSeverity);
230
    }
231
    if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm);
232
  }
233

234
  function onChange(cm) {
235
    var state = cm.state.lint;
236
    if (!state) return;
237
    clearTimeout(state.timeout);
238
    state.timeout = setTimeout(function(){startLinting(cm);}, state.options.delay);
239
  }
240

241
  function popupTooltips(cm, annotations, e) {
242
    var target = e.target || e.srcElement;
243
    var tooltip = document.createDocumentFragment();
244
    for (var i = 0; i < annotations.length; i++) {
245
      var ann = annotations[i];
246
      tooltip.appendChild(annotationTooltip(ann));
247
    }
248
    showTooltipFor(cm, e, tooltip, target);
249
  }
250

251
  function onMouseOver(cm, e) {
252
    var target = e.target || e.srcElement;
253
    if (!/\bCodeMirror-lint-mark-/.test(target.className)) return;
254
    var box = target.getBoundingClientRect(), x = (box.left + box.right) / 2, y = (box.top + box.bottom) / 2;
255
    var spans = cm.findMarksAt(cm.coordsChar({left: x, top: y}, "client"));
256

257
    var annotations = [];
258
    for (var i = 0; i < spans.length; ++i) {
259
      var ann = spans[i].__annotation;
260
      if (ann) annotations.push(ann);
261
    }
262
    if (annotations.length) popupTooltips(cm, annotations, e);
263
  }
264

265
  CodeMirror.defineOption("lint", false, function(cm, val, old) {
266
    if (old && old != CodeMirror.Init) {
267
      clearMarks(cm);
268
      if (cm.state.lint.options.lintOnChange !== false)
269
        cm.off("change", onChange);
270
      CodeMirror.off(cm.getWrapperElement(), "mouseover", cm.state.lint.onMouseOver);
271
      clearTimeout(cm.state.lint.timeout);
272
      delete cm.state.lint;
273
    }
274

275
    if (val) {
276
      var gutters = cm.getOption("gutters"), hasLintGutter = false;
277
      for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true;
278
      var state = cm.state.lint = new LintState(cm, val, hasLintGutter);
279
      if (state.options.lintOnChange)
280
        cm.on("change", onChange);
281
      if (state.options.tooltips != false && state.options.tooltips != "gutter")
282
        CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver);
283

284
      startLinting(cm);
285
    }
286
  });
287

288
  CodeMirror.defineExtension("performLint", function() {
289
    startLinting(this);
290
  });
291
});
292