DRY up comma separated list parsing.

Author: wvanbergen

lib/sql_tree/node.rb

@@ -81,6 +81,15 @@ def equal_leafs?(other)
     def self.parse(tokens)
       raise 'Only implemented in subclasses!'
     end
+    
+    def self.parse_list(tokens, item_class = SQLTree::Node::Expression)
+      items = [item_class.parse(tokens)]
+      while SQLTree::Token::COMMA === tokens.peek
+        tokens.consume(SQLTree::Token::COMMA)
+        items << item_class.parse(tokens)
+      end
+      return items
+    end
 
     # Parses a string, expecting it to be parsable to an instance of
     # the current class.

lib/sql_tree/node/expression.rb

@@ -295,14 +295,9 @@ def self.parse(tokens)
         tokens.consume(SQLTree::Token::LPAREN)
         items = []
         unless SQLTree::Token::RPAREN === tokens.peek
-          items << SQLTree::Node::Expression.parse(tokens)
-          while SQLTree::Token::COMMA === tokens.peek
-            tokens.consume(SQLTree::Token::COMMA)
-            items << SQLTree::Node::Expression.parse(tokens)
-          end
+          items = self.parse_list(tokens, SQLTree::Node::Expression)
         end
         tokens.consume(SQLTree::Token::RPAREN)
-
         self.new(items)
       end
     end
@@ -315,11 +310,11 @@ class FunctionCall  < SQLTree::Node::Expression
       leaf :function
 
       # The argument list as {SQLTree::Node::Expression::List} instance.
-      child :argument_list
+      child :arguments
 
       # Generates an SQL fragment for this function call.
       def to_sql(options = {})
-        "#{function}(" + argument_list.items.map { |e| e.to_sql(options) }.join(', ') + ")"
+        "#{function}(" + arguments.map { |e| e.to_sql(options) }.join(', ') + ")"
       end
 
       # Parses an SQL function call.
@@ -331,8 +326,11 @@ def to_sql(options = {})
       # @raise [SQLTree::Parser::UnexpectedToken] if an unexpected token is
       # encountered during parsing.      
       def self.parse(tokens)
-        return self.new(:function => tokens.next.literal, 
-            :argument_list => SQLTree::Node::Expression::List.parse(tokens))
+        function_call = self.new(:function => tokens.next.literal, :arguments => [])
+        tokens.consume(SQLTree::Token::LPAREN)
+        function_call.arguments = self.parse_list(tokens) unless SQLTree::Token::RPAREN === tokens.peek
+        tokens.consume(SQLTree::Token::RPAREN)
+        return function_call
       end
     end
 

lib/sql_tree/node/insert_query.rb

@@ -21,23 +21,15 @@ def to_sql(options = {})
 
     def self.parse_field_list(tokens)
       tokens.consume(SQLTree::Token::LPAREN)
-      fields = [SQLTree::Node::Expression::Field.parse(tokens)]
-      while SQLTree::Token::COMMA === tokens.peek
-        tokens.consume(SQLTree::Token::COMMA)
-        fields << SQLTree::Node::Expression::Field.parse(tokens)
-      end
+      fields = parse_list(tokens, SQLTree::Node::Expression::Field)
       tokens.consume(SQLTree::Token::RPAREN)
       return fields
     end
 
     def self.parse_value_list(tokens)
       tokens.consume(SQLTree::Token::VALUES)
       tokens.consume(SQLTree::Token::LPAREN)
-      values = [SQLTree::Node::Expression.parse(tokens)]
-      while SQLTree::Token::COMMA === tokens.peek
-        tokens.consume(SQLTree::Token::COMMA)
-        values << SQLTree::Node::Expression.parse(tokens)
-      end
+      values = parse_list(tokens)
       tokens.consume(SQLTree::Token::RPAREN)
       return values
     end

lib/sql_tree/node/select_query.rb

@@ -38,7 +38,7 @@ def self.parse(tokens)
         select_node.distinct = true
       end
 
-      select_node.select   = self.parse_select_clause(tokens)
+      select_node.select   = parse_list(tokens, SQLTree::Node::SelectDeclaration)
       select_node.from     = self.parse_from_clause(tokens)   if SQLTree::Token::FROM === tokens.peek
       select_node.where    = self.parse_where_clause(tokens)  if SQLTree::Token::WHERE === tokens.peek
       if SQLTree::Token::GROUP === tokens.peek
@@ -49,23 +49,9 @@ def self.parse(tokens)
       return select_node
     end
 
-    def self.parse_select_clause(tokens)
-      expressions = [SQLTree::Node::SelectDeclaration.parse(tokens)]
-      while SQLTree::Token::COMMA === tokens.peek
-        tokens.consume(SQLTree::Token::COMMA)
-        expressions << SQLTree::Node::SelectDeclaration.parse(tokens)
-      end
-      return expressions
-    end
-
     def self.parse_from_clause(tokens)
       tokens.consume(SQLTree::Token::FROM)
-      sources = [SQLTree::Node::Source.parse(tokens)]
-      while SQLTree::Token::COMMA === tokens.peek
-        tokens.consume(SQLTree::Token::COMMA)
-        sources << SQLTree::Node::Source.parse(tokens)
-      end
-      return sources
+      parse_list(tokens, SQLTree::Node::Source)
     end
 
     def self.parse_where_clause(tokens)
@@ -74,14 +60,8 @@ def self.parse_where_clause(tokens)
     end
 
     def self.parse_group_clause(tokens)
-      tokens.consume(SQLTree::Token::GROUP)
-      tokens.consume(SQLTree::Token::BY)
-      exprs = [SQLTree::Node::Expression.parse(tokens)]
-      while SQLTree::Token::COMMA === tokens.peek
-        tokens.consume(SQLTree::Token::COMMA)
-        exprs << SQLTree::Node::Expression.parse(tokens)
-      end
-      return exprs
+      tokens.consume(SQLTree::Token::GROUP, SQLTree::Token::BY)
+      parse_list(tokens)
     end
 
     def self.parse_having_clause(tokens)
@@ -90,14 +70,8 @@ def self.parse_having_clause(tokens)
     end
 
     def self.parse_order_clause(tokens)
-      tokens.consume(SQLTree::Token::ORDER)
-      tokens.consume(SQLTree::Token::BY)
-      exprs = [SQLTree::Node::Ordering.parse(tokens)]
-      while SQLTree::Token::COMMA === tokens.peek
-        tokens.consume(SQLTree::Token::COMMA)
-        exprs << SQLTree::Node::Ordering.parse(tokens)
-      end
-      return exprs
+      tokens.consume(SQLTree::Token::ORDER, SQLTree::Token::BY)
+      parse_list(tokens, SQLTree::Node::Ordering)
     end
 
     def self.parse_limit_clause(tokens)

lib/sql_tree/node/update_query.rb

@@ -43,11 +43,7 @@ def self.parse(tokens)
       tokens.consume(SQLTree::Token::UPDATE)
       update_query = self.new(SQLTree::Node::TableReference.parse(tokens))
       tokens.consume(SQLTree::Token::SET)
-      update_query.updates = [SQLTree::Node::UpdateQuery::Assignment.parse(tokens)]
-      while SQLTree::Token::COMMA === tokens.peek
-        tokens.consume(SQLTree::Token::COMMA)
-        update_query.updates << SQLTree::Node::UpdateQuery::Assignment.parse(tokens)
-      end
+      update_query.updates = parse_list(tokens, SQLTree::Node::UpdateQuery::Assignment)
 
       if SQLTree::Token::WHERE === tokens.peek
         tokens.consume(SQLTree::Token::WHERE)

spec/unit/expression_node_spec.rb

@@ -10,13 +10,13 @@
     it "shoud parse a function call without arguments correctly" do
       function = SQLTree::Node::Expression['NOW()']
       function.function.should == 'NOW'
-      function.argument_list.should be_empty
+      function.arguments.should be_empty
     end
 
     it "shoud parse a function call with arguments correctly" do
       function = SQLTree::Node::Expression["MD5('string')"]
       function.function.should == 'MD5'
-      function.argument_list.items.should == [SQLTree::Node::Expression::Value.new('string')]
+      function.arguments.should == [SQLTree::Node::Expression::Value.new('string')]
     end
 
     it "should parse a logical OR expression correctly" do