[Summary view] [Print] [Text view]

   1  // CodeMirror, copyright (c) by Marijn Haverbeke and others
   2  // Distributed under an MIT license: https://codemirror.net/5/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  });