Start parsing

src/ast.ts

@@ -0,0 +1,2 @@
+export * from "./ast/number";
+export * from "./ast/statement";

src/ast/number.ts

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

src/ast/statement.ts

@@ -0,0 +1,20 @@
+import * as AST from "../ast";
+
+export enum StatementType {
+  SELECT = "SELECT",
+}
+
+export interface IStatementOptions {
+  type: StatementType;
+  arguments: AST.Number[];
+}
+
+export class Statement {
+  public type: StatementType;
+  public arguments: AST.Number[];
+
+  constructor(opts: IStatementOptions) {
+    this.type = opts.type;
+    this.arguments = opts.arguments;
+  }
+}

src/parser.ts

@@ -0,0 +1,101 @@
+import * as AST from "./ast";
+import Error, { isError } from "./error";
+import Token, { TokenKind } from "./token";
+
+export default class Parser {
+  public tokens: Token[];
+  public position: number;
+
+  constructor(tokens: Token[]) {
+    this.tokens = tokens;
+    this.position = 0;
+  }
+
+  public parse(): AST.Statement[] | Error {
+    const tree: AST.Statement[] = [];
+
+    while (!this.atEnd()) {
+      const stmt = this.statement();
+      if (isError(stmt)) {
+        return stmt;
+      } else {
+        tree.push(stmt);
+      }
+    }
+
+    return tree;
+  }
+
+  private statement(): AST.Statement | Error {
+    const token = this.currentToken();
+
+    switch (token.kind) {
+      case TokenKind.SELECT:
+        return this.select();
+    }
+
+    return new Error(`Unexpected token ${token.kind}`, token.line);
+  }
+
+  private select(): AST.Statement | Error {
+    this.eat(TokenKind.SELECT);
+    const args = this.args();
+    if (isError(args)) {
+      return args;
+    }
+    return new AST.Statement({
+      arguments: args,
+      type: AST.StatementType.SELECT,
+    });
+  }
+
+  private args(): AST.Number[] | Error {
+    const args = [];
+
+    while (true) {
+      const arg = this.number();
+      if (isError(arg)) {
+        return arg;
+      }
+      args.push(arg);
+
+      if (this.currentToken().kind === TokenKind.COMMA) {
+        this.eat(TokenKind.COMMA);
+      } else {
+        break;
+      }
+    }
+
+    return args;
+  }
+
+  private number(): AST.Number | Error {
+    const n = this.eat(TokenKind.NUMBER);
+    if (isError(n)) {
+      return n;
+    }
+    return new AST.Number(parseFloat(n.value || ""));
+  }
+
+  private eat(kind: TokenKind) {
+    const token = this.currentToken();
+    if (token.kind === kind) {
+      this.advance();
+      return token;
+    }
+
+    return new Error(`Unexpected token ${token}`, token.line);
+  }
+
+  private currentToken(): Token {
+    return this.tokens[this.position];
+  }
+
+  private advance() {
+    this.position += 1;
+  }
+
+  private atEnd(): boolean {
+    return this.currentToken().kind === TokenKind.EOF;
+  }
+}

test/parser.test.ts

@@ -0,0 +1,45 @@
+/* tslint:disable:no-unused-expression */
+import { expect } from "chai";
+
+import * as AST from "../src/ast";
+import { isError } from "../src/error";
+import Lexer from "../src/lexer";
+import Parser from "../src/parser";
+
+const parse = (source: string): AST.Statement[] => {
+  const tokens = new Lexer(source).scan();
+  if (isError(tokens)) {
+    throw tokens.message;
+  } else {
+    const tree = new Parser(tokens).parse();
+    if (isError(tree)) {
+      throw tree.message;
+    }
+    return tree;
+  }
+};
+
+describe("Parser", () => {
+  it("should parse a number selection", () => {
+    const tree = parse("select 5");
+    expect(tree).to.deep.equal([
+      new AST.Statement({
+        arguments: [new AST.Number(5)],
+        type: AST.StatementType.SELECT,
+      }),
+    ]);
+  });
+
+  it("should parse a multiple number selection", () => {
+    const tree = parse("select 5, 6");
+    expect(tree).to.deep.equal([
+      new AST.Statement({
+        arguments: [
+          new AST.Number(5),
+          new AST.Number(6),
+        ],
+        type: AST.StatementType.SELECT,
+      }),
+    ]);
+  });
+});