locomotivecms 4.1.1 → 4.2.0.alpha1

data/vendor/assets/javascripts/locomotive/codemirror/modes/dylan.js

@@ -0,0 +1,344 @@
+// 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("dylan", function(_config) {
+  // Words
+  var words = {
+    // Words that introduce unnamed definitions like "define interface"
+    unnamedDefinition: ["interface"],
+
+    // Words that introduce simple named definitions like "define library"
+    namedDefinition: ["module", "library", "macro",
+                      "C-struct", "C-union",
+                      "C-function", "C-callable-wrapper"
+                     ],
+
+    // Words that introduce type definitions like "define class".
+    // These are also parameterized like "define method" and are
+    // appended to otherParameterizedDefinitionWords
+    typeParameterizedDefinition: ["class", "C-subtype", "C-mapped-subtype"],
+
+    // Words that introduce trickier definitions like "define method".
+    // These require special definitions to be added to startExpressions
+    otherParameterizedDefinition: ["method", "function",
+                                   "C-variable", "C-address"
+                                  ],
+
+    // Words that introduce module constant definitions.
+    // These must also be simple definitions and are
+    // appended to otherSimpleDefinitionWords
+    constantSimpleDefinition: ["constant"],
+
+    // Words that introduce module variable definitions.
+    // These must also be simple definitions and are
+    // appended to otherSimpleDefinitionWords
+    variableSimpleDefinition: ["variable"],
+
+    // Other words that introduce simple definitions
+    // (without implicit bodies).
+    otherSimpleDefinition: ["generic", "domain",
+                            "C-pointer-type",
+                            "table"
+                           ],
+
+    // Words that begin statements with implicit bodies.
+    statement: ["if", "block", "begin", "method", "case",
+                "for", "select", "when", "unless", "until",
+                "while", "iterate", "profiling", "dynamic-bind"
+               ],
+
+    // Patterns that act as separators in compound statements.
+    // This may include any general pattern that must be indented
+    // specially.
+    separator: ["finally", "exception", "cleanup", "else",
+                "elseif", "afterwards"
+               ],
+
+    // Keywords that do not require special indentation handling,
+    // but which should be highlighted
+    other: ["above", "below", "by", "from", "handler", "in",
+            "instance", "let", "local", "otherwise", "slot",
+            "subclass", "then", "to", "keyed-by", "virtual"
+           ],
+
+    // Condition signaling function calls
+    signalingCalls: ["signal", "error", "cerror",
+                     "break", "check-type", "abort"
+                    ]
+  };
+
+  words["otherDefinition"] =
+    words["unnamedDefinition"]
+    .concat(words["namedDefinition"])
+    .concat(words["otherParameterizedDefinition"]);
+
+  words["definition"] =
+    words["typeParameterizedDefinition"]
+    .concat(words["otherDefinition"]);
+
+  words["parameterizedDefinition"] =
+    words["typeParameterizedDefinition"]
+    .concat(words["otherParameterizedDefinition"]);
+
+  words["simpleDefinition"] =
+    words["constantSimpleDefinition"]
+    .concat(words["variableSimpleDefinition"])
+    .concat(words["otherSimpleDefinition"]);
+
+  words["keyword"] =
+    words["statement"]
+    .concat(words["separator"])
+    .concat(words["other"]);
+
+  // Patterns
+  var symbolPattern = "[-_a-zA-Z?!*@<>$%]+";
+  var symbol = new RegExp("^" + symbolPattern);
+  var patterns = {
+    // Symbols with special syntax
+    symbolKeyword: symbolPattern + ":",
+    symbolClass: "<" + symbolPattern + ">",
+    symbolGlobal: "\\*" + symbolPattern + "\\*",
+    symbolConstant: "\\$" + symbolPattern
+  };
+  var patternStyles = {
+    symbolKeyword: "atom",
+    symbolClass: "tag",
+    symbolGlobal: "variable-2",
+    symbolConstant: "variable-3"
+  };
+
+  // Compile all patterns to regular expressions
+  for (var patternName in patterns)
+    if (patterns.hasOwnProperty(patternName))
+      patterns[patternName] = new RegExp("^" + patterns[patternName]);
+
+  // Names beginning "with-" and "without-" are commonly
+  // used as statement macro
+  patterns["keyword"] = [/^with(?:out)?-[-_a-zA-Z?!*@<>$%]+/];
+
+  var styles = {};
+  styles["keyword"] = "keyword";
+  styles["definition"] = "def";
+  styles["simpleDefinition"] = "def";
+  styles["signalingCalls"] = "builtin";
+
+  // protected words lookup table
+  var wordLookup = {};
+  var styleLookup = {};
+
+  [
+    "keyword",
+    "definition",
+    "simpleDefinition",
+    "signalingCalls"
+  ].forEach(function(type) {
+    words[type].forEach(function(word) {
+      wordLookup[word] = type;
+      styleLookup[word] = styles[type];
+    });
+  });
+
+
+  function chain(stream, state, f) {
+    state.tokenize = f;
+    return f(stream, state);
+  }
+
+  function tokenBase(stream, state) {
+    // String
+    var ch = stream.peek();
+    if (ch == "'" || ch == '"') {
+      stream.next();
+      return chain(stream, state, tokenString(ch, "string"));
+    }
+    // Comment
+    else if (ch == "/") {
+      stream.next();
+      if (stream.eat("*")) {
+        return chain(stream, state, tokenComment);
+      } else if (stream.eat("/")) {
+        stream.skipToEnd();
+        return "comment";
+      }
+      stream.backUp(1);
+    }
+    // Decimal
+    else if (/[+\-\d\.]/.test(ch)) {
+      if (stream.match(/^[+-]?[0-9]*\.[0-9]*([esdx][+-]?[0-9]+)?/i) ||
+          stream.match(/^[+-]?[0-9]+([esdx][+-]?[0-9]+)/i) ||
+          stream.match(/^[+-]?\d+/)) {
+        return "number";
+      }
+    }
+    // Hash
+    else if (ch == "#") {
+      stream.next();
+      // Symbol with string syntax
+      ch = stream.peek();
+      if (ch == '"') {
+        stream.next();
+        return chain(stream, state, tokenString('"', "string"));
+      }
+      // Binary number
+      else if (ch == "b") {
+        stream.next();
+        stream.eatWhile(/[01]/);
+        return "number";
+      }
+      // Hex number
+      else if (ch == "x") {
+        stream.next();
+        stream.eatWhile(/[\da-f]/i);
+        return "number";
+      }
+      // Octal number
+      else if (ch == "o") {
+        stream.next();
+        stream.eatWhile(/[0-7]/);
+        return "number";
+      }
+      // Token concatenation in macros
+      else if (ch == '#') {
+        stream.next();
+        return "punctuation";
+      }
+      // Sequence literals
+      else if ((ch == '[') || (ch == '(')) {
+        stream.next();
+        return "bracket";
+      // Hash symbol
+      } else if (stream.match(/f|t|all-keys|include|key|next|rest/i)) {
+        return "atom";
+      } else {
+        stream.eatWhile(/[-a-zA-Z]/);
+        return "error";
+      }
+    } else if (ch == "~") {
+      stream.next();
+      ch = stream.peek();
+      if (ch == "=") {
+        stream.next();
+        ch = stream.peek();
+        if (ch == "=") {
+          stream.next();
+          return "operator";
+        }
+        return "operator";
+      }
+      return "operator";
+    } else if (ch == ":") {
+      stream.next();
+      ch = stream.peek();
+      if (ch == "=") {
+        stream.next();
+        return "operator";
+      } else if (ch == ":") {
+        stream.next();
+        return "punctuation";
+      }
+    } else if ("[](){}".indexOf(ch) != -1) {
+      stream.next();
+      return "bracket";
+    } else if (".,".indexOf(ch) != -1) {
+      stream.next();
+      return "punctuation";
+    } else if (stream.match("end")) {
+      return "keyword";
+    }
+    for (var name in patterns) {
+      if (patterns.hasOwnProperty(name)) {
+        var pattern = patterns[name];
+        if ((pattern instanceof Array && pattern.some(function(p) {
+          return stream.match(p);
+        })) || stream.match(pattern))
+          return patternStyles[name];
+      }
+    }
+    if (/[+\-*\/^=<>&|]/.test(ch)) {
+      stream.next();
+      return "operator";
+    }
+    if (stream.match("define")) {
+      return "def";
+    } else {
+      stream.eatWhile(/[\w\-]/);
+      // Keyword
+      if (wordLookup[stream.current()]) {
+        return styleLookup[stream.current()];
+      } else if (stream.current().match(symbol)) {
+        return "variable";
+      } else {
+        stream.next();
+        return "variable-2";
+      }
+    }
+  }
+
+  function tokenComment(stream, state) {
+    var maybeEnd = false, maybeNested = false, nestedCount = 0, ch;
+    while ((ch = stream.next())) {
+      if (ch == "/" && maybeEnd) {
+        if (nestedCount > 0) {
+          nestedCount--;
+        } else {
+          state.tokenize = tokenBase;
+          break;
+        }
+      } else if (ch == "*" && maybeNested) {
+        nestedCount++;
+      }
+      maybeEnd = (ch == "*");
+      maybeNested = (ch == "/");
+    }
+    return "comment";
+  }
+
+  function tokenString(quote, style) {
+    return function(stream, state) {
+      var escaped = false, next, end = false;
+      while ((next = stream.next()) != null) {
+        if (next == quote && !escaped) {
+          end = true;
+          break;
+        }
+        escaped = !escaped && next == "\\";
+      }
+      if (end || !escaped) {
+        state.tokenize = tokenBase;
+      }
+      return style;
+    };
+  }
+
+  // Interface
+  return {
+    startState: function() {
+      return {
+        tokenize: tokenBase,
+        currentIndent: 0
+      };
+    },
+    token: function(stream, state) {
+      if (stream.eatSpace())
+        return null;
+      var style = state.tokenize(stream, state);
+      return style;
+    },
+    blockCommentStart: "/*",
+    blockCommentEnd: "*/"
+  };
+});
+
+CodeMirror.defineMIME("text/x-dylan", "dylan");
+
+});

data/vendor/assets/javascripts/locomotive/codemirror/modes/ebnf.js

@@ -0,0 +1,195 @@
+// 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("ebnf", function (config) {
+    var commentType = {slash: 0, parenthesis: 1};
+    var stateType = {comment: 0, _string: 1, characterClass: 2};
+    var bracesMode = null;
+
+    if (config.bracesMode)
+      bracesMode = CodeMirror.getMode(config, config.bracesMode);
+
+    return {
+      startState: function () {
+        return {
+          stringType: null,
+          commentType: null,
+          braced: 0,
+          lhs: true,
+          localState: null,
+          stack: [],
+          inDefinition: false
+        };
+      },
+      token: function (stream, state) {
+        if (!stream) return;
+
+        //check for state changes
+        if (state.stack.length === 0) {
+          //strings
+          if ((stream.peek() == '"') || (stream.peek() == "'")) {
+            state.stringType = stream.peek();
+            stream.next(); // Skip quote
+            state.stack.unshift(stateType._string);
+          } else if (stream.match(/^\/\*/)) { //comments starting with /*
+            state.stack.unshift(stateType.comment);
+            state.commentType = commentType.slash;
+          } else if (stream.match(/^\(\*/)) { //comments starting with (*
+            state.stack.unshift(stateType.comment);
+            state.commentType = commentType.parenthesis;
+          }
+        }
+
+        //return state
+        //stack has
+        switch (state.stack[0]) {
+        case stateType._string:
+          while (state.stack[0] === stateType._string && !stream.eol()) {
+            if (stream.peek() === state.stringType) {
+              stream.next(); // Skip quote
+              state.stack.shift(); // Clear flag
+            } else if (stream.peek() === "\\") {
+              stream.next();
+              stream.next();
+            } else {
+              stream.match(/^.[^\\\"\']*/);
+            }
+          }
+          return state.lhs ? "property string" : "string"; // Token style
+
+        case stateType.comment:
+          while (state.stack[0] === stateType.comment && !stream.eol()) {
+            if (state.commentType === commentType.slash && stream.match(/\*\//)) {
+              state.stack.shift(); // Clear flag
+              state.commentType = null;
+            } else if (state.commentType === commentType.parenthesis && stream.match(/\*\)/)) {
+              state.stack.shift(); // Clear flag
+              state.commentType = null;
+            } else {
+              stream.match(/^.[^\*]*/);
+            }
+          }
+          return "comment";
+
+        case stateType.characterClass:
+          while (state.stack[0] === stateType.characterClass && !stream.eol()) {
+            if (!(stream.match(/^[^\]\\]+/) || stream.match(/^\\./))) {
+              state.stack.shift();
+            }
+          }
+          return "operator";
+        }
+
+        var peek = stream.peek();
+
+        if (bracesMode !== null && (state.braced || peek === "{")) {
+          if (state.localState === null)
+            state.localState = CodeMirror.startState(bracesMode);
+
+          var token = bracesMode.token(stream, state.localState),
+          text = stream.current();
+
+          if (!token) {
+            for (var i = 0; i < text.length; i++) {
+              if (text[i] === "{") {
+                if (state.braced === 0) {
+                  token = "matchingbracket";
+                }
+                state.braced++;
+              } else if (text[i] === "}") {
+                state.braced--;
+                if (state.braced === 0) {
+                  token = "matchingbracket";
+                }
+              }
+            }
+          }
+          return token;
+        }
+
+        //no stack
+        switch (peek) {
+        case "[":
+          stream.next();
+          state.stack.unshift(stateType.characterClass);
+          return "bracket";
+        case ":":
+        case "|":
+        case ";":
+          stream.next();
+          return "operator";
+        case "%":
+          if (stream.match("%%")) {
+            return "header";
+          } else if (stream.match(/[%][A-Za-z]+/)) {
+            return "keyword";
+          } else if (stream.match(/[%][}]/)) {
+            return "matchingbracket";
+          }
+          break;
+        case "/":
+          if (stream.match(/[\/][A-Za-z]+/)) {
+          return "keyword";
+        }
+        case "\\":
+          if (stream.match(/[\][a-z]+/)) {
+            return "string-2";
+          }
+        case ".":
+          if (stream.match(".")) {
+            return "atom";
+          }
+        case "*":
+        case "-":
+        case "+":
+        case "^":
+          if (stream.match(peek)) {
+            return "atom";
+          }
+        case "$":
+          if (stream.match("$$")) {
+            return "builtin";
+          } else if (stream.match(/[$][0-9]+/)) {
+            return "variable-3";
+          }
+        case "<":
+          if (stream.match(/<<[a-zA-Z_]+>>/)) {
+            return "builtin";
+          }
+        }
+
+        if (stream.match(/^\/\//)) {
+          stream.skipToEnd();
+          return "comment";
+        } else if (stream.match(/return/)) {
+          return "operator";
+        } else if (stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/)) {
+          if (stream.match(/(?=[\(.])/)) {
+            return "variable";
+          } else if (stream.match(/(?=[\s\n]*[:=])/)) {
+            return "def";
+          }
+          return "variable-2";
+        } else if (["[", "]", "(", ")"].indexOf(stream.peek()) != -1) {
+          stream.next();
+          return "bracket";
+        } else if (!stream.eatSpace()) {
+          stream.next();
+        }
+        return null;
+      }
+    };
+  });
+
+  CodeMirror.defineMIME("text/x-ebnf", "ebnf");
+});