735a74901f
Previously, we were at an ACE editor published between 1.1.8 and 1.1.9. This caused multiple issues and was especially a problem for the upcoming pair programming feature. Further, updating ace is a long-time priority, see https://github.com/openHPI/codeocean/issues/250. Now, we are not yet updating to the latest version, but rather to the next minor version. This already contains breaking changes, and we are currently interested to keep the number of changes as low as possible. Further updating ACE might be still a future task. The new ACE version 1.2.0 is taken from this tag: https://github.com/ajaxorg/ace-builds/releases/tag/v1.2.0. We are using the src build (not minified, not in the noconflict version), since the same was used before as well. Further, we need to change our migration for storing editor events. Since the table is not yet used (in production), we also update the enum.
494 lines
23 KiB
JavaScript
494 lines
23 KiB
JavaScript
define("ace/mode/elixir_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var oop = require("../lib/oop");
|
|
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
|
|
|
|
var ElixirHighlightRules = function() {
|
|
|
|
this.$rules = { start:
|
|
[ { token:
|
|
[ 'meta.module.elixir',
|
|
'keyword.control.module.elixir',
|
|
'meta.module.elixir',
|
|
'entity.name.type.module.elixir' ],
|
|
regex: '^(\\s*)(defmodule)(\\s+)((?:[A-Z]\\w*\\s*\\.\\s*)*[A-Z]\\w*)' },
|
|
{ token: 'comment.documentation.heredoc',
|
|
regex: '@(?:module|type)?doc (?:~[a-z])?"""',
|
|
push:
|
|
[ { token: 'comment.documentation.heredoc',
|
|
regex: '\\s*"""',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'comment.documentation.heredoc' } ],
|
|
comment: '@doc with heredocs is treated as documentation' },
|
|
{ token: 'comment.documentation.heredoc',
|
|
regex: '@(?:module|type)?doc ~[A-Z]"""',
|
|
push:
|
|
[ { token: 'comment.documentation.heredoc',
|
|
regex: '\\s*"""',
|
|
next: 'pop' },
|
|
{ defaultToken: 'comment.documentation.heredoc' } ],
|
|
comment: '@doc with heredocs is treated as documentation' },
|
|
{ token: 'comment.documentation.heredoc',
|
|
regex: '@(?:module|type)?doc (?:~[a-z])?\'\'\'',
|
|
push:
|
|
[ { token: 'comment.documentation.heredoc',
|
|
regex: '\\s*\'\'\'',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'comment.documentation.heredoc' } ],
|
|
comment: '@doc with heredocs is treated as documentation' },
|
|
{ token: 'comment.documentation.heredoc',
|
|
regex: '@(?:module|type)?doc ~[A-Z]\'\'\'',
|
|
push:
|
|
[ { token: 'comment.documentation.heredoc',
|
|
regex: '\\s*\'\'\'',
|
|
next: 'pop' },
|
|
{ defaultToken: 'comment.documentation.heredoc' } ],
|
|
comment: '@doc with heredocs is treated as documentation' },
|
|
{ token: 'comment.documentation.false',
|
|
regex: '@(?:module|type)?doc false',
|
|
comment: '@doc false is treated as documentation' },
|
|
{ token: 'comment.documentation.string',
|
|
regex: '@(?:module|type)?doc "',
|
|
push:
|
|
[ { token: 'comment.documentation.string',
|
|
regex: '"',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'comment.documentation.string' } ],
|
|
comment: '@doc with string is treated as documentation' },
|
|
{ token: 'keyword.control.elixir',
|
|
regex: '\\b(?:do|end|case|bc|lc|for|if|cond|unless|try|receive|fn|defmodule|defp?|defprotocol|defimpl|defrecord|defstruct|defmacrop?|defdelegate|defcallback|defmacrocallback|defexception|defoverridable|exit|after|rescue|catch|else|raise|throw|import|require|alias|use|quote|unquote|super)\\b(?![?!])',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '(?<!\\.)\\b(do|end|case|bc|lc|for|if|cond|unless|try|receive|fn|defmodule|defp?|defprotocol|defimpl|defrecord|defstruct|defmacrop?|defdelegate|defcallback|defmacrocallback|defexception|defoverridable|exit|after|rescue|catch|else|raise|throw|import|require|alias|use|quote|unquote|super)\\b(?![?!])' },
|
|
{ token: 'keyword.operator.elixir',
|
|
regex: '\\b(?:and|not|or|when|xor|in|inlist|inbits)\\b',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '(?<!\\.)\\b(and|not|or|when|xor|in|inlist|inbits)\\b',
|
|
comment: ' as above, just doesn\'t need a \'end\' and does a logic operation' },
|
|
{ token: 'constant.language.elixir',
|
|
regex: '\\b(?:nil|true|false)\\b(?![?!])' },
|
|
{ token: 'variable.language.elixir',
|
|
regex: '\\b__(?:CALLER|ENV|MODULE|DIR)__\\b(?![?!])' },
|
|
{ token:
|
|
[ 'punctuation.definition.variable.elixir',
|
|
'variable.other.readwrite.module.elixir' ],
|
|
regex: '(@)([a-zA-Z_]\\w*)' },
|
|
{ token:
|
|
[ 'punctuation.definition.variable.elixir',
|
|
'variable.other.anonymous.elixir' ],
|
|
regex: '(&)(\\d*)' },
|
|
{ token: 'variable.other.constant.elixir',
|
|
regex: '\\b[A-Z]\\w*\\b' },
|
|
{ token: 'constant.numeric.elixir',
|
|
regex: '\\b(?:0x[\\da-fA-F](?:_?[\\da-fA-F])*|\\d(?:_?\\d)*(?:\\.(?![^[:space:][:digit:]])(?:_?\\d)*)?(?:[eE][-+]?\\d(?:_?\\d)*)?|0b[01]+|0o[0-7]+)\\b',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '\\b(0x\\h(?>_?\\h)*|\\d(?>_?\\d)*(\\.(?![^[:space:][:digit:]])(?>_?\\d)*)?([eE][-+]?\\d(?>_?\\d)*)?|0b[01]+|0o[0-7]+)\\b' },
|
|
{ token: 'punctuation.definition.constant.elixir',
|
|
regex: ':\'',
|
|
push:
|
|
[ { token: 'punctuation.definition.constant.elixir',
|
|
regex: '\'',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'constant.other.symbol.single-quoted.elixir' } ] },
|
|
{ token: 'punctuation.definition.constant.elixir',
|
|
regex: ':"',
|
|
push:
|
|
[ { token: 'punctuation.definition.constant.elixir',
|
|
regex: '"',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'constant.other.symbol.double-quoted.elixir' } ] },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '(?:\'\'\')',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '(?>\'\'\')',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '^\\s*\'\'\'',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'support.function.variable.quoted.single.heredoc.elixir' } ],
|
|
comment: 'Single-quoted heredocs' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '\'',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\'',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'support.function.variable.quoted.single.elixir' } ],
|
|
comment: 'single quoted string (allows for interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '(?:""")',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '(?>""")',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '^\\s*"""',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.quoted.double.heredoc.elixir' } ],
|
|
comment: 'Double-quoted heredocs' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '"',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '"',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.quoted.double.elixir' } ],
|
|
comment: 'double quoted string (allows for interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[a-z](?:""")',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '~[a-z](?>""")',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '^\\s*"""',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.quoted.double.heredoc.elixir' } ],
|
|
comment: 'Double-quoted heredocs sigils' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[a-z]\\{',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\\}[a-z]*',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.interpolated.elixir' } ],
|
|
comment: 'sigil (allow for interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[a-z]\\[',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\\][a-z]*',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.interpolated.elixir' } ],
|
|
comment: 'sigil (allow for interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[a-z]\\<',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\\>[a-z]*',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.interpolated.elixir' } ],
|
|
comment: 'sigil (allow for interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[a-z]\\(',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\\)[a-z]*',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.interpolated.elixir' } ],
|
|
comment: 'sigil (allow for interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[a-z][^\\w]',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '[^\\w][a-z]*',
|
|
next: 'pop' },
|
|
{ include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.interpolated.elixir' } ],
|
|
comment: 'sigil (allow for interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[A-Z](?:""")',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '~[A-Z](?>""")',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '^\\s*"""',
|
|
next: 'pop' },
|
|
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
|
|
comment: 'Double-quoted heredocs sigils' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[A-Z]\\{',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\\}[a-z]*',
|
|
next: 'pop' },
|
|
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
|
|
comment: 'sigil (without interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[A-Z]\\[',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\\][a-z]*',
|
|
next: 'pop' },
|
|
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
|
|
comment: 'sigil (without interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[A-Z]\\<',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\\>[a-z]*',
|
|
next: 'pop' },
|
|
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
|
|
comment: 'sigil (without interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[A-Z]\\(',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '\\)[a-z]*',
|
|
next: 'pop' },
|
|
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
|
|
comment: 'sigil (without interpolation)' },
|
|
{ token: 'punctuation.definition.string.begin.elixir',
|
|
regex: '~[A-Z][^\\w]',
|
|
push:
|
|
[ { token: 'punctuation.definition.string.end.elixir',
|
|
regex: '[^\\w][a-z]*',
|
|
next: 'pop' },
|
|
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
|
|
comment: 'sigil (without interpolation)' },
|
|
{ token: ['punctuation.definition.constant.elixir', 'constant.other.symbol.elixir'],
|
|
regex: '(:)([a-zA-Z_][\\w@]*(?:[?!]|=(?![>=]))?|\\<\\>|===?|!==?|<<>>|<<<|>>>|~~~|::|<\\-|\\|>|=>|~|~=|=|/|\\\\\\\\|\\*\\*?|\\.\\.?\\.?|>=?|<=?|&&?&?|\\+\\+?|\\-\\-?|\\|\\|?\\|?|\\!|@|\\%?\\{\\}|%|\\[\\]|\\^(?:\\^\\^)?)',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '(?<!:)(:)(?>[a-zA-Z_][\\w@]*(?>[?!]|=(?![>=]))?|\\<\\>|===?|!==?|<<>>|<<<|>>>|~~~|::|<\\-|\\|>|=>|~|~=|=|/|\\\\\\\\|\\*\\*?|\\.\\.?\\.?|>=?|<=?|&&?&?|\\+\\+?|\\-\\-?|\\|\\|?\\|?|\\!|@|\\%?\\{\\}|%|\\[\\]|\\^(\\^\\^)?)',
|
|
comment: 'symbols' },
|
|
{ token: 'punctuation.definition.constant.elixir',
|
|
regex: '(?:[a-zA-Z_][\\w@]*(?:[?!])?):(?!:)',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '(?>[a-zA-Z_][\\w@]*(?>[?!])?)(:)(?!:)',
|
|
comment: 'symbols' },
|
|
{ token:
|
|
[ 'punctuation.definition.comment.elixir',
|
|
'comment.line.number-sign.elixir' ],
|
|
regex: '(#)(.*)' },
|
|
{ token: 'constant.numeric.elixir',
|
|
regex: '\\?(?:\\\\(?:x[\\da-fA-F]{1,2}(?![\\da-fA-F])\\b|[^xMC])|[^\\s\\\\])',
|
|
TODO: 'FIXME: regexp doesn\'t have js equivalent',
|
|
originalRegex: '(?<!\\w)\\?(\\\\(x\\h{1,2}(?!\\h)\\b|[^xMC])|[^\\s\\\\])',
|
|
comment: '\n\t\t\tmatches questionmark-letters.\n\n\t\t\texamples (1st alternation = hex):\n\t\t\t?\\x1 ?\\x61\n\n\t\t\texamples (2rd alternation = escaped):\n\t\t\t?\\n ?\\b\n\n\t\t\texamples (3rd alternation = normal):\n\t\t\t?a ?A ?0 \n\t\t\t?* ?" ?( \n\t\t\t?. ?#\n\t\t\t\n\t\t\tthe negative lookbehind prevents against matching\n\t\t\tp(42.tainted?)\n\t\t\t' },
|
|
{ token: 'keyword.operator.assignment.augmented.elixir',
|
|
regex: '\\+=|\\-=|\\|\\|=|~=|&&=' },
|
|
{ token: 'keyword.operator.comparison.elixir',
|
|
regex: '===?|!==?|<=?|>=?' },
|
|
{ token: 'keyword.operator.bitwise.elixir',
|
|
regex: '\\|{3}|&{3}|\\^{3}|<{3}|>{3}|~{3}' },
|
|
{ token: 'keyword.operator.logical.elixir',
|
|
regex: '!+|\\bnot\\b|&&|\\band\\b|\\|\\||\\bor\\b|\\bxor\\b',
|
|
originalRegex: '(?<=[ \\t])!+|\\bnot\\b|&&|\\band\\b|\\|\\||\\bor\\b|\\bxor\\b' },
|
|
{ token: 'keyword.operator.arithmetic.elixir',
|
|
regex: '\\*|\\+|\\-|/' },
|
|
{ token: 'keyword.operator.other.elixir',
|
|
regex: '\\||\\+\\+|\\-\\-|\\*\\*|\\\\\\\\|\\<\\-|\\<\\>|\\<\\<|\\>\\>|\\:\\:|\\.\\.|\\|>|~|=>' },
|
|
{ token: 'keyword.operator.assignment.elixir', regex: '=' },
|
|
{ token: 'punctuation.separator.other.elixir', regex: ':' },
|
|
{ token: 'punctuation.separator.statement.elixir',
|
|
regex: '\\;' },
|
|
{ token: 'punctuation.separator.object.elixir', regex: ',' },
|
|
{ token: 'punctuation.separator.method.elixir', regex: '\\.' },
|
|
{ token: 'punctuation.section.scope.elixir', regex: '\\{|\\}' },
|
|
{ token: 'punctuation.section.array.elixir', regex: '\\[|\\]' },
|
|
{ token: 'punctuation.section.function.elixir',
|
|
regex: '\\(|\\)' } ],
|
|
'#escaped_char':
|
|
[ { token: 'constant.character.escape.elixir',
|
|
regex: '\\\\(?:x[\\da-fA-F]{1,2}|.)' } ],
|
|
'#interpolated_elixir':
|
|
[ { token:
|
|
[ 'source.elixir.embedded.source',
|
|
'source.elixir.embedded.source.empty' ],
|
|
regex: '(#\\{)(\\})' },
|
|
{ todo:
|
|
{ token: 'punctuation.section.embedded.elixir',
|
|
regex: '#\\{',
|
|
push:
|
|
[ { token: 'punctuation.section.embedded.elixir',
|
|
regex: '\\}',
|
|
next: 'pop' },
|
|
{ include: '#nest_curly_and_self' },
|
|
{ include: '$self' },
|
|
{ defaultToken: 'source.elixir.embedded.source' } ] } } ],
|
|
'#nest_curly_and_self':
|
|
[ { token: 'punctuation.section.scope.elixir',
|
|
regex: '\\{',
|
|
push:
|
|
[ { token: 'punctuation.section.scope.elixir',
|
|
regex: '\\}',
|
|
next: 'pop' },
|
|
{ include: '#nest_curly_and_self' } ] },
|
|
{ include: '$self' } ],
|
|
'#regex_sub':
|
|
[ { include: '#interpolated_elixir' },
|
|
{ include: '#escaped_char' },
|
|
{ token:
|
|
[ 'punctuation.definition.arbitrary-repitition.elixir',
|
|
'string.regexp.arbitrary-repitition.elixir',
|
|
'string.regexp.arbitrary-repitition.elixir',
|
|
'punctuation.definition.arbitrary-repitition.elixir' ],
|
|
regex: '(\\{)(\\d+)((?:,\\d+)?)(\\})' },
|
|
{ token: 'punctuation.definition.character-class.elixir',
|
|
regex: '\\[(?:\\^?\\])?',
|
|
push:
|
|
[ { token: 'punctuation.definition.character-class.elixir',
|
|
regex: '\\]',
|
|
next: 'pop' },
|
|
{ include: '#escaped_char' },
|
|
{ defaultToken: 'string.regexp.character-class.elixir' } ] },
|
|
{ token: 'punctuation.definition.group.elixir',
|
|
regex: '\\(',
|
|
push:
|
|
[ { token: 'punctuation.definition.group.elixir',
|
|
regex: '\\)',
|
|
next: 'pop' },
|
|
{ include: '#regex_sub' },
|
|
{ defaultToken: 'string.regexp.group.elixir' } ] },
|
|
{ token:
|
|
[ 'punctuation.definition.comment.elixir',
|
|
'comment.line.number-sign.elixir' ],
|
|
regex: '(?:^|\\s)(#)(\\s[[a-zA-Z0-9,. \\t?!-][^\\x00-\\x7F]]*$)',
|
|
originalRegex: '(?<=^|\\s)(#)\\s[[a-zA-Z0-9,. \\t?!-][^\\x{00}-\\x{7F}]]*$',
|
|
comment: 'We are restrictive in what we allow to go after the comment character to avoid false positives, since the availability of comments depend on regexp flags.' } ] }
|
|
|
|
this.normalizeRules();
|
|
};
|
|
|
|
ElixirHighlightRules.metaData = { comment: 'Textmate bundle for Elixir Programming Language.',
|
|
fileTypes: [ 'ex', 'exs' ],
|
|
firstLineMatch: '^#!/.*\\belixir',
|
|
foldingStartMarker: '(after|else|catch|rescue|\\-\\>|\\{|\\[|do)\\s*$',
|
|
foldingStopMarker: '^\\s*((\\}|\\]|after|else|catch|rescue)\\s*$|end\\b)',
|
|
keyEquivalent: '^~E',
|
|
name: 'Elixir',
|
|
scopeName: 'source.elixir' }
|
|
|
|
|
|
oop.inherits(ElixirHighlightRules, TextHighlightRules);
|
|
|
|
exports.ElixirHighlightRules = ElixirHighlightRules;
|
|
});
|
|
|
|
define("ace/mode/folding/coffee",["require","exports","module","ace/lib/oop","ace/mode/folding/fold_mode","ace/range"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var oop = require("../../lib/oop");
|
|
var BaseFoldMode = require("./fold_mode").FoldMode;
|
|
var Range = require("../../range").Range;
|
|
|
|
var FoldMode = exports.FoldMode = function() {};
|
|
oop.inherits(FoldMode, BaseFoldMode);
|
|
|
|
(function() {
|
|
|
|
this.getFoldWidgetRange = function(session, foldStyle, row) {
|
|
var range = this.indentationBlock(session, row);
|
|
if (range)
|
|
return range;
|
|
|
|
var re = /\S/;
|
|
var line = session.getLine(row);
|
|
var startLevel = line.search(re);
|
|
if (startLevel == -1 || line[startLevel] != "#")
|
|
return;
|
|
|
|
var startColumn = line.length;
|
|
var maxRow = session.getLength();
|
|
var startRow = row;
|
|
var endRow = row;
|
|
|
|
while (++row < maxRow) {
|
|
line = session.getLine(row);
|
|
var level = line.search(re);
|
|
|
|
if (level == -1)
|
|
continue;
|
|
|
|
if (line[level] != "#")
|
|
break;
|
|
|
|
endRow = row;
|
|
}
|
|
|
|
if (endRow > startRow) {
|
|
var endColumn = session.getLine(endRow).length;
|
|
return new Range(startRow, startColumn, endRow, endColumn);
|
|
}
|
|
};
|
|
this.getFoldWidget = function(session, foldStyle, row) {
|
|
var line = session.getLine(row);
|
|
var indent = line.search(/\S/);
|
|
var next = session.getLine(row + 1);
|
|
var prev = session.getLine(row - 1);
|
|
var prevIndent = prev.search(/\S/);
|
|
var nextIndent = next.search(/\S/);
|
|
|
|
if (indent == -1) {
|
|
session.foldWidgets[row - 1] = prevIndent!= -1 && prevIndent < nextIndent ? "start" : "";
|
|
return "";
|
|
}
|
|
if (prevIndent == -1) {
|
|
if (indent == nextIndent && line[indent] == "#" && next[indent] == "#") {
|
|
session.foldWidgets[row - 1] = "";
|
|
session.foldWidgets[row + 1] = "";
|
|
return "start";
|
|
}
|
|
} else if (prevIndent == indent && line[indent] == "#" && prev[indent] == "#") {
|
|
if (session.getLine(row - 2).search(/\S/) == -1) {
|
|
session.foldWidgets[row - 1] = "start";
|
|
session.foldWidgets[row + 1] = "";
|
|
return "";
|
|
}
|
|
}
|
|
|
|
if (prevIndent!= -1 && prevIndent < indent)
|
|
session.foldWidgets[row - 1] = "start";
|
|
else
|
|
session.foldWidgets[row - 1] = "";
|
|
|
|
if (indent < nextIndent)
|
|
return "start";
|
|
else
|
|
return "";
|
|
};
|
|
|
|
}).call(FoldMode.prototype);
|
|
|
|
});
|
|
|
|
define("ace/mode/elixir",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/elixir_highlight_rules","ace/mode/folding/coffee"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var oop = require("../lib/oop");
|
|
var TextMode = require("./text").Mode;
|
|
var ElixirHighlightRules = require("./elixir_highlight_rules").ElixirHighlightRules;
|
|
var FoldMode = require("./folding/coffee").FoldMode;
|
|
|
|
var Mode = function() {
|
|
this.HighlightRules = ElixirHighlightRules;
|
|
this.foldingRules = new FoldMode();
|
|
};
|
|
oop.inherits(Mode, TextMode);
|
|
|
|
(function() {
|
|
this.lineCommentStart = "#";
|
|
this.$id = "ace/mode/elixir"
|
|
}).call(Mode.prototype);
|
|
|
|
exports.Mode = Mode;
|
|
});
|