github/coffeescript
1
1
Fork 0
mirror of https://github.com/jashkenas/coffeescript.git synced 2026-05-03 03:00:14 -04:00
Code Issues Packages Projects Releases Wiki Activity

2.1.0 (#4823)

Browse Source 
* Changelog for 2.1.0; remove text from objects section that is no longer valid for CS2/ES2015.

* Update packages

* 2.1.0 build

* Update output

* Correct reference to `//` division, per https://github.com/coffeescript6/discuss/issues/39#issuecomment-347144647
This commit is contained in:
Geoffrey Booth
2017-12-10 23:12:33 -08:00
committed by GitHub
parent b1286752b9
commit 926cb8463c
26 changed files with 1621 additions and 781 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
docs/v2/annotated-source/grammar.html
View File

@@ -558,6 +558,7 @@ the ordinary <strong>Assign</strong> is that these allow numbers and strings as
o <span class="hljs-string">'Identifier'</span>
o <span class="hljs-string">'Property'</span>
o <span class="hljs-string">'ThisProperty'</span>
o <span class="hljs-string">'[ Expression ]'</span>, <span class="hljs-function">-&gt;</span> <span class="hljs-keyword">new</span> Value <span class="hljs-keyword">new</span> ComputedPropertyName $<span class="hljs-number">2</span>
]
ObjAssignable: [
@@ -1133,7 +1134,8 @@ and optional references to the superclass.</p>
<div class="content"><div class='highlight'><pre> Array: [
o <span class="hljs-string">'[ ]'</span>, <span class="hljs-function">-&gt;</span> <span class="hljs-keyword">new</span> Arr []
o <span class="hljs-string">'[ ArgList OptComma ]'</span>, <span class="hljs-function">-&gt;</span> <span class="hljs-keyword">new</span> Arr $<span class="hljs-number">2</span>
o <span class="hljs-string">'[ Elisions ]'</span>, <span class="hljs-function">-&gt;</span> <span class="hljs-keyword">new</span> Arr $<span class="hljs-number">2</span>
o <span class="hljs-string">'[ ArgElisionList OptElisions ]'</span>, <span class="hljs-function">-&gt;</span> <span class="hljs-keyword">new</span> Arr [].concat $<span class="hljs-number">2</span>, $<span class="hljs-number">3</span>
]</pre></div></div>
</li>
@@ -1200,8 +1202,7 @@ and optional references to the superclass.</p>
<div class="pilwrap ">
<a class="pilcrow" href="#section-49">&#182;</a>
</div>
<p>The <strong>ArgList</strong> is both the list of objects passed into a function call,
as well as the contents of an array literal
<p>The <strong>ArgList</strong> is the list of objects passed into a function call
(i.e. comma-separated expressions). Newlines work as well.</p>
</div>
@@ -1242,6 +1243,47 @@ as well as the contents of an array literal
<div class="pilwrap ">
<a class="pilcrow" href="#section-51">&#182;</a>
</div>
<p>The <strong>ArgElisionList</strong> is the list of objects, contents of an array literal
(i.e. comma-separated expressions and elisions). Newlines work as well.</p>
</div>
<div class="content"><div class='highlight'><pre> ArgElisionList: [
o <span class="hljs-string">'ArgElision'</span>
o <span class="hljs-string">'ArgElisionList , ArgElision'</span>, <span class="hljs-function">-&gt;</span> $<span class="hljs-number">1.</span>concat $<span class="hljs-number">3</span>
o <span class="hljs-string">'ArgElisionList OptElisions TERMINATOR ArgElision'</span>, <span class="hljs-function">-&gt;</span> $<span class="hljs-number">1.</span>concat $<span class="hljs-number">2</span>, $<span class="hljs-number">4</span>
o <span class="hljs-string">'INDENT ArgElisionList OptElisions OUTDENT'</span>, <span class="hljs-function">-&gt;</span> $<span class="hljs-number">2.</span>concat $<span class="hljs-number">3</span>
o <span class="hljs-string">'ArgElisionList OptElisions INDENT ArgElisionList OptElisions OUTDENT'</span>, <span class="hljs-function">-&gt;</span> $<span class="hljs-number">1.</span>concat $<span class="hljs-number">2</span>, $<span class="hljs-number">4</span>, $<span class="hljs-number">5</span>
]
ArgElision: [
o <span class="hljs-string">'Arg'</span>, <span class="hljs-function">-&gt;</span> [$<span class="hljs-number">1</span>]
o <span class="hljs-string">'Elisions Arg'</span>, <span class="hljs-function">-&gt;</span> $<span class="hljs-number">1.</span>concat $<span class="hljs-number">2</span>
]
OptElisions: [
o <span class="hljs-string">'OptComma'</span>, <span class="hljs-function">-&gt;</span> []
o <span class="hljs-string">', Elisions'</span>, <span class="hljs-function">-&gt;</span> [].concat $<span class="hljs-number">2</span>
]
Elisions: [
o <span class="hljs-string">'Elision'</span>, <span class="hljs-function">-&gt;</span> [$<span class="hljs-number">1</span>]
o <span class="hljs-string">'Elisions Elision'</span>, <span class="hljs-function">-&gt;</span> $<span class="hljs-number">1.</span>concat $<span class="hljs-number">2</span>
]
Elision: [
o <span class="hljs-string">','</span>, <span class="hljs-function">-&gt;</span> <span class="hljs-keyword">new</span> Elision
]</pre></div></div>
</li>
<li id="section-52">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-52">&#182;</a>
</div>
<p>Just simple, comma-separated, required arguments (no fancy syntax). We need
this to be separate from the <strong>ArgList</strong> for use in <strong>Switch</strong> blocks, where
having the newlines wouldn’t make sense.</p>
@@ -1256,11 +1298,11 @@ having the newlines wouldn’t make sense.</p>
</li>
<li id="section-52">
<li id="section-53">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-52">&#182;</a>
<a class="pilcrow" href="#section-53">&#182;</a>
</div>
<p>The variants of <em>try/catch/finally</em> exception handling blocks.</p>
@@ -1276,11 +1318,11 @@ having the newlines wouldn’t make sense.</p>
</li>
<li id="section-53">
<li id="section-54">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-53">&#182;</a>
<a class="pilcrow" href="#section-54">&#182;</a>
</div>
<p>A catch clause names its error and runs a block of code.</p>
@@ -1295,11 +1337,11 @@ having the newlines wouldn’t make sense.</p>
</li>
<li id="section-54">
<li id="section-55">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-54">&#182;</a>
<a class="pilcrow" href="#section-55">&#182;</a>
</div>
<p>Throw an exception object.</p>
@@ -1313,11 +1355,11 @@ having the newlines wouldn’t make sense.</p>
</li>
<li id="section-55">
<li id="section-56">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-55">&#182;</a>
<a class="pilcrow" href="#section-56">&#182;</a>
</div>
<p>Parenthetical expressions. Note that the <strong>Parenthetical</strong> is a <strong>Value</strong>,
not an <strong>Expression</strong>, so if you need to use an expression in a place
@@ -1334,11 +1376,11 @@ the trick.</p>
</li>
<li id="section-56">
<li id="section-57">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-56">&#182;</a>
<a class="pilcrow" href="#section-57">&#182;</a>
</div>
<p>The condition portion of a while loop.</p>
@@ -1354,11 +1396,11 @@ the trick.</p>
</li>
<li id="section-57">
<li id="section-58">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-57">&#182;</a>
<a class="pilcrow" href="#section-58">&#182;</a>
</div>
<p>The while loop can either be normal, with a block of expressions to execute,
or postfix, with a single expression. There is no do..while.</p>
@@ -1380,11 +1422,11 @@ or postfix, with a single expression. There is no do..while.</p>
</li>
<li id="section-58">
<li id="section-59">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-58">&#182;</a>
<a class="pilcrow" href="#section-59">&#182;</a>
</div>
<p>Array, object, and range comprehensions, at the most generic level.
Comprehensions can either be normal, with a block of expressions to execute,
@@ -1412,11 +1454,11 @@ or postfix, with a single expression.</p>
</li>
<li id="section-59">
<li id="section-60">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-59">&#182;</a>
<a class="pilcrow" href="#section-60">&#182;</a>
</div>
<p>An array of all accepted values for a variable inside the loop.
This enables support for pattern matching.</p>
@@ -1433,11 +1475,11 @@ This enables support for pattern matching.</p>
</li>
<li id="section-60">
<li id="section-61">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-60">&#182;</a>
<a class="pilcrow" href="#section-61">&#182;</a>
</div>
<p>An array or range comprehension has variables for the current element
and (optional) reference to the current index. Or, <em>key, value</em>, in the case
@@ -1453,11 +1495,11 @@ of object comprehensions.</p>
</li>
<li id="section-61">
<li id="section-62">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-61">&#182;</a>
<a class="pilcrow" href="#section-62">&#182;</a>
</div>
<p>The source of a comprehension is an array or object with an optional guard
clause. If it’s an array comprehension, you can also choose to step through
@@ -1492,11 +1534,11 @@ in fixed-size increments.</p>
</li>
<li id="section-62">
<li id="section-63">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-62">&#182;</a>
<a class="pilcrow" href="#section-63">&#182;</a>
</div>
<p>An individual <strong>When</strong> clause, with action.</p>
@@ -1510,11 +1552,11 @@ in fixed-size increments.</p>
</li>
<li id="section-63">
<li id="section-64">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-63">&#182;</a>
<a class="pilcrow" href="#section-64">&#182;</a>
</div>
<p>The most basic form of <em>if</em> is a condition and an action. The following
if-related rules are broken up along these lines in order to avoid
@@ -1530,11 +1572,11 @@ ambiguity.</p>
</li>
<li id="section-64">
<li id="section-65">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-64">&#182;</a>
<a class="pilcrow" href="#section-65">&#182;</a>
</div>
<p>The full complement of <em>if</em> expressions, including postfix one-liner
<em>if</em> and <em>unless</em>.</p>
@@ -1551,11 +1593,11 @@ ambiguity.</p>
</li>
<li id="section-65">
<li id="section-66">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-65">&#182;</a>
<a class="pilcrow" href="#section-66">&#182;</a>
</div>
<p>Arithmetic and logical operators, working on one or more operands.
Here they are grouped by order of precedence. The actual precedence rules
@@ -1582,11 +1624,11 @@ rules are necessary.</p>
</li>
<li id="section-66">
<li id="section-67">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-66">&#182;</a>
<a class="pilcrow" href="#section-67">&#182;</a>
</div>
<p><a href="http://coffeescript.org/#existential-operator">The existential operator</a>.</p>
@@ -1624,26 +1666,14 @@ rules are necessary.</p>
</li>
<li id="section-67">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-67">&#182;</a>
</div>
<h2 id="precedence">Precedence</h2>
</div>
</li>
<li id="section-68">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-68">&#182;</a>
</div>
<h2 id="precedence">Precedence</h2>
</div>
</li>
@@ -1655,6 +1685,18 @@ rules are necessary.</p>
<div class="pilwrap ">
<a class="pilcrow" href="#section-69">&#182;</a>
</div>
</div>
</li>
<li id="section-70">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-70">&#182;</a>
</div>
<p>Operators at the top of this list have higher precedence than the ones lower
down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
<pre><code><span class="hljs-number">2</span> + (<span class="hljs-number">3</span> * <span class="hljs-number">4</span>)
@@ -1694,26 +1736,14 @@ down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
</li>
<li id="section-70">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-70">&#182;</a>
</div>
<h2 id="wrapping-up">Wrapping Up</h2>
</div>
</li>
<li id="section-71">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-71">&#182;</a>
</div>
<h2 id="wrapping-up">Wrapping Up</h2>
</div>
</li>
@@ -1725,6 +1755,18 @@ down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
<div class="pilwrap ">
<a class="pilcrow" href="#section-72">&#182;</a>
</div>
</div>
</li>
<li id="section-73">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-73">&#182;</a>
</div>
<p>Finally, now that we have our <strong>grammar</strong> and our <strong>operators</strong>, we can create
our <strong>Jison.Parser</strong>. We do this by processing all of our rules, recording all
terminals (every symbol which does not appear as the name of a rule above)
@@ -1743,11 +1785,11 @@ as “tokens”.</p>
</li>
<li id="section-73">
<li id="section-74">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-73">&#182;</a>
<a class="pilcrow" href="#section-74">&#182;</a>
</div>
<p>Initialize the <strong>Parser</strong> with our list of terminal <strong>tokens</strong>, our <strong>grammar</strong>
rules, and the name of the root. Reverse the operators because Jison orders

168
docs/v2/annotated-source/lexer.html
View File

@@ -1121,7 +1121,7 @@ comments that trail it.</p>
<div class="content"><div class='highlight'><pre> prevChar = <span class="hljs-keyword">if</span> @tokens.length &gt; <span class="hljs-number">0</span> <span class="hljs-keyword">then</span> @tokens[@tokens.length - <span class="hljs-number">1</span>][<span class="hljs-number">0</span>] <span class="hljs-keyword">else</span> <span class="hljs-string">''</span>
<span class="hljs-keyword">if</span> firstChar <span class="hljs-keyword">is</span> <span class="hljs-string">'&lt;'</span>
match = CSX_IDENTIFIER.exec @chunk[<span class="hljs-number">1.</span>..]
match = CSX_IDENTIFIER.exec(@chunk[<span class="hljs-number">1.</span>..]) <span class="hljs-keyword">or</span> CSX_FRAGMENT_IDENTIFIER.exec(@chunk[<span class="hljs-number">1.</span>..])
<span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> match <span class="hljs-keyword">and</span> (
@csxDepth &gt; <span class="hljs-number">0</span> <span class="hljs-keyword">or</span></pre></div></div>
@@ -1187,8 +1187,8 @@ comments that trail it.</p>
@matchWithInterpolations INSIDE_CSX, <span class="hljs-string">'&gt;'</span>, <span class="hljs-string">'&lt;/'</span>, CSX_INTERPOLATION
@mergeInterpolationTokens tokens, {delimiter: <span class="hljs-string">'"'</span>}, <span class="hljs-function"><span class="hljs-params">(value, i)</span> =&gt;</span>
@formatString value, delimiter: <span class="hljs-string">'&gt;'</span>
match = CSX_IDENTIFIER.exec @chunk[end...]
<span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> match <span class="hljs-keyword">or</span> match[<span class="hljs-number">0</span>] <span class="hljs-keyword">isnt</span> csxTag.name
match = CSX_IDENTIFIER.exec(@chunk[end...]) <span class="hljs-keyword">or</span> CSX_FRAGMENT_IDENTIFIER.exec(@chunk[end...])
<span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> match <span class="hljs-keyword">or</span> match[<span class="hljs-number">1</span>] <span class="hljs-keyword">isnt</span> csxTag.name
@error <span class="hljs-string">"expected corresponding CSX closing tag for <span class="hljs-subst">#{csxTag.name}</span>"</span>,
csxTag.origin[<span class="hljs-number">2</span>]
afterTag = end + csxTag.name.length
@@ -2458,6 +2458,23 @@ be used as identifiers or properties.</p>
CSX_IDENTIFIER = <span class="hljs-regexp">/// ^
(?![\d&lt;]) <span class="hljs-comment"># Must not start with `&lt;`.</span>
( (?: (?!\s)[\.\-$\w\x7f-\uffff] )+ ) <span class="hljs-comment"># Like `IDENTIFIER`, but includes `-`s and `.`s.</span>
///</span></pre></div></div>
</li>
<li id="section-98">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-98">&#182;</a>
</div>
<p>Fragment: &lt;&gt;&lt;/&gt;</p>
</div>
<div class="content"><div class='highlight'><pre>CSX_FRAGMENT_IDENTIFIER = <span class="hljs-regexp">/// ^
()&gt; <span class="hljs-comment"># Ends immediately with `&gt;`.</span>
///</span>
CSX_ATTRIBUTE = <span class="hljs-regexp">/// ^
@@ -2497,11 +2514,11 @@ HERE_JSTOKEN = <span class="hljs-regexp">///^ ``` ((?: [^`\\] | \\[\s\S] | `
</li>
<li id="section-98">
<li id="section-99">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-98">&#182;</a>
<a class="pilcrow" href="#section-99">&#182;</a>
</div>
<p>String-matching-regexes.</p>
@@ -2535,11 +2552,11 @@ HEREDOC_INDENT = <span class="hljs-regexp">/\n+([^\n\S]*)(?=\S)/g</span></pr
</li>
<li id="section-99">
<li id="section-100">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-99">&#182;</a>
<a class="pilcrow" href="#section-100">&#182;</a>
</div>
<p>Regex-matching-regexes.</p>
@@ -2558,7 +2575,86 @@ HEREDOC_INDENT = <span class="hljs-regexp">/\n+([^\n\S]*)(?=\S)/g</span></pr
REGEX_FLAGS = <span class="hljs-regexp">/^\w*/</span>
VALID_FLAGS = <span class="hljs-regexp">/^(?!.*(.).*\1)[imguy]*$/</span>
HEREGEX = <span class="hljs-regexp">/// ^(?: [^\\/<span class="hljs-comment">#] | \\[\s\S] | /(?!//) | \#(?!\{) )* ///</span>
HEREGEX = <span class="hljs-regexp">/// ^
(?:
</span></pre></div></div>
</li>
<li id="section-101">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-101">&#182;</a>
</div>
<p>Match any character, except those that need special handling below.</p>
</div>
<div class="content"><div class='highlight'><pre> [^\\/<span class="hljs-comment">#\s]</span></pre></div></div>
</li>
<li id="section-102">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-102">&#182;</a>
</div>
<p>Match <code>\</code> followed by any character.</p>
</div>
<div class="content"><div class='highlight'><pre> | \\[\s\S]</pre></div></div>
</li>
<li id="section-103">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-103">&#182;</a>
</div>
<p>Match any <code>/</code> except <code>///</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> | <span class="hljs-regexp">/(?!/</span>/)</pre></div></div>
</li>
<li id="section-104">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-104">&#182;</a>
</div>
<p>Match <code>#</code> which is not part of interpolation, e.g. <code>#{}</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> | \<span class="hljs-comment">#(?!\{)</span></pre></div></div>
</li>
<li id="section-105">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-105">&#182;</a>
</div>
<p>Comments consume everything until the end of the line, including <code>///</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> | \s+(?:<span class="hljs-comment">#(?!\{).*)?</span>
)*
<span class="hljs-regexp">///
HEREGEX_OMIT = ///</span>
((?:\\\\)+) <span class="hljs-comment"># Consume (and preserve) an even number of backslashes.</span>
@@ -2573,11 +2669,11 @@ POSSIBLY_DIVISION = <span class="hljs-regexp">/// ^ /=?\s ///</span></pre></di
</li>
<li id="section-100">
<li id="section-106">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-100">&#182;</a>
<a class="pilcrow" href="#section-106">&#182;</a>
</div>
<p>Other regexes.</p>
@@ -2620,11 +2716,11 @@ TRAILING_SPACES = <span class="hljs-regexp">/\s+$/</span></pre></div></div>
</li>
<li id="section-101">
<li id="section-107">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-101">&#182;</a>
<a class="pilcrow" href="#section-107">&#182;</a>
</div>
<p>Compound assignment tokens.</p>
@@ -2638,11 +2734,11 @@ TRAILING_SPACES = <span class="hljs-regexp">/\s+$/</span></pre></div></div>
</li>
<li id="section-102">
<li id="section-108">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-102">&#182;</a>
<a class="pilcrow" href="#section-108">&#182;</a>
</div>
<p>Unary tokens.</p>
@@ -2655,11 +2751,11 @@ UNARY_MATH = [<span class="hljs-string">'!'</span>, <span class="hljs-string">'~
</li>
<li id="section-103">
<li id="section-109">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-103">&#182;</a>
<a class="pilcrow" href="#section-109">&#182;</a>
</div>
<p>Bit-shifting tokens.</p>
@@ -2670,11 +2766,11 @@ UNARY_MATH = [<span class="hljs-string">'!'</span>, <span class="hljs-string">'~
</li>
<li id="section-104">
<li id="section-110">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-104">&#182;</a>
<a class="pilcrow" href="#section-110">&#182;</a>
</div>
<p>Comparison tokens.</p>
@@ -2685,11 +2781,11 @@ UNARY_MATH = [<span class="hljs-string">'!'</span>, <span class="hljs-string">'~
</li>
<li id="section-105">
<li id="section-111">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-105">&#182;</a>
<a class="pilcrow" href="#section-111">&#182;</a>
</div>
<p>Mathematical tokens.</p>
@@ -2700,11 +2796,11 @@ UNARY_MATH = [<span class="hljs-string">'!'</span>, <span class="hljs-string">'~
</li>
<li id="section-106">
<li id="section-112">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-106">&#182;</a>
<a class="pilcrow" href="#section-112">&#182;</a>
</div>
<p>Relational tokens that are negatable with <code>not</code> prefix.</p>
@@ -2715,11 +2811,11 @@ UNARY_MATH = [<span class="hljs-string">'!'</span>, <span class="hljs-string">'~
</li>
<li id="section-107">
<li id="section-113">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-107">&#182;</a>
<a class="pilcrow" href="#section-113">&#182;</a>
</div>
<p>Boolean tokens.</p>
@@ -2730,11 +2826,11 @@ UNARY_MATH = [<span class="hljs-string">'!'</span>, <span class="hljs-string">'~
</li>
<li id="section-108">
<li id="section-114">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-108">&#182;</a>
<a class="pilcrow" href="#section-114">&#182;</a>
</div>
<p>Tokens which could legitimately be invoked or indexed. An opening
parentheses or bracket following these tokens will be recorded as the start
@@ -2751,11 +2847,11 @@ INDEXABLE = CALLABLE.concat [
</li>
<li id="section-109">
<li id="section-115">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-109">&#182;</a>
<a class="pilcrow" href="#section-115">&#182;</a>
</div>
<p>Tokens which can be the left-hand side of a less-than comparison, i.e. <code>a&lt;b</code>.</p>
@@ -2766,11 +2862,11 @@ INDEXABLE = CALLABLE.concat [
</li>
<li id="section-110">
<li id="section-116">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-110">&#182;</a>
<a class="pilcrow" href="#section-116">&#182;</a>
</div>
<p>Tokens which a regular expression will never immediately follow (except spaced
CALLABLEs in some cases), but which a division operator can.</p>
@@ -2783,11 +2879,11 @@ CALLABLEs in some cases), but which a division operator can.</p>
</li>
<li id="section-111">
<li id="section-117">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-111">&#182;</a>
<a class="pilcrow" href="#section-117">&#182;</a>
</div>
<p>Tokens that, when immediately preceding a <code>WHEN</code>, indicate that the <code>WHEN</code>
occurs at the start of a line. We disambiguate these from trailing whens to
@@ -2800,11 +2896,11 @@ avoid an ambiguity in the grammar.</p>
</li>
<li id="section-112">
<li id="section-118">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-112">&#182;</a>
<a class="pilcrow" href="#section-118">&#182;</a>
</div>
<p>Additional indent in front of these is ignored.</p>
@@ -2815,11 +2911,11 @@ avoid an ambiguity in the grammar.</p>
</li>
<li id="section-113">
<li id="section-119">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-113">&#182;</a>
<a class="pilcrow" href="#section-119">&#182;</a>
</div>
<p>Tokens that, when appearing at the end of a line, suppress a following TERMINATOR/INDENT token</p>

852
docs/v2/annotated-source/nodes.html
View File

File diff suppressed because it is too large Load Diff

4
docs/v2/browser-compiler/coffeescript.js
View File

File diff suppressed because one or more lines are too long

51
docs/v2/index.html
View File

@@ -646,7 +646,7 @@ div.CodeMirror-cursor {
<section id="overview">
<p><strong>CoffeeScript is a little language that compiles into JavaScript.</strong> Underneath that awkward Java-esque patina, JavaScript has always had a gorgeous heart. CoffeeScript is an attempt to expose the good parts of JavaScript in a simple way.</p>
<p>The golden rule of CoffeeScript is: <em>“It’s just JavaScript.”</em> The code compiles one-to-one into the equivalent JS, and there is no interpretation at runtime. You can use any existing JavaScript library seamlessly from CoffeeScript (and vice-versa). The compiled output is readable, pretty-printed, and tends to run as fast or faster than the equivalent handwritten JavaScript.</p>
<p><strong>Latest Version:</strong> <a href="https://github.com/jashkenas/coffeescript/tarball/2.0.3">2.0.3</a></p>
<p><strong>Latest Version:</strong> <a href="https://github.com/jashkenas/coffeescript/tarball/2.1.0">2.1.0</a></p>
<blockquote class="uneditable-code-block"><pre><code class="language-bash"><span class="comment"># Install locally for a project:</span>
npm install --save-dev coffeescript
@@ -1343,36 +1343,6 @@ kids = {
</div>
</div>
</aside>
<p>In JavaScript, you can’t use reserved words, like <code>class</code>, as properties of an object, without quoting them as strings. CoffeeScript notices reserved words used as keys in objects and quotes them for you, so you don’t have to worry about it (say, when using jQuery).</p>
<aside class="code-example container-fluid bg-ribbed-dark" data-example="objects_reserved">
<div class="row">
<div class="col-md-6 coffeescript-input-column">
<textarea class="coffeescript-input" id="objects_reserved-coffee">$('.account').prop class: 'active'
log object.class
</textarea>
<pre class="placeholder-code"><span class="cm-variable">$</span><span class="cm-punctuation">(</span><span class="cm-string">'.account'</span><span class="cm-punctuation">).</span><span class="cm-property">prop</span> <span class="cm-keyword">class</span><span class="cm-punctuation">:</span> <span class="cm-string">'active'</span>
<span class="cm-variable">log</span> <span class="cm-variable">object</span><span class="cm-punctuation">.</span><span class="cm-property">class</span>
</pre>
</div>
<div class="col-md-6 javascript-output-column">
<textarea class="javascript-output" id="objects_reserved-js">$('.account').prop({
class: 'active'
});
log(object.class);
</textarea>
<pre class="placeholder-code"><span class="cm-variable">$</span>(<span class="cm-string">'.account'</span>).<span class="cm-property">prop</span>({
<span class="cm-property">class</span>: <span class="cm-string">'active'</span>
});
<span class="cm-variable">log</span>(<span class="cm-variable">object</span>.<span class="cm-property">class</span>);
</pre>
</div>
</div>
</aside>
<p>CoffeeScript has a shortcut for creating objects when you want the key to be set with a variable of the same name.</p>
<aside class="code-example container-fluid bg-ribbed-dark" data-example="objects_shorthand">
@@ -2489,7 +2459,7 @@ alert((function() {
<span class="cm-variable">alert</span>((<span class="cm-keyword">function</span>() {
<span class="cm-keyword">try</span> {
<span class="cm-keyword">return</span> <span class="cm-variable">nonexistent</span> <span class="cm-operator">/</span> <span class="cm-variable">void</span> <span class="cm-number">0</span>;
<span class="cm-keyword">return</span> <span class="cm-variable">nonexistent</span> <span class="cm-operator">/</span> <span class="cm-keyword">void</span> <span class="cm-number">0</span>;
} <span class="cm-keyword">catch</span> (<span class="cm-def">error1</span>) {
<span class="cm-variable">error</span> <span class="cm-operator">=</span> <span class="cm-variable-2">error1</span>;
<span class="cm-keyword">return</span> <span class="cm-string-2">`And the error is ... ${</span><span class="cm-variable">error</span><span class="cm-string-2">}`</span>;
@@ -2523,7 +2493,7 @@ alert((function() {
<p>As a shortcut for <code>this.property</code>, you can use <code>@property</code>.</p>
<p>You can use <code>in</code> to test for array presence, and <code>of</code> to test for JavaScript object-key presence.</p>
<p>In a <code>for</code> loop, <code>from</code> compiles to the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of">ES2015 <code>of</code></a>. (Yes, it’s unfortunate; the CoffeeScript <code>of</code> predates the ES2015 <code>of</code>.)</p>
<p>To simplify math expressions, <code>**</code> can be used for exponentiation and <code>//</code> performs integer division. <code>%</code> works just like in JavaScript, while <code>%%</code> provides <a href="https://en.wikipedia.org/wiki/Modulo_operation">“dividend dependent modulo”</a>:</p>
<p>To simplify math expressions, <code>**</code> can be used for exponentiation and <code>//</code> performs floor division. <code>%</code> works just like in JavaScript, while <code>%%</code> provides <a href="https://en.wikipedia.org/wiki/Modulo_operation">“dividend dependent modulo”</a>:</p>
<aside class="code-example container-fluid bg-ribbed-dark" data-example="modulo">
<div class="row">
<div class="col-md-6 coffeescript-input-column">
@@ -2853,7 +2823,7 @@ zip = typeof lottery.drawWinner === "function" ? (ref = lottery.drawWinner().add
</textarea>
<pre class="placeholder-code"><span class="cm-keyword">var</span> <span class="cm-def">ref</span>, <span class="cm-def">zip</span>;
<span class="cm-variable">zip</span> <span class="cm-operator">=</span> <span class="cm-keyword">typeof</span> <span class="cm-variable">lottery</span>.<span class="cm-property">drawWinner</span> <span class="cm-operator">===</span> <span class="cm-string">"function"</span> <span class="cm-operator">?</span> (<span class="cm-variable">ref</span> <span class="cm-operator">=</span> <span class="cm-variable">lottery</span>.<span class="cm-property">drawWinner</span>().<span class="cm-property">address</span>) <span class="cm-operator">!=</span> <span class="cm-atom">null</span> <span class="cm-operator">?</span> <span class="cm-variable">ref</span>.<span class="cm-property">zipcode</span> : <span class="cm-variable">void</span> <span class="cm-number">0</span> : <span class="cm-variable">void</span> <span class="cm-number">0</span>;
<span class="cm-variable">zip</span> <span class="cm-operator">=</span> <span class="cm-keyword">typeof</span> <span class="cm-variable">lottery</span>.<span class="cm-property">drawWinner</span> <span class="cm-operator">===</span> <span class="cm-string">"function"</span> <span class="cm-operator">?</span> (<span class="cm-variable">ref</span> <span class="cm-operator">=</span> <span class="cm-variable">lottery</span>.<span class="cm-property">drawWinner</span>().<span class="cm-property">address</span>) <span class="cm-operator">!=</span> <span class="cm-atom">null</span> <span class="cm-operator">?</span> <span class="cm-variable">ref</span>.<span class="cm-property">zipcode</span> : <span class="cm-keyword">void</span> <span class="cm-number">0</span> : <span class="cm-keyword">void</span> <span class="cm-number">0</span>;
</pre>
</div>
</div>
@@ -4820,7 +4790,7 @@ The CoffeeScript logo is available in SVG for use in presentations.</li>
</section>
<section id="annotated-source">
<h2>Annotated Source</h2>
<p>You can browse the CoffeeScript 2.0.3 source in readable, annotated form <a href="annotated-source/">here</a>. You can also jump directly to a particular source file:</p>
<p>You can browse the CoffeeScript 2.1.0 source in readable, annotated form <a href="annotated-source/">here</a>. You can also jump directly to a particular source file:</p>
<ul>
<li><a href="annotated-source/grammar.html">Grammar Rules — src/grammar</a></li>
<li><a href="annotated-source/lexer.html">Lexing Tokens — src/lexer</a></li>
@@ -5497,6 +5467,17 @@ x = <span class="number">2</span> + <span class="number">2</span>
</section>
<section id="changelog">
<h2>Changelog</h2>
<div class="anchor" id="2.1.0"></div>
<h2 class="header">
<a href="https://github.com/jashkenas/coffeescript/compare/2.0.3...2.1.0">2.1.0</a>
<span class="timestamp"> &mdash; <time datetime="2017-12-10">December 10, 2017</time></span>
</h2><ul>
<li>Computed property keys in object literals are now supported: <code>obj = { ['key' + i]: 42 }</code>, or <code>obj = [Symbol.iterator]: -&gt; yield i++</code>.</li>
<li>Skipping of array elements, a.k.a. elision, is now supported: <code>arr = [a, , b]</code>, or <code>[, protocol] = url.match /^(.*):\/\//</code>.</li>
<li><a href="https://reactjs.org/blog/2017/11/28/react-v16.2.0-fragment-support.html">JSX fragments syntax</a> is now supported.</li>
<li>Bugfix where <code>///</code> within a <code>#</code> line comment inside a <code>///</code> block regex was erroneously closing the regex, rather than being treated as part of the comment.</li>
<li>Bugfix for incorrect output for object rest destructuring inside array destructuring.</li>
</ul>
<div class="anchor" id="2.0.3"></div>
<h2 class="header">
<a href="https://github.com/jashkenas/coffeescript/compare/2.0.2...2.0.3">2.0.3</a>

461
docs/v2/test.html
View File

@@ -361,6 +361,94 @@ test "incorrect indentation without commas", ->
ok result[0][0] is 'a'
ok result[1]['b'] is 'c'
# Elisions
test "array elisions", ->
eq [,1].length, 2
eq [,,1,2,,].length, 5
arr = [1,,2]
eq arr.length, 3
eq arr[1], undefined
eq [,,].length, 2
test "array elisions indentation and commas", ->
arr1 = [
, 1, 2, , , 3,
4, 5, 6
, , 8, 9,
]
eq arr1.length, 12
eq arr1[5], 3
eq arr1[9], undefined
arr2 = [, , 1,
2, , 3,
, 4, 5
6
, , ,
]
eq arr2.length, 12
eq arr2[8], 5
eq arr2[1], undefined
test "array elisions destructuring", ->
arr = [1,2,3,4,5,6,7,8,9]
[,a] = arr
[,,,b] = arr
arrayEq [a,b], [2,4]
[,a,,b,,c,,,d] = arr
arrayEq [a,b,c,d], [2,4,6,9]
[
,e,
,f,
,g,
,,h] = arr
arrayEq [e,f,g,h], [2,4,6,9]
test "array elisions destructuring with splats and expansions", ->
arr = [1,2,3,4,5,6,7,8,9]
[,a,,,b...] = arr
arrayEq [a,b], [2,[5,6,7,8,9]]
[,c,...,,d,,e] = arr
arrayEq [c,d,e], [2,7,9]
[...,f,,,g,,,] = arr
arrayEq [f,g], [4,7]
test "array elisions as function parameters", ->
arr = [1,2,3,4,5,6,7,8,9]
foo = ([,a]) -> a
a = foo arr
eq a, 2
foo = ([,,,a]) -> a
a = foo arr
eq a, 4
foo = ([,a,,b,,c,,,d]) -> [a,b,c,d]
[a,b,c,d] = foo arr
arrayEq [a,b,c,d], [2,4,6,9]
test "array elisions nested destructuring", ->
arr = [
1,
[2,3, [4,5,6, [7,8,9] ] ]
]
[,a] = arr
arrayEq a[2][3], [7,8,9]
[,[,,[,b,,[,,c]]]] = arr
eq b, 5
eq c, 9
aobj = [
{},
{x: 2},
{},
[
{},
{},
{z:1, w:[1,2,4], p:3, q:4}
{},
{}
]
]
[,d,,[,,{w}]] = aobj
deepEqual d, {x:2}
arrayEq w, [1,2,4]
# Splats in Array Literals
@@ -724,6 +812,17 @@ test "#4787 destructuring of objects within arrays", ->
eq b, arr[1].b
deepEqual {a, b}, arr[1]
test "#4798 destructuring of objects with splat within arrays", ->
arr = [1, {a:1, b:2}]
[...,{a, r...}] = arr
eq a, 1
deepEqual r, {b:2}
[b, {q...}] = arr
eq b, 1
deepEqual q, arr[1]
eq q.b, r.b
eq q.a, a
test "destructuring assignment with splats", ->
a = {}; b = {}; c = {}; d = {}; e = {}
[x,y...,z] = [a,b,c,d,e]
@@ -6694,6 +6793,50 @@ test '#4686: comments inside interpolations that also contain CSX attributes', -
</div>;
'''
# https://reactjs.org/blog/2017/11/28/react-v16.2.0-fragment-support.html
test 'JSX fragments: empty fragment', ->
eqJS '''
<></>
''', '''
<></>;
'''
test 'JSX fragments: fragment with text nodes', ->
eqJS '''
<>
Some text.
<h2>A heading</h2>
More text.
<h2>Another heading</h2>
Even more text.
</>
''', '''
<>
Some text.
<h2>A heading</h2>
More text.
<h2>Another heading</h2>
Even more text.
</>;
'''
test 'JSX fragments: fragment with component nodes', ->
eqJS '''
Component = (props) =>
<Fragment>
<OtherComponent />
<OtherComponent />
</Fragment>
''', '''
var Component;
Component = (props) => {
return <Fragment>
<OtherComponent />
<OtherComponent />
</Fragment>;
};
'''
</script>
<script type="text/x-coffeescript" class="test" id="error_messages">
@@ -6882,9 +7025,9 @@ test "#1096: unexpected generated tokens", ->
for i in [1]:
1
''', '''
[stdin]:1:10: error: unexpected [
for i in [1]:
^
[stdin]:2:4: error: unexpected end of input
1
^
'''
# Unexpected regex
assertErrorFormat '{/a/i: val}', '''
@@ -7507,29 +7650,8 @@ test "invalid numbers", ->
^^^
'''
test "unexpected object keys", ->
assertErrorFormat '''
{[[]]}
''', '''
[stdin]:1:2: error: unexpected [
{[[]]}
^
'''
assertErrorFormat '''
{[[]]: 1}
''', '''
[stdin]:1:2: error: unexpected [
{[[]]: 1}
^
'''
assertErrorFormat '''
[[]]: 1
''', '''
[stdin]:1:1: error: unexpected [
[[]]: 1
^
'''
test "unexpected object keys", ->
assertErrorFormat '''
{(a + "b")}
''', '''
@@ -7551,20 +7673,6 @@ test "unexpected object keys", ->
(a + "b"): 1
^
'''
assertErrorFormat '''
a: 1, [[]]: 2
''', '''
[stdin]:1:7: error: unexpected [
a: 1, [[]]: 2
^
'''
assertErrorFormat '''
{a: 1, [[]]: 2}
''', '''
[stdin]:1:8: error: unexpected [
{a: 1, [[]]: 2}
^
'''
test "invalid object keys", ->
assertErrorFormat '''
@@ -8503,6 +8611,15 @@ test "#3098: suppressed newline should be unsuppressed by semicolon", ->
^
'''
test "#4811: '///' inside a heregex comment does not close the heregex", ->
assertErrorFormat '''
/// .* # comment ///
''', '''
[stdin]:1:1: error: missing ///
/// .* # comment ///
^^^
'''
</script>
<script type="text/x-coffeescript" class="test" id="eval">
if vm = require? 'vm'
@@ -11275,6 +11392,8 @@ path = require 'path'
# Get the folder containing the compiled `coffee` executable and make it the
# PATH so that `#!/usr/bin/env coffee` resolves to our locally built file.
coffeeBinFolder = path.dirname require.resolve '../bin/coffee'
# For some reason, Windows requires `coffee` to be executed as `node coffee`.
coffeeCommand = if isWindows() then 'node coffee' else 'coffee'
spawnOptions =
cwd: coffeeBinFolder
encoding: 'utf8'
@@ -11287,7 +11406,7 @@ initialSpaceScript = require.resolve './importing/shebang_initial_space.coffee'
extraArgsScript = require.resolve './importing/shebang_extra_args.coffee'
initialSpaceExtraArgsScript = require.resolve './importing/shebang_initial_space_extra_args.coffee'
test "parse arguments for shebang scripts correctly (on unix platforms)", ->
test "parse arguments for shebang scripts correctly (on *nix platforms)", ->
return if isWindows()
stdout = execFileSync shebangScript, ['-abck'], spawnOptions
@@ -11301,7 +11420,7 @@ test "parse arguments for shebang scripts correctly (on unix platforms)", ->
arrayEq expectedArgs, realArgs
test "warn and remove -- if it is the second positional argument", ->
result = spawnSync 'coffee', [shebangScript, '--'], spawnOptions
result = spawnSync coffeeCommand, [shebangScript, '--'], spawnOptions
stderr = result.stderr.toString()
arrayEq JSON.parse(result.stdout), ['coffee', shebangScript]
ok stderr.match /^coffee was invoked with '--'/m
@@ -11309,7 +11428,7 @@ test "warn and remove -- if it is the second positional argument", ->
arrayEq JSON.parse(posArgs), [shebangScript, '--']
ok result.status is 0
result = spawnSync 'coffee', ['-b', shebangScript, '--'], spawnOptions
result = spawnSync coffeeCommand, ['-b', shebangScript, '--'], spawnOptions
stderr = result.stderr.toString()
arrayEq JSON.parse(result.stdout), ['coffee', shebangScript]
ok stderr.match /^coffee was invoked with '--'/m
@@ -11318,7 +11437,7 @@ test "warn and remove -- if it is the second positional argument", ->
ok result.status is 0
result = spawnSync(
'coffee', ['-b', shebangScript, '--', 'ANOTHER'], spawnOptions)
coffeeCommand, ['-b', shebangScript, '--', 'ANOTHER'], spawnOptions)
stderr = result.stderr.toString()
arrayEq JSON.parse(result.stdout), ['coffee', shebangScript, 'ANOTHER']
ok stderr.match /^coffee was invoked with '--'/m
@@ -11327,7 +11446,7 @@ test "warn and remove -- if it is the second positional argument", ->
ok result.status is 0
result = spawnSync(
'coffee', ['--', initialSpaceScript, 'arg'], spawnOptions)
coffeeCommand, ['--', initialSpaceScript, 'arg'], spawnOptions)
expectedArgs = ['coffee', initialSpaceScript, 'arg']
realArgs = JSON.parse result.stdout
arrayEq expectedArgs, realArgs
@@ -11335,7 +11454,7 @@ test "warn and remove -- if it is the second positional argument", ->
ok result.status is 0
test "warn about non-portable shebang lines", ->
result = spawnSync 'coffee', [extraArgsScript, 'arg'], spawnOptions
result = spawnSync coffeeCommand, [extraArgsScript, 'arg'], spawnOptions
stderr = result.stderr.toString()
arrayEq JSON.parse(result.stdout), ['coffee', extraArgsScript, 'arg']
ok stderr.match /^The script to be run begins with a shebang line with more than one/m
@@ -11346,14 +11465,14 @@ test "warn about non-portable shebang lines", ->
arrayEq JSON.parse(args), ['coffee', '--']
ok result.status is 0
result = spawnSync 'coffee', [initialSpaceScript, 'arg'], spawnOptions
result = spawnSync coffeeCommand, [initialSpaceScript, 'arg'], spawnOptions
stderr = result.stderr.toString()
ok stderr is ''
arrayEq JSON.parse(result.stdout), ['coffee', initialSpaceScript, 'arg']
ok result.status is 0
result = spawnSync(
'coffee', [initialSpaceExtraArgsScript, 'arg'], spawnOptions)
coffeeCommand, [initialSpaceExtraArgsScript, 'arg'], spawnOptions)
stderr = result.stderr.toString()
arrayEq JSON.parse(result.stdout), ['coffee', initialSpaceExtraArgsScript, 'arg']
ok stderr.match /^The script to be run begins with a shebang line with more than one/m
@@ -11366,7 +11485,7 @@ test "warn about non-portable shebang lines", ->
test "both warnings will be shown at once", ->
result = spawnSync(
'coffee', [initialSpaceExtraArgsScript, '--', 'arg'], spawnOptions)
coffeeCommand, [initialSpaceExtraArgsScript, '--', 'arg'], spawnOptions)
stderr = result.stderr.toString()
arrayEq JSON.parse(result.stdout), ['coffee', initialSpaceExtraArgsScript, 'arg']
ok stderr.match /^The script to be run begins with a shebang line with more than one/m
@@ -13792,8 +13911,7 @@ test 'inline implicit object literals within multiline implicit object literals'
eq 0, x.b
eq 0, x.a.aa
test "object keys with interpolations", ->
# Simple cases.
test "object keys with interpolations: simple cases", ->
a = 'a'
obj = "#{a}": yes
eq obj.a, yes
@@ -13804,7 +13922,7 @@ test "object keys with interpolations", ->
obj = {"#{5}"}
eq obj[5], '5' # Note that the value is a string, just like the key.
# Commas in implicit object.
test "object keys with interpolations: commas in implicit object", ->
obj = "#{'a'}": 1, b: 2
deepEqual obj, {a: 1, b: 2}
obj = a: 1, "#{'b'}": 2
@@ -13812,7 +13930,7 @@ test "object keys with interpolations", ->
obj = "#{'a'}": 1, "#{'b'}": 2
deepEqual obj, {a: 1, b: 2}
# Commas in explicit object.
test "object keys with interpolations: commas in explicit object", ->
obj = {"#{'a'}": 1, b: 2}
deepEqual obj, {a: 1, b: 2}
obj = {a: 1, "#{'b'}": 2}
@@ -13820,7 +13938,7 @@ test "object keys with interpolations", ->
obj = {"#{'a'}": 1, "#{'b'}": 2}
deepEqual obj, {a: 1, b: 2}
# Commas after key with interpolation.
test "object keys with interpolations: commas after key with interpolation", ->
obj = {"#{'a'}": yes,}
eq obj.a, yes
obj = {
@@ -13843,17 +13961,17 @@ test "object keys with interpolations", ->
"#{'c'}": 3, "#{'d'}": 4,
deepEqual obj, {a: 1, b: 2, c: 3, d: 4}
# Key with interpolation mixed with `@prop`.
test "object keys with interpolations: key with interpolation mixed with `@prop`", ->
deepEqual (-> {@a, "#{'b'}": 2}).call(a: 1), {a: 1, b: 2}
# Evaluate only once.
test "object keys with interpolations: evaluate only once", ->
count = 0
b = -> count++; 'b'
obj = {"#{b()}"}
eq obj.b, 'b'
a = -> count++; 'a'
obj = {"#{a()}"}
eq obj.a, 'a'
eq count, 1
# Evaluation order.
test "object keys with interpolations: evaluation order", ->
arr = []
obj =
a: arr.push 1
@@ -13866,13 +13984,13 @@ test "object keys with interpolations", ->
arrayEq arr, [1..7]
deepEqual obj, {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7}
# Object starting with dynamic key.
test "object keys with interpolations: object starting with dynamic key", ->
obj =
"#{'a'}": 1
b: 2
deepEqual obj, {a: 1, b: 2}
# Comments in implicit object.
test "object keys with interpolations: comments in implicit object", ->
obj =
### leading comment ###
"#{'a'}": 1
@@ -13903,7 +14021,7 @@ test "object keys with interpolations", ->
}
deepEqual obj, {a: 1, b: 2, c: 3, d: 4, e: 5}
# A more complicated case.
test "object keys with interpolations: more complicated case", ->
obj = {
"#{'interpolated'}":
"""
@@ -13921,6 +14039,212 @@ test "#4324: Shorthand after interpolated key", ->
eq 1, obj[1]
eq 2, obj.a
test "computed property keys: simple cases", ->
a = 'a'
obj = [a]: yes
eq obj.a, yes
obj = {[a]: yes}
eq obj.a, yes
obj = {[a]}
eq obj.a, 'a'
obj = {[5]}
eq obj[5], 5
obj = {['5']}
eq obj['5'], '5'
test "computed property keys: commas in implicit object", ->
obj = ['a']: 1, b: 2
deepEqual obj, {a: 1, b: 2}
obj = a: 1, ['b']: 2
deepEqual obj, {a: 1, b: 2}
obj = ['a']: 1, ['b']: 2
deepEqual obj, {a: 1, b: 2}
test "computed property keys: commas in explicit object", ->
obj = {['a']: 1, b: 2}
deepEqual obj, {a: 1, b: 2}
obj = {a: 1, ['b']: 2}
deepEqual obj, {a: 1, b: 2}
obj = {['a']: 1, ['b']: 2}
deepEqual obj, {a: 1, b: 2}
test "computed property keys: commas after key with interpolation", ->
obj = {['a']: yes,}
eq obj.a, yes
obj = {
['a']: 1,
['b']: 2,
### herecomment ###
['c']: 3,
}
deepEqual obj, {a: 1, b: 2, c: 3}
obj =
['a']: 1,
['b']: 2,
### herecomment ###
['c']: 3,
deepEqual obj, {a: 1, b: 2, c: 3}
obj =
['a']: 1,
['b']: 2,
### herecomment ###
['c']: 3, ['d']: 4,
deepEqual obj, {a: 1, b: 2, c: 3, d: 4}
test "computed property keys: key with interpolation mixed with `@prop`", ->
deepEqual (-> {@a, ['b']: 2}).call(a: 1), {a: 1, b: 2}
test "computed property keys: evaluate only once", ->
count = 0
a = -> count++; 'a'
obj = {[a()]}
eq obj.a, 'a'
eq count, 1
test "computed property keys: evaluation order", ->
arr = []
obj =
a: arr.push 1
b: arr.push 2
['c']: arr.push 3
['d']: arr.push 4
e: arr.push 5
['f']: arr.push 6
g: arr.push 7
arrayEq arr, [1..7]
deepEqual obj, {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7}
test "computed property keys: object starting with dynamic key", ->
obj =
['a']: 1
b: 2
deepEqual obj, {a: 1, b: 2}
test "computed property keys: comments in implicit object", ->
obj =
### leading comment ###
['a']: 1
### middle ###
['b']: 2
# regular comment
'c': 3
### foo ###
d: 4
['e']: 5
deepEqual obj, {a: 1, b: 2, c: 3, d: 4, e: 5}
obj = {
### leading comment ###
['a']: 1
### middle ###
['b']: 2
# regular comment
'c': 3
### foo ###
d: 4
['e']: 5
}
deepEqual obj, {a: 1, b: 2, c: 3, d: 4, e: 5}
test "computed property keys: more complicated case", ->
obj = {
['interpolated']:
['nested']:
123: 456
}
deepEqual obj,
interpolated:
nested:
123: 456
test "computed property keys: empty array as key", ->
o1 = { [[]] }
deepEqual o1, { [[]]: [] }
arrayEq o1[[]], []
o2 = { [[]]: 1 }
deepEqual o2, { [[]]: 1 }
eq o2[[]], 1
o3 = [[]]: 1
deepEqual o3, { [[]]: 1 }
deepEqual o3, { [[]]: 1 }
eq o3[[]], 1
o4 = a: 1, [[]]: 2
deepEqual o4, { a: 1, [[]]: 2 }
eq o4.a, 1,
eq o4[[]], 2
o5 = { a: 1, [[]]: 2 }
deepEqual o5, { a: 1, [[]]: 2 }
eq o5.a, 1,
eq o5[[]], 2
test "computed property keys: shorthand after computed property key", ->
a = 2
obj = {[1]: 1, a}
eq 1, obj[1]
eq 2, obj.a
test "computed property keys: shorthand computed property key", ->
a = 'b'
o = {[a]}
p = {a}
r = {['a']}
eq o.b, 'b'
eq p.a, o.b
eq r.a, 'a'
foo = -> "a"
obj = { [foo()] }
eq obj.a, 'a'
test "computed property keys: arrays", ->
b = 'b'
f = (c) -> "#{c}1"
obj =
['a']: [1, 2, 3]
[b]: [4, 5, 6]
[f(b)]: [7, 8, 9]
arrayEq obj.a, [1, 2, 3]
arrayEq obj.b, [4, 5, 6]
arrayEq obj.b1, [7, 8, 9]
test "computed property keys: examples from developer.mozilla.org (Object initializer)", ->
i = 0
obj =
['foo' + ++i]: i
['foo' + ++i]: i
['foo' + ++i]: i
eq obj.foo1, 1
eq obj.foo2, 2
eq obj.foo3, 3
param = 'size'
config =
[param]: 12,
['mobile' + param.charAt(0).toUpperCase() + param.slice(1)]: 4
deepEqual config, {size: 12, mobileSize: 4}
test "computed property keys: [Symbol.iterator]", ->
obj =
[Symbol.iterator]: ->
yield "hello"
yield "world"
arrayEq [obj...], ['hello', 'world']
test "computed property keys: Class property", ->
increment_method = "increment"
decrement_method = "decrement"
class Obs
constructor: (@count) ->
[increment_method]: -> @count += 1
[decrement_method]: -> @count -= 1
ob = new Obs 2
eq ob.increment(), 3
eq ob.decrement(), 2
test "#1263: Braceless object return", ->
fn = ->
return
@@ -15122,6 +15446,19 @@ test "#4248: Unicode code point escapes", ->
/a\\udab3\\uddef/;
"""
test "#4811, heregex comments with ///", ->
eqJS """
///
a | # comment with ///
b # /// 'heregex' in comment will be consumed
///
""",
"""
// comment with ///
// /// 'heregex' in comment will be consumed
/a|b/;
"""
</script>
<script type="text/x-coffeescript" class="test" id="repl">
return if global.testingBrowser

10
documentation/sections/changelog.md
View File

@@ -1,5 +1,15 @@
## Changelog
```
releaseHeader('2017-12-10', '2.1.0', '2.0.3')
```
* Computed property keys in object literals are now supported: `obj = { ['key' + i]: 42 }`, or `obj = [Symbol.iterator]: -> yield i++`.
* Skipping of array elements, a.k.a. elision, is now supported: `arr = [a, , b]`, or `[, protocol] = url.match /^(.*):\/\//`.
* [JSX fragments syntax](https://reactjs.org/blog/2017/11/28/react-v16.2.0-fragment-support.html) is now supported.
* Bugfix where `///` within a `#` line comment inside a `///` block regex was erroneously closing the regex, rather than being treated as part of the comment.
* Bugfix for incorrect output for object rest destructuring inside array destructuring.
```
releaseHeader('2017-11-26', '2.0.3', '2.0.2')
```

6
documentation/sections/objects_and_arrays.md
View File

@@ -6,12 +6,6 @@ The CoffeeScript literals for objects and arrays look very similar to their Java
codeFor('objects_and_arrays', 'song.join(" … ")')
```
In JavaScript, you can’t use reserved words, like `class`, as properties of an object, without quoting them as strings. CoffeeScript notices reserved words used as keys in objects and quotes them for you, so you don’t have to worry about it (say, when using jQuery).
```
codeFor('objects_reserved')
```
CoffeeScript has a shortcut for creating objects when you want the key to be set with a variable of the same name.
```

2
documentation/sections/operators.md
View File

@@ -18,7 +18,7 @@ You can use `in` to test for array presence, and `of` to test for JavaScript obj
In a `for` loop, `from` compiles to the [ES2015 `of`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of). (Yes, it’s unfortunate; the CoffeeScript `of` predates the ES2015 `of`.)
To simplify math expressions, `**` can be used for exponentiation and `//` performs integer division. `%` works just like in JavaScript, while `%%` provides [“dividend dependent modulo”](https://en.wikipedia.org/wiki/Modulo_operation):
To simplify math expressions, `**` can be used for exponentiation and `//` performs floor division. `%` works just like in JavaScript, while `%%` provides [“dividend dependent modulo”](https://en.wikipedia.org/wiki/Modulo_operation):
```
codeFor('modulo')

2
lib/coffeescript/browser.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// This **Browser** compatibility layer extends core CoffeeScript functions
// to make things work smoothly when compiling code directly in the browser.

2
lib/coffeescript/cake.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// `cake` is a simplified version of [Make](http://www.gnu.org/software/make/)
// ([Rake](http://rake.rubyforge.org/), [Jake](https://github.com/280north/jake))

2
lib/coffeescript/coffeescript.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// CoffeeScript can be used both on the server, as a command-line compiler based
// on Node.js/V8, or to run CoffeeScript directly in the browser. This module

2
lib/coffeescript/command.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// The `coffee` utility. Handles command-line compilation of CoffeeScript
// into various forms: saved into `.js` files or printed to stdout

2
lib/coffeescript/grammar.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// The CoffeeScript parser is generated by [Jison](https://github.com/zaach/jison)
// from this grammar file. Jison is a bottom-up parser generator, similar in

2
lib/coffeescript/helpers.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// This file contains the common helper functions that we'd like to share among
// the **Lexer**, **Rewriter**, and the **Nodes**. Merge objects, flatten

2
lib/coffeescript/index.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// Node.js Implementation
var CoffeeScript, ext, fn, fs, helpers, i, len, path, ref, universalCompile, vm,

2
lib/coffeescript/lexer.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// The CoffeeScript Lexer. Uses a series of token-matching regexes to attempt
// matches against the beginning of the source code. When a match is found,

2
lib/coffeescript/nodes.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// `nodes.coffee` contains all of the node classes for the syntax tree. Most
// nodes are created as the result of actions in the [grammar](grammar.html),

2
lib/coffeescript/optparse.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
var LONG_FLAG, MULTI_FLAG, OPTIONAL, OptionParser, SHORT_FLAG, buildRule, buildRules, normalizeArguments, repeat,
slice = [].slice;

2
lib/coffeescript/register.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
var CoffeeScript, Module, binary, child_process, ext, findExtension, fork, getRootModule, helpers, i, len, loadFile, path, ref;

2
lib/coffeescript/repl.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
var CoffeeScript, addHistory, addMultilineHandler, fs, getCommandId, merge, nodeREPL, path, replDefaults, runInContext, sawSIGINT, transpile, updateSyntaxError, vm;

2
lib/coffeescript/rewriter.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// The CoffeeScript language has a good deal of optional syntax, implicit syntax,
// and shorthand syntax. This can greatly complicate a grammar and bloat

2
lib/coffeescript/scope.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// The **Scope** class regulates lexical scoping within CoffeeScript. As you
// generate code, you create a tree of scopes in the same shape as the nested

2
lib/coffeescript/sourcemap.js
View File

@@ -1,4 +1,4 @@
// Generated by CoffeeScript 2.0.3
// Generated by CoffeeScript 2.1.0
(function() {
// Source maps allow JavaScript runtimes to match running JavaScript back to
// the original source code that corresponds to it. This can be minified

642
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

8
package.json
View File

@@ -8,7 +8,7 @@
"compiler"
],
"author": "Jeremy Ashkenas",
"version": "2.0.3",
"version": "2.1.0",
"license": "MIT",
"engines": {
"node": ">=6"
@@ -41,15 +41,15 @@
"devDependencies": {
"babel-core": "~6.26.0",
"babel-preset-babili": "~0.1.4",
"babel-preset-env": "~1.6.0",
"babel-preset-env": "~1.6.1",
"babel-preset-minify": "^0.2.0",
"codemirror": "^5.29.0",
"codemirror": "^5.32.0",
"docco": "~0.7.0",
"highlight.js": "~9.12.0",
"jison": ">=0.4.18",
"markdown-it": "~8.4.0",
"underscore": "~1.8.3",
"webpack": "~3.6.0"
"webpack": "~3.10.0"
},
"dependencies": {}
}