haml-more 0.4.0.a

data/vendor/coffee-script/vendor/jison/tests/parser/actions.js

@@ -0,0 +1,311 @@
+var Jison = require("../setup").Jison,
+    RegExpLexer = require("../setup").RegExpLexer,
+    assert = require("assert");
+
+exports["test Semantic action basic return"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["y", "return 'y';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "E"   :[ ["E x", "return 0"],
+                     ["E y", "return 1"],
+                     "" ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('x'), 0, "semantic action");
+    assert.equal(parser.parse('y'), 1, "semantic action");
+};
+
+exports["test return null"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "E"   :[ ["E x", "return null;"],
+                     "" ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('x'), null, "semantic action");
+};
+
+exports["test terminal semantic values are null"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["y", "return 'y';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "E"   :[ ["E x", "return [$2 === null]"],
+                     ["E y", "return [$2]"],
+                     "" ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.deepEqual(parser.parse('x'), [true], "semantic action");
+    assert.deepEqual(parser.parse('y'), [null], "semantic action");
+};
+
+exports["test Semantic action stack lookup"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["y", "return 'y';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "pgm" :[ ["E", "return $1"] ],
+            "E"   :[ ["B E", "return $1+$2"],
+                      ["x", "$$ = 'EX'"] ],
+            "B"   :[ ["y", "$$ = 'BY'"] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('x'), "EX", "return first token");
+    assert.equal(parser.parse('yx'), "BYEX", "return first after reduction");
+};
+
+exports["test Semantic actions on nullable grammar"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "S" :[ ["A", "return $1"] ],
+            "A" :[ ['x A', "$$ = $2+'x'" ],
+                   ['', "$$ = '->'" ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('xx'), "->xx", "return first after reduction");
+};
+
+exports["test named semantic value"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "S" :[ ["A", "return $A"] ],
+            "A" :[ ['x A', "$$ = $A+'x'" ],
+                   ['', "$$ = '->'" ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('xx'), "->xx", "return first after reduction");
+};
+
+exports["test ambiguous named semantic value"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["y", "return 'y';"]
+        ]
+    };
+    var grammar = {
+        operators: [["left", "y"]],
+        bnf: {
+            "S" :[ ["A", "return $A"] ],
+            "A" :[ ['A y A', "$$ = $A2+'y'+$A1" ],
+                   ['x', "$$ = 'x'" ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('xyx'), "xyx", "return first after reduction");
+};
+
+exports["test Build AST"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "S" :[ ['A', "return $1;" ] ],
+            "A" :[ ['x A', "$2.push(['ID',{value:'x'}]); $$ = $2;"],
+                   ['', "$$ = ['A',{}];"] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    var expectedAST = ['A',{},
+        ['ID',{value:'x'}],
+        ['ID',{value:'x'}],
+        ['ID',{value:'x'}]];
+
+    var r = parser.parse("xxx");
+    assert.deepEqual(r, expectedAST);
+};
+
+exports["test 0+0 grammar"] = function() {
+    var lexData2 = {
+        rules: [
+           ["0", "return 'ZERO';"],
+           ["\\+", "return 'PLUS';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "S" :[ [ "E EOF",    "return $1" ]],
+            "E" :[ [ "E PLUS T", "$$ = ['+',$1,$3]"  ],
+                   [ "T",        "$$ = $1" ]  ],
+            "T" :[ [ "ZERO",     "$$ = [0]" ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData2);
+
+    var expectedAST = ["+", ["+", [0], [0]], [0]];
+
+    assert.deepEqual(parser.parse("0+0+0"), expectedAST);
+};
+
+exports["test implicit $$ = $1 action"] = function() {
+    var lexData2 = {
+        rules: [
+           ["0", "return 'ZERO';"],
+           ["\\+", "return 'PLUS';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "S" :[ [ "E EOF",    "return $1" ]],
+            "E" :[ [ "E PLUS T", "$$ = ['+',$1,$3]"  ],
+                   "T" ],
+            "T" :[ [ "ZERO",     "$$ = [0]" ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData2);
+
+    var expectedAST = ["+", ["+", [0], [0]], [0]];
+
+    assert.deepEqual(parser.parse("0+0+0"), expectedAST);
+};
+
+exports["test yytext"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "pgm" :[ ["Xexpr", "return $1;"] ],
+            "Xexpr"   :[ ["x", "$$ = yytext;"] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('x'), "x", "return first token");
+};
+
+exports["test yyleng"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "pgm" :[ ["Xexpr", "return $1;"] ],
+            "Xexpr"   :[ ["x", "$$ = yyleng;"] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('x'), 1, "return first token");
+};
+
+exports["test yytext more"] = function() {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["y", "return 'y';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "pgm" :[ ["expr expr", "return $1+$2;"] ],
+            "expr"   :[ ["x", "$$ = yytext;"],
+                         ["y", "$$ = yytext;"] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('xy'), "xy", "return first token");
+};
+
+exports["test action include"] = function() {
+    var lexData = {
+        rules: [
+           ["y", "return 'y';"]
+        ]
+    };
+    var grammar = {
+        bnf: {
+            "E"   :[ ["E y", "return test();"],
+                     "" ]
+        },
+        actionInclude: function () {
+            function test(val) {
+                return 1;
+            }
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert.equal(parser.parse('y'), 1, "semantic action");
+};
+

data/vendor/coffee-script/vendor/jison/tests/parser/api.js

@@ -0,0 +1,236 @@
+var Jison = require("../setup").Jison,
+    Lexer = require("../setup").Lexer,
+    assert = require("assert");
+
+var lexData = {
+    rules: [
+       ["x", "return 'x';"],
+       ["y", "return 'y';"]
+    ]
+};
+
+exports["test tokens as a string"] = function () {
+
+    var grammar = {
+        tokens: "x y",
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'A x',
+                   'A y',
+                   ''      ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new Lexer(lexData);
+    assert.ok(parser.parse('xyx'), "parse xyx");
+};
+
+exports["test generator"] = function () {
+
+    var grammar = {
+        bnf: {
+            "A" :[ 'A x',
+                   'A y',
+                   ''      ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new Lexer(lexData);
+    assert.ok(parser.parse('xyx'), "parse xyx");
+};
+
+exports["test extra spaces in productions"] = function () {
+
+    var grammar = {
+        tokens: "x y",
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'A x ',
+                   'A y',
+                   ''      ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new Lexer(lexData);
+    assert.ok(parser.parse('xyx'), "parse xyx");
+};
+
+exports["test | seperated rules"] = function () {
+
+    var grammar = {
+        tokens: "x y",
+        startSymbol: "A",
+        bnf: {
+            "A" :"A x | A y | "
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new Lexer(lexData);
+    assert.ok(parser.parse('xyx'), "parse xyx");
+};
+
+exports["test start symbol optional"] = function () {
+
+    var grammar = {
+        tokens: "x y",
+        bnf: {
+            "A" :"A x | A y | "
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    var ok = true;
+    assert.ok(ok, "no error");
+};
+
+exports["test start symbol should be nonterminal"] = function () {
+
+    var grammar = {
+        tokens: "x y",
+        startSymbol: "x",
+        bnf: {
+            "A" :"A x | A y | "
+        }
+    };
+
+    assert["throws"](function(){new Jison.Generator(grammar);}, "throws error");
+};
+
+exports["test token list as string"] = function () {
+
+    var grammar = {
+        tokens: "x y",
+        startSymbol: "A",
+        bnf: {
+            "A" :"A x | A y | "
+        }
+    };
+
+    var gen = new Jison.Generator(grammar);
+    assert.deepEqual(gen.terminals, ["$end", "x", "y"]);
+};
+
+exports["test grammar options"] = function () {
+
+    var grammar = {
+        options: {type: "slr"},
+        tokens: "x y",
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'A x',
+                   'A y',
+                   ''      ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar);
+    assert.ok(gen);
+};
+
+exports["test overwrite grammar options"] = function () {
+
+    var grammar = {
+        options: {type: "slr"},
+        tokens: "x y",
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'A x',
+                   'A y',
+                   ''      ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "lr0"});
+    assert.equal(gen.constructor, Jison.LR0Generator);
+};
+
+exports["test yy shared scope"] = function () {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["y", "return yy.xed ? 'yfoo' : 'ybar';"]
+        ]
+    };
+    var grammar = {
+        tokens: "x yfoo ybar",
+        startSymbol: "A",
+        bnf: {
+            "A" :[[ 'A x', "yy.xed = true;" ],
+                  [ 'A yfoo', " return 'foo';" ],
+                  [ 'A ybar', " return 'bar';" ],
+                   ''      ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar, {type: "lr0"});
+    parser.lexer = new Lexer(lexData);
+    assert.equal(parser.parse('y'), "bar", "should return bar");
+    assert.equal(parser.parse('xxy'), "foo", "should return foo");
+};
+
+
+exports["test optional token declaration"] = function () {
+
+    var grammar = {
+        options: {type: "slr"},
+        bnf: {
+            "A" :[ 'A x',
+                   'A y',
+                   ''      ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "lr0"});
+    assert.equal(gen.constructor, Jison.LR0Generator);
+};
+
+
+exports["test custom parse error method"] = function () {
+    var lexData = {
+        rules: [
+           ["a", "return 'a';"],
+           ["b", "return 'b';"],
+           ["c", "return 'c';"],
+           ["d", "return 'd';"],
+           ["g", "return 'g';"]
+        ]
+    };
+    var grammar = {
+        "tokens": "a b c d g",
+        "startSymbol": "S",
+        "bnf": {
+            "S" :[ "a g d",
+                   "a A c",
+                   "b A d",
+                   "b g c" ],
+            "A" :[ "B" ],
+            "B" :[ "g" ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar, {type: "lalr"});
+    parser.lexer = new Lexer(lexData);
+    var result={};
+    parser.yy.parseError = function (str, hash) {
+        result = hash;
+        throw str;
+    };
+
+    assert["throws"](function () {parser.parse("aga")});
+    assert.strictEqual(result.text, "a", "parse error text should equal b");
+    assert.strictEqual(typeof result.token, 'string', "parse error token should be a string");
+    assert.strictEqual(result.line, 0, "hash should include line number");
+};
+
+exports["test jison grammar as string"] = function () {
+
+    var grammar = "%% A : A x | A y | ;"
+
+    var parser = new Jison.Generator(grammar).createParser();
+    parser.lexer = new Lexer(lexData);
+    assert.ok(parser.parse('xyx'), "parse xyx");
+};