Upgrade CodeMirror to 5.10.1 and now support fullscreen, jump-to-line in editor

2 files changed, 510 insertions, 0 deletions

diff --git a/public/vendor/codemirror/mode/crystal/crystal.js b/public/vendor/codemirror/mode/crystal/crystal.js
new file mode 100644
index 00000000..2e74bee4
--- /dev/null
+++ b/public/vendor/codemirror/mode/crystal/crystal.js
@@ -0,0 +1,391 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineMode("crystal", function(config) {
+    function wordRegExp(words, end) {
+      return new RegExp((end ? "" : "^") + "(?:" + words.join("|") + ")" + (end ? "$" : "\\b"));
+    }
+
+    function chain(tokenize, stream, state) {
+      state.tokenize.push(tokenize);
+      return tokenize(stream, state);
+    }
+
+    var operators = /^(?:[-+/%|&^]|\*\*?|[<>]{2})/;
+    var conditionalOperators = /^(?:[=!]~|===|<=>|[<>=!]=?|[|&]{2}|~)/;
+    var indexingOperators = /^(?:\[\][?=]?)/;
+    var anotherOperators = /^(?:\.(?:\.{2})?|->|[?:])/;
+    var idents = /^[a-z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
+    var types = /^[A-Z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
+    var keywords = wordRegExp([
+      "abstract", "alias", "as", "asm", "begin", "break", "case", "class", "def", "do",
+      "else", "elsif", "end", "ensure", "enum", "extend", "for", "fun", "if", "ifdef",
+      "include", "instance_sizeof", "lib", "macro", "module", "next", "of", "out", "pointerof",
+      "private", "protected", "rescue", "return", "require", "sizeof", "struct",
+      "super", "then", "type", "typeof", "union", "unless", "until", "when", "while", "with",
+      "yield", "__DIR__", "__FILE__", "__LINE__"
+    ]);
+    var atomWords = wordRegExp(["true", "false", "nil", "self"]);
+    var indentKeywordsArray = [
+      "def", "fun", "macro",
+      "class", "module", "struct", "lib", "enum", "union",
+      "if", "unless", "case", "while", "until", "begin", "then",
+      "do",
+      "for", "ifdef"
+    ];
+    var indentKeywords = wordRegExp(indentKeywordsArray);
+    var dedentKeywordsArray = [
+      "end",
+      "else", "elsif",
+      "rescue", "ensure"
+    ];
+    var dedentKeywords = wordRegExp(dedentKeywordsArray);
+    var dedentPunctualsArray = ["\\)", "\\}", "\\]"];
+    var dedentPunctuals = new RegExp("^(?:" + dedentPunctualsArray.join("|") + ")$");
+    var nextTokenizer = {
+      "def": tokenFollowIdent, "fun": tokenFollowIdent, "macro": tokenMacroDef,
+      "class": tokenFollowType, "module": tokenFollowType, "struct": tokenFollowType,
+      "lib": tokenFollowType, "enum": tokenFollowType, "union": tokenFollowType
+    };
+    var matching = {"[": "]", "{": "}", "(": ")", "<": ">"};
+
+    function tokenBase(stream, state) {
+      if (stream.eatSpace()) {
+        return null;
+      }
+
+      // Macros
+      if (state.lastToken != "\\" && stream.match("{%", false)) {
+        return chain(tokenMacro("%", "%"), stream, state);
+      }
+
+      if (state.lastToken != "\\" && stream.match("{{", false)) {
+        return chain(tokenMacro("{", "}"), stream, state);
+      }
+
+      // Comments
+      if (stream.peek() == "#") {
+        stream.skipToEnd();
+        return "comment";
+      }
+
+      // Variables and keywords
+      var matched;
+      if (stream.match(idents)) {
+        stream.eat(/[?!]/);
+
+        matched = stream.current();
+        if (stream.eat(":")) {
+          return "atom";
+        } else if (state.lastToken == ".") {
+          return "property";
+        } else if (keywords.test(matched)) {
+          if (state.lastToken != "abstract" && indentKeywords.test(matched)) {
+            if (!(matched == "fun" && state.blocks.indexOf("lib") >= 0)) {
+              state.blocks.push(matched);
+              state.currentIndent += 1;
+            }
+          } else if (dedentKeywords.test(matched)) {
+            state.blocks.pop();
+            state.currentIndent -= 1;
+          }
+
+          if (nextTokenizer.hasOwnProperty(matched)) {
+            state.tokenize.push(nextTokenizer[matched]);
+          }
+
+          return "keyword";
+        } else if (atomWords.test(matched)) {
+          return "atom";
+        }
+
+        return "variable";
+      }
+
+      // Class variables and instance variables
+      // or attributes
+      if (stream.eat("@")) {
+        if (stream.peek() == "[") {
+          return chain(tokenNest("[", "]", "meta"), stream, state);
+        }
+
+        stream.eat("@");
+        stream.match(idents) || stream.match(types);
+        return "variable-2";
+      }
+
+      // Global variables
+      if (stream.eat("$")) {
+        stream.eat(/[0-9]+|\?/) || stream.match(idents) || stream.match(types);
+        return "variable-3";
+      }
+
+      // Constants and types
+      if (stream.match(types)) {
+        return "tag";
+      }
+
+      // Symbols or ':' operator
+      if (stream.eat(":")) {
+        if (stream.eat("\"")) {
+          return chain(tokenQuote("\"", "atom", false), stream, state);
+        } else if (stream.match(idents) || stream.match(types) ||
+                   stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators)) {
+          return "atom";
+        }
+        stream.eat(":");
+        return "operator";
+      }
+
+      // Strings
+      if (stream.eat("\"")) {
+        return chain(tokenQuote("\"", "string", true), stream, state);
+      }
+
+      // Strings or regexps or macro variables or '%' operator
+      if (stream.peek() == "%") {
+        var style = "string";
+        var embed = true;
+        var delim;
+
+        if (stream.match("%r")) {
+          // Regexps
+          style = "string-2";
+          delim = stream.next();
+        } else if (stream.match("%w")) {
+          embed = false;
+          delim = stream.next();
+        } else {
+          if(delim = stream.match(/^%([^\w\s=])/)) {
+            delim = delim[1];
+          } else if (stream.match(/^%[a-zA-Z0-9_\u009F-\uFFFF]*/)) {
+            // Macro variables
+            return "meta";
+          } else {
+            // '%' operator
+            return "operator";
+          }
+        }
+
+        if (matching.hasOwnProperty(delim)) {
+          delim = matching[delim];
+        }
+        return chain(tokenQuote(delim, style, embed), stream, state);
+      }
+
+      // Characters
+      if (stream.eat("'")) {
+        stream.match(/^(?:[^']|\\(?:[befnrtv0'"]|[0-7]{3}|u(?:[0-9a-fA-F]{4}|\{[0-9a-fA-F]{1,6}\})))/);
+        stream.eat("'");
+        return "atom";
+      }
+
+      // Numbers
+      if (stream.eat("0")) {
+        if (stream.eat("x")) {
+          stream.match(/^[0-9a-fA-F]+/);
+        } else if (stream.eat("o")) {
+          stream.match(/^[0-7]+/);
+        } else if (stream.eat("b")) {
+          stream.match(/^[01]+/);
+        }
+        return "number";
+      }
+
+      if (stream.eat(/\d/)) {
+        stream.match(/^\d*(?:\.\d+)?(?:[eE][+-]?\d+)?/);
+        return "number";
+      }
+
+      // Operators
+      if (stream.match(operators)) {
+        stream.eat("="); // Operators can follow assigin symbol.
+        return "operator";
+      }
+
+      if (stream.match(conditionalOperators) || stream.match(anotherOperators)) {
+        return "operator";
+      }
+
+      // Parens and braces
+      if (matched = stream.match(/[({[]/, false)) {
+        matched = matched[0];
+        return chain(tokenNest(matched, matching[matched], null), stream, state);
+      }
+
+      // Escapes
+      if (stream.eat("\\")) {
+        stream.next();
+        return "meta";
+      }
+
+      stream.next();
+      return null;
+    }
+
+    function tokenNest(begin, end, style, started) {
+      return function (stream, state) {
+        if (!started && stream.match(begin)) {
+          state.tokenize[state.tokenize.length - 1] = tokenNest(begin, end, style, true);
+          state.currentIndent += 1;
+          return style;
+        }
+
+        var nextStyle = tokenBase(stream, state);
+        if (stream.current() === end) {
+          state.tokenize.pop();
+          state.currentIndent -= 1;
+          nextStyle = style;
+        }
+
+        return nextStyle;
+      };
+    }
+
+    function tokenMacro(begin, end, started) {
+      return function (stream, state) {
+        if (!started && stream.match("{" + begin)) {
+          state.currentIndent += 1;
+          state.tokenize[state.tokenize.length - 1] = tokenMacro(begin, end, true);
+          return "meta";
+        }
+
+        if (stream.match(end + "}")) {
+          state.currentIndent -= 1;
+          state.tokenize.pop();
+          return "meta";
+        }
+
+        return tokenBase(stream, state);
+      };
+    }
+
+    function tokenMacroDef(stream, state) {
+      if (stream.eatSpace()) {
+        return null;
+      }
+
+      var matched;
+      if (matched = stream.match(idents)) {
+        if (matched == "def") {
+          return "keyword";
+        }
+        stream.eat(/[?!]/);
+      }
+
+      state.tokenize.pop();
+      return "def";
+    }
+
+    function tokenFollowIdent(stream, state) {
+      if (stream.eatSpace()) {
+        return null;
+      }
+
+      if (stream.match(idents)) {
+        stream.eat(/[!?]/);
+      } else {
+        stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators);
+      }
+      state.tokenize.pop();
+      return "def";
+    }
+
+    function tokenFollowType(stream, state) {
+      if (stream.eatSpace()) {
+        return null;
+      }
+
+      stream.match(types);
+      state.tokenize.pop();
+      return "def";
+    }
+
+    function tokenQuote(end, style, embed) {
+      return function (stream, state) {
+        var escaped = false;
+
+        while (stream.peek()) {
+          if (!escaped) {
+            if (stream.match("{%", false)) {
+              state.tokenize.push(tokenMacro("%", "%"));
+              return style;
+            }
+
+            if (stream.match("{{", false)) {
+              state.tokenize.push(tokenMacro("{", "}"));
+              return style;
+            }
+
+            if (embed && stream.match("#{", false)) {
+              state.tokenize.push(tokenNest("#{", "}", "meta"));
+              return style;
+            }
+
+            var ch = stream.next();
+
+            if (ch == end) {
+              state.tokenize.pop();
+              return style;
+            }
+
+            escaped = ch == "\\";
+          } else {
+            stream.next();
+            escaped = false;
+          }
+        }
+
+        return style;
+      };
+    }
+
+    return {
+      startState: function () {
+        return {
+          tokenize: [tokenBase],
+          currentIndent: 0,
+          lastToken: null,
+          blocks: []
+        };
+      },
+
+      token: function (stream, state) {
+        var style = state.tokenize[state.tokenize.length - 1](stream, state);
+        var token = stream.current();
+
+        if (style && style != "comment") {
+          state.lastToken = token;
+        }
+
+        return style;
+      },
+
+      indent: function (state, textAfter) {
+        textAfter = textAfter.replace(/^\s*(?:\{%)?\s*|\s*(?:%\})?\s*$/g, "");
+
+        if (dedentKeywords.test(textAfter) || dedentPunctuals.test(textAfter)) {
+          return config.indentUnit * (state.currentIndent - 1);
+        }
+
+        return config.indentUnit * state.currentIndent;
+      },
+
+      fold: "indent",
+      electricInput: wordRegExp(dedentPunctualsArray.concat(dedentKeywordsArray), true),
+      lineComment: '#'
+    };
+  });
+
+  CodeMirror.defineMIME("text/x-crystal", "crystal");
+});
diff --git a/public/vendor/codemirror/mode/crystal/index.html b/public/vendor/codemirror/mode/crystal/index.html
new file mode 100644
index 00000000..ec03e250
--- /dev/null
+++ b/public/vendor/codemirror/mode/crystal/index.html
@@ -0,0 +1,119 @@
+<!doctype html>
+
+<title>CodeMirror: Crystal mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="../../addon/edit/matchbrackets.js"></script>
+<script src="crystal.js"></script>
+<style>
+  .CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}
+  .cm-s-default span.cm-arrow { color: red; }
+</style>
+
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Crystal</a>
+  </ul>
+</div>
+
+<article>
+<h2>Crystal mode</h2>
+<form><textarea id="code" name="code">
+# Features of Crystal
+# - Ruby-inspired syntax.
+# - Statically type-checked but without having to specify the type of variables or method arguments.
+# - Be able to call C code by writing bindings to it in Crystal.
+# - Have compile-time evaluation and generation of code, to avoid boilerplate code.
+# - Compile to efficient native code.
+
+# A very basic HTTP server
+require "http/server"
+
+server = HTTP::Server.new(8080) do |request|
+  HTTP::Response.ok "text/plain", "Hello world, got #{request.path}!"
+end
+
+puts "Listening on http://0.0.0.0:8080"
+server.listen
+
+module Foo
+  def initialize(@foo); end
+
+  abstract def abstract_method : String
+
+  @[AlwaysInline]
+  def with_foofoo
+    with Foo.new(self) yield
+  end
+
+  struct Foo
+    def initialize(@foo); end
+
+    def hello_world
+      @foo.abstract_method
+    end
+  end
+end
+
+class Bar
+  include Foo
+
+  @@foobar = 12345
+
+  def initialize(@bar)
+    super(@bar.not_nil! + 100)
+  end
+
+  macro alias_method(name, method)
+    def {{ name }}(*args)
+      {{ method }}(*args)
+    end
+  end
+
+  def a_method
+    "Hello, World"
+  end
+
+  alias_method abstract_method, a_method
+
+  macro def show_instance_vars : Nil
+    {% for var in @type.instance_vars %}
+      puts "@{{ var }} = #{ @{{ var }} }"
+    {% end %}
+    nil
+  end
+end
+
+class Baz &lt; Bar; end
+
+lib LibC
+  fun c_puts = "puts"(str : Char*) : Int
+end
+
+$baz = Baz.new(100)
+$baz.show_instance_vars
+$baz.with_foofoo do
+  LibC.c_puts hello_world
+end
+</textarea></form>
+<script>
+  var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+    mode: "text/x-crystal",
+    matchBrackets: true,
+    indentUnit: 2
+  });
+</script>
+
+<p><strong>MIME types defined:</strong> <code>text/x-crystal</code>.</p>
+</article>