<!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 © 2011 Jeff Pickhardt, released under # the MIT License. # # Modified from the Python CodeMirror mode, which also is # under the MIT License Copyright © 2010 Timothy Farrell. # # The following script, Underscore.coffee, is used to # demonstrate CoffeeScript mode for CodeMirror. # # To download CoffeeScript mode for CodeMirror, go to: # github.com/pickhardt/coffeescript-codemirror-mode

# **Underscore.coffee # © 2011 Jeremy Ashkenas, DocumentCloud Inc.** # Underscore is freely distributable under the terms of the # [MIT license](en.wikipedia.org/wiki/MIT_License). # Portions of Underscore are inspired by or borrowed from # [Prototype.js](prototypejs.org/api), Oliver Steele's # [Functional](osteele.com), and John Resig's # [Micro-Templating](ejohn.org). # For all details and documentation: # 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](docs.python.org/library/functions.html#range). _.range = (start, stop, step) ->

a = arguments
solo = a.length <= 1
i = start = if solo then 0 else a[0]
stop = if solo then a[0] else a[1]
step = a[2] or 1
len = Math.ceil((stop - start) / step)
return [] if len <= 0
range = new 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>