Allowed dice rolls without roll times (eg: d6) (#17)

Author: adrianocola

spec/parser/dice-parser.parseDice.spec.ts

@@ -6,6 +6,39 @@ import { MockLexer } from '../helpers';
 
 describe('DiceParser', () => {
   describe('parseDice', () => {
+    it('can correctly parse a simple dice roll without roll times.', () => {
+      const lexer = new MockLexer([
+          new Token(TokenType.Identifier, 0, 'd'),
+          new Token(TokenType.Number, 1, '6')
+      ]);
+      const parser = new Parser.DiceParser(lexer);
+      const result = new ParseResult();
+      const dice = parser.parseDice(result);
+      expect(result.errors.length).toBe(0);
+
+      expect(dice.type).toBe(NodeType.Dice);
+      expect(dice.getChildCount()).toBe(2);
+      expect(dice.getChild(0).type).toBe(NodeType.Number);
+      expect(dice.getChild(0).getAttribute('value')).toBe(1);
+      expect(dice.getChild(1).type).toBe(NodeType.DiceSides);
+      expect(dice.getChild(1).getAttribute('value')).toBe(6);
+    });
+    it('can correctly parse a simple fate dice roll without roll times.', () => {
+      const lexer = new MockLexer([
+          new Token(TokenType.Identifier, 0, 'dF'),
+      ]);
+      const parser = new Parser.DiceParser(lexer);
+      const result = new ParseResult();
+      const dice = parser.parseDice(result);
+      expect(result.errors.length).toBe(0);
+
+      expect(dice.type).toBe(NodeType.Dice);
+      expect(dice.getChildCount()).toBe(2);
+      expect(dice.getChild(0).type).toBe(NodeType.Number);
+      expect(dice.getChild(0).getAttribute('value')).toBe(1);
+      expect(dice.getChild(1).type).toBe(NodeType.DiceSides);
+      expect(dice.getChild(1).getAttribute('value')).toBe('fate');
+    });
     it('can correctly parse a simple dice roll with pre-parsed number.', () => {
       const lexer = new MockLexer([
         new Token(TokenType.Number, 0, '10'),

spec/parser/dice-parser.parseDiceRoll.spec.ts

@@ -40,6 +40,22 @@ describe('DiceParser', () => {
       expect(dice.getChild(1).type).toBe(NodeType.DiceSides);
       expect(dice.getChild(1).getAttribute('value')).toBe(6);
     });
+    it('can correctly parse a simple dice roll without roll times.', () => {
+      const lexer = new MockLexer([
+          new Token(TokenType.Identifier, 0, 'd'),
+          new Token(TokenType.Number, 1, '6')
+      ]);
+      const parser = new Parser.DiceParser(lexer);
+      const result = new Parser.ParseResult();
+      const dice = parser.parseDiceRoll(result);
+      expect(result.errors.length).toBe(0);
+      expect(dice.type).toBe(NodeType.Dice);
+      expect(dice.getChildCount()).toBe(2);
+      expect(dice.getChild(0).type).toBe(NodeType.Number);
+      expect(dice.getChild(0).getAttribute('value')).toBe(1);
+      expect(dice.getChild(1).type).toBe(NodeType.DiceSides);
+      expect(dice.getChild(1).getAttribute('value')).toBe(6);
+    });
     it('can correctly parse a simple fate dice roll', () => {
       const lexer = new MockLexer([
         new Token(TokenType.Number, 0, '10'),
@@ -56,6 +72,21 @@ describe('DiceParser', () => {
       expect(dice.getChild(1).type).toBe(NodeType.DiceSides);
       expect(dice.getChild(1).getAttribute('value')).toBe('fate');
     });
+    it('can correctly parse a simple fate dice roll without roll times', () => {
+      const lexer = new MockLexer([
+          new Token(TokenType.Identifier, 0, 'dF')
+      ]);
+      const parser = new Parser.DiceParser(lexer);
+      const result = new Parser.ParseResult();
+      const dice = parser.parseDiceRoll(result);
+      expect(result.errors.length).toBe(0);
+      expect(dice.type).toBe(NodeType.Dice);
+      expect(dice.getChildCount()).toBe(2);
+      expect(dice.getChild(0).type).toBe(NodeType.Number);
+      expect(dice.getChild(0).getAttribute('value')).toBe(1);
+      expect(dice.getChild(1).type).toBe(NodeType.DiceSides);
+      expect(dice.getChild(1).getAttribute('value')).toBe('fate');
+    });
     it('can correctly parse a dice roll with a bracketed number', () => {
       const lexer = new MockLexer([
         new Token(TokenType.ParenthesisOpen, 0, '('),
@@ -100,17 +131,6 @@ describe('DiceParser', () => {
       expect(dice.getChild(1).type).toBe(NodeType.DiceSides);
       expect(dice.getChild(1).getAttribute('value')).toBe(6);
     });
-    it('throws on missing roll times', () => {
-      const lexer = new MockLexer([
-        new Token(TokenType.Identifier, 0, 'd'),
-        new Token(TokenType.Number, 1, '10')
-      ]);
-      const parser = new Parser.DiceParser(lexer);
-
-      const result = new Parser.ParseResult();
-      const dice = parser.parseDiceRoll(result);
-      expect(result.errors.length).toBeGreaterThanOrEqual(1);
-    });
     it('throws on missing dice value', () => {
       const lexer = new MockLexer([
         new Token(TokenType.Number, 0, '6'),

src/parser/dice-parser.class.ts

@@ -96,7 +96,11 @@ export class DiceParser extends BasicParser {
     const token = this.lexer.peekNextToken();
     switch (token.type) {
       case TokenType.Identifier:
-        root = this.parseFunction(result);
+        if (token.value === 'd' || token.value === 'dF') {
+          root = this.parseDice(result);
+        } else {
+          root = this.parseFunction(result);
+        }
         break;
       case TokenType.ParenthesisOpen:
         root = this.parseBracketedExpression(result);
@@ -125,6 +129,7 @@ export class DiceParser extends BasicParser {
     switch (token.type) {
       case TokenType.Number: return this.parseNumber(result);
       case TokenType.ParenthesisOpen: return this.parseBracketedExpression(result);
+      case TokenType.Identifier: return Ast.Factory.create(Ast.NodeType.Number).setAttribute('value', Number(1));
       default: this.errorToken(result, TokenType.Number, token);
     }
   }