index.html
22.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
<!doctype html>
<title>CodeMirror: CoffeeScript 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="coffeescript.js"></script>
<style>
.CodeMirror {
border-top: 1px solid silver;
border-bottom: 1px solid silver;
}
</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="#">CoffeeScript</a>
</ul>
</div>
<article>
<h2>CoffeeScript mode</h2>
<form>
<textarea id="code" name="code"> # CoffeeScript mode for CodeMirror # Copyright (c) 2011 Jeff Pickhardt, released under # the MIT License. # # Modified from the Python CodeMirror mode, which also is # under the MIT License Copyright (c) 2010 Timothy Farrell. # # The following
script, Underscore.coffee, is used to # demonstrate CoffeeScript mode for CodeMirror. # # To download CoffeeScript mode for CodeMirror, go to: # https://github.com/pickhardt/coffeescript-codemirror-mode # **Underscore.coffee # (c) 2011 Jeremy
Ashkenas, DocumentCloud Inc.** # Underscore is freely distributable under the terms of the # [MIT license](http://en.wikipedia.org/wiki/MIT_License). # Portions of Underscore are inspired by or borrowed from # [Prototype.js](http://prototypejs.org/api),
Oliver Steele's # [Functional](http://osteele.com), and John Resig's # [Micro-Templating](http://ejohn.org). # For all details and documentation: # http://documentcloud.github.com/underscore/ # Baseline setup # -------------- # Establish the
root object, `window` in the browser, or `global` on the server. root = this # Save the previous value of the `_` variable. previousUnderscore = root._ ### Multiline comment ### # Establish the object that gets thrown to break out of a loop
iteration. # `StopIteration` is SOP on Mozilla. breaker = if typeof(StopIteration) is 'undefined' then '__break__' else StopIteration #### Docco style single line comment (title) # Helper function to escape **RegExp** contents, because JS
doesn't have one. escapeRegExp = (string) -> string.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1') # Save bytes in the minified (but not gzipped) version: ArrayProto = Array.prototype ObjProto = Object.prototype # Create quick reference variables
for speed access to core prototypes. slice = ArrayProto.slice unshift = ArrayProto.unshift toString = ObjProto.toString hasOwnProperty = ObjProto.hasOwnProperty propertyIsEnumerable = ObjProto.propertyIsEnumerable # All **ECMA5** native implementations
we hope to use are declared here. nativeForEach = ArrayProto.forEach nativeMap = ArrayProto.map nativeReduce = ArrayProto.reduce nativeReduceRight = ArrayProto.reduceRight nativeFilter = ArrayProto.filter nativeEvery = ArrayProto.every nativeSome
= ArrayProto.some nativeIndexOf = ArrayProto.indexOf nativeLastIndexOf = ArrayProto.lastIndexOf nativeIsArray = Array.isArray nativeKeys = Object.keys # Create a safe reference to the Underscore object for use below. _ = (obj) -> new wrapper(obj)
# Export the Underscore object for **CommonJS**. if typeof(exports) != 'undefined' then exports._ = _ # Export Underscore to global scope. root._ = _ # Current version. _.VERSION = '1.1.0' # Collection Functions # -------------------- # The
cornerstone, an **each** implementation. # Handles objects implementing **forEach**, arrays, and raw objects. _.each = (obj, iterator, context) -> try if nativeForEach and obj.forEach is nativeForEach obj.forEach iterator, context else if
_.isNumber obj.length iterator.call context, obj[i], i, obj for i in [0...obj.length] else iterator.call context, val, key, obj for own key, val of obj catch e throw e if e isnt breaker obj # Return the results of applying the iterator to
each element. Use JavaScript # 1.6's version of **map**, if possible. _.map = (obj, iterator, context) -> return obj.map(iterator, context) if nativeMap and obj.map is nativeMap results = [] _.each obj, (value, index, list) -> results.push
iterator.call context, value, index, list results # **Reduce** builds up a single result from a list of values. Also known as # **inject**, or **foldl**. Uses JavaScript 1.8's version of **reduce**, if possible. _.reduce = (obj, iterator,
memo, context) -> if nativeReduce and obj.reduce is nativeReduce iterator = _.bind iterator, context if context return obj.reduce iterator, memo _.each obj, (value, index, list) -> memo = iterator.call context, memo, value, index, list memo
# The right-associative version of **reduce**, also known as **foldr**. Uses # JavaScript 1.8's version of **reduceRight**, if available. _.reduceRight = (obj, iterator, memo, context) -> if nativeReduceRight and obj.reduceRight is nativeReduceRight
iterator = _.bind iterator, context if context return obj.reduceRight iterator, memo reversed = _.clone(_.toArray(obj)).reverse() _.reduce reversed, iterator, memo, context # Return the first value which passes a truth test. _.detect = (obj,
iterator, context) -> result = null _.each obj, (value, index, list) -> if iterator.call context, value, index, list result = value _.breakLoop() result # Return all the elements that pass a truth test. Use JavaScript 1.6's # **filter**, if
it exists. _.filter = (obj, iterator, context) -> return obj.filter iterator, context if nativeFilter and obj.filter is nativeFilter results = [] _.each obj, (value, index, list) -> results.push value if iterator.call context, value, index,
list results # Return all the elements for which a truth test fails. _.reject = (obj, iterator, context) -> results = [] _.each obj, (value, index, list) -> results.push value if not iterator.call context, value, index, list results # Determine
whether all of the elements match a truth test. Delegate to # JavaScript 1.6's **every**, if it is present. _.every = (obj, iterator, context) -> iterator ||= _.identity return obj.every iterator, context if nativeEvery and obj.every is nativeEvery
result = true _.each obj, (value, index, list) -> _.breakLoop() unless (result = result and iterator.call(context, value, index, list)) result # Determine if at least one element in the object matches a truth test. Use # JavaScript 1.6's **some**,
if it exists. _.some = (obj, iterator, context) -> iterator ||= _.identity return obj.some iterator, context if nativeSome and obj.some is nativeSome result = false _.each obj, (value, index, list) -> _.breakLoop() if (result = iterator.call(context,
value, index, list)) result # Determine if a given value is included in the array or object, # based on `===`. _.include = (obj, target) -> return _.indexOf(obj, target) isnt -1 if nativeIndexOf and obj.indexOf is nativeIndexOf return true
for own key, val of obj when val is target false # Invoke a method with arguments on every item in a collection. _.invoke = (obj, method) -> args = _.rest arguments, 2 (if method then val[method] else val).apply(val, args) for val in obj #
Convenience version of a common use case of **map**: fetching a property. _.pluck = (obj, key) -> _.map(obj, (val) -> val[key]) # Return the maximum item or (item-based computation). _.max = (obj, iterator, context) -> return Math.max.apply(Math,
obj) if not iterator and _.isArray(obj) result = computed: -Infinity _.each obj, (value, index, list) -> computed = if iterator then iterator.call(context, value, index, list) else value computed >= result.computed and (result = {value: value,
computed: computed}) result.value # Return the minimum element (or element-based computation). _.min = (obj, iterator, context) -> return Math.min.apply(Math, obj) if not iterator and _.isArray(obj) result = computed: Infinity _.each obj,
(value, index, list) -> computed = if iterator then iterator.call(context, value, index, list) else value computed
< result.computed and (result={ value: value, computed: computed}) result.value # Sort the object 's values by a criterion produced by an iterator.
_.sortBy = (obj, iterator, context) ->
_.pluck(((_.map obj, (value, index, list) ->
{value: value, criteria: iterator.call(context, value, index, list)}
).sort((left, right) ->
a = left.criteria; b = right.criteria
if a < b then -1 else if a > b then 1 else 0
)), 'value ')
# Use a comparator function to figure out at what index an object should
# be inserted so as to maintain order. Uses binary search.
_.sortedIndex = (array, obj, iterator) ->
iterator ||= _.identity
low = 0
high = array.length
while low < high
mid = (low + high) >> 1
if iterator(array[mid]) < iterator(obj) then low = mid + 1 else high = mid
low
# Convert anything iterable into a real, live array.
_.toArray = (iterable) ->
return [] if (!iterable)
return iterable.toArray() if (iterable.toArray)
return iterable if (_.isArray(iterable))
return slice.call(iterable) if (_.isArguments(iterable))
_.values(iterable)
# Return the number of elements in an object.
_.size = (obj) -> _.toArray(obj).length
# Array Functions
# ---------------
# Get the first element of an array. Passing `n` will return the first N
# values in the array. Aliased as **head**. The `guard` check allows it to work
# with **map**.
_.first = (array, n, guard) ->
if n and not guard then slice.call(array, 0, n) else array[0]
# Returns everything but the first entry of the array. Aliased as **tail**.
# Especially useful on the arguments object. Passing an `index` will return
# the rest of the values in the array from that index onward. The `guard`
# check allows it to work with **map**.
_.rest = (array, index, guard) ->
slice.call(array, if _.isUndefined(index) or guard then 1 else index)
# Get the last element of an array.
_.last = (array) -> array[array.length - 1]
# Trim out all falsy values from an array.
_.compact = (array) -> item for item in array when item
# Return a completely flattened version of an array.
_.flatten = (array) ->
_.reduce array, (memo, value) ->
return memo.concat(_.flatten(value)) if _.isArray value
memo.push value
memo
, []
# Return a version of the array that does not contain the specified value(s).
_.without = (array) ->
values = _.rest arguments
val for val in _.toArray(array) when not _.include values, val
# Produce a duplicate-free version of the array. If the array has already
# been sorted, you have the option of using a faster algorithm.
_.uniq = (array, isSorted) ->
memo = []
for el, i in _.toArray array
memo.push el if i is 0 || (if isSorted is true then _.last(memo) isnt el else not _.include(memo, el))
memo
# Produce an array that contains every item shared between all the
# passed-in arrays.
_.intersect = (array) ->
rest = _.rest arguments
_.select _.uniq(array), (item) ->
_.all rest, (other) ->
_.indexOf(other, item) >= 0
# Zip together multiple lists into a single array -- elements that share
# an index go together.
_.zip = ->
length = _.max _.pluck arguments, 'length '
results = new Array length
for i in [0...length]
results[i] = _.pluck arguments, String i
results
# If the browser doesn't supply us with **indexOf** (I 'm looking at you, MSIE),
# we need this function. Return the position of the first occurrence of an
# item in an array, or -1 if the item is not included in the array.
_.indexOf = (array, item) ->
return array.indexOf item if nativeIndexOf and array.indexOf is nativeIndexOf
i = 0; l = array.length
while l - i
if array[i] is item then return i else i++
-1
# Provide JavaScript 1.6's **lastIndexOf**, delegating to the native function, # if possible. _.lastIndexOf=( array, item) -> return array.lastIndexOf(item) if nativeLastIndexOf and array.lastIndexOf is nativeLastIndexOf i = array.length while i if array[i] is item then return i else i-- -1 # Generate an integer Array containing an arithmetic progression. A port
of # [the native Python **range** function](http://docs.python.org/library/functions.html#range). _.range = (start, stop, step) -> a = arguments solo = a.length
<=1 i=s tart=i f solo then 0 else a[0] stop=i f solo then a[0] else a[1] step=a
[2] or 1 len=M ath.ceil((stop - start) / step) return [] if len <=0 range=n ew Array len idx=0 loop return range if (if step> 0 then i - stop else stop - i) >= 0 range[idx] = i idx++ i+= step # Function Functions # ------------------ # Create a function bound to a given object (assigning `this`, and arguments, # optionally). Binding with arguments is also known
as **curry**. _.bind = (func, obj) -> args = _.rest arguments, 2 -> func.apply obj or root, args.concat arguments # Bind all of an object's methods to that object. Useful for ensuring that # all callbacks defined on an object belong
to it. _.bindAll = (obj) -> funcs = if arguments.length > 1 then _.rest(arguments) else _.functions(obj) _.each funcs, (f) -> obj[f] = _.bind obj[f], obj obj # Delays a function for the given number of milliseconds, and then calls
# it with the arguments supplied. _.delay = (func, wait) -> args = _.rest arguments, 2 setTimeout((-> func.apply(func, args)), wait) # Memoize an expensive function by storing its results. _.memoize = (func, hasher) -> memo = {} hasher
or= _.identity -> key = hasher.apply this, arguments return memo[key] if key of memo memo[key] = func.apply this, arguments # Defers a function, scheduling it to run after the current call stack has # cleared. _.defer = (func) -> _.delay.apply
_, [func, 1].concat _.rest arguments # Returns the first function passed as an argument to the second, # allowing you to adjust arguments, run code before and after, and # conditionally execute the original function. _.wrap = (func,
wrapper) -> -> wrapper.apply wrapper, [func].concat arguments # Returns a function that is the composition of a list of functions, each # consuming the return value of the function that follows. _.compose = -> funcs = arguments ->
args = arguments for i in [funcs.length - 1..0] by -1 args = [funcs[i].apply(this, args)] args[0] # Object Functions # ---------------- # Retrieve the names of an object's properties. _.keys = nativeKeys or (obj) -> return _.range
0, obj.length if _.isArray(obj) key for key, val of obj # Retrieve the values of an object's properties. _.values = (obj) -> _.map obj, _.identity # Return a sorted list of the function names available in Underscore. _.functions =
(obj) -> _.filter(_.keys(obj), (key) -> _.isFunction(obj[key])).sort() # Extend a given object with all of the properties in a source object. _.extend = (obj) -> for source in _.rest(arguments) obj[key] = val for key, val of source
obj # Create a (shallow-cloned) duplicate of an object. _.clone = (obj) -> return obj.slice 0 if _.isArray obj _.extend {}, obj # Invokes interceptor with the obj, and then returns obj. # The primary purpose of this method is to "tap
into" a method chain, # in order to perform operations on intermediate results within the chain. _.tap = (obj, interceptor) -> interceptor obj obj # Perform a deep comparison to check if two objects are equal. _.isEqual = (a, b) ->
# Check object identity. return true if a is b # Different types? atype = typeof(a); btype = typeof(b) return false if atype isnt btype # Basic equality test (watch out for coercions). return true if `a == b` # One is falsy and the
other truthy. return false if (!a and b) or (a and !b) # One of them implements an `isEqual()`? return a.isEqual(b) if a.isEqual # Check dates' integer values. return a.getTime() is b.getTime() if _.isDate(a) and _.isDate(b) # Both
are NaN? return false if _.isNaN(a) and _.isNaN(b) # Compare regular expressions. if _.isRegExp(a) and _.isRegExp(b) return a.source is b.source and a.global is b.global and a.ignoreCase is b.ignoreCase and a.multiline is b.multiline
# If a is not an object by this point, we can't handle it. return false if atype isnt 'object' # Check for different array lengths before comparing contents. return false if a.length and (a.length isnt b.length) # Nothing else worked,
deep compare the contents. aKeys = _.keys(a); bKeys = _.keys(b) # Different object sizes? return false if aKeys.length isnt bKeys.length # Recursive comparison of contents. return false for key, val of a when !(key of b) or !_.isEqual(val,
b[key]) true # Is a given array or object empty? _.isEmpty = (obj) -> return obj.length is 0 if _.isArray(obj) or _.isString(obj) return false for own key of obj true # Is a given value a DOM element? _.isElement = (obj) -> obj and
obj.nodeType is 1 # Is a given value an array? _.isArray = nativeIsArray or (obj) -> !!(obj and obj.concat and obj.unshift and not obj.callee) # Is a given variable an arguments object? _.isArguments = (obj) -> obj and obj.callee #
Is the given value a function? _.isFunction = (obj) -> !!(obj and obj.constructor and obj.call and obj.apply) # Is the given value a string? _.isString = (obj) -> !!(obj is '' or (obj and obj.charCodeAt and obj.substr)) # Is a given
value a number? _.isNumber = (obj) -> (obj is +obj) or toString.call(obj) is '[object Number]' # Is a given value a boolean? _.isBoolean = (obj) -> obj is true or obj is false # Is a given value a Date? _.isDate = (obj) -> !!(obj and
obj.getTimezoneOffset and obj.setUTCFullYear) # Is the given value a regular expression? _.isRegExp = (obj) -> !!(obj and obj.exec and (obj.ignoreCase or obj.ignoreCase is false)) # Is the given value NaN -- this one is interesting.
`NaN != NaN`, and # `isNaN(undefined) == true`, so we make sure it's a number first. _.isNaN = (obj) -> _.isNumber(obj) and window.isNaN(obj) # Is a given value equal to null? _.isNull = (obj) -> obj is null # Is a given variable undefined?
_.isUndefined = (obj) -> typeof obj is 'undefined' # Utility Functions # ----------------- # Run Underscore.js in noConflict mode, returning the `_` variable to its # previous owner. Returns a reference to the Underscore object. _.noConflict
= -> root._ = previousUnderscore this # Keep the identity function around for default iterators. _.identity = (value) -> value # Run a function `n` times. _.times = (n, iterator, context) -> iterator.call context, i for i in [0...n]
# Break out of the middle of an iteration. _.breakLoop = -> throw breaker # Add your own custom functions to the Underscore object, ensuring that # they're correctly added to the OOP wrapper as well. _.mixin = (obj) -> for name in
_.functions(obj) addToWrapper name, _[name] = obj[name] # Generate a unique integer id (unique within the entire client session). # Useful for temporary DOM ids. idCounter = 0 _.uniqueId = (prefix) -> (prefix or '') + idCounter++ #
By default, Underscore uses **ERB**-style template delimiters, change the # following template settings to use alternative delimiters. _.templateSettings = { start: '
<%'
end: '%>' interpolate: /
<%=(.+?)%>/g } # JavaScript templating a-la **ERB**, pilfered from John Resig's # *Secrets of the JavaScript Ninja*, page 83. # Single-quote fix from Rick Strahl. # With alterations for arbitrary delimiters, and to preserve whitespace. _.template
= (str, data) -> c = _.templateSettings endMatch = new RegExp("'(?=[^"+c.end.substr(0, 1)+"]*"+escapeRegExp(c.end)+")","g") fn = new Function 'obj', 'var p=[],print=function(){p.push.apply(p,arguments);};' + 'with(obj||{}){p.push(\''
+ str.replace(/\r/g, '\\r') .replace(/\n/g, '\\n') .replace(/\t/g, '\\t') .replace(endMatch,"���") .split("'").join("\\'") .split("���").join("'") .replace(c.interpolate, "',$1,'") .split(c.start).join("');") .split(c.end).join("p.push('")
+ "');}return p.join('');" if data then fn(data) else fn # Aliases # ------- _.forEach = _.each _.foldl = _.inject = _.reduce _.foldr = _.reduceRight _.select = _.filter _.all = _.every _.any = _.some _.contains = _.include
_.head = _.first _.tail = _.rest _.methods = _.functions # Setup the OOP Wrapper # --------------------- # If Underscore is called as a function, it returns a wrapped object that # can be used OO-style. This wrapper holds altered
versions of all the # underscore functions. Wrapped objects may be chained. wrapper = (obj) -> this._wrapped = obj this # Helper function to continue chaining intermediate results. result = (obj, chain) -> if chain then _(obj).chain()
else obj # A method to easily add functions to the OOP wrapper. addToWrapper = (name, func) -> wrapper.prototype[name] = -> args = _.toArray arguments unshift.call args, this._wrapped result func.apply(_, args), this._chain
# Add all ofthe Underscore functions to the wrapper object. _.mixin _ # Add all mutator Array functions to the wrapper. _.each ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], (name) -> method = Array.prototype[name]
wrapper.prototype[name] = -> method.apply(this._wrapped, arguments) result(this._wrapped, this._chain) # Add all accessor Array functions to the wrapper. _.each ['concat', 'join', 'slice'], (name) -> method = Array.prototype[name]
wrapper.prototype[name] = -> result(method.apply(this._wrapped, arguments), this._chain) # Start chaining a wrapped Underscore object. wrapper::chain = -> this._chain = true this # Extracts the result from a wrapped and chained
object. wrapper::value = -> this._wrapped </textarea>
</form>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"),
{});
</script>
<p>
<strong>MIME types defined:</strong> <code>text/x-coffeescript</code>.</p>
<p>The CoffeeScript mode was written by Jeff Pickhardt.</p>
</article>