Add roller to generate roll results

Added classic and WoD roll function.
Added `Result` object to hold the roll results.
Added stringifier and normalizer functions for the roll result.
Renamed tests folder `/normalizers` to `normalizer`.

src/grammar.js

@@ -2,7 +2,7 @@
 // Each grammar is an array of RegExps
 module.exports = {
   simple: [
-    /^(\d+)(?:\s+(\d+)(?:\s+([+-]?\d+))?)?$/,             // 1 20 4 || 1 20 +4 5 || 1 20 -4 5 20
+    /^(\d+)(?:\s+(\d+)(?:\s+([+-]?\d+))?)?$/,        // 1 20 4 || 1 20 +4 5 || 1 20 -4 5 20
   ],
   classic: [
     /^(\d*)(?:[dD])(\d+)([+-]\d+)?$/,                // d20 || 1d20 || d20+4 || 1d20-4

src/normalizer.js

@@ -7,6 +7,8 @@ const fixInvalid = backup => value => ( isPositiveInteger( value ) ? value : bac
 // normalizeInteger :: Any -> Number
 const normalizeInteger = value => ( Number.isInteger( value ) ? value : 0 );
 
+// normalizeRollResult :: Any -> Number
+const normalizeRollResult = fixInvalid( 1 );
 
 // normalizeTop :: Number -> Number -> Number
 const normalizeTop = max => top => Math.min( fixInvalid( Number.MAX_SAFE_INTEGER )( top ), max );
@@ -36,6 +38,7 @@ module.exports = {
   isAbsent,
   fixInvalid,
   normalizeInteger,
+  normalizeRollResult,
   normalizeTop,
   normalizeBottom,
   normalizeWodBorders,

src/object/Result.js

@@ -0,0 +1,23 @@
+const { resultNotation } = require( '../stringifier' );
+/**
+ * A class that represents a dice roll result
+ * @class
+ * @classdesc A class that represents a dice roll result
+ * @since v2.0.0
+ * @param {String} notation - A roll notation
+ * @param {Number} value - A numeric representation of roll result, like total summ or success count
+ * @param {Array} rolls - An array of rolls dome
+ * @see Roll
+ * @see WodRoll
+ */
+function Result( notation, value, rolls ) {
+  this.notation = notation;
+  this.value = value;
+  this.rolls = rolls;
+}
+
+Result.prototype.toString = function toString() {
+  return resultNotation( this );
+};
+
+module.exports = Result;

src/roller.js

@@ -0,0 +1,44 @@
+const { randomRoll } = require( './random' );
+const { normalizeRollResult } = require( './normalizer' );
+const Result = require( './object/Result' );
+
+function rollClassic( roll ) {
+  const { dice, count, modifier } = roll;
+
+  const rolls = new Array( count ).fill( randomRoll( dice ));
+  const summ = rolls.reduce(( prev, curr ) => prev + curr, 0 );
+  const result = normalizeRollResult( summ + modifier );
+
+  return new Result( roll.toString(), result, rolls );
+}
+
+function rollWod( roll ) {
+  const { dice, count, again, success, fail } = roll;
+
+  const rolls = [];
+
+  let i = count;
+  while ( i > 0 ) {
+    const value = randomRoll( dice );
+    rolls.push( value );
+    if ( value !== dice || !again ) {
+      i -= 1;
+    }
+  }
+
+  const result = rolls.reduce(( suc, val ) => {
+    if ( val >= success ) {
+      return suc + 1;
+    } else if ( val <= fail ) {
+      return suc - 1;
+    }
+    return val;
+  }, 0 );
+
+  return new Result( roll.toString(), result, rolls );
+}
+
+module.exports = {
+  rollClassic,
+  rollWod,
+};

src/stringifier.js

@@ -36,8 +36,14 @@ function wodNotation( roll ) {
   return `${ count }d${ roll.dice }${ again }>${ roll.success }f${ roll.fail }`;
 }
 
+function resultNotation( result ) {
+  const { notation, value, rolls } = result;
+  return `(${ notation }) ${ value } [${ rolls }]`;
+}
+
 module.exports = {
   simpleNotation,
   classicNotation,
   wodNotation,
+  resultNotation,
 };

test/object/result/result.generation.spec.js

@@ -0,0 +1,8 @@
+const Result = require( '../../../src/object/Result' );
+
+describe( 'Result generation:', () => {
+  test( 'Should generate valid result.', () => {
+    const result = { notation: '4d10+1', value: 21, rolls: [ 10, 2, 7, 1 ] };
+    expect( new Result( '4d10+1', 21, [ 10, 2, 7, 1 ])).toEqual( result );
+  });
+});

test/object/result/result.toString.spec.js

@@ -0,0 +1,7 @@
+const Result = require( '../../../src/object/Result' );
+
+describe( 'Result.toString:', () => {
+  test( 'Should generate notation `(4d10+1) 21 [10,2,7,1]`.', () => {
+    expect( new Result( '4d10+1', 21, [ 10, 2, 7, 1 ]).toString()).toEqual( '(4d10+1) 21 [10,2,7,1]' );
+  });
+});

test/stringifier/stringifier.result.spec.js

@@ -0,0 +1,5 @@
+const { testResultNotation } = require( '../util' );
+
+describe( 'Roll result notation:', () => {
+  testResultNotation( '(4d10+1) 21 [10,2,7,1]', '4d10+1', 21, [ 10, 2, 7, 1 ]);
+});

test/util.js

@@ -1,6 +1,7 @@
 const Roll = require( '../src/object/Roll' );
 const WodRoll = require( '../src/object/WodRoll' );
-const { simpleNotation, classicNotation, wodNotation } = require( '../src/stringifier' );
+const Result = require( '../src/object/Result' );
+const { simpleNotation, classicNotation, wodNotation, resultNotation } = require( '../src/stringifier' );
 
 const validRoll = regexp => ( roll ) => {
   test( `Should parse '${ roll }' roll.`, () => {
@@ -44,6 +45,12 @@ function testWodNotation( notation, ...args ) {
   });
 }
 
+function testResultNotation( notation, ...args ) {
+  test( `Should generate '${ notation }' from parameters '${ stringifyArgs( args ) }'.`, () => {
+    expect( resultNotation( new Result( ...args ))).toBe( notation );
+  });
+}
+
 const validRollParse = parser => ( roll ) => {
   test( `Should parse '${ roll }' roll.`, () => {
     expect( parser( roll )).toBeTruthy();
@@ -73,6 +80,7 @@ module.exports = {
   testSimpleNotation,
   testClassicNotation,
   testWodNotation,
+  testResultNotation,
   validRollParse,
   invalidRollParse,
   testParse,