Parse fields in SELECT

src/parser.rs

-use std::slice::Iter;
+use std::{iter::Peekable, slice::Iter};
 
 use crate::error::ParserError;
 use crate::token::{Token, TokenType};
 
 #[derive(Debug, PartialEq)]
 pub enum Field {
+    Named(String),
     Star,
 }
 
 }
 
 pub fn parse(tokens: Vec<Token>) -> Result<Select, ParserError> {
-    select_expression(&mut tokens.iter())
+    parse_select_expression(&mut tokens.iter().peekable())
 }
 
-fn select_expression(tokens: &mut Iter<Token>) -> Result<Select, ParserError> {
+fn parse_select_expression(tokens: &mut Peekable<Iter<Token>>) -> Result<Select, ParserError> {
     eat(tokens, TokenType::Select)?;
-    let fields = eat(tokens, TokenType::Star).and_then(|_| Ok(vec![Field::Star]))?;
+    let fields = parse_fields(tokens)?;
     eat(tokens, TokenType::From)?;
     let source = eat(tokens, TokenType::Identfiier).and_then(|t| Ok(Identifier::new(&t.value)))?;
 
     Ok(Select { fields, source })
 }
 
-fn eat<'a>(tokens: &'a mut Iter<Token>, token_type: TokenType) -> Result<&'a Token, ParserError> {
+fn parse_fields(tokens: &mut Peekable<Iter<Token>>) -> Result<Vec<Field>, ParserError> {
+    if current_token_is(tokens, TokenType::Star) {
+        eat(tokens, TokenType::Star).and_then(|_| Ok(vec![Field::Star]))
+    } else {
+        let mut fields: Vec<Field> = vec![];
+
+        loop {
+            let field = eat(tokens, TokenType::Identfiier)?;
+            fields.push(Field::Named(field.value.clone()));
+
+            if current_token_is(tokens, TokenType::Comma) {
+                eat(tokens, TokenType::Comma)?;
+            } else {
+                break;
+            }
+        }
+
+        Ok(fields)
+    }
+}
+
+fn current_token_is(tokens: &mut Peekable<Iter<Token>>, token_type: TokenType) -> bool {
+    match tokens.peek() {
+        Some(t) => t.token_type == token_type,
+        None => false,
+    }
+}
+
+fn eat<'a>(
+    tokens: &'a mut Peekable<Iter<Token>>,
+    token_type: TokenType,
+) -> Result<&'a Token, ParserError> {
     match tokens.next() {
         Some(token) => {
             if token.token_type == token_type {
             },
         )
     }
+
+    #[test]
+    fn it_parses_a_select_with_field() {
+        assert_eq!(
+            _parse("SELECT field FROM index").unwrap(),
+            Select {
+                fields: vec![Field::Named("field".to_string())],
+                source: Identifier::new("index")
+            },
+        )
+    }
+
+    #[test]
+    fn it_parses_a_select_with_multiple_fields() {
+        assert_eq!(
+            _parse("SELECT field_one, field_two FROM index").unwrap(),
+            Select {
+                fields: vec![
+                    Field::Named("field_one".to_string()),
+                    Field::Named("field_two".to_string())
+                ],
+                source: Identifier::new("index")
+            },
+        )
+    }
 }