236 lines
9.0 KiB
JavaScript
Executable File
236 lines
9.0 KiB
JavaScript
Executable File
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Distributed under the BSD license:
|
|
*
|
|
* Copyright (c) 2012, Ajax.org B.V.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of Ajax.org B.V. nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
define(function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var modes = require("../config").$modes;
|
|
|
|
var oop = require("../lib/oop");
|
|
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
|
|
var SlimHighlightRules = function() {
|
|
|
|
this.$rules = {
|
|
"start": [
|
|
{
|
|
token: "keyword",
|
|
regex: /^(\s*)(\w+):\s*/,
|
|
onMatch: function(value, state, stack, line) {
|
|
var indent = /^\s*/.exec(line)[0];
|
|
var m = value.match(/^(\s*)(\w+):/);
|
|
var language = m[2];
|
|
if (!/^(javascript|ruby|coffee|markdown|css|scss|sass|less)$/.test(language))
|
|
language = "";
|
|
stack.unshift("language-embed", [], [indent, language], state);
|
|
return this.token;
|
|
},
|
|
stateName: "language-embed",
|
|
next: [{
|
|
token: "string",
|
|
regex: /^(\s*)/,
|
|
onMatch: function(value, state, stack, line) {
|
|
var indent = stack[2][0];
|
|
if (indent.length >= value.length) {
|
|
stack.splice(0, 3);
|
|
this.next = stack.shift();
|
|
return this.token;
|
|
}
|
|
this.next = "";
|
|
return [{type: "text", value: indent}];
|
|
},
|
|
next: ""
|
|
}, {
|
|
token: "string",
|
|
regex: /.+/,
|
|
onMatch: function(value, state, stack, line) {
|
|
var indent = stack[2][0];
|
|
var language = stack[2][1];
|
|
var embedState = stack[1];
|
|
|
|
if (modes[language]) {
|
|
var data = modes[language].getTokenizer().getLineTokens(line.slice(indent.length), embedState.slice(0));
|
|
stack[1] = data.state;
|
|
return data.tokens;
|
|
}
|
|
return this.token;
|
|
}
|
|
}]
|
|
},
|
|
{
|
|
token: 'constant.begin.javascript.filter.slim',
|
|
regex: '^(\\s*)():$'
|
|
}, {
|
|
token: 'constant.begin..filter.slim',
|
|
regex: '^(\\s*)(ruby):$'
|
|
}, {
|
|
token: 'constant.begin.coffeescript.filter.slim',
|
|
regex: '^(\\s*)():$'
|
|
}, {
|
|
token: 'constant.begin..filter.slim',
|
|
regex: '^(\\s*)(markdown):$'
|
|
}, {
|
|
token: 'constant.begin.css.filter.slim',
|
|
regex: '^(\\s*)():$'
|
|
}, {
|
|
token: 'constant.begin.scss.filter.slim',
|
|
regex: '^(\\s*)():$'
|
|
}, {
|
|
token: 'constant.begin..filter.slim',
|
|
regex: '^(\\s*)(sass):$'
|
|
}, {
|
|
token: 'constant.begin..filter.slim',
|
|
regex: '^(\\s*)(less):$'
|
|
}, {
|
|
token: 'constant.begin..filter.slim',
|
|
regex: '^(\\s*)(erb):$'
|
|
}, {
|
|
token: 'keyword.html.tags.slim',
|
|
regex: '^(\\s*)((:?\\*(\\w)+)|doctype html|abbr|acronym|address|applet|area|article|aside|audio|base|basefont|bdo|big|blockquote|body|br|button|canvas|caption|center|cite|code|col|colgroup|command|datalist|dd|del|details|dialog|dfn|dir|div|dl|dt|embed|fieldset|figure|font|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|header|hgroup|hr|html|i|iframe|img|input|ins|keygen|kbd|label|legend|link|li|map|mark|menu|meta|meter|nav|noframes|noscript|object|ol|optgroup|option|output|p|param|pre|progress|q|rp|rt|ruby|samp|script|section|select|small|source|span|strike|strong|style|sub|sup|table|tbody|td|textarea|tfoot|th|thead|time|title|tr|tt|ul|var|video|xmp|b|u|s|em|a)(?:([.#](\\w|\\.)+)+\\s?)?\\b'
|
|
|
|
}, {
|
|
token: 'keyword.slim',
|
|
regex: '^(\\s*)(?:([.#](\\w|\\.)+)+\\s?)'
|
|
}, {
|
|
token: "string",
|
|
regex: /^(\s*)('|\||\/|(\/!))\s*/,
|
|
onMatch: function(val, state, stack, line) {
|
|
var indent = /^\s*/.exec(line)[0];
|
|
if (stack.length < 1) {
|
|
stack.push(this.next);
|
|
}
|
|
else {
|
|
stack[0] = "mlString";
|
|
}
|
|
|
|
if (stack.length < 2) {
|
|
stack.push(indent.length);
|
|
}
|
|
else {
|
|
stack[1] = indent.length;
|
|
}
|
|
return this.token;
|
|
},
|
|
next: "mlString"
|
|
}, {
|
|
token: 'keyword.control.slim',
|
|
regex: '^(\\s*)(\\-|==|=)',
|
|
push: [{
|
|
token: 'control.end.slim',
|
|
regex: '$',
|
|
next: "pop"
|
|
}, {
|
|
include: "rubyline"
|
|
}, {
|
|
include: "misc"
|
|
}]
|
|
|
|
}, {
|
|
token: 'paren',
|
|
regex: '\\(',
|
|
push: [{
|
|
token: 'paren',
|
|
regex: '\\)',
|
|
next: "pop"
|
|
}, {
|
|
include: "misc"
|
|
}]
|
|
|
|
}, {
|
|
token: 'paren',
|
|
regex: '\\[',
|
|
push: [{
|
|
token: 'paren',
|
|
regex: '\\]',
|
|
next: "pop"
|
|
}, {
|
|
include: "misc"
|
|
}]
|
|
}, {
|
|
include: "misc"
|
|
}
|
|
],
|
|
"mlString": [{
|
|
token: "indent",
|
|
regex: /^\s*/,
|
|
onMatch: function(val, state, stack) {
|
|
var curIndent = stack[1];
|
|
|
|
if (curIndent >= val.length) {
|
|
this.next = "start";
|
|
stack.splice(0);
|
|
}
|
|
else {
|
|
this.next = "mlString";
|
|
}
|
|
return this.token;
|
|
},
|
|
next: "start"
|
|
}, {
|
|
defaultToken: "string"
|
|
}],
|
|
"rubyline": [{
|
|
token: "keyword.operator.ruby.embedded.slim",
|
|
regex: "(==|=)(<>|><|<'|'<|<|>)?|-"
|
|
}, {
|
|
token: "list.ruby.operators.slim",
|
|
regex: "(\\b)(for|in|do|if|else|elsif|unless|while|yield|not|and|or)\\b"
|
|
}, {
|
|
token: "string",
|
|
regex: "['](.)*?[']"
|
|
}, {
|
|
token: "string",
|
|
regex: "[\"](.)*?[\"]"
|
|
}],
|
|
"misc": [{
|
|
token: 'class.variable.slim',
|
|
regex: '\\@([a-zA-Z_][a-zA-Z0-9_]*)\\b'
|
|
}, {
|
|
token: "list.meta.slim",
|
|
regex: "(\\b)(true|false|nil)(\\b)"
|
|
}, {
|
|
token: 'keyword.operator.equals.slim',
|
|
regex: '='
|
|
}, {
|
|
token: "string",
|
|
regex: "['](.)*?[']"
|
|
}, {
|
|
token: "string",
|
|
regex: "[\"](.)*?[\"]"
|
|
}]
|
|
};
|
|
this.normalizeRules();
|
|
};
|
|
|
|
|
|
oop.inherits(SlimHighlightRules, TextHighlightRules);
|
|
|
|
exports.SlimHighlightRules = SlimHighlightRules;
|
|
});
|