/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/js/ace/mode-clojure.js

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/js/ace/mode-clojure.js
 
1
/* ***** BEGIN LICENSE BLOCK *****
 
2
 * Distributed under the BSD license:
 
3
 *
 
4
 * Copyright (c) 2010, Ajax.org B.V.
 
5
 * All rights reserved.
 
6
 * 
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions are met:
 
9
 *     * Redistributions of source code must retain the above copyright
 
10
 *       notice, this list of conditions and the following disclaimer.
 
11
 *     * Redistributions in binary form must reproduce the above copyright
 
12
 *       notice, this list of conditions and the following disclaimer in the
 
13
 *       documentation and/or other materials provided with the distribution.
 
14
 *     * Neither the name of Ajax.org B.V. nor the
 
15
 *       names of its contributors may be used to endorse or promote products
 
16
 *       derived from this software without specific prior written permission.
 
17
 * 
 
18
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
20
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
21
 * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
 
22
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
23
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 
24
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 
25
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 
27
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
28
 *
 
29
 * ***** END LICENSE BLOCK ***** */
 
30
 
 
31
define('ace/mode/clojure', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/clojure_highlight_rules', 'ace/mode/matching_parens_outdent', 'ace/range'], function(require, exports, module) {
 
32
 
 
33
 
 
34
var oop = require("../lib/oop");
 
35
var TextMode = require("./text").Mode;
 
36
var Tokenizer = require("../tokenizer").Tokenizer;
 
37
var ClojureHighlightRules = require("./clojure_highlight_rules").ClojureHighlightRules;
 
38
var MatchingParensOutdent = require("./matching_parens_outdent").MatchingParensOutdent;
 
39
var Range = require("../range").Range;
 
40
 
 
41
var Mode = function() {
 
42
    this.$tokenizer = new Tokenizer(new ClojureHighlightRules().getRules());
 
43
    this.$outdent = new MatchingParensOutdent();
 
44
};
 
45
oop.inherits(Mode, TextMode);
 
46
 
 
47
(function() {
 
48
 
 
49
    this.lineCommentStart = ";";
 
50
 
 
51
    this.getNextLineIndent = function(state, line, tab) {
 
52
        var indent = this.$getIndent(line);
 
53
 
 
54
        var tokenizedLine = this.$tokenizer.getLineTokens(line, state);
 
55
        var tokens = tokenizedLine.tokens;
 
56
 
 
57
        if (tokens.length && tokens[tokens.length-1].type == "comment") {
 
58
            return indent;
 
59
        }
 
60
        
 
61
        if (state == "start") {
 
62
            var match = line.match(/[\(\[]/);
 
63
            if (match) {
 
64
                indent += "  ";
 
65
            }
 
66
            match = line.match(/[\)]/);
 
67
            if (match) {
 
68
              indent = "";
 
69
            }
 
70
        }
 
71
 
 
72
        return indent;
 
73
    };
 
74
 
 
75
    this.checkOutdent = function(state, line, input) {
 
76
        return this.$outdent.checkOutdent(line, input);
 
77
    };
 
78
 
 
79
    this.autoOutdent = function(state, doc, row) {
 
80
        this.$outdent.autoOutdent(doc, row);
 
81
    };
 
82
 
 
83
}).call(Mode.prototype);
 
84
 
 
85
exports.Mode = Mode;
 
86
});
 
87
 
 
88
define('ace/mode/clojure_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
 
89
 
 
90
 
 
91
var oop = require("../lib/oop");
 
92
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
93
 
 
94
 
 
95
 
 
96
var ClojureHighlightRules = function() {
 
97
 
 
98
    var builtinFunctions = (
 
99
        '* *1 *2 *3 *agent* *allow-unresolved-vars* *assert* *clojure-version* ' +
 
100
        '*command-line-args* *compile-files* *compile-path* *e *err* *file* ' +
 
101
        '*flush-on-newline* *in* *macro-meta* *math-context* *ns* *out* ' +
 
102
        '*print-dup* *print-length* *print-level* *print-meta* *print-readably* ' +
 
103
        '*read-eval* *source-path* *use-context-classloader* ' +
 
104
        '*warn-on-reflection* + - -> ->> .. / < <= = ' +
 
105
        '== > &gt; >= &gt;= accessor aclone ' +
 
106
        'add-classpath add-watch agent agent-errors aget alength alias all-ns ' +
 
107
        'alter alter-meta! alter-var-root amap ancestors and apply areduce ' +
 
108
        'array-map aset aset-boolean aset-byte aset-char aset-double aset-float ' +
 
109
        'aset-int aset-long aset-short assert assoc assoc! assoc-in associative? ' +
 
110
        'atom await await-for await1 bases bean bigdec bigint binding bit-and ' +
 
111
        'bit-and-not bit-clear bit-flip bit-not bit-or bit-set bit-shift-left ' +
 
112
        'bit-shift-right bit-test bit-xor boolean boolean-array booleans ' +
 
113
        'bound-fn bound-fn* butlast byte byte-array bytes cast char char-array ' +
 
114
        'char-escape-string char-name-string char? chars chunk chunk-append ' +
 
115
        'chunk-buffer chunk-cons chunk-first chunk-next chunk-rest chunked-seq? ' +
 
116
        'class class? clear-agent-errors clojure-version coll? comment commute ' +
 
117
        'comp comparator compare compare-and-set! compile complement concat cond ' +
 
118
        'condp conj conj! cons constantly construct-proxy contains? count ' +
 
119
        'counted? create-ns create-struct cycle dec decimal? declare definline ' +
 
120
        'defmacro defmethod defmulti defn defn- defonce defstruct delay delay? ' +
 
121
        'deliver deref derive descendants destructure disj disj! dissoc dissoc! ' +
 
122
        'distinct distinct? doall doc dorun doseq dosync dotimes doto double ' +
 
123
        'double-array doubles drop drop-last drop-while empty empty? ensure ' +
 
124
        'enumeration-seq eval even? every? false? ffirst file-seq filter find ' +
 
125
        'find-doc find-ns find-var first float float-array float? floats flush ' +
 
126
        'fn fn? fnext for force format future future-call future-cancel ' +
 
127
        'future-cancelled? future-done? future? gen-class gen-interface gensym ' +
 
128
        'get get-in get-method get-proxy-class get-thread-bindings get-validator ' +
 
129
        'hash hash-map hash-set identical? identity if-let if-not ifn? import ' +
 
130
        'in-ns inc init-proxy instance? int int-array integer? interleave intern ' +
 
131
        'interpose into into-array ints io! isa? iterate iterator-seq juxt key ' +
 
132
        'keys keyword keyword? last lazy-cat lazy-seq let letfn line-seq list ' +
 
133
        'list* list? load load-file load-reader load-string loaded-libs locking ' +
 
134
        'long long-array longs loop macroexpand macroexpand-1 make-array ' +
 
135
        'make-hierarchy map map? mapcat max max-key memfn memoize merge ' +
 
136
        'merge-with meta method-sig methods min min-key mod name namespace neg? ' +
 
137
        'newline next nfirst nil? nnext not not-any? not-empty not-every? not= ' +
 
138
        'ns ns-aliases ns-imports ns-interns ns-map ns-name ns-publics ' +
 
139
        'ns-refers ns-resolve ns-unalias ns-unmap nth nthnext num number? odd? ' +
 
140
        'or parents partial partition pcalls peek persistent! pmap pop pop! ' +
 
141
        'pop-thread-bindings pos? pr pr-str prefer-method prefers ' +
 
142
        'primitives-classnames print print-ctor print-doc print-dup print-method ' +
 
143
        'print-namespace-doc print-simple print-special-doc print-str printf ' +
 
144
        'println println-str prn prn-str promise proxy proxy-call-with-super ' +
 
145
        'proxy-mappings proxy-name proxy-super push-thread-bindings pvalues quot ' +
 
146
        'rand rand-int range ratio? rational? rationalize re-find re-groups ' +
 
147
        're-matcher re-matches re-pattern re-seq read read-line read-string ' +
 
148
        'reduce ref ref-history-count ref-max-history ref-min-history ref-set ' +
 
149
        'refer refer-clojure release-pending-sends rem remove remove-method ' +
 
150
        'remove-ns remove-watch repeat repeatedly replace replicate require ' +
 
151
        'reset! reset-meta! resolve rest resultset-seq reverse reversible? rseq ' +
 
152
        'rsubseq second select-keys send send-off seq seq? seque sequence ' +
 
153
        'sequential? set set-validator! set? short short-array shorts ' +
 
154
        'shutdown-agents slurp some sort sort-by sorted-map sorted-map-by ' +
 
155
        'sorted-set sorted-set-by sorted? special-form-anchor special-symbol? ' +
 
156
        'split-at split-with str stream? string? struct struct-map subs subseq ' +
 
157
        'subvec supers swap! symbol symbol? sync syntax-symbol-anchor take ' +
 
158
        'take-last take-nth take-while test the-ns time to-array to-array-2d ' +
 
159
        'trampoline transient tree-seq true? type unchecked-add unchecked-dec ' +
 
160
        'unchecked-divide unchecked-inc unchecked-multiply unchecked-negate ' +
 
161
        'unchecked-remainder unchecked-subtract underive unquote ' +
 
162
        'unquote-splicing update-in update-proxy use val vals var-get var-set ' +
 
163
        'var? vary-meta vec vector vector? when when-first when-let when-not ' +
 
164
        'while with-bindings with-bindings* with-in-str with-loading-context ' +
 
165
        'with-local-vars with-meta with-open with-out-str with-precision xml-seq ' +
 
166
        'zero? zipmap'
 
167
    );
 
168
 
 
169
    var keywords = ('throw try var ' +
 
170
        'def do fn if let loop monitor-enter monitor-exit new quote recur set!'
 
171
    );
 
172
 
 
173
    var buildinConstants = ("true false nil");
 
174
 
 
175
    var keywordMapper = this.createKeywordMapper({
 
176
        "keyword": keywords,
 
177
        "constant.language": buildinConstants,
 
178
        "support.function": builtinFunctions
 
179
    }, "identifier", false, " ");
 
180
 
 
181
    this.$rules = {
 
182
        "start" : [
 
183
            {
 
184
                token : "comment",
 
185
                regex : ";.*$"
 
186
            }, {
 
187
                token : "keyword", //parens
 
188
                regex : "[\\(|\\)]"
 
189
            }, {
 
190
                token : "keyword", //lists
 
191
                regex : "[\\'\\(]"
 
192
            }, {
 
193
                token : "keyword", //vectors
 
194
                regex : "[\\[|\\]]"
 
195
            }, {
 
196
                token : "keyword", //sets and maps
 
197
                regex : "[\\{|\\}|\\#\\{|\\#\\}]"
 
198
            }, {
 
199
                    token : "keyword", // ampersands
 
200
                    regex : '[\\&]'
 
201
            }, {
 
202
                    token : "keyword", // metadata
 
203
                    regex : '[\\#\\^\\{]'
 
204
            }, {
 
205
                    token : "keyword", // anonymous fn syntactic sugar
 
206
                    regex : '[\\%]'
 
207
            }, {
 
208
                    token : "keyword", // deref reader macro
 
209
                    regex : '[@]'
 
210
            }, {
 
211
                token : "constant.numeric", // hex
 
212
                regex : "0[xX][0-9a-fA-F]+\\b"
 
213
            }, {
 
214
                token : "constant.numeric", // float
 
215
                regex : "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
 
216
            }, {
 
217
                token : "constant.language",
 
218
                regex : '[!|\\$|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+||=|!=|<=|>=|<>|<|>|!|&&]'
 
219
            }, {
 
220
                token : keywordMapper,
 
221
                regex : "[a-zA-Z_$][a-zA-Z0-9_$\\-]*\\b"
 
222
            }, {
 
223
                token : "string", // single line
 
224
                regex : '"',
 
225
                next: "string"
 
226
            }, {
 
227
                token : "string", // symbol
 
228
                regex : /:[\w*+!\-_?:\/]+/
 
229
            }, {
 
230
                token : "string.regexp", //Regular Expressions
 
231
                regex : '/#"(?:\\.|(?:\\\")|[^\""\n])*"/g'
 
232
            }
 
233
 
 
234
        ],
 
235
        "string" : [
 
236
            {
 
237
                token : "constant.language.escape",                
 
238
                regex : "\\\\.|\\\\$"
 
239
            }, {
 
240
                token : "string",                
 
241
                regex : '[^"\\\\]+'
 
242
            }, {
 
243
                token : "string",
 
244
                regex : '"',
 
245
                next : "start"
 
246
            }
 
247
        ]
 
248
    };
 
249
};
 
250
 
 
251
oop.inherits(ClojureHighlightRules, TextHighlightRules);
 
252
 
 
253
exports.ClojureHighlightRules = ClojureHighlightRules;
 
254
});
 
255
 
 
256
define('ace/mode/matching_parens_outdent', ['require', 'exports', 'module' , 'ace/range'], function(require, exports, module) {
 
257
 
 
258
 
 
259
var Range = require("../range").Range;
 
260
 
 
261
var MatchingParensOutdent = function() {};
 
262
 
 
263
(function() {
 
264
 
 
265
    this.checkOutdent = function(line, input) {
 
266
        if (! /^\s+$/.test(line))
 
267
            return false;
 
268
 
 
269
        return /^\s*\)/.test(input);
 
270
    };
 
271
 
 
272
    this.autoOutdent = function(doc, row) {
 
273
        var line = doc.getLine(row);
 
274
        var match = line.match(/^(\s*\))/);
 
275
 
 
276
        if (!match) return 0;
 
277
 
 
278
        var column = match[1].length;
 
279
        var openBracePos = doc.findMatchingBracket({row: row, column: column});
 
280
 
 
281
        if (!openBracePos || openBracePos.row == row) return 0;
 
282
 
 
283
        var indent = this.$getIndent(doc.getLine(openBracePos.row));
 
284
        doc.replace(new Range(row, 0, row, column-1), indent);
 
285
    };
 
286
 
 
287
    this.$getIndent = function(line) {
 
288
        var match = line.match(/^(\s+)/);
 
289
        if (match) {
 
290
            return match[1];
 
291
        }
 
292
 
 
293
        return "";
 
294
    };
 
295
 
 
296
}).call(MatchingParensOutdent.prototype);
 
297
 
 
298
exports.MatchingParensOutdent = MatchingParensOutdent;
 
299
});