Merge pull request #302 from dice-roller/feature/301-Enable-rounding-to-zero

Feature/301 enable rounding to zero

Author: GreenImp

.github/workflows/build.yml

@@ -5,13 +5,16 @@ on:
       - main
       - develop
       - 'releases/**'
+      - 'next/**'
   pull_request:
     branches:
       - main
       - develop
       - 'releases/**'
+      - 'next/**'
 jobs:
   test:
+    name: 'Run tests'
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -34,7 +37,8 @@ jobs:
           github-token: ${{ secrets.github_token }}
           parallel: true
 
-  build-typescript:
+  build-definitions:
+    name: 'Check TS definitions are compiled'
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -48,10 +52,14 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Build Grammars
+        run: npm run build:grammars
+
       - name: Build Typescript
-        run: npm run build:declaration
+        run: npm run build:definitions
 
   build-api-docs:
+    name: "Check API docs are built"
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -69,6 +77,7 @@ jobs:
         run: npm run docs:build
 
   finish:
+    name: "Send Coverage"
     needs: test
     runs-on: ubuntu-latest
     steps:

src/parser/grammars/grammar.pegjs

@@ -7,12 +7,9 @@ Main = Expression
 
 // Expression / roll groups
 RollGroup
-  = "{" _ expr:Expression exprs:(_ "," _ Expression)* _ "}" modifiers:Modifier* descriptions:__ {
+  = "{" _ expressions:ExpressionCollection _ "}" modifiers:Modifier* descriptions:__ {
     return new RollGroup(
-      [
-        expr,
-        ...exprs.map(v => v[3])
-      ],
+      expressions,
       Object.assign({}, ...modifiers.map(item => {
         return {[item.name]: item};
       })),
@@ -170,6 +167,13 @@ Expression
     ]
   }
 
+ExpressionCollection = expr:Expression exprs:(_ "," _ Expression)* {
+  return [
+    expr,
+    ...exprs.map(v => v[3])
+  ];
+}
+
 Factor
   = MathFunction
   / Dice
@@ -194,6 +198,17 @@ MathFunction
       ')',
     ];
   }
+  / func:("fix" / "trunc" { return "fix" }) "(" _ expr1:Expression _ expr2:("," _ Expression _)? ")" {
+    return [
+      `${func}(`,
+      ...expr1,
+      ...(expr2 ? [
+        ',',
+        ...expr2[2],
+      ] : []),
+      ')',
+    ];
+  }
 
 FloatNumber
   = "-"? Number ([.] Number)? { return parseFloat(text()) }

tests/Feature/rolling.test.ts

@@ -113,6 +113,86 @@ describe('Rolling', () => {
       ]);
     });
 
+    test('roll `fix(4d10/3)', () => {
+      const rolls = new RollResults([2,3,6,2])
+      jest.spyOn(StandardDice.prototype, 'roll')
+        .mockImplementationOnce(() => rolls);
+      const roll = roller.roll('fix(4d10/3)') as DiceRoll;
+
+      expect(roll).toBeInstanceOf(DiceRoll);
+      expect(roll.notation).toEqual('fix(4d10/3)');
+      expect(roll.total).toBe(4);
+      expect(roll.output).toEqual('fix(4d10/3): fix([2, 3, 6, 2]/3) = 4');
+      expect(roll.rolls).toEqual([
+        'fix(',
+        rolls,
+        '/',
+        3,
+        ')',
+      ]);
+    });
+
+    test('roll `fix(4d10/3, 2)', () => {
+      const rolls = new RollResults([2,3,6,2])
+      jest.spyOn(StandardDice.prototype, 'roll')
+        .mockImplementationOnce(() => rolls);
+      const roll = roller.roll('fix(4d10/3, 2)') as DiceRoll;
+
+      expect(roll).toBeInstanceOf(DiceRoll);
+      expect(roll.notation).toEqual('fix(4d10/3, 2)');
+      expect(roll.total).toBe(4.33);
+      expect(roll.output).toEqual('fix(4d10/3, 2): fix([2, 3, 6, 2]/3,2) = 4.33');
+      expect(roll.rolls).toEqual([
+        'fix(',
+        rolls,
+        '/',
+        3,
+        ',',
+        2,
+        ')',
+      ]);
+    });
+
+    test('roll `trunc(4d10/3)', () => {
+      const rolls = new RollResults([2,3,6,2])
+      jest.spyOn(StandardDice.prototype, 'roll')
+        .mockImplementationOnce(() => rolls);
+      const roll = roller.roll('trunc(4d10/3)') as DiceRoll;
+
+      expect(roll).toBeInstanceOf(DiceRoll);
+      expect(roll.notation).toEqual('trunc(4d10/3)');
+      expect(roll.total).toBe(4);
+      expect(roll.output).toEqual('trunc(4d10/3): fix([2, 3, 6, 2]/3) = 4');
+      expect(roll.rolls).toEqual([
+        'fix(',
+        rolls,
+        '/',
+        3,
+        ')',
+      ]);
+    });
+
+    test('roll `trunc(4d10/3, 2)', () => {
+      const rolls = new RollResults([2,3,6,2])
+      jest.spyOn(StandardDice.prototype, 'roll')
+        .mockImplementationOnce(() => rolls);
+      const roll = roller.roll('trunc(4d10/3, 2)') as DiceRoll;
+
+      expect(roll).toBeInstanceOf(DiceRoll);
+      expect(roll.notation).toEqual('trunc(4d10/3, 2)');
+      expect(roll.total).toBe(4.33);
+      expect(roll.output).toEqual('trunc(4d10/3, 2): fix([2, 3, 6, 2]/3,2) = 4.33');
+      expect(roll.rolls).toEqual([
+        'fix(',
+        rolls,
+        '/',
+        3,
+        ',',
+        2,
+        ')',
+      ]);
+    });
+
     test('roll `3d6cs>3cf<3`', () => {
       jest.spyOn(StandardDice.prototype, 'rollOnce')
         .mockImplementationOnce(() => new RollResult(5))

tests/Unit/Parser/Parsing.test.ts

@@ -110,6 +110,47 @@ describe('Parsing', () => {
         }).toThrow(parser.PeggySyntaxError);
       });
     });
+
+    // Test the fix / trunc function
+    ['fix', 'trunc'].forEach((name) => {
+      test(`can parse \`${name}(2d10*3)\``, () => {
+        const parsed = Parser.parse(`${name}(2d10*3)`);
+
+        expect(parsed).toBeInstanceOf(Array);
+        expect(parsed).toHaveLength(5);
+
+        expect(parsed[0]).toEqual('fix(');
+
+        const result = parsed[1] as Dice;
+        expect(result).toBeInstanceOf(StandardDice);
+        expect(result.sides).toBe(10);
+        expect(result.qty).toBe(2);
+        expect(result.modifiers).toEqual(new Map());
+
+        expect(parsed[2]).toEqual('*');
+        expect(parsed[3]).toBe(3);
+        expect(parsed[4]).toEqual(')');
+      });
+
+      test(`can parse \`${name}(5d20, 2)\``, () => {
+        const parsed = Parser.parse(`${name}(5d20, 2)`);
+
+        expect(parsed).toBeInstanceOf(Array);
+        expect(parsed).toHaveLength(5);
+
+        expect(parsed[0]).toEqual('fix(');
+
+        const result = parsed[1] as Dice;
+        expect(result).toBeInstanceOf(StandardDice);
+        expect(result.sides).toBe(20);
+        expect(result.qty).toBe(5);
+        expect(result.modifiers).toEqual(new Map());
+
+        expect(parsed[2]).toEqual(',');
+        expect(parsed[3]).toBe(2);
+        expect(parsed[4]).toEqual(')');
+      });
+    });
   });
 
   describe('Multiple dice', () => {