syntax highlighting

Author: mjrusso

README.md

@@ -79,9 +79,10 @@ UTF-8 is the preferred source file encoding.
 
 If using a module system (CommonJS Modules, AMD, etc.), `require` statements should be placed on separate lines.
 
+    ```coffeescript
     require 'lib/setup'
     Backbone = require 'backbone'
-
+    ```
 These statements should be grouped in the following order:
 
 1. Standard library imports _(if a standard library exists)_
@@ -95,13 +96,17 @@ Avoid extraneous whitespace in the following situations:
 
 - Immediately inside parentheses, brackets or braces
 
+          ```coffeescript
           ($ 'body') # Yes
           ( $ 'body' ) # No
+          ```
 
 - Immediately before a comma
 
+          ```coffeescript
           console.log x, y # Yes
           console.log x , y # No
+          ```
 
 Additional recommendations:
 
@@ -114,6 +119,7 @@ Additional recommendations:
 
     - _(Do not use more than one space around these operators)_
 
+              ```coffeescript
               # Yes
               x = 1
               y = 1
@@ -123,11 +129,14 @@ Additional recommendations:
               x      = 1
               y      = 1
               fooBar = 3
+              ```
 
 - Do not use spaces around the `=` sign when used to indicate a default parameter value
 
+          ```coffeescript
           test: (param=null) -> # Yes
           test: (param = null) -> # No
+          ```
 
 <a name="comments"/>
 ## Comments
@@ -147,6 +156,7 @@ Each line of a block comment starts with a `#` and a single space, and should be
 
 Paragraphs inside of block comments are separated by a line containing a single `#`.
 
+    ```coffeescript
     # This is a block comment. Note that if this were a real block
     # comment, we would actually be describing the proceeding code.
     #
@@ -157,6 +167,7 @@ Paragraphs inside of block comments are separated by a line containing a single
     init()
     start()
     stop()
+    ```
 
 <a name="inline_comments"/>
 ### Inline Comments
@@ -169,13 +180,17 @@ The use of inline comments should be limited, because their existence is typical
 
 Do not use inline comments when they state the obvious:
 
+    ```coffeescript
     # No
     x = x + 1 # Increment x
+    ```
 
 However, inline comments can be useful in certain scenarios:
 
+    ```coffeescript
     # Yes
     x = x + 1 # Compensate for border
+    ```
 
 <a name="naming_conventions"/>
 ## Naming Conventions
@@ -188,11 +203,15 @@ _(The **official** CoffeeScript convention is camelcase, because this simplifies
 
 For constants, use all uppercase with underscores:
 
-      CONSTANT_LIKE_THIS
+    ```coffeescript
+    CONSTANT_LIKE_THIS
+    ```
 
 Methods and variables that are intended to be "private" should begin with a leading underscore:
 
-      _privateMethod: ->
+    ```coffeescript
+    _privateMethod: ->
+    ```
 
 <a name="functions"/>
 ## Functions
@@ -201,44 +220,58 @@ _(These guidelines also apply to the methods of a class.)_
 
 When declaring a function that takes arguments, always use a single space after the closing parenthesis of the arguments list:
 
+    ```coffeescript
     foo = (arg1, arg2) -> # Yes
     foo = (arg1, arg2)-> # No
+    ```
 
 Do not use parentheses when declaring functions that take no arguments:
 
+    ```coffeescript
     bar = -> # Yes
     bar = () -> # No
+    ```
 
 In cases where method calls are being chained and the code does not fit on a single line, each call should be placed on a separate line and indented by one level (i.e., two spaces), with a leading `.`.
 
+    ```coffeescript
     [1..3]
       .map((x) -> x * x)
       .concat([10..12])
       .filter((x) -> x < 11)
       .reduce((x, y) -> x + y)
+    ```
 
 When calling functions, omit the parentheses on the final method call in a chain. For example:
 
+    ```coffeescript
     baz 12
 
     foo(4).bar 8
+    ```
 
 You will sometimes see parentheses used to group functions (instead of being used to group function parameters). Examples of using this style (hereafter referred to as the "function grouping style"):
 
+    ```coffeescript
     ($ '#selektor').addClass 'klass'
 
     (foo 4).bar 8
+    ```
 
 This is in contrast to:
 
+    ```coffeescript
     $('#selektor').addClass 'klass'
 
     foo(4).bar 8
+    ```
 
 The correct way to apply the function grouping style when chaining is to use it for the initial call only:
 
+    ```coffeescript
     ($ '#selektor').addClass('klass').hide() # Yes
     ($ '#selektor').(addClass 'klass').hide() # No
+    ```
 
 This guide does not prescribe the use of the function grouping style or the alternative. However, **if the function grouping style is adopted for a particular project, be consistent with its usage.**
 
@@ -247,8 +280,10 @@ This guide does not prescribe the use of the function grouping style or the alte
 
 Use string interpolation instead of string concatenation:
 
+    ```coffeescript
     "this is an #{adjective} string" # Yes
     "this is an " + adjective + " string" # No
+    ```
 
 Prefer single quoted strings (`''`) instead of double quoted (`""`) strings, unless features like string interpolation are being used for the given string.
 
@@ -259,51 +294,61 @@ Favor `unless` over `if` for negative conditions.
 
 Instead of using `unless...else`, use `if...else`:
 
-      # Yes
-      if true
-        ...
-      else
-        ...
+    ```coffeescript
+    # Yes
+    if true
+      ...
+    else
+      ...
 
-      # No
-      unless false
-        ...
-      else
-        ...
+    # No
+    unless false
+      ...
+    else
+      ...
+    ```
 
 Multi-line if/else clauses should use indentation:
 
-      # Yes
-      if true
-        ...
-      else
-        ...
+    ```coffeescript
+    # Yes
+    if true
+      ...
+    else
+      ...
 
-      # No
-      if true then ...
-      else ...
+    # No
+    if true then ...
+    else ...
+    ```
 
 <a name="looping_and_comprehensions"/>
 ## Looping and Comprehensions
 
 Take advantage of comprehensions whenever possible:
 
+    ```coffeescript
     # Yes
     result = (item.name for item in array)
 
     # No
     results = []
     for item in array
       results.push item.name
+    ```
 
 To filter:
 
-      result = (item for item in array when item.name is "test")
+    ```coffeescript
+    result = (item for item in array when item.name is "test")
+    ```
 
 To iterate over the keys and values of objects:
 
-      object = one: 1, two: 2
-      alert("#{key} = #{value}") for key, value of object
+    ```coffeescript
+    object = one: 1, two: 2
+    alert("#{key} = #{value}") for key, value of object
+    ```
 
 <a name="#extending_native_objects"/>
 ## Extending Native Objects
@@ -326,15 +371,19 @@ Write the annotation on the line immediately above the code that the annotation
 
 The annotation keyword should be followed by a colon and a space, and a descriptive note.
 
+    ```coffeescript
     # FIXME: The client's current state should *not* affect payload processing.
     resetClientState()
     processPayload()
+    ```
 
 If multiple lines are required by the description, indent subsequent lines with two spaces:
 
+    ```coffeescript
     # TODO: Ensure that the value returned by this call falls within a certain
     #   range, or throw an exception.
     analyze()
+    ```
 
 Annotation types:
 
@@ -359,23 +408,29 @@ If a custom annotation is required, the annotation should be documented in the p
 
 `or=` should be used when possible:
 
-      temp or= {} # Yes
-      temp = temp || {} # No
+    ```coffeescript
+    temp or= {} # Yes
+    temp = temp || {} # No
+    ```
 
 Prefer shorthand notation (`::`) for accessing an object's prototype:
 
-      Array::slice # Yes
-      Array.prototype.slice # No
+    ```coffeescript
+    Array::slice # Yes
+    Array.prototype.slice # No
+    ```coffeescript
 
 Prefer `@property` over `this.property`.
 
 Avoid `return` where not required, unless the explicit return increases clarity.
 
 Use splats (`...`) when working with functions that accept variable numbers of arguments:
 
-      console.log args... # Yes
+    ```coffeescript
+    console.log args... # Yes
 
-      (a, b, c, rest...) -> # Yes
+    (a, b, c, rest...) -> # Yes
+    ```
 
 [coffeescript]: http://jashkenas.github.com/coffee-script/
 [coffeescript-issue-425]: https://github.com/jashkenas/coffee-script/issues/425