Fix case/when parsing + unit tests

Author: mistic100

.gitignore

@@ -1,4 +1,5 @@
 node_modules
 .DS_Store
 *.swp
-
+*.iml
+.idea

src/grammar.coffee

@@ -61,7 +61,7 @@ grammar =
 
   Unions: [
     o 'Union',                                            -> [$1]
-    o 'Unions Union',                                     -> $1.concat($3)
+    o 'Unions Union',                                     -> $1.concat($2)
   ]
 
   Union: [
@@ -152,17 +152,17 @@ grammar =
   ]
 
   CaseStatement: [
-    o 'CASE CaseWhen END',                                -> new Case($2)
-    o 'CASE CaseWhen CaseElse END',                       -> new Case($2, $3)
+    o 'CASE CaseWhens END',                               -> new Case($2)
+    o 'CASE CaseWhens CaseElse END',                      -> new Case($2, $3)
   ]
 
   CaseWhen: [
     o 'WHEN Expression THEN Expression',                  -> new CaseWhen($2, $4)
   ]
 
   CaseWhens: [
-    o 'CaseWhen',                                         -> [$1],
-    o 'CaseWhens SEPARATOR CaseWhen',                     -> $1.concat($3)
+    o 'CaseWhens CaseWhen',                               -> $1.concat($2)
+    o 'CaseWhen',                                         -> [$1]
   ]
 
   CaseElse: [

src/nodes.coffee

@@ -101,14 +101,15 @@ exports.FunctionValue = class FunctionValue
 exports.Case = class Case
   constructor: (@whens, @else) ->
   toString: ->
+    whensStr = @whens.map((w) -> w.toString()).join(' ')
     if @else
-      "CASE #{@whens.toString()} #{@else.toString} END"
+      "CASE #{whensStr} #{@else.toString()} END"
     else
-      "CASE #{@whens.toString()} END"
+      "CASE #{whensStr} END"
 
 exports.CaseWhen = class CaseWhen
   constructor: (@whenCondition, @resCondition) ->
-  toString: -> "WHEN #{@whenCondition} THEN @resCondition"
+  toString: -> "WHEN #{@whenCondition} THEN #{@resCondition}"
 
 exports.CaseElse = class CaseElse
   constructor: (@elseCondition) ->

test/grammar.spec.coffee

@@ -254,12 +254,15 @@ describe "SQL Grammar", ->
       """
 
     it "parses UNIONs", ->
-      parse("select * from a union select * from b").toString().should.eql """
+      parse("select * from a union select * from b union select * from c").toString().should.eql """
       SELECT *
         FROM `a`
       UNION
       SELECT *
         FROM `b`
+      UNION
+      SELECT *
+        FROM `c`
       """
 
     it "parses UNION ALL", ->
@@ -360,3 +363,10 @@ describe "SQL Grammar", ->
         WHERE (`bar` = $12)
       """
 
+  describe "Case When", ->
+    it "parses case when statements", ->
+      parse('select case when foo = \'a\' then a when foo = \'b\' then b else c end from table').toString().should.eql """
+      SELECT CASE WHEN (`foo` = 'a') THEN `a` WHEN (`foo` = 'b') THEN `b` ELSE `c` END
+        FROM `table`
+      """
+

test/lexer.spec.coffee

@@ -4,62 +4,87 @@ describe "SQL Lexer", ->
   it "eats select queries", ->
     tokens = lexer.tokenize("select * from my_table")
     tokens.should.eql [
-      ["SELECT", "select", 1]
-      ["STAR", "*", 1]
-      ["FROM", "from", 1]
-      ["LITERAL", "my_table", 1]
-      ["EOF", "", 1]
+      ["SELECT", "select", 1, 0]
+      ["STAR", "*", 1, 7]
+      ["FROM", "from", 1, 9]
+      ["LITERAL", "my_table", 1, 14]
+      ["EOF", "", 1, 22]
     ]
 
   it "eats select queries with stars and multiplication", ->
     tokens = lexer.tokenize("select * from my_table where foo = 1 * 2")
     tokens.should.eql [
-      ["SELECT", "select", 1]
-      ["STAR", "*", 1]
-      ["FROM", "from", 1]
-      ["LITERAL", "my_table", 1]
-      ["WHERE", "where", 1]
-      ["LITERAL", "foo", 1]
-      ["OPERATOR", "=", 1]
-      ["NUMBER", "1", 1]
-      ["MATH_MULTI", "*", 1]
-      ["NUMBER", "2", 1]
-      ["EOF", "", 1]
+      ["SELECT", "select", 1, 0]
+      ["STAR", "*", 1, 7]
+      ["FROM", "from", 1, 9]
+      ["LITERAL", "my_table", 1, 14]
+      ["WHERE", "where", 1, 23]
+      ["LITERAL", "foo", 1, 29]
+      ["OPERATOR", "=", 1, 33]
+      ["NUMBER", "1", 1, 35]
+      ["MATH_MULTI", "*", 1, 37]
+      ["NUMBER", "2", 1, 39]
+      ["EOF", "", 1, 40]
     ]
 
 
   it "eats sub selects", ->
     tokens = lexer.tokenize("select * from (select * from my_table) t")
     tokens.should.eql [
-      ["SELECT", "select", 1]
-      ["STAR", "*", 1]
-      ["FROM", "from", 1]
-      [ 'LEFT_PAREN', '(', 1 ]
-      [ 'SELECT', 'select', 1 ]
-      [ 'STAR', '*', 1 ]
-      [ 'FROM', 'from', 1 ]
-      [ 'LITERAL', 'my_table', 1 ]
-      [ 'RIGHT_PAREN', ')', 1 ]
-      ["LITERAL", "t", 1]
-      ["EOF", "", 1]
+      ["SELECT", "select", 1, 0]
+      ["STAR", "*", 1, 7]
+      ["FROM", "from", 1, 9]
+      [ 'LEFT_PAREN', '(', 1, 14]
+      [ 'SELECT', 'select', 1, 15]
+      [ 'STAR', '*', 1, 22]
+      [ 'FROM', 'from', 1, 24]
+      [ 'LITERAL', 'my_table', 1, 29]
+      [ 'RIGHT_PAREN', ')', 1, 37]
+      ["LITERAL", "t", 1, 39]
+      ["EOF", "", 1, 40]
     ]
 
   it "eats joins", ->
     tokens = lexer.tokenize("select * from a join b on a.id = b.id")
     tokens.should.eql [
-      ["SELECT", "select", 1]
-      ["STAR", "*", 1]
-      ["FROM", "from", 1]
-      [ 'LITERAL', 'a', 1 ]
-      [ 'JOIN', 'join', 1 ]
-      [ 'LITERAL', 'b', 1 ]
-      [ 'ON', 'on', 1 ]
-      [ 'LITERAL', 'a', 1 ]
-      [ 'DOT', '.', 1 ]
-      [ 'LITERAL', 'id', 1 ]
-      [ 'OPERATOR', '=', 1 ]
-      [ 'LITERAL', 'b', 1 ]
-      [ 'DOT', '.', 1 ]
-      [ 'LITERAL', 'id', 1 ]
-      ["EOF", "", 1]
+      ["SELECT", "select", 1, 0]
+      ["STAR", "*", 1, 7]
+      ["FROM", "from", 1, 9]
+      [ 'LITERAL', 'a', 1, 14]
+      [ 'JOIN', 'join', 1, 16]
+      [ 'LITERAL', 'b', 1, 21]
+      [ 'ON', 'on', 1, 23]
+      [ 'LITERAL', 'a', 1, 26]
+      [ 'DOT', '.', 1, 27]
+      [ 'LITERAL', 'id', 1, 28]
+      [ 'OPERATOR', '=', 1, 31]
+      [ 'LITERAL', 'b', 1, 33]
+      [ 'DOT', '.', 1, 34]
+      [ 'LITERAL', 'id', 1, 35]
+      ["EOF", "", 1, 37]
     ]
+
+  it "eats case when", ->
+    tokens = lexer.tokenize("select case when foo = 'a' then a when foo = 'b' then b else c end from table")
+    tokens.should.eql [
+      ['SELECT', 'select', 1, 0]
+      ['CASE', 'case', 1, 7]
+      ['WHEN', 'when', 1, 12]
+      ['LITERAL', 'foo', 1, 17]
+      ['OPERATOR', '=', 1, 21]
+      ['STRING', 'a', 1, 23]
+      ['THEN', 'then', 1, 27]
+      ['LITERAL', 'a', 1, 32]
+      ['WHEN', 'when', 1, 34]
+      ['LITERAL', 'foo', 1, 39]
+      ['OPERATOR', '=', 1, 43]
+      ['STRING', 'b', 1, 45]
+      ['THEN', 'then', 1, 49]
+      ['LITERAL', 'b', 1, 54]
+      ['ELSE', 'else', 1, 56]
+      ['LITERAL', 'c', 1, 61]
+      ['END', 'end', 1, 63]
+      ['FROM', "from", 1, 67]
+      ['LITERAL', 'table', 1, 72]
+      ['EOF', '', 1, 77]
+    ]