Parse identifiers

src/ast.ts

@@ -1,2 +1,8 @@
+import { Identifier } from "./ast/identifier";
+import { Number as _Number } from "./ast/number";
+
+export * from "./ast/identifier";
 export * from "./ast/number";
 export * from "./ast/statement";
+
+export type Primary = _Number | Identifier;

src/ast/identifier.ts

@@ -0,0 +1,7 @@
+export class Identifier {
+  public value: string;
+
+  constructor(value: string) {
+    this.value = value;
+  }
+}

src/ast/statement.ts

@@ -6,12 +6,12 @@ export enum StatementType {
 
 export interface IStatementOptions {
   type: StatementType;
-  arguments: AST.Number[];
+  arguments: AST.Primary[];
 }
 
 export class Statement {
   public type: StatementType;
-  public arguments: AST.Number[];
+  public arguments: AST.Primary[];
 
   constructor(opts: IStatementOptions) {
     this.type = opts.type;

src/parser.ts

@@ -49,11 +49,11 @@ export default class Parser {
     });
   }
 
-  private args(): AST.Number[] | Error {
+  private args(): AST.Primary[] | Error {
     const args = [];
 
     while (true) {
-      const arg = this.number();
+      const arg = this.primary();
       if (isError(arg)) {
         return arg;
       }
@@ -69,6 +69,26 @@ export default class Parser {
     return args;
   }
 
+  private primary(): AST.Primary | Error {
+    const token = this.currentToken();
+    switch (token.kind) {
+      case TokenKind.NUMBER:
+        return this.number();
+      case TokenKind.IDENTIFIER:
+        return this.identifier();
+    }
+
+    return new Error(`Unexpected token ${token.kind} ${token.value}`, token.line);
+  }
+
+  private identifier(): AST.Identifier | Error {
+    const identifier = this.eat(TokenKind.IDENTIFIER);
+    if (isError(identifier)) {
+      return identifier;
+    }
+    return new AST.Identifier(identifier.value || "");
+  }
+
   private number(): AST.Number | Error {
     const n = this.eat(TokenKind.NUMBER);
     if (isError(n)) {

test/parser.test.ts

@@ -42,4 +42,30 @@ describe("Parser", () => {
       }),
     ]);
   });
+
+  it("should parse a selection of identifiers", () => {
+    const tree = parse("select a, b");
+    expect(tree).to.deep.equal([
+      new AST.Statement({
+        arguments: [
+          new AST.Identifier("a"),
+          new AST.Identifier("b"),
+        ],
+        type: AST.StatementType.SELECT,
+      }),
+    ]);
+  });
+
+  it("should parse a selection of identifiers and numbers", () => {
+    const tree = parse("select a, 5");
+    expect(tree).to.deep.equal([
+      new AST.Statement({
+        arguments: [
+          new AST.Identifier("a"),
+          new AST.Number(5),
+        ],
+        type: AST.StatementType.SELECT,
+      }),
+    ]);
+  });
 });